No OneTemporary
Actions

Size

6 MB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

This document is not UTF8. It was detected as ISO-8859-1 (Latin 1) and converted to UTF8 for display.

	diff --git a/.hgignore b/.hgignore
	--- a/.hgignore
	+++ b/.hgignore
	@@ -1,70 +1,72 @@
	~$
	^run.*$
	\.orig$
	\.(o\|Po\|lo\|Plo\|la\|a\|so\|dylib\|pyc\|tar\.bz2\|tar\.gz\|fifo\|hepmc)$
	^config\.guess$
	^config\.status$
	^config\.sub$
	^config\.log$
	^configure$
	^depcomp$
	^compile$
	^ar-lib$
	^install-sh$
	^INSTALL$
	^libtool$
	^test-driver$
	^ltmain\.sh$
	^m4/ltoptions\.m4$
	^m4/ltsugar\.m4$
	^m4/ltversion\.m4$
	^m4/lt~obsolete\.m4$
	^missing$
	^autom4te\.cache$
	^include/Rivet/Config/stamp-h.$
	^tmp$
	^rivet.pc$
	Makefile$
	Makefile\.in$
	\.(pdf\|toc\|bbl\|blg\|sty\|bib\|html\|tex)$
	Doxyfile$
	\.libs$
	\.deps$
	#Rivet.yoda
	#.*/Rivet\.yoda
	^bin/rivet-buildplugin$
	^bin/rivet-config$
	^bin/rivet-nopy$
	^aclocal\.m4$
	^pyext/build$
	^pyext/rivet/core.cpp$
	^pyext/rivet/rivetwrap\.py$
	^pyext/rivet/rivetwrap_wrap\.cc$
	^pyext/rivet/fix-out-of-source$
	^pyext/setup\.py$
	^rivetenv\.(sh\|csh)$
	^test/test(Api\|Cmp\|NaN)$
	^include/Rivet/Config/DummyConfig\.hh\.in$
	^include/Rivet/Config/BuildOptions\.hh$
	^include/Rivet/Config/DummyConfig\.hh$
	^include/Rivet/Config/RivetConfig\.hh$
	^doc/.*\.(log\|aux\|out)$
	^doc/diffanas$
	^test/log$
	^test/.*\.log$
	^test/out\.yoda$
	^test/NaN.aida$
	^test/Rivet.yoda$
	^test/testBoost$
	^test/.*\.trs$
	^test/testMatVec$
	^test/testMath$
	+^test/testBeams$
	^dev$
	^devval$
	^newanalyses$
	^.*plots$
	^a\.out$
	^a\.out\.dSYM$
	^Rivet-.\..\..$
	^local/.*$
	^(for\|analyses)\d\d\d$
	+^src/Analyses/.*__all\.cc$
	diff --git a/.hgtags b/.hgtags
	--- a/.hgtags
	+++ b/.hgtags
	@@ -1,62 +1,73 @@
	041cc049512ed9767d0d7c7344f407b0deeaec48 rivet-1.0
	04c9104bf67af2da8be8233e6eb74e10e72a619a rivet-1.1.0
	1bd1ee1b351d0ed85484dd0940e9c914c4b52a92 rivet-1.8.0
	49417ad8f75595e5661093ce29ef6bc4c33c28ae rivet-1.1.1
	4c7765c4ae989d6ffc44eaacac042d5e288fdb28 rivet-1.2.0a0
	67fd1c15dd92810c0dd09a694e8d17fd4b08ffcf rivet-0.9
	68c1d049c8bca48506145cc5fd8349de637ced77 rivet-1.8.2
	70bc4e373609b4be88f0966d7adef6556badadc6 rivet-1.2.0
	85f9fb654f4c6ae445688a65472f305d4a4d615a rivet-1.2.0rc1
	879cbee6e5bfac7a6c218c95a5e853187fd9117b rivet-0.9b1
	886bd3d6ec6b598c602093905493925b55e7eee9 rivet-1.8.1
	88f72c595dbb82679cc44370b75b1802a529b45e rivet-1.1.2
	8919564de90c325a72cd20a3711319fd96cb8d86 rivet-1.5.1
	8dfaacabef9d08b8395f3da982bd83bd2e3f681e rivet-1.6.0
	92ea72f0626e6113c17df3965f5faf25408a62f7 rivet-1.2.1
	a3846123635d334e30312b0df5b35b3349d0c960 rivet-1.1.3
	ac2363d7b563b8498ac0c34954d227433e0aa394 rivet-1.7.0
	b6c491e282cc50598e3d6e76dedeb67542827445 rivet-1.4.0
	cd1be037b3ec1e8562180430b4d1b5546147eb5e rivet-1.8.3
	d1ceb2511be7d0589fc97c466e13b77f8ecc9365 rivet-1.0b2
	ddd059260df5a43048f0ac86b9adfdc6407e5c17 rivet-2.0.0b1
	ec4759fe22d2e811d9e471b39f0e6a5d20362e23 rivet-1.2.1.1
	ec4759fe22d2e811d9e471b39f0e6a5d20362e23 rivet-1.2.2a0
	f18173885a8f037676421516beb2e5a10b27c867 rivet-1.5.0
	fe4cd71dee85bacc537c0b4c11574b61c819940e rivet-1.3.0
	114301d50bf5a1993dd2cde22a410710cf619016 rivet-2.0.0b2
	a01c3ec46a56c6ab8eecf24c410a7a296dc6f721 rivet-2.0.0b3
	746bd5fac0b6a6d25358fad141055e98dbffdeb0 rivet-2.0.0
	ec4759fe22d2e811d9e471b39f0e6a5d20362e23 rivet-1.2.2a0
	0000000000000000000000000000000000000000 rivet-1.2.2a0
	a01c3ec46a56c6ab8eecf24c410a7a296dc6f721 rivet-2.0.0b3
	0000000000000000000000000000000000000000 rivet-2.0.0b3
	114301d50bf5a1993dd2cde22a410710cf619016 rivet-2.0.0b2
	0000000000000000000000000000000000000000 rivet-2.0.0b2
	ddd059260df5a43048f0ac86b9adfdc6407e5c17 rivet-2.0.0b1
	0000000000000000000000000000000000000000 rivet-2.0.0b1
	ec4759fe22d2e811d9e471b39f0e6a5d20362e23 rivet-1.2.1.1
	0000000000000000000000000000000000000000 rivet-1.2.1.1
	85f9fb654f4c6ae445688a65472f305d4a4d615a rivet-1.2.0rc1
	0000000000000000000000000000000000000000 rivet-1.2.0rc1
	4c7765c4ae989d6ffc44eaacac042d5e288fdb28 rivet-1.2.0a0
	0000000000000000000000000000000000000000 rivet-1.2.0a0
	d1ceb2511be7d0589fc97c466e13b77f8ecc9365 rivet-1.0b2
	0000000000000000000000000000000000000000 rivet-1.0b2
	879cbee6e5bfac7a6c218c95a5e853187fd9117b rivet-0.9b1
	0000000000000000000000000000000000000000 rivet-0.9b1
	5fc2379981180bb3985e6c7edf7ddb5bc906df21 rivet-2.1.0
	7452e4ce7d772698dd840a31d2f39467ad529211 rivet-2.1.1
	6b735bb5801b935c3eefa03d651e328a967c2e5f rivet-2.1.2
	974b3c3e84ea2f09cd39750a2facfd7e9726209b rivet-2.2.0beta1
	96aa6bd1c36a0891fb6a620919920090505466ef rivet-2.2.0
	974b3c3e84ea2f09cd39750a2facfd7e9726209b rivet-2.2.0beta1
	0000000000000000000000000000000000000000 rivet-2.2.0beta1
	805d410d6fadd4efb8d0e6bdf5a930ec0fc1e848 rivet-2.2.1
	-bd82c99d2b3f089c22df6beb7fd038b7762e2a05 rivet-2.3.0
	-bd82c99d2b3f089c22df6beb7fd038b7762e2a05 rivet-2.3.0
	-0000000000000000000000000000000000000000 rivet-2.3.0
	-0000000000000000000000000000000000000000 rivet-2.3.0
	086c7cd50a1906839b8440845077a39a0279ebb0 rivet-2.3.0
	c77ff1b297a71e9ec14440cd2e549fb1c4924148 rivet-2.4.0
	6bec638a1eb96ff0b1e18b4f6d62ef96bff40888 rivet-2.4.1
	-66e20000b87f2cbd6a5a6e42d3da6a711484ee6c rivet-2.5.0b1
	+c91d27b41c5a7084f79ede52ae03588a72529c4b rivet-2.4.2
	+28324a9ab8e39c73376934594e08f872bc442a76 rivet-2.4.3
	+af77fa6d1c6408c7d8d70ff681996ee614cc6117 rivet-2.5.0beta1
	+e46470f99190ee58a8f5cbc4c9788867e6b06d30 rivet-2.5.0beta2
	+6342afb6b879ed61b8988c4521480a9f8406e1aa rivet-2.5.0
	+af77fa6d1c6408c7d8d70ff681996ee614cc6117 rivet-2.5.0beta1
	+0000000000000000000000000000000000000000 rivet-2.5.0beta1
	+e46470f99190ee58a8f5cbc4c9788867e6b06d30 rivet-2.5.0beta2
	+0000000000000000000000000000000000000000 rivet-2.5.0beta2
	+afdfca08d4df8a7a80ef980f4fd9324fa6a0263f rivet-2.5.1
	+7ff482331c2ee005b60d6e4e9bb88dd523de3dc4 rivet-2.5.2
	+7ff482331c2ee005b60d6e4e9bb88dd523de3dc4 rivet-2.5.2
	+0000000000000000000000000000000000000000 rivet-2.5.2
	+0000000000000000000000000000000000000000 rivet-2.5.2
	+8a05acecd26c18f368f4b748da2d5aa2db46be6c rivet-2.5.2
	+ad44338e2fa10dd81e2b306545b801ce53f31921 rivet-2.5.3
	diff --git a/ChangeLog b/ChangeLog
	--- a/ChangeLog
	+++ b/ChangeLog
	@@ -1,5225 +1,5874 @@
	+2017-01-21 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Removing lots of long-deprecated functions & methods.
	+
	+2017-01-18 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Use std::function in functor-expanded method signatures on JetAlg.
	+
	+2017-01-16 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Convert FinalState particles() accessors to use std::function
	+ rather than a template arg for sorting, and add filtering functor
	+ support -- including a mix of filtering and sorting functors. Yay
	+ for C++11!
	+
	+ * Add ParticleEffFilter and JetEffFilter constructors from a double (encoding constant efficiency).
	+
	+ * Add Vector3::abseta()
	+
	+2016-12-13 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Version 2.5.3 release.
	+
	+2016-12-12 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add cut in BZ calculation in OPAL 4 jet analysis. Paper is not clear
	+ about treatment of parallel vectors, leads to division by zero and
	+ nan-fill and subsequent YODA RangeError (OPAL_2001_S4553896)
	+
	+2016-12-12 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Fix bugs in SmearedJets treatment of b & c tagging rates.
	+
	+ * Adding ATLAS_2016_I1467454 analysis (high-mass Drell-Yan at 8 TeV)
	+
	+ * Tweak to 'convert' call to improve the thumbnail quality from rivet-mkhtml/make-plots.
	+
	+2016-12-07 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Require Cython 0.24 or later.
	+
	+2016-12-02 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Adding L3_2004_I652683 (LEP 1 & 2 event shapes) and
	+ LHCB_2014_I1262703 (Z+jet at 7 TeV).
	+
	+ * Adding leading dijet mass plots to MC_JetAnalysis (and all
	+ derived classes). Thanks to Chris Gutschow!
	+
	+ * Adding CMS_2012_I1298807 (ZZ cross-section at 8 TeV),
	+ CMS_2016_I1459051 (inclusive jet cross-sections at 13 TeV) and
	+ CMS_PAS_FSQ_12_020 (preliminary 7 TeV leading-track underlying
	+ event).
	+
	+ * Adding CDF_2015_1388868 (ppbar underlying event at 300, 900, and 1960 GeV)
	+
	+ * Adding ATLAS_2016_I1467230 (13 TeV min bias),
	+ ATLAS_2016_I1468167 (13 TeV inelastic pp cross-section), and
	+ ATLAS_2016_I1479760 (7 TeV pp double-parton scattering with 4
	+ jets).
	+
	+2016-12-01 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Adding ALICE_2012_I1116147 (eta and pi0 pTs and ratio) and
	+ ATLAS_2011_I929691 (7 TeV jet frag)
	+
	+2016-11-30 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Fix bash bugs in rivet-buildplugin, including fixing the --cmd mode.
	+
	+2016-11-28 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add LHC Run 2 BSM analyses ATLAS_2016_CONF_2016_037 (3-lepton
	+ and same-sign 2-lepton), ATLAS_2016_CONF_2016_054 (1-lepton +
	+ jets), ATLAS_2016_CONF_2016_078 (ICHEP jets + MET),
	+ ATLAS_2016_CONF_2016_094 (1-lepton + many jets), CMS_2013_I1223519
	+ (alphaT + b-jets), and CMS_2016_PAS_SUS_16_14 (jets + MET).
	+
	+ * Provide convenience reversed-argument versions of apply and
	+ declare methods, to allow presentational choice of declare syntax
	+ in situations where the projection argument is very long, and
	+ reduce requirements on the user's memory since this is one
	+ situation in Rivet where there is no 'most natural' ordering
	+ choice.
	+
	+2016-11-24 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Adding pTvec() function to 4-vectors and ParticleBase.
	+
	+ * Fix --pwd option of the rivet script
	+
	+2016-11-21 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add weights and scaling to Cutflow/s.
	+
	+2016-11-19 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add Et(const ParticleBase&) unbound function.
	+
	+2016-11-18 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Fix missing YAML quote mark in rivet-mkanalysis.
	+
	+2016-11-15 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Fix constness requirements on ifilter_select() and Particle/JetEffFilter::operator().
	+
	+ * src/Analyses/ATLAS_2016_I1458270.cc: Fix inverted particle efficiency filtering.
	+
	+2016-10-24 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add rough ATLAS and CMS photon reco efficiency functions from
	+ Delphes (ATLAS and CMS versions are identical, hmmm)
	+
	+2016-10-12 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Tidying/fixing make-plots custom z-ticks code. Thanks to Dmitry Kalinkin.
	+
	+2016-10-03 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Fix SpiresID -> InspireID in some analyses (show-analysis pointed to
	+ non-existing web page)
	+
	+2016-09-29 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add Luminosity_fb to AnalysisInfo
	+
	+ * Added some keywords and Lumi to ATLAS_2016_I1458270
	+
	+2016-09-28 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Merge the ATLAS and CMS from-Delphes electron and muon tracking
	+ efficiency functions into generic trkeff functions -- this is how
	+ it should be.
	+
	+ * Fix return type typo in Jet::bTagged(FN) templated method.
	+
	+ * Add eta and pT cuts to ATLAS truth b-jet definition.
	+
	+ * Use rounding rather than truncation in Cutflow percentage efficiency printing.
	+
	+2016-09-28 Frank Siegert <frank.siegert@cern.ch>
	+
	+ * make-plots bugfix in y-axis labels for RatioPlotMode=deviation
	+
	+2016-09-27 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add vector and scalar pT (rather than Et) to MissingMomentum.
	+
	+2016-09-27 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Analysis keyword machinery
	+
	+ * rivet -a @semileptonic
	+
	+ * rivet -a @semileptonic@^bdecays -a @semileptonic@^ddecays
	+
	+2016-09-22 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Release version 2.5.2
	+
	+2016-09-21 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add a requirement to DressedLeptons that the FinalState passed
	+ as 'bareleptons' will be filtered to only contain charged leptons,
	+ if that is not already the case. Thanks to Markus Seidel for the
	+ suggestion.
	+
	+2016-09-21 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add Simone Amoroso's plugin for hadron spectra (ALEPH_1995_I382179)
	+
	+ * Add Simone Amoroso's plugin for hadron spectra (OPAL_1993_I342766)
	+
	+2016-09-20 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add CMS ttbar analysis from contrib, mark validated (CMS_2016_I1473674)
	+
	+ * Extend rivet-mkhtml --booklet to also work with pdfmerge
	+
	+2016-09-20 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Fix make-plots automatic YMax calculation, which had a typo from code cleaning (mea culpa!).
	+
	+ * Fix ChargedLeptons projection, which failed to exclude neutrinos!!! Thanks to Markus Seidel.
	+
	+ * Add templated FN filtering arg versions of the Jet::*Tags() and
	+ Jet::*Tagged() functions.
	+
	+2016-09-18 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add CMS partonic top analysis (CMS_2015_I1397174)
	+
	+2016-09-18 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add L3 xp analysis of eta mesons, thanks Simone (L3_1992_I336180)
	+
	+ * Add D0 1.8 TeV jet shapes analysis, thanks Simone (D0_1995_I398175)
	+
	+2016-09-17 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add has{Ancestor,Parent,Child,Descendant}With functions and
	+ HasParticle{Ancestor,Parent,Child,Descendant}With functors.
	+
	+2016-09-16 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add ATLAS 8TeV ttbar analysis from contrib (ATLAS_2015_I1404878)
	+
	+2016-09-16 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add particles(GenParticlePtr) to RivetHepMC.hh
	+
	+ * Add hasParent, hasParentWith, and hasAncestorWith to Particle.
	+
	+2016-09-15 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add ATLAS 8TeV dijet analysis from contrib (ATLAS_2015_I1393758)
	+
	+ * Add ATLAS 8TeV 'number of tracks in jets' analysis from contrib (ATLAS_2016_I1419070)
	+
	+ * Add ATLAS 8TeV g->H->WW->enumunu analysis from contrib (ATLAS_2016_I1444991)
	+
	+2016-09-14 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Explicit std::toupper and std::tolower to make clang happy
	+
	+2016-09-14 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add ATLAS Run 2 0-lepton SUSY and monojet search papers (ATLAS_2016_I1452559, ATLAS_2016_I1458270)
	+
	+2016-09-13 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add experimental Cutflow and Cutflows objects for BSM cut tracking.
	+
	+ * Add 'direct' versions of any, all, none to Utils.hh, with an
	+ implicity bool() transforming function.
	+
	+2016-09-13 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add and mark validated B+ to omega analysis (BABAR_2013_I1116411)
	+
	+ * Add and mark validated D0 to pi- analysis (BABAR_2015_I1334693)
	+
	+ * Add a few more particle names and use PID names in recently added
	+ analyses
	+
	+ * Add Simone's OPAL b-frag analysis (OPAL_2003_I599181) after some
	+ cleanup and heavy usage of new features
	+
	+ * Restructured DELPHI_2011_I890503 in the same manner --- picks up
	+ a few more B-hadrons now (e.g. 20523 and such)
	+
	+ * Clean up and add ATLAS 8TeV MinBias (from contrib ATLAS_2016_I1426695)
	+
	+2016-09-12 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add a static constexpr DBL_NAN to Utils.hh for convenience, and
	+ move some utils stuff out of MathHeader.hh
	+
	+2016-09-12 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add count function to Tools/Utils.h
	+
	+ * Add and mark validated B0bar and Bminus-decay to pi analysis (BELLE_2013_I1238273)
	+
	+ * Add and mark validated B0-decay analysis (BELLE_2011_I878990)
	+
	+ * Add and mark validated B to D decay analysis (BELLE_2011_I878990)
	+
	+2016-09-08 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add C-array version of multi-target Analysis::scale() and normalize(), and fix (semantic) constness.
	+
	+ * Add == and != operators for cuts applied to integers.
	+
	+ * Add missing delta{Phi,Eta,Rap}{Gtr,Less} functors to ParticleBaseUtils.hh
	+
	+2016-09-07 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add templated functor filtering args to the Particle parent/child/descendent methods.
	+
	+2016-09-06 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add ATLAS Run 1 medium and tight electron ID efficiency functions.
	+
	+ * Update configure scripts to use newer (Py3-safe) Python testing macros.
	+
	+2016-09-02 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add isFirstWith(out), isLastWith(out) functions, and functor
	+ wrappers, using Cut and templated function/functor args.
	+
	+ * Add Particle::parent() method.
	+
	+ * Add using import/typedef of HepMC *Ptr types (useful step for HepMC 2.07 and 3.00).
	+
	+ * Various typo fixes (and canonical renaming) in ParticleBaseUtils functor collection.
	+
	+ * Add ATLAS MV2c10 and MV2c20 b-tagging effs to SmearingFunctions.hh collection.
	+
	+2016-09-01 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add a PartonicTops projection.
	+
	+ * Add overloaded versions of the Event::allParticles() method with
	+ selection Cut or templated selection function arguments.
	+
	+2016-08-25 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add rapidity scheme arg to DeltaR functor constructors.
	+
	+2016-08-23 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Provide an Analysis::bookCounter(d,x,y, title) function, for
	+ convenience and making the mkanalysis template valid.
	+
	+ * Improve container utils functions, and provide combined
	+ remove_if+erase filter_* functions for both select- and
	+ discard-type selector functions.
	+
	+2016-08-22 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Bugfix in rivet-mkhtml (NoneType: ana.spiresID() --> spiresid)
	+
	+ * Added <numeric> include to Rivet/Tools/Utils.h to make gcc6 happy
	+
	+2016-08-22 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add efffilt() functions and Particle/JetEffFilt functors to SmearingFunctions.hh
	+
	+2016-08-20 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Adding filterBy methods for Particle and Jet which accept
	+ generic boolean functions as well as the Cut specialisation.
	+
	+2016-08-18 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add a Jet::particles(Cut&) method, for inline filtering of jet constituents.
	+
	+ * Add 'conjugate' behaviours to container head and tail functions
	+ via negative length arg values.
	+
	+2016-08-15 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add convenience headers for including all final-state and
	+ smearing projections, to save user typing.
	+
	+2016-08-12 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add standard MET functions for ATLAS R1 (and currently copies
	+ for R2 and CMS).
	+
	+ * Add lots of vector/container helpers for e.g. container slicing,
	+ summing, and min/max calculation.
	+
	+ * Adapt SmearedMET to take two arguments, since SET is typically
	+ used to calculate MET resolution.
	+
	+ * Adding functors for computing vector & ParticleBase differences
	+ w.r.t. another vector.
	+
	+2016-08-12 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Implemented a few more cuts in prompt photon analysis
	+ (CDF_1993_S2742446) but to no avail, the rise of the data towards
	+ larger costheta values cannot be reproduced --- maybe this is a
	+ candidate for more scrutiny and using the boosting machinery such that
	+ the c.m. cuts can be done in a non-approximate way
	+
	+2016-08-11 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Rename CDF_2009_S8383952 to CDF_2009_I856131 due to invalid Spires
	+ entry.
	+
	+ * Add InspireID to all analysis known by their Spires key
	+
	+2016-08-09 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Release 2.5.1
	+
	+2016-08-08 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add a simple MC_MET analysis for out-of-the-box MET distribution testing.
	+
	+2016-08-08 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Add DELPHI_2011_I890503 b-quark fragmentation function measurement,
	+ which superseded DELPHI_2002_069_CONF_603. The latter is marked
	+ OBSOLETE.
	+
	+2016-08-05 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Use Jet mass and energy smearing in CDF_1997_... six-jet analysis,
	+ mark validated.
	+
	+ * Mark CDF_2001_S4563131 validated
	+
	+ * D0_1996_S3214044 --- cut on jet Et rather than pT, fix filling of
	+ costheta and theta plots, mark validated. Concerning the jet
	+ algorithm, I tried with the implementation of fastjet
	+ fastjet/D0RunIConePlugin.hh but that really does not help.
	+
	+ * D0_1996_S3324664 --- fix normalisations, sorting jets properly now,
	+ cleanup and mark validated.
	+
	+
	+2016-08-04 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Use Jet mass and energy smearing in CDF_1996_S310 ... jet properties
	+ analysis. Cleanup analysis and mark validated. Added some more run info.
	+ The same for CDF_1996_S334... (pretty much the same cuts, different
	+ observables).
	+
	+ * Minor fixes in SmearedJets projection
	+
	+2016-08-03 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Protect SmearedJets against loss of tagging information if a
	+ momentum smearing function is used (rather than a dedicated Jet
	+ smearing fn) via implicit casts.
	+
	+2016-08-02 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add SmearedMET projection, wrapping MissingMomentum.
	+
	+ * Include base truth-level projections in SmearedParticles/Jets compare() methods.
	+
	+2016-07-29 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Rename TOTEM_2012_002 to proper TOTEM_2012_I1220862 name.
	+
	+ * Remove conditional building of obsolete, preliminary and
	+ unvalidated analyses. Now always built, since there are sufficient
	+ warnings.
	+
	+2016-07-28 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Mark D0_2000... W pT analysis validated
	+
	+ * Mark LHCB_2011_S919... phi meson analysis validated
	+
	+2016-07-25 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add unbound accessors for momentum properties of ParticleBase objects.
	+
	+ * Add Rivet/Tools/ParticleBaseUtils.hh to collect tools like functors for particle & jet filtering.
	+
	+ * Add vector<ptr> versions of Analysis::scale() and ::normalize(), for batched scaling.
	+
	+ * Add Analysis::scale() and Analysis::divide() methods for Counter types.
	+
	+ * Utils.hh: add a generic sum() function for containers, and use auto in loop to support arrays.
	+
	+ * Set data path as well as lib path in scripts with --pwd option, and use abs path to $PWD.
	+
	+ * Add setAnalysisDataPaths and addAnalysisDataPath to RivetPaths.hh/cc and Python.
	+
	+ * Pass absolutized RIVET_DATA_PATH from rivet-mkhtml to rivet-cmphistos.
	+
	+2016-07-24 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Mark CDF_2008_S77... b jet shapes validated
	+
	+ * Added protection against low stats yoda exception
	+ in finalize for that analysis
	+
	+2016-07-22 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Fix newly introduced bug in make-plots which led to data point
	+ markers being skipped for all but the last bin.
	+
	+2016-07-21 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add pid, abspid, charge, abscharge, charge3, and abscharge3 Cut
	+ enums, handled by Particle cut targets.
	+
	+ * Add abscharge() and abscharge3() methods to Particle.
	+
	+ * Add optional Cut and duplicate-removal flags to Particle children & descendants methods.
	+
	+ * Add unbound versions of Particle is* and from* methods, for easier functor use.
	+
	+ * Add Particle::isPrompt() as a member rather than unbound function.
	+
	+ * Add protections against -ve mass from numerical precision errors in smearing functions.
	+
	+2016-07-20 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Move several internal system headers into the include/Rivet/Tools directory.
	+
	+ * Fix median-computing safety logic in ATLAS_2010_S8914702 and
	+ tidy this and @todo markers in several similar analyses.
	+
	+ * Add to_str/toString and stream functions for Particle, and a bit
	+ of Particle util function reorganisation.
	+
	+ * Add isStrange/Charm/Bottom PID and Particle functions.
	+
	+ * Add RangeError exception throwing from MathUtils.hh stats
	+ functions if given empty/mismatched datasets.
	+
	+ * Add Rivet/Tools/PrettyPrint.hh, based on https://louisdx.github.io/cxx-prettyprint/
	+
	+ * Allow use of path regex group references in .plot file keyed values.
	+
	+2016-07-20 Holger Schulz <holger.schulz@cern.ch>
	+
	+ * Fix the --nskip behaviour on the main rivet script.
	+
	+2016-07-07 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Release version 2.5.0
	+
	+2016-07-01 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Fix pandoc interface flag version detection.
	+
	+2016-06-28 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Release version 2.4.3
	+
	+ * Add ATLAS_2016_I1468168 early ttbar fully leptonic fiducial
	+ cross-section analysis at 13 TeV.
	+
	+2016-06-21 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add ATLAS_2016_I1457605 inclusive photon analysis at 8 TeV.
	+
	+2016-06-15 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add a --show-bibtex option to the rivet script, for convenient
	+ outputting of a BibTeX db for the used analyses.
	+
	+2016-06-14 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add and rename 4-vector boost calculation methods: new methods
	+ beta, betaVec, gamma & gammaVec are now preferred to the
	+ deprecated boostVector method.
	+
	+2016-06-13 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add and use projection handling methods declare(proj, pname) and
	+ apply<PROJ>(evt, pname) rather than the longer and explicitly
	+ 'projectiony' addProjection & applyProjection.
	+
	+ * Start using the DEFAULT_RIVET_ANALYSIS_CTOR macro (newly created
	+ preferred alias to long-present DEFAULT_RIVET_ANA_CONSTRUCTOR)
	+
	+ * Add a DEFAULT_RIVET_PROJ_CLONE macro for implementing the
	+ clone() method boiler-plate code in projections.
	+
	+2016-06-10 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add a NonPromptFinalState projection, and tweak the
	+ PromptFinalState and unbound Particle functions a little in
	+ response. May need some more finessing.
	+
	+ * Add user-facing aliases to ProjectionApplier add, get, and apply
	+ methods... the templated versions of which can now be called
	+ without using the word 'projection', which makes the function
	+ names a bit shorter and pithier, and reduces semantic repetition.
	+
	+2016-06-10 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Adding ATLAS_2015_I1397635 Wt at 8 TeV analysis.
	+
	+ * Adding ATLAS_2015_I1390114 tt+b(b) at 8 TeV analysis.
	+
	+2016-06-09 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Downgrade some non-fatal error messages from ERROR to WARNING
	+ status, because sigh ATLAS's software treats any appearance of
	+ the word 'ERROR' in its log file as a reason to report the job as
	+ failed (facepalm).
	+
	+2016-06-07 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Adding ATLAS 13 TeV minimum bias analysis, ATLAS_2016_I1419652.
	+
	+2016-05-30 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * pyext/rivet/util.py: Add pandoc --wrap/--no-wrap CLI detection
	+ and batch conversion.
	+
	+ * bin/rivet: add -o as a more standard 'output' option flag alias to -H.
	+
	+2016-05-23 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Remove the last ref-data bin from table 16 of
	+ ATLAS_2010_S8918562, due to data corruption. The corresponding
	+ HepData record will be amended by ATLAS.
	+
	+2016-05-12 Holger Schulz <holger.schulz@durham.ac.uk>
	+
	+ * Mark ATLAS_2012_I1082009 as validated after exhaustive tests with
	+ Pythia8 and Sherpa in inclusive QCD mode.
	+
	+2016-05-11 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Specialise return error codes from the rivet script.
	+
	+2016-05-11 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add Event::allParticles() to provide neater (but not helpful)
	+ access to Rivet-wrapped versions of the raw particles in the
	+ Event::genEvent() record, and hence reduce HepMC digging.
	+
	+2016-05-05 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Version 2.4.2 release!
	+
	+ * Update SLD_2002_S4869273 ref data to match publication erratum,
	+ now updated in HepData. Thanks to Peter Skands for the report and
	+ Mike Whalley / Graeme Watt for the quick fix and heads-up.
	+
	+2016-04-27 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add CMS_2014_I1305624 event shapes analysis, with standalone
	+ variable calculation struct embedded in an unnamed namespace.
	+
	+2016-04-19 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Various clean-ups and fixes in ATLAS analyses using isolated
	+ photons with median pT density correction.
	+
	+2016-04-18 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add transformBy(LT) methods to Particle and Jet.
	+
	+ * Add mkObjectTransform and mkFrameTransform factory methods to LorentzTransform.
	+
	+2016-04-17 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add null GenVertex protection in Particle children & descendants methods.
	+
	+2016-04-15 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add ATLAS_2015_I1397637, ATLAS 8 TeV boosted top cross-section vs. pT
	+
	+2016-04-14 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add a --no-histos argument to the rivet script.
	+
	+2016-04-13 Andy Buckley <andy.buckley@cern.ch>
	+
	+ * Add ATLAS_2015_I1351916 (8 TeV Z FB asymmetry) and
	+ ATLAS_2015_I1408516 (8 TeV Z phi* and pT) analyses, and their _EL,
	+ _MU variants.
	+
	2016-04-12 Andy Buckley <andy.buckley@cern.ch>

	* Patch PID utils for ordering issues in baryon decoding.

	2016-04-11 Andy Buckley <andy.buckley@cern.ch>

	* Actually implement ZEUS_2001_S4815815... only 10 years late!

	2016-04-08 Andy Buckley <andy.buckley@cern.ch>

	* Add a --guess-prefix flag to rivet-config, cf. fastjet-config.

	* Add RIVET_DATA_PATH variable and related functions in C++ and
	Python as a common first-fallback for RIVET_REF_PATH,
	RIVET_INFO_PATH, and RIVET_PLOT_PATH.

	* Add --pwd options to rivet-mkhtml and rivet-cmphistos

	2016-04-07 Andy Buckley <andy.buckley@cern.ch>

	* Remove implicit conventional event rotation for HERA -- this
	needs to be done explicitly from now.

	* Add comBoost functions and methods to Beam.hh, and tidy
	LorentzTransformation.

	* Restructure Beam projection functions for beam particle and
	sqrtS extraction, and add asqrtS functions.

	* Rename and improve PID and Particle Z,A,lambda functions ->
	nuclZ,nuclA,nuclNlambda.

	2016-04-05 Andy Buckley <andy.buckley@cern.ch>

	* Improve binIndex function, with an optional argument to allow
	overflow lookup, and add it to testMath.

	* Adding setPE, setPM, setPtEtaPhiM, etc. methods and
	corresponding mk* static methods to FourMomentum, as well as
	adding more convenience aliases and vector attributes for
	completeness. Coordinate conversion functions taken from
	HEPUtils::P4. New attrs also mapped to ParticleBase.

	2016-03-29 Andy Buckley <andy.buckley@cern.ch>

	* ALEPH_1996_S3196992.cc, ATLAS_2010_S8914702.cc,
	ATLAS_2011_I921594.cc, ATLAS_2011_S9120807.cc,
	ATLAS_2012_I1093738.cc, ATLAS_2012_I1199269.cc,
	ATLAS_2013_I1217867.cc, ATLAS_2013_I1244522.cc,
	ATLAS_2013_I1263495.cc, ATLAS_2014_I1307756.cc,
	ATLAS_2015_I1364361.cc, CDF_2008_S7540469.cc,
	CMS_2015_I1370682.cc, MC_JetSplittings.cc, STAR_2006_S6870392.cc:
	Updates for new FastJets interface, and other cleaning.

	* Deprecate 'standalone' FastJets constructors -- they are
	misleading.

	* More improvements around jets, including unbound conversion and
	filtering routines between collections of Particles, Jets, and
	PseudoJets.

	* Place 'Cut' forward declaration in a new Cuts.fhh header.

	* Adding a Cuts::OPEN extern const (a bit more standard- and
	constant-looking than Cuts::open())

	2016-03-28 Andy Buckley <andy.buckley@cern.ch>

	* Improvements to FastJets constructors, including specification
	of optional AreaDefinition as a constructor arg, disabling dodgy
	no-FS constructors which I suspect don't work properly in the
	brave new world of automatic ghost tagging, using a bit of
	judicious constructor delegation, and completing/exposing use of
	shared_ptr for internal memory management.

	2016-03-26 Andy Buckley <andy.buckley@cern.ch>

	* Remove Rivet/Tools/RivetBoost.hh and Boost references from
	rivet-config, rivet-buildplugin, and configure.ac. It's gone ;-)

	* Replace Boost assign usage with C++11 brace initialisers. All
	Boost use is gone from Rivet!

	* Replace Boost lexical_cast and string algorithms.

	2016-03-25 Andy Buckley <andy.buckley@cern.ch>

	* Bug-fix in semi-leptonic top selection of CMS_2015_I1370682.

	2016-03-12 Andy Buckley <andy.buckley@cern.ch>

	* Allow multi-line major tick labels on make-plots linear x and y
	axes. Linebreaks are indicated by \n in the .dat file.

	2016-03-09 Andy Buckley <andy.buckley@cern.ch>

	* Release 2.4.1

	2016-03-03 Andy Buckley <andy.buckley@cern.ch>

	* Add a --nskip flag to the rivet command-line tool, to allow
	processing to begin in the middle of an event file (useful for
	batched processing of large files, in combination with --nevts)

	2016-03-03 Holger Schulz <holger.schulz@durham.ac.uk>

	* Add ATLAS 7 TeV event shapes in Z+jets analysis (ATLAS_2016_I1424838)

	2016-02-29 Andy Buckley <andy.buckley@cern.ch>

	* Update make-plots to use multiprocessing rather than threading.

	* Add FastJets::trimJet method, thanks to James Monk for the
	suggestion and patch.

	* Add new preferred name PID::charge3 in place of
	PID::threeCharge, and also convenience PID::abscharge and
	PID::abscharge3 functions -- all derived from changes in external
	HEPUtils.

	* Add analyze(const GenEvent*) and analysis(string&) methods to
	AnalysisHandler, plus some docstring improvements.

	2016-02-23 Andy Buckley <andy.buckley@cern.ch>

	* New ATLAS_2015_I1394679 analysis.

	* New MC_HHJETS analysis from Andreas Papaefstathiou.

	* Ref data updates for ATLAS_2013_I1219109, ATLAS_2014_I1312627,
	and ATLAS_2014_I1319490.

	* Add automatic output paging to 'rivet --show-analyses'

	2016-02-16 Andy Buckley <andy.buckley@cern.ch>

	* Apply cross-section unit fixes and plot styling improvements to
	ATLAS_2013_I1217863 analyses, thanks to Christian Gutschow.

	* Fix to rivet-cmphistos to avoid overwriting RatioPlotYLabel if
	already set via e.g. the PLOT pseudo-file. Thanks to Johann Felix
	v. Soden-Fraunhofen.

	2016-02-15 Andy Buckley <andy.buckley@cern.ch>

	* Add Analysis::bookCounter and some machinery in rivet-cmphistos
	to avoid getting tripped up by unplottable (for now) data types.

	* Add --font and --format options to rivet-mkhtml and make-plots,
	to replace the individual flags used for that purpose. Not fully
	cleaned up, but a necessary step.

	* Add new plot styling options to rivet-cmphistos and
	rivet-mkhtml. Thanks to Gavin Hesketh.

	* Modify rivet-cmphistos and rivet-mkhtml to apply plot hiding if
	any path component is hidden by an underscore prefix, as
	implemented in AOPath, plus other tidying using new AOPath
	methods.

	* Add pyext/rivet/aopaths.py, containing AOPath object for central
	& standard decoding of Rivet-standard analysis object path
	structures.

	2016-02-12 Andy Buckley <andy.buckley@cern.ch>

	* Update ParticleIdUtils.hh (i.e. PID:: functions) to use the
	functions from the latest version of MCUtils' PIDUtils.h.

	2016-01-15 Andy Buckley <andy.buckley@cern.ch>

	* Change rivet-cmphistos path matching logic from match to search
	(user can add explicit ^ marker if they want match semantics).

	2015-12-20 Andy Buckley <andy.buckley@cern.ch>

	* Improve linspace (and hence also logspace) precision errors by
	using multiplication rather than repeated addition to build edge
	list (thanks to Holger Schulz for the suggestion).

	2015-12-15 Andy Buckley <andy.buckley@cern.ch>

	* Add cmphistos and make-plots machinery for handling 'suffix'
	variations on plot paths, currently just by plotting every line,
	with the variations in a 70% faded tint.

	* Add Beam::pv() method for finding the beam interaction primary
	vertex 4-position.

	* Add a new Particle::setMomentum(E,x,y,z) method, and an origin
	position member which is automatically populated from the
	GenParticle, with access methods corresponding to the momentum
	ones.

	2015-12-10 Andy Buckley <andy.buckley@cern.ch>

	* make-plots: improve custom tick attribute handling, allowing
	empty lists. Also, any whitespace now counts as a tick separator
	-- explicit whitespace in labels should be done via ~ or similar
	LaTeX markup.

	2015-12-04 Andy Buckley <andy.buckley@cern.ch>

	* Pro-actively use -m/-M arguments when initially loading
	histograms in mkhtml, before passing them to cmphistos.

	2015-12-03 Andy Buckley <andy.buckley@cern.ch>

	* Move contains() and has_key() functions on STL containers from std to Rivet namespaces.

	* Adding IsRef attributes to all YODA refdata files; this will be
	used to replace the /REF prefix in Rivet v3 onwards. The migration
	has also removed leading # characters from BEGIN/END blocks, as
	per YODA format evolution: new YODA versions as required by
	current Rivet releases are able to read both the old and new
	formats.

	2015-12-02 Andy Buckley <andy.buckley@cern.ch>

	* Add handling of a command-line PLOT 'file' argument to rivet-mkhtml, cf. rivet-cmphistos.

	* Improvements to rivet-mkhtml behaviour re. consistency with
	rivet-cmphistos in how muti-part histo paths are decomposed into
	analysis-name + histo name, and removal of 'NONE' strings.

	2015-11-30 Andy Buckley <andy.buckley@cern.ch>

	* Relax rivet/plotinfo.py pattern matching on .plot file
	components, to allow leading whitespace and around = signs, and to
	make the leading # optional on BEGIN/END blocks.

	2015-11-26 Andy Buckley <andy.buckley@cern.ch>

	* Write out intermediate histogram files by default, with event interval of 10k.

	2015-11-25 Andy Buckley <andy.buckley@cern.ch>

	* Protect make-plots against lock-up due to partial pstricks command when there are no data points.

	2015-11-17 Andy Buckley <andy.buckley@cern.ch>

	* rivet-cmphistos: Use a ratio label that doesn't mention 'data' when plotting MC vs. MC.

	2015-11-12 Andy Buckley <andy.buckley@cern.ch>

	* Tweak plot and subplot sizing defaults in make-plots so the
	total canvas is always the same size by default.

	2015-11-10 Andy Buckley <andy.buckley@cern.ch>

	* Handle 2D histograms better in rivet-cmphistos (since they can't be overlaid)

	2015-11-05 Andy Buckley <andy.buckley@cern.ch>

	* Allow comma-separated analysis name lists to be passed to a single -a/--analysis/--analyses option.

	* Convert namespace-global const variables to be static, to suppress compiler warnings.

	* Use standard MAX_DBL and MAX_INT macros as a source for MAXDOUBLE and MAXINT, to suppress GCC5 warnings.

	2015-11-04 Holger Schulz <holger.schulz@durham.ac.uk>

	* Adding LHCB inelastic xsection measurement (LHCB_2015_I1333223)

	* Adding ATLAS colour flow in ttbar->semileptonic measurement (ATLAS_2015_I1376945)

	2015-10-07 Chris Pollard <cpollard@cern.ch>

	* Release 2.4.0

	2015-10-06 Holger Schulz <holger.schulz@durham.ac.uk>

	* Adding CMS_2015_I1327224 dijet analysis (Mjj>2 TeV)

	2015-10-03 Holger Schulz <holger.schulz@durham.ac.uk>

	* Adding CMS_2015_I1346843 Z+gamma

	2015-09-30 Andy Buckley <andy.buckley@cern.ch>

	* Important improvement in FourVector & FourMomentum: new reverse()
	method to return a 4-vector in which only the spatial component
	has been inverted cf. operator- which flips the t/E component as
	well.

	2015-09-28 Holger Schulz <holger.schulz@durham.ac.uk>

	* Adding D0_2000_I503361 ZPT at 1800 GeV

	2015-09-29 Chris Pollard <cpollard@cern.ch>

	* Adding ATLAS_2015_CONF_2015_041

	2015-09-29 Chris Pollard <cpollard@cern.ch>

	* Adding ATLAS_2015_I1387176

	2015-09-29 Chris Pollard <cpollard@cern.ch>

	* Adding ATLAS_2014_I1327229

	2015-09-28 Chris Pollard <cpollard@cern.ch>

	* Adding ATLAS_2014_I1326641

	2015-09-28 Holger Schulz <holger.schulz@durham.ac.uk>

	* Adding CMS_2013_I1122847 FB assymetry in DY analysis

	2015-09-28 Andy Buckley <andy.buckley@cern.ch>

	* Adding CMS_2015_I1385107 LHA pp 2.76 TeV track-jet underlying event.

	2015-09-27 Andy Buckley <andy.buckley@cern.ch>

	* Adding CMS_2015_I1384119 LHC Run 2 minimum bias dN/deta with no B field.

	2015-09-25 Andy Buckley <andy.buckley@cern.ch>

	* Adding TOTEM_2014_I1328627 forward charged density in eta analysis.

	2015-09-23 Andy Buckley <andy.buckley@cern.ch>

	* Add CMS_2015_I1310737 Z+jets analysis.

	* Allow running MC_{W,Z}INC, MC_{W,Z}JETS as separate bare lepton
	analyses.

	2015-09-23 Andy Buckley <andy.buckley@cern.ch>

	* FastJets now allows use of FastJet pure ghosts, by excluding
	them from the constituents of Rivet Jet objects. Thanks to James
	Monk for raising the issue and providing a patch.

	2015-09-15 Andy Buckley <andy.buckley@cern.ch>

	* More MissingMomentum changes: add optional 'mass target'
	argument when retrieving the vector sum as a 4-momentum, with the
	mass defaulting to 0 rather than sqrt(sum(E)^2 - sum(p)^2).

	* Require Boost 1.55 for robust compilation, as pointed out by
	Andrii Verbytskyi.

	2015-09-10 Andy Buckley <andy.buckley@cern.ch>

	* Allow access to MissingMomentum projection via WFinder.

	* Adding extra methods to MissingMomentum, to make it more user-friendly.

	2015-09-09 Andy Buckley <andy.buckley@cern.ch>

	* Fix factor of 2 in LHCB_2013_I1218996 normalisation, thanks to
	Felix Riehn for the report.

	2015-08-20 Frank Siegert <frank.siegert@cern.ch>

	* Add function to ZFinder to retrieve all fiducial dressed
	leptons, e.g. to allow vetoing on a third one (proposed by
	Christian Gutschow).

	2015-08-18 Andy Buckley <andy.buckley@cern.ch>

	* Rename xs and counter AOs to start with underscores, and modify
	rivet-cmphistos to skip AOs whose basenames start with _.

	2015-08-17 Andy Buckley <andy.buckley@cern.ch>

	* Add writing out of cross-section and total event counter by
	default. Need to add some name protection to avoid them being
	plotted.

	2015-08-16 Andy Buckley <andy.buckley@cern.ch>

	* Add templated versions of Analysis::refData() to use data types
	other than Scatter2DPtr, and convert the cached ref data store to
	generic AnalysisObjectPtrs to make it possible.

	2015-07-29 Andy Buckley <andy.buckley@cern.ch>

	* Add optional Cut arguments to all the Jet tag methods.

	* Add exception handling and pre-emptive testing for a
	non-writeable output directory (based on patch from Lukas
	Heinrich).

	2015-07-24 Andy Buckley <andy.buckley@cern.ch>

	* Version 2.3.0 release.

	2015-07-02 Holger Schulz <holger.schulz@durham.ac.uk>

	* Tidy up ATLAS higgs combination analysis.
	* Add ALICE kaon, pion analysis (ALICE_2015_I1357424)
	* Add ALICE strange baryon analysis (ALICE_2014_I1300380)
	* Add CDF ZpT measurement in Z->ee events analysis (CDF_2012_I1124333)
	* Add validated ATLAS W+charm measurement (ATLAS_2014_I1282447)
	* Add validated CMS jet and dijet analysis (CMS_2013_I1208923)

	2015-07-01 Andy Buckley <andy.buckley@cern.ch>

	* Define a private virtual operator= on Projection, to block
	'sliced' accidental value copies of derived class instances.

	* Add new muon-in-jet options to FastJet constructors, pass that
	and invisibles enums correctly to JetAlg, tweak the default
	strategies, and add a FastJets constructor from a
	fastjet::JetDefinition (while deprecating the plugin-by-reference
	constructor).

	2015-07-01 Holger Schulz <holger.schulz@durham.ac.uk>

	* Add D0 phi* measurement (D0_2015_I1324946).

	* Remove WUD and MC_PHOTONJETUE analyses

	* Don't abort ATLAS_2015_I1364361 if there is no stable Higgs
	print a warning instead and veto event

	2015-07-01 Andy Buckley <andy.buckley@cern.ch>

	* Add all, none, from-decay muon filtering options to JetAlg and
	FastJets.

	* Rename NONPROMPT_INVISIBLES to DECAY_INVISIBLES for clarity &
	extensibility.

	* Remove FastJets::ySubJet, splitJet, and filterJet methods --
	they're BDRS-paper-specific and you can now use the FastJet
	objects directly to do this and much more.

	* Adding InvisiblesStrategy to JetAlg, using it rather than a bool
	in the useInvisibles method, and updating FastJets to use this
	approach for its particle filtering and to optionally use the enum
	in the constructor arguments. The new default invisibles-using
	behaviour is to still exclude _prompt_ invisibles, and the default
	is still to exclude them all. Only one analysis
	(src/Analyses/STAR_2006_S6870392.cc) required updating, since it
	was the only one to be using the FastJets legacy seed_threshold
	constructor argument.

	* Adding isVisible method to Particle, taken from
	VisibleFinalState (which now uses this).

	2015-06-30 Andy Buckley <andy.buckley@cern.ch>

	* Marking many old & superseded ATLAS analyses as obsolete.

	* Adding cmpMomByMass and cmpMomByAscMass sorting functors.

	* Bump version to 2.3.0 and require YODA > 1.4.0 (current head at
	time of development).
	2015-06-08 Andy Buckley <andy.buckley@cern.ch>

	* Add handling of -m/-M flags on rivet-cmphistos and rivet-mkhtml,
	moving current rivet-mkhtml -m/-M to -a/-A (for analysis name
	pattern matching). Requires YODA head (will be YODA 1.3.2 of
	1.4.0).

	* src/Analyses/ATLAS_2015_I1364361.cc: Now use the built-in prompt
	photon selecting functions.

	* Tweak legend positions in MC_JETS .plot file.

	* Add a bit more debug output from ZFinder and WFinder.

	2015-05-24 Holger Schulz <holger.schulz@durham.ac.uk>

	* Normalisation discussion concerning ATLAS_2014_I1325553
	is resolved. Changed YLabel accordingly.

	2015-05-19 Holger Schulz <holger.schulz@durham.ac.uk>

	* Add (preliminary) ATLAS combined Higgs analysis
	(ATLAS_2015_I1364361). Data will be updated and more
	histos added as soon as paper is published in journal.
	For now using data taken from public ressource
	https://atlas.web.cern.ch/Atlas/GROUPS/PHYSICS/PAPERS/HIGG-2014-11/

	2015-05-19 Peter Richardson <peter.richardson@durham.ac.uk>

	* Fix ATLAS_2014_I1325553 normalisation of histograms was wrong by
	factor of two \|y\| vs y problem

	2015-05-01 Andy Buckley <andy.buckley@cern.ch>

	* Fix MC_HJETS/HINC/HKTSPLITTINGS analyses to (ab)use the ZFinder
	with a mass range of 115-135 GeV and a mass target of 125 GeV (was
	previously 115-125 and mass target of mZ)

	2015-04-30 Andy Buckley <andy.buckley@cern.ch>

	* Removing uses of boost::assign::list_of, preferring the existing
	comma-based assign override for now, for C++11 compatibility.

	* Convert MC_Z* analysis finalize methods to use scale() rather than normalize().

	2015-04-01 Holger Schulz <holger.schulz@durham.ac.uk>

	* Add CMS 7 TeV rapidity gap analysis (CMS_2015_I1356998).

	* Remove FinalState Projection.

	2015-03-30 Holger Schulz <holger.schulz@durham.ac.uk>

	* Add ATLAS 7 TeV photon + jets analysis (ATLAS_2013_I1244522).

	2015-03-26 Andy Buckley <andy.buckley@cern.ch>

	* Updates for HepMC 2.07 interface constness improvements.

	2015-03-25 Holger Schulz <holger.schulz@durham.ac.uk>

	* Add ATLAS double parton scattering in W+2j analysis (ATLAS_2013_I1216670).

	2015-03-24 Andy Buckley <andy.buckley@cern.ch>

	* 2.2.1 release!

	2015-03-23 Holger Schulz <holger.schulz@durham.ac.uk>

	* Add ATLAS differential Higgs analysis (ATLAS_2014_I1306615).

	2015-03-19 Chris Pollard <cpollard@cern.ch>

	* Add ATLAS V+gamma analyses (ATLAS_2013_I1217863)

	2015-03-20 Andy Buckley <andy.buckley@cern.ch>

	* Adding ATLAS R-jets analysis i.e. ratios of W+jets and Z+jets
	observables (ATLAS_2014_I1312627 and _EL, _MU variants)

	* include/Rivet/Tools/ParticleUtils.hh: Adding same/oppSign and
	same/opp/diffCharge functions, operating on two Particles.

	* include/Rivet/Tools/ParticleUtils.hh: Adding HasAbsPID functor
	and removing optional abs arg from HasPID.

	2015-03-19 Andy Buckley <andy.buckley@cern.ch>

	* Mark ATLAS_2012_I1083318 as VALIDATED and fix d25-x01-y02 ref data.

	2015-03-19 Chris Pollard <cpollard@cern.ch>

	* Add ATLAS W and Z angular analyses (ATLAS_2011_I928289)

	2015-03-19 Andy Buckley <andy.buckley@cern.ch>

	* Add LHCb charged particle multiplicities and densities analysis (LHCB_2014_I1281685)

	* Add LHCb Z y and phi* analysis (LHCB_2012_I1208102)

	2015-03-19 Holger Schulz <holger.schulz@durham.ac.uk>

	* Add ATLAS dijet analysis (ATLAS_2014_I1325553).

	* Add ATLAS Z pT analysis (ATLAS_2014_I1300647).

	* Add ATLAS low-mass Drell-Yan analysis (ATLAS_2014_I1288706).

	* Add ATLAS gap fractions analysis (ATLAS_2014_I1307243).

	2015-03-18 Andy Buckley <andy.buckley@cern.ch>

	* Adding CMS_2014_I1298810 and CMS_2014_I1303894 analyses.

	2015-03-18 Holger Schulz <holger.schulz@durham.ac.uk>

	* Add PDG_TAUS analysis which makes use of the TauFinder.

	* Add ATLAS 'traditional' Underlying Event in Z->mumu analysis (ATLAS_2014_I1315949).

	2015-03-18 Andy Buckley <andy.buckley@cern.ch>

	* Change UnstableFinalState duplicate resolution to use the last
	in a chain rather than the first.

	2015-03-17 Holger Schulz <holger.schulz@durham.ac.uk>

	* Update Taufinder to use decaytyoe (can be HADRONIC, LEPTONIC or
	ANY), in FastJet.cc --- set TauFinder mode to hadronic for tau-tagging

	2015-03-16 Chris Pollard <cpollard@cern.ch>

	* Removed fuzzyEquals() from Vector3::angle()

	2015-03-16 Andy Buckley <andy.buckley@cern.ch>

	* Adding Cuts-based constructor to PrimaryHadrons.

	* Adding missing compare() method to HeavyHadrons projection.

	2015-03-15 Chris Pollard <cpollard@cern.ch>

	* Adding FinalPartons projection which selects the quarks and
	gluons immediately before hadronization

	2015-03-05 Andy Buckley <andy.buckley@cern.ch>

	* Adding Cuts-based constructors and other tidying in UnstableFinalState and HeavyHadrons

	2015-03-03 Andy Buckley <andy.buckley@cern.ch>

	* Add support for a PLOT meta-file argument to rivet-cmphistos.

	2015-02-27 Andy Buckley <andy.buckley@cern.ch>

	* Improved time reporting.

	2015-02-24 Andy Buckley <andy.buckley@cern.ch>

	* Add Particle::fromHadron and Particle::fromPromptTau, and add a
	boolean 'prompt' argument to Particle::fromTau.

	* Fix WFinder use-transverse-mass property setting. Thanks to Christian Gutschow.

	2015-02-04 Andy Buckley <andy.buckley@cern.ch>

	* Add more protection against math domain errors with log axes.

	* Add some protection against nan-valued points and error bars in make-plots.

	2015-02-03 Andy Buckley <andy.buckley@cern.ch>

	* Converting 'bitwise' to 'logical' Cuts combinations in all analyses.

	2015-02-02 Andy Buckley <andy.buckley@cern.ch>

	* Use vector MET rather than scalar VET (doh...) in WFinder
	cut. Thanks to Ines Ochoa for the bug report.

	* Updating and tidying analyses with deprecation warnings.

	* Adding more Cuts/FS constructors for Charged,Neutral,UnstableFinalState.

	* Add &&, \|\| and ! operators for without-parens-warnings Cut
	combining. Note these don't short-circuit, but this is ok since
	Cut comparisons don't have side-effects.

	* Add absetaIn, absrapIn Cut range definitions.

	* Updating use of sorted particle/jet access methods and cmp
	functors in projections and analyses.

	2014-12-09 Andy Buckley <andy.buckley@cern.ch>

	* Adding a --cmd arg to rivet-buildplugin to allow the output
	paths to be sed'ed (to help deal with naive Grid
	distribution). For example BUILDROOT=`rivet-config --prefix`;
	rivet-buildplugin PHOTONS.cc --cmd \| sed -e
	"s:$BUILDROOT:$SITEROOT:g"

	2014-11-26 Andy Buckley <andy.buckley@cern.ch>

	* Interface improvements in DressedLeptons constructor.

	* Adding DEPRECATED macro to throw compiler deprecation warnings when using deprecated features.

	2014-11-25 Andy Buckley <andy.buckley@cern.ch>

	* Adding Cut-based constructors, and various constructors with
	lists of PDG codes to IdentifiedFinalState.

	2014-11-20 Andy Buckley <andy.buckley@cern.ch>

	* Analysis updates (ATLAS, CMS, CDF, D0) to apply the changes below.

	* Adding JetAlg jets(Cut, Sorter) methods, and other interface
	improvements for cut and sorted ParticleBase retrieval from JetAlg
	and ParticleFinder projections. Some old many-doubles versions
	removed, syntactic sugar sorting methods deprecated.

	* Adding Cuts::Et and Cuts::ptIn, Cuts::etIn, Cuts::massIn.

	* Moving FastJet includes, conversions, uses etc. into Tools/RivetFastJet.hh

	2014-10-07 Andy Buckley <andy.buckley@cern.ch>

	* Fix a bug in the isCharmHadron(pid) function and remove isStrange* functions.

	2014-09-30 Andy Buckley <andy.buckley@cern.ch>

	* 2.2.0 release!

	* Mark Jet::containsBottom and Jet::containsCharm as deprecated
	methods: use the new methods. Analyses updated.

	* Add Jet::bTagged(), Jet::cTagged() and Jet::tauTagged() as
	ghost-assoc-based replacements for the 'contains' tagging methods.

	2014-09-17 Andy Buckley <andy.buckley@cern.ch>

	* Adding support for 1D and 3D YODA scatters, and helper methods
	for calling the efficiency, asymm and 2D histo divide functions.

	2014-09-12 Andy Buckley <andy.buckley@cern.ch>

	* Adding 5 new ATLAS analyses:
	ATLAS_2011_I921594: Inclusive isolated prompt photon analysis with full 2010 LHC data
	ATLAS_2013_I1263495: Inclusive isolated prompt photon analysis with 2011 LHC data
	ATLAS_2014_I1279489: Measurements of electroweak production of dijets + $Z$ boson, and distributions sensitive to vector boson fusion
	ATLAS_2014_I1282441: The differential production cross section of the $\phi(1020)$ meson in $\sqrt{s}=7$ TeV $pp$ collisions measured with the ATLAS detector
	ATLAS_2014_I1298811: Leading jet underlying event at 7 TeV in ATLAS

	* Adding a median(vector<NUM>) function and fixing the other stats
	functions to operate on vector<NUM> rather than vector<int>.

	2014-09-03 Andy Buckley <andy.buckley@cern.ch>

	* Fix wrong behaviour of LorentzTransform with a null boost vector
	-- thanks to Michael Grosse.

	2014-08-26 Andy Buckley <andy.buckley@cern.ch>

	* Add calc() methods to Hemispheres as requested, to allow it to
	be used with Jet or FourMomentum inputs outside the normal
	projection system.

	2014-08-17 Andy Buckley <andy.buckley@cern.ch>

	* Improvements to the particles methods on
	ParticleFinder/FinalState, in particular adding the range of cuts
	arguments cf. JetAlg (and tweaking the sorted jets equivalent) and
	returning as a copy rather than a reference if cut/sorted to avoid
	accidentally messing up the cached copy.

	* Creating ParticleFinder projection base class, and moving
	Particles-accessing methods from FinalState into it.

	* Adding basic forms of MC_ELECTRONS, MC_MUONS, and MC_TAUS
	analyses.

	2014-08-15 Andy Buckley <andy.buckley@cern.ch>

	* Version bump to 2.2.0beta1 for use at BOOST and MCnet school.

	2014-08-13 Andy Buckley <andy.buckley@cern.ch>

	* New analyses:
	ATLAS_2014_I1268975 (high mass dijet cross-section at 7 TeV)
	ATLAS_2014_I1304688 (jet multiplicity and pT at 7 TeV)
	ATLAS_2014_I1307756 (scalar diphoton resonance search at 8 TeV -- no histograms!)
	CMSTOTEM_2014_I1294140 (charged particle pseudorapidity at 8 TeV)

	2014-08-09 Andy Buckley <andy.buckley@cern.ch>

	* Adding PromptFinalState, based on code submitted by Alex
	Grohsjean and Will Bell. Thanks!

	2014-08-06 Andy Buckley <andy.buckley@cern.ch>

	* Adding MC_HFJETS and MC_JETTAGS analyses.

	2014-08-05 Andy Buckley <andy.buckley@cern.ch>

	* Update all analyses to use the xMin/Max/Mid, xMean, xWidth,
	etc. methods on YODA classes rather than the deprecated lowEdge
	etc.

	* Merge new HasPID functor from Holger Schulz into
	Rivet/Tools/ParticleUtils.hh, mainly for use with the any()
	function in Rivet/Tools/Utils.hh

	2014-08-04 Andy Buckley <andy.buckley@cern.ch>

	* Add ghost tagging of charms, bottoms and taus to FastJets, and
	tag info accessors to Jet.

	* Add constructors from and cast operators to FastJet's PseudoJet
	object from Particle and Jet.

	* Convert inRange to not use fuzzy comparisons on closed
	intervals, providing old version as fuzzyInRange.

	2014-07-30 Andy Buckley <andy.buckley@cern.ch>

	* Remove classifier functions accepting a Particle from the PID
	inner namespace.

	2014-07-29 Andy Buckley <andy.buckley@cern.ch>

	* MC_JetAnalysis.cc: re-enable +- ratios for eta and y, now that
	YODA divide doesn't throw an exception.

	* ATLAS_2012_I1093734: fix a loop index error which led to the
	first bin value being unfilled for half the dphi plots.

	* Fix accidental passing of a GenParticle pointer as a PID code
	int in HeavyHadrons.cc. Effect limited to incorrect deductions
	about excited HF decay chains and should be small. Thanks to
	Tomasz Przedzinski for finding and reporting the issue during
	HepMC3 design work!

	2014-07-23 Andy Buckley <andy.buckley@cern.ch>

	* Fix to logspace: make sure that start and end values are exact,
	not the result of exp(log(x)).

	2014-07-16 Andy Buckley <andy.buckley@cern.ch>

	* Fix setting of library paths for doc building: Python can't
	influence the dynamic loader in its own process by setting an
	environment variable because the loader only looks at the variable
	once, when it starts.

	2014-07-02 Andy Buckley <andy.buckley@cern.ch>

	* rivet-cmphistos now uses the generic yoda.read() function rather
	than readYODA() -- AIDA files can also be compared and plotted
	directly now.

	2014-06-24 Andy Buckley <andy.buckley@cern.ch>

	* Add stupid missing <string> include and std:: prefix in Rivet.hh

	2014-06-20 Holger Schulz <hschulz@physik.hu-berlin.de>

	* bin/make-plots: Automatic generation of minor xtick labels if LogX is requested
	but data resides e.g. in [200, 700]. Fixes m_12 plots of, e.g.
	ATLAS_2010_S8817804

	2014-06-17 David Grellscheid <David.Grellscheid@durham.ac.uk>

	* pyext/rivet/Makefile.am: 'make distcheck' and out-of-source
	builds should work now.

	2014-06-10 Andy Buckley <andy.buckley@cern.ch>

	* Fix use of the install command for bash completion installation on Macs.

	2014-06-07 Andy Buckley <andy.buckley@cern.ch>

	* Removing direct includes of MathUtils.hh and others from analysis code files.

	2014-06-02 Andy Buckley <andy.buckley@cern.ch>

	* Rivet 2.1.2 release!

	2014-05-30 Andy Buckley <andy.buckley@cern.ch>

	* Using Particle absrap(), abseta() and abspid() where automatic conversion was feasible.

	* Adding a few extra kinematics mappings to ParticleBase.

	* Adding p3() accessors to the 3-momentum on FourMomentum, Particle, and Jet.

	* Using Jet and Particle kinematics methods directly (without momentum()) where possible.

	* More tweaks to make-plots 2D histo parsing behaviour.

	2014-05-30 Holger Schulz <hschulz@physik.hu-berlin.de>

	* Actually fill the XQ 2D histo, .plot decorations.

	* Have make-plots produce colourmaps using YODA_3D_SCATTER
	objects. Remove the grid in colourmaps.

	* Some tweaks for the SFM analysis, trying to contact Martin Wunsch
	who did the unfolding back then.

	2014-05-29 Holger Schulz <hschulz@physik.hu-berlin.de>

	* Re-enable 2D histo in MC_PDFS

	2014-05-28 Andy Buckley <andy.buckley@cern.ch>

	* Updating analysis and project routines to use Particle::pid() by
	preference to Particle::pdgId(), and Particle::abspid() by
	preference to abs(Particle::pdgId()), etc.

	* Adding interfacing of smart pointer types and booking etc. for
	YODA 2D histograms and profiles.

	* Improving ParticleIdUtils and ParticleUtils functions based on
	merging of improved function collections from MCUtils, and
	dropping the compiled ParticleIdUtils.cc file.

	2014-05-27 Andy Buckley <andy.buckley@cern.ch>

	* Adding CMS_2012_I1090423 (dijet angular distributions),
	CMS_2013_I1256943 (Zbb xsec and angular correlations),
	CMS_2013_I1261026 (jet and UE properties vs. Nch) and
	D0_2000_I499943 (bbbar production xsec and angular correlations).

	2014-05-26 Andy Buckley <andy.buckley@cern.ch>

	* Fixing a bug in plot file handling, and adding a texpand()
	routine to rivet.util, to be used to expand some 'standard'
	physics TeX macros.

	* Adding ATLAS_2012_I1124167 (min bias event shapes),
	ATLAS_2012_I1203852 (ZZ cross-section), and ATLAS_2013_I1190187
	(WW cross-section) analyses.

	2014-05-16 Andy Buckley <andy.buckley@cern.ch>

	* Adding any(iterable, fn) and all(iterable, fn) template functions for convenience.

	2014-05-15 Holger Schulz <holger.schulz@cern.ch>

	* Fix some bugs in identified hadron PIDs in OPAL_1998_S3749908.

	2014-05-13 Andy Buckley <andy.buckley@cern.ch>

	* Writing out [UNVALIDATED], [PRELIMINARY], etc. in the
	--list-analyses output if analysis is not VALIDATED.

	2014-05-12 Andy Buckley <andy.buckley@cern.ch>

	* Adding CMS_2013_I1265659 colour coherence analysis.

	2014-05-07 Andy Buckley <andy.buckley@cern.ch>

	* Bug fixes in CMS_2013_I1209721 from Giulio Lenzi.

	* Fixing compiler warnings from clang, including one which
	indicated a misapplied cut bug in CDF_2006_S6653332.

	2014-05-05 Andy Buckley <andy.buckley@cern.ch>

	* Fix missing abs() in Particle::abspid()!!!!

	2014-04-14 Andy Buckley <andy.buckley@cern.ch>

	* Adding the namespace protection workaround for Boost described
	at http://www.boost.org/doc/libs/1_55_0/doc/html/foreach.html

	2014-04-13 Andy Buckley <andy.buckley@cern.ch>

	* Adding a rivet.pc template file and installation rule for pkg-config to use.

	* Updating data/refdata/ALEPH_2001_S4656318.yoda to corrected version in HepData.

	2014-03-27 Andy Buckley <andy.buckley@cern.ch>

	* Flattening PNG output of make-plots (i.e. no transparency) and other tweaks.

	2014-03-23 Andy Buckley <andy.buckley@cern.ch>

	* Renaming the internal meta-particle class in DressedLeptons (and
	exposed in the W/ZFinders) from ClusteredLepton to DressedLepton
	for consistency with the change in name of its containing class.

	* Removing need for cmake and unportable yaml-cpp trickery by
	using libtool to build an embedded symbol-mangled copy of yaml-cpp
	rather than trying to mangle and build direct from the tarball.

	2014-03-10 Andy Buckley <andy.buckley@cern.ch>

	* Rivet 2.1.1 release.

	2014-03-07 Andy Buckley <andy.buckley@cern.ch>

	* Adding ATLAS multilepton search (no ref data file), ATLAS_2012_I1204447.

	2014-03-05 Andy Buckley <andy.buckley@cern.ch>

	* Also renaming Breit-Wigner functions to cdfBW, invcdfBW and bwspace.

	* Renaming index_between() to the more Rivety binIndex(), since that's the only real use of such a function... plus a bit of SFINAE type relaxation trickery.

	2014-03-04 Andy Buckley <andy.buckley@cern.ch>

	* Adding programmatic access to final histograms via AnalysisHandler::getData().

	* Adding CMS 4 jet correlations analysis, CMS_2013_I1273574.

	* Adding CMS W + 2 jet double parton scattering analysis, CMS_2013_I1272853.

	* Adding ATLAS isolated diphoton measurement, ATLAS_2012_I1199269.

	* Improving the index_between function so the numeric types don't
	have to exactly match.

	* Adding better momentum comparison functors and sortBy, sortByX
	functions to use them easily on containers of Particle, Jet, and
	FourMomentum.

	2014-02-10 Andy Buckley <andy.buckley@cern.ch>

	* Removing duplicate and unused ParticleBase sorting functors.

	* Removing unused HT increment and units in ATLAS_2012_I1180197 (unvalidated SUSY).

	* Fixing photon isolation logic bug in CMS_2013_I1258128 (Z rapidity).

	* Replacing internal uses of #include Rivet/Rivet.hh with
	Rivet/Config/RivetCommon.hh, removing the MAXRAPIDITY const, and
	repurposing Rivet/Rivet.hh as a convenience include for external
	API users.

	* Adding isStable, children, allDescendants, stableDescendants,
	and flightLength functions to Particle.

	* Replacing Particle and Jet deltaX functions with generic ones on
	ParticleBase, and adding deltaRap variants.

	* Adding a Jet.fhh forward declaration header, including fastjet::PseudoJet.

	* Adding a RivetCommon.hh header to allow Rivet.hh to be used externally.

	* Fixing HeavyHadrons to apply pT cuts if specified.

	2014-02-06 Andy Buckley <andy.buckley@cern.ch>

	* 2.1.0 release!

	2014-02-05 Andy Buckley <andy.buckley@cern.ch>

	* Protect against invalid prefix value if the --prefix configure option is unused.

	2014-02-03 Andy Buckley <andy.buckley@cern.ch>

	* Adding the ATLAS_2012_I1093734 fwd-bwd / azimuthal minbias correlations analysis.

	* Adding the LHCB_2013_I1208105 forward energy flow analysis.

	2014-01-31 Andy Buckley <andy.buckley@cern.ch>

	* Checking the YODA minimum version in the configure script.

	* Fixing the JADE_OPAL analysis ycut values to the midpoints,
	thanks to information from Christoph Pahl / Stefan Kluth.

	2014-01-29 Andy Buckley <andy.buckley@cern.ch>

	* Removing unused/overrestrictive Isolation* headers.

	2014-01-27 Andy Buckley <andy.buckley@cern.ch>

	* Re-bundling yaml-cpp, now built as a mangled static lib based on
	the LHAPDF6 experience.

	* Throw a UserError rather than an assert if AnalysisHandler::init
	is called more than once.

	2014-01-25 David Grellscheid <david.grellscheid@durham.ac.uk>

	* src/Core/Cuts.cc: New Cuts machinery, already used in FinalState.
	Old-style "mineta, maxeta, minpt" constructors kept around for ease of
	transition. Minimal set of convenience functions available, like EtaIn(),
	should be expanded as needed.

	2014-01-22 Andy Buckley <andy.buckley@cern.ch>

	* configure.ac: Remove opportunistic C++11 build, until this
	becomes mandatory (in version 2.2.0?). Anyone who wants C++11 can
	explicitly set the CXXFLAGS (and DYLDFLAGS for pre-Mavericks Macs)

	-2014-01-21 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2014-01-21 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* src/Core/Analysis.cc: Fixed bug in Analysis::isCompatible where
	an 'abs' was left out when checking that beam energes does not
	differ by more than 1GeV.

	* src/Analyses/CMS_2011_S8978280.cc: Fixed checking of beam energy
	and booking corresponding histograms.

	2013-12-19 Andy Buckley <andy.buckley@cern.ch>

	* Adding pid() and abspid() methods to Particle.

	* Adding hasCharm and hasBottom methods to Particle.

	* Adding a sorting functor arg version of the ZFinder::constituents() method.

	* Adding pTmin cut accessors to HeavyHadrons.

	* Tweak to the WFinder constructor to place the target W (trans) mass argument last.

	2013-12-18 Andy Buckley <andy.buckley@cern.ch>

	* Adding a GenParticle* cast operator to Particle, removing the
	Particle and Jet copies of the momentum cmp functors, and general
	tidying/improvement/unification of the momentum properties of jets
	and particles.

	2013-12-17 Andy Buckley <andy.buckley@cern.ch>

	* Using SFINAE techniques to improve the math util functions.

	* Adding isNeutrino to ParticleIdUtils, and
	isHadron/isMeson/isBaryon/isLepton/isNeutrino methods to Particle.

	* Adding a FourMomentum cast operator to ParticleBase, so that
	Particle and Jet objects can be used directly as FourMomentums.

	2013-12-16 Andy Buckley <andy@duality>

	* LeptonClusters renamed to DressedLeptons.

	* Adding singular particle accessor functions to WFinder and ZFinder.

	* Removing ClusteredPhotons and converting ATLAS_2010_S8919674.

	2013-12-12 Andy Buckley <andy.buckley@cern.ch>

	* Fixing a problem with --disable-analyses (thanks to David Hall)

	* Require FastJet version 3.

	* Bumped version to 2.1.0a0

	* Adding -DNDEBUG to the default build flags, unless in --enable-debug mode.

	* Adding a special treatment of RIVET_*_PATH variables: if they
	end in :: the default search paths will not be appended. Used
	primarily to restrict the doc builds to look only inside the build
	dirs, but potentially also useful in other special circumstances.

	* Adding a definition of exec_prefix to rivet-buildplugin.

	* Adding -DNDEBUG to the default non-debug build flags.

	2013-11-27 Andy Buckley <andy.buckley@cern.ch>

	* Removing accidentally still-present no-as-needed linker flag from rivet-config.

	* Lots of analysis clean-up and migration to use new features and W/Z finder APIs.

	* More momentum method forwarding on ParticleBase and adding
	abseta(), absrap() etc. functions.

	* Adding the DEFAULT_RIVET_ANA_CONSTRUCTOR cosmetic macro.

	* Adding deltaRap() etc. function variations

	* Adding no-decay photon clustering option to WFinder and ZFinder,
	and replacing opaque bool args with enums.

	* Adding an option for ignoring photons from hadron/tau decays in LeptonClusters.

	2013-11-22 Andy Buckley <andy.buckley@cern.ch>

	* Adding Particle::fromBottom/Charm/Tau() members. LHCb were
	aready mocking this up, so it seemed sensible to add it to the
	interface as a more popular (and even less dangerous) version of
	hasAncestor().

	* Adding an empty() member to the JetAlg interface.

	2013-11-07 Andy Buckley <andy.buckley@cern.ch>

	* Adding the GSL lib path to the library path in the env scripts
	and the rivet-config --ldflags output.

	2013-10-25 Andy Buckley <andy.buckley@cern.ch>

	* 2.0.0 release!!!!!!

	2013-10-24 Andy Buckley <andy.buckley@cern.ch>

	* Supporting zsh completion via bash completion compatibility.

	2013-10-22 Andy Buckley <andy.buckley@cern.ch>

	* Updating the manual to describe YODA rather than AIDA and the new rivet-cmphistos script.

	* bin/make-plots: Adding paths to error messages in histogram combination.

	* CDF_2005_S6217184: fixes to low stats errors and final scatter plot binning.

	2013-10-21 Andy Buckley <andy.buckley@cern.ch>

	* Several small fixes in jet shape analyses, SFM_1984, etc. found
	in the last H++ validation run.

	2013-10-18 Andy Buckley <andy.buckley@cern.ch>

	* Updates to configure and the rivetenv scripts to try harder to discover YODA.

	2013-09-26 Andy Buckley <andy.buckley@cern.ch>

	* Now bundling Cython-generated files in the tarballs, so Cython
	is not a build requirement for non-developers.

	2013-09-24 Andy Buckley <andy.buckley@cern.ch>

	* Removing unnecessary uses of a momentum() indirection when
	accessing kinematic variables.

	* Clean-up in Jet, Particle, and ParticleBase, in particular
	splitting PID functions on Particle from those on PID codes, and
	adding convenience kinematic functions to ParticleBase.

	2013-09-23 Andy Buckley <andy.buckley@cern.ch>

	* Add the -avoid-version flag to libtool.

	* Final analysis histogramming issues resolved.

	2013-08-16 Andy Buckley <andy.buckley@cern.ch>

	* Adding a ConnectBins flag in make-plots, to decide whether to
	connect adjacent, gapless bins with a vertical line. Enabled by
	default (good for the step-histo default look of MC lines), but
	now rivet-cmphistos disables it for the reference data.

	2013-08-14 Andy Buckley <andy.buckley@cern.ch>

	* Making 2.0.0beta3 -- just a few remaining analysis migration
	issues remaining but it's worth making another beta since there
	were lots of framework fixes/improvements.

	2013-08-11 Andy Buckley <andy.buckley@cern.ch>

	* ARGUS_1993_S2669951 also fixed using scatter autobooking.

	* Fixing remaining issues with booking in BABAR_2007_S7266081
	using the feature below (far nicer than hard-coding).

	* Adding a copy_pts param to some Analysis::bookScatter2D methods:
	pre-setting the points with x values is sometimes genuinely
	useful.

	2013-07-26 Andy Buckley <andy.buckley@cern.ch>

	* Removed the (officially) obsolete CDF 2008 LEADINGJETS and
	NOTE_9351 underlying event analyses -- superseded by the proper
	versions of these analyses based on the final combined paper.

	* Removed the semi-demo Multiplicity projection -- only the
	EXAMPLE analysis and the trivial ALEPH_1991_S2435284 needed
	adaptation.

	2013-07-24 Andy Buckley <andy.buckley@cern.ch>

	* Adding a rejection of histo paths containing /TMP/ from the
	writeData function. Use this to handle booked temporary
	histograms... for now.

	2013-07-23 Andy Buckley <andy.buckley@cern.ch>

	* Make rivet-cmphistos _not_ draw a ratio plot if there is only one line.

	* Improvements and fixes to HepData lookup with rivet-mkanalysis.

	2013-07-22 Andy Buckley <andy.buckley@cern.ch>

	* Add -std=c++11 or -std=c++0x to the Rivet compiler flags if supported.

	* Various fixes to analyses with non-zero numerical diffs.

	2013-06-12 Andy Buckley <andy.buckley@cern.ch>

	* Adding a new HeavyHadrons projection.

	* Adding optional extra include_end args to logspace() and linspace().

	2013-06-11 Andy Buckley <andy.buckley@cern.ch>

	* Moving Rivet/RivetXXX.hh tools headers into Rivet/Tools/.

	* Adding PrimaryHadrons projection.

	* Adding particles_in/out functions on GenParticle to RivetHepMC.

	* Moved STL extensions from Utils.hh to RivetSTL.hh and tidying.

	* Tidying, improving, extending, and documenting in RivetSTL.hh.

	* Adding a #include of Logging.hh into Projection.hh, and removing
	unnecessary #includes from all Projection headers.

	2013-06-10 Andy Buckley <andy.buckley@cern.ch>

	* Moving htmlify() and detex() Python functions into rivet.util.

	* Add HepData URL for Inspire ID lookup to the rivet script.

	* Fix analyses' info files which accidentally listed the Inspire
	ID under the SpiresID metadata key.

	2013-06-07 Andy Buckley <andy.buckley@cern.ch>

	* Updating mk-analysis-html script to produce MathJax output

	* Adding a version of Analysis::removeAnalysisObject() which takes
	an AO pointer as its argument.

	* bin/rivet: Adding pandoc-based conversion of TeX summary and
	description strings to plain text on the terminal output.

	* Add MathJax to rivet-mkhtml output, set up so the .info entries should render ok.

	* Mark the OPAL 1993 analysis as UNVALIDATED: from the H++
	benchmark runs it looks nothing like the data, and there are some
	outstanding ambiguities.

	2013-06-06 Andy Buckley <andy.buckley@cern.ch>

	* Releasing 2.0.0b2 beta version.

	2013-06-05 Andy Buckley <andy.buckley@cern.ch>

	* Renaming Analysis::add() etc. to very explicit
	addAnalysisObject(), sorting out shared_pointer polymorphism
	issues via the Boost dynamic_pointer_cast, and adding a full set
	of getHisto1D(), etc. explicitly named and typed accessors,
	including ones with HepData dataset/axis ID signatures.

	* Adding histo booking from an explicit reference Scatter2D (and
	more placeholders for 2D histos / 3D scatters) and rewriting
	existing autobooking to use this.

	* Converting inappropriate uses of size_t to unsigned int in Analysis.

	* Moving Analysis::addPlot to Analysis::add() (or reg()?) and
	adding get() and remove() (or unreg()?)

	* Fixing attempted abstraction of import fallbacks in rivet.util.import_ET().

	* Removing broken attempt at histoDir() caching which led to all
	histograms being registered under the same analysis name.

	2013-06-04 Andy Buckley <andy.buckley@cern.ch>

	* Updating the Cython version requirement to 0.18

	* Adding Analysis::integrate() functions and tidying the Analysis.hh file a bit.

	2013-06-03 Andy Buckley <andy.buckley@cern.ch>

	* Adding explicit protection against using inf/nan scalefactors in
	ATLAS_2011_S9131140 and H1_2000_S4129130.

	* Making Analysis::scale noisly complain about invalid
	scalefactors.

	2013-05-31 Andy Buckley <andy.buckley@cern.ch>

	* Reducing the TeX main memory to ~500MB. Turns out that it can
	be too large with new versions of TeXLive!

	2013-05-30 Andy Buckley <andy.buckley@cern.ch>

	* Reverting bookScatter2D behaviour to never look at ref data, and
	updating a few affected analyses. This should fix some bugs with
	doubled datapoints introduced by the previous behaviour+addPoint.

	* Adding a couple of minor Utils.hh and MathUtils.hh features.

	2013-05-29 Andy Buckley <andy.buckley@cern.ch>

	* Removing Constraints.hh header.

	* Minor bugfixes and improvements in Scatter2D booking and MC_JetAnalysis.

	2013-05-28 Andy Buckley <andy.buckley@cern.ch>

	* Removing defunct HistoFormat.hh and HistoHandler.{hh,cc}

	2013-05-27 Andy Buckley <andy.buckley@cern.ch>

	* Removing includes of Logging.hh, RivetYODA.hh, and
	ParticleIdUtils.hh from analyses (and adding an include of
	ParticleIdUtils.hh to Analysis.hh)

	* Removing now-unused .fhh files.

	* Removing lots of unnecessary .fhh includes from core classes:
	everything still compiling ok. A good opportunity to tidy this up
	before the release.

	* Moving the rivet-completion script from the data dir to bin (the
	completion is for scripts in bin, and this makes development
	easier).

	* Updating bash completion scripts for YODA format and
	compare-histos -> rivet-cmphistos.

	2013-05-23 Andy Buckley <andy.buckley@cern.ch>

	* Adding Doxy comments and a couple of useful convenience functions to Utils.hh.

	* Final tweaks to ATLAS ttbar jet veto analysis (checked logic with Kiran Joshi).

	2013-05-15 Andy Buckley <andy.buckley@cern.ch>

	* Many 1.0 -> weight bugfixes in ATLAS_2011_I945498.

	* yaml-cpp v3 support re-introduced in .info parsing.

	* Lots of analysis clean-ups for YODA TODO issues.

	2013-05-13 Andy Buckley <andy.buckley@cern.ch>

	* Analysis histo booking improvements for Scatter2D, placeholders
	for 2D histos, and general tidying.

	2013-05-12 Andy Buckley <andy.buckley@cern.ch>

	* Adding configure-time differentiation between yaml-cpp API versions 3 and 5.

	2013-05-07 Andy Buckley <andy.buckley@cern.ch>

	* Converting info file reading to use the yaml-cpp 0.5.x API.

	2013-04-12 Andy Buckley <andy.buckley@cern.ch>

	* Tagging as 2.0.0b1

	2013-04-04 Andy Buckley <andy.buckley@cern.ch>

	* Removing bundling of yaml-cpp: it needs to be installed by the
	user / bootstrap script from now on.

	2013-04-03 Andy Buckley <andy.buckley@cern.ch>

	* Removing svn:external m4 directory, and converting Boost
	detection to use better boost.m4 macros.

	2013-03-22 Andy Buckley <andy.buckley@cern.ch>

	* Moving PID consts to the PID namespace and corresponding code
	updates and opportunistic clean-ups.

	* Adding Particle::fromDecay() method.

	2013-03-09 Andy Buckley <andy.buckley@cern.ch>

	* Version bump to 2.0.0b1 in anticipation of first beta release.

	* Adding many more 'popular' particle ID code named-consts and
	aliases, and updating the RapScheme enum with ETA -> ETARAP, and
	fixing affected analyses (plus other opportunistic tidying / minor
	bug-fixing).

	* Fixing a symbol misnaming in ATLAS_2012_I1119557.

	2013-03-07 Andy Buckley <andy.buckley@cern.ch>

	* Renaming existing uses of ParticleVector to the new 'Particles' type.

	* Updating util classes, projections, and analyses to deal with
	the HepMC return value changes.

	* Adding new Particle(const GenParticle*) constructor.

	* Converting Particle::genParticle() to return a const pointer
	rather than a reference, for the same reason as below (+
	consistency within Rivet and with the HepMC pointer-centric coding
	design).

	* Converting Event to use a different implementation of original
	and modified GenParticles, and to manage the memory in a more
	future-proof way. Event::genParticle() now returns a const pointer
	rather than a reference, to signal that the user is leaving the
	happy pastures of 'normal' Rivet behind.

	* Adding a Particles typedef by analogy to Jets, and in preference
	to the cumbersome ParticleVector.

	* bin/: Lots of tidying/pruning of messy/defunct scripts.

	* Creating spiresbib, util, and plotinfo rivet python module
	submodules: this eliminates lighthisto and the standalone
	spiresbib modules. Util contains convenience functions for Python
	version testing, clean ElementTree import, and process renaming,
	for primary use by the rivet-* scripts.

	* Removing defunct scripts that have been replaced/obsoleted by YODA.

	2013-03-06 Andy Buckley <andy.buckley@cern.ch>

	* Fixing doc build so that the reference histos and titles are
	~correctly documented. We may want to truncate some of the lists!

	2013-03-06 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added ATLAS_2012_I1125575 analysis

	* Converted rivet-mkhtml to yoda

	* Introduced rivet-cmphistos as yoda based replacement for compare-histos

	2013-03-05 Andy Buckley <andy.buckley@cern.ch>

	* Replacing all AIDA ref data with YODA versions.

	* Fixing the histograms entries in the documentation to be
	tolerant to plotinfo loading failures.

	* Making the findDatafile() function primarily find YODA data
	files, then fall back to AIDA. The ref data loader will use the
	appropriate YODA format reader.

	2013-02-05 David Grellscheid <David.Grellscheid@durham.ac.uk>

	* include/Rivet/Math/MathUtils.hh: added BWspace bin edge method
	to give equal-area Breit-Wigner bins

	2013-02-01 Andy Buckley <andy.buckley@cern.ch>

	* Adding an element to the PhiMapping enum and a new mapAngle(angle, mapping) function.

	* Fixes to Vector3::azimuthalAngle and Vector3::polarAngle calculation (using the mapAngle functions).

	2013-01-25 Frank Siegert <frank.siegert@cern.ch>

	* Split MC_*JETS analyses into three separate bits:
	MC_*INC (inclusive properties)
	MC_*JETS (jet properties)
	MC_*KTSPLITTINGS (kT splitting scales).

	2013-01-22 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fix TeX variable in the rivetenv scripts, especially for csh

	2012-12-21 Andy Buckley <andy.buckley@cern.ch>

	* Version 1.8.2 release!

	2012-12-20 Andy Buckley <andy.buckley@cern.ch>

	* Adding ATLAS_2012_I1119557 analysis (from Roman Lysak and Lily Asquith).

	2012-12-18 Andy Buckley <andy.buckley@cern.ch>

	* Adding TOTEM_2012_002 analysis, from Sercan Sen.

	2012-12-18 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added CMS_2011_I954992 analysis

	2012-12-17 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added CMS_2012_I1193338 analysis

	* Fixed xi cut in ATLAS_2011_I894867

	2012-12-17 Andy Buckley <andy.buckley@cern.ch>

	* Adding analysis descriptions to the HTML analysis page ToC.

	2012-12-14 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added CMS_2012_PAS_FWD_11_003 analysis

	* Added LHCB_2012_I1119400 analysis

	2012-12-12 Andy Buckley <andy.buckley@cern.ch>

	* Correction to jet acceptance in CMS_2011_S9120041, from Sercan Sen: thanks!

	2012-12-12 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added CMS_2012_PAS_QCD_11_010 analysis

	2012-12-07 Andy Buckley <andy.buckley@cern.ch>

	* Version number bump to 1.8.2 -- release approaching.

	* Rewrite of ALICE_2012_I1181770 analysis to make it a bit more sane and acceptable.

	* Adding a note on FourVector and FourMomentum that operator- and
	operator-= invert both the space and time components: use of -=
	can result in a vector with negative energy.

	* Adding particlesByRapidity and particlesByAbsRapidity to FinalState.

	2012-12-07 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added ALICE_2012_I1181770 analysis

	* Bump version to 1.8.2

	2012-12-06 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added ATLAS_2012_I1188891 analysis

	* Added ATLAS_2012_I1118269 analysis

	* Added CMS_2012_I1184941 analysis

	* Added LHCB_2010_I867355 analysis

	* Added TGraphErrors support to root2flat

	2012-11-27 Andy Buckley <andy.buckley@cern.ch>

	* Converting CMS_2012_I1102908 analysis to use YODA.

	* Adding XLabel and YLabel setting in histo/profile/scatter booking.

	2012-11-27 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fix make-plots png creation for SL5

	2012-11-23 Peter Richardson <peter.richardson@durham.ac.uk>

	* Added ATLAS_2012_CONF_2012_153 4-lepton SUSY search

	2012-11-17 Andy Buckley <andy.buckley@cern.ch>

	* Adding MC_PHOTONS by Steve Lloyd and AB, for testing general
	unisolated photon properties, especially those associated with
	charged leptons (e and mu).

	2012-11-16 Andy Buckley <andy.buckley@cern.ch>

	* Adding MC_PRINTEVENT, a convenient (but verbose!) analysis for
	printing out event details to stdout.

	2012-11-15 Andy Buckley <andy.buckley@cern.ch>

	* Removing the long-unused/defunct autopackage system.

	2012-11-15 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added LHCF_2012_I1115479 analysis
	* Added ATLAS_2011_I894867 analysis

	2012-11-14 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added CMS_2012_I1102908 analysis

	2012-11-14 Andy Buckley <andy.buckley@cern.ch>

	* Converting the argument order of logspace, clarifying the
	arguments, updating affected code, and removing Analysis::logBinEdges.

	* Merging updates from the AIDA maintenance branch up to r4002
	(latest revision for next merges is r4009).

	2012-11-11 Andy Buckley <andy.buckley@cern.ch>

	* include/Math/: Various numerical fixes to Vector3::angle and
	changing the 4 vector mass treatment to permit spacelike
	virtualities (in some cases even the fuzzy isZero assert check was
	being violated). The angle check allows a clean-up of some
	workaround code in MC_VH2BB.

	2012-10-15 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added CMS_2012_I1107658 analysis

	2012-10-11 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added CDF_2012_NOTE10874 analysis

	2012-10-04 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added ATLAS_2012_I1183818 analysis

	2012-07-17 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Cleanup and multiple fixes in CMS_2011_S9120041

	* Bugfixed in ALEPH_2004_S5765862 and ATLAS_2010_CONF_2010_049
	(thanks to Anil Pratap)

	2012-08-09 Andy Buckley <andy.buckley@cern.ch>

	* Fixing aida2root command-line help message and converting to TH*
	rather than TGraph by default.

	2012-07-24 Andy Buckley <andy.buckley@cern.ch>

	* Improvements/migrations to rivet-mkhtml, rivet-mkanalysis, and
	rivet-buildplugin.

	2012-07-17 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Add CMS_2012_I1087342

	2012-07-12 Andy Buckley <andy.buckley@cern.ch>

	* Fix rivet-mkanalysis a bit for YODA compatibility.

	2012-07-05 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Version 1.8.1!

	2012-07-05 Holger Schulz <holger.schulz@physik.hu-berlin.de>

	* Add ATLAS_2011_I945498

	2012-07-03 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Bugfix for transverse mass (thanks to Gavin Hesketh)

	2012-06-29 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Merge YODA branch into trunk. YODA is alive!!!!!!

	2012-06-26 Holger Schulz <holger.schulz@physik.hu-berlin.de>

	* Add ATLAS_2012_I1091481

	2012-06-20 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added D0_2011_I895662: 3-jet mass

	2012-04-24 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* fixed a few bugs in rivet-rmgaps

	* Added new TOTEM dN/deta analysis

	2012-03-19 Andy Buckley <andy.buckley@cern.ch>

	* Version 1.8.0!

	* src/Projections/UnstableFinalState.cc: Fix compiler warning.

	* Version bump for testing: 1.8.0beta1.

	* src/Core/AnalysisInfo.cc: Add printout of YAML parser exception error messages to aid debugging.

	* bin/Makefile.am: Attempt to fix rivet-nopy build on SLC5.

	* src/Analyses/LHCB_2010_S8758301.cc: Add two missing entries to the PDGID -> lifetime map.

	* src/Projections/UnstableFinalState.cc: Extend list of vetoed particles to include reggeons.

	2012-03-16 Andy Buckley <andy.buckley@cern.ch>

	* Version change to 1.8.0beta0 -- nearly ready for long-awaited release!

	* pyext/setup.py.in: Adding handling for the YAML library: fix for
	Genser build from Anton Karneyeu.

	* src/Analyses/LHCB_2011_I917009.cc: Hiding lifetime-lookup error
	message if the offending particle is not a hadron.

	* include/Rivet/Math/MathHeader.hh: Using unnamespaced std::isnan
	and std::isinf as standard.

	2012-03-16 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Improve default plot behaviour for 2D histograms

	2012-03-15 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Make ATLAS_2012_I1084540 less verbose, and general code
	cleanup of that analysis.

	* New-style plugin hook in ATLAS_2011_I926145,
	ATLAS_2011_I944826 and ATLAS_2012_I1084540

	* Fix compiler warnings in ATLAS_2011_I944826 and CMS_2011_S8973270

	* CMS_2011_S8941262: Weights are double, not int.

	* disable inRange() tests in test/testMath.cc until we have a proper
	fix for the compiler warnings we see on SL5.

	2012-03-07 Andy Buckley <andy.buckley@cern.ch>

	* Marking ATLAS_2011_I919017 as VALIDATED (this should have
	happened a long time ago) and adding more references.

	2012-02-28 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* lighthisto.py: Caching for re.compile(). This speeds up aida2flat
	and flat2aida by more than an order of magnitude.

	2012-02-27 Andy Buckley <andy.buckley@cern.ch>

	* doc/mk-analysis-html: Adding more LaTeX/text -> HTML conversion
	replacements, including better <,> handling.

	2012-02-26 Andy Buckley <andy.buckley@cern.ch>

	* Adding CMS_2011_S8973270, CMS_2011_S8941262, CMS_2011_S9215166,
	CMS_QCD_10_024, from CMS.

	* Adding LHCB_2011_I917009 analysis, from Alex Grecu.

	* src/Core/Analysis.cc, include/Rivet/Analysis.hh: Add a numeric-arg version of histoPath().

	2012-02-24 Holger Schulz <holger.schulz@physik.hu-berlin.de>

	* Adding ATLAS Ks/Lambda analysis.

	2012-02-20 Andy Buckley <andy.buckley@cern.ch>

	* src/Analyses/ATLAS_2011_I925932.cc: Using new overflow-aware
	normalize() in place of counters and scale(..., 1/count)

	2012-02-14 Andy Buckley <andy.buckley@cern.ch>

	* Splitting MC_GENERIC to put the PDF and PID plotting into
	MC_PDFS and MC_IDENTIFIED respectively.

	* Renaming MC_LEADINGJETS to MC_LEADJETUE.

	2012-02-14 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* DELPHI_1996_S3430090 and ALEPH_1996_S3486095:
	fix rapidity vs {Thrust,Sphericity}-axis.

	2012-02-14 Andy Buckley <andy.buckley@cern.ch>

	* bin/compare-histos: Don't attempt to remove bins from MC histos
	where they aren't found in the ref file, if the ref file is not
	expt data, or if the new --no-rmgapbins arg is given.

	* bin/rivet: Remove the conversion of requested analysis names to
	upper-case: mixed-case analysis names will now work.

	2012-02-14 Frank Siegert <frank.siegert@cern.ch>

	* Bugfixes and improvements for MC_TTBAR:
	- Avoid assert failure with logspace starting at 0.0
	- Ignore charged lepton in jet finding (otherwise jet multi is always
	+1).
	- Add some dR/deta/dphi distributions as noted in TODO
	- Change pT plots to logspace as well (to avoid low-stat high pT bins)

	2012-02-10 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* rivet-mkhtml -c option now has the semantics of a .plot
	file. The contents are appended to the dat output by
	compare-histos.

	2012-02-09 David Grellscheid <david.grellscheid@durham.ac.uk>

	* Fixed broken UnstableFS behaviour

	2012-01-25 Frank Siegert <frank.siegert@cern.ch>

	* Improvements in make-plots:
	- Add PlotTickLabels and RatioPlotTickLabels options (cf.
	make-plots.txt)
	- Make ErrorBars and ErrorBands non-exclusive (and change
	their order, such that Bars are on top of Bands)

	2012-01-25 Holger Schulz <holger.schulz@physik.hu-berlin.de>

	* Add ATLAS diffractive gap analysis

	2012-01-23 Andy Buckley <andy.buckley@cern.ch>

	* bin/rivet: When using --list-analyses, the analysis summary is
	now printed out when log level is <= INFO, rather than < INFO.
	The effect on command line behaviour is that useful identifying
	info is now printed by default when using --list-analyses, rather
	than requiring --list-analyses -v. To get the old behaviour,
	e.g. if using the output of rivet --list-analyses for scripting,
	now use --list-analyses -q.

	2012-01-22 Andy Buckley <andy.buckley@cern.ch>

	* Tidying lighthisto, including fixing the order in which +- error
	values are passed to the Bin constructor in fromFlatHisto.

	2012-01-16 Frank Siegert <frank.siegert@cern.ch>

	* Bugfix in ATLAS_2012_I1083318: Include non-signal neutrinos in
	jet clustering.

	* Add first version of ATLAS_2012_I1083318 (W+jets). Still
	UNVALIDATED until final happiness with validation plots arises and
	data is in Hepdata.

	* Bugfix in ATLAS_2010_S8919674: Really use neutrino with highest
	pT for Etmiss. Doesn't seem to make very much difference, but is
	more correct in principle.

	2012-01-16 Peter Richardson <peter.richardson@durham.ac.uk>

	* Fixes to ATLAS_20111_S9225137 to include reference data

	2012-01-13 Holger Schulz <holger.schulz@physik.hu-berlin.de>

	* Add ATLAS inclusive lepton analysis

	2012-01-12 Hendrik Hoeth <hendrik.hoeth@durham.ac.uk>

	* Font selection support in rivet-mkhtml

	2012-01-11 Peter Richardson <peter.richardson@durham.ac.uk>

	* Added pi0 to list of particles.

	2012-01-11 Andy Buckley <andy.buckley@cern.ch>

	* Removing references to Boost random numbers.

	2011-12-30 Andy Buckley <andy.buckley@cern.ch>

	* Adding a placeholder rivet-which script (not currently
	installed).

	* Tweaking to avoid a very time-consuming debug printout in
	compare-histos with the -v flag, and modifying the Rivet env vars
	in rivet-mkhtml before calling compare-histos to eliminate
	problems induced by relative paths (i.e. "." does not mean the
	same thing when the directory is changed within the script).

	2011-12-12 Andy Buckley <andy.buckley@cern.ch>

	* Adding a command line completion function for rivet-mkhtml.

	2011-12-12 Frank Siegert <frank.siegert@cern.ch>

	* Fix for factor of 2.0 in normalisation of CMS_2011_S9086218

	* Add --ignore-missing option to rivet-mkhtml to ignore non-existing
	AIDA files.

	2011-12-06 Andy Buckley <andy.buckley@cern.ch>

	* Include underflow and overflow bins in the normalisation when
	calling Analysis::normalise(h)

	2011-11-23 Andy Buckley <andy.buckley@cern.ch>

	* Bumping version to 1.8.0alpha0 since the Jet interface changes
	are quite a major break with backward compatibility (although the
	vast majority of analyses should be unaffected).

	* Removing crufty legacy stuff from the Jet class -- there is
	never any ambiguity between whether Particle or FourMomentum
	objects are the constituents now, and the jet 4-momentum is set
	explicitly by the jet alg so that e.g. there is no mismatch if the
	FastJet pt recombination scheme is used.

	* Adding default do-nothing implementations of Analysis::init()
	and Analysis::finalize(), since it is possible for analysis
	implementations to not need to do anything in these methods, and
	forcing analysis authors to write do-nothing boilerplate code is
	not "the Rivet way"!

	2011-11-19 Andy Buckley <andy.buckley@cern.ch>

	* Adding variant constructors to FastJets with a more natural
	Plugin* argument, and decrufting the constructor implementations a
	bit.

	* bin/rivet: Adding a more helpful error message if the rivet
	module can't be loaded, grouping the option parser options,
	removing the -A option (this just doesn't seem useful anymore),
	and providing a --pwd option as a shortcut to append "." to the
	search path.

	2011-11-18 Andy Buckley <andy.buckley@cern.ch>

	* Adding a guide to compiling a new analysis template to the
	output message of rivet-mkanalysis.

	2011-11-11 Andy Buckley <andy.buckley@cern.ch>

	* Version 1.7.0 release!

	* Protecting the OPAL 2004 analysis against NaNs in the
	hemispheres projection -- I can't track the origin of these and
	suspect some occasional memory corruption.

	2011-11-09 Andy Buckley <andy@insectnation.org>

	* Renaming source files for EXAMPLE and
	PDG_HADRON_MULTIPLICITIES(_RATIOS) analyses to match the analysis
	names.

	* Cosmetic fixes in ATLAS_2011_S9212183 SUSY analysis.

	* Adding new ATLAS W pT analysis from Elena Yatsenko (slightly adapted).

	2011-10-20 Frank Siegert <frank.siegert@cern.ch>

	* Extend API of W/ZFinder to allow for specification of input final
	state in which to search for leptons/photons.

	2011-10-19 Andy Buckley <andy@insectnation.org>

	* Adding new version of LHCB_2010_S8758301, based on submission
	from Alex Grecu. There is some slightly dodgy-looking GenParticle*
	fiddling going on, but apparently it's necessary (and hopefully robust).

	2011-10-17 Andy Buckley <andy@insectnation.org>

	* bin/rivet-nopy linker line tweak to make compilation work with
	GCC 4.6 (-lHepMC has to be explicitly added for some reason).

	2011-10-13 Frank Siegert <frank.siegert@cern.ch>

	* Add four CMS QCD analyses kindly provided by CMS.

	2011-10-12 Andy Buckley <andy@insectnation.org>

	* Adding a separate test program for non-matrix/vector math
	functions, and adding a new set of int/float literal arg tests for
	the inRange functions in it.

	* Adding a jet multiplicity plot for jets with pT > 30 GeV to
	MC_TTBAR.

	2011-10-11 Andy Buckley <andy@insectnation.org>

	* Removing SVertex.

	2011-10-11 James Monk <jmonk@cern.ch>

	* root2flat was missing the first bin (plus spurious last bin)

	* My version of bash does not understand the pipe syntax \|& in rivet-buildplugin

	2011-09-30 James Monk <jmonk@cern.ch>

	* Fix bug in ATLAS_2010_S8817804 that misidentified the akt4 jets
	as akt6

	2011-09-29 Andy Buckley <andy@insectnation.org>

	* Converting FinalStateHCM to a slightly more general
	DISFinalState.

	2011-09-26 Andy Buckley <andy@insectnation.org>

	* Adding a default libname argument to rivet-buildplugin. If the
	first argument doesn't have a .so library suffix, then use
	RivetAnalysis.so as the default.

	2011-09-19 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* make-plots: Fixing regex for \physicscoor. Adding "FrameColor"
	option.

	2011-09-17 Andy Buckley <andy@insectnation.org>

	* Improving interactive metadata printout, by not printing
	headings for missing info.

	* Bumping the release number to 1.7.0alpha0, since with these
	SPIRES/Inspire changes and the MissingMomentum API change we need
	more than a minor release.

	* Updating the mkanalysis, BibTeX-grabbing and other places that
	care about analysis SPIRES IDs to also be able to handle the new
	Inspire system record IDs. The missing link is getting to HepData
	from an Inspire code...

	* Using the .info file rather than an in-code declaration to
	specify that an analysis needs cross-section information.

	* Adding Inspire support to the AnalysisInfo and Analysis
	interfaces. Maybe we can find a way to combine the two,
	e.g. return the SPIRES code prefixed with an "S" if no Inspire ID
	is available...

	2011-09-17 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added ALICE_2011_S8909580 (strange particle production at 900 GeV)

	* Feed-down correction in ALICE_2011_S8945144

	2011-09-16 Andy Buckley <andy@insectnation.org>

	* Adding ATLAS track jet analysis, modified from the version
	provided by Seth Zenz: ATLAS_2011_I919017. Note that this analysis
	is currently using the Inspire ID rather than the Spires one:
	we're clearly going to have to update the API to handle Inspire
	codes, so might as well start now...

	2011-09-14 Andy Buckley <andy@insectnation.org>

	* Adding the ATLAS Z pT measurement at 7 TeV (ATLAS_2011_S9131140)
	and an MC analysis for VH->bb events (MC_VH2BB).

	2011-09-12 Andy Buckley <andy@insectnation.org>

	* Removing uses of getLog, cout, cerr, and endl from all standard
	analyses and projections, except in a very few special cases.

	2011-09-10 Andy Buckley <andy@insectnation.org>

	* Changing the behaviour and interface of the MissingMomentum
	projection to calculate vector ET correctly. This was previously
	calculated according to the common definition of -E*sin(theta) of
	the summed visible 4-momentum in the event, but that is incorrect
	because the timelike term grows monotonically. Instead, transverse
	2-vectors of size ET need to be constructed for each visible
	particle, and vector-summed in the transverse plane.

	The rewrite of this behaviour made it opportune to make an API
	improvement: the previous method names scalarET/vectorET() have
	been renamed to scalar/vectorEt() to better match the Rivet
	FourMomentum::Et() method, and MissingMomentum::vectorEt() now
	returns a Vector3 rather than a double so that the transverse
	missing Et direction is also available.

	Only one data analysis has been affected by this change in
	behaviour: the D0_2004_S5992206 dijet delta(phi) analysis. It's
	expected that this change will not be very significant, as it is
	a veto on significant missing ET to reduce non-QCD
	contributions. MC studies using this analysis ~always run with QCD
	events only, so these contributions should be small. The analysis
	efficiency may have been greatly improved, as fewer events will
	now fail the missing ET veto cut.

	* Add sorting of the ParticleVector returned by the ChargedLeptons
	projection.

	* configure.ac: Adding a check to make sure that no-one tries to
	install into --prefix=$PWD.

	2011-09-04 Andy Buckley <andy@insectnation.org>

	* lighthisto fixes from Christian Roehr.

	2011-08-26 Andy Buckley <andy@insectnation.org>

	* Removing deprecated features: the setBeams(...) method on
	Analysis, the MaxRapidity constant, the split(...) function, the
	default init() method from AnalysisHandler and its test, and the
	deprecated TotalVisibleMomentum and PVertex projections.

	2011-08-23 Andy Buckley <andy@insectnation.org>

	* Adding a new DECLARE_RIVET_PLUGIN wrapper macro to hide the
	details of the plugin hook system from analysis authors. Migration
	of all analyses and the rivet-mkanalysis script to use this as the
	standard plugin hook syntax.

	* Also call the --cflags option on root-config when using the
	--root option with rivet-biuldplugin (thanks to Richard Corke for
	the report)

	2011-08-23 Frank Siegert <frank.siegert@cern.ch>

	* Added ATLAS_2011_S9126244
	* Added ATLAS_2011_S9128077

	2011-08-23 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added ALICE_2011_S8945144

	* Remove obsolete setBeams() from the analyses

	* Update CMS_2011_S8957746 reference data to the official numbers

	* Use Inspire rather than Spires.

	2011-08-19 Frank Siegert <frank.siegert@cern.ch>

	* More NLO parton level generator friendliness: Don't crash or fail when
	there are no beam particles.

	* Add --ignore-beams option to skip compatibility check.

	2011-08-09 David Mallows <dave.mallows@gmail.com>

	* Fix aida2flat to ignore empty dataPointSet

	2011-08-07 Andy Buckley <andy@insectnation.org>

	* Adding TEXINPUTS and LATEXINPUTS prepend definitions to the
	variables provided by rivetenv.(c)sh. A manual setting of these
	variables that didn't include the Rivet TEXMFHOME path was
	breaking make-plots on lxplus, presumably since the system LaTeX
	packages are so old there.

	2011-08-02 Frank Siegert <frank.siegert@cern.ch>

	Version 1.6.0 release!

	2011-08-01 Frank Siegert <frank.siegert@cern.ch>

	* Overhaul of the WFinder and ZFinder projections, including a change
	of interface. This solves potential problems with leptons which are not
	W/Z constituents being excluded from the RemainingFinalState.

	2011-07-29 Andy Buckley <andy@insectnation.org>

	* Version 1.5.2 release!

	* New version of aida2root from James Monk.

	2011-07-29 Frank Siegert <frank.siegert@cern.ch>

	* Fix implementation of --config file option in make-plots.

	2011-07-27 David Mallows <dave.mallows@gmail.com>

	* Updated MC_TTBAR.plot to reflect updated analysis.

	2011-07-25 Andy Buckley <andy@insectnation.org>

	* Adding a useTransverseMass flag method and implementation to
	InvMassFinalState, and using it in the WFinder, after feedback
	from Gavin Hesketh. This was the neatest way I could do it :S Some
	other tidying up happened along the way.

	* Adding transverse mass massT and massT2 methods and functions
	for FourMomentum.

	2011-07-22 Frank Siegert <frank.siegert@cern.ch>

	* Added ATLAS_2011_S9120807

	* Add two more observables to MC_DIPHOTON and make its isolation cut
	more LHC-like

	* Add linear photon pT histo to MC_PHOTONJETS

	2011-07-20 Andy Buckley <andy@insectnation.org>

	* Making MC_TTBAR work with semileptonic ttbar events and generally
	tidying the code.

	2011-07-19 Andy Buckley <andy@insectnation.org>

	* Version bump to 1.5.2.b01 in preparation for a release in the
	very near future.

	2011-07-18 David Mallows <dave.mallows@gmail.com>

	* Replaced MC_TTBAR: Added t,tbar reconstruction. Not yet working.

	2011-07-18 Andy Buckley <andy@insectnation.org>

	* bin/rivet-buildplugin.in: Pass the AM_CXXFLAGS
	variable (including the warning flags) to the C++ compiler when
	building user analysis plugins.

	* include/LWH/DataPointSet.h: Fix accidental setting of errorMinus
	= scalefactor * error_Plus_. Thanks to Anton Karneyeu for the bug
	report!

	2011-07-18 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added CMS_2011_S8884919 (charged hadron multiplicity in NSD
	events corrected to pT>=0).

	* Added CMS_2010_S8656010 and CMS_2010_S8547297 (charged
	hadron pT and eta in NSD events)

	* Added CMS_2011_S8968497 (chi_dijet)

	* Added CMS_2011_S8978280 (strangeness)

	2011-07-13 Andy Buckley <andy@insectnation.org>

	* Rivet PDF manual updates, to not spread disinformation about
	bootstrapping a Genser repo.

	2011-07-12 Andy Buckley <andy@insectnation.org>

	* bin/make-plots: Protect property reading against unstripped \r
	characters from DOS newlines.

	* bin/rivet-mkhtml: Add a -M unmatch regex flag (note that these
	are matching the analysis path rather than individual histos on
	this script), and speed up the initial analysis identification and
	selection by avoiding loops of regex comparisons for repeats of
	strings which have already been analysed.

	* bin/compare-histos: remove the completely (?) unused histogram
	list, and add -m and -M regex flags, as for aida2flat and
	flat2aida.

	2011-06-30 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* fix fromFlat() in lighthistos: It would ignore histogram paths
	before.

	* flat2aida: preserve histogram order from .dat files

	2011-06-27 Andy Buckley <andy@insectnation.org>

	* pyext/setup.py.in: Use CXXFLAGS and LDFLAGS safely in the Python
	extension build, and improve the use of build/src directory
	arguments.

	2011-06-23 Andy Buckley <andy@insectnation.org>

	* Adding a tentative rivet-updateanalyses script, based on
	lhapdf-getdata, which will download new analyses as requested. We
	could change our analysis-providing behaviour a bit to allow this
	sort of delivery mechanism to be used as the normal way of getting
	analysis updates without us having to make a whole new Rivet
	release. It is nice to be able to identify analyses with releases,
	though, for tracking whether bugs have been addressed.

	2011-06-10 Frank Siegert <frank.siegert@cern.ch>

	* Bugfixes in WFinder.

	2011-06-10 Andy Buckley <andy@insectnation.org>

	* Adding \physicsxcoor and \physicsycoor treatment to make-plots.

	2011-06-06 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Allow for negative cross-sections. NLO tools need this.

	* make-plots: For RatioPlotMode=deviation also consider the MC
	uncertainties, not just data.

	2011-06-04 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Add support for goodness-of-fit calculations to make-plots.
	The results are shown in the legend, and one histogram can
	be selected to determine the color of the plot margin. See
	the documentation for more details.

	2011-06-04 Andy Buckley <andy@insectnation.org>

	* Adding auto conversion of Histogram2D to DataPointSets in the
	AnalysisHandler _normalizeTree method.

	2011-06-03 Andy Buckley <andy@insectnation.org>

	* Adding a file-weight feature to the Run object, which will
	optionally rescale the weights in the provided HepMC files. This
	should be useful for e.g. running on multiple differently-weighted
	AlpGen HepMC files/streams. The new functionality is used by the
	rivet command via an optional weight appended to the filename with
	a colon delimiter, e.g. "rivet fifo1.hepmc fifo2.hepmc:2.31"

	2011-06-01 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Add BeamThrust projection

	2011-05-31 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fix LIBS for fastjet-3.0

	* Add basic infrastructure for Taylor plots in make-plots

	* Fix OPAL_2004_S6132243: They are using charged+neutral.

	* Release 1.5.1

	2011-05-22 Andy Buckley <andy@insectnation.org>

	* Adding plots of stable and decayed PID multiplicities to
	MC_GENERIC (useful for sanity-checking generator setups).

	* Removing actually-unused ProjectionApplier.fhh forward
	declaration header.

	2011-05-20 Andy Buckley <andy@insectnation.org>

	* Removing import of ipython shell from rivet-rescale, having just
	seen it throw a multi-coloured warning message on a student's
	lxplus Rivet session!

	* Adding support for the compare-histos --no-ratio flag when using
	rivet-mkhtml. Adding --rel-ratio, --linear, etc. is an exercise
	for the enthusiast ;-)

	2011-05-10 Andy Buckley <andy@insectnation.org>

	* Internal minor changes to the ProjectionHandler and
	ProjectionApplier interfaces, in particular changing the
	ProjectionHandler::create() function to be called getInstance and
	to return a reference rather than a pointer. The reference change
	is to make way for an improved singleton implementation, which
	cannot yet be used due to a bug in projection memory
	management. The code of the improved singleton is available, but
	commented out, in ProjectionManager.hh to allow for easier
	migration and to avoid branching.

	2011-05-08 Andy Buckley <andy@insectnation.org>

	* Extending flat2aida to be able to read from and write to
	stdin/out as for aida2flat, and also eliminating the internal
	histo parsing representation in favour of the one in
	lighthisto. lighthisto's fromFlat also needed a bit of an
	overhaul: it has been extended to parse each histo's chunk of
	text (including BEGIN and END lines) in fromFlatHisto, and for
	fromFlat to parse a collection of histos from a file, in keeping
	with the behaviour of fromDPS/fromAIDA. Merging into Professor is
	now needed.

	* Extending aida2flat to have a better usage message, to accept
	input from stdin for command chaining via pipes, and to be a bit
	more sensibly internally structured (although it also now has to
	hold all histos in memory before writing out -- that shouldn't be
	a problem for anything other than truly huge histo files).

	2011-05-04 Andy Buckley <andy@insectnation.org>

	* compare-histos: If using --mc-errs style, prefer dotted and
	dashdotted line styles to dashed, since dashes are often too long
	to be distinguishable from solid lines. Even better might be to
	always use a solid line for MC errs style, and to add more colours.

	* rivet-mkhtml: use a no-mc-errors drawing style by default,
	to match the behaviour of compare-histos, which it calls. The
	--no-mc-errs option has been replaced with an --mc-errs option.

	2011-05-04 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Ignore duplicate files in compare-histos.

	2011-04-25 Andy Buckley <andy@insectnation.org>

	* Adding some hadron-specific N and sumET vs. \|eta\| plots to MC_GENERIC.

	* Re-adding an explicit attempt to get the beam particles, since
	HepMC's IO_HERWIG seems to not always set them even though it's
	meant to.

	2011-04-19 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added ATLAS_2011_S9002537 W asymmetry analysis

	2011-04-14 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* deltaR, deltaPhi, deltaEta now available in all combinations of
	FourVector, FourMomentum, Vector3, doubles. They also accept jets
	and particles as arguments now.

	2011-04-13 David Grellscheid <david.grellscheid@durham.ac.uk>

	* added ATLAS 8983313: 0-lepton BSM

	2011-04-01 Andy Buckley <andy@insectnation.org>

	* bin/rivet-mkanalysis: Don't try to download SPIRES or HepData
	info if it's not a standard analysis (i.e. if the SPIRES ID is not
	known), and make the default .info file validly parseable by YAML,
	which was an unfortunate gotcha for anyone writing a first
	analysis.

	2011-03-31 Andy Buckley <andy@insectnation.org>

	* bin/compare-histos: Write more appropriate ratio plot labels
	when not comparing to data, and use the default make-plots labels
	when comparing to data.

	* bin/rivet-mkhtml: Adding a timestamp to the generated pages, and
	a -t/--title option to allow setting the main HTML page title on
	the command line: otherwise it becomes impossible to tell these
	pages apart when you have a lot of them, except by URL!

	2011-03-24 Andy Buckley <andy@insectnation.org>

	* bin/aida2flat: Adding a -M option to exclude histograms whose
	paths match a regex. Writing a negative lookahead regex with
	positive matching was far too awkward!

	-2011-03-18 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2011-03-18 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* src/Core/AnalysisHandler.cc (AnalysisHandler::removeAnalysis):
	Fixed strange shared pointer assignment that caused seg-fault.

	2011-03-13 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* filling of functions works now in a more intuitive way (I hope).

	2011-03-09 Andy Buckley <andy@insectnation.org>

	* Version 1.5.0 release!

	2011-03-08 Andy Buckley <andy@insectnation.org>

	* Adding some extra checks for external packages in make-plots.

	2011-03-07 Andy Buckley <andy@insectnation.org>

	* Changing the accuracy of the beam energy checking to 1%, to make
	the UI a bit more forgiving. It's still best to specify exactly the right
	energy of course!

	2011-03-01 Andy Buckley <andy@insectnation.org>

	* Adding --no-plottitle to compare-histos (+ completion).

	* Fixing segfaults in UA1_1990_S2044935 and UA5_1982_S875503.

	* Bump ABI version numbers for 1.5.0 release.

	* Use AnalysisInfo for storage of the NeedsCrossSection analysis flag.

	* Allow field setting in AnalysisInfo.

	2011-02-27 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Support LineStyle=dashdotted in make-plots

	* New command line option --style for compare-histos. Options are
	"default", "bw" and "talk".

	* cleaner uninstall

	2011-02-26 Andy Buckley <andy@insectnation.org>

	* Changing internal storage and return type of Particle::pdgId()
	to PdgId, and adding Particle::energy().

	* Renaming Analysis::energies() as Analysis::requiredEnergies().

	* Adding beam energies into beam consistency checking:
	Analysis::isCompatible methods now also require the beam energies
	to be provided.

	* Removing long-deprecated AnalysisHandler::init() constructor and
	AnalysisHandler::removeIncompatibleAnalyses() methods.

	2011-02-25 Andy Buckley <andy@insectnation.org>

	* Adding --disable-obsolete, which takes its value from the value
	of --disable-preliminary by default.

	* Replacing RivetUnvalidated and RivetPreliminary plugin libraries
	with optionally-configured analysis contents in the
	experiment-specific plugin libraries. This avoids issues with
	making libraries rebuild consistently when sources were reassigned
	between libraries.

	2011-02-24 Andy Buckley <andy@insectnation.org>

	* Changing analysis plugin registration to fall back through
	available paths rather than have RIVET_ANALYSIS_PATH totally
	override the built-in paths. The first analysis hook of a given
	name to be found is now the one that's used: any duplicates found
	will be warned about but unused. getAnalysisLibPaths() now returns
	all the search paths, in keeping with the new search behaviour.

	2011-02-22 Andy Buckley <andy@insectnation.org>

	* Moving the definition of the MSG_* macros into the Logging.hh
	header. They can't be used everywhere, though, as they depend on
	the existence of a this->getLog() method in the call scope. This
	move makes them available in e.g. AnalysisHandler and other bits
	of framework other than projections and analyses.

	* Adding a gentle print-out from the Rivet AnalysisHandler if
	preliminary analyses are being used, and strengthening the current
	warning if unvalidated analyses are used.

	* Adding documentation about the validation "process" and
	the (un)validated and preliminary analysis statuses.

	* Adding the new RivetPreliminary analysis library, and the
	corresponding --disable-preliminary configure flag. Analyses in
	this library are subject to change names, histograms, reference
	data values, etc. between releases: make sure you check any
	dependences on these analyses when upgrading Rivet.

	* Change the Python script ref data search behaviours to use Rivet
	ref data by default where available, rather than requiring a -R
	option. Where relevant, -R is still a valid option, to avoid
	breaking legacy scripts, and there is a new --no-rivet-refs option
	to turn the default searching off.

	* Add the prepending and appending optional arguments to the path
	searching functions. This will make it easier to combine the
	search functions with user-supplied paths in Python scripts.

	* Make make-plots killable!

	* Adding Rivet version to top of run printout.

	* Adding Run::crossSection() and printing out the cross-section in
	pb at the end of a Rivet run.

	2011-02-22 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Make lighthisto.py aware of 2D histograms

	* Adding published versions of the CDF_2008 leading jets and DY
	analyses, and marking the preliminary ones as "OBSOLETE".

	2011-02-21 Andy Buckley <andy@insectnation.org>

	* Adding PDF documentation for path searching and .info/.plot
	files, and tidying overfull lines.

	* Removing unneeded const declarations from various return by
	value path and internal binning functions. Should not affect ABI
	compatibility but will force recompilation of external packages
	using the RivetPaths.hh and Utils.hh headers.

	* Adding findAnalysis*File(fname) functions, to be used by Rivet
	scripts and external programs to find files known to Rivet
	according to Rivet's (newly standard) lookup rule.

	* Changing search path function behaviour to always return all
	search directories rather than overriding the built-in locations
	if the environment variables are set.

	2011-02-20 Andy Buckley <andy@insectnation.org>

	* Adding the ATLAS 2011 transverse jet shapes analysis.

	2011-02-18 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Support for transparency in make-plots

	2011-02-18 Frank Siegert <frank.siegert@cern.ch>

	* Added ATLAS prompt photon analysis ATLAS_2010_S8914702

	2011-02-10 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Simple NOOP constructor for Thrust projection

	* Add CMS event shape analysis. Data read off the plots. We
	will get the final numbers when the paper is accepted by
	the journal.

	2011-02-10 Frank Siegert <frank.siegert@cern.ch>

	* Add final version of ATLAS dijet azimuthal decorrelation

	2011-02-10 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* remove ATLAS conf note analyses for which we have final data
	* reshuffle histograms in ATLAS minbias analysis to match Hepdata
	* small pT-cut fix in ATLAS track based UE analysis

	2011-01-31 Andy Buckley <andy@insectnation.org>

	* Doc tweaks and adding cmp-by-\|p\| functions for Jets, to match
	those added by Hendrik for Particles.

	* Don't sum photons around muons in the D0 2010 Z pT analysis.

	2011-01-27 Andy Buckley <andy@insectnation.org>

	* Adding ATLAS 2010 min bias and underlying event analyses and data.

	2011-01-23 Andy Buckley <andy@insectnation.org>

	* Make make-plots write out PDF rather than PS by default.

	2011-01-12 Andy Buckley <andy@insectnation.org>

	* Fix several rendering and comparison bugs in rivet-mkhtml.

	* Allow make-plots to write into an existing directory, at the
	user's own risk.

	* Make rivet-mkhtml produce PDF-based output rather than PS by
	default (most people want PDF these days). Can we do the same
	change of default for make-plots?

	* Add getAnalysisPlotPaths() function, and use it in compare-histos

	* Use proper .info file search path function internally in AnalysisInfo::make.

	2011-01-11 Andy Buckley <andy@insectnation.org>

	* Clean up ATLAS dijet analysis.

	2010-12-30 Andy Buckley <andy@insectnation.org>

	* Adding a run timeout option, and small bug-fixes to the event
	timeout handling, and making first event timeout work nicely with
	the run timeout. Run timeout is intended to be used in conjunction
	with timed batch token expiry, of the type that likes to make 0
	byte AIDA files on LCG when Grid proxies time out.

	2010-12-21 Andy Buckley <andy@insectnation.org>

	* Fix the cuts in the CDF 1994 colour coherence analysis.

	2010-12-19 Andy Buckley <andy@insectnation.org>

	* Fixing CDF midpoint cone jet algorithm default construction to
	have an overlap threshold of 0.5 rather than 0.75. This was
	recommended by the FastJet manual, and noticed while adding the
	ATLAS and CMS cones.

	* Adding ATLAS and CMS old iterative cones as "official" FastJets
	constructor options (they could always have been used by explicit
	instantiation and attachment of a Fastjet plugin object).

	* Removing defunct and unused ClosestJetShape projection.

	2010-12-16 Andy Buckley <andy@insectnation.org>

	* bin/compare-histos, pyext/lighthisto.py: Take ref paths from
	rivet module API rather than getting the environment by hand.

	* pyext/lighthisto.py: Only read .plot info from the first
	matching file (speed-up compare-histos).

	2010-12-14 Andy Buckley <andy@insectnation.org>

	* Augmenting the physics vector functionality to make FourMomentum
	support maths operators with the correct return type (FourMomentum
	rather than FourVector).

	2010-12-11 Andy Buckley <andy@insectnation.org>

	* Adding a --event-timeout option to control the event timeout,
	adding it to the completion script, and making sure that the init
	time check is turned OFF once successful!

	* Adding an 3600 second timeout for initialising an event file. If
	it takes longer than (or anywhere close to) this long, chances are
	that the event source is inactive for some reason (perhaps
	accidentally unspecified and stdin is not active, or the event
	generator has died at the other end of the pipe. The reason for
	not making it something shorter is that e.g. Herwig++ or Sherpa
	can have long initialisation times to set up the MPI handler or to
	run the matrix element integration. An timeout after an hour is
	still better than a batch job which runs for two days before you
	realise that you forgot to generate any events!

	2010-12-10 Andy Buckley <andy@insectnation.org>

	* Fixing unbooked-histo segfault in UA1_1990_S2044935 at 63 GeV.

	2010-12-08 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixes in ATLAS_2010_CONF_083, declaring it validated

	* Added ATLAS_2010_CONF_046, only two plots are implemented.
	The paper will be out soon, and we don't need the other plots
	right now. Data is read off the plots in the note.

	* New option "SmoothLine" for HISTOGRAM sections in make-plots

	* Changed CustomTicks to CustomMajorTicks and added CustomMinorTicks
	in make-plots.

	2010-12-07 Andy Buckley <andy@insectnation.org>

	* Update the documentation to explain this latest bump to path
	lookup behaviours.

	* Various improvements to existing path lookups. In particular,
	the analysis lib path locations are added to the info and ref
	paths to avoid having to set three variables when you have all
	three file types in the same personal plugin directory.

	* Adding setAnalysisLibPaths and addAnalysisLibPath
	functions. rivet --analysis-path{,-append} now use these and work
	correctly. Hurrah!

	* Add --show-analyses as an alias for --show-analysis, following a
	comment at the ATLAS tutorial.

	2010-12-07 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Change LegendXPos behaviour in make-plots. Now the top left
	corner of the legend is used as anchor point.

	2010-12-03 Andy Buckley <andy@insectnation.org>

	* 1.4.0 release.

	* Add bin-skipping to compare-histos to avoid one use of
	rivet-rmgaps (it's still needed for non-plotting post-processing
	like Professor).

	2010-12-03 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fix normalisation issues in UA5 and ALEPH analyses

	2010-11-27 Andy Buckley <andy@insectnation.org>

	* MathUtils.hh: Adding fuzzyGtrEquals and fuzzyLessEquals, and
	tidying up the math utils collection a bit.

	* CDF 1994 colour coherence analysis overhauled and
	correction/norm factors fixed. Moved to VALIDATED status.

	* Adding programmable completion for aida2flat and flat2aida.

	* Improvements to programmable completion using the neat _filedir
	completion shell function which I just discovered.

	2010-11-26 Andy Buckley <andy@insectnation.org>

	* Tweak to floating point inRange to use fuzzyEquals for CLOSED
	interval equality comparisons.

	* Some BibTeX generation improvements, and fixing the ATLAS dijet
	BibTeX key.

	* Resolution upgrade in PNG make-plots output.

	* CDF_2005_S6217184.cc, CDF_2008_S7782535.cc: Updates to use the
	new per-jet JetAlg interface (and some other fixes).

	* JetAlg.cc: Changed the interface on request to return per-jet
	rather than per-event jet shapes, with an extra jet index argument.

	* MathUtils.hh: Adding index_between(...) function, which is handy
	for working out which bin a value falls in, given a set of bin edges.

	2010-11-25 Andy Buckley <andy@insectnation.org>

	* Cmp.hh: Adding ASC/DESC (and ANTISORTED) as preferred
	non-EQUIVALENT enum value synonyms over misleading
	SORTED/UNSORTED.

	* Change of rapidity scheme enum name to RapScheme

	* Reworking JetShape a bit further: constructor args now avoid
	inconsistencies (it was previously possible to define incompatible
	range-ends and interval). Internal binning implementation also
	reworked to use a vector of bin edges: the bin details are
	available via the interface. The general jet pT cuts can be
	applied via the JetShape constructor.

	* MathUtils.hh: Adding linspace and logspace utility
	functions. Useful for defining binnings.

	* Adding more general cuts on jet pT and (pseudo)rapidity.

	2010-11-11 Andy Buckley <andy@insectnation.org>

	* Adding special handling of FourMomentum::mass() for computed
	zero-mass vectors for which mass2 can go (very slightly) negative
	due to numerical precision.

	2010-11-10 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Adding ATLAS-CONF-2010-083 conference note. Data is read from plots.
	When I run Pythia 6 the bins close to pi/2 are higher than in the note,
	so I call this "unvalidated". But then ... the note doesn't specify
	a tune or even just a version for the generators in the plots. Not even
	if they used Pythia 6 or Pythia 8. Probably 6, since they mention AGILe.

	2010-11-10 Andy Buckley <andy@insectnation.org>

	* Adding a JetAlg::useInvisibles(bool) mechanism to allow ATLAS
	jet studies to include neutrinos. Anyone who chooses to use this
	mechanism had better be careful to remove hard neutrinos manually
	in the provided FinalState object.

	2010-11-09 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Adding ATLAS-CONF-2010-049 conference note. Data is read from plots.
	Fragmentation functions look good, but I can't reproduce the MC lines
	(or even the relative differences between them) in the jet cross-section
	plots. So consider those unvalidated for now. Oh, and it seems ATLAS
	screwed up the error bands in their ratio plots, too. They are
	upside-down.

	2010-11-07 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Adding ATLAS-CONF-2010-081 conference note. Data is read from plots.

	2010-11-06 Andy Buckley <andy@insectnation.org>

	* Deprecating the old JetShape projection and renaming to
	ClosestJetShape: the algorithm has a tenuous relationship with
	that actually used in the CDF (and ATLAS) jet shape analyses. CDF
	analyses to be migrated to the new JetShape projection... and some
	of that projection's features, design elements, etc. to be
	finished off: we may as well take this opportunity to clear up
	what was one of our nastiest pieces of code.

	2010-11-05 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Adding ATLAS-CONF-2010-031 conference note. Data is read from plots.

	2010-10-29 Andy Buckley <andy@insectnation.org>

	* Making rivet-buildplugin use the same C++ compiler and CXXFLAGS
	variable as used for the Rivet system build.

	* Fixing NeutralFinalState projection to, erm, actually select
	neutral particles (by Hendrik).

	* Allow passing a general FinalState reference to the JetShape
	projection, rather than requiring a VetoedFS.

	2010-10-07 Andy Buckley <andy@insectnation.org>

	* Adding a --with-root flag to rivet-buildplugin to add
	root-config --libs flags to the plugin build command.

	2010-09-24 Andy Buckley <andy@insectnation.org>

	* Releasing as Rivet 1.3.0.

	* Bundling underscore.sty to fix problems with running make-plots
	on dat files generated by compare-histos from AIDA files with
	underscores in their names.

	2010-09-16 Andy Buckley <andy@insectnation.org>

	* Fix error in N_effective definition for weighted profile errors.

	2010-08-18 Andy Buckley <andy@insectnation.org>

	* Adding MC_GENERIC analysis. NB. Frank Siegert also added MC_HJETS.

	2010-08-03 Andy Buckley <andy@insectnation.org>

	* Fixing compare-histos treatment of what is now a ref file, and
	speeding things up... again. What a mess!

	2010-08-02 Andy Buckley <andy@insectnation.org>

	* Adding rivet-nopy: a super-simple Rivet C++ command line
	interface which avoids Python to make profiling and debugging
	easier.

	* Adding graceful exception handling to the AnalysisHandler event
	loop methods.

	* Changing compare-histos behaviour to always show plots for which
	there is at least one MC histo. The default behaviour should now
	be the correct one in 99% of use cases.

	2010-07-30 Andy Buckley <andy@insectnation.org>

	* Merging in a fix for shared_ptrs not being compared for
	insertion into a set based on raw pointer value.

	2010-07-16 Andy Buckley <andy@insectnation.org>

	* Adding an explicit library dependency declaration on libHepMC,
	and hence removing the -lHepMC from the rivet-config --libs
	output.

	2010-07-14 Andy Buckley <andy@insectnation.org>

	* Adding a manual section on use of Rivet (and AGILe) as
	libraries, and how to use the -config scripts to aid compilation.

	* FastJets projection now allows setting of a jet area definition,
	plus a hacky mapping for getting the area-enabled cluster
	sequence. Requested by Pavel Starovoitov & Paolo Francavilla.

	* Lots of script updates in last two weeks!

	2010-06-30 Andy Buckley <andy@insectnation.org>

	* Minimising amount of Log class mapped into SWIG.

	* Making Python ext build checks fail with error rather than
	warning if it has been requested (or, rather, not explicitly
	disabled).

	2010-06-28 Andy Buckley <andy@insectnation.org>

	* Converting rivet Python module to be a package, with the dlopen
	flag setting etc. done around the SWIG generated core wrapper
	module (rivet.rivetwrap).

	* Requiring Python >= 2.4.0 in rivet scripts (and adding a Python
	version checker function to rivet module)

	* Adding --epspng option to make-plots (and converting to use subprocess.Popen).

	2010-06-27 Andy Buckley <andy@insectnation.org>

	* Converting JADE_OPAL analysis to use the fastjet
	exclusive_ymerge_max function, rather than just
	exclusive_ymerge: everything looks good now. It seems that fastjet
	>= 2.4.2 is needed for this to work properly.

	2010-06-24 Andy Buckley <andy@insectnation.org>

	* Making rivet-buildplugin look in its own bin directory when
	trying to find rivet-config.

	2010-06-23 Andy Buckley <andy@insectnation.org>

	* Adding protection and warning about numerical precision issues
	in jet mass calculation/histogramming to the MC_JetAnalysis
	analysis.

	* Numerical precision improvement in calculation of
	Vector4::mass2.

	* Adding relative scale ratio plot flag to compare-histos

	* Extended command completion to rivet-config, compare-histos, and
	make-plots.

	* Providing protected log messaging macros,
	MSG_{TRACE,DEBUG,INFO,WARNING,ERROR} cf. Athena.

	* Adding environment-aware functions for Rivet search path list access.

	2010-06-21 Andy Buckley <andy@insectnation.org>

	* Using .info file beam ID and energy info in HTML and LaTeX documentation.

	* Using .info file beam ID and energy info in command-line printout.

	* Fixing a couple of references to temporary variables in the
	analysis beam info, which had been introduced during refactoring:
	have reinstated reference-type returns as the more efficient
	solution. This should not affect API compatibility.

	* Making SWIG configure-time check include testing for
	incompatibilities with the C++ compiler (re. the recurring _const_
	char* literals issue).

	* Various tweaks to scripts: make-plots and compare-histos
	processes are now renamed (on Linux), rivet-config is avoided when
	computing the Rivet version,and RIVET_REF_PATH is also set using
	the rivet --analysis-path* flags. compare-histos now uses multiple
	ref data paths for .aida file globbing.

	* Hendrik changed VetoedFinalState comparison to always return
	UNDEFINED if vetoing on the results of other FS projections is
	being used. This is the only simple way to avoid problems
	emanating from the remainingFinalState thing.

	2010-06-19 Andy Buckley <andy@insectnation.org>

	* Adding --analysis-path and --analysis-path-append command-line
	flags to the rivet script, as a "persistent" way to set or extend
	the RIVET_ANALYSIS_PATH variable.

	* Changing -Q/-V script verbosity arguments to more standard
	-q/-v, after Hendrik moaned about it ;)

	* Small fix to TinyXML operator precendence: removes a warning,
	and I think fixes a small bug.

	* Adding plotinfo entries for new jet rapidity and jet mass plots
	in MC_JetAnalysis derivatives.

	* Moving MC_JetAnalysis base class into a new
	libRivetAnalysisTools library, with analysis base class and helper
	headers to be stored in the reinstated Rivet/Analyses include
	directory.

	2010-06-08 Andy Buckley <andy@insectnation.org>

	* Removing check for CEDARSTD #define guard, since we no longer
	compile against AGILe and don't have to be careful about
	duplication.

	* Moving crappy closest approach and decay significance functions
	from Utils into SVertex, which is the only place they have ever
	been used (and is itself almost entirely pointless).

	* Overhauling particle ID <-> name system to clear up ambiguities
	between enums, ints, particles and beams. There are no more enums,
	although the names are still available as const static ints, and
	names are now obtained via a singleton class which wraps an STL
	map for name/ID lookups in both directions.

	2010-05-18 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixing factor-of-2 bug in the error calculation when scaling
	histograms.

	* Fixing D0_2001_S4674421 analysis.

	2010-05-11 Andy Buckley <andy@insectnation.org>

	* Replacing TotalVisibleMomentum with MissingMomentum in analyses
	and WFinder. Using vector ET rather than scalar ET in some places.

	2010-05-07 Andy Buckley <andy@insectnation.org>

	* Revamping the AnalysisHandler constructor and data writing, with
	some LWH/AIDA mangling to bypass the stupid AIDA idea of having to
	specify the sole output file and format when making the data
	tree. Preferred AnalysisHandler constructor now takes only one arg
	-- the runname -- and there is a new AH.writeData(outfile) method
	to replace AH.commitData(). Doing this now to begin migration to
	more flexible histogramming in the long term.

	2010-04-21 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixing LaTeX problems (make-plots) on ancient machines, like lxplus.

	2010-04-29 Andy Buckley <andy@insectnation.org>

	* Fixing (I hope!) the treatment of weighted profile bin errors in LWH.

	2010-04-21 Andy Buckley <andy@insectnation.org>

	* Removing defunct and unused KtJets and Configuration classes.

	* Hiding some internal details from Doxygen.

	* Add @brief Doxygen comments to all analyses, projections and
	core classes which were missing them.

	2010-04-21 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* remove obsolete reference to InitialQuarks from DELPHI_2002
	* fix normalisation in CDF_2000_S4155203

	2010-04-20 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* bin/make-plots: real support for 2-dim histograms plotted as
	colormaps, updated the documentation accordingly.
	* fix misleading help comment in configure.ac

	2010-04-08 Andy Buckley <andy@insectnation.org>

	* bin/root2flat: Adding this little helper script, minimally
	modified from one which Holger Schulz made for internal use in
	ATLAS.

	2010-04-05 Andy Buckley <andy@insectnation.org>

	* Using spiresbib in rivet-mkanalysis: analysis templates made
	with rivet-mkanalysis will now contain a SPIRES-dumped BibTeX key
	and entry if possible!

	* Adding BibKey and BibTeX entries to analysis metadata files, and
	updating doc build to use them rather than the time-consuming
	SPIRES screen-scraping. Added SPIRES BibTeX dumps to all analysis
	metadata using new (uninstalled & unpackaged) doc/get-spires-data
	script hack.

	* Updating metadata files to add Energies, Beams and PtCuts
	entries to all of them.

	* Adding ToDo, NeedsCrossSection, and better treatment of Beams
	and Energies entries in metadata files and in AnalysisInfo and
	Analysis interfaces.

	2010-04-03 Andy Buckley <andy@insectnation.org>

	* Frank Siegert: Update of rivet-mkhtml to conform to improved
	compare-histos.

	* Frank Siegert: LWH output in precision-8 scientific notation, to
	solve a binning precision problem... the first time weve noticed a
	problem!

	* Improved treatment of data/reference datasets and labels in
	compare-histos.

	* Rewrite of rivet-mkanalysis in Python to make way for neat
	additions.

	* Improving SWIG tests, since once again the user's biuld system
	must include SWIG (no test to check that it's a 'good SWIG', since
	the meaning of that depends on which compiler is being used and we
	hope that the user system is consistent... evidence from Finkified
	Macs and bloody SLC5 notwithstanding).

	2010-03-23 Andy Buckley <andy@insectnation.org>

	* Tag as patch release 1.2.1.

	2010-03-22 Andy Buckley <andy@insectnation.org>

	* General tidying of return arguments and intentionally unused
	parameters to keep -Wextra happy (some complaints remain from
	TinyXML, FastJet, and HepMC).

	* Some extra bug fixes: in FastJets projection with explicit
	plugin argument, removing muon veto cut on FoxWolframMoments.

	* Adding UNUSED macro to help with places where compiler warnings
	can't be helped.

	* Turning on -Wextra warnings, and fixing some violations.

	2010-03-21 Andy Buckley <andy@insectnation.org>

	* Adding MissingMomentum projection, as replacement for ~all uses
	of now-deprecated TotalVisibleMomentum projection.

	* Fixing bug with TotalVisibleMomentum projection usage in MC_SUSY
	analysis.

	* Frank Siegert fixed major bug in pTmin param passing to FastJets
	projection. D'oh: requires patch release.

	2010-03-02 Andy Buckley <andy@insectnation.org>

	* Tagging for 1.2.0 release... at last!

	2010-03-01 Andy Buckley <andy@insectnation.org>

	* Updates to manual, manual generation scripts, analysis info etc.

	* Add HepData URL to metadata print-out with rivet --show-analysis

	* Fix average Et plot in UA1 analysis to only apply to the tracker
	acceptance (but to include neutral particle contributions,
	i.e. the region of the calorimeter in the tracker acceptance).

	* Use Et rather than pT in filling the scalar Et measure in
	TotalVisibleMomentum.

	* Fixes to UA1 normalisation (which is rather funny in the paper).

	2010-02-26 Andy Buckley <andy@insectnation.org>

	* Update WFinder to not place cuts and other restrictions on the
	neutrino.

	2010-02-11 Andy Buckley <andy@insectnation.org>

	* Change analysis loader behaviour to use ONLY RIVET_ANALYSIS_PATH
	locations if set, otherwise use ONLY the standard Rivet analysis
	install path. Should only impact users of personal plugin
	analyses, who should now explicitly set RIVET_ANALYSIS_PATH to
	load their analysis... and who can now create personal versions of
	standard analyses without getting an error message about duplicate
	loading.

	2010-01-15 Andy Buckley <andy@insectnation.org>

	* Add tests for "stable" heavy flavour hadrons in jets (rather
	than just testing for c/b hadrons in the ancestor lists of stable
	jet constituents)

	2009-12-23 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* New option "RatioPlotMode=deviation" in make-plots.

	2009-12-14 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* New option "MainPlot" in make-plots. For people who only want
	the ratio plot and nothing else.

	* New option "ConnectGaps" in make-plots. Set to 1 if you
	want to connect gaps in histograms with a line when ErrorBars=0.
	Works both in PLOT and in HISTOGRAM sections.

	* Eliminated global variables for coordinates in make-plots and
	enabled multithreading.

	2009-12-14 Andy Buckley <andy@insectnation.org>

	* AnalysisHandler::execute now calls AnalysisHandler::init(event)
	if it has not yet been initialised.

	* Adding more beam configuration features to Beam and
	AnalysisHandler: the setRunBeams(...) methods on the latter now
	allows a beam configuration for the run to be specified without
	using the Run class.

	2009-12-11 Andy Buckley <andy@insectnation.org>

	* Removing use of PVertex from few remaining analyses. Still used
	by SVertex, which is itself hardly used and could maybe be
	removed...

	2009-12-10 Andy Buckley <andy@insectnation.org>

	* Updating JADE_OPAL to do the histo booking in init(), since
	sqrtS() is now available at that stage.

	* Renaming and slightly re-engineering all MC__ analyses to not
	be collider-specific (now the Analysis::sqrtS/beams()) methods
	mean that histograms can be dynamically binned.

	* Creating RivetUnvalidated.so plugin library for unvalidated
	analyses. Unvalidated analyses now need to be explicitly enabled
	with a --enable-unvalidated flag on the configure script.

	* Various min bias analyses updated and validated.

	2009-12-10 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Propagate SPECIAL and HISTOGRAM sections from .plot files
	through compare-histos

	* STAR_2006_S6860818: <pT> vs particle mass, validate analysis

	2009-12-04 Andy Buckley <andy@insectnation.org>

	* Use scaling rather than normalising in DELPHI_1996: this is
	generally desirable, since normalizing to 1 for 1/sig dsig/dx
	observables isn't correct if any events fall outside the histo
	bounds.

	* Many fixes to OPAL_2004.

	* Improved Hemispheres interface to remove unnecessary consts on
	returned doubles, and to also return non-squared versions
	of (scaled) hemisphere masses.

	* Add "make pyclean" make target at the top level to make it
	easier for developers to clean their Python module build when the
	API is extended.

	* Identify use of unvalidated analyses with a warning message at
	runtime.

	* Providing Analysis::sqrtS() and Analysis::beams(), and making
	sure they're available by the time the init methods are called.

	2009-12-02 Andy Buckley <andy@insectnation.org>

	* Adding passing of first event sqrt(s) and beams to analysis handler.

	* Restructuring running to only use one HepMC input file (no-one
	was using multiple ones, right?) and to break down the Run class
	to cleanly separate the init and event loop phases. End of file is
	now neater.

	2009-12-01 Andy Buckley <andy@insectnation.org>

	* Adding parsing of beam types and pairs of energies from YAML.

	2009-12-01 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixing trigger efficiency in CDF_2009_S8233977

	2009-11-30 Andy Buckley <andy@insectnation.org>

	* Using shared pointers to make I/O object memory management
	neater and less error-prone.

	* Adding crossSectionPerEvent() method [==
	crossSection()/sumOfWeights()] to Analysis. Useful for histogram
	scaling since numerator of sumW_passed/sumW_total (to calculate
	pass-cuts xsec) is cancelled by dividing histo by sumW_passed.

	* Clean-up of Particle class and provision of inline PID::
	functions which take a Particle as an argument to avoid having to
	explicitly call the Particle::pdgId() method.

	2009-11-30 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixing division by zero in Profile1D bin errors for
	bins with just a single entry.

	2009-11-24 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* First working version of STAR_2006_S6860818

	2009-11-23 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Adding missing CDF_2001_S4751469 plots to uemerge
	* New "ShowZero" option in make-plots
	* Improving lots of plot defaults
	* Fixing typos / non-existing bins in CDF_2001_S4751469 and
	CDF_2004_S5839831 reference data

	2009-11-19 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixing our compare() for doubles.

	2009-11-17 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Zeroth version of STAR_2006_S6860818 analysis (identified
	strange particles). Not working yet for unstable particles.

	2009-11-11 Andy Buckley <andy@insectnation.org>

	* Adding separate jet-oriented and photon-oriented observables to
	MC PHOTONJETUE analysis.

	* Bug fix in MC leading jets analysis, and general tidying of
	leading jet analyses to insert units, etc. (should not affect any
	current results)

	2009-11-10 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixing last issues in STAR_2006_S6500200 and setting it to
	VALIDATED.
	* Noramlise STAR_2006_S6870392 to cross-section

	2009-11-09 Andy Buckley <andy@insectnation.org>

	* Overhaul of jet caching and ParticleBase interface.

	* Adding lists of analyses' histograms (obtained by scanning the
	plot info files) to the LaTeX documentation.

	2009-11-07 Andy Buckley <andy@insectnation.org>

	* Adding checking system to ensure that Projections aren't
	registered before the init phase of analyses.

	* Now that the ProjHandler isn't full of defunct pointers (which
	tend to coincidentally point to new Projection pointers rather
	than undefined memory, hence it wasn't noticed until recently!),
	use of a duplicate projection name is now banned with a helpful
	message at runtime.

	* (Huge) overhaul of ProjectionHandler system to use shared_ptr:
	projections are now deleted much more efficiently, naturally
	cleaning themselves out of the central repository as they go out
	of scope.

	2009-11-06 Andy Buckley <andy@insectnation.org>

	* Adding Cmp<double> specialisation, using fuzzyEquals().

	2009-11-05 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixing histogram division code.

	2009-11-04 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* New analysis STAR_2006_S6500200 (pion and proton pT spectra in
	pp collisions at 200 GeV). It is still unclear if they used a cut
	in rapidity or pseudorapidity, thus the analysis is declared
	"UNDER DEVELOPMENT" and "DO NOT USE".
	* Fixing compare() in NeutralFinalState and MergedFinalState

	2009-11-04 Andy Buckley <andy@insectnation.org>

	* Adding consistence checking on beam ID and sqrt(s) vs. those
	from first event.

	2009-11-03 Andy Buckley <andy@insectnation.org>

	* Adding more assertion checks to linear algebra testing.

	2009-11-02 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixing normalisation issue with stacked histograms in
	make-plots.

	2009-10-30 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* CDF_2009_S8233977: Updating data and axes labels to match final
	paper. Normalise to cross-section instead of data.

	2009-10-23 Andy Buckley <andy@insectnation.org>

	* Fixing Cheese-3 plot in CDF 2004... at last!

	2009-10-23 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fix muon veto in CDF_1994_S2952106, CDF_2005_S6217184,
	CDF_2008_S7782535, and D0_2004_S5992206

	2009-10-19 Andy Buckley <andy@insectnation.org>

	* Adding analysis info files for MC SUSY and PHOTONJETUE analyses.

	* Adding MC UE analysis in photon+jet events.

	2009-10-19 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Adding new NeutralFinalState projection. Note that this final
	state takes E_T instead of p_T as argument (makes more sense for
	neutral particles). The compare() method does not yet work as
	expected (E_T comparison still missing).

	* Adding new MergedFinalState projection. This merges two final
	states, removing duplicate particles. Duplicates are identified by
	looking at the genParticle(), so users need to take care of any
	manually added particles themselves.

	* Fixing most open issues with the STAR_2009_UE_HELEN analysis.
	There is only one question left, regarding the away region.

	* Set the default split-merge value for SISCone in our FastJets
	projection to the recommended (but not Fastjet-default!) value of
	0.75.

	2009-10-17 Andy Buckley <andy@insectnation.org>

	* Adding parsing of units in cross-sections passed to the "-x"
	flag, i.e. "-x 101 mb" is parsed internally into 1.01e11 pb.

	2009-10-16 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Disabling DELPHI_2003_WUD_03_11 in the Makefiles, since I don't
	trust the data.

	* Getting STAR_2009_UE_HELEN to work.

	2009-10-04 Andy Buckley <andy@insectnation.org>

	* Adding triggers and other tidying to (still unvalidated)
	UA1_1990 analysis.

	* Fixing definition of UA5 trigger to not be intrinscally
	different for pp and ppbar: this is corrected for (although it
	takes some readng to work this out) in the 1982 paper, which I
	think is the only one to compare the two modes.

	* Moving projection setup and registration into init() method for
	remaining analyses.

	* Adding trigger implementations as projections for CDF Runs 0 &
	1, and for UA5.

	2009-10-01 Andy Buckley <andy.buckley@cern.ch>

	* Moving projection setup and registration into init() method for
	analyses from ALEPH, CDF and the MC_ group.

	* Adding generic SUSY validation analysis, based on plots used in
	ATLAS Herwig++ validation.

	* Adding sorted particle accessors to FinalState (cf. JetAlg).

	2009-09-29 Andy Buckley <andy@insectnation.org>

	* Adding optional use of args as regex match expressions with
	-l/--list-analyses.

	2009-09-03 Andy Buckley <andy.buckley@cern.ch>

	* Passing GSL include path to compiler, since its absence was
	breaking builds on systems with no GSL installation in a standard
	location (such as SLC5, for some mysterious reason!)

	* Removing lib extension passing to compiler from the configure
	script, because Macs and Linux now both use .so extensions for the
	plugin analysis modules.

	2009-09-02 Andy Buckley <andy@insectnation.org>

	* Adding analysis info file path search with RIVET_DATA_PATH
	variable (and using this to fix doc build.)

	* Improvements to AnalysisLoader path search.

	* Moving analysis sources back into single directory, after a
	proletarian uprising ;)

	2009-09-01 Andy Buckley <andy@insectnation.org>

	* Adding WFinder and WAnalysis, based on Z proj and analysis, with
	some tidying of the Z code.

	* ClusteredPhotons now uses an IdentifiedFS to pick the photons to
	be looped over, and only clusters photons around charged signal
	particles.

	2009-08-31 Andy Buckley <andy@insectnation.org>

	* Splitting analyses by directory, to make it easier to disable
	building of particular analysis group plugin libs.

	* Removing/merging headers for all analyses except for the special
	MC_JetAnalysis base class.

	* Exit with an error message if addProjection is used twice from
	the same parent with distinct projections.

	2009-08-28 Andy Buckley <andy@insectnation.org>

	* Changed naming convention for analysis plugin libraries, since
	the loader has changed so much: they must now start with the
	word "Rivet" (i.e. no lib prefix).

	* Split standard plugin analyses into several plugin libraries:
	these will eventually move into separate subdirs for extra build
	convenience.

	* Started merging analysis headers into the source files, now that
	we can (the plugin hooks previously forbade this).

	* Replacement of analysis loader system with a new one based on
	ideas from ThePEG, which uses dlopen-time instantiation of
	templated global variables to reduce boilerplate plugin hooks to
	one line in analyses.

	2009-07-14 Frank Siegert <frank.siegert@durham.ac.uk>

	* Replacing in-source histo-booking metadata with .plot files.

	2009-07-14 Andy Buckley <andy@insectnation.org>

	* Making Python wrapper files copy into place based on bundled
	versions for each active HepMC interface (2.3, 2.4 & 2.5), using a
	new HepMC version detector test in configure.

	* Adding YAML metadata files and parser, removing same metadata
	from the analysis classes' source headers.

	2009-07-07 Andy Buckley <andy@insectnation.org>

	* Adding Jet::hadronicEnergy()

	* Adding VisibleFinalState and automatically using it in JetAlg
	projections.

	* Adding YAML parser for new metadata (and eventually ref data)
	files.

	2009-07-02 Andy Buckley <andy@insectnation.org>

	* Adding Jet::neutralEnergy() (and Jet::totalEnergy() for
	convenience/symmetry).

	2009-06-25 Andy Buckley <andy@insectnation.org>

	* Tidying and small efficiency improvements in CDF_2008_S7541902
	W+jets analysis (remove unneeded second stage of jet storing,
	sorting the jets twice, using foreach, etc.).

	2009-06-24 Andy Buckley <andy@insectnation.org>

	* Fixing Jet's containsBottom and containsCharm methods, since B
	hadrons are not necessarily to be found in the final
	state. Discovered at the same time that HepMC::GenParticle defines
	a massively unhelpful copy constructor that actually loses the
	tree information; it would be better to hide it entirely!

	* Adding RivetHepMC.hh, which defines container-type accessors to
	HepMC particles and vertices, making it possible to use Boost
	foreach and hence avoiding the usual huge boilerplate for-loops.

	2009-06-11 Andy Buckley <andy@insectnation.org>

	* Adding --disable-pdfmanual option, to make the bootstrap a bit
	more robust.

	* Re-enabling D0IL in FastJets: adding 10^-10 to the pTmin removes
	the numerical instability!

	* Fixing CDF_2004 min/max cone analysis to use calo jets for the
	leading jet Et binning. Thanks to Markus Warsinsky
	for (re)discovering this bug: I was sure it had been fixed. I'm
	optimistic that this will fix the main distributions, although
	Swiss Cheese "minus 3" is still likely to be broken. Early tests
	look okay, but it'll take more stats before we can remove the "do
	not trust" sign.

	2009-06-10 Andy Buckley <andy@insectnation.org>

	* Providing "calc" methods so that Thrust and Sphericity
	projections can be used as calculators without having to use the
	projecting/caching system.

	2009-06-09 Andy Buckley <andy@insectnation.org>

	* 1.1.3 release!

	* More doc building and SWIG robustness tweaks.

	2009-06-07 Andy Buckley <andy@insectnation.org>

	* Make doc build from metadata work even before the library is
	installed.

	2009-06-07 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fix phi rotation in CDF_2008_LEADINGJETS.

	2009-06-07 Andy Buckley <andy@insectnation.org>

	* Disabling D0 IL midpoint cone (using CDF modpoint instead),
	since there seems to be a crashing bug in FastJet's
	implementation: we can't release that way, since ~no D0 analyses
	will run.

	2009-06-03 Andy Buckley <andy@insectnation.org>

	* Putting SWIG-generated source files under SVN control to make
	life easier for people who we advise to check out the SVN head
	version, but who don't have a sufficiently modern copy of SWIG to

	* Adding the --disable-analyses option, for people who just want
	to use Rivet as a framework for their own analyses.

	* Enabling HepMC cross-section reading, now that HepMC 2.5.0 has
	been released.

	2009-05-23 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Using gsl-config to locate libgsl

	* Fix the paths for linking such that our own libraries are found
	before any system libraries, e.g. for the case that there is an
	outdated fastjet version installed on the system while we want to
	use our own up-to-date version.

	* Change dmerge to ymerge in the e+e- analyses using JADE or
	DURHAM from fastjet. That's what it is called in fastjet-2.4 now.

	2009-05-18 Andy Buckley <andy@insectnation.org>

	* Adding use of gsl-config in configure script.

	2009-05-16 Andy Buckley <andy@insectnation.org>

	* Removing argument to vetoEvent macro, since no weight
	subtraction is now needed. It's now just an annotated return, with
	built-in debug log message.

	* Adding an "open" FinalState, which is only calculated once per
	even, then used by all other FSes, avoiding the loop over
	non-status 1 particles.

	2009-05-15 Andy Buckley <andy@insectnation.org>

	* Removing incorrect setting of DPS x-errs in CDF_2008 jet shape
	analysis: the DPS autobooking already gets this bit right.

	* Using Jet rather than FastJet::PseudoJet where possible, as it
	means that the phi ranges match up nicely between Particle and the
	Jet object. The FastJet objects are only really needed if you want
	to do detailed things like look at split/merge scales for
	e.g. diff jet rates or "y-split" analyses.

	* Tidying and debugging CDF jet shape analyses and jet shape
	plugin... ongoing, but I think I've found at least one real bug,
	plus a lot of stuff that can be done a lot more nicely.

	* Fully removing deprecated math functions and updating affected
	analyses.

	2009-05-14 Andy Buckley <andy@insectnation.org>

	* Removing redundant rotation in DISKinematics... this was a
	legacy of Peter using theta rather than pi-theta in his rotation.

	* Adding convenience phi, rho, eta, theta, and perp,perp2 methods
	to the 3 and 4 vector classes.

	2009-05-12 Andy Buckley <andy@insectnation.org>

	* Adding event auto-rotation for events with one proton... more
	complete approach?

	2009-05-09 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Renaming CDF_2008_NOTE_9337 to CDF_2009_S8233977.

	* Numerous small bug fixes in ALEPH_1996_S3486095.

	* Adding data for one of the Rick-Field-style STAR UE analyses.

	2009-05-08 Andy Buckley <andy@insectnation.org>

	* Adding rivet-mkanalysis script, to make generating new analysis
	source templates easier.

	2009-05-07 Andy Buckley <andy@insectnation.org>

	* Adding null vector check to Vector3::azimuthalAngle().

	* Fixing definition of HCM/Breit frames in DISKinematics, and
	adding asserts to check that the transformation is doing what it
	should.

	2009-05-05 Andy Buckley <andy@insectnation.org>

	* Removing eta and Et cuts from CDF 2000 Z pT analysis, based on
	our reading of the paper, and converting most of the analysis to a
	call of the ZFinder projection.

	2009-05-05 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Support non-default seed_threshold in CDF cone jet algorithms.

	* New analyses STAR_2006_S6870392 and STAR_2008_S7993412. In
	STAR_2008_S7993412 only the first distribution is filled at the
	moment. STAR_2006_S6870392 is normalised to data instead of the
	Monte Carlo cross-section, since we don't have that available in
	the HepMC stream yet.

	2009-05-05 Andy Buckley <andy@insectnation.org>

	* Changing Event wrapper to copy whole GenEvents rather than
	pointers, use std units if supported in HepMC, and run a
	placeholder function for event auto-orientation.

	2009-04-28 Andy Buckley <andy@insectnation.org>

	* Removing inclusion of IsolationTools header by analyses that
	aren't actually using the isolation tools... which is all of
	them. Leaving the isolation tools in place for now, as there might
	still be use cases for them and there's quite a lot of code there
	that deserves a second chance to be used!

	2009-04-24 Andy Buckley <andy@insectnation.org>

	* Deleting Rivet implementations of TrackJet and D0ILConeJets: the
	code from these has now been incorporated into FastJet 2.4.0.

	* Removed all mentions of the FastJet JADE patch and the HAVE_JADE
	preprocessor macro.

	* Bug fix to D0_2008_S6879055 to ensure that cuts compare to both
	electron and positron momenta (was just comparing against
	electrons, twice, probably thanks to the miracle of cut and
	paste).

	* Converting all D0 IL Cone jets to use FastJets. Involved tidying
	D0_2004 jet azimuthal decorrelation analysis and D0_2008_S6879055
	as part of migration away from using the getLorentzJets method,
	and removing the D0ILConeJets header from quite a few analyses
	that weren't using it at all.

	* Updating CDF 2001 to use FastJets in place of TrackJet, and
	adding axis labels to its plots.

	* Note that ZEUS_2001_S4815815 uses the wrong jet definition: it
	should be a cone but curently uses kT.

	* Fixing CDF_2005_S6217184 to use correct (midpoint, R=0.7) jet
	definition. That this was using a kT definition with R=1.0 was
	only made obvious when the default FastJets constructor was
	removed.

	* Removing FastJets default constructor: since there are now
	several good (IRC safe) jet definitions available, there is no
	obvious safe default and analyses should have to specify which
	they use.

	* Moving FastJets constructors into implementation file to reduce
	recompilation dependencies, and adding new plugins.

	* Ensuring that axis labels actually get written to the output
	data file.

	2009-04-22 Andy Buckley <andy@insectnation.org>

	* Adding explicit FastJet CDF jet alg overlap_threshold
	constructor param values, since the default value from 2.3.x is
	now removed in version 2.4.0.

	* Removing use of HepMC ThreeVector::mag method (in one place
	only) since this has been removed in version 2.5.0b.

	* Fix to hepmc.i (included by rivet.i) to ignore new HepMC 2.5.0b
	GenEvent stream operator.

	2009-04-21 Andy Buckley <andy@insectnation.org>

	* Dependency on FastJet now requires version 2.4.0 or later. Jade
	algorithm is now native.

	* Moving all analysis constructors and Projection headers from the
	analysis header files into their .cc implementation files, cutting
	header dependencies.

	* Removing AIDA headers: now using LWH headers only, with
	enhancement to use axis labels. This facility is now used by the
	histo booking routines, and calling the booking function versions
	which don't specify axis labels will result in a runtime warning.

	2009-04-07 Andy Buckley <andy@insectnation.org>

	* Adding $(DESTDIR) prefix to call to Python module "setup.py
	install"

	* Moving HepMC SWIG mappings into Python Rivet module for now:
	seems to work-around the SL type-mapping bug.

	2009-04-03 Andy Buckley <andy@insectnation.org>

	* Adding MC analysis for LHC UE: higher-pT replica of Tevatron
	2008 leading jets study.

	* Adding CDF_1990 pseudorapidity analysis.

	* Moving CDF_2001 constructor into implementation file.

	* Cleaning up CDF_2008_LEADINGJETS a bit, e.g. using foreach
	loops.

	* Adding function interface for specifying axis labels in histo
	bookings. Currently has no effect, since AIDA doesn't seem to have
	a mechanism for axis labels. It really is a piece of crap.

	2009-03-18 Andy Buckley <andy@insectnation.org>

	* Adding docs "make upload" and other tweaks to make the doc files
	fit in with the Rivet website.

	* Improving LaTex docs to show email addresses in printable form
	and to group analyses by collider or other metadata.

	* Adding doc script to include run info in LaTeX docs, and to make
	HTML docs.

	* Removing WZandh projection, which wasn't generator independent
	and whose sole usage was already replaced by ZFinder.

	* Improvements to constructors of ZFinder and InvMassFS.

	* Changing ExampleTree to use real FS-based Z finding.

	2009-03-16 Andy Buckley <andy@insectnation.org>

	* Allow the -H histo file spec to give a full name if wanted. If
	it doesn't end in the desired extension, it will be added.

	* Adding --runname option (and API elements) to choose a run name
	to be prepended as a "top level directory" in histo paths. An
	empty value results in no extra TLD.

	2009-03-06 Andy Buckley <andy@insectnation.org>

	* Adding R=0.2 photon clustering to the electrons in the CDF 2000
	Z pT analysis.

	2009-03-04 Andy Buckley <andy@insectnation.org>

	* Fixing use of fastjet-config to not use the user's PATH
	variable.

	* Fixing SWIG type table for HepMC object interchange.

	2009-02-20 Andy Buckley <andy@insectnation.org>

	* Adding use of new metadata in command line analysis querying
	with the rivet command, and in building the PDF Rivet manual.

	* Adding extended metadata methods to the Analysis interface and
	the Python wrapper. All standard analyses comply with this new
	interface.

	2009-02-19 Andy Buckley <andy@insectnation.org>

	* Adding usefully-scoped config headers, a Rivet::version()
	function which uses them, and installing the generated headers to
	fix "external" builds against an installed copy of Rivet. The
	version() function has been added to the Python wrapper.

	2009-02-05 Andy Buckley <andy@insectnation.org>

	* Removing ROOT dependency and linking. Woo! There's no need for
	this now, because the front-end accepts no histo format switch and
	we'll just use aida2root for output conversions. Simpler this way,
	and it avoids about half of our compilation bug reports from 32/64
	bit ROOT build confusions.

	2009-02-04 Andy Buckley <andy@insectnation.org>

	* Adding automatic generation of LaTeX manual entries for the
	standard analyses.

	2009-01-20 Andy Buckley <andy@insectnation.org>

	* Removing RivetGun and TCLAP source files!

	2009-01-19 Andy Buckley <andy@insectnation.org>

	* Added psyco Python optimiser to rivet, make-plots and
	compare-histos.

	* bin/aida2root: Added "-" -> "_" mangling, following requests.

	2009-01-17 Andy Buckley <andy@insectnation.org>

	* 1.1.2 release.

	2009-01-15 Andy Buckley <andy@insectnation.org>

	* Converting Python build system to bundle SWIG output in tarball.

	2009-01-14 Andy Buckley <andy@insectnation.org>

	* Converting AIDA/LWH divide function to return a DPS so that bin
	width factors don't get all screwed up. Analyses adapted to use
	the new division operation (a DPS/DPS divide would also be
	nice... but can wait for YODA).

	2009-01-06 Andy Buckley <andy@insectnation.org>

	* bin/make-plots: Added --png option for making PNG output files,
	using 'convert' (after making a PDF --- it's a bit messy)

	* bin/make-plots: Added --eps option for output filtering through
	ps2eps.

	2009-01-05 Andy Buckley <andy@insectnation.org>

	* Python: reworking Python extension build to use distutils and
	newer m4 Python macros. Probably breaks distcheck but is otherwise
	more robust and platform independent (i.e. it should now work on
	Macs).

	2008-12-19 Andy Buckley <andy@insectnation.org>

	* make-plots: Multi-threaded make-plots and cleaned up the LaTeX
	building a bit (necessary to remove the implicit single global
	state).

	2008-12-18 Andy Buckley <andy@insectnation.org>

	* make-plots: Made LaTeX run in no-stop mode.

	* compare-histos: Updated to use a nicer labelling syntax on the
	command line and to successfully build MC-MC plots.

	2008-12-16 Andy Buckley <andy@insectnation.org>

	* Made LWH bin edge comparisons safe against numerical errors.

	* Added Particle comparison functions for sorting.

	* Removing most bad things from ExampleTree and tidying up. Marked
	WZandh projection for removal.

	2008-12-03 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added the two missing observables to the CDF_2008_NOTE_9337 analysis,
	i.e. track pT and sum(ET). There is a small difference between our MC
	output and the MC plots of the analysis' author, we're still waiting
	for the author's comments.

	2008-12-02 Andy Buckley <andy@insectnation.org>

	* Overloading use of a std::set in the interface, since the
	version of SWIG on Sci Linux doesn't have a predefined mapping for
	STL sets.

	2008-12-02 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixed uemerge. The output was seriously broken by a single line
	of debug information in fillAbove(). Also changed uemerge output
	to exponential notation.

	* Unified ref and mc histos in compare-histos. Histos with one
	bin are plotted linear. Option for disabling the ratio plot.
	Several fixes for labels, legends, output directories, ...

	* Changed rivetgun's fallback directory for parameter files to
	$PREFIX/share/AGILe, since that's where the steering files now are.

	* Running aida2flat in split mode now produces make-plots compatible
	dat-files for direct plotting.

	2008-11-28 Andy Buckley <andy@insectnation.org>

	* Replaced binreloc with an upgraded and symbol-independent copy.

	2008-11-25 Andy Buckley <andy@insectnation.org>

	* Added searching of $RIVET_REF_PATH for AIDA reference data
	files.

	2008-11-24 Andy Buckley <andy@insectnation.org>

	* Removing "get"s and other obsfucated syntax from
	ProjectionApplier (Projection and Analysis) interfaces.

	2008-11-21 Andy Buckley <andy@insectnation.org>

	* Using new "global" Jet and V4 sorting functors in
	TrackJet. Looks like there was a sorting direction problem before...

	* Verbose mode with --list-analyses now shows descriptions as well
	as analysis names.

	* Moved data/Rivet to data/refdata and moved data/RivetGun
	contents to AGILe (since generator steering is no longer a Rivet
	thing)

	* Added unchecked ratio plots to D0 Run II jet + photon analysis.

	* Added D0 inclusive photon analysis.

	* Added D0 Z rapidity analysis.

	* Tidied up constructor interface and projection chain
	implementation of InvMassFinalState.

	* Added ~complete set of Jet and FourMomentum sorting functors.

	2008-11-20 Andy Buckley <andy@insectnation.org>

	* Added IdentifiedFinalState.

	* Moved a lot of TrackJet and Jet code into .cc files.

	* Fixed a caching bug in Jet: cache flag resets should never be
	conditional, since they are then sensitive to initialisation
	errors.

	* Added quark enum values to ParticleName.

	* Rationalised JetAlg interfaces somewhat, with "size()" and
	"jets()" methods in the interface.

	* Added D0 W charge asymmetry and D0 inclusive jets analyses.

	2008-11-18 Andy Buckley <andy@insectnation.org>

	* Adding D0 inclusive Z pT shape analysis.

	* Added D0 Z + jet pT and photon + jet pT spectrum analyses.

	* Lots of tidying up of particle, event, particle name etc.

	* Now the first event is used to detect the beam type and remove
	incompatible analyses.

	2008-11-17 Andy Buckley <andy@insectnation.org>

	* Added bash completion for rivetgun.

	* Starting to provide stand-alone call methods on projections so
	they can be used without the caching infrastructure. This could
	also be handy for unit testing.

	* Adding functionality (sorting function and built-in sorting
	schemes) to the JetAlg interface.

	2008-11-10 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fix floating point number output format in aida2flat and flat2aida

	* Added CDF_2002_S4796047: CDF Run-I charged multiplicity distribution

	* Renamed CDF_2008_MINBIAS to CDF_2008_NOTE_9337, since the
	note is publicly available now.

	2008-11-10 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added DELPHI_2003_WUD_03_11: Delphi 4-jet angular distributions.
	There is still a problem with the analysis, so don't use it yet.
	But I need to commit the code because my laptop is broken ...

	2008-11-06 Andy Buckley <andy@insectnation.org>

	* Code review: lots of tidying up of projections and analyses.

	* Fixes for compatibility with the LLVM C & C++ compiler.

	* Change of Particle interface to remove "get"-prefixed method
	names.

	2008-11-05 Andy Buckley <andy@insectnation.org>

	* Adding ability to query analysis metadata from the command line.

	* Example of a plugin analyis now in plugindemo, with a make check
	test to make sure that the plugin analysis is recognised by the
	command line "rivet" tool.

	* GCC 4.3 fix to mat-vec tests.

	2008-11-04 Andy Buckley <andy@insectnation.org>

	* Adding native logger control from Python interface.

	2008-11-03 Andy Buckley <andy@insectnation.org>

	* Adding bash_completion for rivet executable.

	2008-10-31 Andy Buckley <andy@insectnation.org>

	* Clean-up of histo titles and analysis code review.

	* Added momentum construction functions from FastJet PseudoJets.

	2008-10-28 Andy Buckley <andy@insectnation.org>

	* Auto-booking of histograms with a name, rather than the HepData
	ID 3-tuple is now possible.

	* Fix in CDF 2001 pT spectra to get the normalisations to depend
	on the pT_lead cutoff.

	2008-10-23 Andy Buckley <andy@insectnation.org>

	* rivet handles signals neatly, as for rivetgun, so that premature
	killing of the analysis process will still result in an analysis
	file.

	* rivet now accepts cross-section as a command line argument and,
	if it is missing and is required, will prompt the user for it
	interactively.

	2008-10-22 Andy Buckley <andy@insectnation.org>

	* rivet (Python interface) now can list analyses, check when
	adding analyses that the given names are valid, specify histo file
	name, and provide sensibly graded event number logging.

	2008-10-20 Andy Buckley <andy@insectnation.org>

	* Corrections to CDF 2004 analysis based on correspondance with
	Joey Huston. M bias dbns now use whole event within \|eta\| < 0.7,
	and Cheese plots aren't filled at all if there are insufficient
	jets (and the correct ETlead is used).

	2008-10-08 Andy Buckley <andy@insectnation.org>

	* Added AnalysisHandler::commitData() method, to allow the Python
	interface to write out a histo file without having to know
	anything about the histogramming API.

	* Reduced SWIG interface file to just map a subset of Analysis and
	AnalysisHandler functionality. This will be the basis for a new
	command line interface.

	2008-10-06 Andy Buckley <andy@insectnation.org>

	* Converted FastJets plugin to use a Boost shared_pointer to the
	cached ClusterSequence. The nullness of the pointer is now used to
	indicate an empty tracks (and hence jets) set. Once FastJet
	natively support empty CSeqs, we can rewrite this a bit more
	neatly and ditch the shared_ptr.

	2008-10-02 Andy Buckley <andy@insectnation.org>

	* The CDF_2004 (Acosta) data file now includes the full range of
	pT for the min bias data at both 630 and 1800 GeV. Previously,
	only the small low-pT insert plot had been entered into HepData.

	2008-09-30 Andy Buckley <andy@insectnation.org>

	* Lots of updates to CDF_2004 (Acosta) UE analysis, including
	sorting jets by E rather than Et, and factorising transverse cone
	code into a function so that it can be called with a random
	"leading jet" in min bias mode. Min bias histos are now being
	trial-filled just with tracks in the transverse cones, since the
	paper is very unclear on this.

	* Discovered a serious caching problem in FastJets projection when
	an empty tracks vector is passed from the
	FinalState. Unfortunately, FastJet provides no API way to solve
	the problem, so we'll have to report this upstream. For now, we're
	solving this for CDF_2004 by explicitly vetoing events with no
	tracks.

	* Added Doxygen to the build with target "dox"

	* Moved detection of whether cross-section information is needed
	into the AnalysisHandler, with dynamic computation by scanning
	contained analyses.

	* Improved robustness of event reading to detect properly when the
	input file is smaller than expected.

	2008-09-29 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* New analysis: CDF_2000_S4155203

	2008-09-23 Andy Buckley <andy@insectnation.org>

	* rivetgun can now be built and run without AGILe. Based on a
	patch by Frank Siegert.

	2008-09-23 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Some preliminary numbers for the CDF_2008_LEADINGJETS analysis
	(only transverse region and not all observables. But all we have now.)

	2008-09-17 Andy Buckley <andy@insectnation.org>

	* Breaking up the mammoth "generate" function, to make Python
	mapping easier, among other reasons.

	* Added if-zero-return-zero checking to angle mapping functions,
	to avoid problems where 1e-19 gets mapped on to 2 pi and then
	fails boundary asserts.

	* Added HistoHandler singleton class, which will be a central
	repository for holding analyses' histogram objects to be accessed
	via a user-chosen name.

	2008-08-26 Andy Buckley <andy@insectnation.org>

	* Allowing rivet-config to return combined flags.

	2008-08-14 Andy Buckley <andy@insectnation.org>

	* Fixed some g++ 4.3 compilation bugs, including "vector" not
	being a valid name for a method which returns a physics vector,
	since it clashes with std::vector (which we globally import). Took
	the opportunity to rationalise the Jet interface a bit, since
	"particle" was used to mean "FourMomentum", and "Particle" types
	required a call to "getFullParticle". I removed the "gets" at the
	same time, as part of our gradual migration to a coherent naming
	policy.

	2008-08-11 Andy Buckley <andy@insectnation.org>

	* Tidying of FastJets and added new data files from HepData.

	2008-08-10 James Monk <jmonk@hep.ucl.ac.uk>

	* FastJets now uses user_index property of fastjet::PseudoJet to
	reconstruct PID information in jet contents.

	2008-08-07 Andy Buckley <andy@insectnation.org>

	* Reworking of param file and command line parsing. Tab characters
	are now handled by the parser, in a way equivalent to spaces.

	2008-08-06 Andy Buckley <andy@insectnation.org>

	* Added extra histos and filling to Acosta analysis - all HepData
	histos should now be filled, depending on sqrt{s}. Also trialling
	use of LaTeX math mode in titles.

	2008-08-05 Andy Buckley <andy@insectnation.org>

	* More data files for CDF analyses (2 x 2008, 1 x 1994), and moved
	the RivetGun AtlasPythia6.params file to more standard
	fpythia-atlas.params (and added to the install list).

	2008-08-04 Andy Buckley <andy@insectnation.org>

	* Reduced size of available options blocks in RivetGun help text
	by removing "~" negating variants (which are hardly ever used in
	practice) and restricting beam particles to
	PROTON, ANTIPROTON,ELECTRON and POSITRON.

	* Fixed Et sorting in Acosta analysis.

	2008-08-01 Andy Buckley <andy@insectnation.org>

	* Added AIDA headers to the install list, since
	external (plugin-type) analyses need them to be present for
	compilation to succeed.

	2008-07-29 Andy Buckley <andy@insectnation.org>

	* Fixed missing ROOT compile flags for libRivet.

	* Added command line repetition to logging.

	2008-07-29 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Included the missing numbers and three more observables
	in the CDF_2008_NOTE_9351 analysis.

	2008-07-29 Andy Buckley <andy@insectnation.org>

	* Fixed wrong flags on rivet-config

	2008-07-28 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Renamed CDF_2008_DRELLYAN to CDF_2008_NOTE_9351. Updated
	numbers and cuts to the final version of this CDF note.

	2008-07-28 Andy Buckley <andy@insectation.org>

	* Fixed polar angle calcuation to use atan2.

	* Added "mk" prefixes and x/setX convention to math classes.

	2008-07-28 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Fixed definition of FourMomentum::pT (it had been returning pT2)

	2008-07-27 Andy Buckley <andy@insectnation.org>

	* Added better tests for Boost headers.

	* Added testing for -ansi, -pedantic and -Wall compiler flags.

	2008-07-25 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* updated DELPHI_2002_069_CONF_603 according to information
	from the author

	2008-07-17 Andy Buckley <andy@insectnation.org>

	* Improvements to aida2flat: now can produce one output file per
	histo, and there is a -g "gnuplot mode" which comments out the
	YODA/make_plot headers to make the format readable by gnuplot.

	* Import boost::assign namespace contents into the Rivet namespace
	--- provides very useful intuitive collection initialising
	functions.

	2008-07-15 Andy Buckley <andy.buckley@dur.ac.uk>

	* Fixed missing namespace in vector/matrix testing.

	* Removed Boost headers: now a system dependency.

	* Fixed polarRadius infinite loop.

	2008-07-09 Andy Buckley <andy@insectnation.org>

	* Fixed definitions of mapAngleMPiToPi, etc. and used them to fix
	the Jet::getPhi method.

	* Trialling use of "foreach" loop in CDF_2004: it works! Very nice.

	2008-07-08 Andy Buckley <andy@insectnation.org>

	* Removed accidental reference to an "FS" projection in
	FinalStateHCM's compare method. rivetgun -A now works again.

	* Added TASSO, SLD and D0_2008 reference data. The TASSO and SLD
	papers aren't installed or included in the tarball since there are
	currently no plans to implement these analyses.

	* Added Rivet namespacing to vector, matrix etc. classes. This
	required some re-writing and the opportunity was taken to move
	some canonical function definitions inside the classes and to
	improve the header structure of the Math area.

	2008-07-07 Andy Buckley <andy@insectnation.org>

	* Added Rivet namespace to Units.hh and Constants.hh.

	* Added Doxygen "@brief" flags to analyses.

	* Added "RIVET_" namespacing to all header guards.

	* Merged Giulio Lenzi's isolation/vetoing/invmass projections and
	D0 2008 analysis.

	2008-06-23 Jon Butterworth <J.Butterworth@ucl.ac.uk>

	* Modified FastJet to fix ysplit and split and filter.

	* Modified ExampleTree to show how to call them.

	2008-06-19 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added first version of the CDF_2008_DRELLYAN analysis described on
	http://www-cdf.fnal.gov/physics/new/qcd/abstracts/UEinDY_08.html
	There is a small difference between the analysis and this
	implementation, but it's too small to be visible.
	The fpythia-cdfdrellyan.params parameter file is for this analysis.

	* Added first version of the CDF_2008_MINBIAS analysis described on
	http://www-cdf.fnal.gov/physics/new/qcd/abstracts/minbias_08.html
	The .aida file is read from the plots on the web and will change.
	I'm still discussing some open questions about the analysis with
	the author.

	2008-06-18 Jon Butterworth <J.Butterworth@ucl.ac.uk>

	* Added First versions of splitJet and filterJet methods to
	fastjet.cc. Not yet tested, buyer beware.

	2008-06-18 Andy Buckley <andy@insectnation.org>

	* Added extra sorted Jets and Pseudojets methods to FastJets, and
	added ptmin argument to the JetAlg getJets() method, requiring a
	change to TrackJet.

	2008-06-13 Andy Buckley <andy@insectnation.org>

	* Fixed processing of "RG" parameters to ensure that invalid
	iterators are never used.

	2008-06-10 Andy Buckley <andy@insectnation.org>

	* Updated AIDA reference files, changing "/HepData" root path to
	"/REF". Still missing a couple of reference files due to upstream
	problems with the HepData records.

	2008-06-09 Andy Buckley <andy@insectnation.org>

	* rivetgun now handles termination signals (SIGTERM, SIGINT and
	SIGHUP) gracefully, finishing the event loop and finalising
	histograms. This means that histograms will always get written
	out, even if not all the requested events have been generated.

	2008-06-04 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added DELPHI_2002_069_CONF_603 analysis

	2008-05-30 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added InitialQuarks projection
	* Added OPAL_1998_S3780481 analysis

	2008-05-29 Andy Buckley <andy@insectnation.org>

	* distcheck compatibility fixes and autotools tweaks.

	2008-05-28 Andy Buckley <andy@insectnation.org>

	* Converted FastJet to use Boost smart_ptr for its plugin
	handling, to solve double-delete errors stemming from the heap
	cloning of projections.

	* Added (a subset of) Boost headers, particularly the smart
	pointers.

	2008-05-24 Andy Buckley <andy@insectnation.org>

	* Added autopackage spec files.

	* Merged these changes into the trunk.

	* Added a registerClonedProjection(...) method to
	ProjectionHandler: this is needed so that cloned projections will
	have valid pointer entries in the ProjectHandler repository.

	* Added clone() methods to all projections (need to use this,
	since the templated "new PROJ(proj)" approach to cloning can't
	handle object polymorphism.

	2008-05-19 Andy Buckley <andy@insectnation.org>

	* Moved projection-applying functions into ProjectionApplier base
	class (from which Projection and Analysis both derive).

	* Added Rivet-specific exceptions in place of std::runtime_error.

	* Removed unused HepML reference files.

	* Added error handling for requested analyses with wrong case
	convention / missing name.

	2008-05-15 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* New analysis PDG_Hadron_Multiplicities

	* flat2aida converter

	2008-05-15 Andy Buckley <andy@insectnation.org>

	* Removed unused mysterious Perl scripts!

	* Added RivetGun.HepMC logging of HepMC event details.

	2008-05-14 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* New analysis DELPHI_1995_S3137023. This analysis contains
	the xp spectra of Xi+- and Sigma(1385)+-.

	2008-05-13 Andy Buckley <andy@insectnation.org>

	* Improved logging interface: log levels are now integers (for
	cross-library compatibility and level setting also applies to
	existing loggers.

	2008-05-09 Andy Buckley <andy@insectnation.org>

	* Improvements to robustness of ROOT checks.

	* Added --version flag on config scripts and rivetgun.

	2008-05-06 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* New UnstableFinalState projection which selects all hadrons,
	leptons and real photons including unstable particles.

	* In the DELPHI_1996_S3430090 analysis the multiplicities for
	pi+/pi- and p0 are filled, using the UnstableFinalState projection.

	2008-05-06 Andy Buckley <andy@insectnation.org>

	* FastJets projection now protects against the case where no
	particles exist in the final state (where FastJet throws an
	exception).

	* AIDA file writing is now separated from the
	AnalysisHandler::finalize method... API users can choose what to
	do with the histo objects, be that writing out or further
	processing.

	2008-04-29 Andy Buckley <andy@insectnation.org>

	* Increased default tolerances in floating point comparisons as
	they were overly stringent and valid f.p. precision errors were
	being treated as significant.

	* Implemented remainder of Acosta UE analysis.

	* Added proper getEtSum() to Jet.

	* Added Et2() member and function to FourMomentum.

	* Added aida2flat conversion script.

	* Fixed ambiguity in TrackJet algorithm as to how the iteration
	continues when tracks are merged into jets in the inner loop.

	2008-04-28 Andy Buckley <andy@insectnation.org>

	* Merged in major "ProjectionHandler" branch. Projections are now
	all stored centrally in the singleton ProjectionHandler container,
	rather than as member pointers in projections and analyses. This
	also affects the applyProjection mechanism, which is now available
	as a templated method on Analysis and Projection. Still a few
	wrinkles need to be worked out.

	* The branch changes required a comprehensive review of all
	existing projections and analyses: lots of tidying up of these
	classes, as well as the auxiliary code like math utils, has taken
	place. Too much to list and track, unfortunately!

	2008-03-28 Andy Buckley <buckley@pc54.hep.ucl.ac.uk>

	* Started second CDF UE analysis ("Acosta"): histograms defined.

	* Fixed anomalous factor of 2 in LWH conversion from Profile1D
	to DataPointSet.

	* Added pT distribution histos to CDF 2001 UE analysis.

	2008-03-26 Andy Buckley <andy@insectnation.org>

	* Removed charged+neutral versions of histograms and projections
	from DELPHI analysis since they just duplicate the more robust
	charged-only measurements and aren't really of interest for
	tuning.

	2008-03-10 Andy Buckley <andy@insectnation.org>

	* Profile histograms now use error computation with proper
	weighting, as described here:
	http://en.wikipedia.org/wiki/Weighted_average

	2008-02-28 Andy Buckley <andy@insectnation.org>

	* Added --enable-jade flag for Professor studies with patched
	FastJet.

	* Minor fixes to LCG tag generator and gfilt m4 macros.

	* Fixed projection slicing issues with Field UE analysis.

	* Added Analysis::vetoEvent(e) function, which keeps track of the
	correction to the sum of weights due to event vetoing in analysis
	classes.

	2008-02-26 Andy Buckley <andy@insectnation.org>

	* Vector<N> and derived classes now initialise to have zeroed
	components when the no-arg constructor is used.

	* Added Analysis::scale() function to scale 1D
	histograms. Analysis::normalize() uses it internally, and the
	DELPHI (A)EEC, whose histo weights are not pure event weights, and
	normalised using scale(h, 1/sumEventWeights).

	2008-02-21 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Added EEC and AEEC to the DELPHI_1996_S3430090 analysis. The
	normalisation of these histograms is still broken (ticket #163).

	2008-02-19 Hendrik Hoeth <hendrik.hoeth@cern.ch>

	* Many fixes to the DELPHI_1996_S3430090 analysis: bugfix in the
	calulation of eigenvalues/eigenvectors in MatrixDiag.hh for the
	sphericity, rewrite of Thrust/Major/Minor, fixed scaled momentum,
	hemisphere masses, normalisation in single particle events,
	final state slicing problems in the projections for Thrust,
	Sphericity and Hemispheres.

	2008-02-08 Andy Buckley <andy@insectnation.org>

	* Applied fixes and extensions to DIS classes, based on
	submissions by Dan Traynor.

	2008-02-06 Andy Buckley <andy@insectnation.org>

	* Made projection pointers used for cut combining into const
	pointers. Required some redefinition of the Projection* comparison
	operator.

	* Temporarily added FinalState member to ChargedFinalState to stop
	projection lifetime crash.

	2008-02-01 Andy Buckley <andy@insectnation.org>

	* Fixed another misplaced factor of bin width in the
	Analysis::normalize() method.

	2008-01-30 Andy Buckley <andy@insectnation.org>

	* Fixed the conversion of IHistogram1D to DPS, both via the
	explicit Analysis::normalize() method and the implicit
	AnalysisHandler::treeNormalize() route. The root of the problem is
	the AIDA choice of the word "height" to represent the sum of
	weights in a bin: i.e. the bin width is not taken into account
	either in computing bin height or error.

	2008-01-22 Andy Buckley <andy@insectnation.org>

	* Beam projection now uses HepMC GenEvent::beam_particles() method
	to get the beam particles. This is more portable and robust for
	C++ generators, and equivalent to the existing "first two" method
	for Fortran generators.

	2008-01-17 Andy Buckley <andy@insectnation.org>

	* Added angle range fix to pseudorapidity function (thanks to
	Piergiulio Lenzi).

	2008-01-10 Andy Buckley <andy@insectnation.org>

	* Changed autobooking plot codes to use zero-padding (gets the
	order right in JAS, file browser, ROOT etc.). Also changed the
	'ds' part to 'd' for consistency. HepData's AIDA output has been
	correspondingly updated, as have the bundled data files.

	2008-01-04 Andy Buckley <andy@insectnation.org>

	* Tidied up JetShape projection a bit, including making the
	constructor params const references. This seems to have sorted the
	runtime segfault in the CDF_2005 analysis.

	* Added caching of the analysis bin edges from the AIDA file -
	each analysis object will now only read its reference file once,
	which massively speeds up the rivetgun startup time for analyses
	with large numbhers of autobooked histos (e.g. the
	DELPHI_1996_S3430090 analysis).

	2008-01-02 Andy Buckley <andy@insectnation.org>

	* CDF_2001_S4751469 now uses the LossyFinalState projection, with
	an 8% loss rate.

	* Added LossyFinalState and HadronicFinalState, and fixed a
	"polarity" bug in the charged final state projection (it was
	keeping only the uncharged particles).

	* Now using isatty(1) to determine whether or not color escapes
	can be used. Also removed --color argument, since it can't have an
	effect (TCLAP doesn't do position-based flag toggling).

	* Made Python extension build optional (and disabled by default).

	2008-01-01 Andy Buckley <andy@insectnation.org>

	* Removed some unwanted DEBUG statements, and lowered the level of
	some infrastructure DEBUGs to TRACE level.

	* Added bash color escapes to the logger system.

	-2007-12-21 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-12-21 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* include/LWH/ManagedObject.h: Fixed infinite loop in
	encodeForXML cf. ticket #135.

	2007-12-20 Andy Buckley <andy@insectnation.org>

	* Removed HepPID, HepPDT and Boost dependencies.

	* Fixed XML entity encoding in LWH. Updated CDF_2007_S7057202
	analysis to not do its own XML encoding of titles.

	2007-12-19 Andy Buckley <andy@insectnation.org>

	* Changed units header to set GeV = 1 (HepMC convention) and using
	units in CDF UE analysis.

	2007-12-15 Andy Buckley <andy@insectnation.org>

	* Introduced analysis metadata methods for all analyses (and made
	them part of the Analysis interface).

	2007-12-11 Andy Buckley <andy@insectnation.org>

	* Added JetAlg base projection for TrackJet, FastJet etc.

	2007-12-06 Andy Buckley <andy@insectnation.org>

	* Added checking for Boost library, and the standard Boost test
	program for shared_ptr.

	* Got basic Python interface running - required some tweaking
	since Python and Rivet's uses of dlopen collide (another
	RTLD_GLOBAL issue - see
	http://muttley.hates-software.com/2006/01/25/c37456e6.html )

	2007-12-05 Andy Buckley <andy@insectnation.org>

	* Replaced all use of KtJets projection with FastJets
	projection. KtJets projection disabled but left undeleted for
	now. CLHEP and KtJet libraries removed from configure searches and
	Makefile flags.

	2007-12-04 Andy Buckley <andy@insectnation.org>

	* Param file loading now falls back to the share/RivetGun
	directory if a local file can't be found and the provided name has
	no directory separators in it.

	* Converted TrackJet projection to update the jet centroid with
	each particle added, using pT weighting in the eta and phi
	averaging.

	2007-12-03 Andy Buckley <andy@insectnation.org>

	* Merged all command line handling functions into one large parse
	function, since only one executable now needs them. This removes a
	few awkward memory leaks.

	* Removed rivet executable - HepMC file reading functionality will
	move into rivetgun.

	* Now using HepMC IO_GenEvent format (IO_Ascii and
	IO_ExtendedAscii are deprecated). Now requires HepMC >= 2.3.0.

	* Added forward declarations of GSL diagonalisation routines,
	eliminating need for GSL headers to be installed on build machine.

	2007-11-27 Andy Buckley <andy@insectnation.org>

	* Removed charge differentiation from Multiplicity projection (use
	CFS proj) and updated ExampleAnalysis to produce more useful numbers.

	* Introduced binreloc for runtime path determination.

	* Fixed several bugs in FinalState, ChargedFinalState, TrackJet
	and Field analysis.

	* Completed move to new analysis naming scheme.

	2007-11-26 Andy Buckley <andy@insectnation.org>

	* Removed conditional HAVE_FASTJET bits: FastJet is now compulsory.

	* Merging appropriate RivetGun parts into Rivet. RivetGun currently broken.

	2007-11-23 Andy Buckley <andy@insectnation.org>

	* Renaming analyses to Spires-ID scheme: currently of form
	S<SpiresID>, to become <Expt>_<YYYY>_<SpiresID>.

	2007-11-20 Andy Buckley <andy@insectnation.org>

	* Merged replacement vectors, matrices and boosts into trunk.

	-2007-11-15 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-11-15 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* src/Analysis.cc, include/Rivet/Analysis.hh: Introduced normalize
	function. See ticket #126.

	2007-10-31 Andy Buckley <andy@insectnation.org>

	* Tagging as 1.0b2 for HERA-LHC meeting.


	2007-10-25 Andy Buckley <andy@insectnation.org>

	* Added AxesDefinition base interface to Sphericity and Thrust,
	used by Hemispheres.

	* Exposed BinaryCut class, improved its interface and fixed a few
	bugs. It's now used by VetoedFinalState for momentum cuts.

	* Removed extra output from autobooking AIDA reader.

	* Added automatic DPS booking.

	2007-10-12 Andy Buckley <andy@insectnation.org>

	* Improved a few features of the build system

	2007-10-09 James Monk

	* Fixed dylib dlopen on Mac OS X.

	2007-10-05 Andy Buckley <andy@insectnation.org>

	* Added new reference files.


	2007-10-03 Andy Buckley <andy@insectnation.org>

	* Fixed bug in configure.ac which led to explicit CXX setting
	being ignored.

	* Including Logging.hh in Projection.hh, hence new transitive
	dependency on Logging.hh being installed. Since this is the normal
	behaviour, I don't think this is a problem.

	* Fixed segfaulting bug due to use of addProjection() in
	locally-scoped contained projections. This isn't a proper fix,
	since the whole framework should be designed to avoid the
	possibility of bugs like this.

	* Added newly built HepML and AIDA reference files for current
	analyses.

	2007-10-02 Andy Buckley <andy@insectnation.org>

	* Fixed possible null-pointer dereference in Particle copy
	constructor and copy assignment: this removes one of two blocker
	segfaults, the other of which is related to the copy-assignment of
	the TotalVisMomentum projection in the ExampleTree analysis.

	2007-10-01 Andy Buckley <andy@insectnation.org>

	* Fixed portable path to Rivet share directory.

	2007-09-28 Andy Buckley <andy@insectnation.org>

	* Added more functionality to the rivet-config script: now has
	libdir, includedir, cppflags, ldflags and ldlibs options.

	2007-09-26 Andy Buckley <andy@insectnation.org>

	* Added the analysis library closer function to the
	AnalysisHandler finalize() method, and also moved the analysis
	delete loop into AnalysisHandler::finalize() so as not to try
	deleting objects whose libraries have already closed.

	* Replaced the RivetPaths.cc.in method for portable paths with
	something using -D defines - much simpler!

	2007-09-21 Lars Sonnenschein <sonne@mail.cern.ch>

	* Added HepEx0505013 analysis and JetShape projection (some fixes
	by AB.)

	* Added GetLorentzJets member function to D0 RunII cone jet projection

	2007-09-21 Andy Buckley <andy@insectnation.org>

	* Fixed lots if bugs and bad practice in HepEx0505013 (to make it
	compile-able!)

	* Downclassed the log messages from the Test analysis to DEBUG
	level.

	* Added isEmpty() method to final state projection.

	* Added testing for empty final state and useful debug log
	messages to sphericity projection.

	2007-09-20 Andy Buckley <andy@insectnation.org>

	* Added Hemispheres projection, which calculates event hemisphere
	masses and broadenings.

	2007-09-19 Andy Buckley <andy@insectnation.org>

	* Added an explicit copy assignment operator to Particle: the
	absence of one of these was responsible for the double-delete
	error.

	* Added a "fuzzy equals" utility function for float/double types
	to Utils.hh (which already contains a variety of handy little
	functions).

	* Removed deprecated Beam::operator().

	* Added ChargedFinalState projection and de-pointered the
	contained FinalState projection in VetoedFinalState.

	2007-09-18 Andy Buckley <andy@insectnation.org>

	* Major bug fixes to the regularised version of the sphericity
	projection (and hence the Parisi tensor projection). Don't trust
	C & D param results from any previous version!

	* Added extra methods to thrust and sphericity projections to get
	the oblateness and the sphericity basis (currently returns dummy
	axes since I can't yet work out how to get the similarity
	transform eigenvectors from CLHEP)

	2007-09-14 Andy Buckley <andy@insectnation.org>

	* Merged in a branch of pluggable analysis mechanisms.

	2007-06-25 Jon Butterworth <jmb@hep.ucl.ac.uk>

	* Fixed some bugs in the root output for DataPoint.h

	2007-06-25 Andy Buckley <andy@insectnation.org>

	* include/Rivet/**/Makefile.am: No longer installing headers for
	"internal" functionality.

	* include/Rivet/Projections/*.hh: Removed the private restrictions
	on copy-assignment operators.

	-2007-06-18 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-06-18 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* include/LWH/Tree.h: Fixed minor bug in listObjectNames.

	* include/LWH/DataPointSet.h: Fixed setCoordinate functions so
	that they resize the vector of DataPoints if it initially was
	empty.

	* include/LWH/DataPoint.h: Added constructor taking a vector of
	measuremts.

	-2007-06-16 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-06-16 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* include/LWH/Tree.h: Implemented the listObjectNames and ls
	functions.

	* include/Rivet/Projections/FinalStateHCM.hh,
	include/Rivet/Projections/VetoedFinalState.hh: removed
	_theParticles and corresponding access function. Use base class
	variable instead.

	* include/Rivet/Projections/FinalState.hh: Made _theParticles
	protected.

	-2007-06-13 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-06-13 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* src/Projections/FinalStateHCM.cc,
	src/Projections/DISKinematics.cc: Equality checks using
	GenParticle::operator== changed to check for pointer equality.

	* include/Rivet/Analysis/HepEx9506012.hh: Uses modified DISLepton
	projection.

	* include/Rivet/Particle.hh: Added member function to check if a
	GenParticle is associated.

	* include/Rivet/Projections/DISLepton.hh,
	src/Projections/DISLepton.cc: Fixed bug in projection. Introduced
	final state projection to limit searching for scattered
	lepton. Still not properly tested.

	-2007-06-08 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-06-08 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* include/Rivet/Projections/PVertex.hh,
	src/Projections/PVertex.cc: Fixed the projection to simply get the
	signal_process_vertex from the GenEvent. This is the way it should
	work. If the GenEvent does not have a signal_process_vertex
	properly set up in this way, the problem is with the class that
	fills the GenEvent.

	2007-06-06 Jon Butterworth <jmb@hep.ucl.ac.uk>

	* Merged TotalVisibleMomentum and CalMET
	* Added pT ranges to Vetoed final state projection

	2007-05-27 Jon Butterworth <jmb@hep.ucl.ac.uk>

	* Fixed initialization of VetoedFinalStateProjection in ExampleTree

	-2007-05-27 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-05-27 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* include/Rivet/Projections/KtJets.*: Make sure the KtEvent is
	deleted properly.

	2007-05-26 Jon Butterworth <jmb@hep.ucl.ac.uk>

	* Added leptons to the ExampleTree.
	* Added TotalVisibleEnergy projection, and added output to ExampleTree.

	2007-05-25 Jon Butterworth <jmb@hep.ucl.ac.uk>

	* Added a charged lepton projection

	2007-05-23 Andy Buckley <andy@insectnation.org>

	* src/Analysis/HepEx0409040.cc: Changed range of the histograms to
	the "pi" range rather than the "128" range.

	* src/Analysis/Analysis.cc: Fixed a bug in the AIDA path building.
	Histogram auto-booking now works.

	-2007-05-23 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-05-23 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* src/Analysis/HepEx9506012.cc: Now uses the histogram booking
	function in the Analysis class.

	2007-05-23 Jon Butterworth <jmb@hep.ucl.ac.uk>

	* Fixed bug in PRD65092002 (was failing on zero jets)

	2007-05-23 Andy Buckley <andy@insectnation.org>

	* Added (but haven't properly tested) a VetoedFinalState projection.

	* Added normalize() method for AIDA 1D histograms.

	* Added configure checking for Mac OS X version, and setting the
	development target flag accordingly.

	2007-05-22 Andy Buckley <andy@insectnation.org>

	* Added an ostream method for AnalysisName enums.

	* Converted Analyses and Projections to use projection lists, cuts
	and beam constraints.

	* Added beam pair combining to the BeamPair sets of Projections
	by finding set meta-intersections.

	* Added methods to Cuts, Analysis and Projection to make Cut
	definition easier.

	* Fixed default fall-through in cut handling switch statement and
	now using -numeric_limits<double>::max() rather than min()

	* Added more control of logging presentation via static flag
	methods on Log.

	2007-05-13 Andy Buckley <andy@insectnation.org>

	* Added self-consistency checking mechanisms for Cuts and Beam

	* Re-implemented the cut-handling part of RivetInfo as a Cuts class.

	* Changed names of Analysis and Projection name() and handler()
	methods to getName() and getHandler() to be more consistent with
	the rest of the public method names in those classes.

	2007-05-02 Andy Buckley <andy@insectnation.org>

	* Added auto-booking of histogram bins from AIDA XML files. The
	AIDA files are located via a C++ function which is generated from
	RivetPaths.cc.in by running configure.


	2007-04-18 Andy Buckley <andy@insectnation.org>

	* Added a preliminary version of the Rick Field UE analysis, under
	the name PRD65092002.

	-2007-04-19 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-04-19 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* src/Analysis/HepEx0409040.cc: The reason this did not compile
	under gcc-4 is that some iterators into a vector were wrongly
	assued to be pointers and were initialized to 0 and later compared
	to 0. I've changed this to initialize to end() of the
	corresponding vector and to compare with the same end() later.

	2007-04-05 Andy Buckley <andy@insectnation.org>

	* Lots of name changes in anticipation of the MCNet
	school. RivetHandler is now AnalysisHandler (since that's what it
	does!), BeamParticle has become ParticleName, and RivetInfo has
	been split into Cut and BeamConstraint portions.

	* Added BeamConstraint mechanism, which can be used to determine
	if an analysis is compatible with the beams being used in the
	generator. The ParticleName includes an "ANY" wildcard for this
	purpose.

	2006-03-19 Andy Buckley <andy@insectnation.org>

	* Added "rivet" executable which can read in HepMC ASCII dump
	files and apply Rivet analyses on the events.

	-2007-02-24 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-02-24 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* src/Projections/KtJets.cc: Added comparison of member variables
	in compare() function

	* all: Merged changes from polymorphic-projections branch into
	trunk

	-2007-02-17 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-02-17 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* all: projections and analysis handlers: All projections which
	uses other projctions now has a pointer rather than a copy of
	those projections to allow for polymorphism. The constructors has
	also been changed to require the used projections themselves,
	rather than the arguments needed to construct them.

	-2007-02-17 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-02-17 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* src/Projections/FinalState.cc,
	include/Rivet/Projections/FinalState.icc (Rivet),
	include/Rivet/Projections/FinalState.hh: Added cut in transverse
	momentum on the particles to be included in the final state.

	-2007-02-06 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-02-06 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* include/LWH/HistogramFactory.h: Fixed divide-by-zero in divide
	function. Also fixed bug in error calculation in divide
	function. Introduced checkBin function to make sure two histograms
	are equal even if they have variable bin widths.

	* include/LWH/Histogram1D.h: In normalize(double), do not do anything
	if the sum of the bins are zero to avoid dividing by zero.

	-2007-01-20 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2007-01-20 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* src/Test/testLWH.cc: Modified to output files using the Tree.

	* configure.ac: Removed AC_CONFIG_AUX_DIR([include/Rivet/Config])
	since the directory does not exist anymore.

	2006-12-21 Andy Buckley <andy@insectnation.org>

	* Rivet will now conditionally install the AIDA and LWH headers if
	it can't find them when configure'ing.

	* Started integrating Leif's LWH package to fulfill the AIDA
	duties.

	* Replaced multitude of CLHEP wrapper headers with a single
	RivetCLHEP.h header.

	2006-11-20 Andy Buckley <andy@insectnation.org>

	* Introduced log4cpp logging.

	* Added analysis enum, which can be used as input to an analysis
	factory by Rivet users.

	2006-11-02 Andy Buckley <andy@insectnation.org>

	* Yet more, almost pointless, administrative moving around of
	things with the intention of making the structure a bit
	better-defined:

	* The RivetInfo and RivetHandler classes have been
	moved from src/Analysis into src as they are really the main Rivet
	interface classes. The Rivet.h header has also been moved into the
	"header root".

	* The build of a single shared library in lib has been disabled,
	with the library being built instead in src.

	2006-10-14 Andy Buckley <andy@insectnation.org>

	* Introduced a minimal subset of the Sherpa math tools, such as
	Vector{3,4}D, Matrix, etc. The intention is to eventually cut the
	dependency on CLHEP.

	2006-07-28 Andy Buckley <andy@insectnation.org>

	* Moving things around: all sources now in directories under src

	-2006-06-04 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2006-06-04 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* Analysis/Examples/HZ95108.*: Now uses CentralEtHCM. Also set GeV
	units on the relevant histograms.

	* Projections/CentralEtHCM.*: Making a special class just to get
	out one number - the summed Et in the central rapidity bin - may
	seem like an overkill. But in case some one else might nees it...

	-2006-06-03 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2006-06-03 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* Analysis/Examples/HZ95108.*: Added the hz95108 energy flow
	analysis from HZtool.

	* Projections/DISLepton.*: Since many HERA measurements do not
	care if we have electron or positron beam, it is now possible to
	specify lepton or anti-lepton.

	* Projections/Event.*: Added member and access function for the
	weight of an event (taken from the GenEvent object.weights()[0].

	* Analysis/RivetHandler.*: Now depends explicitly on the AIDA
	interface. An AIDA analysis factory must be specified in the
	constructor, where a tree and histogram factory is automatically
	created. Added access functions to the relevant AIDA objects.

	* Analysis/AnalysisBase.*: Added access to the RivetHandler and
	its AIDA factories.

	-2005-12-27 Leif Lönnblad <Leif.Lonnblad@thep.lu.se>
	+2005-12-27 Leif Lonnblad <Leif.Lonnblad@thep.lu.se>

	* configure.ac: Added -I$THEPEGPATH/include to AM_CPPFLAGS.

	* Config/Rivet.h: Added some std incudes and using std::
	declaration.

	* Analysis/RivetInfo.*: Fixed some bugs. The RivetInfo facility
	now works, although it has not been thoroughly tested.

	* Analysis/Examples/TestMultiplicity.*: Re-introduced
	FinalStateHCM for testing purposes but commented it away again.

	* .: Made a number of changes to implement handling of RivetInfo
	objects.
	diff --git a/bin/make-plots b/bin/make-plots
	--- a/bin/make-plots
	+++ b/bin/make-plots
	@@ -1,2623 +1,2752 @@
	#! /usr/bin/env python

	"""\
	Usage: %prog [options] file.dat [file2.dat ...]

	TODO
	* Optimise output for e.g. lots of same-height bins in a row
	* Add a RatioFullRange directive to show the full range of error bars + MC envelope in the ratio
	* Tidy LaTeX-writing code -- faster to compile one doc only, then split it?
	* Handle boolean values flexibly (yes, no, true, false, etc. as well as 1, 0)
	"""

	##
	## This program is copyright by Hendrik Hoeth <hoeth@linta.de> and
	## the Rivet team https://rivet.hepforge.org. It may be used
	## for scientific and private purposes. Patches are welcome, but please don't
	## redistribute changed versions yourself.
	##

	## Check the Python version
	import sys
	if sys.version_info[:3] < (2,6,0):
	print "make-plots requires Python version >= 2.6.0... exiting"
	sys.exit(1)

	## Try to rename the process on Linux
	try:
	import ctypes
	libc = ctypes.cdll.LoadLibrary('libc.so.6')
	libc.prctl(15, 'make-plots', 0, 0, 0)
	except Exception, e:
	pass


	import os, logging, re
	import tempfile
	import getopt
	import string
	from math import *


	## Regex patterns
	pat_begin_block = re.compile(r'^#+\s*BEGIN ([A-Z0-9_]+) ?(\S+)?')
	pat_end_block = re.compile('^#+\s*END ([A-Z0-9_]+)')
	pat_comment = re.compile('^#\|^\s*$')
	pat_property = re.compile('^(\w+?)=(.*)$')
	pat_path_property = re.compile('^(\S+?)::(\w+?)=(.*)$')


	def fuzzyeq(a, b, tolerance=1e-6):
	"Fuzzy equality comparison function for floats, with given fractional tolerance"
	# if type(a) is not float or type(a) is not float:
	# print a, b
	if (a == 0 and abs(b) < 1e-12) or (b == 0 and abs(a) < 1e-12):
	return True
	return 2.0*abs(a-b)/abs(a+b) < tolerance

	+def inrange(x, a, b):
	+ return x >= a and x < b
	+
	+def floatify(x):
	+ if type(x) is str:
	+ x = x.split()
	+ if not hasattr(x, "__len__"):
	+ x = [x]
	+ x = [float(a) for a in x]
	+ return x[0] if len(x) == 1 else x
	+
	+def floatpair(x):
	+ if type(x) is str:
	+ x = x.split()
	+ if hasattr(x, "__len__"):
	+ assert len(x) == 2
	+ return [float(a) for a in x]
	+ return [float(x), float(x)]
	+

	def is_end_marker(line, blockname):
	m = pat_end_block.match(line)
	return m and m.group(1) == blockname

	def is_comment(line):
	return pat_comment.match(line) is not None



	-class Inputdata(object):
	+class Described(object):
	+ "Inherited functionality for objects holding a 'description' dictionary"
	+
	+ def __init__(self):
	+ pass
	+
	+ def has_attr(self, key):
	+ return self.description.has_key(key)
	+
	+ def set_attr(self, key, val):
	+ self.description[key] = val
	+
	+ def attr(self, key, default=None):
	+ return self.description.get(key, default)
	+
	+ def attr_bool(self, key, default=None):
	+ x = self.attr(key, default)
	+ if x is None: return None
	+ if str(x).lower() in ["1", "true", "yes", "on"]: return True
	+ if str(x).lower() in ["0", "false", "no", "off"]: return False
	+ return None
	+
	+ def attr_int(self, key, default=None):
	+ x = self.attr(key, default)
	+ try:
	+ x = int(x)
	+ except:
	+ x = None
	+ return x
	+
	+ def attr_float(self, key, default=None):
	+ x = self.attr(key, default)
	+ try:
	+ x = float(x)
	+ except:
	+ x = None
	+ return x
	+
	+
	+
	+class InputData(Described):

	def __init__(self, filename):
	self.filename = filename+".dat"
	self.histos = {}
	self.special = {}
	self.functions = {}

	self.description = {}
	self.pathdescriptions = []

	- self.description['is2dim'] = False
	- f = open(filename+'.dat')
	+ self.is2dim = False
	+ f = open(self.filename)
	for line in f:
	m = pat_begin_block.match(line)
	if m:
	name, path = m.group(1,2)
	if path is None and name != 'PLOT':
	raise Exception('BEGIN sections need a path name.')

	## Pass the reading of the block to separate functions
	if name == 'PLOT':
	self.read_input(f);
	elif name == 'SPECIAL':
	self.special[path] = Special(f)
	elif name == 'HISTOGRAM' or name == 'HISTOGRAM2D':
	self.histos[path] = Histogram(f, p=path)
	# self.histos[path].path = path
	self.description['is2dim'] = self.histos[path].is2dim
	elif name == 'HISTO1D':
	self.histos[path] = Histo1D(f, p=path)
	elif name == 'HISTO2D':
	self.histos[path] = Histo2D(f, p=path)
	self.description['is2dim'] = True
	elif name == 'FUNCTION':
	self.functions[path] = Function(f)
	# elif is_comment(line):
	# continue
	# else:
	# self.read_path_based_input(line)
	f.close()

	self.apply_config_files(opts.CONFIGFILES)

	-
	## Plot (and subplot) sizing
	+ # TODO: Use attr functions and bools properly
	self.description.setdefault('PlotSizeX', 10.)
	if self.description['is2dim']:
	self.description['PlotSizeX'] -= 1.7
	self.description['MainPlot'] = '1'
	self.description['RatioPlot'] = '0'

	if self.description.has_key('PlotSize') and self.description['PlotSize']!='':
	plotsizes = self.description['PlotSize'].split(',')
	self.description['PlotSizeX'] = float(plotsizes[0])
	self.description['PlotSizeY'] = float(plotsizes[1])
	if len(plotsizes) == 3:
	self.description['RatioPlotSizeY'] = float(plotsizes[2])
	del self.description['PlotSize']

	if self.description.get('MainPlot', '1') == '0':
	## Ratio, no main
	self.description['RatioPlot'] = '1' #< don't allow both to be zero!
	self.description['PlotSizeY'] = 0.
	self.description.setdefault('RatioPlotSizeY', 9.)
	else:
	if self.description.get('RatioPlot', '0') == '1':
	## Main and ratio
	self.description.setdefault('PlotSizeY', 6.)
	self.description.setdefault('RatioPlotSizeY', self.description.get('RatioPlotYSize', 3.))
	else:
	## Main, no ratio
	self.description.setdefault('PlotSizeY', self.description.get('PlotYSize', 9.))
	self.description['RatioPlotSizeY'] = 0.

	## Ensure numbers, not strings
	self.description['PlotSizeX'] = float(self.description['PlotSizeX'])
	self.description['PlotSizeY'] = float(self.description['PlotSizeY'])
	self.description['RatioPlotSizeY'] = float(self.description['RatioPlotSizeY'])
	# self.description['TopMargin'] = float(self.description['TopMargin'])
	# self.description['BottomMargin'] = float(self.description['BottomMargin'])

	self.description['LogX'] = self.description.has_key('LogX') and self.description['LogX']=='1'
	self.description['LogY'] = self.description.has_key('LogY') and self.description['LogY']=='1'
	self.description['LogZ'] = self.description.has_key('LogZ') and self.description['LogZ']=='1'
	if self.description.has_key('Rebin'):
	for i in self.histos:
	self.histos[i].description['Rebin'] = self.description['Rebin']

	histoordermap = {}
	histolist = self.histos.keys()
	if self.description.has_key('DrawOnly'):
	histolist = filter(self.histos.keys().count, self.description['DrawOnly'].strip().split())
	for histo in histolist:
	order = 0
	if self.histos[histo].description.has_key('PlotOrder'):
	order = int(self.histos[histo].description['PlotOrder'])
	if not order in histoordermap:
	histoordermap[order] = []
	histoordermap[order].append(histo)
	sortedhistolist = []
	for i in sorted(histoordermap.keys()):
	sortedhistolist.extend(histoordermap[i])
	- self.description['DrawOnly']=sortedhistolist
	-
	-
	- # inherit various values from histograms if not explicitly
	- # set.
	+ self.description['DrawOnly'] = sortedhistolist
	+
	+
	+ ## Inherit various values from histograms if not explicitly set
	for k in ['LogX', 'LogY', 'LogZ',
	'XLabel', 'YLabel', 'ZLabel',
	'XCustomMajorTicks', 'YCustomMajorTicks', 'ZCustomMajorTicks']:
	self.inherit_from_histos(k)

	return


	+ @property
	+ def is2dim(self):
	+ return self.attr_bool("is2dim", False)
	+ @is2dim.setter
	+ def is2dim(self, val):
	+ self.set_attr("is2dim", val)
	+
	+
	+ @property
	+ def drawonly(self):
	+ x = self.attr("DrawOnly")
	+ if type(x) is str:
	+ self.drawonly = x #< use setter to listify
	+ return x if x else []
	+ @drawonly.setter
	+ def drawonly(self, val):
	+ if type(val) is str:
	+ val = val.strip().split()
	+ self.set_attr("DrawOnly", val)
	+
	+
	+ @property
	+ def stacklist(self):
	+ x = self.attr("Stack")
	+ if type(x) is str:
	+ self.stacklist = x #< use setter to listify
	+ return x if x else []
	+ @stacklist.setter
	+ def stacklist(self, val):
	+ if type(val) is str:
	+ val = val.strip().split()
	+ self.set_attr("Stack", val)
	+
	+
	+ @property
	+ def plotorder(self):
	+ x = self.attr("PlotOrder")
	+ if type(x) is str:
	+ self.plotorder = x #< use setter to listify
	+ return x if x else []
	+ @plotorder.setter
	+ def plotorder(self, val):
	+ if type(val) is str:
	+ val = val.strip().split()
	+ self.set_attr("PlotOrder", val)
	+
	+
	+ @property
	+ def plotsizex(self):
	+ return self.attr_float("PlotSizeX")
	+ @plotsizex.setter
	+ def plotsizex(self, val):
	+ self.set_attr("PlotSizeX", val)
	+
	+ @property
	+ def plotsizey(self):
	+ return self.attr_float("PlotSizeY")
	+ @plotsizey.setter
	+ def plotsizey(self, val):
	+ self.set_attr("PlotSizeY", val)
	+
	+ @property
	+ def plotsize(self):
	+ return [self.plotsizex, self.plotsizey]
	+ @plotsize.setter
	+ def plotsize(self, val):
	+ if type(val) is str:
	+ val = [float(x) for x in val.split(",")]
	+ assert len(val) == 2
	+ self.plotsizex = val[0]
	+ self.plotsizey = val[1]
	+
	+ @property
	+ def ratiosizey(self):
	+ return self.attr_float("RatioPlotSizeY")
	+ @ratiosizey.setter
	+ def ratiosizey(self, val):
	+ self.set_attr("RatioPlotSizeY", val)
	+
	+
	+ @property
	+ def scale(self):
	+ return self.attr_float("Scale")
	+ @scale.setter
	+ def scale(self, val):
	+ self.set_attr("Scale", val)
	+
	+
	+ @property
	+ def xmin(self):
	+ return self.attr_float("XMin")
	+ @xmin.setter
	+ def xmin(self, val):
	+ self.set_attr("XMin", val)
	+
	+ @property
	+ def xmax(self):
	+ return self.attr_float("XMax")
	+ @xmax.setter
	+ def xmax(self, val):
	+ self.set_attr("XMax", val)
	+
	+ @property
	+ def xrange(self):
	+ return [self.xmin, self.xmax]
	+ @xrange.setter
	+ def xrange(self, val):
	+ if type(val) is str:
	+ val = [float(x) for x in val.split(",")]
	+ assert len(val) == 2
	+ self.xmin = val[0]
	+ self.xmax = val[1]
	+
	+
	+ @property
	+ def ymin(self):
	+ return self.attr_float("YMin")
	+ @ymin.setter
	+ def ymin(self, val):
	+ self.set_attr("YMin", val)
	+
	+ @property
	+ def ymax(self):
	+ return self.attr_float("YMax")
	+ @ymax.setter
	+ def ymax(self, val):
	+ self.set_attr("YMax", val)
	+
	+ @property
	+ def yrange(self):
	+ return [self.ymin, self.ymax]
	+ @yrange.setter
	+ def yrange(self, val):
	+ if type(val) is str:
	+ val = [float(y) for y in val.split(",")]
	+ assert len(val) == 2
	+ self.ymin = val[0]
	+ self.ymax = val[1]
	+
	+
	+ # TODO: add more rw properties for plotsize(x,y), ratiosize(y),
	+ # show_mainplot, show_ratioplot, show_legend, log(x,y,z), rebin,
	+ # drawonly, legendonly, plotorder, stack,
	+ # label(x,y,z), majorticks(x,y,z), minorticks(x,y,z),
	+ # min(x,y,z), max(x,y,z), range(x,y,z)
	+
	+
	def inherit_from_histos(self, k):
	- # note: this will inherit the key from a random histogram:
	- # only use if you're sure all histograms have this key!
	+ """Note: this will inherit the key from a random histogram:
	+ only use if you're sure all histograms have this key!"""
	if not self.description.has_key(k):
	h = list(self.histos.itervalues())[0]
	if h.description.has_key(k):
	self.description[k] = h.description[k]

	- return
	-
	-

	def read_input(self, f):
	for line in f:
	if is_end_marker(line, 'PLOT'):
	break
	elif is_comment(line):
	continue
	m = pat_property.match(line)
	if m:
	prop, value = m.group(1,2)
	if prop in self.description:
	logging.debug("Overwriting property %s = %s -> %s" % (prop, self.description[prop], value))
	## Use strip here to deal with DOS newlines containing \r
	self.description[prop.strip()] = value.strip()


	def apply_config_files(self, conffiles):
	if conffiles is not None:
	for filename in conffiles:
	cf = open(filename,'r')
	lines = cf.readlines()
	for i in range(0, len(lines)):
	## First evaluate PLOT sections
	m = pat_begin_block.match(lines[i])
	if m and m.group(1) == 'PLOT' and re.match(m.group(2),self.filename):
	while i<len(lines)-1:
	i = i+1
	if is_end_marker(lines[i], 'PLOT'):
	break
	elif is_comment(lines[i]):
	continue
	m = pat_property.match(lines[i])
	if m:
	prop, value = m.group(1,2)
	if prop in self.description:
	logging.debug("Overwriting from conffile property %s = %s -> %s" % (prop, self.description[prop], value))
	## Use strip here to deal with DOS newlines containing \r
	self.description[prop.strip()] = value.strip()
	elif is_comment(lines[i]):
	continue
	else:
	## Then evaluate path-based settings, e.g. for HISTOGRAMs
	m = pat_path_property.match(lines[i])
	if m:
	- regex, prop, value=m.group(1,2,3)
	+ regex, prop, value = m.group(1,2,3)
	for obj_dict in [self.special, self.histos, self.functions]:
	for path, obj in obj_dict.iteritems():
	if re.match(regex, path):
	## Use strip here to deal with DOS newlines containing \r
	obj.description.update({prop.strip() : value.strip()})
	cf.close()



	-
	class Plot(object):

	- def __init__(self,inputdata):
	+ def __init__(self, inputdata):
	pass

	def set_normalization(self,inputdata):
	for method in ['NormalizeToIntegral', 'NormalizeToSum']:
	if inputdata.description.has_key(method):
	- for i in inputdata.description['DrawOnly']:
	- if not inputdata.histos[i].description.has_key(method):
	- inputdata.histos[i].description[method] = inputdata.description[method]
	- if inputdata.description.has_key('Scale'):
	- for i in inputdata.description['DrawOnly']:
	- inputdata.histos[i].description['Scale'] = float(inputdata.description['Scale'])
	- for i in inputdata.description['DrawOnly']:
	+ for i in inputdata.drawonly:
	+ if not inputdata.histos[i].has_attr(method):
	+ inputdata.histos[i].set_attr(method, inputdata.attr(method))
	+ if inputdata.scale:
	+ for i in inputdata.drawonly:
	+ inputdata.histos[i].scale = inputdata.scale
	+ for i in inputdata.drawonly:
	inputdata.histos[i].mangle_input()

	def stack_histograms(self,inputdata):
	if inputdata.description.has_key('Stack'):
	- foo=[]
	- for i in inputdata.description['Stack'].strip().split():
	- if i in inputdata.histos.keys():
	- foo.append(i)
	- previous=''
	- for i in foo:
	- if previous!='':
	+ stackhists = [h for h in inputdata.attr('Stack').strip().split() if h in inputdata.histos]
	+ previous = ''
	+ for i in stackhists:
	+ if previous != '':
	inputdata.histos[i].add(inputdata.histos[previous])
	- previous=i
	+ previous = i

	def set_histo_options(self,inputdata):
	if inputdata.description.has_key('ConnectGaps'):
	for i in inputdata.histos.keys():
	if not inputdata.histos[i].description.has_key('ConnectGaps'):
	- inputdata.histos[i].description['ConnectGaps']=inputdata.description['ConnectGaps']
	-
	- def set_borders(self,inputdata):
	+ inputdata.histos[i].description['ConnectGaps'] = inputdata.description['ConnectGaps']
	+
	+ def set_borders(self, inputdata):
	self.set_xmax(inputdata)
	self.set_xmin(inputdata)
	self.set_ymax(inputdata)
	self.set_ymin(inputdata)
	self.set_zmax(inputdata)
	self.set_zmin(inputdata)
	- inputdata.description['Borders']=(self.xmin, self.xmax, self.ymin, self.ymax, self.zmin, self.zmax)
	-
	- def set_xmin(self,inputdata):
	- if inputdata.description.has_key('XMin'):
	- self.xmin = float(inputdata.description['XMin'])
	+ inputdata.description['Borders'] = (self.xmin, self.xmax, self.ymin, self.ymax, self.zmin, self.zmax)
	+
	+ def set_xmin(self, inputdata):
	+ self.xmin = inputdata.xmin
	+ if self.xmin is None:
	+ self.xmin = min(inputdata.histos[h].getXMin() for h in inputdata.description['DrawOnly'])
	+
	+ def set_xmax(self,inputdata):
	+ self.xmax = inputdata.xmax
	+ if self.xmax is None:
	+ self.xmax = min(inputdata.histos[h].getXMax() for h in inputdata.description['DrawOnly'])
	+
	+ def set_ymin(self,inputdata):
	+ if inputdata.ymin is not None:
	+ self.ymin = inputdata.ymin
	else:
	- self.xmin = min(inputdata.histos[i].getXMin() for i in inputdata.description['DrawOnly'])
	-
	- def set_xmax(self,inputdata):
	- #print inputdata.description
	- if inputdata.description.has_key('XMax'):
	- self.xmax = float(inputdata.description['XMax'])
	+ ymins = [inputdata.histos[i].getYMin(self.xmin, self.xmax, inputdata.description['LogY']) for i in inputdata.attr('DrawOnly')]
	+ minymin = min(ymins)
	+ if inputdata.description['is2dim']:
	+ self.ymin = minymin
	+ else:
	+ showzero = inputdata.attr_bool("ShowZero", True)
	+ if showzero:
	+ self.ymin = 0. if minymin > -1e-4 else 1.1*minymin
	+ else:
	+ self.ymin = 1.1minymin if minymin < -1e-4 else 0 if minymin < 1e-4 else 0.9minymin
	+ if inputdata.description['LogY']:
	+ ymins = [ymin for ymin in ymins if ymin > 0.0]
	+ if not ymins:
	+ if self.ymax == 0:
	+ self.ymax = 1
	+ ymins.append(2e-7*self.ymax)
	+ minymin = min(ymins)
	+ fullrange = opts.FULL_RANGE
	+ if inputdata.has_attr('FullRange'):
	+ fullrange = inputdata.attr_bool('FullRange')
	+ self.ymin = minymin/1.7 if fullrange else max(minymin/1.7, 2e-7*self.ymax)
	+
	+ if self.ymin == self.ymax:
	+ self.ymin -= 1
	+ self.ymax += 1
	+
	+ def set_ymax(self,inputdata):
	+ if inputdata.has_attr('YMax'):
	+ self.ymax = inputdata.attr_float('YMax')
	else:
	- #print inputdata.description['DrawOnly']
	- self.xmax = max(inputdata.histos[i].getXMax() for i in inputdata.description['DrawOnly'])
	-
	- def set_ymin(self,inputdata):
	- if inputdata.description.has_key('YMin'):
	- self.ymin = float(inputdata.description['YMin'])
	+ self.ymax = max(inputdata.histos[h].getYMax(self.xmin, self.xmax) for h in inputdata.attr('DrawOnly'))
	+ if not inputdata.is2dim:
	+ self.ymax *= (1.7 if inputdata.attr_bool('LogY') else 1.1)
	+
	+ def set_zmin(self,inputdata):
	+ if inputdata.has_attr('ZMin'):
	+ self.zmin = inputdata.attr_float('ZMin')
	else:
	- foo=[]
	- for i in inputdata.description['DrawOnly']:
	- foo.append(inputdata.histos[i].getYMin(self.xmin, self.xmax, inputdata.description['LogY']))
	- if inputdata.description['is2dim']:
	- self.ymin=min(foo)
	- else:
	- showzero = True
	- if inputdata.description.has_key('ShowZero'):
	- if inputdata.description['ShowZero']=='0':
	- showzero = False
	+ zmins = [inputdata.histos[i].getZMin(self.xmin, self.xmax, self.ymin, self.ymax) for i in inputdata.attr('DrawOnly')]
	+ minzmin = min(zmins)
	+ self.zmin = minzmin
	+ if zmins:
	+ showzero = inputdata.attr_bool('ShowZero', True)
	if showzero:
	- if min(foo) > -1e-4:
	- self.ymin = 0
	- else:
	- self.ymin = 1.1*min(foo)
	+ self.zmin = 0 if minzmin > -1e-4 else 1.1*minzmin
	else:
	- if min(foo) < -1e-4:
	- self.ymin = 1.1*min(foo)
	- elif min(foo) < 1e-4:
	- self.ymin = 0
	- else:
	- self.ymin = 0.9*min(foo)
	-
	- if inputdata.description['LogY']:
	- foo=[item for item in foo if item>0.0]
	- if len(foo)==0:
	- if self.ymax==0:
	- self.ymax=1
	- foo.append(2e-7*self.ymax)
	- fullrange = opts.FULL_RANGE
	- if inputdata.description.has_key('FullRange'):
	- if inputdata.description['FullRange']=='1':
	- fullrange = True
	- else:
	- fullrange = False
	- if fullrange:
	- self.ymin = min(foo)/1.7
	- else:
	- self.ymin = max(min(foo)/1.7, 2e-7*self.ymax)
	- if self.ymin==self.ymax:
	- self.ymin-=1
	- self.ymax+=1
	-
	- def set_ymax(self,inputdata):
	- if inputdata.description.has_key('YMax'):
	- self.ymax = float(inputdata.description['YMax'])
	- else:
	- foo=[]
	- for i in inputdata.description['DrawOnly']:
	- foo.append(inputdata.histos[i].getYMax(self.xmin, self.xmax))
	- if inputdata.description['is2dim']:
	- self.ymax=max(foo)
	- else:
	- if inputdata.description['LogY']:
	- self.ymax=1.7*max(foo)
	- else:
	- self.ymax=1.1*max(foo)
	-
	- def set_zmin(self,inputdata):
	- if inputdata.description.has_key('ZMin'):
	- self.zmin = float(inputdata.description['ZMin'])
	- else:
	- foo=[]
	- for i in inputdata.description['DrawOnly']:
	- foo.append(inputdata.histos[i].getZMin(self.xmin, self.xmax, self.ymin, self.ymax))
	- if not foo:
	- self.zmin = min(foo)
	- else:
	- showzero = True
	- if inputdata.description.has_key('ShowZero'):
	- if inputdata.description['ShowZero']=='0':
	- showzero = False
	- if showzero:
	- if min(foo) > -1e-4:
	- self.zmin = 0
	- else:
	- self.zmin = 1.1*min(foo)
	- else:
	- if min(foo) < -1e-4:
	- self.zmin = 1.1*min(foo)
	- elif min(foo) < 1e-4:
	- self.zmin = 0
	- else:
	- self.zmin = 0.9*min(foo)
	-
	- if inputdata.description['LogZ']:
	- foo=[item for item in foo if item>0.0]
	- if len(foo)==0:
	- if self.zmax==0:
	- self.zmax=1
	- foo.append(2e-7*self.zmax)
	- fullrange = opts.FULL_RANGE
	- if inputdata.description.has_key('FullRange'):
	- if inputdata.description['FullRange']=='1':
	- fullrange = True
	- else:
	- fullrange = False
	- if fullrange:
	- self.zmin = min(foo)/1.7
	- else:
	- self.zmin = max(min(foo)/1.7, 2e-7*self.zmax)
	- if self.zmin==self.zmax:
	- self.zmin-=1
	- self.zmax+=1
	+ self.zmin = 1.1minzmin if minzmin < -1e-4 else 0. if minzmin < 1e-4 else 0.9minzmin
	+ if inputdata.attr_bool('LogZ', False):
	+ zmins = [zmin for zmin in zmins if zmin > 0]
	+ if not zmins:
	+ if self.zmax == 0:
	+ self.zmax = 1
	+ zmins.append(2e-7*self.zmax)
	+ minzmin = min(zmins)
	+ fullrange = inputdata.attr_bool("FullRange", opts.FULL_RANGE)
	+ self.zmin = minzmin/1.7 if fullrange else max(minzmin/1.7, 2e-7*self.zmax)
	+
	+ if self.zmin == self.zmax:
	+ self.zmin -= 1
	+ self.zmax += 1

	def set_zmax(self,inputdata):
	- if inputdata.description.has_key('ZMax'):
	- self.zmax = float(inputdata.description['ZMax'])
	- else:
	- foo=[]
	- for i in inputdata.description['DrawOnly']:
	- foo.append(inputdata.histos[i].getZMax(self.xmin, self.xmax, self.ymin, self.ymax))
	- if foo:
	- self.zmax = max(foo)
	- else:
	- self.zmax = 1
	+ self.zmax = inputdata.attr_float('ZMax')
	+ if self.zmax is None:
	+ zmaxs = [inputdata.histos[h].getZMax(self.xmin, self.xmax, self.ymin, self.ymax) for h in inputdata.attr('DrawOnly')]
	+ self.zmax = max(zmaxs) if zmaxs else 1


	def draw(self):
	pass

	+
	def write_header(self,inputdata):
	if inputdata.description.has_key('LeftMargin') and inputdata.description['LeftMargin']!='':
	inputdata.description['LeftMargin'] = float(inputdata.description['LeftMargin'])
	else:
	inputdata.description['LeftMargin'] = 1.4
	if inputdata.description.has_key('RightMargin') and inputdata.description['RightMargin']!='':
	inputdata.description['RightMargin'] = float(inputdata.description['RightMargin'])
	else:
	inputdata.description['RightMargin'] = 0.35
	if inputdata.description.has_key('TopMargin') and inputdata.description['TopMargin']!='':
	inputdata.description['TopMargin'] = float(inputdata.description['TopMargin'])
	else:
	inputdata.description['TopMargin'] = 0.65
	if inputdata.description.has_key('BottomMargin') and inputdata.description['BottomMargin']!='':
	inputdata.description['BottomMargin'] = float(inputdata.description['BottomMargin'])
	else:
	inputdata.description['BottomMargin'] = 0.95
	if inputdata.description['is2dim']:
	inputdata.description['RightMargin'] += 1.7
	papersizex = inputdata.description['PlotSizeX'] + 0.1 + \
	inputdata.description['LeftMargin'] + inputdata.description['RightMargin']
	papersizey = inputdata.description['PlotSizeY'] + inputdata.description['RatioPlotSizeY'] + 0.1 + \
	inputdata.description['TopMargin'] + inputdata.description['BottomMargin']
	#
	out = ""
	out += '\\documentclass{article}\n'
	if opts.OUTPUT_FONT == "MINION":
	out += ('\\usepackage{minion}\n')
	elif opts.OUTPUT_FONT == "PALATINO_OSF":
	out += ('\\usepackage[osf,sc]{mathpazo}\n')
	elif opts.OUTPUT_FONT == "PALATINO":
	out += ('\\usepackage{mathpazo}\n')
	elif opts.OUTPUT_FONT == "TIMES":
	out += ('\\usepackage{mathptmx}\n')
	elif opts.OUTPUT_FONT == "HELVETICA":
	out += ('\\renewcommand{\\familydefault}{\\sfdefault}\n')
	out += ('\\usepackage{sfmath}\n')
	out += ('\\usepackage{helvet}\n')
	out += ('\\usepackage[symbolgreek]{mathastext}\n')
	for pkg in opts.LATEXPKGS:
	out += ('\\usepackage{%s}\n' % pkg)
	out += ('\\usepackage{pst-all}\n')
	out += ('\\usepackage{xcolor}\n')
	out += ('\\selectcolormodel{rgb}\n')
	out += ('\\definecolor{red}{HTML}{EE3311}\n') # (Google uses 'DC3912')
	out += ('\\definecolor{blue}{HTML}{3366FF}')
	out += ('\\definecolor{green}{HTML}{109618}')
	out += ('\\definecolor{orange}{HTML}{FF9900}')
	out += ('\\definecolor{lilac}{HTML}{990099}')
	out += ('\\usepackage{amsmath}\n')
	out += ('\\usepackage{amssymb}\n')
	out += ('\\usepackage{relsize}\n')
	out += ('\\usepackage[dvips,\n')
	- out += (' left=%4.3fcm, right=0cm,\n' %(inputdata.description['LeftMargin']-0.45,))
	- out += (' top=%4.3fcm, bottom=0cm,\n' %(inputdata.description['TopMargin']-0.30,))
	- out += (' paperwidth=%scm,paperheight=%scm\n' %(papersizex,papersizey))
	+ out += (' left=%4.3fcm, right=0cm,\n' % (inputdata.description['LeftMargin']-0.45,))
	+ out += (' top=%4.3fcm, bottom=0cm,\n' % (inputdata.description['TopMargin']-0.30,))
	+ out += (' paperwidth=%scm,paperheight=%scm\n' % (papersizex,papersizey))
	out += (']{geometry}\n')
	out += ('\\begin{document}\n')
	out += ('\\pagestyle{empty}\n')
	out += ('\\SpecialCoor\n')
	out += ('\\begin{pspicture}(0,0)(0,0)\n')
	out += ('\\psset{xunit=%scm}\n' %(inputdata.description['PlotSizeX']))
	if inputdata.description['is2dim']:
	if inputdata.description.has_key('ColorSeries') and inputdata.description['ColorSeries']!='':
	colorseries = inputdata.description['ColorSeries']
	else:
	colorseries = '{hsb}{grad}[rgb]{0,0,1}{-.700,0,0}'
	out += ('\\definecolorseries{gradientcolors}%s\n' % colorseries)
	out += ('\\resetcolorseries[130]{gradientcolors}\n')
	return out

	def write_footer(self):
	out = ""
	out += ('\\end{pspicture}\n')
	out += ('\\end{document}\n')
	return out



	class MainPlot(Plot):

	def __init__(self, inputdata):
	self.set_normalization(inputdata)
	self.stack_histograms(inputdata)
	if (inputdata.description.has_key('GofLegend') and inputdata.description['GofLegend']=='1') or \
	(inputdata.description.has_key('GofFrame') and inputdata.description['GofFrame']!='') and not \
	(inputdata.description.has_key('TaylorPlot') and inputdata.description['TaylorPlot']=='1'):
	self.calculate_gof(inputdata)
	self.set_histo_options(inputdata)
	self.set_borders(inputdata)
	self.yoffset = inputdata.description['PlotSizeY']
	self.coors = Coordinates(inputdata)

	def draw(self, inputdata):
	out = ""
	out += ('\n%\n% MainPlot\n%\n')
	out += ('\\psset{yunit=%scm}\n' %(self.yoffset))
	out += ('\\rput(0,-1){%\n')
	out += ('\\psset{yunit=%scm}\n' %(inputdata.description['PlotSizeY']))
	out += self._draw(inputdata)
	out += ('}\n')
	return out

	def _draw(self, inputdata):
	out = ""
	- if inputdata.description.has_key('DrawSpecialFirst') and inputdata.description['DrawSpecialFirst']=='1':
	- for i in inputdata.special.keys():
	- out += inputdata.special[i].draw(self.coors)
	- if inputdata.description.has_key('DrawFunctionFirst') and inputdata.description['DrawFunctionFirst']=='1':
	- for i in inputdata.functions.keys():
	- out += inputdata.functions[i].draw(self.coors)
	+
	+ # TODO: do this more compactly, e.g. by assigning sorting keys!
	+ if inputdata.attr_bool('DrawSpecialFirst', False):
	+ for s in inputdata.special:
	+ out += s.draw(self.coors)
	+ if inputdata.attr_bool('DrawFunctionFirst', False):
	+ for f in inputdata.functions:
	+ out += f.draw(self.coors)
	for i in inputdata.description['DrawOnly']:
	out += inputdata.histos[i].draw(self.coors)
	else:
	for i in inputdata.description['DrawOnly']:
	out += inputdata.histos[i].draw(self.coors)
	- for i in inputdata.functions.keys():
	- out += inputdata.functions[i].draw(self.coors)
	+ for f in inputdata.functions:
	+ out += f.draw(self.coors)
	else:
	- if inputdata.description.has_key('DrawFunctionFirst') and inputdata.description['DrawFunctionFirst']=='1':
	- for i in inputdata.functions.keys():
	- out += inputdata.functions[i].draw(self.coors)
	+ if inputdata.attr_bool('DrawFunctionFirst', False):
	+ for f in inputdata.functions:
	+ out += f.draw(self.coors)
	for i in inputdata.description['DrawOnly']:
	out += inputdata.histos[i].draw(self.coors)
	else:
	for i in inputdata.description['DrawOnly']:
	out += inputdata.histos[i].draw(self.coors)
	- for i in inputdata.functions.keys():
	- out += inputdata.functions[i].draw(self.coors)
	+ for f in inputdata.functions:
	+ out += f.draw(self.coors)
	for i in inputdata.special.keys():
	out += inputdata.special[i].draw(self.coors)
	- if inputdata.description.has_key('Legend') and inputdata.description['Legend']=='1':
	+
	+ if inputdata.attr_bool('Legend', False):
	legend = Legend(inputdata.description,inputdata.histos,inputdata.functions)
	out += legend.draw()
	if inputdata.description['is2dim']:
	- colorscale = Colorscale(inputdata.description,self.coors)
	+ colorscale = ColorScale(inputdata.description, self.coors)
	out += colorscale.draw()
	frame = Frame()
	out += frame.draw(inputdata)

	- if inputdata.description.has_key('XMajorTickMarks') and inputdata.description['XMajorTickMarks']!='':
	- xcustommajortickmarks=int(inputdata.description['XMajorTickMarks'])
	- else:
	- xcustommajortickmarks=-1
	- if inputdata.description.has_key('XMinorTickMarks') and inputdata.description['XMinorTickMarks']!='':
	- xcustomminortickmarks=int(inputdata.description['XMinorTickMarks'])
	- else:
	- xcustomminortickmarks=-1
	- xcustommajorticks=None
	- xcustomminorticks=None
	- if inputdata.description.has_key('XCustomMajorTicks'): # and inputdata.description['XCustomMajorTicks']!='':
	- xcustommajorticks=[]
	- FOO=inputdata.description['XCustomMajorTicks'].strip().split() #'\t')
	- if len(FOO) % 2 == 0:
	- for i in range(0,len(FOO),2):
	- xcustommajorticks.append({'Value': float(FOO[i]), 'Label': FOO[i+1]})
	- if inputdata.description.has_key('XCustomMinorTicks'): # and inputdata.description['XCustomMinorTicks']!='':
	- FOO=inputdata.description['XCustomMinorTicks'].strip().split() #'\t')
	- xcustomminorticks=[{'Value': float(FOO[i])} for i in range(len(FOO))]
	+ xcustommajortickmarks = inputdata.attr_int('XMajorTickMarks', -1)
	+ xcustomminortickmarks = inputdata.attr_int('XMinorTickMarks', -1)
	+
	+ xcustommajorticks = xcustomminorticks = None
	+ if inputdata.attr('XCustomMajorTicks'):
	+ xcustommajorticks = []
	+ x_label_pairs = inputdata.attr('XCustomMajorTicks').strip().split() #'\t')
	+ if len(x_label_pairs) % 2 == 0:
	+ for i in range(0, len(x_label_pairs), 2):
	+ xcustommajorticks.append({'Value': float(x_label_pairs[i]), 'Label': x_label_pairs[i+1]})
	+ else:
	+ print "Warning: XCustomMajorTicks requires an even number of alternating pos/label entries"
	+
	+ if inputdata.attr('XCustomMinorTicks'):
	+ xs = inputdata.attr('XCustomMinorTicks').strip().split() #'\t')
	+ xcustomminorticks = [{'Value': float(x)} for x in xs]
	+
	xticks = XTicks(inputdata.description, self.coors)
	- if (inputdata.description.has_key('RatioPlot') and inputdata.description['RatioPlot']=='1') or (inputdata.description.has_key('PlotXTickLabels') and inputdata.description['PlotXTickLabels']=='0'):
	- drawxlabels=False
	- else:
	- drawxlabels=True
	- out += xticks.draw(custommajortickmarks=xcustommajortickmarks,\
	- customminortickmarks=xcustomminortickmarks,\
	- custommajorticks=xcustommajorticks,\
	- customminorticks=xcustomminorticks,\
	+ drawxlabels = inputdata.attr_bool('PlotXTickLabels', True) and not inputdata.attr_bool('RatioPlot', False)
	+
	+ out += xticks.draw(custommajortickmarks=xcustommajortickmarks,
	+ customminortickmarks=xcustomminortickmarks,
	+ custommajorticks=xcustommajorticks,
	+ customminorticks=xcustomminorticks,
	drawlabels=drawxlabels)

	- if inputdata.description.has_key('YMajorTickMarks') and inputdata.description['YMajorTickMarks']!='':
	- ycustommajortickmarks=int(inputdata.description['YMajorTickMarks'])
	- else:
	- ycustommajortickmarks=-1
	- if inputdata.description.has_key('YMinorTickMarks') and inputdata.description['YMinorTickMarks']!='':
	- ycustomminortickmarks=int(inputdata.description['YMinorTickMarks'])
	- else:
	- ycustomminortickmarks=-1
	- ycustommajorticks=None
	- ycustomminorticks=None
	- if inputdata.description.has_key('YCustomMajorTicks'): # and inputdata.description['YCustomMajorTicks']!='':
	- ycustommajorticks=[]
	- FOO=inputdata.description['YCustomMajorTicks'].strip().split() #'\t')
	- if len(FOO) % 2 == 0:
	- for i in range(0,len(FOO),2):
	- ycustommajorticks.append({'Value': float(FOO[i]), 'Label': FOO[i+1]})
	- if inputdata.description.has_key('YCustomMinorTicks'): # and inputdata.description['YCustomMinorTicks']!='':
	- FOO=inputdata.description['YCustomMinorTicks'].strip().split() #'\t')
	- ycustomminorticks=[{'Value': float(FOO[i])} for i in range(len(FOO))]
	+ ycustommajortickmarks = inputdata.attr_int('YMajorTickMarks', -1)
	+ ycustomminortickmarks = inputdata.attr_int('YMinorTickMarks', -1)
	+
	+ ycustommajorticks = ycustomminorticks = None
	+ if inputdata.description.has_key('YCustomMajorTicks'):
	+ ycustommajorticks = []
	+ y_label_pairs = inputdata.description['YCustomMajorTicks'].strip().split() #'\t')
	+ if len(y_label_pairs) % 2 == 0:
	+ for i in range(0, len(y_label_pairs), 2):
	+ ycustommajorticks.append({'Value': float(y_label_pairs[i]), 'Label': y_label_pairs[i+1]})
	+ else:
	+ print "Warning: YCustomMajorTicks requires an even number of alternating pos/label entries"
	+
	+ if inputdata.has_attr('YCustomMinorTicks'):
	+ ys = inputdata.attr('YCustomMinorTicks').strip().split() #'\t')
	+ ycustomminorticks = [{'Value': float(y)} for y in ys]
	+
	yticks = YTicks(inputdata.description, self.coors)
	- if (inputdata.description.has_key('PlotYTickLabels') and inputdata.description['PlotYTickLabels']=='0'):
	- drawylabels=False
	- else:
	- drawylabels=True
	+ drawylabels = inputdata.attr_bool('PlotYTickLabels', True)
	+
	out += yticks.draw(custommajortickmarks=ycustommajortickmarks,
	customminortickmarks=ycustomminortickmarks,
	custommajorticks=ycustommajorticks,
	customminorticks=ycustomminorticks,
	drawlabels=drawylabels)

	labels = Labels(inputdata.description)
	- if inputdata.description.has_key('RatioPlot') and inputdata.description['RatioPlot']=='1':
	- out += labels.draw(['Title','YLabel'])
	+ if inputdata.attr_bool('RatioPlot', False):
	+ olab = labels.draw(['Title','YLabel'])
	else:
	if not inputdata.description['is2dim']:
	- out += labels.draw(['Title','XLabel','YLabel'])
	+ olab = labels.draw(['Title','XLabel','YLabel'])
	else:
	- out += labels.draw(['Title','XLabel','YLabel','ZLabel'])
	+ olab = labels.draw(['Title','XLabel','YLabel','ZLabel'])
	+ out += olab
	return out

	+
	def calculate_gof(self, inputdata):
	refdata = inputdata.description.get('GofReference')
	if refdata is None:
	refdata = inputdata.description.get('RatioPlotReference')

	if refdata is None:
	inputdata.description['GofLegend'] = '0'
	inputdata.description['GofFrame'] = ''
	return

	def pickcolor(gof):
	color = None
	colordefs = {}
	for i in inputdata.description.setdefault('GofFrameColor', '0:green 3:yellow 6:red!70').strip().split():
	foo = i.split(':')
	- if len(foo)!=2: continue
	+ if len(foo) != 2:
	+ continue
	colordefs[float(foo[0])] = foo[1]
	for i in sorted(colordefs.keys()):
	if gof>=i:
	color=colordefs[i]
	return color

	- inputdata.description.setdefault('GofLegend','0')
	- inputdata.description.setdefault('GofFrame','')
	- inputdata.description.setdefault('FrameColor',None)
	+ inputdata.description.setdefault('GofLegend', '0')
	+ inputdata.description.setdefault('GofFrame', '')
	+ inputdata.description.setdefault('FrameColor', None)

	for i in inputdata.description['DrawOnly']:
	- if i==refdata: continue
	- if inputdata.description['GofLegend']!='1' and i!=inputdata.description['GofFrame']: continue
	+ if i == refdata:
	+ continue
	+ if inputdata.description['GofLegend']!='1' and i!=inputdata.description['GofFrame']:
	+ continue

	if inputdata.description.has_key('GofType') and inputdata.description['GofType']!='chi2':
	return
	gof = inputdata.histos[i].getChi2(inputdata.histos[refdata])
	- if i==inputdata.description['GofFrame'] and inputdata.description['FrameColor'] is None:
	- inputdata.description['FrameColor']=pickcolor(gof)
	- if inputdata.histos[i].description.setdefault('Title', '')!='':
	+ if i == inputdata.description['GofFrame'] and inputdata.description['FrameColor'] is None:
	+ inputdata.description['FrameColor'] = pickcolor(gof)
	+ if inputdata.histos[i].description.setdefault('Title', '') != '':
	inputdata.histos[i].description['Title'] += ', '
	inputdata.histos[i].description['Title'] += '$\\chi^2/n={}$%1.2f' %gof



	class TaylorPlot(Plot):

	def __init__(self, inputdata):
	self.refdata = inputdata.description['TaylorPlotReference']
	self.calculate_taylorcoordinates(inputdata)

	def calculate_taylorcoordinates(self,inputdata):
	- foo=inputdata.description['DrawOnly'].pop(inputdata.description['DrawOnly'].index(self.refdata))
	+ foo = inputdata.description['DrawOnly'].pop(inputdata.description['DrawOnly'].index(self.refdata))
	inputdata.description['DrawOnly'].append(foo)
	for i in inputdata.description['DrawOnly']:
	print i
	print 'meanbinval = ', inputdata.histos[i].getMeanBinValue()
	print 'sigmabinval = ', inputdata.histos[i].getSigmaBinValue()
	print 'chi2/nbins = ', inputdata.histos[i].getChi2(inputdata.histos[self.refdata])
	print 'correlation = ', inputdata.histos[i].getCorrelation(inputdata.histos[self.refdata])
	print 'distance = ', inputdata.histos[i].getRMSdistance(inputdata.histos[self.refdata])



	class RatioPlot(Plot):

	def __init__(self, inputdata):
	+
	self.refdata = inputdata.description['RatioPlotReference']
	self.yoffset = inputdata.description['PlotSizeY'] + inputdata.description['RatioPlotSizeY']
	+
	inputdata.description['RatioPlotStage'] = True
	inputdata.description['PlotSizeY'] = inputdata.description['RatioPlotSizeY']
	inputdata.description['LogY'] = False
	+
	# TODO: It'd be nice it this wasn't so MC-specific
	if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='deviation':
	- inputdata.description['YLabel']='$(\\text{MC}-\\text{data})$'
	- inputdata.description['YMin']=-3.5
	- inputdata.description['YMax']=3.5
	+ inputdata.description['YLabel'] = '$(\\text{MC}-\\text{data})$'
	+ inputdata.description['YMin'] = -3.5
	+ inputdata.description['YMax'] = 3.5
	elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='datamc':
	- inputdata.description['YLabel']='Data/MC'
	- inputdata.description['YMin']=0.5
	- inputdata.description['YMax']=1.5
	+ inputdata.description['YLabel'] = 'Data/MC'
	+ inputdata.description['YMin'] = 0.5
	+ inputdata.description['YMax'] = 1.5
	else:
	- inputdata.description['YLabel']='MC/Data'
	- inputdata.description['YMin']=0.5
	- inputdata.description['YMax']=1.5
	+ inputdata.description['YLabel'] = 'MC/Data'
	+ inputdata.description['YMin'] = 0.5
	+ inputdata.description['YMax'] = 1.5
	+
	if inputdata.description.has_key('RatioPlotYLabel'):
	inputdata.description['YLabel'] = inputdata.description['RatioPlotYLabel']
	inputdata.description['YLabel']='\\rput(-%s,0){%s}'%(0.5*inputdata.description['PlotSizeY']/inputdata.description['PlotSizeX'],inputdata.description['YLabel'])
	+
	if inputdata.description.has_key('RatioPlotYMin'):
	- inputdata.description['YMin']=inputdata.description['RatioPlotYMin']
	+ inputdata.description['YMin'] = inputdata.description['RatioPlotYMin']
	if inputdata.description.has_key('RatioPlotYMax'):
	- inputdata.description['YMax']=inputdata.description['RatioPlotYMax']
	+ inputdata.description['YMax'] = inputdata.description['RatioPlotYMax']
	+
	if not inputdata.description.has_key('RatioPlotErrorBandColor'):
	- inputdata.description['RatioPlotErrorBandColor']='yellow'
	- if not inputdata.description.has_key('RatioPlotSameStyle') or inputdata.description['RatioPlotSameStyle']=='0':
	- inputdata.histos[self.refdata].description['ErrorBandColor']=inputdata.description['RatioPlotErrorBandColor']
	- inputdata.histos[self.refdata].description['ErrorBands']='1'
	- inputdata.histos[self.refdata].description['ErrorBars']='0'
	- inputdata.histos[self.refdata].description['LineStyle']='solid'
	- inputdata.histos[self.refdata].description['LineColor']='black'
	- inputdata.histos[self.refdata].description['LineWidth']='0.3pt'
	- inputdata.histos[self.refdata].description['PolyMarker']=''
	- inputdata.histos[self.refdata].description['ConnectGaps']='1'
	+ inputdata.description['RatioPlotErrorBandColor'] = 'yellow'
	+ if not inputdata.description.has_key('RatioPlotSameStyle') or inputdata.description['RatioPlotSameStyle'] == '0':
	+ inputdata.histos[self.refdata].description['ErrorBandColor'] = inputdata.description['RatioPlotErrorBandColor']
	+ inputdata.histos[self.refdata].description['ErrorBands'] = '1'
	+ inputdata.histos[self.refdata].description['ErrorBars'] = '0'
	+ inputdata.histos[self.refdata].description['LineStyle'] = 'solid'
	+ inputdata.histos[self.refdata].description['LineColor'] = 'black'
	+ inputdata.histos[self.refdata].description['LineWidth'] = '0.3pt'
	+ inputdata.histos[self.refdata].description['PolyMarker'] = ''
	+ inputdata.histos[self.refdata].description['ConnectGaps'] = '1'
	+
	self.calculate_ratios(inputdata)
	self.set_borders(inputdata)
	self.coors = Coordinates(inputdata)

	def draw(self, inputdata):
	out = ""
	out += ('\n%\n% RatioPlot\n%\n')
	out += ('\\psset{yunit=%scm}\n' %(self.yoffset))
	out += ('\\rput(0,-1){%\n')
	out += ('\\psset{yunit=%scm}\n' %(inputdata.description['PlotSizeY']))
	out += self._draw(inputdata)
	out += ('}\n')
	return out

	- def calculate_ratios(self,inputdata):
	- foo=inputdata.description['DrawOnly'].pop(inputdata.description['DrawOnly'].index(self.refdata))
	+ def calculate_ratios(self, inputdata):
	+ foo = inputdata.description['DrawOnly'].pop(inputdata.description['DrawOnly'].index(self.refdata))
	if inputdata.histos[self.refdata].description.has_key('ErrorBands') and inputdata.histos[self.refdata].description['ErrorBands']=='1':
	inputdata.description['DrawOnly'].insert(0,foo)
	else:
	inputdata.description['DrawOnly'].append(foo)
	for i in inputdata.description['DrawOnly']:
	- if i!=self.refdata:
	- if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='deviation':
	+ if i != self.refdata:
	+ if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'deviation':
	inputdata.histos[i].deviation(inputdata.histos[self.refdata])
	- elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='datamc':
	+ elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'datamc':
	inputdata.histos[i].dividereverse(inputdata.histos[self.refdata])
	- inputdata.histos[i].description['ErrorBars']='1'
	+ inputdata.histos[i].description['ErrorBars'] = '1'
	else:
	inputdata.histos[i].divide(inputdata.histos[self.refdata])
	- if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='deviation':
	+ if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'deviation':
	inputdata.histos[self.refdata].deviation(inputdata.histos[self.refdata])
	- elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='datamc':
	+ elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'datamc':
	inputdata.histos[self.refdata].dividereverse(inputdata.histos[self.refdata])
	else:
	inputdata.histos[self.refdata].divide(inputdata.histos[self.refdata])

	def _draw(self, inputdata):
	out = ""
	for i in inputdata.description['DrawOnly']:
	- if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='datamc':
	- if i!=self.refdata:
	+ if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'datamc':
	+ if i != self.refdata:
	out += inputdata.histos[i].draw(self.coors)
	else:
	out += inputdata.histos[i].draw(self.coors)

	frame = Frame()
	out += frame.draw(inputdata)

	# TODO: so much duplication with MainPlot... yuck!
	- if inputdata.description.has_key('XMajorTickMarks') and inputdata.description['XMajorTickMarks']!='':
	- xcustommajortickmarks=int(inputdata.description['XMajorTickMarks'])
	+ if inputdata.description.has_key('XMajorTickMarks') and inputdata.description['XMajorTickMarks'] != '':
	+ xcustommajortickmarks = int(inputdata.description['XMajorTickMarks'])
	else:
	- xcustommajortickmarks=-1
	- if inputdata.description.has_key('XMinorTickMarks') and inputdata.description['XMinorTickMarks']!='':
	- xcustomminortickmarks=int(inputdata.description['XMinorTickMarks'])
	+ xcustommajortickmarks = -1
	+ if inputdata.description.has_key('XMinorTickMarks') and inputdata.description['XMinorTickMarks'] != '':
	+ xcustomminortickmarks = int(inputdata.description['XMinorTickMarks'])
	else:
	- xcustomminortickmarks=-1
	- xcustommajorticks=None
	- xcustomminorticks=None
	+ xcustomminortickmarks =- 1
	+
	+ xcustommajorticks = None
	if inputdata.description.has_key('XCustomMajorTicks'): # and inputdata.description['XCustomMajorTicks']!='':
	- xcustommajorticks=[]
	- FOO=inputdata.description['XCustomMajorTicks'].strip().split() #'\t')
	- if not len(FOO)%2:
	- for i in range(0,len(FOO),2):
	- xcustommajorticks.append({'Value': float(FOO[i]), 'Label': FOO[i+1]})
	+ xcustommajorticks = []
	+ tickstr = inputdata.description['XCustomMajorTicks'].strip().split() #'\t')
	+ if not len(tickstr) % 2:
	+ for i in range(0, len(tickstr), 2):
	+ xcustommajorticks.append({'Value': float(tickstr[i]), 'Label': tickstr[i+1]})
	+
	+ xcustomminorticks = None
	if inputdata.description.has_key('XCustomMinorTicks'): # and inputdata.description['XCustomMinorTicks']!='':
	- xcustomminorticks=[]
	- FOO=inputdata.description['XCustomMinorTicks'].strip().split() #'\t')
	- for i in range(len(FOO)):
	- xcustomminorticks.append({'Value': float(FOO[i])})
	+ xcustomminorticks = []
	+ tickstr = inputdata.description['XCustomMinorTicks'].strip().split() #'\t')
	+ for i in range(len(tickstr)):
	+ xcustomminorticks.append({'Value': float(tickstr[i])})
	+
	xticks = XTicks(inputdata.description, self.coors)
	- if inputdata.description.has_key('RatioPlotTickLabels') and inputdata.description['RatioPlotTickLabels']=='0':
	- drawlabels=False
	- else:
	- drawlabels=True
	- out += xticks.draw(custommajortickmarks=xcustommajortickmarks,\
	- customminortickmarks=xcustomminortickmarks,\
	- custommajorticks=xcustommajorticks,\
	+ drawlabels = not (inputdata.description.has_key('RatioPlotTickLabels') and inputdata.description['RatioPlotTickLabels']=='0')
	+ out += xticks.draw(custommajortickmarks=xcustommajortickmarks,
	+ customminortickmarks=xcustomminortickmarks,
	+ custommajorticks=xcustommajorticks,
	customminorticks=xcustomminorticks,
	drawlabels=drawlabels)

	- if inputdata.description.has_key('YMajorTickMarks') and inputdata.description['YMajorTickMarks']!='':
	- ycustommajortickmarks=int(inputdata.description['YMajorTickMarks'])
	- else:
	- ycustommajortickmarks=-1
	- if inputdata.description.has_key('YMinorTickMarks') and inputdata.description['YMinorTickMarks']!='':
	- ycustomminortickmarks=int(inputdata.description['YMinorTickMarks'])
	- else:
	- ycustomminortickmarks=-1
	- ycustommajorticks=None
	- ycustomminorticks=None
	- if inputdata.description.has_key('YCustomMajorTicks'): # and inputdata.description['YCustomMajorTicks']!='':
	- ycustommajorticks=[]
	- FOO=inputdata.description['YCustomMajorTicks'].strip().split() #'\t')
	- if not len(FOO)%2:
	- for i in range(0,len(FOO),2):
	- ycustommajorticks.append({'Value': float(FOO[i]), 'Label': FOO[i+1]})
	- if inputdata.description.has_key('YCustomMinorTicks'): # and inputdata.description['YCustomMinorTicks']!='':
	- ycustomminorticks=[]
	- FOO=inputdata.description['YCustomMinorTicks'].strip().split() #'\t')
	- for i in range(len(FOO)):
	- ycustomminorticks.append({'Value': float(FOO[i])})
	+
	+ ycustommajortickmarks = inputdata.attr('YMajorTickMarks', '')
	+ ycustommajortickmarks = int(ycustommajortickmarks) if ycustommajortickmarks else -1
	+
	+ ycustomminortickmarks = inputdata.attr('YMinorTickMarks', '')
	+ ycustomminortickmarks = int(ycustomminortickmarks) if ycustomminortickmarks else -1
	+
	+ ycustommajorticks = None
	+ if inputdata.description.has_key('YCustomMajorTicks'):
	+ ycustommajorticks = []
	+ tickstr = inputdata.description['YCustomMajorTicks'].strip().split() #'\t')
	+ if not len(tickstr) % 2:
	+ for i in range(0, len(tickstr), 2):
	+ ycustommajorticks.append({'Value': float(tickstr[i]), 'Label': tickstr[i+1]})
	+
	+ ycustomminorticks = None
	+ if inputdata.description.has_key('YCustomMinorTicks'):
	+ ycustomminorticks = []
	+ tickstr = inputdata.description['YCustomMinorTicks'].strip().split() #'\t')
	+ for i in range(len(tickstr)):
	+ ycustomminorticks.append({'Value': float(tickstr[i])})
	+
	yticks = YTicks(inputdata.description, self.coors)
	- out += yticks.draw(custommajortickmarks=ycustommajortickmarks,\
	- customminortickmarks=ycustomminortickmarks,\
	- custommajorticks=ycustommajorticks,\
	+ out += yticks.draw(custommajortickmarks=ycustommajortickmarks,
	+ customminortickmarks=ycustomminortickmarks,
	+ custommajorticks=ycustommajorticks,
	customminorticks=ycustomminorticks)

	- if inputdata.description.has_key('MainPlot') and inputdata.description['MainPlot']=='0':
	- if inputdata.description.has_key('Legend') and inputdata.description['Legend']=='1':
	- legend = Legend(inputdata.description,inputdata.histos,inputdata.functions)
	- out += legend.draw()
	+ if not inputdata.attr_bool('MainPlot', True) and inputdata.attr_bool('Legend', False):
	+ legend = Legend(inputdata.description, inputdata.histos, inputdata.functions)
	+ out += legend.draw()

	labels = Labels(inputdata.description)
	- if inputdata.description.has_key('MainPlot') and inputdata.description['MainPlot']=='0':
	- out += labels.draw(['Title','XLabel','YLabel'])
	- else:
	- out += labels.draw(['XLabel','YLabel'])
	+ lnames = ['XLabel','YLabel']
	+ if not inputdata.attr_bool('MainPlot', True):
	+ lnames.append("Title")
	+ out += labels.draw(lnames)
	return out



	-class Legend(object):
	+class Legend(Described):

	def __init__(self, description, histos, functions):
	self.histos = histos
	self.functions = functions
	self.description = description

	def draw(self):
	out = ""
	out += '\n%\n% Legend\n%\n'
	out += '\\rput[tr](%s,%s){%%\n' % (self.getLegendXPos(), self.getLegendYPos())
	ypos = -0.05*6/self.description['PlotSizeY']

	legendordermap = {}
	legendlist = self.description['DrawOnly']+self.functions.keys()
	if self.description.has_key('LegendOnly'):
	legendlist = []
	for legend in self.description['LegendOnly'].strip().split():
	if legend in self.histos.keys() or legend in self.functions.keys():
	legendlist.append(legend)
	for legend in legendlist:
	order = 0
	if self.histos.has_key(legend) and self.histos[legend].description.has_key('LegendOrder'):
	order = int(self.histos[legend].description['LegendOrder'])
	if self.functions.has_key(legend) and self.functions[legend].description.has_key('LegendOrder'):
	order = int(self.functions[legend].description['LegendOrder'])
	if not order in legendordermap:
	legendordermap[order] = []
	legendordermap[order].append(legend)
	foo=[]
	for i in sorted(legendordermap.keys()):
	foo.extend(legendordermap[i])

	rel_xpos_sign = 1.0
	if self.getLegendAlign()=='r':
	rel_xpos_sign = -1.0
	xpos1 = -0.10*rel_xpos_sign
	xpos2 = -0.02*rel_xpos_sign

	for i in foo:
	if self.histos.has_key(i):
	drawobject=self.histos[i]
	elif self.functions.has_key(i):
	drawobject=self.functions[i]
	else:
	continue
	title = drawobject.getTitle()
	if title == '':
	continue
	else:
	out += ('\\rput[B%s](%s,%s){%s}\n' %(self.getLegendAlign(),rel_xpos_sign*0.1,ypos,title))
	out += ('\\rput[B%s](%s,%s){%s\n' %(self.getLegendAlign(),rel_xpos_sign*0.1,ypos,'%'))
	if drawobject.getErrorBands():
	out += ('\\psframe[linewidth=0pt,linestyle=none,fillstyle=solid,fillcolor=%s,opacity=%s]' %(drawobject.getErrorBandColor(),drawobject.getErrorBandOpacity()))
	out += ('(%s, 0.033)(%s, 0.001)\n' %(xpos1, xpos2))
	out += ('\\psline[linestyle=' + drawobject.getLineStyle() \
	+ ', linecolor=' + drawobject.getLineColor() \
	+ ', linewidth=' + drawobject.getLineWidth() \
	+ ', strokeopacity=' + drawobject.getLineOpacity() \
	+ ', opacity=' + drawobject.getFillOpacity())
	- if drawobject.getLineDash()!='':
	+ if drawobject.getLineDash() != '':
	out += (', dash=' + drawobject.getLineDash())
	if drawobject.getFillStyle()!='none':
	out += (', fillstyle=' + drawobject.getFillStyle() \
	+ ', fillcolor=' + drawobject.getFillColor() \
	+ ', hatchcolor=' + drawobject.getHatchColor() \
	+ ']{C-C}(%s, 0.030)(%s, 0.030)(%s, 0.004)(%s, 0.004)(%s, 0.030)\n' \
	%(xpos1, xpos2, xpos2, xpos1, xpos1))
	else:
	out += ('](%s, 0.016)(%s, 0.016)\n' %(xpos1, xpos2))
	if drawobject.getPolyMarker() != '':
	out += (' \\psdot[dotstyle=' + drawobject.getPolyMarker() \
	+ ', dotsize=' + drawobject.getDotSize() \
	+ ', dotscale=' + drawobject.getDotScale() \
	+ ', linecolor=' + drawobject.getLineColor() \
	+ ', linewidth=' + drawobject.getLineWidth() \
	+ ', linestyle=' + drawobject.getLineStyle() \
	+ ', fillstyle=' + drawobject.getFillStyle() \
	+ ', fillcolor=' + drawobject.getFillColor() \
	+ ', strokeopacity=' + drawobject.getLineOpacity() \
	+ ', opacity=' + drawobject.getFillOpacity() \
	+ ', hatchcolor=' + drawobject.getHatchColor())
	if drawobject.getFillStyle()!='none':
	out += ('](%s, 0.028)\n' % (rel_xpos_sign*-0.06))
	else:
	out += ('](%s, 0.016)\n' % (rel_xpos_sign*-0.06))
	out += ('}\n')
	ypos -= 0.075*6/self.description['PlotSizeY']
	if self.description.has_key('CustomLegend'):
	for i in self.description['CustomLegend'].strip().split('\\\\'):
	out += ('\\rput[B%s](%s,%s){%s}\n' %(self.getLegendAlign(),rel_xpos_sign*0.1,ypos,i))
	ypos -= 0.075*6/self.description['PlotSizeY']
	out += ('}\n')
	return out

	def getLegendXPos(self):
	if self.description.has_key('LegendXPos'):
	return self.description['LegendXPos']
	else:
	if self.getLegendAlign()=='r':
	return '0.95'
	else:
	return '0.53'

	def getLegendYPos(self):
	if self.description.has_key('LegendYPos'):
	return self.description['LegendYPos']
	else:
	return '0.93'

	def getLegendAlign(self):
	if self.description.has_key('LegendAlign'):
	return self.description['LegendAlign']
	else:
	return 'l'


	-class Colorscale(object):
	+class ColorScale(Described):

	def __init__(self, description, coors):
	self.description = description
	self.coors = coors

	def draw(self):
	out = ''
	- out += '\n%\n% Colorscale\n%\n'
	+ out += '\n%\n% ColorScale\n%\n'
	out += '\\rput(1,0){\n'
	out += ' \\psset{xunit=4mm}\n'
	out += ' \\rput(0.5,0){\n'
	out += ' \\psset{yunit=0.0076923, linestyle=none, fillstyle=solid}\n'
	out += ' \\multido{\\ic=0+1,\\id=1+1}{130}{\n'
	out += ' \\psframe[fillcolor={gradientcolors!![\\ic]},dimen=inner,linewidth=0.1pt](0, \\ic)(1, \\id)\n'
	out += ' }\n'
	out += ' }\n'
	out += ' \\rput(0.5,0){\n'
	out += ' \\psframe[linewidth=0.3pt,dimen=middle](0,0)(1,1)\n'

	- zcustommajortickmarks = int(self.description.get('ZMajorTickMarks', -1))
	- zcustomminortickmarks = int(self.description.get('ZMinorTickMarks', -1))
	- zcustommajorticks=[]
	- zcustomminorticks=[]
	- if self.description.has_key('ZCustomMajorTicks') and self.description['ZCustomMajorTicks']!='':
	- # TODO: Would be nice to have less invisible separation of the custom ticks than split on tabs
	- ticks = self.description['ZCustomMajorTicks'].strip().split('\t')
	- if not len(ticks)%2:
	- for i in range(0,len(ticks),2):
	- zcustommajorticks.append({'Value': float(ticks[i]), 'Label': ticks[i+1]})
	- if self.description.has_key('ZCustomMinorTicks') and self.description['ZCustomMinorTicks']!='':
	- # TODO: Would be nice to have less invisible separation of the custom ticks than split on tabs
	- ticks = self.description['ZCustomMinorTicks'].strip().split('\t')
	- for i in range(len(ticks)):
	- zcustomminorticks.append({'Value': float(ticks[i])})
	- if (self.description.has_key('PlotZTickLabels') and self.description['PlotZTickLabels']=='0'):
	- drawzlabels=False
	- else:
	- drawzlabels=True
	+ zcustommajortickmarks = self.attr_int('ZMajorTickMarks', -1)
	+ zcustomminortickmarks = self.attr_int('ZMinorTickMarks', -1)
	+
	+ zcustommajorticks = zcustomminorticks = None
	+ if self.attr('ZCustomMajorTicks'):
	+ zcustommajorticks = []
	+ z_label_pairs = self.attr('ZCustomMajorTicks').strip().split() #'\t')
	+ if len(z_label_pairs) % 2 == 0:
	+ for i in range(0, len(z_label_pairs), 2):
	+ zcustommajorticks.append({'Value': float(x_label_pairs[i]), 'Label': x_label_pairs[i+1]})
	+ else:
	+ print "Warning: ZCustomMajorTicks requires an even number of alternating pos/label entries"
	+
	+ if self.attr('ZCustomMinorTicks'):
	+ zs = self.attr('ZCustomMinorTicks').strip().split() #'\t')
	+ zcustomminorticks = [{'Value': float(x)} for x in xs]
	+
	+ drawzlabels = self.attr_bool('PlotZTickLabels', True)
	+
	zticks = ZTicks(self.description, self.coors)
	out += zticks.draw(custommajortickmarks=zcustommajortickmarks,\
	customminortickmarks=zcustomminortickmarks,\
	custommajorticks=zcustommajorticks,\
	customminorticks=zcustomminorticks,
	drawlabels=drawzlabels)
	out += ' }\n'
	out += '}\n'
	return out



	-class Labels(object):
	+class Labels(Described):

	def __init__(self, description):
	self.description = description

	def draw(self, axis=[]):
	out = ""
	out += ('\n%\n% Labels\n%\n')
	if self.description.has_key('Title') and (axis.count('Title') or axis==[]):
	out += ('\\rput(0,1){\\rput[lB](0, 1.7\\labelsep){\\normalsize '+self.description['Title']+'}}\n')
	if self.description.has_key('XLabel') and (axis.count('XLabel') or axis==[]):
	xlabelsep=4.7
	if self.description.has_key('XLabelSep'):
	xlabelsep=float(self.description['XLabelSep'])
	out += ('\\rput(1,0){\\rput[rB](0,-%4.3f\\labelsep){\\normalsize '%(xlabelsep) +self.description['XLabel']+'}}\n')
	if self.description.has_key('YLabel') and (axis.count('YLabel') or axis==[]):
	ylabelsep=6.5
	if self.description.has_key('YLabelSep'):
	ylabelsep=float(self.description['YLabelSep'])
	out += ('\\rput(0,1){\\rput[rB]{90}(-%4.3f\\labelsep,0){\\normalsize '%(ylabelsep) +self.description['YLabel']+'}}\n')
	if self.description.has_key('ZLabel') and (axis.count('ZLabel') or axis==[]):
	zlabelsep=5.3
	if self.description.has_key('ZLabelSep'):
	zlabelsep=float(self.description['ZLabelSep'])
	out += ('\\rput(1,1){\\rput(%4.3f\\labelsep,0){\\psset{xunit=4mm}\\rput[lB]{270}(1.5,0){\\normalsize '%(zlabelsep) +self.description['ZLabel']+'}}}\n')
	return out



	-class Special(object):
	+class Special(Described):

	def __init__(self, f):
	self.description = {}
	self.data = []
	self.read_input(f)

	def read_input(self, f):
	for line in f:
	if is_end_marker(line, 'SPECIAL'):
	break
	elif is_comment(line):
	continue
	else:
	self.data.append(line)

	- def draw(self,coors):
	+ def draw(self, coors):
	out = ""
	out += ('\n%\n% Special\n%\n')
	import re
	regex = re.compile(r'^(.?)(\\physics[xy]?coor)$\s?([0-9\.eE+-]+)\s?,\s?([0-9\.eE+-]+)\s?$(.)')
	# TODO: More precise number string matching, something like this:
	# num = r"-?[0-9](?:\.[0-9])(?:[eE][+-]?\d+]"
	# regex = re.compile(r'^(.?)(\\physics[xy]?coor)$\s?(' + num + ')\s?,\s?(' + num + ')\s?$(.)')
	- for i in xrange(len(self.data)):
	- while regex.search(self.data[i]):
	- match = regex.search(self.data[i])
	+ for l in self.data:
	+ while regex.search(l):
	+ match = regex.search(l)
	xcoor, ycoor = float(match.group(3)), float(match.group(4))
	if match.group(2)[1:] in ["physicscoor", "physicsxcoor"]:
	xcoor = coors.phys2frameX(xcoor)
	if match.group(2)[1:] in ["physicscoor", "physicsycoor"]:
	ycoor = coors.phys2frameY(ycoor)
	line = "%s(%f, %f)%s" % (match.group(1), xcoor, ycoor, match.group(5))
	- self.data[i] = line
	- out += self.data[i]+'\n'
	+ l = line
	+ out += l + "\n"
	return out



	-class DrawableObject(object):
	+class DrawableObject(Described):

	def __init__(self, f):
	pass

	def getTitle(self):
	- if self.description.has_key('Title'):
	- return self.description['Title']
	- else:
	- return ''
	+ return self.description.get("Title", "")

	def getLineStyle(self):
	if self.description.has_key('LineStyle'):
	## I normally like there to be "only one way to do it", but providing
	## this dashdotted/dotdashed synonym just seems humane ;-)
	if self.description['LineStyle'] in ('dashdotted', 'dotdashed'):
	self.description['LineStyle']='dashed'
	self.description['LineDash']='3pt 3pt .8pt 3pt'
	return self.description['LineStyle']
	else:
	return 'solid'

	def getLineDash(self):
	if self.description.has_key('LineDash'):
	# Check if LineStyle=='dashdotted' before returning something
	self.getLineStyle()
	return self.description['LineDash']
	else:
	return ''

	def getLineWidth(self):
	- if self.description.has_key('LineWidth'):
	- return self.description['LineWidth']
	- else:
	- return '0.8pt'
	+ return self.description.get("LineWidth", "0.8pt")

	def getLineColor(self):
	- if self.description.has_key('LineColor'):
	- return self.description['LineColor']
	- else:
	- return 'black'
	+ return self.description.get("LineColor", "black")

	def getLineOpacity(self):
	- if self.description.has_key('LineOpacity'):
	- return self.description['LineOpacity']
	- else:
	- return '1.0'
	+ return self.description.get("LineOpacity", "1.0")

	def getFillColor(self):
	- if self.description.has_key('FillColor'):
	- return self.description['FillColor']
	- else:
	- return 'white'
	+ return self.description.get("FillColor", "white")

	def getFillOpacity(self):
	- if self.description.has_key('FillOpacity'):
	- return self.description['FillOpacity']
	- else:
	- return '1.0'
	+ return self.description.get("FillOpacity", "1.0")

	def getHatchColor(self):
	- if self.description.has_key('HatchColor'):
	- return self.description['HatchColor']
	- else:
	- return 'black'
	+ return self.description.get("HatchColor", "black")

	def getFillStyle(self):
	- if self.description.has_key('FillStyle'):
	- return self.description['FillStyle']
	- else:
	- return 'none'
	+ return self.description.get("FillStyle", "none")

	def getPolyMarker(self):
	- if self.description.has_key('PolyMarker'):
	- return self.description['PolyMarker']
	- else:
	- return ''
	+ return self.description.get("PolyMarker", "")

	def getDotSize(self):
	- if self.description.has_key('DotSize'):
	- return self.description['DotSize']
	- else:
	- return '2pt 2'
	+ return self.description.get("DotSize", "2pt 2")

	def getDotScale(self):
	- if self.description.has_key('DotScale'):
	- return self.description['DotScale']
	- else:
	- return '1'
	+ return self.description.get("DotScale", "1")

	def getErrorBars(self):
	- if self.description.has_key('ErrorBars'):
	- return bool(int(self.description['ErrorBars']))
	- else:
	- return False
	+ return bool(int(self.description.get("ErrorBars", "0")))

	def getErrorBands(self):
	- if self.description.has_key('ErrorBands'):
	- return bool(int(self.description['ErrorBands']))
	- else:
	- return False
	+ return bool(int(self.description.get("ErrorBands", "0")))

	def getErrorBandColor(self):
	- if self.description.has_key('ErrorBandColor'):
	- return self.description['ErrorBandColor']
	- else:
	- return 'yellow'
	+ return self.description.get("ErrorBandColor", "yellow")

	def getErrorBandOpacity(self):
	- if self.description.has_key('ErrorBandOpacity'):
	- return self.description['ErrorBandOpacity']
	- else:
	- return '1.0'
	+ return self.description.get("ErrorBandOpacity", "1.0")

	def getSmoothLine(self):
	- if self.description.has_key('SmoothLine'):
	- return bool(int(self.description['SmoothLine']))
	- else:
	- return False
	+ return bool(int(self.description.get("SmoothLine", "0")))

	def startclip(self):
	return '\\psclip{\\psframe[linewidth=0, linestyle=none](0,0)(1,1)}\n'

	def stopclip(self):
	return '\\endpsclip\n'

	def startpsset(self):
	out = ""
	out += ('\\psset{linecolor='+self.getLineColor()+'}\n')
	out += ('\\psset{linewidth='+self.getLineWidth()+'}\n')
	out += ('\\psset{linestyle='+self.getLineStyle()+'}\n')
	out += ('\\psset{fillstyle='+self.getFillStyle()+'}\n')
	out += ('\\psset{fillcolor='+self.getFillColor()+'}\n')
	out += ('\\psset{hatchcolor='+self.getHatchColor()+'}\n')
	out += ('\\psset{strokeopacity='+self.getLineOpacity()+'}\n')
	out += ('\\psset{opacity='+self.getFillOpacity()+'}\n')
	if self.getLineDash()!='':
	out += ('\\psset{dash='+self.getLineDash()+'}\n')
	return out

	def stoppsset(self):
	out = ""
	out += ('\\psset{linecolor=black}\n')
	out += ('\\psset{linewidth=0.8pt}\n')
	out += ('\\psset{linestyle=solid}\n')
	out += ('\\psset{fillstyle=none}\n')
	out += ('\\psset{fillcolor=white}\n')
	out += ('\\psset{hatchcolor=black}\n')
	out += ('\\psset{strokeopacity=1.0}\n')
	out += ('\\psset{opacity=1.0}\n')
	return out



	-class Function(DrawableObject):
	+class Function(DrawableObject, Described):

	def __init__(self, f):
	self.description = {}
	self.read_input(f)

	def read_input(self, f):
	self.code='def plotfunction(x):\n'
	iscode=False
	for line in f:
	if is_end_marker(line, 'FUNCTION'):
	break
	elif is_comment(line):
	continue
	else:
	m = pat_property.match(line)
	if iscode:
	self.code+=' '+line
	elif m:
	prop, value = m.group(1,2)
	if prop=='Code':
	iscode=True
	else:
	self.description[prop] = value
	if not iscode:
	print '++++++++++ ERROR: No code in function'
	else:
	foo = compile(self.code, '<string>', 'exec')
	exec(foo)
	self.plotfunction = plotfunction


	def draw(self,coors):
	out = ""
	out += self.startclip()
	out += self.startpsset()
	xmin = coors.xmin()
	if self.description.has_key('XMin') and self.description['XMin']:
	xmin = float(self.description['XMin'])
	xmax=coors.xmax()
	if self.description.has_key('XMax') and self.description['XMax']:
	xmax=float(self.description['XMax'])
	# TODO: Space sample points logarithmically if LogX=1
	dx = (xmax-xmin)/500.
	x = xmin-dx
	out += '\\pscurve'
	if self.description.has_key('FillStyle') and self.description['FillStyle']!='none':
	out += '(%s,%s)\n' % (coors.strphys2frameX(xmin),coors.strphys2frameY(coors.ymin()))
	while x < (xmax+2*dx):
	y = self.plotfunction(x)
	out += ('(%s,%s)\n' % (coors.strphys2frameX(x), coors.strphys2frameY(y)))
	x += dx
	if self.description.has_key('FillStyle') and self.description['FillStyle']!='none':
	out += '(%s,%s)\n' % (coors.strphys2frameX(xmax),coors.strphys2frameY(coors.ymin()))
	out += self.stoppsset()
	out += self.stopclip()
	return out


	-
	-
	-class Histogram(DrawableObject):
	+class BinData(object):
	+ """\
	+ Store bin edge and value+error(s) data for a 1D or 2D bin.
	+
	+ TODO: generalise/alias the attr names to avoid mention of x and y
	+ """
	+
	+ def __init__(self, low, high, val, err):
	+ #print "@", low, high, val, err
	+ self.low = floatify(low)
	+ self.high = floatify(high)
	+ self.val = float(val)
	+ self.err = floatpair(err)
	+
	+ @property
	+ def is2D(self):
	+ return hasattr(self.low, "__len__") and hasattr(self.high, "__len__")
	+
	+ @property
	+ def isValid(self):
	+ invalid_val = (isnan(self.val) or isnan(self.err[0]) or isnan(self.err[1]))
	+ if invalid_val:
	+ return False
	+ if self.is2D:
	+ invalid_low = any(isnan(x) for x in self.low)
	+ invalid_high = any(isnan(x) for x in self.high)
	+ else:
	+ invalid_low, invalid_high = isnan(self.low), isnan(self.high)
	+ return not (invalid_low or invalid_high)
	+
	+ @property
	+ def xmin(self):
	+ return self.low
	+ @xmin.setter
	+ def xmin(self,x):
	+ self.low = x
	+
	+ @property
	+ def xmax(self):
	+ return self.high
	+ @xmax.setter
	+ def xmax(self,x):
	+ self.high = x
	+
	+ @property
	+ def xmid(self):
	+ # TODO: Generalise to 2D
	+ return (self.xmin + self.xmax) / 2.0
	+
	+ @property
	+ def xwidth(self):
	+ # TODO: Generalise to 2D
	+ assert self.xmin <= self.xmax
	+ return self.xmax - self.xmin
	+
	+ @property
	+ def y(self):
	+ return self.val
	+ @y.setter
	+ def y(self, x):
	+ self.val = x
	+
	+ @property
	+ def ey(self):
	+ return self.err
	+ @ey.setter
	+ def ey(self, x):
	+ self.err = x
	+
	+ @property
	+ def ymin(self):
	+ return self.y - self.ey[0]
	+
	+ @property
	+ def ymax(self):
	+ return self.y + self.ey[1]
	+
	+ def __getitem__(self, key):
	+ "dict-like access for backward compatibility"
	+ if key in ("LowEdge"):
	+ return self.xmin
	+ elif key == ("UpEdge", "HighEdge"):
	+ return self.xmax
	+ elif key == "Content":
	+ return self.y
	+ elif key == "Errors":
	+ return self.ey
	+
	+
	+class Histogram(DrawableObject, Described):

	def __init__(self, f, p=None):
	self.description = {}
	self.is2dim = False
	self.data = []
	self.read_input_data(f)
	self.sigmabinvalue = None
	self.meanbinvalue = None
	self.path = p

	def read_input_data(self, f):
	for line in f:
	if is_end_marker(line, 'HISTOGRAM'):
	break
	elif is_comment(line):
	continue
	else:
	line = line.rstrip()
	m = pat_property.match(line)
	if m:
	prop, value = m.group(1,2)
	self.description[prop] = value
	else:
	## Detect symm errs
	linearray = line.split()
	if len(linearray) == 4:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[3])]})
	+ self.data.append(BinData(*linearray))
	## Detect asymm errs
	elif len(linearray) == 5:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[4])]})
	+ self.data.append(BinData(linearray[0], linearray[1], linearray[2], [linearray[3],linearray[4]]))
	## Detect two-dimensionality
	elif len(linearray) in [6,7]:
	self.is2dim = True
	# If asymm z error, use the max or average of +- error
	err = float(linearray[5])
	if len(linearray) == 7:
	if self.description.get("ShowMaxZErr", 1):
	err = max(err, float(linearray[6]))
	else:
	err = 0.5 * (err + float(linearray[6]))
	- self.data.append({'LowEdge': [float(linearray[0]), float(linearray[2])],
	- 'UpEdge': [float(linearray[1]), float(linearray[3])],
	- 'Content': float(linearray[4]),
	- 'Error': err})
	+ self.data.append(BinData([linearray[0], linearray[2]], [linearray[1], linearray[3]], linearray[4], err))
	## Unknown histo format
	else:
	raise RuntimeError("Unknown HISTOGRAM data line format with %d entries" % len(linearray))


	def mangle_input(self):
	- if (self.description.has_key('NormalizeToIntegral') and self.description['NormalizeToIntegral']=='1') or \
	- (self.description.has_key('NormalizeToSum') and self.description['NormalizeToSum']=='1'):
	- if (self.description.has_key('NormalizeToIntegral') and self.description['NormalizeToIntegral']=='1') and \
	- (self.description.has_key('NormalizeToSum') and self.description['NormalizeToSum']=='1'):
	- print 'Can\'t normalize to Integral and to Sum at the same time. Will normalize to the Sum.'
	+ norm2int = self.attr_bool("NormalizeToIntegral", False)
	+ norm2sum = self.attr_bool("NormalizeToSum", False)
	+ if norm2int or norm2sum:
	+ if norm2int and norm2sum:
	+ print "Can't normalize to Integral and to Sum at the same time. Will normalize to the Sum."
	foo = 0
	+ # TODO: change to "in self.data"?
	for i in range(len(self.data)):
	- if self.description.has_key('NormalizeToSum') and self.description['NormalizeToSum']=='1':
	- foo += self.data[i]['Content']
	+ if norm2sum:
	+ foo += self.data[i].val
	else:
	- foo += self.data[i]['Content']*(self.data[i]['UpEdge']-self.data[i]['LowEdge'])
	+ foo += self.data[i].val*(self.data[i].xmax-self.data[i].xmin)
	+
	+ # TODO: change to "in self.data"?
	+ if foo != 0:
	+ for i in range(len(self.data)):
	+ self.data[i].val /= foo
	+ self.data[i].err[0] /= foo
	+ self.data[i].err[1] /= foo
	+ scale = self.attr_float('Scale', 1.0)
	+ if scale != 1.0:
	+ # TODO: change to "in self.data"?
	for i in range(len(self.data)):
	- self.data[i]['Content'] /= foo
	- self.data[i]['Error'][0] /= foo
	- self.data[i]['Error'][1] /= foo
	- if self.description.has_key('Scale') and self.description['Scale']!='':
	- scale = float(self.description['Scale'])
	- for i in range(len(self.data)):
	- self.data[i]['Content'] *= scale
	- self.data[i]['Error'][0] *= scale
	- self.data[i]['Error'][1] *= scale
	- if self.description.has_key('Rebin') and self.description['Rebin']!='':
	- rebin=int(self.description['Rebin'])
	- errortype = "stat"
	- if self.description.has_key('ErrorType') and self.description['ErrorType']!='':
	- errortype = self.description['ErrorType']
	- newdata=[]
	- if rebin>=2:
	- for i in range(0,(len(self.data)/rebin)*rebin,rebin):
	- foo=0.
	- barl=0.
	- baru=0.
	- for j in range(rebin):
	- binwidth=self.data[i+j]['UpEdge']-self.data[i+j]['LowEdge']
	- foo +=self.data[i+j]['Content']*binwidth
	- if errortype=="stat":
	- barl+=(binwidthself.data[i+j]['Error'][0])*2
	- baru+=(binwidthself.data[i+j]['Error'][1])*2
	- elif errortype=="env":
	- barl+=(self.data[i+j]['Content']-self.data[i+j]['Error'][0])*binwidth
	- baru+=(self.data[i+j]['Content']+self.data[i+j]['Error'][1])*binwidth
	- else:
	- logging.error("Rebinning for ErrorType not implemented.")
	- sys.exit(1)
	- newbinwidth=self.data[i+rebin-1]['UpEdge']-self.data[i]['LowEdge']
	- newcentral=foo/newbinwidth
	- if errortype=="stat":
	- newerror=[sqrt(barl)/newbinwidth,sqrt(baru)/newbinwidth]
	- elif errortype=="env":
	- newerror=[(foo-barl)/newbinwidth,(baru-foo)/newbinwidth]
	- newdata.append({'LowEdge': self.data[i]['LowEdge'],
	- 'UpEdge': self.data[i+rebin-1]['UpEdge'],
	- 'Content': newcentral,
	- 'Error': newerror})
	- self.data=newdata
	+ self.data[i].val *= scale
	+ self.data[i].err[0] *= scale
	+ self.data[i].err[1] *= scale
	+ if self.attr_int("Rebin", 1) > 1:
	+ rebin = self.attr_int("Rebin", 1)
	+ errortype = self.attr("ErrorType", "stat")
	+ newdata = []
	+ for i in range(0, (len(self.data)//rebin)*rebin, rebin):
	+ foo = 0.
	+ barl = 0.
	+ baru = 0.
	+ for j in range(rebin):
	+ binwidth = self.data[i+j].xwidth
	+ foo += self.data[i+j].val * binwidth
	+ if errortype == "stat":
	+ barl += (binwidth * self.data[i+j].err[0])**2
	+ baru += (binwidth * self.data[i+j].err[1])**2
	+ elif errortype == "env":
	+ barl += self.data[i+j].ymin * binwidth
	+ baru += self.data[i+j].ymax * binwidth
	+ else:
	+ logging.error("Rebinning for ErrorType not implemented.")
	+ sys.exit(1)
	+ newbinwidth = self.data[i+rebin-1].xmax - self.data[i].xmin
	+ newcentral = foo/newbinwidth
	+ if errortype == "stat":
	+ newerror = [sqrt(barl)/newbinwidth, sqrt(baru)/newbinwidth]
	+ elif errortype == "env":
	+ newerror = [(foo-barl)/newbinwidth, (baru-foo)/newbinwidth]
	+ newdata.append(BinData(self.data[i].xmin, self.data[i+rebin-1].xmax, newcentral, newerror))
	+ self.data = newdata

	def add(self, name):
	if len(self.data) != len(name.data):
	print '+++ Error in Histogram.add() for %s: different numbers of bins' % self.path
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	- self.data[i]['Content'] += name.data[i]['Content']
	- self.data[i]['Error'][0] = sqrt(self.data[i]['Error'][0]2 + name.data[i]['Error'][0]2)
	- self.data[i]['Error'][1] = sqrt(self.data[i]['Error'][1]2 + name.data[i]['Error'][1]2)
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	+ self.data[i].val += name.data[i].val
	+ self.data[i].err[0] = sqrt(self.data[i].err[0]2 + name.data[i].err[0]2)
	+ self.data[i].err[1] = sqrt(self.data[i].err[1]2 + name.data[i].err[1]2)
	else:
	print '+++ Error in Histogram.add() for %s: binning of histograms differs' % self.path

	def divide(self, name):
	#print name.path, self.path
	if len(self.data) != len(name.data):
	print '+++ Error in Histogram.divide() for %s: different numbers of bins' % self.path
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	try:
	- self.data[i]['Error'][0] /= name.data[i]['Content']
	+ self.data[i].err[0] /= name.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Error'][0]=0.
	+ self.data[i].err[0]=0.
	try:
	- self.data[i]['Error'][1] /= name.data[i]['Content']
	+ self.data[i].err[1] /= name.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Error'][1]=0.
	+ self.data[i].err[1]=0.
	try:
	- self.data[i]['Content'] /= name.data[i]['Content']
	+ self.data[i].val /= name.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Content']=1.
	-# self.data[i]['Error'][0] = sqrt(self.data[i]['Error'][0]2 + name.data[i]['Error'][0]2)
	-# self.data[i]['Error'][1] = sqrt(self.data[i]['Error'][1]2 + name.data[i]['Error'][1]2)
	+ self.data[i].val=1.
	+# self.data[i].err[0] = sqrt(self.data[i].err[0]2 + name.data[i].err[0]2)
	+# self.data[i].err[1] = sqrt(self.data[i].err[1]2 + name.data[i].err[1]2)
	else:
	print '+++ Error in Histogram.divide() for %s: binning of histograms differs' % self.path

	def dividereverse(self, name):
	if len(self.data) != len(name.data):
	print '+++ Error in Histogram.dividereverse() for %s: different numbers of bins' % self.path
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	try:
	- self.data[i]['Error'][0] = name.data[i]['Error'][0]/self.data[i]['Content']
	+ self.data[i].err[0] = name.data[i].err[0]/self.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Error'][0]=0.
	+ self.data[i].err[0]=0.
	try:
	- self.data[i]['Error'][1] = name.data[i]['Error'][1]/self.data[i]['Content']
	+ self.data[i].err[1] = name.data[i].err[1]/self.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Error'][1]=0.
	+ self.data[i].err[1]=0.
	try:
	- self.data[i]['Content'] = name.data[i]['Content']/self.data[i]['Content']
	+ self.data[i].val = name.data[i].val/self.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Content']=1.
	+ self.data[i].val=1.
	else:
	print '+++ Error in Histogram.dividereverse(): binning of histograms differs'

	def deviation(self, name):
	if len(self.data) != len(name.data):
	print '+++ Error in Histogram.deviation() for %s: different numbers of bins' % self.path
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	- self.data[i]['Content'] -= name.data[i]['Content']
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	+ self.data[i].val -= name.data[i].val
	try:
	- self.data[i]['Content'] /= 0.5sqrt((name.data[i]['Error'][0] + name.data[i]['Error'][1])*2 + \
	- (self.data[i]['Error'][0] + self.data[i]['Error'][1])**2)
	+ self.data[i].val /= 0.5sqrt((name.data[i].err[0] + name.data[i].err[1])*2 + \
	+ (self.data[i].err[0] + self.data[i].err[1])**2)
	except ZeroDivisionError:
	- self.data[i]['Content'] = 0.0
	+ self.data[i].val = 0.0
	try:
	- self.data[i]['Error'][0] /= name.data[i]['Error'][0]
	+ self.data[i].err[0] /= name.data[i].err[0]
	except ZeroDivisionError:
	- self.data[i]['Error'][0] = 0.0
	+ self.data[i].err[0] = 0.0
	try:
	- self.data[i]['Error'][1] /= name.data[i]['Error'][1]
	+ self.data[i].err[1] /= name.data[i].err[1]
	except ZeroDivisionError:
	- self.data[i]['Error'][1] = 0.0
	+ self.data[i].err[1] = 0.0
	else:
	print '+++ Error in Histogram.deviation() for %s: binning of histograms differs' % self.path

	def getChi2(self, name):
	chi2 = 0.
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	try:
	- chi2 += (self.data[i]['Content']-name.data[i]['Content'])*2/((0.5self.data[i]['Error'][0]+0.5self.data[i]['Error'][1])2 + (0.5name.data[i]['Error'][0]+0.5name.data[i]['Error'][1])*2)
	+ chi2 += (self.data[i].val-name.data[i].val)*2/((0.5self.data[i].err[0]+0.5self.data[i].err[1])2 + (0.5name.data[i].err[0]+0.5name.data[i].err[1])*2)
	except ZeroDivisionError:
	pass
	else:
	print '+++ Error in Histogram.getChi2() for %s: binning of histograms differs' % self.path
	return chi2/len(self.data)

	def getSigmaBinValue(self):
	if self.sigmabinvalue==None:
	self.sigmabinvalue = 0.
	sumofweights = 0.
	for i in range(len(self.data)):
	if self.is2dim:
	- binwidth = abs( (self.data[i]['UpEdge'][0] - self.data[i]['LowEdge'][0])
	- *(self.data[i]['UpEdge'][1] - self.data[i]['LowEdge'][1]))
	+ binwidth = abs( (self.data[i].xmax[0] - self.data[i].xmin[0])
	+ *(self.data[i].xmax[1] - self.data[i].xmin[1]))
	else:
	- binwidth = abs(self.data[i]['UpEdge'] - self.data[i]['LowEdge'])
	- self.sigmabinvalue += binwidth(self.data[i]['Content']-self.getMeanBinValue())*2
	+ binwidth = abs(self.data[i].xmax - self.data[i].xmin)
	+ self.sigmabinvalue += binwidth(self.data[i].val-self.getMeanBinValue())*2
	sumofweights += binwidth
	self.sigmabinvalue = sqrt(self.sigmabinvalue/sumofweights)
	return self.sigmabinvalue

	def getMeanBinValue(self):
	if self.meanbinvalue==None:
	self.meanbinvalue = 0.
	sumofweights = 0.
	for i in range(len(self.data)):
	if self.is2dim:
	- binwidth = abs( (self.data[i]['UpEdge'][0] - self.data[i]['LowEdge'][0])
	- *(self.data[i]['UpEdge'][1] - self.data[i]['LowEdge'][1]))
	+ binwidth = abs( (self.data[i].xmax[0] - self.data[i].xmin[0])
	+ *(self.data[i].xmax[1] - self.data[i].xmin[1]))
	else:
	- binwidth = abs(self.data[i]['UpEdge'] - self.data[i]['LowEdge'])
	- self.meanbinvalue += binwidth*self.data[i]['Content']
	+ binwidth = abs(self.data[i].xmax - self.data[i].xmin)
	+ self.meanbinvalue += binwidth*self.data[i].val
	sumofweights += binwidth
	self.meanbinvalue /= sumofweights
	return self.meanbinvalue

	def getCorrelation(self, name):
	correlation = 0.
	sumofweights = 0.
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	if self.is2dim:
	- binwidth = abs( (self.data[i]['UpEdge'][0] - self.data[i]['LowEdge'][0])
	- * (self.data[i]['UpEdge'][1] - self.data[i]['LowEdge'][1]) )
	+ binwidth = abs( (self.data[i].xmax[0] - self.data[i].xmin[0])
	+ * (self.data[i].xmax[1] - self.data[i].xmin[1]) )
	else:
	- binwidth = abs(self.data[i]['UpEdge'] - self.data[i]['LowEdge'])
	- correlation += binwidth * ( self.data[i]['Content'] - self.getMeanBinValue() ) \
	- * ( name.data[i]['Content'] - name.getMeanBinValue() )
	+ binwidth = abs(self.data[i].xmax - self.data[i].xmin)
	+ correlation += binwidth * ( self.data[i].val - self.getMeanBinValue() ) \
	+ * ( name.data[i].val - name.getMeanBinValue() )
	sumofweights += binwidth
	else:
	print '+++ Error in Histogram.getCorrelation(): binning of histograms differs' % self.path
	correlation /= sumofweights
	try:
	correlation /= self.getSigmaBinValue()*name.getSigmaBinValue()
	except ZeroDivisionError:
	correlation = 0
	return correlation

	def getRMSdistance(self,name):
	distance = 0.
	sumofweights = 0.
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	if self.is2dim:
	- binwidth = abs( (self.data[i]['UpEdge'][0] - self.data[i]['LowEdge'][0])
	- * (self.data[i]['UpEdge'][1] - self.data[i]['LowEdge'][1]) )
	+ binwidth = abs( (self.data[i].xmax[0] - self.data[i].xmin[0])
	+ * (self.data[i].xmax[1] - self.data[i].xmin[1]) )
	else:
	- binwidth = abs(self.data[i]['UpEdge'] - self.data[i]['LowEdge'])
	- distance += binwidth * ( (self.data[i]['Content'] - self.getMeanBinValue())
	- -(name.data[i]['Content'] - name.getMeanBinValue()))**2
	+ binwidth = abs(self.data[i].xmax - self.data[i].xmin)
	+ distance += binwidth * ( (self.data[i].val - self.getMeanBinValue())
	+ -(name.data[i].val - name.getMeanBinValue()))**2
	sumofweights += binwidth
	else:
	print '+++ Error in Histogram.getRMSdistance() for %s: binning of histograms differs' % self.path
	distance = sqrt(distance/sumofweights)
	return distance

	def draw(self,coors):
	seen_nan = False
	out = ""
	out += self.startclip()
	out += self.startpsset()
	- if self.data:
	+ if any(b.isValid for b in self.data):
	out += "% START DATA\n"
	if self.is2dim:
	- for i in xrange(len(self.data)):
	+ for b in self.data:
	out += ('\\psframe')
	- color=int(129*coors.phys2frameZ(self.data[i]['Content']))
	- if self.data[i]['Content']>coors.zmax():
	- color=129
	- if self.data[i]['Content']<coors.zmin():
	- color=0
	- if self.data[i]['Content']<=coors.zmin():
	+ color = int(129*coors.phys2frameZ(b.val))
	+ if b.val > coors.zmax():
	+ color = 129
	+ if b.val < coors.zmin():
	+ color = 0
	+ if b.val <= coors.zmin():
	out += ('[linewidth=0pt, linestyle=none, fillstyle=solid, fillcolor=white]')
	else:
	out += ('[linewidth=0pt, linestyle=none, fillstyle=solid, fillcolor={gradientcolors!!['+str(color)+']}]')
	- out += ('(' + coors.strphys2frameX(self.data[i]['LowEdge'][0]) + ', ' \
	- + coors.strphys2frameY(self.data[i]['LowEdge'][1]) + ')(' \
	- + coors.strphys2frameX(self.data[i]['UpEdge'][0]) + ', ' \
	- + coors.strphys2frameY(self.data[i]['UpEdge'][1]) + ')\n')
	+ out += ('(' + coors.strphys2frameX(b.low[0]) + ', ' \
	+ + coors.strphys2frameY(b.low[1]) + ')(' \
	+ + coors.strphys2frameX(b.high[0]) + ', ' \
	+ + coors.strphys2frameY(b.high[1]) + ')\n')
	else:
	if self.getErrorBands():
	- self.description['SmoothLine']=0
	- for i in xrange(len(self.data)):
	- out += ('\\psframe[dimen=inner,linewidth=0pt,linestyle=none,fillstyle=solid,fillcolor=%s,opacity=%s]' %(self.getErrorBandColor(),self.getErrorBandOpacity()))
	- out += ('(' + coors.strphys2frameX(self.data[i]['LowEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']-self.data[i]['Error'][0]) + ')(' \
	- + coors.strphys2frameX(self.data[i]['UpEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']+self.data[i]['Error'][1]) + ')\n')
	+ self.description['SmoothLine'] = 0
	+ for b in self.data:
	+ out += ('\\psframe[dimen=inner,linewidth=0pt,linestyle=none,fillstyle=solid,fillcolor=%s,opacity=%s]' % (self.getErrorBandColor(),self.getErrorBandOpacity()))
	+ out += ('(' + coors.strphys2frameX(b.xmin) + ', ' \
	+ + coors.strphys2frameY(b.val - b.err[0]) + ')(' \
	+ + coors.strphys2frameX(b.xmax) + ', ' \
	+ + coors.strphys2frameY(b.val + b.err[1]) + ')\n')
	if self.getErrorBars():
	- for i in xrange(len(self.data)):
	- if isnan(self.data[i]['Content']) or isnan(self.data[i]['Error'][0]) or isnan(self.data[i]['Error'][1]):
	+ for b in self.data:
	+ if isnan(b.val) or isnan(b.err[0]) or isnan(b.err[1]):
	seen_nan = True
	continue
	- if self.data[i]['Content']==0. and self.data[i]['Error']==[0.,0.]:
	+ if b.val == 0. and b.err == [0.,0.]:
	continue
	out += ('\\psline')
	- out += ('(' + coors.strphys2frameX(self.data[i]['LowEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')(' \
	- + coors.strphys2frameX(self.data[i]['UpEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')\n')
	+ out += ('(' + coors.strphys2frameX(b.xmin) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')(' \
	+ + coors.strphys2frameX(b.xmax) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')\n')
	out += ('\\psline')
	- bincenter = coors.strphys2frameX(.5*(self.data[i]['LowEdge']+self.data[i]['UpEdge']))
	+ bincenter = coors.strphys2frameX(.5*(b.xmin+b.xmax))
	out += ('(' + bincenter + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']-self.data[i]['Error'][0]) + ')(' \
	+ + coors.strphys2frameY(b.val-b.err[0]) + ')(' \
	+ bincenter + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']+self.data[i]['Error'][1]) + ')\n')
	+ + coors.strphys2frameY(b.val+b.err[1]) + ')\n')
	if self.getSmoothLine():
	out += '\\psbezier'
	else:
	out += '\\psline'
	- if (self.getFillStyle() != 'none'): # make sure that filled areas go all the way down to the x-axis
	- if (coors.phys2frameX(self.data[0]['LowEdge']) > 1e-4):
	- out += '(' + coors.strphys2frameX(self.data[0]['LowEdge']) + ', -0.1)\n'
	+ if self.getFillStyle() != 'none': # make sure that filled areas go all the way down to the x-axis
	+ if coors.phys2frameX(self.data[0].xmin) > 1e-4:
	+ out += '(' + coors.strphys2frameX(self.data[0].xmin) + ', -0.1)\n'
	else:
	out += '(-0.1, -0.1)\n'
	- for i in xrange(len(self.data)):
	- if isnan(self.data[i]['Content']):
	+ for i, b in enumerate(self.data):
	+ if isnan(b.val):
	seen_nan = True
	continue
	if self.getSmoothLine():
	- out += ('(' + coors.strphys2frameX(0.5*(self.data[i]['LowEdge']+self.data[i]['UpEdge'])) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')\n')
	+ out += ('(' + coors.strphys2frameX(0.5*(b.xmin+b.xmax)) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')\n')
	else:
	- out += ('(' + coors.strphys2frameX(self.data[i]['LowEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')(' \
	- + coors.strphys2frameX(self.data[i]['UpEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')\n')
	+ out += ('(' + coors.strphys2frameX(b.xmin) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')(' \
	+ + coors.strphys2frameX(b.xmax) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')\n')
	## Join/separate data points, with vertical/diagonal lines
	- if (i+1 < len(self.data)): #< If this is not the last point
	+ if i+1 < len(self.data): #< If this is not the last point
	if self.description.get('ConnectBins', '1') != '1':
	out += ('\\psline')
	else:
	## If bins are joined, but there is a gap in binning, choose whether to fill the gap
	- if (abs(coors.phys2frameX(self.data[i]['UpEdge']) - coors.phys2frameX(self.data[i+1]['LowEdge'])) > 1e-4):
	+ if (abs(coors.phys2frameX(b.xmax) - coors.phys2frameX(self.data[i+1].xmin)) > 1e-4):
	if self.description.get('ConnectGaps', '0') != '1':
	out += ('\\psline')
	# TODO: Perhaps use a new dashed line to fill the gap?
	- if self.getFillStyle() != 'none': # make sure that filled areas go all the way down to the x-axis
	- if (coors.phys2frameX(self.data[-1]['UpEdge']) < 1-1e-4):
	- out += '(' + coors.strphys2frameX(self.data[-1]['UpEdge']) + ', -0.1)\n'
	- else:
	- out += '(1.1, -0.1)\n'
	+ if self.getFillStyle() != 'none': # make sure that filled areas go all the way down to the x-axis
	+ if (coors.phys2frameX(self.data[-1].xmax) < 1-1e-4):
	+ out += '(' + coors.strphys2frameX(self.data[-1].xmax) + ', -0.1)\n'
	+ else:
	+ out += '(1.1, -0.1)\n'
	#
	if self.getPolyMarker() != '':
	- for i in xrange(len(self.data)):
	- if isnan(self.data[i]['Content']):
	+ for b in self.data:
	+ if isnan(b.val):
	seen_nan = True
	continue
	- if self.data[i]['Content']==0. and self.data[i]['Error']==[0.,0.]:
	+ if b.val == 0. and b.err == [0.,0.]:
	continue
	- out += ('\\psdot[dotstyle=%s,dotsize=%s,dotscale=%s](' %(self.getPolyMarker(),self.getDotSize(),self.getDotScale()) \
	- + coors.strphys2frameX(.5*(self.data[i]['LowEdge']+self.data[i]['UpEdge'])) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')\n')
	+ out += ('\\psdot[dotstyle=%s,dotsize=%s,dotscale=%s](' % (self.getPolyMarker(),self.getDotSize(),self.getDotScale()) \
	+ + coors.strphys2frameX(.5*(b.xmin+b.xmax)) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')\n')

	out += "% END DATA\n"
	+ else:
	+ print "WARNING: No valid bin value/errors/edges to plot!"
	+ out += "% NO DATA!\n"

	out += self.stoppsset()
	out += self.stopclip()
	if seen_nan:
	print "WARNING: NaN-valued value or error bar!"
	return out

	# def is2dimensional(self):
	# return self.is2dim

	def getXMin(self):
	if not self.data:
	return 0
	elif self.is2dim:
	- return min([self.data[i]['LowEdge'][0] for i in range(len(self.data))])
	+ return min(b.low[0] for b in self.data)
	else:
	- return min([self.data[i]['LowEdge'] for i in range(len(self.data))])
	+ return min(b.xmin for b in self.data)

	def getXMax(self):
	if not self.data:
	return 1
	elif self.is2dim:
	- return max([self.data[i]['UpEdge'][0] for i in range(len(self.data))])
	+ return max(b.high[0] for b in self.data)
	else:
	- return max([self.data[i]['UpEdge'] for i in range(len(self.data))])
	+ return max(b.xmax for b in self.data)

	def getYMin(self, xmin, xmax, logy):
	if not self.data:
	return 0
	elif self.is2dim:
	- return min([self.data[i]['LowEdge'][1] for i in range(len(self.data))])
	+ return min(b.low[1] for b in self.data)
	else:
	yvalues = []
	- for i in range(len(self.data)):
	- if ((self.data[i]['UpEdge'] > xmin or self.data[i]['LowEdge'] >= xmin) and \
	- (self.data[i]['LowEdge'] < xmax or self.data[i]['UpEdge'] <= xmax)):
	- foo = 0
	+ for b in self.data:
	+ if (b.xmax > xmin or b.xmin >= xmin) and (b.xmin < xmax or b.xmax <= xmax):
	+ foo = b.val
	if self.getErrorBars() or self.getErrorBands():
	- foo = self.data[i]['Content']-self.data[i]['Error'][0]
	- else:
	- foo = self.data[i]['Content']
	- if logy:
	- if foo>0: yvalues.append(foo)
	- else:
	+ foo -= b.err[0]
	+ if not isnan(foo) and (not logy or foo > 0):
	yvalues.append(foo)
	- if len(yvalues) > 0:
	- return min(yvalues)
	- else:
	- return self.data[0]['Content']
	+ return min(yvalues) if yvalues else self.data[0].val

	def getYMax(self, xmin, xmax):
	if not self.data:
	return 1
	elif self.is2dim:
	- return max([self.data[i]['UpEdge'][1] for i in range(len(self.data))])
	+ return max(b.high[1] for b in self.data)
	else:
	yvalues = []
	- for i in range(len(self.data)):
	- if ((self.data[i]['UpEdge'] > xmin or self.data[i]['LowEdge'] >= xmin) and \
	- (self.data[i]['LowEdge'] < xmax or self.data[i]['UpEdge'] <= xmax)):
	+ for b in self.data:
	+ if (b.xmax > xmin or b.xmin >= xmin) and (b.xmin < xmax or b.xmax <= xmax):
	+ foo = b.val
	if self.getErrorBars() or self.getErrorBands():
	- yvalues.append(self.data[i]['Content']+self.data[i]['Error'][1])
	- else:
	- yvalues.append(self.data[i]['Content'])
	- if len(yvalues) > 0:
	- return max(yvalues)
	- else:
	- return self.data[0]['Content']
	+ foo += b.err[1]
	+ if not isnan(foo): # and (not logy or foo > 0):
	+ yvalues.append(foo)
	+ return max(yvalues) if yvalues else self.data[0].val

	def getZMin(self, xmin, xmax, ymin, ymax):
	if not self.is2dim:
	return 0
	zvalues = []
	- for i in range(len(self.data)):
	- if (self.data[i]['UpEdge'][0] > xmin and self.data[i]['LowEdge'][0] < xmax) and \
	- (self.data[i]['UpEdge'][1] > ymin and self.data[i]['LowEdge'][1] < ymax):
	- zvalues.append(self.data[i]['Content'])
	+ for b in self.data:
	+ if (b.xmax[0] > xmin and b.xmin[0] < xmax) and (b.xmax[1] > ymin and b.xmin[1] < ymax):
	+ zvalues.append(b.val)
	return min(zvalues)

	def getZMax(self, xmin, xmax, ymin, ymax):
	if not self.is2dim:
	return 0
	zvalues = []
	- for i in range(len(self.data)):
	- if (self.data[i]['UpEdge'][0] > xmin and self.data[i]['LowEdge'][0] < xmax) and \
	- (self.data[i]['UpEdge'][1] > ymin and self.data[i]['LowEdge'][1] < ymax):
	- zvalues.append(self.data[i]['Content'])
	+ for b in self.data:
	+ if (b.xmax[0] > xmin and b.xmin[0] < xmax) and (b.xmax[1] > ymin and b.xmin[1] < ymax):
	+ zvalues.append(b.val)
	return max(zvalues)



	class Histo1D(Histogram):

	def read_input_data(self, f):
	for line in f:
	if is_end_marker(line, 'HISTO1D'):
	break
	elif is_comment(line):
	continue
	else:
	line = line.rstrip()
	m = pat_property.match(line)
	if m:
	prop, value = m.group(1,2)
	self.description[prop] = value
	else:
	linearray = line.split()
	## Detect symm errs
	- if len(linearray) == 4:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[3])]})
	+ # TODO: Not sure what the 8-param version is for... auto-compatibility with YODA format?
	+ if len(linearray) in [4,8]:
	+ self.data.append(BinData(linearray[0], linearray[1], linearray[2], linearray[3]))
	## Detect asymm errs
	elif len(linearray) == 5:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[4])]})
	- ## Not sure what this is for... auto-compatibility with YODA format? Urgh
	- elif len(linearray) == 8:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[3])]})
	+ self.data.append(BinData(linearray[0], linearray[1], linearray[2], [linearray[3],linearray[4]]))
	else:
	- raise Exception('Histo1D does not have 8 columns.'+line)
	+ raise Exception('Histo1D does not have the expected number of columns. ' + line)
	+
	+ # TODO: specialise draw() here


	class Histo2D(Histogram):

	def read_input_data(self, f):
	self.is2dim = True #< Should really be done in a constructor, but this is easier for now...

	for line in f:
	if is_end_marker(line, 'HISTO2D'):
	break
	elif is_comment(line):
	continue
	else:
	line = line.rstrip()
	m = pat_property.match(line)
	if m:
	prop, value = m.group(1,2)
	self.description[prop] = value
	else:
	linearray = line.split()
	if len(linearray) in [6,7]:
	# If asymm z error, use the max or average of +- error
	err = float(linearray[5])
	if len(linearray) == 7:
	if self.description.get("ShowMaxZErr", 1):
	err = max(err, float(linearray[6]))
	else:
	err = 0.5 * (err + float(linearray[6]))
	- self.data.append({'LowEdge': [float(linearray[0]), float(linearray[2])],
	- 'UpEdge': [float(linearray[1]), float(linearray[3])],
	- 'Content': float(linearray[4]),
	- 'Error': err})
	+ self.data.append(BinData([linearray[0], linearray[2]], [linearray[1], linearray[3]], float(linearray[4]), err))
	else:
	- raise Exception('Histo1D does not have 6 or 7 columns.'+line)
	-
	+ raise Exception('Histo2D does not have the expected number of columns. '+line)
	+
	+ # TODO: specialise draw() here
	+
	+
	+
	+#############################



	class Frame(object):

	def __init__(self):
	self.framelinewidth = '0.3pt'

	def draw(self,inputdata):
	out = ('\n%\n% Frame\n%\n')
	if inputdata.description.has_key('FrameColor') and inputdata.description['FrameColor']!=None:
	color = inputdata.description['FrameColor']
	# We want to draw this frame only once, so set it to False for next time:
	inputdata.description['FrameColor']=None

	# Calculate how high and wide the overall plot is
	height = [0,0]
	- width = inputdata.description['PlotSizeX']
	- if inputdata.description.has_key('RatioPlot') and inputdata.description['RatioPlot']=='1':
	+ width = inputdata.attr('PlotSizeX')
	+ if inputdata.attr_bool('RatioPlot', False):
	height[1] = -inputdata.description['RatioPlotSizeY']
	- if not (inputdata.description.has_key('MainPlot') and inputdata.description['MainPlot']=='0'):
	+ if not inputdata.attr_bool('MainPlot', True):
	height[0] = inputdata.description['PlotSizeY']
	else:
	height[0] = -height[1]
	height[1] = 0

	# Get the margin widths
	left = inputdata.description['LeftMargin']+0.1
	right = inputdata.description['RightMargin']+0.1
	top = inputdata.description['TopMargin']+0.1
	bottom = inputdata.description['BottomMargin']+0.1

	#
	out += ('\\rput(0,1){\\psline[linewidth=%scm,linecolor=%s](%scm,%scm)(%scm,%scm)}\n' %(top, color, -left, top/2, width+right, top/2))
	out += ('\\rput(0,%scm){\\psline[linewidth=%scm,linecolor=%s](%scm,%scm)(%scm,%scm)}\n' %(height[1], bottom, color, -left, -bottom/2, width+right, -bottom/2))
	out += ('\\rput(0,0){\\psline[linewidth=%scm,linecolor=%s](%scm,%scm)(%scm,%scm)}\n' %(left, color, -left/2, height[1]-0.05, -left/2, height[0]+0.05))
	out += ('\\rput(1,0){\\psline[linewidth=%scm,linecolor=%s](%scm,%scm)(%scm,%scm)}\n' %(right, color, right/2, height[1]-0.05, right/2, height[0]+0.05))


	out += ('\\psframe[linewidth='+self.framelinewidth+',dimen=middle](0,0)(1,1)\n')
	return out



	class Ticks(object):

	def __init__(self, description, coors):
	self.majorticklinewidth = '0.3pt'
	self.minorticklinewidth = '0.3pt'
	self.majorticklength = '9pt'
	self.minorticklength = '4pt'
	self.description = description
	self.coors = coors

	- def draw_ticks(self, min, max, plotlog=False, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True, twosided=False):
	+ def draw_ticks(self, vmin, vmax, plotlog=False, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True, twosided=False):
	out = ""
	if plotlog:
	- if min <= 0 or max <= 0:
	+ if vmin <= 0 or vmax <= 0:
	raise Exception("Cannot place log axis min or max tick <= 0")
	if custommajorticks is None:
	- x=int(log10(min))
	- n_labels=0
	- while (x<log10(max)+1):
	- if 10**x>=min:
	- ticklabel=10**x
	- if ticklabel>min and ticklabel<max:
	+ x = int(log10(vmin))
	+ n_labels = 0
	+ while x < log10(vmax) + 1:
	+ if 10**x >= vmin:
	+ ticklabel = 10**x
	+ if ticklabel > vmin and ticklabel < vmax:
	out += self.draw_majortick(ticklabel,twosided)
	if drawlabels:
	out += self.draw_majorticklabel(ticklabel)
	- n_labels+=1
	- if ticklabel==min or ticklabel==max:
	+ n_labels += 1
	+ if ticklabel == vmin or ticklabel == vmax:
	if drawlabels:
	out += self.draw_majorticklabel(ticklabel)
	n_labels+=1
	for i in range(2,10):
	- ticklabel=i10*(x-1)
	- if ticklabel>min and ticklabel<max:
	+ ticklabel = i10*(x-1)
	+ if ticklabel > vmin and ticklabel < vmax:
	out += self.draw_minortick(ticklabel,twosided)
	- if drawlabels and n_labels==0:
	- if (i+1)10*(x-1)<max: # some special care for the last minor tick
	+ if drawlabels and n_labels == 0:
	+ if (i+1)10*(x-1) < vmax: # some special care for the last minor tick
	out += self.draw_minorticklabel(ticklabel)
	else:
	out += self.draw_minorticklabel(ticklabel, last=True)
	- x+=1
	+ x += 1
	else:
	print "Warning: custom major ticks not currently supported on log axes -- please contact the developers to request!"
	elif custommajorticks is not None or customminorticks is not None:
	if custommajorticks:
	for i in range(len(custommajorticks)):
	- value=custommajorticks[i]['Value']
	- label=custommajorticks[i]['Label']
	- if value>=min and value<=max:
	+ value = custommajorticks[i]['Value']
	+ label = custommajorticks[i]['Label']
	+ if value >= vmin and value <= vmax:
	out += self.draw_majortick(value,twosided)
	if drawlabels:
	out += self.draw_majorticklabel(value, label=label)
	if customminorticks:
	for i in range(len(customminorticks)):
	- value=customminorticks[i]['Value']
	- if value>=min and value<=max:
	+ value = customminorticks[i]['Value']
	+ if value >= vmin and value <= vmax:
	out += self.draw_minortick(value,twosided)
	else:
	- xrange = max-min
	- digits = int(log10(xrange))+1
	- if (xrange < 1):
	+ vrange = vmax - vmin
	+ if isnan(vrange):
	+ vrange, vmin, vmax = 1, 1, 2
	+ digits = int(log10(vrange))+1
	+ if vrange <= 1:
	digits -= 1
	- foo = int(xrange/(10**(digits-1)))
	- if (foo/9. > 0.5):
	+ foo = int(vrange/(10**(digits-1)))
	+ if foo/9. > 0.5:
	tickmarks = 10
	- elif (foo/9. > 0.2):
	+ elif foo/9. > 0.2:
	tickmarks = 5
	- elif (foo/9. > 0.1):
	+ elif foo/9. > 0.1:
	tickmarks = 2

	- if (custommajortickmarks>-1):
	+ if custommajortickmarks > -1:
	if custommajortickmarks not in [1, 2, 5, 10, 20]:
	print '+++ Error in Ticks.draw_ticks(): MajorTickMarks must be in [1, 2, 5, 10, 20]'
	else:
	- #if custommajortickmarks==1: custommajortickmarks=10
	tickmarks = custommajortickmarks

	- if (tickmarks == 2 or tickmarks == 20):
	+ if tickmarks == 2 or tickmarks == 20:
	minortickmarks = 3
	else:
	minortickmarks = 4
	- if (customminortickmarks>-1):
	+ if customminortickmarks > -1:
	minortickmarks = customminortickmarks
	#
	x = 0
	- while (x > min10*digits):
	+ while x > vmin10*digits:
	x -= tickmarks100*(digits-1)
	- while (x <= max10*digits):
	- if (x >= min10digits-tickmarks100**(digits-1)):
	+ while x <= vmax10*digits:
	+ if x >= vmin10digits - tickmarks100**(digits-1):
	ticklabel = 1.x/10*digits
	- if (int(ticklabel) == ticklabel):
	+ if int(ticklabel) == ticklabel:
	ticklabel = int(ticklabel)
	- if (float(ticklabel-min)/xrange >= -1e-5):
	- if (fabs(ticklabel-min)/xrange > 1e-5 and fabs(ticklabel-max)/xrange > 1e-5):
	+ if float(ticklabel-vmin)/vrange >= -1e-5:
	+ if abs(ticklabel-vmin)/vrange > 1e-5 and abs(ticklabel-vmax)/vrange > 1e-5:
	out += self.draw_majortick(ticklabel,twosided)
	if drawlabels:
	out += self.draw_majorticklabel(ticklabel)

	xminor = x
	for i in range(minortickmarks):
	xminor += 1.tickmarks100**(digits-1)/(minortickmarks+1)
	ticklabel = 1.xminor/10*digits
	- if (ticklabel > min and ticklabel < max):
	- if (fabs(ticklabel-min)/xrange > 1e-5 and fabs(ticklabel-max)/xrange > 1e-5):
	+ if ticklabel > vmin and ticklabel < vmax:
	+ if abs(ticklabel-vmin)/vrange > 1e-5 and abs(ticklabel-vmax)/vrange > 1e-5:
	out += self.draw_minortick(ticklabel,twosided)
	x += tickmarks100*(digits-1)
	return out

	def draw(self):
	pass

	def draw_minortick(self, ticklabel, twosided):
	pass

	def draw_majortick(self, ticklabel, twosided):
	pass

	def draw_majorticklabel(self, ticklabel):
	pass

	def draw_minorticklabel(self, value, label='', last=False):
	return ''

	def get_ticklabel(self, value, plotlog=False, minor=False, lastminor=False):
	label=''
	prefix = ''
	if plotlog:
	bar = int(log10(value))
	if bar < 0:
	sign='-'
	else:
	sign='\\,'
	if minor: # The power of ten is only to be added to the last minor tick label
	if lastminor:
	label = str(int(value/(10**bar))) + "\\cdot" + '10$^{'+sign+'\\text{'+str(abs(bar))+'}}$'
	else:
	label = str(int(value/(10**bar))) # The naked prefactor
	else:
	if bar==0:
	label = '1'
	else:
	label = '10$^{'+sign+'\\text{'+str(abs(bar))+'}}$'
	else:
	if fabs(value) < 1e-10:
	value = 0
	label = str(value)
	if "e" in label:
	a, b = label.split("e")
	astr = "%2.1f" % float(a)
	bstr = str(int(b))
	label = "\\smaller{%s $\\!\\cdot 10^{%s} $}" % (astr, bstr)
	return label



	class XTicks(Ticks):

	- def draw(self, custommajorticks=[], customminorticks=[], custommajortickmarks=-1, customminortickmarks=-1,drawlabels=True):
	+ def draw(self, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1,drawlabels=True):
	twosided = bool(int(self.description.get('XTwosidedTicks', '0')))
	out = ""
	out += ('\n%\n% X-Ticks\n%\n')
	out += ('\\def\\majortickmarkx{\\psline[linewidth='+self.majorticklinewidth+'](0,0)(0,'+self.majorticklength+')}%\n')
	out += ('\\def\\minortickmarkx{\\psline[linewidth='+self.minorticklinewidth+'](0,0)(0,'+self.minorticklength+')}%\n')
	uselog = self.description['LogX'] and (self.coors.xmin() > 0 and self.coors.xmax() > 0)
	out += self.draw_ticks(self.coors.xmin(), self.coors.xmax(),\
	plotlog=uselog,\
	custommajorticks=custommajorticks,\
	customminorticks=customminorticks,\
	custommajortickmarks=custommajortickmarks,\
	customminortickmarks=customminortickmarks,\
	drawlabels=drawlabels,\
	twosided=twosided)
	return out

	def draw_minortick(self, ticklabel, twosided):
	out = ''
	out += '\\rput('+self.coors.strphys2frameX(ticklabel)+', 0){\\minortickmarkx}\n'
	if twosided:
	out += '\\rput{180}('+self.coors.strphys2frameX(ticklabel)+', 1){\\minortickmarkx}\n'
	return out

	def draw_minorticklabel(self, value, label='', last=False):
	if not label:
	label=self.get_ticklabel(value, int(self.description['LogX']), minor=True, lastminor=last)
	if last: # Some more indentation for the last minor label
	return ('\\rput('+self.coors.strphys2frameX(value)+', 0){\\rput[B](1.9\\labelsep,-2.3\\labelsep){\\strut{}'+label+'}}\n')
	else:
	return ('\\rput('+self.coors.strphys2frameX(value)+', 0){\\rput[B](0,-2.3\\labelsep){\\strut{}'+label+'}}\n')

	def draw_majortick(self, ticklabel, twosided):
	out = ''
	out += '\\rput('+self.coors.strphys2frameX(ticklabel)+', 0){\\majortickmarkx}\n'
	if twosided:
	out += '\\rput{180}('+self.coors.strphys2frameX(ticklabel)+', 1){\\majortickmarkx}\n'
	return out

	def draw_majorticklabel(self, value, label=''):
	if not label:
	- label = self.get_ticklabel(value, int(self.description['LogX']) and (self.coors.xmin() > 0 and self.coors.xmax() > 0))
	+ label = self.get_ticklabel(value, int(self.description['LogX']) and self.coors.xmin() > 0 and self.coors.xmax() > 0)
	labelparts = label.split("\\n")
	labelcode = label if len(labelparts) == 1 else ("\\shortstack{" + "\\\\ ".join(labelparts) + "}")
	rtn = "\\rput(" + self.coors.strphys2frameX(value) + ", 0){\\rput[t](0,-\\labelsep){" + labelcode + "}}\n"
	return rtn



	class YTicks(Ticks):

	- def draw(self, custommajorticks=[], customminorticks=[], custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True):
	+ def draw(self, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True):
	twosided = bool(int(self.description.get('YTwosidedTicks', '0')))
	out = ""
	out += ('\n%\n% Y-Ticks\n%\n')
	- out += ('\\def\\majortickmarky{\\psline[linewidth='+self.majorticklinewidth+'](0,0)('+self.majorticklength+',0)}%\n')
	- out += ('\\def\\minortickmarky{\\psline[linewidth='+self.minorticklinewidth+'](0,0)('+self.minorticklength+',0)}%\n')
	- uselog = self.description['LogY'] and (self.coors.ymin() > 0 and self.coors.ymax() > 0)
	+ out += ('\\def\\majortickmarky{\\psline[linewidth=%s](0,0)(%s,0)}%%\n' % (self.majorticklinewidth, self.majorticklength))
	+ out += ('\\def\\minortickmarky{\\psline[linewidth=%s](0,0)(%s,0)}%%\n' % (self.minorticklinewidth, self.minorticklength))
	+ uselog = self.description['LogY'] and self.coors.ymin() > 0 and self.coors.ymax() > 0
	out += self.draw_ticks(self.coors.ymin(), self.coors.ymax(),
	plotlog=uselog,
	custommajorticks=custommajorticks,
	customminorticks=customminorticks,
	custommajortickmarks=custommajortickmarks,
	customminortickmarks=customminortickmarks,
	twosided=twosided,
	drawlabels=drawlabels)
	return out

	def draw_minortick(self, ticklabel, twosided):
	out = ''
	out += '\\rput(0, '+self.coors.strphys2frameY(ticklabel)+'){\\minortickmarky}\n'
	if twosided:
	out += '\\rput{180}(1, '+self.coors.strphys2frameY(ticklabel)+'){\\minortickmarky}\n'
	return out

	def draw_majortick(self, ticklabel, twosided):
	out = ''
	out += '\\rput(0, '+self.coors.strphys2frameY(ticklabel)+'){\\majortickmarky}\n'
	if twosided:
	out += '\\rput{180}(1, '+self.coors.strphys2frameY(ticklabel)+'){\\majortickmarky}\n'
	return out

	def draw_majorticklabel(self, value, label=''):
	if not label:
	- label = self.get_ticklabel(value, int(self.description['LogY']) and (self.coors.ymin() > 0 and self.coors.ymax() > 0))
	+ label = self.get_ticklabel(value, int(self.description['LogY']) and self.coors.ymin() > 0 and self.coors.ymax() > 0)
	if self.description.has_key('RatioPlotMode') and self.description['RatioPlotMode'] == 'deviation' and \
	- self.description.has_key('RatioPlotStage') and self.description['RatioPlotStage'] == '1':
	+ self.description.has_key('RatioPlotStage') and self.description['RatioPlotStage']:
	rtn = '\\uput[180]{0}(0, '+self.coors.strphys2frameY(value)+'){\\strut{}'+label+'\\,$\\sigma$}\n'
	else:
	labelparts = label.split("\\n")
	labelcode = label if len(labelparts) == 1 else ("\\shortstack{" + "\\\\ ".join(labelparts) + "}")
	rtn = "\\rput(0, " + self.coors.strphys2frameY(value) + "){\\rput[r](-\\labelsep,0){" + labelcode + "}}\n"
	return rtn



	-
	-
	-
	class ZTicks(Ticks):

	def __init__(self, description, coors):
	self.majorticklinewidth = '0.3pt'
	self.minorticklinewidth = '0.3pt'
	self.majorticklength = '6pt'
	self.minorticklength = '2.6pt'
	self.description = description
	self.coors = coors

	- def draw(self, custommajorticks=[], customminorticks=[],
	- custommajortickmarks=-1, customminortickmarks=-1,
	- drawlabels=True):
	+ def draw(self, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True):
	out = ""
	out += ('\n%\n% Z-Ticks\n%\n')
	out += ('\\def\\majortickmarkz{\\psline[linewidth='+self.majorticklinewidth+'](0,0)('+self.majorticklength+',0)}%\n')
	out += ('\\def\\minortickmarkz{\\psline[linewidth='+self.minorticklinewidth+'](0,0)('+self.minorticklength+',0)}%\n')
	out += self.draw_ticks(self.coors.zmin(), self.coors.zmax(),\
	plotlog=self.description['LogZ'],\
	custommajorticks=custommajorticks,\
	customminorticks=customminorticks,\
	custommajortickmarks=custommajortickmarks,\
	customminortickmarks=customminortickmarks,\
	twosided=False,\
	drawlabels=drawlabels)
	return out

	def draw_minortick(self, ticklabel, twosided):
	return '\\rput{180}(1, '+self.coors.strphys2frameZ(ticklabel)+'){\\minortickmarkz}\n'

	def draw_majortick(self, ticklabel, twosided):
	return '\\rput{180}(1, '+self.coors.strphys2frameZ(ticklabel)+'){\\majortickmarkz}\n'

	def draw_majorticklabel(self, value, label=''):
	if label=='':
	label = self.get_ticklabel(value, int(self.description['LogZ']))
	if self.description.has_key('RatioPlotMode') and self.description['RatioPlotMode']=='deviation' \
	and self.description.has_key('RatioPlotStage') and self.description['RatioPlotStage']:
	return ('\\uput[0]{0}(1, '+self.coors.strphys2frameZ(value)+'){\\strut{}'+label+'\\,$\\sigma$}\n')
	else:
	return ('\\uput[0]{0}(1, '+self.coors.strphys2frameZ(value)+'){\\strut{}'+label+'}\n')



	class Coordinates(object):

	def __init__(self, inputdata):
	self.description = inputdata.description

	def phys2frameX(self, x):
	if self.description['LogX']:
	if x>0:
	result = 1.*(log10(x)-log10(self.xmin()))/(log10(self.xmax())-log10(self.xmin()))
	else:
	return -10
	else:
	result = 1.*(x-self.xmin())/(self.xmax()-self.xmin())
	if (fabs(result) < 1e-4):
	return 0
	else:
	return min(max(result,-10),10)

	def phys2frameY(self, y):
	if self.description['LogY']:
	if y > 0 and self.ymin() > 0 and self.ymax() > 0:
	result = 1.*(log10(y)-log10(self.ymin()))/(log10(self.ymax())-log10(self.ymin()))
	else:
	return -10
	else:
	result = 1.*(y-self.ymin())/(self.ymax()-self.ymin())
	if (fabs(result) < 1e-4):
	return 0
	else:
	return min(max(result,-10),10)

	def phys2frameZ(self, z):
	if self.description['LogZ']:
	if z>0:
	result = 1.*(log10(z)-log10(self.zmin()))/(log10(self.zmax())-log10(self.zmin()))
	else:
	return -10
	else:
	result = 1.*(z-self.zmin())/(self.zmax()-self.zmin())
	if (fabs(result) < 1e-4):
	return 0
	else:
	return min(max(result,-10),10)

	# TODO: Add frame2phys functions (to allow linear function sampling in the frame space rather than the physical space)

	def strphys2frameX(self, x):
	return str(self.phys2frameX(x))

	def strphys2frameY(self, y):
	return str(self.phys2frameY(y))

	def strphys2frameZ(self, z):
	return str(self.phys2frameZ(z))

	def xmin(self):
	return self.description['Borders'][0]

	def xmax(self):
	return self.description['Borders'][1]

	def ymin(self):
	return self.description['Borders'][2]

	def ymax(self):
	return self.description['Borders'][3]

	def zmin(self):
	return self.description['Borders'][4]

	def zmax(self):
	return self.description['Borders'][5]


	####################


	def try_cmd(args):
	"Run the given command + args and return True/False if it succeeds or not"
	import subprocess
	try:
	subprocess.check_output(args, stderr=subprocess.STDOUT)
	return True
	- except AttributeError:
	- # Python <=2.6 does not provide check_output
	- return True
	except:
	return False

	def have_cmd(cmd):
	return try_cmd(["which", cmd])


	import shutil, subprocess
	def process_datfile(datfile):
	global opts
	if not os.access(datfile, os.R_OK):
	raise Exception("Could not read data file '%s'" % datfile)

	dirname = os.path.dirname(datfile)
	datfile = os.path.basename(datfile)
	filename = datfile.replace('.dat','')

	## Create a temporary directory
	cwd = os.getcwd()
	datpath = os.path.join(cwd, dirname, datfile)
	tempdir = tempfile.mkdtemp('.make-plots')
	tempdatpath = os.path.join(tempdir, datfile)
	shutil.copy(datpath, tempdir)
	+ if opts.NO_CLEANUP:
	+ logging.info('Keeping temp-files in %s' % tempdir)

	## Make TeX file
	- inputdata = Inputdata(os.path.join(dirname,filename))
	+ inputdata = InputData(os.path.join(dirname,filename))
	texpath = os.path.join(tempdir, '%s.tex' % filename)
	texfile = open(texpath, 'w')
	p = Plot(inputdata)
	texfile.write(p.write_header(inputdata))
	- if inputdata.description.get('MainPlot', '1') == '1':
	+ if inputdata.attr_bool("MainPlot", True):
	mp = MainPlot(inputdata)
	texfile.write(mp.draw(inputdata))
	- if not inputdata.description.get('is2dim', False) and \
	- inputdata.description.get('RatioPlot', '1') == '1' and \
	- inputdata.description.get('RatioPlotReference') is not None:
	+ if not inputdata.attr_bool("is2dim", False) and inputdata.attr_bool("RatioPlot", True) and inputdata.attr("RatioPlotReference"): # is not None:
	rp = RatioPlot(inputdata)
	texfile.write(rp.draw(inputdata))
	texfile.write(p.write_footer())
	texfile.close()

	if opts.OUTPUT_FORMAT != ["TEX"]:

	## Check for the required programs
	latexavailable = have_cmd("latex")
	dvipsavailable = have_cmd("dvips")
	convertavailable = have_cmd("convert")
	ps2pnmavailable = have_cmd("ps2pnm")
	pnm2pngavailable = have_cmd("pnm2png")

	# TODO: It'd be nice to be able to control the size of the PNG between thumb and full-size...
	# currently defaults (and is used below) to a size suitable for thumbnails
	- def mkpng(infile, outfile, density=100):
	+ def mkpngcmd(infile, outfile, outsize=450, density=300):
	if convertavailable:
	- pngcmd = ["convert", "-flatten", "-density", str(density), infile, "-quality", "100", "-sharpen", "0x1.0", outfile]
	- logging.debug(" ".join(pngcmd))
	- pngproc = subprocess.Popen(pngcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- pngproc.wait()
	+ pngcmd = ["convert",
	+ "-flatten",
	+ "-density", str(density),
	+ infile,
	+ "-quality", "100",
	+ "-resize", "{size:d}x{size:d}>".format(size=outsize),
	+ #"-sharpen", "0x1.0",
	+ outfile]
	+ #logging.debug(" ".join(pngcmd))
	+ #pngproc = subprocess.Popen(pngcmd, stdout=subprocess.PIPE, cwd=tempdir)
	+ #pngproc.wait()
	+ return pngcmd
	else:
	raise Exception("Required PNG maker program (convert) not found")
	# elif ps2pnmavailable and pnm2pngavailable:
	# pstopnm = "pstopnm -stdout -xsize=461 -ysize=422 -xborder=0.01 -yborder=0.01 -portrait " + infile
	# p1 = subprocess.Popen(pstopnm.split(), stdout=subprocess.PIPE, stderr=open("/dev/null", "w"), cwd=tempdir)
	# p2 = subprocess.Popen(["pnmtopng"], stdin=p1.stdout, stdout=open("%s/%s.png" % (tempdir, outfile), "w"), stderr=open("/dev/null", "w"), cwd=tempdir)
	# p2.wait()
	# else:
	# raise Exception("Required PNG maker programs (convert, or ps2pnm and pnm2png) not found")

	## Run LaTeX (in no-stop mode)
	logging.debug(os.listdir(tempdir))
	texcmd = ["latex", "\scrollmode\input", texpath]
	logging.debug("TeX command: " + " ".join(texcmd))
	texproc = subprocess.Popen(texcmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=tempdir)
	logging.debug(texproc.communicate()[0])
	logging.debug(os.listdir(tempdir))

	## Run dvips
	dvcmd = ["dvips", filename]
	if not logging.getLogger().isEnabledFor(logging.DEBUG):
	dvcmd.append("-q")
	## Handle Minion Font
	if opts.OUTPUT_FONT == "MINION":
	dvcmd.append('-Pminion')

	## Choose format
	# TODO: Rationalise... this is a mess! Maybe we can use tex2pix?
	if "PS" in opts.OUTPUT_FORMAT:
	dvcmd += ["-o", "%s.ps" % filename]
	logging.debug(" ".join(dvcmd))
	dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	dvproc.wait()
	if "PDF" in opts.OUTPUT_FORMAT:
	dvcmd.append("-f")
	logging.debug(" ".join(dvcmd))
	dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	cnvproc = subprocess.Popen(["ps2pdf", "-"], stdin=dvproc.stdout, stdout=subprocess.PIPE, cwd=tempdir)
	f = open(os.path.join(tempdir, "%s.pdf" % filename), "w")
	f.write(cnvproc.communicate()[0])
	f.close()
	if "EPS" in opts.OUTPUT_FORMAT:
	dvcmd.append("-f")
	logging.debug(" ".join(dvcmd))
	dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	cnvproc = subprocess.Popen(["ps2eps"], stdin=dvproc.stdout, stderr=subprocess.PIPE, stdout=subprocess.PIPE, cwd=tempdir)
	f = open(os.path.join(tempdir, "%s.eps" % filename), "w")
	f.write(cnvproc.communicate()[0])
	f.close()
	if "PNG" in opts.OUTPUT_FORMAT:
	dvcmd.append("-f")
	logging.debug(" ".join(dvcmd))
	dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- pngcmd = ["convert", "-flatten", "-density", "100", "-", "-quality", "100", "-sharpen", "0x1.0", "%s.png" % filename]
	+ #pngcmd = ["convert", "-flatten", "-density", "110", "-", "-quality", "100", "-sharpen", "0x1.0", "%s.png" % filename]
	+ pngcmd = mkpngcmd("-", "%s.png" % filename)
	logging.debug(" ".join(pngcmd))
	pngproc = subprocess.Popen(pngcmd, stdin=dvproc.stdout, stdout=subprocess.PIPE, cwd=tempdir)
	pngproc.wait()
	- # if opts.OUTPUT_FORMAT == "PSPNG":
	- # dvcmd += ["-o", "%s.ps" % filename]
	- # logging.debug(" ".join(dvcmd))
	- # dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- # dvproc.wait()
	- # assert os.path.exists("%s.ps" % filename)
	- # mkpng("%s.ps" % filename, "%s.png" % filename)
	- # if opts.OUTPUT_FORMAT == "PDFPNG":
	- # dvcmd.append("-f")
	- # logging.debug(" ".join(dvcmd))
	- # dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- # cnvproc = subprocess.Popen(["ps2pdf", "-"], stdin=dvproc.stdout, stdout=subprocess.PIPE, cwd=tempdir)
	- # f = open(os.path.join(tempdir, "%s.pdf" % filename), "w")
	- # f.write(cnvproc.communicate()[0])
	- # f.close()
	- # logging.debug(os.listdir(tempdir))
	- # assert os.path.exists("%s.pdf" % filename)
	- # mkpng("%s.pdf" % filename, "%s.png" % filename)
	- # if opts.OUTPUT_FORMAT == "EPSPNG":
	- # dvcmd.append("-f")
	- # logging.debug(" ".join(dvcmd))
	- # dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- # cnvproc = subprocess.Popen(["ps2eps"], stdin=dvproc.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=tempdir)
	- # f = open(os.path.join(tempdir, "%s.eps" % filename), "w")
	- # f.write(cnvproc.communicate()[0])
	- # f.close()
	- # mkpng("%s.eps" % filename, "%s.png" % filename)
	- # else:
	- # logging.error("Unknown format: %s" % opts.OUTPUT_FORMAT)
	- # sys.exit(1)
	logging.debug(os.listdir(tempdir))

	## Copy results back to main dir
	for fmt in opts.OUTPUT_FORMAT:
	outname = "%s.%s" % (filename, fmt.lower())
	outpath = os.path.join(tempdir, outname)
	if os.path.exists(outpath):
	shutil.copy(outpath, os.path.join(cwd,dirname))
	else:
	logging.error("No output file '%s' from processing %s" % (outname, datfile))

	## Clean up
	- if opts.NO_CLEANUP:
	- logging.info('Keeping temp-files in %s' % tempdir)
	- else:
	+ if not opts.NO_CLEANUP:
	shutil.rmtree(tempdir, ignore_errors=True)


	####################


	if __name__ == '__main__':

	## Try to rename the process on Linux
	try:
	import ctypes
	libc = ctypes.cdll.LoadLibrary('libc.so.6')
	libc.prctl(15, 'make-plots', 0, 0, 0)
	except Exception:
	pass

	## Try to use Psyco optimiser
	try:
	import psyco
	psyco.full()
	except ImportError:
	pass

	## Find number of (virtual) processing units
	- numcores = os.sysconf('SC_NPROCESSORS_ONLN')
	- if numcores is None:
	+ import multiprocessing
	+ try:
	+ numcores = multiprocessing.cpu_count()
	+ except:
	numcores = 1

	## Parse command line options
	from optparse import OptionParser, OptionGroup
	parser = OptionParser(usage=__doc__)
	parser.add_option("-n", "-j", "--num-threads", dest="NUM_THREADS", type="int",
	default=numcores, help="max number of threads to be used [%s]" % numcores)
	parser.add_option("--font", dest="OUTPUT_FONT", choices="palatino,cm,times,helvetica,minion".split(","),
	default="palatino", help="choose the font to be used in the plots")
	parser.add_option("--palatino", dest="OUTPUT_FONT", action="store_const", const="palatino", default="palatino",
	- help="Use Palatino as font (default). DEPRECATED: Use --font")
	+ help="use Palatino as font (default). DEPRECATED: Use --font")
	parser.add_option("--cm", dest="OUTPUT_FONT", action="store_const", const="cm", default="palatino",
	- help="Use Computer Modern as font. DEPRECATED: Use --font")
	+ help="use Computer Modern as font. DEPRECATED: Use --font")
	parser.add_option("--times", dest="OUTPUT_FONT", action="store_const", const="times", default="palatino",
	- help="Use Times as font. DEPRECATED: Use --font")
	+ help="use Times as font. DEPRECATED: Use --font")
	parser.add_option("--minion", dest="OUTPUT_FONT", action="store_const", const="minion", default="palatino",
	- help="Use Adobe Minion Pro as font. Note: You need to set TEXMFHOME first. DEPRECATED: Use --font")
	+ help="use Adobe Minion Pro as font. Note: You need to set TEXMFHOME first. DEPRECATED: Use --font")
	parser.add_option("--helvetica", dest="OUTPUT_FONT", action="store_const", const="helvetica", default="palatino",
	- help="Use Helvetica as font. DEPRECATED: Use --font")
	+ help="use Helvetica as font. DEPRECATED: Use --font")
	parser.add_option("--format", dest="OUTPUT_FORMAT", default="PDF",
	- help="Choose plot format, perhaps multiple comma-separated formats e.g. 'pdf' or 'tex,pdf,png' (default = PDF).")
	+ help="choose plot format, perhaps multiple comma-separated formats e.g. 'pdf' or 'tex,pdf,png' (default = PDF).")
	parser.add_option("--ps", dest="OUTPUT_FORMAT", action="store_const", const="PS", default="PDF",
	- help="Create PostScript output (default). DEPRECATED")
	+ help="create PostScript output (default). DEPRECATED")
	parser.add_option("--pdf", dest="OUTPUT_FORMAT", action="store_const", const="PDF", default="PDF",
	- help="Create PDF output. DEPRECATED")
	+ help="create PDF output. DEPRECATED")
	parser.add_option("--eps", dest="OUTPUT_FORMAT", action="store_const", const="EPS", default="PDF",
	- help="Create Encapsulated PostScript output. DEPRECATED")
	+ help="create Encapsulated PostScript output. DEPRECATED")
	parser.add_option("--png", dest="OUTPUT_FORMAT", action="store_const", const="PNG", default="PDF",
	- help="Create PNG output. DEPRECATED")
	+ help="create PNG output. DEPRECATED")
	parser.add_option("--pspng", dest="OUTPUT_FORMAT", action="store_const", const="PS,PNG", default="PDF",
	- help="Create PS and PNG output. DEPRECATED")
	+ help="create PS and PNG output. DEPRECATED")
	parser.add_option("--pdfpng", dest="OUTPUT_FORMAT", action="store_const", const="PDF,PNG", default="PDF",
	- help="Create PDF and PNG output. DEPRECATED")
	+ help="create PDF and PNG output. DEPRECATED")
	parser.add_option("--epspng", dest="OUTPUT_FORMAT", action="store_const", const="EPS,PNG", default="PDF",
	- help="Create EPS and PNG output. DEPRECATED")
	+ help="create EPS and PNG output. DEPRECATED")
	parser.add_option("--tex", dest="OUTPUT_FORMAT", action="store_const", const="TEX", default="PDF",
	- help="Create TeX/LaTeX output.")
	+ help="create TeX/LaTeX output.")
	parser.add_option("--no-cleanup", dest="NO_CLEANUP", action="store_true", default=False,
	- help="Keep temporary directory and print its filename.")
	+ help="keep temporary directory and print its filename.")
	+ parser.add_option("--no-subproc", dest="NO_SUBPROC", action="store_true", default=False,
	+ help="don't use subprocesses to render the plots in parallel -- useful for debugging.")
	parser.add_option("--full-range", dest="FULL_RANGE", action="store_true", default=False,
	- help="Plot full y range in LogY plots.")
	+ help="plot full y range in LogY plots.")
	parser.add_option("-c", "--config", dest="CONFIGFILES", action="append", default=None,
	- help="Plot config file to be used. Overrides internal config blocks.")
	+ help="plot config file to be used. Overrides internal config blocks.")
	verbgroup = OptionGroup(parser, "Verbosity control")
	verbgroup.add_option("-v", "--verbose", action="store_const", const=logging.DEBUG, dest="LOGLEVEL",
	default=logging.INFO, help="print debug (very verbose) messages")
	verbgroup.add_option("-q", "--quiet", action="store_const", const=logging.WARNING, dest="LOGLEVEL",
	default=logging.INFO, help="be very quiet")
	parser.add_option_group(verbgroup)

	opts, args = parser.parse_args()
	logging.basicConfig(level=opts.LOGLEVEL, format="%(message)s")
	+ opts.OUTPUT_FONT = opts.OUTPUT_FONT.upper()
	opts.OUTPUT_FORMAT = opts.OUTPUT_FORMAT.upper().split(",")

	## Check for no args
	if len(args) == 0:
	logging.error(parser.get_usage())
	sys.exit(2)

	## Check that the files exist
	for f in args:
	if not os.access(f, os.R_OK):
	print "Error: cannot read from %s" % f
	sys.exit(1)

	## Test for external programs (kpsewhich, latex, dvips, ps2pdf/ps2eps, and convert)
	opts.LATEXPKGS = []
	if opts.OUTPUT_FORMAT != ["TEX"]:
	try:
	## latex
	if not have_cmd("latex"):
	logging.error("ERROR: required program 'latex' could not be found. Exiting...")
	sys.exit(1)
	## dvips
	if not have_cmd("dvips"):
	logging.error("ERROR: required program 'dvips' could not be found. Exiting...")
	sys.exit(1)

	## ps2pdf / ps2eps
	if "PDF" in opts.OUTPUT_FORMAT:
	if not have_cmd("ps2pdf"):
	logging.error("ERROR: required program 'ps2pdf' (for PDF output) could not be found. Exiting...")
	sys.exit(1)
	elif "EPS" in opts.OUTPUT_FORMAT:
	if not have_cmd("ps2eps"):
	logging.error("ERROR: required program 'ps2eps' (for EPS output) could not be found. Exiting...")
	sys.exit(1)
	## PNG output converter
	if "PNG" in opts.OUTPUT_FORMAT:
	if not have_cmd("convert"):
	logging.error("ERROR: required program 'convert' (for PNG output) could not be found. Exiting...")
	sys.exit(1)

	## kpsewhich: required for LaTeX package testing
	if not have_cmd("kpsewhich"):
	logging.warning("WARNING: required program 'kpsewhich' (for LaTeX package checks) could not be found")
	else:
	## Check minion font
	if opts.OUTPUT_FONT == "MINION":
	p = subprocess.Popen(["kpsewhich", "minion.sty"], stdout=subprocess.PIPE)
	p.wait()
	if p.returncode != 0:
	logging.warning('Warning: Using "--minion" requires minion.sty to be installed. Ignoring it.')
	opts.OUTPUT_FONT = "PALATINO"

	## Check for HEP LaTeX packages
	# TODO: remove HEP-specifics/non-standards?
	for pkg in ["hepnames", "hepunits", "underscore"]:
	p = subprocess.Popen(["kpsewhich", "%s.sty" % pkg], stdout=subprocess.PIPE)
	p.wait()
	if p.returncode == 0:
	opts.LATEXPKGS.append(pkg)

	## Check for Palatino old style figures and small caps
	if opts.OUTPUT_FONT == "PALATINO":
	p = subprocess.Popen(["kpsewhich", "ot1pplx.fd"], stdout=subprocess.PIPE)
	p.wait()
	if p.returncode == 0:
	opts.OUTPUT_FONT = "PALATINO_OSF"
	except Exception, e:
	logging.warning("Problem while testing for external packages. I'm going to try and continue without testing, but don't hold your breath...")

	-
	- ## Set up signal handling
	- import signal
	- RECVD_KILL_SIGNAL = None
	- def handleKillSignal(signum, frame):
	- "Declare us as having been signalled, and return to default handling behaviour"
	- global RECVD_KILL_SIGNAL
	- logging.critical("Signal handler called with signal " + str(signum))
	- RECVD_KILL_SIGNAL = signum
	- signal.signal(signum, signal.SIG_DFL)
	- ## Signals to handle
	- # signal.signal(signal.SIGINT, handleKillSignal)
	- # signal.signal(signal.SIGTERM, handleKillSignal)
	- # signal.signal(signal.SIGHUP, handleKillSignal)
	- # signal.signal(signal.SIGUSR2, handleKillSignal)
	-
	def init_worker():
	+ import signal
	signal.signal(signal.SIGINT, signal.SIG_IGN)

	- ## Run threads
	+ ## Run rendering jobs
	datfiles = args
	plotword = "plots" if len(datfiles) > 1 else "plot"
	logging.info("Making %d %s" % (len(datfiles), plotword))
	- import multiprocessing
	- pool = multiprocessing.Pool(opts.NUM_THREADS, init_worker)
	- try:
	- for i, _ in enumerate(pool.imap(process_datfile, datfiles)):
	- logging.info("Plotting %s (%d/%d remaining)" % (datfiles[i], len(datfiles)-i, len(datfiles)))
	- pool.close()
	- except KeyboardInterrupt:
	- print "Caught KeyboardInterrupt, terminating workers"
	- pool.terminate()
	- pool.join()
	+ if opts.NO_SUBPROC:
	+ init_worker()
	+ for i, df in enumerate(datfiles):
	+ logging.info("Plotting %s (%d/%d remaining)" % (df, len(datfiles)-i, len(datfiles)))
	+ process_datfile(df)
	+ else:
	+ pool = multiprocessing.Pool(opts.NUM_THREADS, init_worker)
	+ try:
	+ for i, _ in enumerate(pool.imap(process_datfile, datfiles)):
	+ logging.info("Plotting %s (%d/%d remaining)" % (datfiles[i], len(datfiles)-i, len(datfiles)))
	+ pool.close()
	+ except KeyboardInterrupt:
	+ print "Caught KeyboardInterrupt, terminating workers"
	+ pool.terminate()
	+ pool.join()
	diff --git a/bin/make-plots b/bin/make-plots-fast
	copy from bin/make-plots
	copy to bin/make-plots-fast
	--- a/bin/make-plots
	+++ b/bin/make-plots-fast
	@@ -1,2623 +1,2762 @@
	#! /usr/bin/env python

	"""\
	Usage: %prog [options] file.dat [file2.dat ...]

	TODO
	* Optimise output for e.g. lots of same-height bins in a row
	* Add a RatioFullRange directive to show the full range of error bars + MC envelope in the ratio
	* Tidy LaTeX-writing code -- faster to compile one doc only, then split it?
	* Handle boolean values flexibly (yes, no, true, false, etc. as well as 1, 0)
	"""

	##
	## This program is copyright by Hendrik Hoeth <hoeth@linta.de> and
	## the Rivet team https://rivet.hepforge.org. It may be used
	## for scientific and private purposes. Patches are welcome, but please don't
	## redistribute changed versions yourself.
	##

	## Check the Python version
	import sys
	if sys.version_info[:3] < (2,6,0):
	print "make-plots requires Python version >= 2.6.0... exiting"
	sys.exit(1)

	## Try to rename the process on Linux
	try:
	import ctypes
	libc = ctypes.cdll.LoadLibrary('libc.so.6')
	libc.prctl(15, 'make-plots', 0, 0, 0)
	except Exception, e:
	pass


	import os, logging, re
	import tempfile
	import getopt
	import string
	from math import *


	## Regex patterns
	pat_begin_block = re.compile(r'^#+\s*BEGIN ([A-Z0-9_]+) ?(\S+)?')
	pat_end_block = re.compile('^#+\s*END ([A-Z0-9_]+)')
	pat_comment = re.compile('^#\|^\s*$')
	pat_property = re.compile('^(\w+?)=(.*)$')
	pat_path_property = re.compile('^(\S+?)::(\w+?)=(.*)$')


	def fuzzyeq(a, b, tolerance=1e-6):
	"Fuzzy equality comparison function for floats, with given fractional tolerance"
	# if type(a) is not float or type(a) is not float:
	# print a, b
	if (a == 0 and abs(b) < 1e-12) or (b == 0 and abs(a) < 1e-12):
	return True
	return 2.0*abs(a-b)/abs(a+b) < tolerance

	+def inrange(x, a, b):
	+ return x >= a and x < b
	+
	+def floatify(x):
	+ if type(x) is str:
	+ x = x.split()
	+ if not hasattr(x, "__len__"):
	+ x = [x]
	+ x = [float(a) for a in x]
	+ return x[0] if len(x) == 1 else x
	+
	+def floatpair(x):
	+ if type(x) is str:
	+ x = x.split()
	+ if hasattr(x, "__len__"):
	+ assert len(x) == 2
	+ return [float(a) for a in x]
	+ return [float(x), float(x)]
	+

	def is_end_marker(line, blockname):
	m = pat_end_block.match(line)
	return m and m.group(1) == blockname

	def is_comment(line):
	return pat_comment.match(line) is not None



	-class Inputdata(object):
	+class Described(object):
	+ "Inherited functionality for objects holding a 'description' dictionary"
	+
	+ def __init__(self):
	+ pass
	+
	+ def has_attr(self, key):
	+ return self.description.has_key(key)
	+
	+ def set_attr(self, key, val):
	+ self.description[key] = val
	+
	+ def attr(self, key, default=None):
	+ return self.description.get(key, default)
	+
	+ def attr_bool(self, key, default=None):
	+ x = self.attr(key, default)
	+ if x is None: return None
	+ if str(x).lower() in ["1", "true", "yes", "on"]: return True
	+ if str(x).lower() in ["0", "false", "no", "off"]: return False
	+ return None
	+
	+ def attr_int(self, key, default=None):
	+ x = self.attr(key, default)
	+ try:
	+ x = int(x)
	+ except:
	+ x = None
	+ return x
	+
	+ def attr_float(self, key, default=None):
	+ x = self.attr(key, default)
	+ try:
	+ x = float(x)
	+ except:
	+ x = None
	+ return x
	+
	+
	+
	+class InputData(Described):

	def __init__(self, filename):
	self.filename = filename+".dat"
	self.histos = {}
	self.special = {}
	self.functions = {}

	self.description = {}
	self.pathdescriptions = []

	- self.description['is2dim'] = False
	- f = open(filename+'.dat')
	+ self.is2dim = False
	+ f = open(self.filename)
	for line in f:
	m = pat_begin_block.match(line)
	if m:
	name, path = m.group(1,2)
	if path is None and name != 'PLOT':
	raise Exception('BEGIN sections need a path name.')

	## Pass the reading of the block to separate functions
	if name == 'PLOT':
	self.read_input(f);
	elif name == 'SPECIAL':
	self.special[path] = Special(f)
	elif name == 'HISTOGRAM' or name == 'HISTOGRAM2D':
	self.histos[path] = Histogram(f, p=path)
	# self.histos[path].path = path
	self.description['is2dim'] = self.histos[path].is2dim
	elif name == 'HISTO1D':
	self.histos[path] = Histo1D(f, p=path)
	elif name == 'HISTO2D':
	self.histos[path] = Histo2D(f, p=path)
	self.description['is2dim'] = True
	elif name == 'FUNCTION':
	self.functions[path] = Function(f)
	# elif is_comment(line):
	# continue
	# else:
	# self.read_path_based_input(line)
	f.close()

	self.apply_config_files(opts.CONFIGFILES)

	-
	## Plot (and subplot) sizing
	+ # TODO: Use attr functions and bools properly
	self.description.setdefault('PlotSizeX', 10.)
	if self.description['is2dim']:
	self.description['PlotSizeX'] -= 1.7
	self.description['MainPlot'] = '1'
	self.description['RatioPlot'] = '0'

	if self.description.has_key('PlotSize') and self.description['PlotSize']!='':
	plotsizes = self.description['PlotSize'].split(',')
	self.description['PlotSizeX'] = float(plotsizes[0])
	self.description['PlotSizeY'] = float(plotsizes[1])
	if len(plotsizes) == 3:
	self.description['RatioPlotSizeY'] = float(plotsizes[2])
	del self.description['PlotSize']

	if self.description.get('MainPlot', '1') == '0':
	## Ratio, no main
	self.description['RatioPlot'] = '1' #< don't allow both to be zero!
	self.description['PlotSizeY'] = 0.
	self.description.setdefault('RatioPlotSizeY', 9.)
	else:
	if self.description.get('RatioPlot', '0') == '1':
	## Main and ratio
	self.description.setdefault('PlotSizeY', 6.)
	self.description.setdefault('RatioPlotSizeY', self.description.get('RatioPlotYSize', 3.))
	else:
	## Main, no ratio
	self.description.setdefault('PlotSizeY', self.description.get('PlotYSize', 9.))
	self.description['RatioPlotSizeY'] = 0.

	## Ensure numbers, not strings
	self.description['PlotSizeX'] = float(self.description['PlotSizeX'])
	self.description['PlotSizeY'] = float(self.description['PlotSizeY'])
	self.description['RatioPlotSizeY'] = float(self.description['RatioPlotSizeY'])
	# self.description['TopMargin'] = float(self.description['TopMargin'])
	# self.description['BottomMargin'] = float(self.description['BottomMargin'])

	self.description['LogX'] = self.description.has_key('LogX') and self.description['LogX']=='1'
	self.description['LogY'] = self.description.has_key('LogY') and self.description['LogY']=='1'
	self.description['LogZ'] = self.description.has_key('LogZ') and self.description['LogZ']=='1'
	if self.description.has_key('Rebin'):
	for i in self.histos:
	self.histos[i].description['Rebin'] = self.description['Rebin']

	histoordermap = {}
	histolist = self.histos.keys()
	if self.description.has_key('DrawOnly'):
	histolist = filter(self.histos.keys().count, self.description['DrawOnly'].strip().split())
	for histo in histolist:
	order = 0
	if self.histos[histo].description.has_key('PlotOrder'):
	order = int(self.histos[histo].description['PlotOrder'])
	if not order in histoordermap:
	histoordermap[order] = []
	histoordermap[order].append(histo)
	sortedhistolist = []
	for i in sorted(histoordermap.keys()):
	sortedhistolist.extend(histoordermap[i])
	- self.description['DrawOnly']=sortedhistolist
	-
	-
	- # inherit various values from histograms if not explicitly
	- # set.
	+ self.description['DrawOnly'] = sortedhistolist
	+
	+
	+ ## Inherit various values from histograms if not explicitly set
	for k in ['LogX', 'LogY', 'LogZ',
	'XLabel', 'YLabel', 'ZLabel',
	'XCustomMajorTicks', 'YCustomMajorTicks', 'ZCustomMajorTicks']:
	self.inherit_from_histos(k)

	return


	+ @property
	+ def is2dim(self):
	+ return self.attr_bool("is2dim", False)
	+ @is2dim.setter
	+ def is2dim(self, val):
	+ self.set_attr("is2dim", val)
	+
	+
	+ @property
	+ def drawonly(self):
	+ x = self.attr("DrawOnly")
	+ if type(x) is str:
	+ self.drawonly = x #< use setter to listify
	+ return x if x else []
	+ @drawonly.setter
	+ def drawonly(self, val):
	+ if type(val) is str:
	+ val = val.strip().split()
	+ self.set_attr("DrawOnly", val)
	+
	+
	+ @property
	+ def stacklist(self):
	+ x = self.attr("Stack")
	+ if type(x) is str:
	+ self.stacklist = x #< use setter to listify
	+ return x if x else []
	+ @stacklist.setter
	+ def stacklist(self, val):
	+ if type(val) is str:
	+ val = val.strip().split()
	+ self.set_attr("Stack", val)
	+
	+
	+ @property
	+ def plotorder(self):
	+ x = self.attr("PlotOrder")
	+ if type(x) is str:
	+ self.plotorder = x #< use setter to listify
	+ return x if x else []
	+ @plotorder.setter
	+ def plotorder(self, val):
	+ if type(val) is str:
	+ val = val.strip().split()
	+ self.set_attr("PlotOrder", val)
	+
	+
	+ @property
	+ def plotsizex(self):
	+ return self.attr_float("PlotSizeX")
	+ @plotsizex.setter
	+ def plotsizex(self, val):
	+ self.set_attr("PlotSizeX", val)
	+
	+ @property
	+ def plotsizey(self):
	+ return self.attr_float("PlotSizeY")
	+ @plotsizey.setter
	+ def plotsizey(self, val):
	+ self.set_attr("PlotSizeY", val)
	+
	+ @property
	+ def plotsize(self):
	+ return [self.plotsizex, self.plotsizey]
	+ @plotsize.setter
	+ def plotsize(self, val):
	+ if type(val) is str:
	+ val = [float(x) for x in val.split(",")]
	+ assert len(val) == 2
	+ self.plotsizex = val[0]
	+ self.plotsizey = val[1]
	+
	+ @property
	+ def ratiosizey(self):
	+ return self.attr_float("RatioPlotSizeY")
	+ @ratiosizey.setter
	+ def ratiosizey(self, val):
	+ self.set_attr("RatioPlotSizeY", val)
	+
	+
	+ @property
	+ def scale(self):
	+ return self.attr_float("Scale")
	+ @scale.setter
	+ def scale(self, val):
	+ self.set_attr("Scale", val)
	+
	+
	+ @property
	+ def xmin(self):
	+ return self.attr_float("XMin")
	+ @xmin.setter
	+ def xmin(self, val):
	+ self.set_attr("XMin", val)
	+
	+ @property
	+ def xmax(self):
	+ return self.attr_float("XMax")
	+ @xmax.setter
	+ def xmax(self, val):
	+ self.set_attr("XMax", val)
	+
	+ @property
	+ def xrange(self):
	+ return [self.xmin, self.xmax]
	+ @xrange.setter
	+ def xrange(self, val):
	+ if type(val) is str:
	+ val = [float(x) for x in val.split(",")]
	+ assert len(val) == 2
	+ self.xmin = val[0]
	+ self.xmax = val[1]
	+
	+
	+ @property
	+ def ymin(self):
	+ return self.attr_float("YMin")
	+ @ymin.setter
	+ def ymin(self, val):
	+ self.set_attr("YMin", val)
	+
	+ @property
	+ def ymax(self):
	+ return self.attr_float("YMax")
	+ @ymax.setter
	+ def ymax(self, val):
	+ self.set_attr("YMax", val)
	+
	+ @property
	+ def yrange(self):
	+ return [self.ymin, self.ymax]
	+ @yrange.setter
	+ def yrange(self, val):
	+ if type(val) is str:
	+ val = [float(y) for y in val.split(",")]
	+ assert len(val) == 2
	+ self.ymin = val[0]
	+ self.ymax = val[1]
	+
	+
	+ # TODO: add more rw properties for plotsize(x,y), ratiosize(y),
	+ # show_mainplot, show_ratioplot, show_legend, log(x,y,z), rebin,
	+ # drawonly, legendonly, plotorder, stack,
	+ # label(x,y,z), majorticks(x,y,z), minorticks(x,y,z),
	+ # min(x,y,z), max(x,y,z), range(x,y,z)
	+
	+
	def inherit_from_histos(self, k):
	- # note: this will inherit the key from a random histogram:
	- # only use if you're sure all histograms have this key!
	+ """Note: this will inherit the key from a random histogram:
	+ only use if you're sure all histograms have this key!"""
	if not self.description.has_key(k):
	h = list(self.histos.itervalues())[0]
	if h.description.has_key(k):
	self.description[k] = h.description[k]

	- return
	-
	-

	def read_input(self, f):
	for line in f:
	if is_end_marker(line, 'PLOT'):
	break
	elif is_comment(line):
	continue
	m = pat_property.match(line)
	if m:
	prop, value = m.group(1,2)
	if prop in self.description:
	logging.debug("Overwriting property %s = %s -> %s" % (prop, self.description[prop], value))
	## Use strip here to deal with DOS newlines containing \r
	self.description[prop.strip()] = value.strip()


	def apply_config_files(self, conffiles):
	if conffiles is not None:
	for filename in conffiles:
	cf = open(filename,'r')
	lines = cf.readlines()
	for i in range(0, len(lines)):
	## First evaluate PLOT sections
	m = pat_begin_block.match(lines[i])
	if m and m.group(1) == 'PLOT' and re.match(m.group(2),self.filename):
	while i<len(lines)-1:
	i = i+1
	if is_end_marker(lines[i], 'PLOT'):
	break
	elif is_comment(lines[i]):
	continue
	m = pat_property.match(lines[i])
	if m:
	prop, value = m.group(1,2)
	if prop in self.description:
	logging.debug("Overwriting from conffile property %s = %s -> %s" % (prop, self.description[prop], value))
	## Use strip here to deal with DOS newlines containing \r
	self.description[prop.strip()] = value.strip()
	elif is_comment(lines[i]):
	continue
	else:
	## Then evaluate path-based settings, e.g. for HISTOGRAMs
	m = pat_path_property.match(lines[i])
	if m:
	- regex, prop, value=m.group(1,2,3)
	+ regex, prop, value = m.group(1,2,3)
	for obj_dict in [self.special, self.histos, self.functions]:
	for path, obj in obj_dict.iteritems():
	if re.match(regex, path):
	## Use strip here to deal with DOS newlines containing \r
	obj.description.update({prop.strip() : value.strip()})
	cf.close()



	-
	class Plot(object):

	- def __init__(self,inputdata):
	+ def __init__(self, inputdata):
	pass

	def set_normalization(self,inputdata):
	for method in ['NormalizeToIntegral', 'NormalizeToSum']:
	if inputdata.description.has_key(method):
	- for i in inputdata.description['DrawOnly']:
	- if not inputdata.histos[i].description.has_key(method):
	- inputdata.histos[i].description[method] = inputdata.description[method]
	- if inputdata.description.has_key('Scale'):
	- for i in inputdata.description['DrawOnly']:
	- inputdata.histos[i].description['Scale'] = float(inputdata.description['Scale'])
	- for i in inputdata.description['DrawOnly']:
	+ for i in inputdata.drawonly:
	+ if not inputdata.histos[i].has_attr(method):
	+ inputdata.histos[i].set_attr(method, inputdata.attr(method))
	+ if inputdata.scale:
	+ for i in inputdata.drawonly:
	+ inputdata.histos[i].scale = inputdata.scale
	+ for i in inputdata.drawonly:
	inputdata.histos[i].mangle_input()

	def stack_histograms(self,inputdata):
	if inputdata.description.has_key('Stack'):
	- foo=[]
	- for i in inputdata.description['Stack'].strip().split():
	- if i in inputdata.histos.keys():
	- foo.append(i)
	- previous=''
	- for i in foo:
	- if previous!='':
	+ stackhists = [h for h in inputdata.attr('Stack').strip().split() if h in inputdata.histos]
	+ previous = ''
	+ for i in stackhists:
	+ if previous != '':
	inputdata.histos[i].add(inputdata.histos[previous])
	- previous=i
	+ previous = i

	def set_histo_options(self,inputdata):
	if inputdata.description.has_key('ConnectGaps'):
	for i in inputdata.histos.keys():
	if not inputdata.histos[i].description.has_key('ConnectGaps'):
	- inputdata.histos[i].description['ConnectGaps']=inputdata.description['ConnectGaps']
	-
	- def set_borders(self,inputdata):
	+ inputdata.histos[i].description['ConnectGaps'] = inputdata.description['ConnectGaps']
	+
	+ def set_borders(self, inputdata):
	self.set_xmax(inputdata)
	self.set_xmin(inputdata)
	self.set_ymax(inputdata)
	self.set_ymin(inputdata)
	self.set_zmax(inputdata)
	self.set_zmin(inputdata)
	- inputdata.description['Borders']=(self.xmin, self.xmax, self.ymin, self.ymax, self.zmin, self.zmax)
	-
	- def set_xmin(self,inputdata):
	- if inputdata.description.has_key('XMin'):
	- self.xmin = float(inputdata.description['XMin'])
	+ inputdata.description['Borders'] = (self.xmin, self.xmax, self.ymin, self.ymax, self.zmin, self.zmax)
	+
	+ def set_xmin(self, inputdata):
	+ self.xmin = inputdata.xmin
	+ if self.xmin is None:
	+ self.xmin = min(inputdata.histos[h].getXMin() for h in inputdata.description['DrawOnly'])
	+
	+ def set_xmax(self,inputdata):
	+ self.xmax = inputdata.xmax
	+ if self.xmax is None:
	+ self.xmax = min(inputdata.histos[h].getXMax() for h in inputdata.description['DrawOnly'])
	+
	+ def set_ymin(self,inputdata):
	+ if inputdata.ymin is not None:
	+ self.ymin = inputdata.ymin
	else:
	- self.xmin = min(inputdata.histos[i].getXMin() for i in inputdata.description['DrawOnly'])
	-
	- def set_xmax(self,inputdata):
	- #print inputdata.description
	- if inputdata.description.has_key('XMax'):
	- self.xmax = float(inputdata.description['XMax'])
	+ ymins = [inputdata.histos[i].getYMin(self.xmin, self.xmax, inputdata.description['LogY']) for i in inputdata.attr('DrawOnly')]
	+ minymin = min(ymins)
	+ if inputdata.description['is2dim']:
	+ self.ymin = minymin
	+ else:
	+ showzero = inputdata.attr_bool("ShowZero", True)
	+ if showzero:
	+ self.ymin = 0. if minymin > -1e-4 else 1.1*minymin
	+ else:
	+ self.ymin = 1.1minymin if minymin < -1e-4 else 0 if minymin < 1e-4 else 0.9minymin
	+ if inputdata.description['LogY']:
	+ ymins = [ymin for ymin in ymins if ymin > 0.0]
	+ if not ymins:
	+ if self.ymax == 0:
	+ self.ymax = 1
	+ ymins.append(2e-7*self.ymax)
	+ minymin = min(ymins)
	+ fullrange = opts.FULL_RANGE
	+ if inputdata.has_attr('FullRange'):
	+ fullrange = inputdata.attr_bool('FullRange')
	+ self.ymin = minymin/1.7 if fullrange else max(minymin/1.7, 2e-7*self.ymax)
	+
	+ if self.ymin == self.ymax:
	+ self.ymin -= 1
	+ self.ymax += 1
	+
	+ def set_ymax(self,inputdata):
	+ if inputdata.has_attr('YMax'):
	+ self.ymax = inputdata.attr_float('YMax')
	else:
	- #print inputdata.description['DrawOnly']
	- self.xmax = max(inputdata.histos[i].getXMax() for i in inputdata.description['DrawOnly'])
	-
	- def set_ymin(self,inputdata):
	- if inputdata.description.has_key('YMin'):
	- self.ymin = float(inputdata.description['YMin'])
	+ self.ymax = max(inputdata.histos[h].getYMax(self.xmin, self.xmax) for h in inputdata.attr('DrawOnly'))
	+ if not inputdata.is2dim:
	+ self.ymax *= (1.7 if inputdata.attr_bool('LogY') else 1.1)
	+
	+ def set_zmin(self,inputdata):
	+ if inputdata.has_attr('ZMin'):
	+ self.zmin = inputdata.attr_float('ZMin')
	else:
	- foo=[]
	- for i in inputdata.description['DrawOnly']:
	- foo.append(inputdata.histos[i].getYMin(self.xmin, self.xmax, inputdata.description['LogY']))
	- if inputdata.description['is2dim']:
	- self.ymin=min(foo)
	- else:
	- showzero = True
	- if inputdata.description.has_key('ShowZero'):
	- if inputdata.description['ShowZero']=='0':
	- showzero = False
	+ zmins = [inputdata.histos[i].getZMin(self.xmin, self.xmax, self.ymin, self.ymax) for i in inputdata.attr('DrawOnly')]
	+ minzmin = min(zmins)
	+ self.zmin = minzmin
	+ if zmins:
	+ showzero = inputdata.attr_bool('ShowZero', True)
	if showzero:
	- if min(foo) > -1e-4:
	- self.ymin = 0
	- else:
	- self.ymin = 1.1*min(foo)
	+ self.zmin = 0 if minzmin > -1e-4 else 1.1*minzmin
	else:
	- if min(foo) < -1e-4:
	- self.ymin = 1.1*min(foo)
	- elif min(foo) < 1e-4:
	- self.ymin = 0
	- else:
	- self.ymin = 0.9*min(foo)
	-
	- if inputdata.description['LogY']:
	- foo=[item for item in foo if item>0.0]
	- if len(foo)==0:
	- if self.ymax==0:
	- self.ymax=1
	- foo.append(2e-7*self.ymax)
	- fullrange = opts.FULL_RANGE
	- if inputdata.description.has_key('FullRange'):
	- if inputdata.description['FullRange']=='1':
	- fullrange = True
	- else:
	- fullrange = False
	- if fullrange:
	- self.ymin = min(foo)/1.7
	- else:
	- self.ymin = max(min(foo)/1.7, 2e-7*self.ymax)
	- if self.ymin==self.ymax:
	- self.ymin-=1
	- self.ymax+=1
	-
	- def set_ymax(self,inputdata):
	- if inputdata.description.has_key('YMax'):
	- self.ymax = float(inputdata.description['YMax'])
	- else:
	- foo=[]
	- for i in inputdata.description['DrawOnly']:
	- foo.append(inputdata.histos[i].getYMax(self.xmin, self.xmax))
	- if inputdata.description['is2dim']:
	- self.ymax=max(foo)
	- else:
	- if inputdata.description['LogY']:
	- self.ymax=1.7*max(foo)
	- else:
	- self.ymax=1.1*max(foo)
	-
	- def set_zmin(self,inputdata):
	- if inputdata.description.has_key('ZMin'):
	- self.zmin = float(inputdata.description['ZMin'])
	- else:
	- foo=[]
	- for i in inputdata.description['DrawOnly']:
	- foo.append(inputdata.histos[i].getZMin(self.xmin, self.xmax, self.ymin, self.ymax))
	- if not foo:
	- self.zmin = min(foo)
	- else:
	- showzero = True
	- if inputdata.description.has_key('ShowZero'):
	- if inputdata.description['ShowZero']=='0':
	- showzero = False
	- if showzero:
	- if min(foo) > -1e-4:
	- self.zmin = 0
	- else:
	- self.zmin = 1.1*min(foo)
	- else:
	- if min(foo) < -1e-4:
	- self.zmin = 1.1*min(foo)
	- elif min(foo) < 1e-4:
	- self.zmin = 0
	- else:
	- self.zmin = 0.9*min(foo)
	-
	- if inputdata.description['LogZ']:
	- foo=[item for item in foo if item>0.0]
	- if len(foo)==0:
	- if self.zmax==0:
	- self.zmax=1
	- foo.append(2e-7*self.zmax)
	- fullrange = opts.FULL_RANGE
	- if inputdata.description.has_key('FullRange'):
	- if inputdata.description['FullRange']=='1':
	- fullrange = True
	- else:
	- fullrange = False
	- if fullrange:
	- self.zmin = min(foo)/1.7
	- else:
	- self.zmin = max(min(foo)/1.7, 2e-7*self.zmax)
	- if self.zmin==self.zmax:
	- self.zmin-=1
	- self.zmax+=1
	+ self.zmin = 1.1minzmin if minzmin < -1e-4 else 0. if minzmin < 1e-4 else 0.9minzmin
	+ if inputdata.attr_bool('LogZ', False):
	+ zmins = [zmin for zmin in zmins if zmin > 0]
	+ if not zmins:
	+ if self.zmax == 0:
	+ self.zmax = 1
	+ zmins.append(2e-7*self.zmax)
	+ minzmin = min(zmins)
	+ fullrange = inputdata.attr_bool("FullRange", opts.FULL_RANGE)
	+ self.zmin = minzmin/1.7 if fullrange else max(minzmin/1.7, 2e-7*self.zmax)
	+
	+ if self.zmin == self.zmax:
	+ self.zmin -= 1
	+ self.zmax += 1

	def set_zmax(self,inputdata):
	- if inputdata.description.has_key('ZMax'):
	- self.zmax = float(inputdata.description['ZMax'])
	- else:
	- foo=[]
	- for i in inputdata.description['DrawOnly']:
	- foo.append(inputdata.histos[i].getZMax(self.xmin, self.xmax, self.ymin, self.ymax))
	- if foo:
	- self.zmax = max(foo)
	- else:
	- self.zmax = 1
	+ self.zmax = inputdata.attr_float('ZMax')
	+ if self.zmax is None:
	+ zmaxs = [inputdata.histos[h].getZMax(self.xmin, self.xmax, self.ymin, self.ymax) for h in inputdata.attr('DrawOnly')]
	+ self.zmax = max(zmaxs) if zmaxs else 1


	def draw(self):
	pass

	+
	def write_header(self,inputdata):
	- if inputdata.description.has_key('LeftMargin') and inputdata.description['LeftMargin']!='':
	- inputdata.description['LeftMargin'] = float(inputdata.description['LeftMargin'])
	- else:
	- inputdata.description['LeftMargin'] = 1.4
	- if inputdata.description.has_key('RightMargin') and inputdata.description['RightMargin']!='':
	- inputdata.description['RightMargin'] = float(inputdata.description['RightMargin'])
	- else:
	- inputdata.description['RightMargin'] = 0.35
	- if inputdata.description.has_key('TopMargin') and inputdata.description['TopMargin']!='':
	- inputdata.description['TopMargin'] = float(inputdata.description['TopMargin'])
	- else:
	- inputdata.description['TopMargin'] = 0.65
	- if inputdata.description.has_key('BottomMargin') and inputdata.description['BottomMargin']!='':
	- inputdata.description['BottomMargin'] = float(inputdata.description['BottomMargin'])
	- else:
	- inputdata.description['BottomMargin'] = 0.95
	+ out = '\\begin{multipage}\n'
	+ out += '\\begin{pspicture}(0,0)(0,0)\n'
	+ out += '\\psset{xunit=%scm}\n' %(inputdata.description['PlotSizeX'])
	if inputdata.description['is2dim']:
	- inputdata.description['RightMargin'] += 1.7
	- papersizex = inputdata.description['PlotSizeX'] + 0.1 + \
	- inputdata.description['LeftMargin'] + inputdata.description['RightMargin']
	- papersizey = inputdata.description['PlotSizeY'] + inputdata.description['RatioPlotSizeY'] + 0.1 + \
	- inputdata.description['TopMargin'] + inputdata.description['BottomMargin']
	- #
	- out = ""
	- out += '\\documentclass{article}\n'
	- if opts.OUTPUT_FONT == "MINION":
	- out += ('\\usepackage{minion}\n')
	- elif opts.OUTPUT_FONT == "PALATINO_OSF":
	- out += ('\\usepackage[osf,sc]{mathpazo}\n')
	- elif opts.OUTPUT_FONT == "PALATINO":
	- out += ('\\usepackage{mathpazo}\n')
	- elif opts.OUTPUT_FONT == "TIMES":
	- out += ('\\usepackage{mathptmx}\n')
	- elif opts.OUTPUT_FONT == "HELVETICA":
	- out += ('\\renewcommand{\\familydefault}{\\sfdefault}\n')
	- out += ('\\usepackage{sfmath}\n')
	- out += ('\\usepackage{helvet}\n')
	- out += ('\\usepackage[symbolgreek]{mathastext}\n')
	- for pkg in opts.LATEXPKGS:
	- out += ('\\usepackage{%s}\n' % pkg)
	- out += ('\\usepackage{pst-all}\n')
	- out += ('\\usepackage{xcolor}\n')
	- out += ('\\selectcolormodel{rgb}\n')
	- out += ('\\definecolor{red}{HTML}{EE3311}\n') # (Google uses 'DC3912')
	- out += ('\\definecolor{blue}{HTML}{3366FF}')
	- out += ('\\definecolor{green}{HTML}{109618}')
	- out += ('\\definecolor{orange}{HTML}{FF9900}')
	- out += ('\\definecolor{lilac}{HTML}{990099}')
	- out += ('\\usepackage{amsmath}\n')
	- out += ('\\usepackage{amssymb}\n')
	- out += ('\\usepackage{relsize}\n')
	- out += ('\\usepackage[dvips,\n')
	- out += (' left=%4.3fcm, right=0cm,\n' %(inputdata.description['LeftMargin']-0.45,))
	- out += (' top=%4.3fcm, bottom=0cm,\n' %(inputdata.description['TopMargin']-0.30,))
	- out += (' paperwidth=%scm,paperheight=%scm\n' %(papersizex,papersizey))
	- out += (']{geometry}\n')
	- out += ('\\begin{document}\n')
	- out += ('\\pagestyle{empty}\n')
	- out += ('\\SpecialCoor\n')
	- out += ('\\begin{pspicture}(0,0)(0,0)\n')
	- out += ('\\psset{xunit=%scm}\n' %(inputdata.description['PlotSizeX']))
	- if inputdata.description['is2dim']:
	+ colorseries = '{hsb}{grad}[rgb]{0,0,1}{-.700,0,0}'
	if inputdata.description.has_key('ColorSeries') and inputdata.description['ColorSeries']!='':
	colorseries = inputdata.description['ColorSeries']
	- else:
	- colorseries = '{hsb}{grad}[rgb]{0,0,1}{-.700,0,0}'
	- out += ('\\definecolorseries{gradientcolors}%s\n' % colorseries)
	- out += ('\\resetcolorseries[130]{gradientcolors}\n')
	+ out += '\\definecolorseries{gradientcolors}%s\n' % colorseries
	+ out += '\\resetcolorseries[130]{gradientcolors}\n'
	return out

	def write_footer(self):
	- out = ""
	- out += ('\\end{pspicture}\n')
	- out += ('\\end{document}\n')
	+ out = '\\end{pspicture}\n'
	+ out += '\\end{multipage}\n'
	+ out += '%\n%\n'
	return out



	class MainPlot(Plot):

	def __init__(self, inputdata):
	self.set_normalization(inputdata)
	self.stack_histograms(inputdata)
	if (inputdata.description.has_key('GofLegend') and inputdata.description['GofLegend']=='1') or \
	(inputdata.description.has_key('GofFrame') and inputdata.description['GofFrame']!='') and not \
	(inputdata.description.has_key('TaylorPlot') and inputdata.description['TaylorPlot']=='1'):
	self.calculate_gof(inputdata)
	self.set_histo_options(inputdata)
	self.set_borders(inputdata)
	self.yoffset = inputdata.description['PlotSizeY']
	self.coors = Coordinates(inputdata)

	def draw(self, inputdata):
	out = ""
	out += ('\n%\n% MainPlot\n%\n')
	out += ('\\psset{yunit=%scm}\n' %(self.yoffset))
	out += ('\\rput(0,-1){%\n')
	out += ('\\psset{yunit=%scm}\n' %(inputdata.description['PlotSizeY']))
	out += self._draw(inputdata)
	out += ('}\n')
	return out

	def _draw(self, inputdata):
	out = ""
	- if inputdata.description.has_key('DrawSpecialFirst') and inputdata.description['DrawSpecialFirst']=='1':
	- for i in inputdata.special.keys():
	- out += inputdata.special[i].draw(self.coors)
	- if inputdata.description.has_key('DrawFunctionFirst') and inputdata.description['DrawFunctionFirst']=='1':
	- for i in inputdata.functions.keys():
	- out += inputdata.functions[i].draw(self.coors)
	+
	+ # TODO: do this more compactly, e.g. by assigning sorting keys!
	+ if inputdata.attr_bool('DrawSpecialFirst', False):
	+ for s in inputdata.special:
	+ out += s.draw(self.coors)
	+ if inputdata.attr_bool('DrawFunctionFirst', False):
	+ for f in inputdata.functions:
	+ out += f.draw(self.coors)
	for i in inputdata.description['DrawOnly']:
	out += inputdata.histos[i].draw(self.coors)
	else:
	for i in inputdata.description['DrawOnly']:
	out += inputdata.histos[i].draw(self.coors)
	- for i in inputdata.functions.keys():
	- out += inputdata.functions[i].draw(self.coors)
	+ for f in inputdata.functions:
	+ out += f.draw(self.coors)
	else:
	- if inputdata.description.has_key('DrawFunctionFirst') and inputdata.description['DrawFunctionFirst']=='1':
	- for i in inputdata.functions.keys():
	- out += inputdata.functions[i].draw(self.coors)
	+ if inputdata.attr_bool('DrawFunctionFirst', False):
	+ for f in inputdata.functions:
	+ out += f.draw(self.coors)
	for i in inputdata.description['DrawOnly']:
	out += inputdata.histos[i].draw(self.coors)
	else:
	for i in inputdata.description['DrawOnly']:
	out += inputdata.histos[i].draw(self.coors)
	- for i in inputdata.functions.keys():
	- out += inputdata.functions[i].draw(self.coors)
	+ for f in inputdata.functions:
	+ out += f.draw(self.coors)
	for i in inputdata.special.keys():
	out += inputdata.special[i].draw(self.coors)
	- if inputdata.description.has_key('Legend') and inputdata.description['Legend']=='1':
	+
	+ if inputdata.attr_bool('Legend', False):
	legend = Legend(inputdata.description,inputdata.histos,inputdata.functions)
	out += legend.draw()
	if inputdata.description['is2dim']:
	- colorscale = Colorscale(inputdata.description,self.coors)
	+ colorscale = ColorScale(inputdata.description, self.coors)
	out += colorscale.draw()
	frame = Frame()
	out += frame.draw(inputdata)

	- if inputdata.description.has_key('XMajorTickMarks') and inputdata.description['XMajorTickMarks']!='':
	- xcustommajortickmarks=int(inputdata.description['XMajorTickMarks'])
	- else:
	- xcustommajortickmarks=-1
	- if inputdata.description.has_key('XMinorTickMarks') and inputdata.description['XMinorTickMarks']!='':
	- xcustomminortickmarks=int(inputdata.description['XMinorTickMarks'])
	- else:
	- xcustomminortickmarks=-1
	- xcustommajorticks=None
	- xcustomminorticks=None
	- if inputdata.description.has_key('XCustomMajorTicks'): # and inputdata.description['XCustomMajorTicks']!='':
	- xcustommajorticks=[]
	- FOO=inputdata.description['XCustomMajorTicks'].strip().split() #'\t')
	- if len(FOO) % 2 == 0:
	- for i in range(0,len(FOO),2):
	- xcustommajorticks.append({'Value': float(FOO[i]), 'Label': FOO[i+1]})
	- if inputdata.description.has_key('XCustomMinorTicks'): # and inputdata.description['XCustomMinorTicks']!='':
	- FOO=inputdata.description['XCustomMinorTicks'].strip().split() #'\t')
	- xcustomminorticks=[{'Value': float(FOO[i])} for i in range(len(FOO))]
	+ xcustommajortickmarks = inputdata.attr_int('XMajorTickMarks', -1)
	+ xcustomminortickmarks = inputdata.attr_int('XMinorTickMarks', -1)
	+
	+ xcustommajorticks = xcustomminorticks = None
	+ if inputdata.attr('XCustomMajorTicks'):
	+ xcustommajorticks = []
	+ x_label_pairs = inputdata.attr('XCustomMajorTicks').strip().split() #'\t')
	+ if len(x_label_pairs) % 2 == 0:
	+ for i in range(0, len(x_label_pairs), 2):
	+ xcustommajorticks.append({'Value': float(x_label_pairs[i]), 'Label': x_label_pairs[i+1]})
	+ else:
	+ print "Warning: XCustomMajorTicks requires an even number of alternating pos/label entries"
	+
	+ if inputdata.attr('XCustomMinorTicks'):
	+ xs = inputdata.attr('XCustomMinorTicks').strip().split() #'\t')
	+ xcustomminorticks = [{'Value': float(x)} for x in xs]
	+
	xticks = XTicks(inputdata.description, self.coors)
	- if (inputdata.description.has_key('RatioPlot') and inputdata.description['RatioPlot']=='1') or (inputdata.description.has_key('PlotXTickLabels') and inputdata.description['PlotXTickLabels']=='0'):
	- drawxlabels=False
	- else:
	- drawxlabels=True
	- out += xticks.draw(custommajortickmarks=xcustommajortickmarks,\
	- customminortickmarks=xcustomminortickmarks,\
	- custommajorticks=xcustommajorticks,\
	- customminorticks=xcustomminorticks,\
	+ drawxlabels = inputdata.attr_bool('PlotXTickLabels', True) and not inputdata.attr_bool('RatioPlot', False)
	+
	+ out += xticks.draw(custommajortickmarks=xcustommajortickmarks,
	+ customminortickmarks=xcustomminortickmarks,
	+ custommajorticks=xcustommajorticks,
	+ customminorticks=xcustomminorticks,
	drawlabels=drawxlabels)

	- if inputdata.description.has_key('YMajorTickMarks') and inputdata.description['YMajorTickMarks']!='':
	- ycustommajortickmarks=int(inputdata.description['YMajorTickMarks'])
	- else:
	- ycustommajortickmarks=-1
	- if inputdata.description.has_key('YMinorTickMarks') and inputdata.description['YMinorTickMarks']!='':
	- ycustomminortickmarks=int(inputdata.description['YMinorTickMarks'])
	- else:
	- ycustomminortickmarks=-1
	- ycustommajorticks=None
	- ycustomminorticks=None
	- if inputdata.description.has_key('YCustomMajorTicks'): # and inputdata.description['YCustomMajorTicks']!='':
	- ycustommajorticks=[]
	- FOO=inputdata.description['YCustomMajorTicks'].strip().split() #'\t')
	- if len(FOO) % 2 == 0:
	- for i in range(0,len(FOO),2):
	- ycustommajorticks.append({'Value': float(FOO[i]), 'Label': FOO[i+1]})
	- if inputdata.description.has_key('YCustomMinorTicks'): # and inputdata.description['YCustomMinorTicks']!='':
	- FOO=inputdata.description['YCustomMinorTicks'].strip().split() #'\t')
	- ycustomminorticks=[{'Value': float(FOO[i])} for i in range(len(FOO))]
	+ ycustommajortickmarks = inputdata.attr_int('YMajorTickMarks', -1)
	+ ycustomminortickmarks = inputdata.attr_int('YMinorTickMarks', -1)
	+
	+ ycustommajorticks = ycustomminorticks = None
	+ if inputdata.description.has_key('YCustomMajorTicks'):
	+ ycustommajorticks = []
	+ y_label_pairs = inputdata.description['YCustomMajorTicks'].strip().split() #'\t')
	+ if len(y_label_pairs) % 2 == 0:
	+ for i in range(0, len(y_label_pairs), 2):
	+ ycustommajorticks.append({'Value': float(y_label_pairs[i]), 'Label': y_label_pairs[i+1]})
	+ else:
	+ print "Warning: YCustomMajorTicks requires an even number of alternating pos/label entries"
	+
	+ if inputdata.has_attr('YCustomMinorTicks'):
	+ ys = inputdata.attr('YCustomMinorTicks').strip().split() #'\t')
	+ ycustomminorticks = [{'Value': float(y)} for y in ys]
	+
	yticks = YTicks(inputdata.description, self.coors)
	- if (inputdata.description.has_key('PlotYTickLabels') and inputdata.description['PlotYTickLabels']=='0'):
	- drawylabels=False
	- else:
	- drawylabels=True
	+ drawylabels = inputdata.attr_bool('PlotYTickLabels', True)
	+
	out += yticks.draw(custommajortickmarks=ycustommajortickmarks,
	customminortickmarks=ycustomminortickmarks,
	custommajorticks=ycustommajorticks,
	customminorticks=ycustomminorticks,
	drawlabels=drawylabels)

	labels = Labels(inputdata.description)
	- if inputdata.description.has_key('RatioPlot') and inputdata.description['RatioPlot']=='1':
	- out += labels.draw(['Title','YLabel'])
	+ if inputdata.attr_bool('RatioPlot', False):
	+ olab = labels.draw(['Title','YLabel'])
	else:
	if not inputdata.description['is2dim']:
	- out += labels.draw(['Title','XLabel','YLabel'])
	+ olab = labels.draw(['Title','XLabel','YLabel'])
	else:
	- out += labels.draw(['Title','XLabel','YLabel','ZLabel'])
	+ olab = labels.draw(['Title','XLabel','YLabel','ZLabel'])
	+ out += olab
	return out

	+
	def calculate_gof(self, inputdata):
	refdata = inputdata.description.get('GofReference')
	if refdata is None:
	refdata = inputdata.description.get('RatioPlotReference')

	if refdata is None:
	inputdata.description['GofLegend'] = '0'
	inputdata.description['GofFrame'] = ''
	return

	def pickcolor(gof):
	color = None
	colordefs = {}
	for i in inputdata.description.setdefault('GofFrameColor', '0:green 3:yellow 6:red!70').strip().split():
	foo = i.split(':')
	- if len(foo)!=2: continue
	+ if len(foo) != 2:
	+ continue
	colordefs[float(foo[0])] = foo[1]
	for i in sorted(colordefs.keys()):
	if gof>=i:
	color=colordefs[i]
	return color

	- inputdata.description.setdefault('GofLegend','0')
	- inputdata.description.setdefault('GofFrame','')
	- inputdata.description.setdefault('FrameColor',None)
	+ inputdata.description.setdefault('GofLegend', '0')
	+ inputdata.description.setdefault('GofFrame', '')
	+ inputdata.description.setdefault('FrameColor', None)

	for i in inputdata.description['DrawOnly']:
	- if i==refdata: continue
	- if inputdata.description['GofLegend']!='1' and i!=inputdata.description['GofFrame']: continue
	+ if i == refdata:
	+ continue
	+ if inputdata.description['GofLegend']!='1' and i!=inputdata.description['GofFrame']:
	+ continue

	if inputdata.description.has_key('GofType') and inputdata.description['GofType']!='chi2':
	return
	gof = inputdata.histos[i].getChi2(inputdata.histos[refdata])
	- if i==inputdata.description['GofFrame'] and inputdata.description['FrameColor'] is None:
	- inputdata.description['FrameColor']=pickcolor(gof)
	- if inputdata.histos[i].description.setdefault('Title', '')!='':
	+ if i == inputdata.description['GofFrame'] and inputdata.description['FrameColor'] is None:
	+ inputdata.description['FrameColor'] = pickcolor(gof)
	+ if inputdata.histos[i].description.setdefault('Title', '') != '':
	inputdata.histos[i].description['Title'] += ', '
	inputdata.histos[i].description['Title'] += '$\\chi^2/n={}$%1.2f' %gof



	class TaylorPlot(Plot):

	def __init__(self, inputdata):
	self.refdata = inputdata.description['TaylorPlotReference']
	self.calculate_taylorcoordinates(inputdata)

	def calculate_taylorcoordinates(self,inputdata):
	- foo=inputdata.description['DrawOnly'].pop(inputdata.description['DrawOnly'].index(self.refdata))
	+ foo = inputdata.description['DrawOnly'].pop(inputdata.description['DrawOnly'].index(self.refdata))
	inputdata.description['DrawOnly'].append(foo)
	for i in inputdata.description['DrawOnly']:
	print i
	print 'meanbinval = ', inputdata.histos[i].getMeanBinValue()
	print 'sigmabinval = ', inputdata.histos[i].getSigmaBinValue()
	print 'chi2/nbins = ', inputdata.histos[i].getChi2(inputdata.histos[self.refdata])
	print 'correlation = ', inputdata.histos[i].getCorrelation(inputdata.histos[self.refdata])
	print 'distance = ', inputdata.histos[i].getRMSdistance(inputdata.histos[self.refdata])



	class RatioPlot(Plot):

	def __init__(self, inputdata):
	+
	self.refdata = inputdata.description['RatioPlotReference']
	self.yoffset = inputdata.description['PlotSizeY'] + inputdata.description['RatioPlotSizeY']
	+
	inputdata.description['RatioPlotStage'] = True
	inputdata.description['PlotSizeY'] = inputdata.description['RatioPlotSizeY']
	inputdata.description['LogY'] = False
	+
	# TODO: It'd be nice it this wasn't so MC-specific
	if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='deviation':
	- inputdata.description['YLabel']='$(\\text{MC}-\\text{data})$'
	- inputdata.description['YMin']=-3.5
	- inputdata.description['YMax']=3.5
	+ inputdata.description['YLabel'] = '$(\\text{MC}-\\text{data})$'
	+ inputdata.description['YMin'] = -3.5
	+ inputdata.description['YMax'] = 3.5
	elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='datamc':
	- inputdata.description['YLabel']='Data/MC'
	- inputdata.description['YMin']=0.5
	- inputdata.description['YMax']=1.5
	+ inputdata.description['YLabel'] = 'Data/MC'
	+ inputdata.description['YMin'] = 0.5
	+ inputdata.description['YMax'] = 1.5
	else:
	- inputdata.description['YLabel']='MC/Data'
	- inputdata.description['YMin']=0.5
	- inputdata.description['YMax']=1.5
	+ inputdata.description['YLabel'] = 'MC/Data'
	+ inputdata.description['YMin'] = 0.5
	+ inputdata.description['YMax'] = 1.5
	+
	if inputdata.description.has_key('RatioPlotYLabel'):
	inputdata.description['YLabel'] = inputdata.description['RatioPlotYLabel']
	inputdata.description['YLabel']='\\rput(-%s,0){%s}'%(0.5*inputdata.description['PlotSizeY']/inputdata.description['PlotSizeX'],inputdata.description['YLabel'])
	+
	if inputdata.description.has_key('RatioPlotYMin'):
	- inputdata.description['YMin']=inputdata.description['RatioPlotYMin']
	+ inputdata.description['YMin'] = inputdata.description['RatioPlotYMin']
	if inputdata.description.has_key('RatioPlotYMax'):
	- inputdata.description['YMax']=inputdata.description['RatioPlotYMax']
	+ inputdata.description['YMax'] = inputdata.description['RatioPlotYMax']
	+
	if not inputdata.description.has_key('RatioPlotErrorBandColor'):
	- inputdata.description['RatioPlotErrorBandColor']='yellow'
	- if not inputdata.description.has_key('RatioPlotSameStyle') or inputdata.description['RatioPlotSameStyle']=='0':
	- inputdata.histos[self.refdata].description['ErrorBandColor']=inputdata.description['RatioPlotErrorBandColor']
	- inputdata.histos[self.refdata].description['ErrorBands']='1'
	- inputdata.histos[self.refdata].description['ErrorBars']='0'
	- inputdata.histos[self.refdata].description['LineStyle']='solid'
	- inputdata.histos[self.refdata].description['LineColor']='black'
	- inputdata.histos[self.refdata].description['LineWidth']='0.3pt'
	- inputdata.histos[self.refdata].description['PolyMarker']=''
	- inputdata.histos[self.refdata].description['ConnectGaps']='1'
	+ inputdata.description['RatioPlotErrorBandColor'] = 'yellow'
	+ if not inputdata.description.has_key('RatioPlotSameStyle') or inputdata.description['RatioPlotSameStyle'] == '0':
	+ inputdata.histos[self.refdata].description['ErrorBandColor'] = inputdata.description['RatioPlotErrorBandColor']
	+ inputdata.histos[self.refdata].description['ErrorBands'] = '1'
	+ inputdata.histos[self.refdata].description['ErrorBars'] = '0'
	+ inputdata.histos[self.refdata].description['LineStyle'] = 'solid'
	+ inputdata.histos[self.refdata].description['LineColor'] = 'black'
	+ inputdata.histos[self.refdata].description['LineWidth'] = '0.3pt'
	+ inputdata.histos[self.refdata].description['PolyMarker'] = ''
	+ inputdata.histos[self.refdata].description['ConnectGaps'] = '1'
	+
	self.calculate_ratios(inputdata)
	self.set_borders(inputdata)
	self.coors = Coordinates(inputdata)

	def draw(self, inputdata):
	out = ""
	out += ('\n%\n% RatioPlot\n%\n')
	out += ('\\psset{yunit=%scm}\n' %(self.yoffset))
	out += ('\\rput(0,-1){%\n')
	out += ('\\psset{yunit=%scm}\n' %(inputdata.description['PlotSizeY']))
	out += self._draw(inputdata)
	out += ('}\n')
	return out

	- def calculate_ratios(self,inputdata):
	- foo=inputdata.description['DrawOnly'].pop(inputdata.description['DrawOnly'].index(self.refdata))
	+ def calculate_ratios(self, inputdata):
	+ foo = inputdata.description['DrawOnly'].pop(inputdata.description['DrawOnly'].index(self.refdata))
	if inputdata.histos[self.refdata].description.has_key('ErrorBands') and inputdata.histos[self.refdata].description['ErrorBands']=='1':
	inputdata.description['DrawOnly'].insert(0,foo)
	else:
	inputdata.description['DrawOnly'].append(foo)
	for i in inputdata.description['DrawOnly']:
	- if i!=self.refdata:
	- if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='deviation':
	+ if i != self.refdata:
	+ if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'deviation':
	inputdata.histos[i].deviation(inputdata.histos[self.refdata])
	- elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='datamc':
	+ elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'datamc':
	inputdata.histos[i].dividereverse(inputdata.histos[self.refdata])
	- inputdata.histos[i].description['ErrorBars']='1'
	+ inputdata.histos[i].description['ErrorBars'] = '1'
	else:
	inputdata.histos[i].divide(inputdata.histos[self.refdata])
	- if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='deviation':
	+ if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'deviation':
	inputdata.histos[self.refdata].deviation(inputdata.histos[self.refdata])
	- elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='datamc':
	+ elif inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'datamc':
	inputdata.histos[self.refdata].dividereverse(inputdata.histos[self.refdata])
	else:
	inputdata.histos[self.refdata].divide(inputdata.histos[self.refdata])

	def _draw(self, inputdata):
	out = ""
	for i in inputdata.description['DrawOnly']:
	- if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode']=='datamc':
	- if i!=self.refdata:
	+ if inputdata.description.has_key('RatioPlotMode') and inputdata.description['RatioPlotMode'] == 'datamc':
	+ if i != self.refdata:
	out += inputdata.histos[i].draw(self.coors)
	else:
	out += inputdata.histos[i].draw(self.coors)

	frame = Frame()
	out += frame.draw(inputdata)

	# TODO: so much duplication with MainPlot... yuck!
	- if inputdata.description.has_key('XMajorTickMarks') and inputdata.description['XMajorTickMarks']!='':
	- xcustommajortickmarks=int(inputdata.description['XMajorTickMarks'])
	+ if inputdata.description.has_key('XMajorTickMarks') and inputdata.description['XMajorTickMarks'] != '':
	+ xcustommajortickmarks = int(inputdata.description['XMajorTickMarks'])
	else:
	- xcustommajortickmarks=-1
	- if inputdata.description.has_key('XMinorTickMarks') and inputdata.description['XMinorTickMarks']!='':
	- xcustomminortickmarks=int(inputdata.description['XMinorTickMarks'])
	+ xcustommajortickmarks = -1
	+ if inputdata.description.has_key('XMinorTickMarks') and inputdata.description['XMinorTickMarks'] != '':
	+ xcustomminortickmarks = int(inputdata.description['XMinorTickMarks'])
	else:
	- xcustomminortickmarks=-1
	- xcustommajorticks=None
	- xcustomminorticks=None
	+ xcustomminortickmarks =- 1
	+
	+ xcustommajorticks = None
	if inputdata.description.has_key('XCustomMajorTicks'): # and inputdata.description['XCustomMajorTicks']!='':
	- xcustommajorticks=[]
	- FOO=inputdata.description['XCustomMajorTicks'].strip().split() #'\t')
	- if not len(FOO)%2:
	- for i in range(0,len(FOO),2):
	- xcustommajorticks.append({'Value': float(FOO[i]), 'Label': FOO[i+1]})
	+ xcustommajorticks = []
	+ tickstr = inputdata.description['XCustomMajorTicks'].strip().split() #'\t')
	+ if not len(tickstr) % 2:
	+ for i in range(0, len(tickstr), 2):
	+ xcustommajorticks.append({'Value': float(tickstr[i]), 'Label': tickstr[i+1]})
	+
	+ xcustomminorticks = None
	if inputdata.description.has_key('XCustomMinorTicks'): # and inputdata.description['XCustomMinorTicks']!='':
	- xcustomminorticks=[]
	- FOO=inputdata.description['XCustomMinorTicks'].strip().split() #'\t')
	- for i in range(len(FOO)):
	- xcustomminorticks.append({'Value': float(FOO[i])})
	+ xcustomminorticks = []
	+ tickstr = inputdata.description['XCustomMinorTicks'].strip().split() #'\t')
	+ for i in range(len(tickstr)):
	+ xcustomminorticks.append({'Value': float(tickstr[i])})
	+
	xticks = XTicks(inputdata.description, self.coors)
	- if inputdata.description.has_key('RatioPlotTickLabels') and inputdata.description['RatioPlotTickLabels']=='0':
	- drawlabels=False
	- else:
	- drawlabels=True
	- out += xticks.draw(custommajortickmarks=xcustommajortickmarks,\
	- customminortickmarks=xcustomminortickmarks,\
	- custommajorticks=xcustommajorticks,\
	+ drawlabels = not (inputdata.description.has_key('RatioPlotTickLabels') and inputdata.description['RatioPlotTickLabels']=='0')
	+ out += xticks.draw(custommajortickmarks=xcustommajortickmarks,
	+ customminortickmarks=xcustomminortickmarks,
	+ custommajorticks=xcustommajorticks,
	customminorticks=xcustomminorticks,
	drawlabels=drawlabels)

	- if inputdata.description.has_key('YMajorTickMarks') and inputdata.description['YMajorTickMarks']!='':
	- ycustommajortickmarks=int(inputdata.description['YMajorTickMarks'])
	- else:
	- ycustommajortickmarks=-1
	- if inputdata.description.has_key('YMinorTickMarks') and inputdata.description['YMinorTickMarks']!='':
	- ycustomminortickmarks=int(inputdata.description['YMinorTickMarks'])
	- else:
	- ycustomminortickmarks=-1
	- ycustommajorticks=None
	- ycustomminorticks=None
	- if inputdata.description.has_key('YCustomMajorTicks'): # and inputdata.description['YCustomMajorTicks']!='':
	- ycustommajorticks=[]
	- FOO=inputdata.description['YCustomMajorTicks'].strip().split() #'\t')
	- if not len(FOO)%2:
	- for i in range(0,len(FOO),2):
	- ycustommajorticks.append({'Value': float(FOO[i]), 'Label': FOO[i+1]})
	- if inputdata.description.has_key('YCustomMinorTicks'): # and inputdata.description['YCustomMinorTicks']!='':
	- ycustomminorticks=[]
	- FOO=inputdata.description['YCustomMinorTicks'].strip().split() #'\t')
	- for i in range(len(FOO)):
	- ycustomminorticks.append({'Value': float(FOO[i])})
	+
	+ ycustommajortickmarks = inputdata.attr('YMajorTickMarks', '')
	+ ycustommajortickmarks = int(ycustommajortickmarks) if ycustommajortickmarks else -1
	+
	+ ycustomminortickmarks = inputdata.attr('YMinorTickMarks', '')
	+ ycustomminortickmarks = int(ycustomminortickmarks) if ycustomminortickmarks else -1
	+
	+ ycustommajorticks = None
	+ if inputdata.description.has_key('YCustomMajorTicks'):
	+ ycustommajorticks = []
	+ tickstr = inputdata.description['YCustomMajorTicks'].strip().split() #'\t')
	+ if not len(tickstr) % 2:
	+ for i in range(0, len(tickstr), 2):
	+ ycustommajorticks.append({'Value': float(tickstr[i]), 'Label': tickstr[i+1]})
	+
	+ ycustomminorticks = None
	+ if inputdata.description.has_key('YCustomMinorTicks'):
	+ ycustomminorticks = []
	+ tickstr = inputdata.description['YCustomMinorTicks'].strip().split() #'\t')
	+ for i in range(len(tickstr)):
	+ ycustomminorticks.append({'Value': float(tickstr[i])})
	+
	yticks = YTicks(inputdata.description, self.coors)
	- out += yticks.draw(custommajortickmarks=ycustommajortickmarks,\
	- customminortickmarks=ycustomminortickmarks,\
	- custommajorticks=ycustommajorticks,\
	+ out += yticks.draw(custommajortickmarks=ycustommajortickmarks,
	+ customminortickmarks=ycustomminortickmarks,
	+ custommajorticks=ycustommajorticks,
	customminorticks=ycustomminorticks)

	- if inputdata.description.has_key('MainPlot') and inputdata.description['MainPlot']=='0':
	- if inputdata.description.has_key('Legend') and inputdata.description['Legend']=='1':
	- legend = Legend(inputdata.description,inputdata.histos,inputdata.functions)
	- out += legend.draw()
	+ if not inputdata.attr_bool('MainPlot', True) and not inputdata.attr_bool('Legend', False):
	+ legend = Legend(inputdata.description, inputdata.histos, inputdata.functions)
	+ out += legend.draw()

	labels = Labels(inputdata.description)
	- if inputdata.description.has_key('MainPlot') and inputdata.description['MainPlot']=='0':
	- out += labels.draw(['Title','XLabel','YLabel'])
	- else:
	- out += labels.draw(['XLabel','YLabel'])
	+ lnames = ['XLabel','YLabel']
	+ if not inputdata.attr_bool('MainPlot', True):
	+ lnames.append("Title")
	+ out += labels.draw(lnames)
	return out



	-class Legend(object):
	+class Legend(Described):

	def __init__(self, description, histos, functions):
	self.histos = histos
	self.functions = functions
	self.description = description

	def draw(self):
	out = ""
	out += '\n%\n% Legend\n%\n'
	out += '\\rput[tr](%s,%s){%%\n' % (self.getLegendXPos(), self.getLegendYPos())
	ypos = -0.05*6/self.description['PlotSizeY']

	legendordermap = {}
	legendlist = self.description['DrawOnly']+self.functions.keys()
	if self.description.has_key('LegendOnly'):
	legendlist = []
	for legend in self.description['LegendOnly'].strip().split():
	if legend in self.histos.keys() or legend in self.functions.keys():
	legendlist.append(legend)
	for legend in legendlist:
	order = 0
	if self.histos.has_key(legend) and self.histos[legend].description.has_key('LegendOrder'):
	order = int(self.histos[legend].description['LegendOrder'])
	if self.functions.has_key(legend) and self.functions[legend].description.has_key('LegendOrder'):
	order = int(self.functions[legend].description['LegendOrder'])
	if not order in legendordermap:
	legendordermap[order] = []
	legendordermap[order].append(legend)
	foo=[]
	for i in sorted(legendordermap.keys()):
	foo.extend(legendordermap[i])

	rel_xpos_sign = 1.0
	if self.getLegendAlign()=='r':
	rel_xpos_sign = -1.0
	xpos1 = -0.10*rel_xpos_sign
	xpos2 = -0.02*rel_xpos_sign

	for i in foo:
	if self.histos.has_key(i):
	drawobject=self.histos[i]
	elif self.functions.has_key(i):
	drawobject=self.functions[i]
	else:
	continue
	title = drawobject.getTitle()
	if title == '':
	continue
	else:
	out += ('\\rput[B%s](%s,%s){%s}\n' %(self.getLegendAlign(),rel_xpos_sign*0.1,ypos,title))
	out += ('\\rput[B%s](%s,%s){%s\n' %(self.getLegendAlign(),rel_xpos_sign*0.1,ypos,'%'))
	if drawobject.getErrorBands():
	out += ('\\psframe[linewidth=0pt,linestyle=none,fillstyle=solid,fillcolor=%s,opacity=%s]' %(drawobject.getErrorBandColor(),drawobject.getErrorBandOpacity()))
	out += ('(%s, 0.033)(%s, 0.001)\n' %(xpos1, xpos2))
	out += ('\\psline[linestyle=' + drawobject.getLineStyle() \
	+ ', linecolor=' + drawobject.getLineColor() \
	+ ', linewidth=' + drawobject.getLineWidth() \
	+ ', strokeopacity=' + drawobject.getLineOpacity() \
	+ ', opacity=' + drawobject.getFillOpacity())
	- if drawobject.getLineDash()!='':
	+ if drawobject.getLineDash() != '':
	out += (', dash=' + drawobject.getLineDash())
	if drawobject.getFillStyle()!='none':
	out += (', fillstyle=' + drawobject.getFillStyle() \
	+ ', fillcolor=' + drawobject.getFillColor() \
	+ ', hatchcolor=' + drawobject.getHatchColor() \
	+ ']{C-C}(%s, 0.030)(%s, 0.030)(%s, 0.004)(%s, 0.004)(%s, 0.030)\n' \
	%(xpos1, xpos2, xpos2, xpos1, xpos1))
	else:
	out += ('](%s, 0.016)(%s, 0.016)\n' %(xpos1, xpos2))
	if drawobject.getPolyMarker() != '':
	out += (' \\psdot[dotstyle=' + drawobject.getPolyMarker() \
	+ ', dotsize=' + drawobject.getDotSize() \
	+ ', dotscale=' + drawobject.getDotScale() \
	+ ', linecolor=' + drawobject.getLineColor() \
	+ ', linewidth=' + drawobject.getLineWidth() \
	+ ', linestyle=' + drawobject.getLineStyle() \
	+ ', fillstyle=' + drawobject.getFillStyle() \
	+ ', fillcolor=' + drawobject.getFillColor() \
	+ ', strokeopacity=' + drawobject.getLineOpacity() \
	+ ', opacity=' + drawobject.getFillOpacity() \
	+ ', hatchcolor=' + drawobject.getHatchColor())
	if drawobject.getFillStyle()!='none':
	out += ('](%s, 0.028)\n' % (rel_xpos_sign*-0.06))
	else:
	out += ('](%s, 0.016)\n' % (rel_xpos_sign*-0.06))
	out += ('}\n')
	ypos -= 0.075*6/self.description['PlotSizeY']
	if self.description.has_key('CustomLegend'):
	for i in self.description['CustomLegend'].strip().split('\\\\'):
	out += ('\\rput[B%s](%s,%s){%s}\n' %(self.getLegendAlign(),rel_xpos_sign*0.1,ypos,i))
	ypos -= 0.075*6/self.description['PlotSizeY']
	out += ('}\n')
	return out

	def getLegendXPos(self):
	if self.description.has_key('LegendXPos'):
	return self.description['LegendXPos']
	else:
	if self.getLegendAlign()=='r':
	return '0.95'
	else:
	return '0.53'

	def getLegendYPos(self):
	if self.description.has_key('LegendYPos'):
	return self.description['LegendYPos']
	else:
	return '0.93'

	def getLegendAlign(self):
	if self.description.has_key('LegendAlign'):
	return self.description['LegendAlign']
	else:
	return 'l'


	-class Colorscale(object):
	+class ColorScale(Described):

	def __init__(self, description, coors):
	self.description = description
	self.coors = coors

	def draw(self):
	out = ''
	- out += '\n%\n% Colorscale\n%\n'
	+ out += '\n%\n% ColorScale\n%\n'
	out += '\\rput(1,0){\n'
	out += ' \\psset{xunit=4mm}\n'
	out += ' \\rput(0.5,0){\n'
	out += ' \\psset{yunit=0.0076923, linestyle=none, fillstyle=solid}\n'
	out += ' \\multido{\\ic=0+1,\\id=1+1}{130}{\n'
	out += ' \\psframe[fillcolor={gradientcolors!![\\ic]},dimen=inner,linewidth=0.1pt](0, \\ic)(1, \\id)\n'
	out += ' }\n'
	out += ' }\n'
	out += ' \\rput(0.5,0){\n'
	out += ' \\psframe[linewidth=0.3pt,dimen=middle](0,0)(1,1)\n'

	- zcustommajortickmarks = int(self.description.get('ZMajorTickMarks', -1))
	- zcustomminortickmarks = int(self.description.get('ZMinorTickMarks', -1))
	- zcustommajorticks=[]
	- zcustomminorticks=[]
	- if self.description.has_key('ZCustomMajorTicks') and self.description['ZCustomMajorTicks']!='':
	- # TODO: Would be nice to have less invisible separation of the custom ticks than split on tabs
	- ticks = self.description['ZCustomMajorTicks'].strip().split('\t')
	- if not len(ticks)%2:
	- for i in range(0,len(ticks),2):
	- zcustommajorticks.append({'Value': float(ticks[i]), 'Label': ticks[i+1]})
	- if self.description.has_key('ZCustomMinorTicks') and self.description['ZCustomMinorTicks']!='':
	- # TODO: Would be nice to have less invisible separation of the custom ticks than split on tabs
	- ticks = self.description['ZCustomMinorTicks'].strip().split('\t')
	- for i in range(len(ticks)):
	- zcustomminorticks.append({'Value': float(ticks[i])})
	- if (self.description.has_key('PlotZTickLabels') and self.description['PlotZTickLabels']=='0'):
	- drawzlabels=False
	- else:
	- drawzlabels=True
	+ zcustommajortickmarks = self.attr_int('ZMajorTickMarks', -1)
	+ zcustomminortickmarks = self.attr_int('ZMinorTickMarks', -1)
	+
	+ zcustommajorticks = zcustomminorticks = None
	+ if self.attr('ZCustomMajorTicks'):
	+ zcustommajorticks = []
	+ z_label_pairs = inputdata.attr('ZCustomMajorTicks').strip().split() #'\t')
	+ if len(z_label_pairs) % 2 == 0:
	+ for i in range(0, len(z_label_pairs), 2):
	+ zcustommajorticks.append({'Value': float(x_label_pairs[i]), 'Label': x_label_pairs[i+1]})
	+ else:
	+ print "Warning: ZCustomMajorTicks requires an even number of alternating pos/label entries"
	+
	+ if inputdata.attr('ZCustomMinorTicks'):
	+ zs = inputdata.attr('ZCustomMinorTicks').strip().split() #'\t')
	+ zcustomminorticks = [{'Value': float(x)} for x in xs]
	+
	+ drawzlabels = self.description.attr_bool('PlotZTickLabels', True)
	+
	zticks = ZTicks(self.description, self.coors)
	out += zticks.draw(custommajortickmarks=zcustommajortickmarks,\
	customminortickmarks=zcustomminortickmarks,\
	custommajorticks=zcustommajorticks,\
	customminorticks=zcustomminorticks,
	drawlabels=drawzlabels)
	out += ' }\n'
	out += '}\n'
	return out



	-class Labels(object):
	+class Labels(Described):

	def __init__(self, description):
	self.description = description

	def draw(self, axis=[]):
	out = ""
	out += ('\n%\n% Labels\n%\n')
	if self.description.has_key('Title') and (axis.count('Title') or axis==[]):
	out += ('\\rput(0,1){\\rput[lB](0, 1.7\\labelsep){\\normalsize '+self.description['Title']+'}}\n')
	if self.description.has_key('XLabel') and (axis.count('XLabel') or axis==[]):
	xlabelsep=4.7
	if self.description.has_key('XLabelSep'):
	xlabelsep=float(self.description['XLabelSep'])
	out += ('\\rput(1,0){\\rput[rB](0,-%4.3f\\labelsep){\\normalsize '%(xlabelsep) +self.description['XLabel']+'}}\n')
	if self.description.has_key('YLabel') and (axis.count('YLabel') or axis==[]):
	ylabelsep=6.5
	if self.description.has_key('YLabelSep'):
	ylabelsep=float(self.description['YLabelSep'])
	out += ('\\rput(0,1){\\rput[rB]{90}(-%4.3f\\labelsep,0){\\normalsize '%(ylabelsep) +self.description['YLabel']+'}}\n')
	if self.description.has_key('ZLabel') and (axis.count('ZLabel') or axis==[]):
	zlabelsep=5.3
	if self.description.has_key('ZLabelSep'):
	zlabelsep=float(self.description['ZLabelSep'])
	out += ('\\rput(1,1){\\rput(%4.3f\\labelsep,0){\\psset{xunit=4mm}\\rput[lB]{270}(1.5,0){\\normalsize '%(zlabelsep) +self.description['ZLabel']+'}}}\n')
	return out



	-class Special(object):
	+class Special(Described):

	def __init__(self, f):
	self.description = {}
	self.data = []
	self.read_input(f)

	def read_input(self, f):
	for line in f:
	if is_end_marker(line, 'SPECIAL'):
	break
	elif is_comment(line):
	continue
	else:
	self.data.append(line)

	- def draw(self,coors):
	+ def draw(self, coors):
	out = ""
	out += ('\n%\n% Special\n%\n')
	import re
	regex = re.compile(r'^(.?)(\\physics[xy]?coor)$\s?([0-9\.eE+-]+)\s?,\s?([0-9\.eE+-]+)\s?$(.)')
	# TODO: More precise number string matching, something like this:
	# num = r"-?[0-9](?:\.[0-9])(?:[eE][+-]?\d+]"
	# regex = re.compile(r'^(.?)(\\physics[xy]?coor)$\s?(' + num + ')\s?,\s?(' + num + ')\s?$(.)')
	- for i in xrange(len(self.data)):
	- while regex.search(self.data[i]):
	- match = regex.search(self.data[i])
	+ for l in self.data:
	+ while regex.search(l):
	+ match = regex.search(l)
	xcoor, ycoor = float(match.group(3)), float(match.group(4))
	if match.group(2)[1:] in ["physicscoor", "physicsxcoor"]:
	xcoor = coors.phys2frameX(xcoor)
	if match.group(2)[1:] in ["physicscoor", "physicsycoor"]:
	ycoor = coors.phys2frameY(ycoor)
	line = "%s(%f, %f)%s" % (match.group(1), xcoor, ycoor, match.group(5))
	- self.data[i] = line
	- out += self.data[i]+'\n'
	+ l = line
	+ out += l + "\n"
	return out



	-class DrawableObject(object):
	+class DrawableObject(Described):

	def __init__(self, f):
	pass

	def getTitle(self):
	- if self.description.has_key('Title'):
	- return self.description['Title']
	- else:
	- return ''
	+ return self.description.get("Title", "")

	def getLineStyle(self):
	if self.description.has_key('LineStyle'):
	## I normally like there to be "only one way to do it", but providing
	## this dashdotted/dotdashed synonym just seems humane ;-)
	if self.description['LineStyle'] in ('dashdotted', 'dotdashed'):
	self.description['LineStyle']='dashed'
	self.description['LineDash']='3pt 3pt .8pt 3pt'
	return self.description['LineStyle']
	else:
	return 'solid'

	def getLineDash(self):
	if self.description.has_key('LineDash'):
	# Check if LineStyle=='dashdotted' before returning something
	self.getLineStyle()
	return self.description['LineDash']
	else:
	return ''

	def getLineWidth(self):
	- if self.description.has_key('LineWidth'):
	- return self.description['LineWidth']
	- else:
	- return '0.8pt'
	+ return self.description.get("LineWidth", "0.8pt")

	def getLineColor(self):
	- if self.description.has_key('LineColor'):
	- return self.description['LineColor']
	- else:
	- return 'black'
	+ return self.description.get("LineColor", "black")

	def getLineOpacity(self):
	- if self.description.has_key('LineOpacity'):
	- return self.description['LineOpacity']
	- else:
	- return '1.0'
	+ return self.description.get("LineOpacity", "1.0")

	def getFillColor(self):
	- if self.description.has_key('FillColor'):
	- return self.description['FillColor']
	- else:
	- return 'white'
	+ return self.description.get("FillColor", "white")

	def getFillOpacity(self):
	- if self.description.has_key('FillOpacity'):
	- return self.description['FillOpacity']
	- else:
	- return '1.0'
	+ return self.description.get("FillOpacity", "1.0")

	def getHatchColor(self):
	- if self.description.has_key('HatchColor'):
	- return self.description['HatchColor']
	- else:
	- return 'black'
	+ return self.description.get("HatchColor", "black")

	def getFillStyle(self):
	- if self.description.has_key('FillStyle'):
	- return self.description['FillStyle']
	- else:
	- return 'none'
	+ return self.description.get("FillStyle", "none")

	def getPolyMarker(self):
	- if self.description.has_key('PolyMarker'):
	- return self.description['PolyMarker']
	- else:
	- return ''
	+ return self.description.get("PolyMarker", "")

	def getDotSize(self):
	- if self.description.has_key('DotSize'):
	- return self.description['DotSize']
	- else:
	- return '2pt 2'
	+ return self.description.get("DotSize", "2pt 2")

	def getDotScale(self):
	- if self.description.has_key('DotScale'):
	- return self.description['DotScale']
	- else:
	- return '1'
	+ return self.description.get("DotScale", "1")

	def getErrorBars(self):
	- if self.description.has_key('ErrorBars'):
	- return bool(int(self.description['ErrorBars']))
	- else:
	- return False
	+ return bool(int(self.description.get("ErrorBars", "0")))

	def getErrorBands(self):
	- if self.description.has_key('ErrorBands'):
	- return bool(int(self.description['ErrorBands']))
	- else:
	- return False
	+ return bool(int(self.description.get("ErrorBands", "0")))

	def getErrorBandColor(self):
	- if self.description.has_key('ErrorBandColor'):
	- return self.description['ErrorBandColor']
	- else:
	- return 'yellow'
	+ return self.description.get("ErrorBandColor", "yellow")

	def getErrorBandOpacity(self):
	- if self.description.has_key('ErrorBandOpacity'):
	- return self.description['ErrorBandOpacity']
	- else:
	- return '1.0'
	+ return self.description.get("ErrorBandOpacity", "1.0")

	def getSmoothLine(self):
	- if self.description.has_key('SmoothLine'):
	- return bool(int(self.description['SmoothLine']))
	- else:
	- return False
	+ return bool(int(self.description.get("SmoothLine", "0")))

	def startclip(self):
	return '\\psclip{\\psframe[linewidth=0, linestyle=none](0,0)(1,1)}\n'

	def stopclip(self):
	return '\\endpsclip\n'

	def startpsset(self):
	out = ""
	out += ('\\psset{linecolor='+self.getLineColor()+'}\n')
	out += ('\\psset{linewidth='+self.getLineWidth()+'}\n')
	out += ('\\psset{linestyle='+self.getLineStyle()+'}\n')
	out += ('\\psset{fillstyle='+self.getFillStyle()+'}\n')
	out += ('\\psset{fillcolor='+self.getFillColor()+'}\n')
	out += ('\\psset{hatchcolor='+self.getHatchColor()+'}\n')
	out += ('\\psset{strokeopacity='+self.getLineOpacity()+'}\n')
	out += ('\\psset{opacity='+self.getFillOpacity()+'}\n')
	if self.getLineDash()!='':
	out += ('\\psset{dash='+self.getLineDash()+'}\n')
	return out

	def stoppsset(self):
	out = ""
	out += ('\\psset{linecolor=black}\n')
	out += ('\\psset{linewidth=0.8pt}\n')
	out += ('\\psset{linestyle=solid}\n')
	out += ('\\psset{fillstyle=none}\n')
	out += ('\\psset{fillcolor=white}\n')
	out += ('\\psset{hatchcolor=black}\n')
	out += ('\\psset{strokeopacity=1.0}\n')
	out += ('\\psset{opacity=1.0}\n')
	return out



	-class Function(DrawableObject):
	+class Function(DrawableObject, Described):

	def __init__(self, f):
	self.description = {}
	self.read_input(f)

	def read_input(self, f):
	self.code='def plotfunction(x):\n'
	iscode=False
	for line in f:
	if is_end_marker(line, 'FUNCTION'):
	break
	elif is_comment(line):
	continue
	else:
	m = pat_property.match(line)
	if iscode:
	self.code+=' '+line
	elif m:
	prop, value = m.group(1,2)
	if prop=='Code':
	iscode=True
	else:
	self.description[prop] = value
	if not iscode:
	print '++++++++++ ERROR: No code in function'
	else:
	foo = compile(self.code, '<string>', 'exec')
	exec(foo)
	self.plotfunction = plotfunction


	def draw(self,coors):
	out = ""
	out += self.startclip()
	out += self.startpsset()
	xmin = coors.xmin()
	if self.description.has_key('XMin') and self.description['XMin']:
	xmin = float(self.description['XMin'])
	xmax=coors.xmax()
	if self.description.has_key('XMax') and self.description['XMax']:
	xmax=float(self.description['XMax'])
	# TODO: Space sample points logarithmically if LogX=1
	dx = (xmax-xmin)/500.
	x = xmin-dx
	out += '\\pscurve'
	if self.description.has_key('FillStyle') and self.description['FillStyle']!='none':
	out += '(%s,%s)\n' % (coors.strphys2frameX(xmin),coors.strphys2frameY(coors.ymin()))
	while x < (xmax+2*dx):
	y = self.plotfunction(x)
	out += ('(%s,%s)\n' % (coors.strphys2frameX(x), coors.strphys2frameY(y)))
	x += dx
	if self.description.has_key('FillStyle') and self.description['FillStyle']!='none':
	out += '(%s,%s)\n' % (coors.strphys2frameX(xmax),coors.strphys2frameY(coors.ymin()))
	out += self.stoppsset()
	out += self.stopclip()
	return out


	-
	-
	-class Histogram(DrawableObject):
	+class BinData(object):
	+ """\
	+ Store bin edge and value+error(s) data for a 1D or 2D bin.
	+
	+ TODO: generalise/alias the attr names to avoid mention of x and y
	+ """
	+
	+ def __init__(self, low, high, val, err):
	+ #print "@", low, high, val, err
	+ self.low = floatify(low)
	+ self.high = floatify(high)
	+ self.val = float(val)
	+ self.err = floatpair(err)
	+
	+ @property
	+ def is2D(self):
	+ return hasattr(self.low, "__len__") and hasattr(self.high, "__len__")
	+
	+ @property
	+ def isValid(self):
	+ invalid_val = (isnan(self.val) or isnan(self.err[0]) or isnan(self.err[1]))
	+ if invalid_val:
	+ return False
	+ if self.is2D:
	+ invalid_low = any(isnan(x) for x in self.low)
	+ invalid_high = any(isnan(x) for x in self.high)
	+ else:
	+ invalid_low, invalid_high = isnan(self.low), isnan(self.high)
	+ return not (invalid_low or invalid_high)
	+
	+ @property
	+ def xmin(self):
	+ return self.low
	+ @xmin.setter
	+ def xmin(self,x):
	+ self.low = x
	+
	+ @property
	+ def xmax(self):
	+ return self.high
	+ @xmax.setter
	+ def xmax(self,x):
	+ self.high = x
	+
	+ @property
	+ def xmid(self):
	+ # TODO: Generalise to 2D
	+ return (self.xmin + self.xmax) / 2.0
	+
	+ @property
	+ def xwidth(self):
	+ # TODO: Generalise to 2D
	+ assert self.xmin <= self.xmax
	+ return self.xmax - self.xmin
	+
	+ @property
	+ def y(self):
	+ return self.val
	+ @y.setter
	+ def y(self, x):
	+ self.val = x
	+
	+ @property
	+ def ey(self):
	+ return self.err
	+ @ey.setter
	+ def ey(self, x):
	+ self.err = x
	+
	+ @property
	+ def ymin(self):
	+ return self.y - self.ey[0]
	+
	+ @property
	+ def ymax(self):
	+ return self.y + self.ey[1]
	+
	+ def __getitem__(self, key):
	+ "dict-like access for backward compatibility"
	+ if key in ("LowEdge"):
	+ return self.xmin
	+ elif key == ("UpEdge", "HighEdge"):
	+ return self.xmax
	+ elif key == "Content":
	+ return self.y
	+ elif key == "Errors":
	+ return self.ey
	+
	+
	+class Histogram(DrawableObject, Described):

	def __init__(self, f, p=None):
	self.description = {}
	self.is2dim = False
	self.data = []
	self.read_input_data(f)
	self.sigmabinvalue = None
	self.meanbinvalue = None
	self.path = p

	def read_input_data(self, f):
	for line in f:
	if is_end_marker(line, 'HISTOGRAM'):
	break
	elif is_comment(line):
	continue
	else:
	line = line.rstrip()
	m = pat_property.match(line)
	if m:
	prop, value = m.group(1,2)
	self.description[prop] = value
	else:
	## Detect symm errs
	linearray = line.split()
	if len(linearray) == 4:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[3])]})
	+ self.data.append(BinData(*linearray))
	## Detect asymm errs
	elif len(linearray) == 5:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[4])]})
	+ self.data.append(BinData(linearray[0], linearray[1], linearray[2], [linearray[3],linearray[4]]))
	## Detect two-dimensionality
	elif len(linearray) in [6,7]:
	self.is2dim = True
	# If asymm z error, use the max or average of +- error
	err = float(linearray[5])
	if len(linearray) == 7:
	if self.description.get("ShowMaxZErr", 1):
	err = max(err, float(linearray[6]))
	else:
	err = 0.5 * (err + float(linearray[6]))
	- self.data.append({'LowEdge': [float(linearray[0]), float(linearray[2])],
	- 'UpEdge': [float(linearray[1]), float(linearray[3])],
	- 'Content': float(linearray[4]),
	- 'Error': err})
	+ self.data.append(BinData([linearray[0], linearray[2]], [linearray[1], linearray[3]], linearray[4], err))
	## Unknown histo format
	else:
	raise RuntimeError("Unknown HISTOGRAM data line format with %d entries" % len(linearray))


	def mangle_input(self):
	- if (self.description.has_key('NormalizeToIntegral') and self.description['NormalizeToIntegral']=='1') or \
	- (self.description.has_key('NormalizeToSum') and self.description['NormalizeToSum']=='1'):
	- if (self.description.has_key('NormalizeToIntegral') and self.description['NormalizeToIntegral']=='1') and \
	- (self.description.has_key('NormalizeToSum') and self.description['NormalizeToSum']=='1'):
	- print 'Can\'t normalize to Integral and to Sum at the same time. Will normalize to the Sum.'
	+ norm2int = self.attr_bool("NormalizeToIntegral", False)
	+ norm2sum = self.attr_bool("NormalizeToSum", False)
	+ if norm2int or norm2sum:
	+ if norm2int and norm2sum:
	+ print "Can't normalize to Integral and to Sum at the same time. Will normalize to the Sum."
	foo = 0
	+ # TODO: change to "in self.data"?
	for i in range(len(self.data)):
	- if self.description.has_key('NormalizeToSum') and self.description['NormalizeToSum']=='1':
	- foo += self.data[i]['Content']
	+ if norm2sum:
	+ foo += self.data[i].val
	else:
	- foo += self.data[i]['Content']*(self.data[i]['UpEdge']-self.data[i]['LowEdge'])
	+ foo += self.data[i].val*(self.data[i].xmax-self.data[i].xmin)
	+
	+ # TODO: change to "in self.data"?
	+ if foo != 0:
	+ for i in range(len(self.data)):
	+ self.data[i].val /= foo
	+ self.data[i].err[0] /= foo
	+ self.data[i].err[1] /= foo
	+ scale = self.attr_float('Scale', 1.0)
	+ if scale != 1.0:
	+ # TODO: change to "in self.data"?
	for i in range(len(self.data)):
	- self.data[i]['Content'] /= foo
	- self.data[i]['Error'][0] /= foo
	- self.data[i]['Error'][1] /= foo
	- if self.description.has_key('Scale') and self.description['Scale']!='':
	- scale = float(self.description['Scale'])
	- for i in range(len(self.data)):
	- self.data[i]['Content'] *= scale
	- self.data[i]['Error'][0] *= scale
	- self.data[i]['Error'][1] *= scale
	- if self.description.has_key('Rebin') and self.description['Rebin']!='':
	- rebin=int(self.description['Rebin'])
	- errortype = "stat"
	- if self.description.has_key('ErrorType') and self.description['ErrorType']!='':
	- errortype = self.description['ErrorType']
	- newdata=[]
	- if rebin>=2:
	- for i in range(0,(len(self.data)/rebin)*rebin,rebin):
	- foo=0.
	- barl=0.
	- baru=0.
	- for j in range(rebin):
	- binwidth=self.data[i+j]['UpEdge']-self.data[i+j]['LowEdge']
	- foo +=self.data[i+j]['Content']*binwidth
	- if errortype=="stat":
	- barl+=(binwidthself.data[i+j]['Error'][0])*2
	- baru+=(binwidthself.data[i+j]['Error'][1])*2
	- elif errortype=="env":
	- barl+=(self.data[i+j]['Content']-self.data[i+j]['Error'][0])*binwidth
	- baru+=(self.data[i+j]['Content']+self.data[i+j]['Error'][1])*binwidth
	- else:
	- logging.error("Rebinning for ErrorType not implemented.")
	- sys.exit(1)
	- newbinwidth=self.data[i+rebin-1]['UpEdge']-self.data[i]['LowEdge']
	- newcentral=foo/newbinwidth
	- if errortype=="stat":
	- newerror=[sqrt(barl)/newbinwidth,sqrt(baru)/newbinwidth]
	- elif errortype=="env":
	- newerror=[(foo-barl)/newbinwidth,(baru-foo)/newbinwidth]
	- newdata.append({'LowEdge': self.data[i]['LowEdge'],
	- 'UpEdge': self.data[i+rebin-1]['UpEdge'],
	- 'Content': newcentral,
	- 'Error': newerror})
	- self.data=newdata
	+ self.data[i].val *= scale
	+ self.data[i].err[0] *= scale
	+ self.data[i].err[1] *= scale
	+ if self.attr_int("Rebin", 1) > 1:
	+ rebin = self.attr_int("Rebin", 1)
	+ errortype = self.attr("ErrorType", "stat")
	+ newdata = []
	+ for i in range(0, (len(self.data)//rebin)*rebin, rebin):
	+ foo = 0.
	+ barl = 0.
	+ baru = 0.
	+ for j in range(rebin):
	+ binwidth = self.data[i+j].xwidth
	+ foo += self.data[i+j].val * binwidth
	+ if errortype == "stat":
	+ barl += (binwidth * self.data[i+j].err[0])**2
	+ baru += (binwidth * self.data[i+j].err[1])**2
	+ elif errortype == "env":
	+ barl += self.data[i+j].ymin * binwidth
	+ baru += self.data[i+j].ymax * binwidth
	+ else:
	+ logging.error("Rebinning for ErrorType not implemented.")
	+ sys.exit(1)
	+ newbinwidth = self.data[i+rebin-1].xmax - self.data[i].xmin
	+ newcentral = foo/newbinwidth
	+ if errortype == "stat":
	+ newerror = [sqrt(barl)/newbinwidth, sqrt(baru)/newbinwidth]
	+ elif errortype == "env":
	+ newerror = [(foo-barl)/newbinwidth, (baru-foo)/newbinwidth]
	+ newdata.append(BinData(self.data[i].xmin, self.data[i+rebin-1].xmax, newcentral, newerror))
	+ self.data = newdata

	def add(self, name):
	if len(self.data) != len(name.data):
	print '+++ Error in Histogram.add() for %s: different numbers of bins' % self.path
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	- self.data[i]['Content'] += name.data[i]['Content']
	- self.data[i]['Error'][0] = sqrt(self.data[i]['Error'][0]2 + name.data[i]['Error'][0]2)
	- self.data[i]['Error'][1] = sqrt(self.data[i]['Error'][1]2 + name.data[i]['Error'][1]2)
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	+ self.data[i].val += name.data[i].val
	+ self.data[i].err[0] = sqrt(self.data[i].err[0]2 + name.data[i].err[0]2)
	+ self.data[i].err[1] = sqrt(self.data[i].err[1]2 + name.data[i].err[1]2)
	else:
	print '+++ Error in Histogram.add() for %s: binning of histograms differs' % self.path

	def divide(self, name):
	#print name.path, self.path
	if len(self.data) != len(name.data):
	print '+++ Error in Histogram.divide() for %s: different numbers of bins' % self.path
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	try:
	- self.data[i]['Error'][0] /= name.data[i]['Content']
	+ self.data[i].err[0] /= name.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Error'][0]=0.
	+ self.data[i].err[0]=0.
	try:
	- self.data[i]['Error'][1] /= name.data[i]['Content']
	+ self.data[i].err[1] /= name.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Error'][1]=0.
	+ self.data[i].err[1]=0.
	try:
	- self.data[i]['Content'] /= name.data[i]['Content']
	+ self.data[i].val /= name.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Content']=1.
	-# self.data[i]['Error'][0] = sqrt(self.data[i]['Error'][0]2 + name.data[i]['Error'][0]2)
	-# self.data[i]['Error'][1] = sqrt(self.data[i]['Error'][1]2 + name.data[i]['Error'][1]2)
	+ self.data[i].val=1.
	+# self.data[i].err[0] = sqrt(self.data[i].err[0]2 + name.data[i].err[0]2)
	+# self.data[i].err[1] = sqrt(self.data[i].err[1]2 + name.data[i].err[1]2)
	else:
	print '+++ Error in Histogram.divide() for %s: binning of histograms differs' % self.path

	def dividereverse(self, name):
	if len(self.data) != len(name.data):
	print '+++ Error in Histogram.dividereverse() for %s: different numbers of bins' % self.path
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	try:
	- self.data[i]['Error'][0] = name.data[i]['Error'][0]/self.data[i]['Content']
	+ self.data[i].err[0] = name.data[i].err[0]/self.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Error'][0]=0.
	+ self.data[i].err[0]=0.
	try:
	- self.data[i]['Error'][1] = name.data[i]['Error'][1]/self.data[i]['Content']
	+ self.data[i].err[1] = name.data[i].err[1]/self.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Error'][1]=0.
	+ self.data[i].err[1]=0.
	try:
	- self.data[i]['Content'] = name.data[i]['Content']/self.data[i]['Content']
	+ self.data[i].val = name.data[i].val/self.data[i].val
	except ZeroDivisionError:
	- self.data[i]['Content']=1.
	+ self.data[i].val=1.
	else:
	print '+++ Error in Histogram.dividereverse(): binning of histograms differs'

	def deviation(self, name):
	if len(self.data) != len(name.data):
	print '+++ Error in Histogram.deviation() for %s: different numbers of bins' % self.path
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	- self.data[i]['Content'] -= name.data[i]['Content']
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	+ self.data[i].val -= name.data[i].val
	try:
	- self.data[i]['Content'] /= 0.5sqrt((name.data[i]['Error'][0] + name.data[i]['Error'][1])*2 + \
	- (self.data[i]['Error'][0] + self.data[i]['Error'][1])**2)
	+ self.data[i].val /= 0.5sqrt((name.data[i].err[0] + name.data[i].err[1])*2 + \
	+ (self.data[i].err[0] + self.data[i].err[1])**2)
	except ZeroDivisionError:
	- self.data[i]['Content'] = 0.0
	+ self.data[i].val = 0.0
	try:
	- self.data[i]['Error'][0] /= name.data[i]['Error'][0]
	+ self.data[i].err[0] /= name.data[i].err[0]
	except ZeroDivisionError:
	- self.data[i]['Error'][0] = 0.0
	+ self.data[i].err[0] = 0.0
	try:
	- self.data[i]['Error'][1] /= name.data[i]['Error'][1]
	+ self.data[i].err[1] /= name.data[i].err[1]
	except ZeroDivisionError:
	- self.data[i]['Error'][1] = 0.0
	+ self.data[i].err[1] = 0.0
	else:
	print '+++ Error in Histogram.deviation() for %s: binning of histograms differs' % self.path

	def getChi2(self, name):
	chi2 = 0.
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	try:
	- chi2 += (self.data[i]['Content']-name.data[i]['Content'])*2/((0.5self.data[i]['Error'][0]+0.5self.data[i]['Error'][1])2 + (0.5name.data[i]['Error'][0]+0.5name.data[i]['Error'][1])*2)
	+ chi2 += (self.data[i].val-name.data[i].val)*2/((0.5self.data[i].err[0]+0.5self.data[i].err[1])2 + (0.5name.data[i].err[0]+0.5name.data[i].err[1])*2)
	except ZeroDivisionError:
	pass
	else:
	print '+++ Error in Histogram.getChi2() for %s: binning of histograms differs' % self.path
	return chi2/len(self.data)

	def getSigmaBinValue(self):
	if self.sigmabinvalue==None:
	self.sigmabinvalue = 0.
	sumofweights = 0.
	for i in range(len(self.data)):
	if self.is2dim:
	- binwidth = abs( (self.data[i]['UpEdge'][0] - self.data[i]['LowEdge'][0])
	- *(self.data[i]['UpEdge'][1] - self.data[i]['LowEdge'][1]))
	+ binwidth = abs( (self.data[i].xmax[0] - self.data[i].xmin[0])
	+ *(self.data[i].xmax[1] - self.data[i].xmin[1]))
	else:
	- binwidth = abs(self.data[i]['UpEdge'] - self.data[i]['LowEdge'])
	- self.sigmabinvalue += binwidth(self.data[i]['Content']-self.getMeanBinValue())*2
	+ binwidth = abs(self.data[i].xmax - self.data[i].xmin)
	+ self.sigmabinvalue += binwidth(self.data[i].val-self.getMeanBinValue())*2
	sumofweights += binwidth
	self.sigmabinvalue = sqrt(self.sigmabinvalue/sumofweights)
	return self.sigmabinvalue

	def getMeanBinValue(self):
	if self.meanbinvalue==None:
	self.meanbinvalue = 0.
	sumofweights = 0.
	for i in range(len(self.data)):
	if self.is2dim:
	- binwidth = abs( (self.data[i]['UpEdge'][0] - self.data[i]['LowEdge'][0])
	- *(self.data[i]['UpEdge'][1] - self.data[i]['LowEdge'][1]))
	+ binwidth = abs( (self.data[i].xmax[0] - self.data[i].xmin[0])
	+ *(self.data[i].xmax[1] - self.data[i].xmin[1]))
	else:
	- binwidth = abs(self.data[i]['UpEdge'] - self.data[i]['LowEdge'])
	- self.meanbinvalue += binwidth*self.data[i]['Content']
	+ binwidth = abs(self.data[i].xmax - self.data[i].xmin)
	+ self.meanbinvalue += binwidth*self.data[i].val
	sumofweights += binwidth
	self.meanbinvalue /= sumofweights
	return self.meanbinvalue

	def getCorrelation(self, name):
	correlation = 0.
	sumofweights = 0.
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	if self.is2dim:
	- binwidth = abs( (self.data[i]['UpEdge'][0] - self.data[i]['LowEdge'][0])
	- * (self.data[i]['UpEdge'][1] - self.data[i]['LowEdge'][1]) )
	+ binwidth = abs( (self.data[i].xmax[0] - self.data[i].xmin[0])
	+ * (self.data[i].xmax[1] - self.data[i].xmin[1]) )
	else:
	- binwidth = abs(self.data[i]['UpEdge'] - self.data[i]['LowEdge'])
	- correlation += binwidth * ( self.data[i]['Content'] - self.getMeanBinValue() ) \
	- * ( name.data[i]['Content'] - name.getMeanBinValue() )
	+ binwidth = abs(self.data[i].xmax - self.data[i].xmin)
	+ correlation += binwidth * ( self.data[i].val - self.getMeanBinValue() ) \
	+ * ( name.data[i].val - name.getMeanBinValue() )
	sumofweights += binwidth
	else:
	print '+++ Error in Histogram.getCorrelation(): binning of histograms differs' % self.path
	correlation /= sumofweights
	try:
	correlation /= self.getSigmaBinValue()*name.getSigmaBinValue()
	except ZeroDivisionError:
	correlation = 0
	return correlation

	def getRMSdistance(self,name):
	distance = 0.
	sumofweights = 0.
	for i in range(len(self.data)):
	- if fuzzyeq(self.data[i]['LowEdge'], name.data[i]['LowEdge']) and \
	- fuzzyeq(self.data[i]['UpEdge'], name.data[i]['UpEdge']):
	+ if fuzzyeq(self.data[i].xmin, name.data[i].xmin) and \
	+ fuzzyeq(self.data[i].xmax, name.data[i].xmax):
	if self.is2dim:
	- binwidth = abs( (self.data[i]['UpEdge'][0] - self.data[i]['LowEdge'][0])
	- * (self.data[i]['UpEdge'][1] - self.data[i]['LowEdge'][1]) )
	+ binwidth = abs( (self.data[i].xmax[0] - self.data[i].xmin[0])
	+ * (self.data[i].xmax[1] - self.data[i].xmin[1]) )
	else:
	- binwidth = abs(self.data[i]['UpEdge'] - self.data[i]['LowEdge'])
	- distance += binwidth * ( (self.data[i]['Content'] - self.getMeanBinValue())
	- -(name.data[i]['Content'] - name.getMeanBinValue()))**2
	+ binwidth = abs(self.data[i].xmax - self.data[i].xmin)
	+ distance += binwidth * ( (self.data[i].val - self.getMeanBinValue())
	+ -(name.data[i].val - name.getMeanBinValue()))**2
	sumofweights += binwidth
	else:
	print '+++ Error in Histogram.getRMSdistance() for %s: binning of histograms differs' % self.path
	distance = sqrt(distance/sumofweights)
	return distance

	def draw(self,coors):
	seen_nan = False
	out = ""
	out += self.startclip()
	out += self.startpsset()
	- if self.data:
	+ if any(b.isValid for b in self.data):
	out += "% START DATA\n"
	if self.is2dim:
	- for i in xrange(len(self.data)):
	+ for b in self.data:
	out += ('\\psframe')
	- color=int(129*coors.phys2frameZ(self.data[i]['Content']))
	- if self.data[i]['Content']>coors.zmax():
	- color=129
	- if self.data[i]['Content']<coors.zmin():
	- color=0
	- if self.data[i]['Content']<=coors.zmin():
	+ color = int(129*coors.phys2frameZ(b.val))
	+ if b.val > coors.zmax():
	+ color = 129
	+ if b.val < coors.zmin():
	+ color = 0
	+ if b.val <= coors.zmin():
	out += ('[linewidth=0pt, linestyle=none, fillstyle=solid, fillcolor=white]')
	else:
	out += ('[linewidth=0pt, linestyle=none, fillstyle=solid, fillcolor={gradientcolors!!['+str(color)+']}]')
	- out += ('(' + coors.strphys2frameX(self.data[i]['LowEdge'][0]) + ', ' \
	- + coors.strphys2frameY(self.data[i]['LowEdge'][1]) + ')(' \
	- + coors.strphys2frameX(self.data[i]['UpEdge'][0]) + ', ' \
	- + coors.strphys2frameY(self.data[i]['UpEdge'][1]) + ')\n')
	+ out += ('(' + coors.strphys2frameX(b.low[0]) + ', ' \
	+ + coors.strphys2frameY(b.low[1]) + ')(' \
	+ + coors.strphys2frameX(b.high[0]) + ', ' \
	+ + coors.strphys2frameY(b.high[1]) + ')\n')
	else:
	if self.getErrorBands():
	- self.description['SmoothLine']=0
	- for i in xrange(len(self.data)):
	- out += ('\\psframe[dimen=inner,linewidth=0pt,linestyle=none,fillstyle=solid,fillcolor=%s,opacity=%s]' %(self.getErrorBandColor(),self.getErrorBandOpacity()))
	- out += ('(' + coors.strphys2frameX(self.data[i]['LowEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']-self.data[i]['Error'][0]) + ')(' \
	- + coors.strphys2frameX(self.data[i]['UpEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']+self.data[i]['Error'][1]) + ')\n')
	+ self.description['SmoothLine'] = 0
	+ for b in self.data:
	+ out += ('\\psframe[dimen=inner,linewidth=0pt,linestyle=none,fillstyle=solid,fillcolor=%s,opacity=%s]' % (self.getErrorBandColor(),self.getErrorBandOpacity()))
	+ out += ('(' + coors.strphys2frameX(b.xmin) + ', ' \
	+ + coors.strphys2frameY(b.val - b.err[0]) + ')(' \
	+ + coors.strphys2frameX(b.xmax) + ', ' \
	+ + coors.strphys2frameY(b.val + b.err[1]) + ')\n')
	if self.getErrorBars():
	- for i in xrange(len(self.data)):
	- if isnan(self.data[i]['Content']) or isnan(self.data[i]['Error'][0]) or isnan(self.data[i]['Error'][1]):
	+ for b in self.data:
	+ if isnan(b.val) or isnan(b.err[0]) or isnan(b.err[1]):
	seen_nan = True
	continue
	- if self.data[i]['Content']==0. and self.data[i]['Error']==[0.,0.]:
	+ if b.val == 0. and b.err == [0.,0.]:
	continue
	out += ('\\psline')
	- out += ('(' + coors.strphys2frameX(self.data[i]['LowEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')(' \
	- + coors.strphys2frameX(self.data[i]['UpEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')\n')
	+ out += ('(' + coors.strphys2frameX(b.xmin) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')(' \
	+ + coors.strphys2frameX(b.xmax) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')\n')
	out += ('\\psline')
	- bincenter = coors.strphys2frameX(.5*(self.data[i]['LowEdge']+self.data[i]['UpEdge']))
	+ bincenter = coors.strphys2frameX(.5*(b.xmin+b.xmax))
	out += ('(' + bincenter + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']-self.data[i]['Error'][0]) + ')(' \
	+ + coors.strphys2frameY(b.val-b.err[0]) + ')(' \
	+ bincenter + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']+self.data[i]['Error'][1]) + ')\n')
	+ + coors.strphys2frameY(b.val+b.err[1]) + ')\n')
	if self.getSmoothLine():
	out += '\\psbezier'
	else:
	out += '\\psline'
	- if (self.getFillStyle() != 'none'): # make sure that filled areas go all the way down to the x-axis
	- if (coors.phys2frameX(self.data[0]['LowEdge']) > 1e-4):
	- out += '(' + coors.strphys2frameX(self.data[0]['LowEdge']) + ', -0.1)\n'
	+ if self.getFillStyle() != 'none': # make sure that filled areas go all the way down to the x-axis
	+ if coors.phys2frameX(self.data[0].xmin) > 1e-4:
	+ out += '(' + coors.strphys2frameX(self.data[0].xmin) + ', -0.1)\n'
	else:
	out += '(-0.1, -0.1)\n'
	- for i in xrange(len(self.data)):
	- if isnan(self.data[i]['Content']):
	+ for i, b in enumerate(self.data):
	+ if isnan(b.val):
	seen_nan = True
	continue
	if self.getSmoothLine():
	- out += ('(' + coors.strphys2frameX(0.5*(self.data[i]['LowEdge']+self.data[i]['UpEdge'])) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')\n')
	+ out += ('(' + coors.strphys2frameX(0.5*(b.xmin+b.xmax)) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')\n')
	else:
	- out += ('(' + coors.strphys2frameX(self.data[i]['LowEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')(' \
	- + coors.strphys2frameX(self.data[i]['UpEdge']) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')\n')
	+ out += ('(' + coors.strphys2frameX(b.xmin) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')(' \
	+ + coors.strphys2frameX(b.xmax) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')\n')
	## Join/separate data points, with vertical/diagonal lines
	- if (i+1 < len(self.data)): #< If this is not the last point
	+ if i+1 < len(self.data): #< If this is not the last point
	if self.description.get('ConnectBins', '1') != '1':
	out += ('\\psline')
	else:
	## If bins are joined, but there is a gap in binning, choose whether to fill the gap
	- if (abs(coors.phys2frameX(self.data[i]['UpEdge']) - coors.phys2frameX(self.data[i+1]['LowEdge'])) > 1e-4):
	+ if (abs(coors.phys2frameX(b.xmax) - coors.phys2frameX(self.data[i+1].xmin)) > 1e-4):
	if self.description.get('ConnectGaps', '0') != '1':
	out += ('\\psline')
	# TODO: Perhaps use a new dashed line to fill the gap?
	if self.getFillStyle() != 'none': # make sure that filled areas go all the way down to the x-axis
	- if (coors.phys2frameX(self.data[-1]['UpEdge']) < 1-1e-4):
	- out += '(' + coors.strphys2frameX(self.data[-1]['UpEdge']) + ', -0.1)\n'
	+ if (coors.phys2frameX(self.data[-1].xmax) < 1-1e-4):
	+ out += '(' + coors.strphys2frameX(self.data[-1].xmax) + ', -0.1)\n'
	else:
	out += '(1.1, -0.1)\n'
	#
	if self.getPolyMarker() != '':
	- for i in xrange(len(self.data)):
	- if isnan(self.data[i]['Content']):
	+ for b in self.data:
	+ if isnan(b.val):
	seen_nan = True
	continue
	- if self.data[i]['Content']==0. and self.data[i]['Error']==[0.,0.]:
	+ if b.val == 0. and b.err == [0.,0.]:
	continue
	- out += ('\\psdot[dotstyle=%s,dotsize=%s,dotscale=%s](' %(self.getPolyMarker(),self.getDotSize(),self.getDotScale()) \
	- + coors.strphys2frameX(.5*(self.data[i]['LowEdge']+self.data[i]['UpEdge'])) + ', ' \
	- + coors.strphys2frameY(self.data[i]['Content']) + ')\n')
	+ out += ('\\psdot[dotstyle=%s,dotsize=%s,dotscale=%s](' % (self.getPolyMarker(),self.getDotSize(),self.getDotScale()) \
	+ + coors.strphys2frameX(.5*(b.xmin+b.xmax)) + ', ' \
	+ + coors.strphys2frameY(b.val) + ')\n')

	out += "% END DATA\n"
	+ else:
	+ print "WARNING: No valid bin value/errors/edges to plot!"
	+ out += "% NO DATA!\n"

	out += self.stoppsset()
	out += self.stopclip()
	if seen_nan:
	print "WARNING: NaN-valued value or error bar!"
	return out

	# def is2dimensional(self):
	# return self.is2dim

	def getXMin(self):
	if not self.data:
	return 0
	elif self.is2dim:
	- return min([self.data[i]['LowEdge'][0] for i in range(len(self.data))])
	+ return min(b.low[0] for b in self.data)
	else:
	- return min([self.data[i]['LowEdge'] for i in range(len(self.data))])
	+ return min(b.xmin for b in self.data)

	def getXMax(self):
	if not self.data:
	return 1
	elif self.is2dim:
	- return max([self.data[i]['UpEdge'][0] for i in range(len(self.data))])
	+ return max(b.high[0] for b in self.data)
	else:
	- return max([self.data[i]['UpEdge'] for i in range(len(self.data))])
	+ return max(b.xmax for b in self.data)

	def getYMin(self, xmin, xmax, logy):
	if not self.data:
	return 0
	elif self.is2dim:
	- return min([self.data[i]['LowEdge'][1] for i in range(len(self.data))])
	+ return min(b.low[1] for b in self.data)
	else:
	yvalues = []
	- for i in range(len(self.data)):
	- if ((self.data[i]['UpEdge'] > xmin or self.data[i]['LowEdge'] >= xmin) and \
	- (self.data[i]['LowEdge'] < xmax or self.data[i]['UpEdge'] <= xmax)):
	- foo = 0
	+ for b in self.data:
	+ if (b.xmax > xmin or b.xmin >= xmin) and (b.xmin < xmax or b.xmax <= xmax):
	+ foo = b.val
	if self.getErrorBars() or self.getErrorBands():
	- foo = self.data[i]['Content']-self.data[i]['Error'][0]
	- else:
	- foo = self.data[i]['Content']
	- if logy:
	- if foo>0: yvalues.append(foo)
	- else:
	+ foo -= b.err[0]
	+ if not isnan(foo) and (not logy or foo > 0):
	yvalues.append(foo)
	- if len(yvalues) > 0:
	- return min(yvalues)
	- else:
	- return self.data[0]['Content']
	+ return min(yvalues) if yvalues else self.data[0].val

	def getYMax(self, xmin, xmax):
	if not self.data:
	return 1
	elif self.is2dim:
	- return max([self.data[i]['UpEdge'][1] for i in range(len(self.data))])
	+ return max(b.high[1] for b in self.data)
	else:
	yvalues = []
	- for i in range(len(self.data)):
	- if ((self.data[i]['UpEdge'] > xmin or self.data[i]['LowEdge'] >= xmin) and \
	- (self.data[i]['LowEdge'] < xmax or self.data[i]['UpEdge'] <= xmax)):
	+ for b in self.data:
	+ if (b.xmax > xmin or b.xmin >= xmin) and (b.xmin < xmax or b.xmax <= xmax):
	+ foo = b.val
	if self.getErrorBars() or self.getErrorBands():
	- yvalues.append(self.data[i]['Content']+self.data[i]['Error'][1])
	- else:
	- yvalues.append(self.data[i]['Content'])
	- if len(yvalues) > 0:
	- return max(yvalues)
	- else:
	- return self.data[0]['Content']
	+ foo += b.err[1]
	+ if not isnan(foo): # and (not logy or foo > 0):
	+ yvalues.append(foo)
	+ return max(yvalues) if yvalues else self.data[0].val

	def getZMin(self, xmin, xmax, ymin, ymax):
	if not self.is2dim:
	return 0
	zvalues = []
	- for i in range(len(self.data)):
	- if (self.data[i]['UpEdge'][0] > xmin and self.data[i]['LowEdge'][0] < xmax) and \
	- (self.data[i]['UpEdge'][1] > ymin and self.data[i]['LowEdge'][1] < ymax):
	- zvalues.append(self.data[i]['Content'])
	+ for b in self.data:
	+ if (b.xmax[0] > xmin and b.xmin[0] < xmax) and (b.xmax[1] > ymin and b.xmin[1] < ymax):
	+ zvalues.append(b.val)
	return min(zvalues)

	def getZMax(self, xmin, xmax, ymin, ymax):
	if not self.is2dim:
	return 0
	zvalues = []
	- for i in range(len(self.data)):
	- if (self.data[i]['UpEdge'][0] > xmin and self.data[i]['LowEdge'][0] < xmax) and \
	- (self.data[i]['UpEdge'][1] > ymin and self.data[i]['LowEdge'][1] < ymax):
	- zvalues.append(self.data[i]['Content'])
	+ for b in self.data:
	+ if (b.xmax[0] > xmin and b.xmin[0] < xmax) and (b.xmax[1] > ymin and b.xmin[1] < ymax):
	+ zvalues.append(b.val)
	return max(zvalues)



	class Histo1D(Histogram):

	def read_input_data(self, f):
	for line in f:
	if is_end_marker(line, 'HISTO1D'):
	break
	elif is_comment(line):
	continue
	else:
	line = line.rstrip()
	m = pat_property.match(line)
	if m:
	prop, value = m.group(1,2)
	self.description[prop] = value
	else:
	linearray = line.split()
	## Detect symm errs
	- if len(linearray) == 4:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[3])]})
	+ # TODO: Not sure what the 8-param version is for... auto-compatibility with YODA format?
	+ if len(linearray) in [4,8]:
	+ self.data.append(BinData(linearray[0], linearray[1], linearray[2], linearray[3]))
	## Detect asymm errs
	elif len(linearray) == 5:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[4])]})
	- ## Not sure what this is for... auto-compatibility with YODA format? Urgh
	- elif len(linearray) == 8:
	- self.data.append({'LowEdge': float(linearray[0]),
	- 'UpEdge': float(linearray[1]),
	- 'Content': float(linearray[2]),
	- 'Error': [float(linearray[3]),float(linearray[3])]})
	+ self.data.append(BinData(linearray[0], linearray[1], linearray[2], [linearray[3],linearray[4]]))
	else:
	- raise Exception('Histo1D does not have 8 columns.'+line)
	+ raise Exception('Histo1D does not have the expected number of columns. ' + line)
	+
	+ # TODO: specialise draw() here


	class Histo2D(Histogram):

	def read_input_data(self, f):
	self.is2dim = True #< Should really be done in a constructor, but this is easier for now...

	for line in f:
	if is_end_marker(line, 'HISTO2D'):
	break
	elif is_comment(line):
	continue
	else:
	line = line.rstrip()
	m = pat_property.match(line)
	if m:
	prop, value = m.group(1,2)
	self.description[prop] = value
	else:
	linearray = line.split()
	if len(linearray) in [6,7]:
	# If asymm z error, use the max or average of +- error
	err = float(linearray[5])
	if len(linearray) == 7:
	if self.description.get("ShowMaxZErr", 1):
	err = max(err, float(linearray[6]))
	else:
	err = 0.5 * (err + float(linearray[6]))
	- self.data.append({'LowEdge': [float(linearray[0]), float(linearray[2])],
	- 'UpEdge': [float(linearray[1]), float(linearray[3])],
	- 'Content': float(linearray[4]),
	- 'Error': err})
	+ self.data.append(BinData([linearray[0], linearray[2]], [linearray[1], linearray[3]], float(linearray[4]), err))
	else:
	- raise Exception('Histo1D does not have 6 or 7 columns.'+line)
	-
	+ raise Exception('Histo2D does not have the expected number of columns. '+line)
	+
	+ # TODO: specialise draw() here
	+
	+
	+
	+#############################



	class Frame(object):

	def __init__(self):
	self.framelinewidth = '0.3pt'

	def draw(self,inputdata):
	out = ('\n%\n% Frame\n%\n')
	if inputdata.description.has_key('FrameColor') and inputdata.description['FrameColor']!=None:
	color = inputdata.description['FrameColor']
	# We want to draw this frame only once, so set it to False for next time:
	inputdata.description['FrameColor']=None

	# Calculate how high and wide the overall plot is
	height = [0,0]
	- width = inputdata.description['PlotSizeX']
	- if inputdata.description.has_key('RatioPlot') and inputdata.description['RatioPlot']=='1':
	+ width = inputdata.attr('PlotSizeX')
	+ if inputdata.attr_bool('RatioPlot', False):
	height[1] = -inputdata.description['RatioPlotSizeY']
	- if not (inputdata.description.has_key('MainPlot') and inputdata.description['MainPlot']=='0'):
	+ if not inputdata.attr_bool('MainPlot', True):
	height[0] = inputdata.description['PlotSizeY']
	else:
	height[0] = -height[1]
	height[1] = 0

	# Get the margin widths
	left = inputdata.description['LeftMargin']+0.1
	right = inputdata.description['RightMargin']+0.1
	top = inputdata.description['TopMargin']+0.1
	bottom = inputdata.description['BottomMargin']+0.1

	#
	out += ('\\rput(0,1){\\psline[linewidth=%scm,linecolor=%s](%scm,%scm)(%scm,%scm)}\n' %(top, color, -left, top/2, width+right, top/2))
	out += ('\\rput(0,%scm){\\psline[linewidth=%scm,linecolor=%s](%scm,%scm)(%scm,%scm)}\n' %(height[1], bottom, color, -left, -bottom/2, width+right, -bottom/2))
	out += ('\\rput(0,0){\\psline[linewidth=%scm,linecolor=%s](%scm,%scm)(%scm,%scm)}\n' %(left, color, -left/2, height[1]-0.05, -left/2, height[0]+0.05))
	out += ('\\rput(1,0){\\psline[linewidth=%scm,linecolor=%s](%scm,%scm)(%scm,%scm)}\n' %(right, color, right/2, height[1]-0.05, right/2, height[0]+0.05))


	out += ('\\psframe[linewidth='+self.framelinewidth+',dimen=middle](0,0)(1,1)\n')
	return out



	class Ticks(object):

	def __init__(self, description, coors):
	self.majorticklinewidth = '0.3pt'
	self.minorticklinewidth = '0.3pt'
	self.majorticklength = '9pt'
	self.minorticklength = '4pt'
	self.description = description
	self.coors = coors

	- def draw_ticks(self, min, max, plotlog=False, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True, twosided=False):
	+ def draw_ticks(self, vmin, vmax, plotlog=False, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True, twosided=False):
	out = ""
	if plotlog:
	- if min <= 0 or max <= 0:
	+ if vmin <= 0 or vmax <= 0:
	raise Exception("Cannot place log axis min or max tick <= 0")
	if custommajorticks is None:
	- x=int(log10(min))
	- n_labels=0
	- while (x<log10(max)+1):
	- if 10**x>=min:
	- ticklabel=10**x
	- if ticklabel>min and ticklabel<max:
	+ x = int(log10(vmin))
	+ n_labels = 0
	+ while x < log10(vmax) + 1:
	+ if 10**x >= vmin:
	+ ticklabel = 10**x
	+ if ticklabel > vmin and ticklabel < vmax:
	out += self.draw_majortick(ticklabel,twosided)
	if drawlabels:
	out += self.draw_majorticklabel(ticklabel)
	- n_labels+=1
	- if ticklabel==min or ticklabel==max:
	+ n_labels += 1
	+ if ticklabel == vmin or ticklabel == vmax:
	if drawlabels:
	out += self.draw_majorticklabel(ticklabel)
	n_labels+=1
	for i in range(2,10):
	- ticklabel=i10*(x-1)
	- if ticklabel>min and ticklabel<max:
	+ ticklabel = i10*(x-1)
	+ if ticklabel > vmin and ticklabel < vmax:
	out += self.draw_minortick(ticklabel,twosided)
	- if drawlabels and n_labels==0:
	- if (i+1)10*(x-1)<max: # some special care for the last minor tick
	+ if drawlabels and n_labels == 0:
	+ if (i+1)10*(x-1) < vmax: # some special care for the last minor tick
	out += self.draw_minorticklabel(ticklabel)
	else:
	out += self.draw_minorticklabel(ticklabel, last=True)
	- x+=1
	+ x += 1
	else:
	print "Warning: custom major ticks not currently supported on log axes -- please contact the developers to request!"
	elif custommajorticks is not None or customminorticks is not None:
	if custommajorticks:
	for i in range(len(custommajorticks)):
	- value=custommajorticks[i]['Value']
	- label=custommajorticks[i]['Label']
	- if value>=min and value<=max:
	+ value = custommajorticks[i]['Value']
	+ label = custommajorticks[i]['Label']
	+ if value >= vmin and value <= vmax:
	out += self.draw_majortick(value,twosided)
	if drawlabels:
	out += self.draw_majorticklabel(value, label=label)
	if customminorticks:
	for i in range(len(customminorticks)):
	- value=customminorticks[i]['Value']
	- if value>=min and value<=max:
	+ value = customminorticks[i]['Value']
	+ if value >= vmin and value <= vmax:
	out += self.draw_minortick(value,twosided)
	else:
	- xrange = max-min
	- digits = int(log10(xrange))+1
	- if (xrange < 1):
	+ vrange = vmax - vmin
	+ if isnan(vrange):
	+ vrange, vmin, vmax = 1, 1, 2
	+ digits = int(log10(vrange))+1
	+ if vrange <= 1:
	digits -= 1
	- foo = int(xrange/(10**(digits-1)))
	- if (foo/9. > 0.5):
	+ foo = int(vrange/(10**(digits-1)))
	+ if foo/9. > 0.5:
	tickmarks = 10
	- elif (foo/9. > 0.2):
	+ elif foo/9. > 0.2:
	tickmarks = 5
	- elif (foo/9. > 0.1):
	+ elif foo/9. > 0.1:
	tickmarks = 2

	- if (custommajortickmarks>-1):
	+ if custommajortickmarks > -1:
	if custommajortickmarks not in [1, 2, 5, 10, 20]:
	print '+++ Error in Ticks.draw_ticks(): MajorTickMarks must be in [1, 2, 5, 10, 20]'
	else:
	- #if custommajortickmarks==1: custommajortickmarks=10
	tickmarks = custommajortickmarks

	- if (tickmarks == 2 or tickmarks == 20):
	+ if tickmarks == 2 or tickmarks == 20:
	minortickmarks = 3
	else:
	minortickmarks = 4
	- if (customminortickmarks>-1):
	+ if customminortickmarks > -1:
	minortickmarks = customminortickmarks
	#
	x = 0
	- while (x > min10*digits):
	+ while x > vmin10*digits:
	x -= tickmarks100*(digits-1)
	- while (x <= max10*digits):
	- if (x >= min10digits-tickmarks100**(digits-1)):
	+ while x <= vmax10*digits:
	+ if x >= vmin10digits - tickmarks100**(digits-1):
	ticklabel = 1.x/10*digits
	- if (int(ticklabel) == ticklabel):
	+ if int(ticklabel) == ticklabel:
	ticklabel = int(ticklabel)
	- if (float(ticklabel-min)/xrange >= -1e-5):
	- if (fabs(ticklabel-min)/xrange > 1e-5 and fabs(ticklabel-max)/xrange > 1e-5):
	+ if float(ticklabel-vmin)/vrange >= -1e-5:
	+ if abs(ticklabel-vmin)/vrange > 1e-5 and abs(ticklabel-vmax)/vrange > 1e-5:
	out += self.draw_majortick(ticklabel,twosided)
	if drawlabels:
	out += self.draw_majorticklabel(ticklabel)

	xminor = x
	for i in range(minortickmarks):
	xminor += 1.tickmarks100**(digits-1)/(minortickmarks+1)
	ticklabel = 1.xminor/10*digits
	- if (ticklabel > min and ticklabel < max):
	- if (fabs(ticklabel-min)/xrange > 1e-5 and fabs(ticklabel-max)/xrange > 1e-5):
	+ if ticklabel > vmin and ticklabel < vmax:
	+ if abs(ticklabel-vmin)/vrange > 1e-5 and abs(ticklabel-vmax)/vrange > 1e-5:
	out += self.draw_minortick(ticklabel,twosided)
	x += tickmarks100*(digits-1)
	return out

	def draw(self):
	pass

	def draw_minortick(self, ticklabel, twosided):
	pass

	def draw_majortick(self, ticklabel, twosided):
	pass

	def draw_majorticklabel(self, ticklabel):
	pass

	def draw_minorticklabel(self, value, label='', last=False):
	return ''

	def get_ticklabel(self, value, plotlog=False, minor=False, lastminor=False):
	label=''
	prefix = ''
	if plotlog:
	bar = int(log10(value))
	if bar < 0:
	sign='-'
	else:
	sign='\\,'
	if minor: # The power of ten is only to be added to the last minor tick label
	if lastminor:
	label = str(int(value/(10**bar))) + "\\cdot" + '10$^{'+sign+'\\text{'+str(abs(bar))+'}}$'
	else:
	label = str(int(value/(10**bar))) # The naked prefactor
	else:
	if bar==0:
	label = '1'
	else:
	label = '10$^{'+sign+'\\text{'+str(abs(bar))+'}}$'
	else:
	if fabs(value) < 1e-10:
	value = 0
	label = str(value)
	if "e" in label:
	a, b = label.split("e")
	astr = "%2.1f" % float(a)
	bstr = str(int(b))
	label = "\\smaller{%s $\\!\\cdot 10^{%s} $}" % (astr, bstr)
	return label



	class XTicks(Ticks):

	- def draw(self, custommajorticks=[], customminorticks=[], custommajortickmarks=-1, customminortickmarks=-1,drawlabels=True):
	+ def draw(self, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1,drawlabels=True):
	twosided = bool(int(self.description.get('XTwosidedTicks', '0')))
	out = ""
	out += ('\n%\n% X-Ticks\n%\n')
	out += ('\\def\\majortickmarkx{\\psline[linewidth='+self.majorticklinewidth+'](0,0)(0,'+self.majorticklength+')}%\n')
	out += ('\\def\\minortickmarkx{\\psline[linewidth='+self.minorticklinewidth+'](0,0)(0,'+self.minorticklength+')}%\n')
	uselog = self.description['LogX'] and (self.coors.xmin() > 0 and self.coors.xmax() > 0)
	out += self.draw_ticks(self.coors.xmin(), self.coors.xmax(),\
	plotlog=uselog,\
	custommajorticks=custommajorticks,\
	customminorticks=customminorticks,\
	custommajortickmarks=custommajortickmarks,\
	customminortickmarks=customminortickmarks,\
	drawlabels=drawlabels,\
	twosided=twosided)
	return out

	def draw_minortick(self, ticklabel, twosided):
	out = ''
	out += '\\rput('+self.coors.strphys2frameX(ticklabel)+', 0){\\minortickmarkx}\n'
	if twosided:
	out += '\\rput{180}('+self.coors.strphys2frameX(ticklabel)+', 1){\\minortickmarkx}\n'
	return out

	def draw_minorticklabel(self, value, label='', last=False):
	if not label:
	label=self.get_ticklabel(value, int(self.description['LogX']), minor=True, lastminor=last)
	if last: # Some more indentation for the last minor label
	return ('\\rput('+self.coors.strphys2frameX(value)+', 0){\\rput[B](1.9\\labelsep,-2.3\\labelsep){\\strut{}'+label+'}}\n')
	else:
	return ('\\rput('+self.coors.strphys2frameX(value)+', 0){\\rput[B](0,-2.3\\labelsep){\\strut{}'+label+'}}\n')

	def draw_majortick(self, ticklabel, twosided):
	out = ''
	out += '\\rput('+self.coors.strphys2frameX(ticklabel)+', 0){\\majortickmarkx}\n'
	if twosided:
	out += '\\rput{180}('+self.coors.strphys2frameX(ticklabel)+', 1){\\majortickmarkx}\n'
	return out

	def draw_majorticklabel(self, value, label=''):
	if not label:
	- label = self.get_ticklabel(value, int(self.description['LogX']) and (self.coors.xmin() > 0 and self.coors.xmax() > 0))
	+ label = self.get_ticklabel(value, int(self.description['LogX']) and self.coors.xmin() > 0 and self.coors.xmax() > 0)
	labelparts = label.split("\\n")
	labelcode = label if len(labelparts) == 1 else ("\\shortstack{" + "\\\\ ".join(labelparts) + "}")
	rtn = "\\rput(" + self.coors.strphys2frameX(value) + ", 0){\\rput[t](0,-\\labelsep){" + labelcode + "}}\n"
	return rtn



	class YTicks(Ticks):

	- def draw(self, custommajorticks=[], customminorticks=[], custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True):
	+ def draw(self, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True):
	twosided = bool(int(self.description.get('YTwosidedTicks', '0')))
	out = ""
	out += ('\n%\n% Y-Ticks\n%\n')
	- out += ('\\def\\majortickmarky{\\psline[linewidth='+self.majorticklinewidth+'](0,0)('+self.majorticklength+',0)}%\n')
	- out += ('\\def\\minortickmarky{\\psline[linewidth='+self.minorticklinewidth+'](0,0)('+self.minorticklength+',0)}%\n')
	- uselog = self.description['LogY'] and (self.coors.ymin() > 0 and self.coors.ymax() > 0)
	+ out += ('\\def\\majortickmarky{\\psline[linewidth=%s](0,0)(%s,0)}%%\n' % (self.majorticklinewidth, self.majorticklength))
	+ out += ('\\def\\minortickmarky{\\psline[linewidth=%s](0,0)(%s,0)}%%\n' % (self.minorticklinewidth, self.minorticklength))
	+ uselog = self.description['LogY'] and self.coors.ymin() > 0 and self.coors.ymax() > 0
	out += self.draw_ticks(self.coors.ymin(), self.coors.ymax(),
	plotlog=uselog,
	custommajorticks=custommajorticks,
	customminorticks=customminorticks,
	custommajortickmarks=custommajortickmarks,
	customminortickmarks=customminortickmarks,
	twosided=twosided,
	drawlabels=drawlabels)
	return out

	def draw_minortick(self, ticklabel, twosided):
	out = ''
	out += '\\rput(0, '+self.coors.strphys2frameY(ticklabel)+'){\\minortickmarky}\n'
	if twosided:
	out += '\\rput{180}(1, '+self.coors.strphys2frameY(ticklabel)+'){\\minortickmarky}\n'
	return out

	def draw_majortick(self, ticklabel, twosided):
	out = ''
	out += '\\rput(0, '+self.coors.strphys2frameY(ticklabel)+'){\\majortickmarky}\n'
	if twosided:
	out += '\\rput{180}(1, '+self.coors.strphys2frameY(ticklabel)+'){\\majortickmarky}\n'
	return out

	def draw_majorticklabel(self, value, label=''):
	if not label:
	- label = self.get_ticklabel(value, int(self.description['LogY']) and (self.coors.ymin() > 0 and self.coors.ymax() > 0))
	+ label = self.get_ticklabel(value, int(self.description['LogY']) and self.coors.ymin() > 0 and self.coors.ymax() > 0)
	if self.description.has_key('RatioPlotMode') and self.description['RatioPlotMode'] == 'deviation' and \
	- self.description.has_key('RatioPlotStage') and self.description['RatioPlotStage'] == '1':
	+ self.description.has_key('RatioPlotStage') and self.description['RatioPlotStage']:
	rtn = '\\uput[180]{0}(0, '+self.coors.strphys2frameY(value)+'){\\strut{}'+label+'\\,$\\sigma$}\n'
	else:
	labelparts = label.split("\\n")
	labelcode = label if len(labelparts) == 1 else ("\\shortstack{" + "\\\\ ".join(labelparts) + "}")
	rtn = "\\rput(0, " + self.coors.strphys2frameY(value) + "){\\rput[r](-\\labelsep,0){" + labelcode + "}}\n"
	return rtn



	-
	-
	-
	class ZTicks(Ticks):

	def __init__(self, description, coors):
	self.majorticklinewidth = '0.3pt'
	self.minorticklinewidth = '0.3pt'
	self.majorticklength = '6pt'
	self.minorticklength = '2.6pt'
	self.description = description
	self.coors = coors

	- def draw(self, custommajorticks=[], customminorticks=[],
	- custommajortickmarks=-1, customminortickmarks=-1,
	- drawlabels=True):
	+ def draw(self, custommajorticks=None, customminorticks=None, custommajortickmarks=-1, customminortickmarks=-1, drawlabels=True):
	out = ""
	out += ('\n%\n% Z-Ticks\n%\n')
	out += ('\\def\\majortickmarkz{\\psline[linewidth='+self.majorticklinewidth+'](0,0)('+self.majorticklength+',0)}%\n')
	out += ('\\def\\minortickmarkz{\\psline[linewidth='+self.minorticklinewidth+'](0,0)('+self.minorticklength+',0)}%\n')
	out += self.draw_ticks(self.coors.zmin(), self.coors.zmax(),\
	plotlog=self.description['LogZ'],\
	custommajorticks=custommajorticks,\
	customminorticks=customminorticks,\
	custommajortickmarks=custommajortickmarks,\
	customminortickmarks=customminortickmarks,\
	twosided=False,\
	drawlabels=drawlabels)
	return out

	def draw_minortick(self, ticklabel, twosided):
	return '\\rput{180}(1, '+self.coors.strphys2frameZ(ticklabel)+'){\\minortickmarkz}\n'

	def draw_majortick(self, ticklabel, twosided):
	return '\\rput{180}(1, '+self.coors.strphys2frameZ(ticklabel)+'){\\majortickmarkz}\n'

	def draw_majorticklabel(self, value, label=''):
	if label=='':
	label = self.get_ticklabel(value, int(self.description['LogZ']))
	if self.description.has_key('RatioPlotMode') and self.description['RatioPlotMode']=='deviation' \
	and self.description.has_key('RatioPlotStage') and self.description['RatioPlotStage']:
	return ('\\uput[0]{0}(1, '+self.coors.strphys2frameZ(value)+'){\\strut{}'+label+'\\,$\\sigma$}\n')
	else:
	return ('\\uput[0]{0}(1, '+self.coors.strphys2frameZ(value)+'){\\strut{}'+label+'}\n')



	class Coordinates(object):

	def __init__(self, inputdata):
	self.description = inputdata.description

	def phys2frameX(self, x):
	if self.description['LogX']:
	if x>0:
	result = 1.*(log10(x)-log10(self.xmin()))/(log10(self.xmax())-log10(self.xmin()))
	else:
	return -10
	else:
	result = 1.*(x-self.xmin())/(self.xmax()-self.xmin())
	if (fabs(result) < 1e-4):
	return 0
	else:
	return min(max(result,-10),10)

	def phys2frameY(self, y):
	if self.description['LogY']:
	if y > 0 and self.ymin() > 0 and self.ymax() > 0:
	result = 1.*(log10(y)-log10(self.ymin()))/(log10(self.ymax())-log10(self.ymin()))
	else:
	return -10
	else:
	result = 1.*(y-self.ymin())/(self.ymax()-self.ymin())
	if (fabs(result) < 1e-4):
	return 0
	else:
	return min(max(result,-10),10)

	def phys2frameZ(self, z):
	if self.description['LogZ']:
	if z>0:
	result = 1.*(log10(z)-log10(self.zmin()))/(log10(self.zmax())-log10(self.zmin()))
	else:
	return -10
	else:
	result = 1.*(z-self.zmin())/(self.zmax()-self.zmin())
	if (fabs(result) < 1e-4):
	return 0
	else:
	return min(max(result,-10),10)

	# TODO: Add frame2phys functions (to allow linear function sampling in the frame space rather than the physical space)

	def strphys2frameX(self, x):
	return str(self.phys2frameX(x))

	def strphys2frameY(self, y):
	return str(self.phys2frameY(y))

	def strphys2frameZ(self, z):
	return str(self.phys2frameZ(z))

	def xmin(self):
	return self.description['Borders'][0]

	def xmax(self):
	return self.description['Borders'][1]

	def ymin(self):
	return self.description['Borders'][2]

	def ymax(self):
	return self.description['Borders'][3]

	def zmin(self):
	return self.description['Borders'][4]

	def zmax(self):
	return self.description['Borders'][5]


	####################

	+import shutil, subprocess

	def try_cmd(args):
	"Run the given command + args and return True/False if it succeeds or not"
	- import subprocess
	try:
	subprocess.check_output(args, stderr=subprocess.STDOUT)
	return True
	- except AttributeError:
	- # Python <=2.6 does not provide check_output
	- return True
	except:
	return False

	def have_cmd(cmd):
	return try_cmd(["which", cmd])


	-import shutil, subprocess
	-def process_datfile(datfile):
	- global opts
	- if not os.access(datfile, os.R_OK):
	- raise Exception("Could not read data file '%s'" % datfile)
	-
	- dirname = os.path.dirname(datfile)
	- datfile = os.path.basename(datfile)
	- filename = datfile.replace('.dat','')
	+
	+####################
	+
	+
	+
	+if __name__ == '__main__':
	+
	+ ## Try to rename the process on Linux
	+ try:
	+ import ctypes
	+ libc = ctypes.cdll.LoadLibrary('libc.so.6')
	+ libc.prctl(15, 'make-plots', 0, 0, 0)
	+ except Exception:
	+ pass
	+
	+ ## Try to use Psyco optimiser
	+ try:
	+ import psyco
	+ psyco.full()
	+ except ImportError:
	+ pass
	+
	+ ## Find number of (virtual) processing units
	+ import multiprocessing
	+ try:
	+ numcores = multiprocessing.cpu_count()
	+ except:
	+ numcores = 1
	+
	+ ## Parse command line options
	+ from optparse import OptionParser, OptionGroup
	+ parser = OptionParser(usage=__doc__)
	+ parser.add_option("-n", "-j", "--num-threads", dest="NUM_THREADS", type="int",
	+ default=numcores, help="max number of threads to be used [%s]" % numcores)
	+ parser.add_option("--font", dest="OUTPUT_FONT", choices="palatino,cm,times,helvetica,minion".split(","),
	+ default="palatino", help="choose the font to be used in the plots")
	+ parser.add_option("--palatino", dest="OUTPUT_FONT", action="store_const", const="palatino", default="palatino",
	+ help="use Palatino as font (default). DEPRECATED: Use --font")
	+ parser.add_option("--cm", dest="OUTPUT_FONT", action="store_const", const="cm", default="palatino",
	+ help="use Computer Modern as font. DEPRECATED: Use --font")
	+ parser.add_option("--times", dest="OUTPUT_FONT", action="store_const", const="times", default="palatino",
	+ help="use Times as font. DEPRECATED: Use --font")
	+ parser.add_option("--minion", dest="OUTPUT_FONT", action="store_const", const="minion", default="palatino",
	+ help="use Adobe Minion Pro as font. Note: You need to set TEXMFHOME first. DEPRECATED: Use --font")
	+ parser.add_option("--helvetica", dest="OUTPUT_FONT", action="store_const", const="helvetica", default="palatino",
	+ help="use Helvetica as font. DEPRECATED: Use --font")
	+ parser.add_option("--format", dest="OUTPUT_FORMAT", default="PDF",
	+ help="choose plot format, perhaps multiple comma-separated formats e.g. 'pdf' or 'tex,pdf,png' (default = PDF).")
	+ parser.add_option("--ps", dest="OUTPUT_FORMAT", action="store_const", const="PS", default="PDF",
	+ help="create PostScript output (default). DEPRECATED")
	+ parser.add_option("--pdf", dest="OUTPUT_FORMAT", action="store_const", const="PDF", default="PDF",
	+ help="create PDF output. DEPRECATED")
	+ parser.add_option("--eps", dest="OUTPUT_FORMAT", action="store_const", const="EPS", default="PDF",
	+ help="create Encapsulated PostScript output. DEPRECATED")
	+ parser.add_option("--png", dest="OUTPUT_FORMAT", action="store_const", const="PNG", default="PDF",
	+ help="create PNG output. DEPRECATED")
	+ parser.add_option("--pspng", dest="OUTPUT_FORMAT", action="store_const", const="PS,PNG", default="PDF",
	+ help="create PS and PNG output. DEPRECATED")
	+ parser.add_option("--pdfpng", dest="OUTPUT_FORMAT", action="store_const", const="PDF,PNG", default="PDF",
	+ help="create PDF and PNG output. DEPRECATED")
	+ parser.add_option("--epspng", dest="OUTPUT_FORMAT", action="store_const", const="EPS,PNG", default="PDF",
	+ help="create EPS and PNG output. DEPRECATED")
	+ parser.add_option("--tex", dest="OUTPUT_FORMAT", action="store_const", const="TEX", default="PDF",
	+ help="create TeX/LaTeX output.")
	+ parser.add_option("--no-cleanup", dest="NO_CLEANUP", action="store_true", default=False,
	+ help="keep temporary directory and print its filename.")
	+ parser.add_option("--no-subproc", dest="NO_SUBPROC", action="store_true", default=False,
	+ help="don't use subprocesses to render the plots in parallel -- useful for debugging.")
	+ parser.add_option("--full-range", dest="FULL_RANGE", action="store_true", default=False,
	+ help="plot full y range in LogY plots.")
	+ parser.add_option("-c", "--config", dest="CONFIGFILES", action="append", default=None,
	+ help="plot config file to be used. Overrides internal config blocks.")
	+ verbgroup = OptionGroup(parser, "Verbosity control")
	+ verbgroup.add_option("-v", "--verbose", action="store_const", const=logging.DEBUG, dest="LOGLEVEL",
	+ default=logging.INFO, help="print debug (very verbose) messages")
	+ verbgroup.add_option("-q", "--quiet", action="store_const", const=logging.WARNING, dest="LOGLEVEL",
	+ default=logging.INFO, help="be very quiet")
	+ parser.add_option_group(verbgroup)
	+
	+ opts, args = parser.parse_args()
	+ logging.basicConfig(level=opts.LOGLEVEL, format="%(message)s")
	+ opts.OUTPUT_FONT = opts.OUTPUT_FONT.upper()
	+ opts.OUTPUT_FORMAT = opts.OUTPUT_FORMAT.upper().split(",")
	+
	+ ## Check for no args
	+ if len(args) == 0:
	+ logging.error(parser.get_usage())
	+ sys.exit(2)
	+
	+ ## Check that the files exist
	+ for f in args:
	+ if not os.access(f, os.R_OK):
	+ print "Error: cannot read from %s" % f
	+ sys.exit(1)
	+
	+ ## Test for external programs (kpsewhich, latex, dvips, ps2pdf/ps2eps, and convert)
	+ opts.LATEXPKGS = []
	+ if opts.OUTPUT_FORMAT != ["TEX"]:
	+ try:
	+ ## latex
	+ if not have_cmd("pdflatex"):
	+ logging.error("ERROR: required program 'latex' could not be found. Exiting...")
	+ sys.exit(1)
	+ # ## dvips
	+ # if not have_cmd("dvips"):
	+ # logging.error("ERROR: required program 'dvips' could not be found. Exiting...")
	+ # sys.exit(1)
	+
	+ # ## ps2pdf / ps2eps
	+ # if "PDF" in opts.OUTPUT_FORMAT:
	+ # if not have_cmd("ps2pdf"):
	+ # logging.error("ERROR: required program 'ps2pdf' (for PDF output) could not be found. Exiting...")
	+ # sys.exit(1)
	+ # elif "EPS" in opts.OUTPUT_FORMAT:
	+ # if not have_cmd("ps2eps"):
	+ # logging.error("ERROR: required program 'ps2eps' (for EPS output) could not be found. Exiting...")
	+ # sys.exit(1)
	+
	+ ## PNG output converter
	+ if "PNG" in opts.OUTPUT_FORMAT:
	+ if not have_cmd("convert"):
	+ logging.error("ERROR: required program 'convert' (for PNG output) could not be found. Exiting...")
	+ sys.exit(1)
	+
	+ ## kpsewhich: required for LaTeX package testing
	+ if not have_cmd("kpsewhich"):
	+ logging.warning("WARNING: required program 'kpsewhich' (for LaTeX package checks) could not be found")
	+ else:
	+ ## Check minion font
	+ if opts.OUTPUT_FONT == "MINION":
	+ p = subprocess.Popen(["kpsewhich", "minion.sty"], stdout=subprocess.PIPE)
	+ p.wait()
	+ if p.returncode != 0:
	+ logging.warning('Warning: Using "--minion" requires minion.sty to be installed. Ignoring it.')
	+ opts.OUTPUT_FONT = "PALATINO"
	+
	+ ## Check for HEP LaTeX packages
	+ # TODO: remove HEP-specifics/non-standards?
	+ for pkg in ["hepnames", "hepunits", "underscore"]:
	+ p = subprocess.Popen(["kpsewhich", "%s.sty" % pkg], stdout=subprocess.PIPE)
	+ p.wait()
	+ if p.returncode == 0:
	+ opts.LATEXPKGS.append(pkg)
	+
	+ ## Check for Palatino old style figures and small caps
	+ if opts.OUTPUT_FONT == "PALATINO":
	+ p = subprocess.Popen(["kpsewhich", "ot1pplx.fd"], stdout=subprocess.PIPE)
	+ p.wait()
	+ if p.returncode == 0:
	+ opts.OUTPUT_FONT = "PALATINO_OSF"
	+ except Exception, e:
	+ logging.warning("Problem while testing for external packages. I'm going to try and continue without testing, but don't hold your breath...")
	+
	+ # def init_worker():
	+ # import signal
	+ # signal.signal(signal.SIGINT, signal.SIG_IGN)
	+
	+ ## Run rendering jobs
	+ datfiles = args
	+ plotword = "plots" if len(datfiles) > 1 else "plot"
	+ logging.info("Making %d %s" % (len(datfiles), plotword))

	## Create a temporary directory
	- cwd = os.getcwd()
	- datpath = os.path.join(cwd, dirname, datfile)
	tempdir = tempfile.mkdtemp('.make-plots')
	- tempdatpath = os.path.join(tempdir, datfile)
	- shutil.copy(datpath, tempdir)
	-
	- ## Make TeX file
	- inputdata = Inputdata(os.path.join(dirname,filename))
	- texpath = os.path.join(tempdir, '%s.tex' % filename)
	+ if opts.NO_CLEANUP:
	+ logging.info('Keeping temp-files in %s' % tempdir)
	+
	+ ## Create TeX file
	+ texpath = os.path.join(tempdir, 'plots.tex')
	texfile = open(texpath, 'w')
	- p = Plot(inputdata)
	- texfile.write(p.write_header(inputdata))
	- if inputdata.description.get('MainPlot', '1') == '1':
	- mp = MainPlot(inputdata)
	- texfile.write(mp.draw(inputdata))
	- if not inputdata.description.get('is2dim', False) and \
	- inputdata.description.get('RatioPlot', '1') == '1' and \
	- inputdata.description.get('RatioPlotReference') is not None:
	- rp = RatioPlot(inputdata)
	- texfile.write(rp.draw(inputdata))
	- texfile.write(p.write_footer())
	+ # if inputdata.description.has_key('LeftMargin') and inputdata.description['LeftMargin']!='':
	+ # inputdata.description['LeftMargin'] = float(inputdata.description['LeftMargin'])
	+ # else:
	+ # inputdata.description['LeftMargin'] = 1.4
	+ # if inputdata.description.has_key('RightMargin') and inputdata.description['RightMargin']!='':
	+ # inputdata.description['RightMargin'] = float(inputdata.description['RightMargin'])
	+ # else:
	+ # inputdata.description['RightMargin'] = 0.35
	+ # if inputdata.description.has_key('TopMargin') and inputdata.description['TopMargin']!='':
	+ # inputdata.description['TopMargin'] = float(inputdata.description['TopMargin'])
	+ # else:
	+ # inputdata.description['TopMargin'] = 0.65
	+ # if inputdata.description.has_key('BottomMargin') and inputdata.description['BottomMargin']!='':
	+ # inputdata.description['BottomMargin'] = float(inputdata.description['BottomMargin'])
	+ # else:
	+ # inputdata.description['BottomMargin'] = 0.95
	+ # if inputdata.description['is2dim']:
	+ # inputdata.description['RightMargin'] += 1.7
	+ # papersizex = inputdata.description['PlotSizeX'] + 0.1 + \
	+ # inputdata.description['LeftMargin'] + inputdata.description['RightMargin']
	+ # papersizey = inputdata.description['PlotSizeY'] + inputdata.description['RatioPlotSizeY'] + 0.1 + \
	+ # inputdata.description['TopMargin'] + inputdata.description['BottomMargin']
	+ #
	+ out = ""
	+ # out += '\\documentclass{article}\n'
	+ # out += '\\documentclass[pstricks,multi]{standalone}\n'
	+ out += '\\documentclass[multi=multipage]{standalone}\n'
	+ if opts.OUTPUT_FONT == "MINION":
	+ out += ('\\usepackage{minion}\n')
	+ elif opts.OUTPUT_FONT == "PALATINO_OSF":
	+ out += ('\\usepackage[osf,sc]{mathpazo}\n')
	+ elif opts.OUTPUT_FONT == "PALATINO":
	+ out += ('\\usepackage{mathpazo}\n')
	+ elif opts.OUTPUT_FONT == "TIMES":
	+ out += ('\\usepackage{mathptmx}\n')
	+ elif opts.OUTPUT_FONT == "HELVETICA":
	+ out += ('\\renewcommand{\\familydefault}{\\sfdefault}\n')
	+ out += ('\\usepackage{sfmath}\n')
	+ out += ('\\usepackage{helvet}\n')
	+ out += ('\\usepackage[symbolgreek]{mathastext}\n')
	+ for pkg in opts.LATEXPKGS:
	+ out += ('\\usepackage{%s}\n' % pkg)
	+ out += ('\\usepackage{pst-all}\n')
	+ out += ('\\usepackage{xcolor}\n')
	+ out += ('\\selectcolormodel{rgb}\n')
	+ out += ('\\definecolor{red}{HTML}{EE3311}\n') # (Google uses 'DC3912')
	+ out += ('\\definecolor{blue}{HTML}{3366FF}')
	+ out += ('\\definecolor{green}{HTML}{109618}')
	+ out += ('\\definecolor{orange}{HTML}{FF9900}')
	+ out += ('\\definecolor{lilac}{HTML}{990099}')
	+ out += ('\\usepackage{amsmath}\n')
	+ out += ('\\usepackage{amssymb}\n')
	+ out += ('\\usepackage{relsize}\n')
	+ # out += ('\\usepackage[dvips,\n')
	+ # out += (' left=%4.3fcm, right=0cm,\n' % (inputdata.description['LeftMargin']-0.45,))
	+ # out += (' top=%4.3fcm, bottom=0cm,\n' % (inputdata.description['TopMargin']-0.30,))
	+ # out += (' paperwidth=%scm,paperheight=%scm\n' % (papersizex,papersizey))
	+ # out += (']{geometry}\n')
	+ # out += ('\\usepackage[pdfcrop={--margins 10}]{auto-pst-pdf}\n')
	+ out += ('\\usepackage{auto-pst-pdf}\n')
	+ out += '\n'
	+ out += ('\\begin{document}\n')
	+ #out += ('\\pagestyle{empty}\n')
	+ out += ('\\SpecialCoor\n')
	+ texfile.write(out)
	+
	+ ## Process each datfile into the TeX doc
	+ for i, datfile in enumerate(datfiles):
	+ if not os.access(datfile, os.R_OK):
	+ raise Exception("Could not read data file '%s'" % datfile)
	+
	+ ## Get std paths and copy datfile into tempdir
	+ dirname = os.path.dirname(datfile)
	+ datfile = os.path.basename(datfile)
	+ filename = datfile.replace('.dat','')
	+ cwd = os.getcwd()
	+ datpath = os.path.join(cwd, dirname, datfile)
	+ tempdatpath = os.path.join(tempdir, datfile)
	+ shutil.copy(datpath, tempdir)
	+
	+ ## Append TeX to file
	+ inputdata = InputData(os.path.join(dirname,filename))
	+ p = Plot(inputdata)
	+ texfile.write("\n\n")
	+ texfile.write(p.write_header(inputdata))
	+ if inputdata.attr_bool("MainPlot", True):
	+ mp = MainPlot(inputdata)
	+ texfile.write(mp.draw(inputdata))
	+ if not inputdata.attr_bool("is2dim", False) and inputdata.attr_bool("RatioPlot", True) and inputdata.attr("RatioPlotReference"): # is not None:
	+ rp = RatioPlot(inputdata)
	+ texfile.write(rp.draw(inputdata))
	+ texfile.write(p.write_footer())
	+
	+ texfile.write('\\end{document}\n')
	texfile.close()

	+ filename = "plots" #< TODO: unhack
	+
	if opts.OUTPUT_FORMAT != ["TEX"]:

	## Check for the required programs
	latexavailable = have_cmd("latex")
	dvipsavailable = have_cmd("dvips")
	convertavailable = have_cmd("convert")
	ps2pnmavailable = have_cmd("ps2pnm")
	pnm2pngavailable = have_cmd("pnm2png")

	# TODO: It'd be nice to be able to control the size of the PNG between thumb and full-size...
	# currently defaults (and is used below) to a size suitable for thumbnails
	def mkpng(infile, outfile, density=100):
	if convertavailable:
	pngcmd = ["convert", "-flatten", "-density", str(density), infile, "-quality", "100", "-sharpen", "0x1.0", outfile]
	logging.debug(" ".join(pngcmd))
	pngproc = subprocess.Popen(pngcmd, stdout=subprocess.PIPE, cwd=tempdir)
	pngproc.wait()
	else:
	raise Exception("Required PNG maker program (convert) not found")
	# elif ps2pnmavailable and pnm2pngavailable:
	# pstopnm = "pstopnm -stdout -xsize=461 -ysize=422 -xborder=0.01 -yborder=0.01 -portrait " + infile
	# p1 = subprocess.Popen(pstopnm.split(), stdout=subprocess.PIPE, stderr=open("/dev/null", "w"), cwd=tempdir)
	# p2 = subprocess.Popen(["pnmtopng"], stdin=p1.stdout, stdout=open("%s/%s.png" % (tempdir, outfile), "w"), stderr=open("/dev/null", "w"), cwd=tempdir)
	# p2.wait()
	# else:
	# raise Exception("Required PNG maker programs (convert, or ps2pnm and pnm2png) not found")

	## Run LaTeX (in no-stop mode)
	logging.debug(os.listdir(tempdir))
	- texcmd = ["latex", "\scrollmode\input", texpath]
	+ texcmd = ["pdflatex", "-shell-escape", "\scrollmode\input", texpath]
	logging.debug("TeX command: " + " ".join(texcmd))
	texproc = subprocess.Popen(texcmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=tempdir)
	logging.debug(texproc.communicate()[0])
	logging.debug(os.listdir(tempdir))

	- ## Run dvips
	- dvcmd = ["dvips", filename]
	- if not logging.getLogger().isEnabledFor(logging.DEBUG):
	- dvcmd.append("-q")
	- ## Handle Minion Font
	- if opts.OUTPUT_FONT == "MINION":
	- dvcmd.append('-Pminion')
	+ # ## Run dvips
	+ # dvcmd = ["dvips", filename]
	+ # if not logging.getLogger().isEnabledFor(logging.DEBUG):
	+ # dvcmd.append("-q")
	+ # ## Handle Minion Font
	+ # if opts.OUTPUT_FONT == "MINION":
	+ # dvcmd.append('-Pminion')

	## Choose format
	# TODO: Rationalise... this is a mess! Maybe we can use tex2pix?
	- if "PS" in opts.OUTPUT_FORMAT:
	- dvcmd += ["-o", "%s.ps" % filename]
	- logging.debug(" ".join(dvcmd))
	- dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- dvproc.wait()
	- if "PDF" in opts.OUTPUT_FORMAT:
	- dvcmd.append("-f")
	- logging.debug(" ".join(dvcmd))
	- dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- cnvproc = subprocess.Popen(["ps2pdf", "-"], stdin=dvproc.stdout, stdout=subprocess.PIPE, cwd=tempdir)
	- f = open(os.path.join(tempdir, "%s.pdf" % filename), "w")
	- f.write(cnvproc.communicate()[0])
	- f.close()
	- if "EPS" in opts.OUTPUT_FORMAT:
	- dvcmd.append("-f")
	- logging.debug(" ".join(dvcmd))
	- dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- cnvproc = subprocess.Popen(["ps2eps"], stdin=dvproc.stdout, stderr=subprocess.PIPE, stdout=subprocess.PIPE, cwd=tempdir)
	- f = open(os.path.join(tempdir, "%s.eps" % filename), "w")
	- f.write(cnvproc.communicate()[0])
	- f.close()
	- if "PNG" in opts.OUTPUT_FORMAT:
	- dvcmd.append("-f")
	- logging.debug(" ".join(dvcmd))
	- dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- pngcmd = ["convert", "-flatten", "-density", "100", "-", "-quality", "100", "-sharpen", "0x1.0", "%s.png" % filename]
	- logging.debug(" ".join(pngcmd))
	- pngproc = subprocess.Popen(pngcmd, stdin=dvproc.stdout, stdout=subprocess.PIPE, cwd=tempdir)
	- pngproc.wait()
	- # if opts.OUTPUT_FORMAT == "PSPNG":
	+ # if "PS" in opts.OUTPUT_FORMAT:
	# dvcmd += ["-o", "%s.ps" % filename]
	# logging.debug(" ".join(dvcmd))
	# dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	# dvproc.wait()
	- # assert os.path.exists("%s.ps" % filename)
	- # mkpng("%s.ps" % filename, "%s.png" % filename)
	- # if opts.OUTPUT_FORMAT == "PDFPNG":
	+ # if "PDF" in opts.OUTPUT_FORMAT:
	# dvcmd.append("-f")
	# logging.debug(" ".join(dvcmd))
	# dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	# cnvproc = subprocess.Popen(["ps2pdf", "-"], stdin=dvproc.stdout, stdout=subprocess.PIPE, cwd=tempdir)
	# f = open(os.path.join(tempdir, "%s.pdf" % filename), "w")
	# f.write(cnvproc.communicate()[0])
	# f.close()
	- # logging.debug(os.listdir(tempdir))
	- # assert os.path.exists("%s.pdf" % filename)
	- # mkpng("%s.pdf" % filename, "%s.png" % filename)
	- # if opts.OUTPUT_FORMAT == "EPSPNG":
	+ # if "EPS" in opts.OUTPUT_FORMAT:
	# dvcmd.append("-f")
	# logging.debug(" ".join(dvcmd))
	# dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	- # cnvproc = subprocess.Popen(["ps2eps"], stdin=dvproc.stdout, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=tempdir)
	+ # cnvproc = subprocess.Popen(["ps2eps"], stdin=dvproc.stdout, stderr=subprocess.PIPE, stdout=subprocess.PIPE, cwd=tempdir)
	# f = open(os.path.join(tempdir, "%s.eps" % filename), "w")
	# f.write(cnvproc.communicate()[0])
	# f.close()
	- # mkpng("%s.eps" % filename, "%s.png" % filename)
	- # else:
	- # logging.error("Unknown format: %s" % opts.OUTPUT_FORMAT)
	- # sys.exit(1)
	+ # if "PNG" in opts.OUTPUT_FORMAT:
	+ # dvcmd.append("-f")
	+ # logging.debug(" ".join(dvcmd))
	+ # dvproc = subprocess.Popen(dvcmd, stdout=subprocess.PIPE, cwd=tempdir)
	+ # pngcmd = ["convert", "-flatten", "-density", "100", "-", "-quality", "100", "-sharpen", "0x1.0", "%s.png" % filename]
	+ # logging.debug(" ".join(pngcmd))
	+ # pngproc = subprocess.Popen(pngcmd, stdin=dvproc.stdout, stdout=subprocess.PIPE, cwd=tempdir)
	+ # pngproc.wait()
	logging.debug(os.listdir(tempdir))

	## Copy results back to main dir
	+ # shutil.copy(os.path.join(tempdir,"plots-pics.pdf"), os.path.join(cwd,dirname))
	for fmt in opts.OUTPUT_FORMAT:
	outname = "%s.%s" % (filename, fmt.lower())
	outpath = os.path.join(tempdir, outname)
	if os.path.exists(outpath):
	shutil.copy(outpath, os.path.join(cwd,dirname))
	else:
	logging.error("No output file '%s' from processing %s" % (outname, datfile))

	## Clean up
	- if opts.NO_CLEANUP:
	- logging.info('Keeping temp-files in %s' % tempdir)
	- else:
	+ if not opts.NO_CLEANUP:
	shutil.rmtree(tempdir, ignore_errors=True)


	-####################
	-
	-
	-if __name__ == '__main__':
	-
	- ## Try to rename the process on Linux
	- try:
	- import ctypes
	- libc = ctypes.cdll.LoadLibrary('libc.so.6')
	- libc.prctl(15, 'make-plots', 0, 0, 0)
	- except Exception:
	- pass
	-
	- ## Try to use Psyco optimiser
	- try:
	- import psyco
	- psyco.full()
	- except ImportError:
	- pass
	-
	- ## Find number of (virtual) processing units
	- numcores = os.sysconf('SC_NPROCESSORS_ONLN')
	- if numcores is None:
	- numcores = 1
	-
	- ## Parse command line options
	- from optparse import OptionParser, OptionGroup
	- parser = OptionParser(usage=__doc__)
	- parser.add_option("-n", "-j", "--num-threads", dest="NUM_THREADS", type="int",
	- default=numcores, help="max number of threads to be used [%s]" % numcores)
	- parser.add_option("--font", dest="OUTPUT_FONT", choices="palatino,cm,times,helvetica,minion".split(","),
	- default="palatino", help="choose the font to be used in the plots")
	- parser.add_option("--palatino", dest="OUTPUT_FONT", action="store_const", const="palatino", default="palatino",
	- help="Use Palatino as font (default). DEPRECATED: Use --font")
	- parser.add_option("--cm", dest="OUTPUT_FONT", action="store_const", const="cm", default="palatino",
	- help="Use Computer Modern as font. DEPRECATED: Use --font")
	- parser.add_option("--times", dest="OUTPUT_FONT", action="store_const", const="times", default="palatino",
	- help="Use Times as font. DEPRECATED: Use --font")
	- parser.add_option("--minion", dest="OUTPUT_FONT", action="store_const", const="minion", default="palatino",
	- help="Use Adobe Minion Pro as font. Note: You need to set TEXMFHOME first. DEPRECATED: Use --font")
	- parser.add_option("--helvetica", dest="OUTPUT_FONT", action="store_const", const="helvetica", default="palatino",
	- help="Use Helvetica as font. DEPRECATED: Use --font")
	- parser.add_option("--format", dest="OUTPUT_FORMAT", default="PDF",
	- help="Choose plot format, perhaps multiple comma-separated formats e.g. 'pdf' or 'tex,pdf,png' (default = PDF).")
	- parser.add_option("--ps", dest="OUTPUT_FORMAT", action="store_const", const="PS", default="PDF",
	- help="Create PostScript output (default). DEPRECATED")
	- parser.add_option("--pdf", dest="OUTPUT_FORMAT", action="store_const", const="PDF", default="PDF",
	- help="Create PDF output. DEPRECATED")
	- parser.add_option("--eps", dest="OUTPUT_FORMAT", action="store_const", const="EPS", default="PDF",
	- help="Create Encapsulated PostScript output. DEPRECATED")
	- parser.add_option("--png", dest="OUTPUT_FORMAT", action="store_const", const="PNG", default="PDF",
	- help="Create PNG output. DEPRECATED")
	- parser.add_option("--pspng", dest="OUTPUT_FORMAT", action="store_const", const="PS,PNG", default="PDF",
	- help="Create PS and PNG output. DEPRECATED")
	- parser.add_option("--pdfpng", dest="OUTPUT_FORMAT", action="store_const", const="PDF,PNG", default="PDF",
	- help="Create PDF and PNG output. DEPRECATED")
	- parser.add_option("--epspng", dest="OUTPUT_FORMAT", action="store_const", const="EPS,PNG", default="PDF",
	- help="Create EPS and PNG output. DEPRECATED")
	- parser.add_option("--tex", dest="OUTPUT_FORMAT", action="store_const", const="TEX", default="PDF",
	- help="Create TeX/LaTeX output.")
	- parser.add_option("--no-cleanup", dest="NO_CLEANUP", action="store_true", default=False,
	- help="Keep temporary directory and print its filename.")
	- parser.add_option("--full-range", dest="FULL_RANGE", action="store_true", default=False,
	- help="Plot full y range in LogY plots.")
	- parser.add_option("-c", "--config", dest="CONFIGFILES", action="append", default=None,
	- help="Plot config file to be used. Overrides internal config blocks.")
	- verbgroup = OptionGroup(parser, "Verbosity control")
	- verbgroup.add_option("-v", "--verbose", action="store_const", const=logging.DEBUG, dest="LOGLEVEL",
	- default=logging.INFO, help="print debug (very verbose) messages")
	- verbgroup.add_option("-q", "--quiet", action="store_const", const=logging.WARNING, dest="LOGLEVEL",
	- default=logging.INFO, help="be very quiet")
	- parser.add_option_group(verbgroup)
	-
	- opts, args = parser.parse_args()
	- logging.basicConfig(level=opts.LOGLEVEL, format="%(message)s")
	- opts.OUTPUT_FORMAT = opts.OUTPUT_FORMAT.upper().split(",")
	-
	- ## Check for no args
	- if len(args) == 0:
	- logging.error(parser.get_usage())
	- sys.exit(2)
	-
	- ## Check that the files exist
	- for f in args:
	- if not os.access(f, os.R_OK):
	- print "Error: cannot read from %s" % f
	- sys.exit(1)
	-
	- ## Test for external programs (kpsewhich, latex, dvips, ps2pdf/ps2eps, and convert)
	- opts.LATEXPKGS = []
	- if opts.OUTPUT_FORMAT != ["TEX"]:
	- try:
	- ## latex
	- if not have_cmd("latex"):
	- logging.error("ERROR: required program 'latex' could not be found. Exiting...")
	- sys.exit(1)
	- ## dvips
	- if not have_cmd("dvips"):
	- logging.error("ERROR: required program 'dvips' could not be found. Exiting...")
	- sys.exit(1)
	-
	- ## ps2pdf / ps2eps
	- if "PDF" in opts.OUTPUT_FORMAT:
	- if not have_cmd("ps2pdf"):
	- logging.error("ERROR: required program 'ps2pdf' (for PDF output) could not be found. Exiting...")
	- sys.exit(1)
	- elif "EPS" in opts.OUTPUT_FORMAT:
	- if not have_cmd("ps2eps"):
	- logging.error("ERROR: required program 'ps2eps' (for EPS output) could not be found. Exiting...")
	- sys.exit(1)
	- ## PNG output converter
	- if "PNG" in opts.OUTPUT_FORMAT:
	- if not have_cmd("convert"):
	- logging.error("ERROR: required program 'convert' (for PNG output) could not be found. Exiting...")
	- sys.exit(1)
	-
	- ## kpsewhich: required for LaTeX package testing
	- if not have_cmd("kpsewhich"):
	- logging.warning("WARNING: required program 'kpsewhich' (for LaTeX package checks) could not be found")
	- else:
	- ## Check minion font
	- if opts.OUTPUT_FONT == "MINION":
	- p = subprocess.Popen(["kpsewhich", "minion.sty"], stdout=subprocess.PIPE)
	- p.wait()
	- if p.returncode != 0:
	- logging.warning('Warning: Using "--minion" requires minion.sty to be installed. Ignoring it.')
	- opts.OUTPUT_FONT = "PALATINO"
	-
	- ## Check for HEP LaTeX packages
	- # TODO: remove HEP-specifics/non-standards?
	- for pkg in ["hepnames", "hepunits", "underscore"]:
	- p = subprocess.Popen(["kpsewhich", "%s.sty" % pkg], stdout=subprocess.PIPE)
	- p.wait()
	- if p.returncode == 0:
	- opts.LATEXPKGS.append(pkg)
	-
	- ## Check for Palatino old style figures and small caps
	- if opts.OUTPUT_FONT == "PALATINO":
	- p = subprocess.Popen(["kpsewhich", "ot1pplx.fd"], stdout=subprocess.PIPE)
	- p.wait()
	- if p.returncode == 0:
	- opts.OUTPUT_FONT = "PALATINO_OSF"
	- except Exception, e:
	- logging.warning("Problem while testing for external packages. I'm going to try and continue without testing, but don't hold your breath...")
	-
	-
	- ## Set up signal handling
	- import signal
	- RECVD_KILL_SIGNAL = None
	- def handleKillSignal(signum, frame):
	- "Declare us as having been signalled, and return to default handling behaviour"
	- global RECVD_KILL_SIGNAL
	- logging.critical("Signal handler called with signal " + str(signum))
	- RECVD_KILL_SIGNAL = signum
	- signal.signal(signum, signal.SIG_DFL)
	- ## Signals to handle
	- # signal.signal(signal.SIGINT, handleKillSignal)
	- # signal.signal(signal.SIGTERM, handleKillSignal)
	- # signal.signal(signal.SIGHUP, handleKillSignal)
	- # signal.signal(signal.SIGUSR2, handleKillSignal)
	-
	- def init_worker():
	- signal.signal(signal.SIGINT, signal.SIG_IGN)
	-
	- ## Run threads
	- datfiles = args
	- plotword = "plots" if len(datfiles) > 1 else "plot"
	- logging.info("Making %d %s" % (len(datfiles), plotword))
	- import multiprocessing
	- pool = multiprocessing.Pool(opts.NUM_THREADS, init_worker)
	- try:
	- for i, _ in enumerate(pool.imap(process_datfile, datfiles)):
	- logging.info("Plotting %s (%d/%d remaining)" % (datfiles[i], len(datfiles)-i, len(datfiles)))
	- pool.close()
	- except KeyboardInterrupt:
	- print "Caught KeyboardInterrupt, terminating workers"
	- pool.terminate()
	- pool.join()
	+
	+ # if opts.NO_SUBPROC:
	+ # init_worker()
	+ # for i, df in enumerate(datfiles):
	+ # logging.info("Plotting %s (%d/%d remaining)" % (df, len(datfiles)-i, len(datfiles)))
	+ # process_datfile(df)
	+ # else:
	+ # pool = multiprocessing.Pool(opts.NUM_THREADS, init_worker)
	+ # try:
	+ # for i, _ in enumerate(pool.imap(process_datfile, datfiles)):
	+ # logging.info("Plotting %s (%d/%d remaining)" % (datfiles[i], len(datfiles)-i, len(datfiles)))
	+ # pool.close()
	+ # except KeyboardInterrupt:
	+ # print "Caught KeyboardInterrupt, terminating workers"
	+ # pool.terminate()
	+ # pool.join()
	diff --git a/bin/rivet b/bin/rivet
	--- a/bin/rivet
	+++ b/bin/rivet
	@@ -1,567 +1,657 @@
	#! /usr/bin/env python

	"""\
	Run Rivet analyses on inputted events from file or Unix pipe

	Examples:
	+
	%prog [options] <hepmcfile> [<hepmcfile2> ...]
	- my_generator -o myfifo & \ %prog [options] myfifo
	- agile-runmc <genname> -n 100k -o- \| %prog [options]
	+
	+ or
	+
	+ my_generator -o fifo.hepmc &
	+ %prog [options] fifo.hepmc
	+

	ENVIRONMENT:
	* RIVET_ANALYSIS_PATH: list of paths to be searched for plugin
	analysis libraries at runtime
	* RIVET_DATA_PATH: list of paths to be searched for data files
	"""

	import os, sys

	## Load the rivet module
	try:
	import rivet
	except:
	## If rivet loading failed, try to bootstrap the Python path!
	try:
	# TODO: Is this a good idea? Maybe just notify the user that their PYTHONPATH is wrong?
	import commands
	modname = sys.modules[__name__].__file__
	binpath = os.path.dirname(modname)
	rivetconfigpath = os.path.join(binpath, "rivet-config")
	rivetpypath = commands.getoutput(rivetconfigpath + " --pythonpath")
	sys.path.append(rivetpypath)
	import rivet
	except:
	sys.stderr.write("The rivet Python module could not be loaded: is your PYTHONPATH set correctly?\n")
	- sys.exit(1)
	+ sys.exit(5)

	rivet.util.check_python_version()
	rivet.util.set_process_name("rivet")

	import time, datetime, logging, signal

	## Parse command line options
	from optparse import OptionParser, OptionGroup
	parser = OptionParser(usage=__doc__, version="rivet v%s" % rivet.version())

	anagroup = OptionGroup(parser, "Analysis handling")
	anagroup.add_option("-a", "--analysis", "--analyses", dest="ANALYSES", action="append",
	default=[], metavar="ANA",
	help="add an analysis (or comma-separated list of analyses) to the processing list.")
	anagroup.add_option("--list-analyses", "--list", dest="LIST_ANALYSES", action="store_true",
	default=False, help="show the list of available analyses' names. With -v, it shows the descriptions, too")
	+anagroup.add_option("--list-keywords", "--keywords", dest="LIST_KEYWORDS", action="store_true",
	+ default=False, help="show the list of available keywords.")
	anagroup.add_option("--list-used-analyses", action="store_true", dest="LIST_USED_ANALYSES",
	default=False, help="list the analyses used by this command (after subtraction of inappropriate ones)")
	anagroup.add_option("--show-analysis", "--show-analyses", "--show", dest="SHOW_ANALYSES", action="append",
	default=[], help="show the details of an analysis")
	+anagroup.add_option("--show-bibtex", dest="SHOW_BIBTEX", action="store_true",
	+ default=False, help="show BibTeX entries for all used analyses")
	anagroup.add_option("--analysis-path", dest="ANALYSIS_PATH", metavar="PATH", default=None,
	help="specify the analysis search path (cf. $RIVET_ANALYSIS_PATH).")
	# TODO: remove/deprecate the append?
	anagroup.add_option("--analysis-path-append", dest="ANALYSIS_PATH_APPEND", metavar="PATH", default=None,
	help="append to the analysis search path (cf. $RIVET_ANALYSIS_PATH).")
	anagroup.add_option("--pwd", dest="ANALYSIS_PATH_PWD", action="store_true", default=False,
	help="append the current directory (pwd) to the analysis/data search paths (cf. $RIVET_ANALYSIS_PATH).")
	# TODO: add control for more paths?
	parser.add_option_group(anagroup)


	extragroup = OptionGroup(parser, "Extra run settings")
	-extragroup.add_option("-H", "--histo-file", dest="HISTOFILE",
	+extragroup.add_option("-o", "-H", "--histo-file", dest="HISTOFILE",
	default="Rivet.yoda", help="specify the output histo file path (default = %default)")
	+extragroup.add_option("--no-histo-file", dest="WRITE_DATA", action="store_false", default=True,
	+ help="don't write out any histogram file at the end of the run (default = write)")
	extragroup.add_option("-x", "--cross-section", dest="CROSS_SECTION",
	default=None, metavar="XS",
	help="specify the signal process cross-section in pb")
	extragroup.add_option("-n", "--nevts", dest="MAXEVTNUM", type="int",
	default=None, metavar="NUM",
	help="restrict the max number of events to process")
	extragroup.add_option("--nskip", dest="EVTSKIPNUM", type="int",
	default=0, metavar="NUM",
	help="skip NUM events read from input before beginning processing")
	extragroup.add_option("--runname", dest="RUN_NAME", default=None, metavar="NAME",
	help="give an optional run name, to be prepended as a 'top level directory' in histo paths")
	extragroup.add_option("--ignore-beams", dest="IGNORE_BEAMS", action="store_true", default=False,
	- help="Ignore input event beams when checking analysis compatibility. "
	- "Warning: analyses may not work correctly, or at all, with inappropriate beams")
	+ help="ignore input event beams when checking analysis compatibility. "
	+ "WARNING: analyses may not work correctly, or at all, with inappropriate beams")
	parser.add_option_group(extragroup)


	timinggroup = OptionGroup(parser, "Timeouts and periodic operations")
	timinggroup.add_option("--event-timeout", dest="EVENT_TIMEOUT", type="int",
	default=21600, metavar="NSECS",
	help="max time in whole seconds to wait for an event to be generated from the specified source (default = %default)")
	timinggroup.add_option("--run-timeout", dest="RUN_TIMEOUT", type="int",
	default=None, metavar="NSECS",
	help="max time in whole seconds to wait for the run to finish. This can be useful on batch systems such "
	"as the LCG Grid where tokens expire on a fixed wall-clock and can render long Rivet runs unable to write "
	"out the final histogram file (default = unlimited)")
	timinggroup.add_option("--histo-interval", dest="HISTO_WRITE_INTERVAL", type=int,
	- default=10000, help="[experimental!] specify the number of events between histogram file updates. "
	+ default=1000, help="specify the number of events between histogram file updates, default = %default. "
	"Set to 0 to only write out at the end of the run. Note that intermediate histograms will be those "
	"from the analyze step only: analysis finalizing is currently not executed until the end of the run.")
	parser.add_option_group(timinggroup)


	verbgroup = OptionGroup(parser, "Verbosity control")
	parser.add_option("-l", dest="NATIVE_LOG_STRS", action="append",
	default=[], help="set a log level in the Rivet library")
	verbgroup.add_option("-v", "--verbose", action="store_const", const=logging.DEBUG, dest="LOGLEVEL",
	default=logging.INFO, help="print debug (very verbose) messages")
	verbgroup.add_option("-q", "--quiet", action="store_const", const=logging.WARNING, dest="LOGLEVEL",
	default=logging.INFO, help="be very quiet")
	parser.add_option_group(verbgroup)
	opts, args = parser.parse_args()


	+## Override/modify analysis search path
	+if opts.ANALYSIS_PATH:
	+ rivet.setAnalysisLibPaths(opts.ANALYSIS_PATH.split(":"))
	+ rivet.setAnalysisDataPaths(opts.ANALYSIS_PATH.split(":"))
	+if opts.ANALYSIS_PATH_APPEND:
	+ for ap in opts.ANALYSIS_PATH_APPEND.split(":"):
	+ rivet.addAnalysisLibPath(ap)
	+ rivet.addAnalysisDataPath(ap)
	+if opts.ANALYSIS_PATH_PWD:
	+ rivet.addAnalysisLibPath(os.path.abspath("."))
	+ rivet.addAnalysisDataPath(os.path.abspath("."))
	+
	+
	## Configure logging
	logging.basicConfig(level=opts.LOGLEVEL, format="%(message)s")
	-
	-## Control native Rivet library logger
	for l in opts.NATIVE_LOG_STRS:
	name, level = None, None
	try:
	name, level = l.split("=")
	except:
	name = "Rivet"
	level = l
	## Fix name
	if name != "Rivet" and not name.startswith("Rivet."):
	name = "Rivet." + name
	try:
	## Get right error type
	level = rivet.LEVELS.get(level.upper(), None)
	logging.debug("Setting log level: %s %d" % (name, level))
	rivet.setLogLevel(name, level)
	except:
	logging.warning("Couldn't process logging string '%s'" % l)


	-## We allow comma-separated lists of analysis names -- normalise the list here
	-newanas = []
	-for a in opts.ANALYSES:
	- if "," in a:
	- newanas += a.split(",")
	- else:
	- newanas.append(a)
	-opts.ANALYSES = newanas

	+############################
	+## Listing available analyses/keywords

	-## Parse supplied cross-section
	-if opts.CROSS_SECTION is not None:
	- xsstr = opts.CROSS_SECTION
	- try:
	- opts.CROSS_SECTION = float(xsstr)
	- except:
	- import re
	- suffmatch = re.search(r"[^\d.]", xsstr)
	- if not suffmatch:
	- raise ValueError("Bad cross-section string: %s" % xsstr)
	- factor = base = None
	- suffstart = suffmatch.start()
	- if suffstart != -1:
	- base = xsstr[:suffstart]
	- suffix = xsstr[suffstart:].lower()
	- if suffix == "mb":
	- factor = 1e+9
	- elif suffix == "mub":
	- factor = 1e+6
	- elif suffix == "nb":
	- factor = 1e+3
	- elif suffix == "pb":
	- factor = 1
	- elif suffix == "fb":
	- factor = 1e-3
	- elif suffix == "ab":
	- factor = 1e-6
	- if factor is None or base is None:
	- raise ValueError("Bad cross-section string: %s" % xsstr)
	- xs = float(base) * factor
	- opts.CROSS_SECTION = xs

	+def getAnalysesByKeyword(alist, kstring):
	+ add, veto, ret = [], [], []
	+ bits = [i for i in kstring.replace("^@", "@^").split("@") if len(i) > 0]
	+ for b in bits:
	+ if b.startswith("^"):
	+ veto.append(b.strip("^"))
	+ else:
	+ add.append(b)

	-## Print the available CLI options!
	-#if opts.LIST_OPTIONS:
	-# for o in parser.option_list:
	-# print o.get_opt_string()
	-# sys.exit(0)
	+ add = set(add)
	+ veto = set(veto)

	-
	-## Set up signal handling
	-RECVD_KILL_SIGNAL = None
	-def handleKillSignal(signum, frame):
	- "Declare us as having been signalled, and return to default handling behaviour"
	- global RECVD_KILL_SIGNAL
	- logging.critical("Signal handler called with signal " + str(signum))
	- RECVD_KILL_SIGNAL = signum
	- signal.signal(signum, signal.SIG_DFL)
	-## Signals to handle
	-signal.signal(signal.SIGTERM, handleKillSignal);
	-signal.signal(signal.SIGHUP, handleKillSignal);
	-signal.signal(signal.SIGINT, handleKillSignal);
	-signal.signal(signal.SIGUSR1, handleKillSignal);
	-signal.signal(signal.SIGUSR2, handleKillSignal);
	-try:
	- signal.signal(signal.SIGXCPU, handleKillSignal);
	-except:
	- pass
	-
	-
	-## Override/modify analysis search path
	-if opts.ANALYSIS_PATH:
	- rivet.setAnalysisLibPaths(opts.ANALYSIS_PATH.split(":"))
	-if opts.ANALYSIS_PATH_APPEND:
	- for ap in opts.ANALYSIS_PATH_APPEND.split(":"):
	- rivet.addAnalysisLibPath(ap)
	-if opts.ANALYSIS_PATH_PWD:
	- rivet.addAnalysisLibPath(".")
	+ for a in alist:
	+ kwds = set([i.lower() for i in rivet.AnalysisLoader.getAnalysis(a).keywords()])
	+ if kwds.intersection(veto) and len(kwds.intersection(add)) == len(list(add)):
	+ ret.append(a)
	+ return ret


	## List of analyses
	all_analyses = rivet.AnalysisLoader.analysisNames()
	if opts.LIST_ANALYSES:
	## Treat args as case-insensitive regexes if present
	regexes = None
	if args:
	import re
	regexes = [re.compile(arg, re.I) for arg in args]
	try:
	# import tempfile, subprocess
	# tf, tfpath = tempfile.mkstemp(prefix="rivet-list.")
	for aname in all_analyses:
	if not regexes:
	toshow = True
	else:
	toshow = False
	for regex in regexes:
	if regex.search(aname):
	toshow = True
	break
	if toshow:
	msg = aname
	if opts.LOGLEVEL <= logging.INFO:
	a = rivet.AnalysisLoader.getAnalysis(aname)
	st = "" if a.status() == "VALIDATED" else ("[" + a.status() + "] ")
	msg = "%-25s %s" % (aname, st + rivet.util.detex(a.summary()))
	+ if opts.LOGLEVEL < logging.INFO:
	+ if a.keywords():
	+ msg += " [" + " ".join(a.keywords()) + "]"
	+ if a.luminosityfb():
	+ msg += " [ \int L = %s fb^{-1} ]"%a.luminosityfb()
	print msg
	#os.write(tf, msg + "\n")
	# if os.path.getsize(tfpath) > 0:
	# pager = subprocess.Popen(["less", "-FX", tfpath]) #, stdin=subprocess.PIPE)
	# pager.communicate()
	finally:
	# os.unlink(tfpath) #< always clean up
	pass
	sys.exit(0)


	+def getKeywords(alist):
	+ all_keywords = []
	+ for a in alist:
	+ all_keywords.extend(rivet.AnalysisLoader.getAnalysis(a).keywords())
	+ all_keywords = [i.lower() for i in all_keywords]
	+ return sorted(list(set(all_keywords)))
	+
	+
	+## List keywords
	+if opts.LIST_KEYWORDS:
	+ # a = rivet.AnalysisLoader.getAnalysis(aname)
	+ for k in getKeywords(all_analyses):
	+ print k
	+ sys.exit(0)
	+
	+
	## Show analyses' details
	if len(opts.SHOW_ANALYSES) > 0:
	toshow = []
	for i, a in enumerate(opts.SHOW_ANALYSES):
	a_up = a.upper()
	if a_up in all_analyses and a_up not in toshow:
	toshow.append(a_up)
	else:
	## Treat as a case-insensitive regex
	import re
	regex = re.compile(a, re.I)
	for ana in all_analyses:
	if regex.search(ana) and a_up not in toshow:
	toshow.append(ana)

	msgs = []
	for i, name in enumerate(sorted(toshow)):
	import textwrap
	ana = rivet.AnalysisLoader.getAnalysis(name)

	msg = ""
	msg += name + "\n"
	msg += (len(name) * "=") + "\n\n"
	msg += rivet.util.detex(ana.summary()) + "\n\n"
	msg += "Status: " + ana.status() + "\n\n"

	# TODO: reduce to only show Inspire in v3
	if ana.inspireId():
	msg += "Inspire ID: " + ana.inspireId() + "\n"
	msg += "Inspire URL: http://inspire-hep.net/record/" + ana.inspireId() + "\n"
	msg += "HepData URL: http://hepdata.cedar.ac.uk/view/ins" + ana.inspireId() + "\n"
	elif ana.spiresId():
	msg += "Spires ID: " + ana.spiresId() + "\n"
	msg += "Inspire URL: http://inspire-hep.net/search?p=find+key+" + ana.spiresId() + "\n"
	msg += "HepData URL: http://hepdata.cedar.ac.uk/view/irn" + ana.spiresId() + "\n"

	if ana.experiment():
	msg += "Experiment: " + ana.experiment()
	if ana.collider():
	msg += "(%s)" % ana.collider()
	msg += "\n"

	if ana.year():
	msg += "Year of publication: " + ana.year() + "\n"

	msg += "Authors:\n"
	for a in ana.authors():
	msg += " " + a + "\n"
	msg += "\n"

	msg += "Description:\n"
	twrap = textwrap.TextWrapper(width=75, initial_indent=2" ", subsequent_indent=2" ")
	msg += twrap.fill(rivet.util.detex(ana.description())) + "\n\n"

	# TODO: move this formatting into Analysis or a helper function?
	if ana.requiredBeams():
	def pid_to_str(pid):
	if pid == 11:
	return "e-"
	elif pid == -11:
	return "e+"
	elif pid == 2212:
	return "p+"
	elif pid == -2212:
	return "p-"
	elif pid == 10000:
	return "*"
	else:
	return str(pid)
	beamstrs = []
	for bp in ana.requiredBeams():
	beamstrs.append(pid_to_str(bp[0]) + " " + pid_to_str(bp[1]))
	msg += "Beams:" + ", ".join(beamstrs) + "\n"

	if ana.requiredEnergies():
	- msg += "Beam energies: %s GeV\n" + "; ".join(["(%0.1f, %0.1f)" % (epair[0], epair[1]) for epair in ana.requiredEnergies()])
	+ msg += "Beam energies:" + "; ".join(["(%0.1f, %0.1f) GeV\n" % (epair[0], epair[1]) for epair in ana.requiredEnergies()])
	else:
	msg += "Beam energies: ANY\n"

	if ana.runInfo():
	msg += "Run details:\n"
	twrap = textwrap.TextWrapper(width=75, initial_indent=2" ", subsequent_indent=4" ")
	for l in ana.runInfo().split("\n"):
	msg += twrap.fill(l) + "\n"

	+ if ana.luminosityfb():
	+ msg+= "\nIntegrated data luminosity = %s inverse fb.\n"%ana.luminosityfb()
	+
	+ if ana.keywords():
	+ msg += "\nAnalysis keywords:"
	+ for k in ana.keywords():
	+ msg += " %s"%k
	+ msg+= "\n\n"
	+
	if ana.references():
	- msg += "\n" + "References:"
	+ msg += "\n" + "References:\n"
	for r in ana.references():
	url = None
	if r.startswith("arXiv:"):
	code = r.split()[0].replace("arXiv:", "")
	url = "http://arxiv.org/abs/" + code
	elif r.startswith("doi:"):
	code = r.replace("doi:", "")
	url = "http://dx.doi.org/" + code
	if url is not None:
	r += " - " + url
	msg += " " + r + "\n"

	## Add to the output
	msgs.append(msg)

	-
	## Write the combined messages to a temporary file and page it
	if msgs:
	try:
	import tempfile, subprocess
	tffd, tfpath = tempfile.mkstemp(prefix="rivet-show.")
	os.write(tffd, "\n\n".join(msgs))
	if sys.stdout.isatty():
	pager = subprocess.Popen(["less", "-FX", tfpath]) #, stdin=subprocess.PIPE)
	pager.communicate()
	else:
	f = open(tfpath)
	print f.read()
	f.close()
	finally:
	os.unlink(tfpath) #< always clean up
	sys.exit(0)


	+
	+############################
	+## Actual analysis runs
	+
	+
	+
	+## We allow comma-separated lists of analysis names -- normalise the list here
	+newanas = []
	+for a in opts.ANALYSES:
	+ if "," in a:
	+ newanas += a.split(",")
	+ elif "@" in a: #< NB. this bans combination of ana lists and keywords in a single arg
	+ temp = getAnalysesByKeyword(all_analyses, a)
	+ for i in temp:
	+ newanas.append(i)
	+ else:
	+ newanas.append(a)
	+opts.ANALYSES = newanas
	+
	+
	+## Parse supplied cross-section
	+if opts.CROSS_SECTION is not None:
	+ xsstr = opts.CROSS_SECTION
	+ try:
	+ opts.CROSS_SECTION = float(xsstr)
	+ except:
	+ import re
	+ suffmatch = re.search(r"[^\d.]", xsstr)
	+ if not suffmatch:
	+ raise ValueError("Bad cross-section string: %s" % xsstr)
	+ factor = base = None
	+ suffstart = suffmatch.start()
	+ if suffstart != -1:
	+ base = xsstr[:suffstart]
	+ suffix = xsstr[suffstart:].lower()
	+ if suffix == "mb":
	+ factor = 1e+9
	+ elif suffix == "mub":
	+ factor = 1e+6
	+ elif suffix == "nb":
	+ factor = 1e+3
	+ elif suffix == "pb":
	+ factor = 1
	+ elif suffix == "fb":
	+ factor = 1e-3
	+ elif suffix == "ab":
	+ factor = 1e-6
	+ if factor is None or base is None:
	+ raise ValueError("Bad cross-section string: %s" % xsstr)
	+ xs = float(base) * factor
	+ opts.CROSS_SECTION = xs
	+
	+
	+## Print the available CLI options!
	+#if opts.LIST_OPTIONS:
	+# for o in parser.option_list:
	+# print o.get_opt_string()
	+# sys.exit(0)
	+
	+
	+## Set up signal handling
	+RECVD_KILL_SIGNAL = None
	+def handleKillSignal(signum, frame):
	+ "Declare us as having been signalled, and return to default handling behaviour"
	+ global RECVD_KILL_SIGNAL
	+ logging.critical("Signal handler called with signal " + str(signum))
	+ RECVD_KILL_SIGNAL = signum
	+ signal.signal(signum, signal.SIG_DFL)
	+## Signals to handle
	+signal.signal(signal.SIGTERM, handleKillSignal);
	+signal.signal(signal.SIGHUP, handleKillSignal);
	+signal.signal(signal.SIGINT, handleKillSignal);
	+signal.signal(signal.SIGUSR1, handleKillSignal);
	+signal.signal(signal.SIGUSR2, handleKillSignal);
	+try:
	+ signal.signal(signal.SIGXCPU, handleKillSignal);
	+except:
	+ pass
	+
	+
	+
	## Identify HepMC files/streams
	## TODO: check readability, deal with stdin
	if len(args) > 0:
	HEPMCFILES = args
	else:
	HEPMCFILES = ["-"]


	## Event number logging
	def logNEvt(n, starttime, maxevtnum):
	if n % 10000 == 0:
	nevtloglevel = logging.CRITICAL
	elif n % 1000 == 0:
	nevtloglevel = logging.WARNING
	elif n % 100 == 0:
	nevtloglevel = logging.INFO
	else:
	nevtloglevel = logging.DEBUG
	currenttime = datetime.datetime.now().replace(microsecond=0)
	elapsedtime = currenttime - starttime
	logging.log(nevtloglevel, "Event %d (%s elapsed)" % (n, str(elapsedtime)))
	# if maxevtnum is None:
	# logging.log(nevtloglevel, "Event %d (%s elapsed)" % (n, str(elapsedtime)))
	# else:
	# remainingtime = (maxevtnum-n) * elapsedtime.total_seconds() / float(n)
	# eta = time.strftime("%a %b %d %H:%M", datetime.localtime(currenttime + remainingtime))
	# logging.log(nevtloglevel, "Event %d (%d s elapsed / %d s left) -> ETA: %s" %
	# (n, elapsedtime, remainingtime, eta))


	## Do some checks on output histo file, before we stat the event loop
	histo_parentdir = os.path.dirname(os.path.abspath(opts.HISTOFILE))
	-
	if not os.path.exists(histo_parentdir):
	logging.error('Parent path of output histogram file does not exist: %s\nExiting.' % histo_parentdir)
	- sys.exit(1)
	-
	+ sys.exit(4)
	if not os.access(histo_parentdir,os.W_OK):
	logging.error('Insufficient permissions to write output histogram file to directory %s\nExiting.' % histo_parentdir)
	- sys.exit(1)
	+ sys.exit(4)


	## Set up analysis handler
	RUNNAME = opts.RUN_NAME or ""
	ah = rivet.AnalysisHandler(RUNNAME)
	ah.setIgnoreBeams(opts.IGNORE_BEAMS)
	for a in opts.ANALYSES:
	## Print warning message and exit if not a valid analysis name
	if not a in all_analyses:
	logging.warning("'%s' is not a known Rivet analysis! Do you need to set RIVET_ANALYSIS_PATH or use the --pwd switch?\n" % a)
	# TODO: lay out more neatly, or even try for a "did you mean XXXX?" heuristic?
	logging.warning("There are %d currently available analyses:\n" % len(all_analyses) + ", ".join(all_analyses))
	sys.exit(1)
	logging.debug("Adding analysis '%s'" % a)
	ah.addAnalysis(a)

	+
	+if opts.SHOW_BIBTEX:
	+ bibs = []
	+ for aname in sorted(ah.analysisNames()):
	+ ana = rivet.AnalysisLoader.getAnalysis(aname)
	+ bibs.append("% " + aname + "\n" + ana.bibTeX())
	+ if bibs:
	+ print "\nBibTeX for used Rivet analyses:\n"
	+ print "% --------------------------\n"
	+ print "\n\n".join(bibs) + "\n"
	+ print "% --------------------------\n"
	+
	+
	## Read and process events
	run = rivet.Run(ah)
	if opts.CROSS_SECTION is not None:
	logging.info("User-supplied cross-section = %e pb" % opts.CROSS_SECTION)
	run.setCrossSection(opts.CROSS_SECTION)
	if opts.LIST_USED_ANALYSES is not None:
	run.setListAnalyses(opts.LIST_USED_ANALYSES)

	## Print platform type
	import platform
	starttime = datetime.datetime.now().replace(microsecond=0)
	logging.info("Rivet %s running on machine %s (%s) at %s" % \
	(rivet.version(), platform.node(), platform.machine(), str(starttime)))


	def min_nonnull(a, b):
	"A version of min which considers None to always be greater than a real number"
	rtn = min(a, b)
	if rtn is not None:
	return rtn
	if a is not None:
	return a
	return b


	## Set up an event timeout handler
	class TimeoutException(Exception):
	pass
	if opts.EVENT_TIMEOUT or opts.RUN_TIMEOUT:
	def evttimeouthandler(signum, frame):
	logging.warn("It has taken more than %d secs to get an event! Is the input event stream working?" %
	min_nonnull(opts.EVENT_TIMEOUT, opts.RUN_TIMEOUT))
	raise TimeoutException("Event timeout")
	signal.signal(signal.SIGALRM, evttimeouthandler)


	## Init run based on one event
	hepmcfile = HEPMCFILES[0]
	## Apply a file-level weight derived from the filename
	hepmcfileweight = 1.0
	if ":" in hepmcfile:
	hepmcfile, hepmcfileweight = hepmcfile.rsplit(":", 1)
	hepmcfileweight = float(hepmcfileweight)
	try:
	if opts.EVENT_TIMEOUT or opts.RUN_TIMEOUT:
	signal.alarm(min_nonnull(opts.EVENT_TIMEOUT, opts.RUN_TIMEOUT))
	init_ok = run.init(hepmcfile, hepmcfileweight)
	signal.alarm(0)
	if not init_ok:
	logging.error("Failed to initialise using event file '%s'... exiting" % hepmcfile)
	sys.exit(2)
	except TimeoutException, te:
	logging.error("Timeout in initialisation from event file '%s'... exiting" % hepmcfile)
	sys.exit(3)


	## Event loop
	evtnum = 0
	for fileidx, hepmcfile in enumerate(HEPMCFILES):
	## Apply a file-level weight derived from the filename
	hepmcfileweight = 1.0
	if ":" in hepmcfile:
	hepmcfile, hepmcfileweight = hepmcfile.rsplit(":", 1)
	hepmcfileweight = float(hepmcfileweight)

	## Open next HepMC file (NB. this doesn't apply to the first file: it was already used for the run init)
	if fileidx > 0:
	run.openFile(hepmcfile, hepmcfileweight)
	if not run.readEvent():
	logging.warning("Could not read events from '%s'" % hepmcfile)
	continue

	## Announce new file
	msg = "Reading events from '%s'" % hepmcfile
	if hepmcfileweight != 1.0:
	msg += " (file weight = %e)" % hepmcfileweight
	logging.info(msg)

	## The event loop
	- while opts.MAXEVTNUM is None or evtnum-opts.EVTSKIPNUM <= opts.MAXEVTNUM:
	+ while opts.MAXEVTNUM is None or evtnum-opts.EVTSKIPNUM < opts.MAXEVTNUM:
	evtnum += 1

	## Optional event skipping
	if evtnum <= opts.EVTSKIPNUM:
	+ logging.debug("Skipping event #%i" % evtnum)
	+ run.skipEvent();
	continue

	## Only log the event number once we're actually processing
	logNEvt(evtnum, starttime, opts.MAXEVTNUM)

	## Process this event
	processed_ok = run.processEvent()
	if not processed_ok:
	logging.warn("Event processing failed for evt #%i!" % evtnum)
	break

	## Set flag to exit event loop if run timeout exceeded
	if opts.RUN_TIMEOUT and (time.time() - starttime) > opts.RUN_TIMEOUT:
	logging.warning("Run timeout of %d secs exceeded... exiting gracefully" % opts.RUN_TIMEOUT)
	RECVD_KILL_SIGNAL = True

	## Exit the loop if signalled
	if RECVD_KILL_SIGNAL is not None:
	break

	## Read next event (with timeout handling if requested)
	try:
	if opts.EVENT_TIMEOUT:
	signal.alarm(opts.EVENT_TIMEOUT)
	read_ok = run.readEvent()
	signal.alarm(0)
	if not read_ok:
	break
	except TimeoutException, te:
	logging.error("Timeout in reading event from '%s'... exiting" % hepmcfile)
	sys.exit(3)

	## Write a histo file snapshot if appropriate
	if opts.HISTO_WRITE_INTERVAL is not None and opts.HISTO_WRITE_INTERVAL > 0:
	if evtnum % opts.HISTO_WRITE_INTERVAL == 0:
	ah.writeData(opts.HISTOFILE)


	## Print end-of-loop messages
	loopendtime = datetime.datetime.now().replace(microsecond=0)
	logging.info("Finished event loop at %s" % str(loopendtime))
	logging.info("Cross-section = %e pb" % ah.crossSection())
	print


	## Finalize and write out data file
	run.finalize()
	-ah.writeData(opts.HISTOFILE)
	+if opts.WRITE_DATA:
	+ ah.writeData(opts.HISTOFILE)
	print
	endtime = datetime.datetime.now().replace(microsecond=0)
	logging.info("Rivet run completed at %s, time elapsed = %s" % (str(endtime), str(endtime-starttime)))
	print
	logging.info("Histograms written to %s" % os.path.abspath(opts.HISTOFILE))
	diff --git a/bin/rivet-buildplugin.in b/bin/rivet-buildplugin.in
	--- a/bin/rivet-buildplugin.in
	+++ b/bin/rivet-buildplugin.in
	@@ -1,148 +1,150 @@
	#!/usr/bin/env bash
	## -- sh --
	## @configure_input@

	-## Print help
	+## Get program name
	PROG=$(basename $0)
	-tmp=$(echo $* \| egrep -- '--\<help\>\|-\<h\>')
	-if test $# -lt 1 \|\| test -n "$tmp"; then
	+
	+## Print help message
	+tmp=$(echo "$*" \| egrep -- '--\<help\>\|-\<h\>')
	+if test -n "$tmp"; then # \|\| test $# -lt 1
	echo "$PROG: compilation helper for Rivet analysis plugins"
	echo
	echo "Usage: $PROG [<libname>] <source1> [<source2> [compiler_flags] ...]"
	echo
	echo "<libname> can be a path, provided the filename is of the form 'Rivet*.so'"
	echo "If <libname> is not specified, the default name is 'RivetAnalysis.so'."
	echo
	echo "To make special build variations you can add appropriate compiler flags"
	echo "to the arguments and these will be passed directly to the compiler. For"
	echo "example, for a debug build of your plugin library, add '-g', and for a"
	echo "32 bit build on a 64 bit system add '-m32'."
	echo
	echo "Options:"
	echo " -h \| --help: display this help message"
	echo " --with-root: add ROOT link options (requires root-config on system)"
	+ echo " --cmd\|--dry-run: just print the generated compiler command, do not execute"
	echo
	echo "TODO:"
	echo " * is there a GCC option to parallelise the single-command compilation?"
	test -n "$tmp"
	exit $?
	fi

	## These variables need to exist
	## Note no use of $DESTDIR... we ignore it so that destdir can be used
	## for temp installs later copied to /
	prefix=@prefix@
	exec_prefix=@exec_prefix@
	datarootdir=@datarootdir@

	## Work out shared library build flags by platform
	shared_flags=
	SWVERS=$(which sw_vers 2> /dev/null)
	if test "$SWVERS" && test -x "$SWVERS"; then
	## Mac OS X
	shared_flags="-undefined dynamic_lookup -bundle"
	else
	## Unix
	shared_flags="-shared -fPIC"
	fi

	## Get Rivet system C++ compiler (fall back to $CXX and then g++ if needed)
	mycxx=g++
	-rivetcxx=$(which "@RIVETCXX@" 2> /dev/null)
	+rivetcxx=$(which $(echo "@RIVETCXX@" \| awk '{print $1}') 2> /dev/null)
	abscxx=$(which "$CXX" 2> /dev/null)
	if [[ -x "$rivetcxx" ]]; then
	mycxx="@CXX@"
	elif [[ -x "$abscxx" ]]; then
	mycxx=$CXX
	fi

	## Get Rivet system C++ compiler flags
	mycxxflags=""
	if [[ -n "@AM_CXXFLAGS@" ]]; then
	mycxxflags="@AM_CXXFLAGS@"
	fi
	if [[ -n "@RIVETCXXFLAGS@" ]]; then
	mycxxflags="$mycxxflags @RIVETCXXFLAGS@"
	fi

	## Get Rivet system C preprocessor flags (duplicating that in rivet-config.in)
	mycppflags=""
	prefix="@prefix@"
	exec_prefix="@exec_prefix@"
	irivet="@includedir@"
	test -n "$irivet" && mycppflags="$mycppflags -I${irivet}"
	ihepmc="@HEPMCINCPATH@"
	test -n "$ihepmc" && mycppflags="$mycppflags -I${ihepmc}"
	iyoda="@YODAINCPATH@"
	test -n "$iyoda" && mycppflags="$mycppflags -I${iyoda}"
	ifastjet="@FASTJETINCPATH@"
	test -n "$ifastjet" && mycppflags="$mycppflags -I${ifastjet}"
	igsl="@GSLINCPATH@"
	test -n "$igsl" && mycppflags="$mycppflags -I${igsl}"
	# iboost="@BOOST_CPPFLAGS@"
	# test -n "$iboost" && mycppflags="$mycppflags ${iboost}"


	## Get Rivet system linker flags (duplicating that in rivet-config.in)
	myldflags=""
	lrivet="@libdir@"
	test -n "$lrivet" && myldflags="$myldflags -L${lrivet}"
	lhepmc="@HEPMCLIBPATH@"
	test -n "$lhepmc" && myldflags="$myldflags -L${lhepmc}"
	lyoda="@YODALIBPATH@"
	test -n "$lyoda" && myldflags="$myldflags -L${lyoda}"
	lfastjet="@FASTJETCONFIGLIBADD@"
	test -n "$lfastjet" && myldflags="$myldflags ${lfastjet}"
	## Detect whether the linker accepts the --no-as-needed flag and prepend the linker flag with it if possible
	if (cd /tmp && echo -e 'int main() { return 0; }' > $$.cc; $mycxx -Wl,--no-as-needed $$.cc -o $$ 2> /dev/null); then
	myldflags="-Wl,--no-as-needed $myldflags"
	fi


	## Link against ROOT if requested
	-with_root=$(echo $* \| egrep -- '--\<with-root\>')
	+with_root=$(echo "$*" \| egrep -- '--\<with-root\>')
	# echo $with_root
	-tmp=${@//--with-root/}
	-set $tmp #< Set positional params
	-
	+tmp=$(echo "$*" \| sed -e 's/--with-root//g')

	## Just show the compiler command rather than execute it, if requested
	-only_show=$(echo $* \| egrep -- '--\<cmd\>') #-\<n\>')
	+only_show=$(echo "$tmp" \| egrep -- '--\<cmd\>\|--\<dry-run\>')
	# echo $only_show
	-tmp=${@//--cmd/}
	-set $tmp #< Set positional params
	+tmp=$(echo "$tmp" \| sed -e 's/--cmd//g' -e 's/--dry-run//g')

	+## Reset positional params now that flags have been removed
	+set -- $tmp #< NB. protection against empty $tmp arg!!

	## Get and check the library name
	libname=$1
	match1=$(basename "$libname" \| egrep '^.*\.so')
	match2=$(basename "$libname" \| egrep '^Rivet.*\.so')
	if test -n "$match1"; then
	if test -z "$match2"; then
	echo "Library name '$libname' does not have the required 'Rivet*.so' name pattern" 1>&2
	exit 1
	fi
	## If we're using the first arg as the library name, shift it off the positional list
	shift
	else
	if [[ -z $only_show ]]; then
	echo "Using default library name 'RivetAnalysis.so'"
	fi
	libname="RivetAnalysis.so"
	fi


	## Get the source files (and more flags)
	-sources_and_flags="$@ -lRivet"
	+sources_and_flags="$* -lRivet"
	if [[ -n $with_root ]]; then
	root_flags=$(root-config --libs --cflags 2> /dev/null)
	# echo $root_flags
	sources_and_flags="$root_flags $sources_and_flags"
	fi

	## Build
	cmd="$mycxx -o \"$libname\" $shared_flags $mycppflags $mycxxflags $myldflags $sources_and_flags"
	echo $cmd
	if [[ -z $only_show ]]; then
	eval $cmd
	fi
	diff --git a/bin/rivet-cmphistos b/bin/rivet-cmphistos
	--- a/bin/rivet-cmphistos
	+++ b/bin/rivet-cmphistos
	@@ -1,470 +1,474 @@
	#! /usr/bin/env python

	"""\
	%prog - generate histogram comparison plots

	USAGE:
	%prog [options] yodafile1[:'PlotOption1=Value':'PlotOption2=Value':...] [path/to/yodafile2 ...] [PLOT:Key1=Val1:...]

	where the plot options are described in the make-plots manual in the HISTOGRAM
	section.

	ENVIRONMENT:
	* RIVET_ANALYSIS_PATH: list of paths to be searched for plugin
	analysis libraries at runtime
	* RIVET_DATA_PATH: list of paths to be searched for data files
	"""

	import rivet, yoda, sys, os
	rivet.util.check_python_version()
	rivet.util.set_process_name(os.path.basename(__file__))


	class Plot(dict):
	"A tiny Plot object to help writing out the head in the .dat file"
	def __repr__(self):
	return "# BEGIN PLOT\n" + "\n".join("%s=%s" % (k,v) for k,v in self.iteritems()) + "\n# END PLOT\n\n"


	def sanitiseString(s):
	#s = s.replace('_','\\_')
	#s = s.replace('^','\\^{}')
	#s = s.replace('$','\\$')
	s = s.replace('#','\\#')
	s = s.replace('%','\\%')
	return s


	def getCommandLineOptions():
	"Parse command line options"
	from optparse import OptionParser, OptionGroup
	parser = OptionParser(usage=__doc__)

	parser.add_option('-o', '--outdir', dest='OUTDIR',
	default='.', help='write data files into this directory')
	parser.add_option("--hier-out", action="store_true", dest="HIER_OUTPUT", default=False,
	help="write output dat files into a directory hierarchy which matches the analysis paths")
	parser.add_option('--plotinfodir', dest='PLOTINFODIRS', action='append',
	default=['.'], help='directory which may contain plot header information (in addition '
	'to standard Rivet search paths)')
	parser.add_option("--no-rivet-refs", dest="RIVETREFS", action="store_false",
	default=True, help="don't use Rivet reference data files")
	# parser.add_option("--refid", dest="REF_ID",
	# default="REF", help="ID of reference data set (file path for non-REF data)")
	parser.add_option("--reftitle", dest="REFTITLE",
	default='Data', help="Reference data legend entry")
	parser.add_option("--pwd", dest="PATH_PWD", action="store_true", default=False,
	- help="append the current directory (pwd) to the analysis/data search paths (cf. $RIVET_ANALYSIS_PATH).")
	+ help="append the current directory (pwd) to the analysis/data search paths (cf. $RIVET_ANALYSIS/DATA_PATH)")
	+ parser.add_option("-v", "--verbose", dest="VERBOSE", action="store_true", default=False,
	+ help="produce debug output to the terminal")

	stygroup = OptionGroup(parser, "Plot style")
	stygroup.add_option("--linear", action="store_true", dest="LINEAR",
	default=False, help="plot with linear scale")
	stygroup.add_option("--mc-errs", action="store_true", dest="MC_ERRS",
	default=False, help="show vertical error bars on the MC lines")
	stygroup.add_option("--no-ratio", action="store_false", dest="RATIO",
	default=True, help="disable the ratio plot")
	stygroup.add_option("--rel-ratio", action="store_true", dest="RATIO_DEVIATION",
	default=False, help="show the ratio plots scaled to the ref error")
	stygroup.add_option("--no-plottitle", action="store_true", dest="NOPLOTTITLE",
	default=False, help="don't show the plot title on the plot "
	"(useful when the plot description should only be given in a caption)")
	stygroup.add_option("--style", dest="STYLE", default="default",
	help="change plotting style: default\|bw\|talk")
	stygroup.add_option("-c", "--config", dest="CONFIGFILES", action="append", default=["~/.make-plots"],
	help="additional plot config file(s). Settings will be included in the output configuration.")
	parser.add_option_group(stygroup)

	selgroup = OptionGroup(parser, "Selective plotting")
	# selgroup.add_option("--show-single", dest="SHOW_SINGLE", choices=("no", "ref", "mc", "all"),
	# default="mc", help="control if a plot file is made if there is only one dataset to be plotted "
	# "[default=%default]. If the value is 'no', single plots are always skipped, for 'ref' and 'mc', "
	# "the plot will be written only if the single plot is a reference plot or an MC "
	# "plot respectively, and 'all' will always create single plot files.\n The 'ref' and 'all' values "
	# "should be used with great care, as they will also write out plot files for all reference "
	# "histograms without MC traces: combined with the -R/--rivet-refs flag, this is a great way to "
	# "write out several thousand irrelevant reference data histograms!")
	# selgroup.add_option("--show-mc-only", "--all", action="store_true", dest="SHOW_IF_MC_ONLY",
	# default=False, help="make a plot file even if there is only one dataset to be plotted and "
	# "it is an MC one. Deprecated and will be removed: use --show-single instead, which overrides this.")
	# # selgroup.add_option("-l", "--histogram-list", dest="HISTOGRAMLIST",
	# # default=None, help="specify a file containing a list of histograms to plot, in the format "
	# # "/ANALYSIS_ID/histoname, one per line, e.g. '/DELPHI_1996_S3430090/d01-x01-y01'.")
	selgroup.add_option("-m", "--match", action="append",
	help="only write out histograms whose $path/$name string matches these regexes. The argument "
	"may also be a text file.",
	dest="PATHPATTERNS")
	selgroup.add_option("-M", "--unmatch", action="append",
	help="exclude histograms whose $path/$name string matches these regexes",
	dest="PATHUNPATTERNS")
	parser.add_option_group(selgroup)

	return parser


	def getHistos(filelist):
	"""Loop over all input files. Only use the first occurrence of any REF-histogram
	and the first occurrence in each MC file for every MC-histogram."""
	refhistos, mchistos = {}, {}
	for infile in filelist:
	mchistos.setdefault(infile, {})
	analysisobjects = yoda.read(infile, patterns=opts.PATHPATTERNS, unpatterns=opts.PATHUNPATTERNS)
	+ #print analysisobjects
	for path, ao in analysisobjects.iteritems():
	## We can't plot non-histograms yet
	# TODO: support counter plotting with a faked x (or y) position and forced plot width/height
	if ao.type not in ("Histo1D", "Histo2D", "Profile1D", "Profile2D", "Scatter2D", "Scatter3D"):
	continue

	## Make a path object and ensure the path is in standard form
	try:
	aop = rivet.AOPath(path)
	except Exception, e:
	#print e
	print "Found analysis object with non-standard path structure:", path, "... skipping"
	continue

	## We don't plot data objects with path components hidden by an underscore prefix
	if aop.istmp():
	continue

	## Add it to the ref or mc paths, if this path isn't already known
	basepath = aop.basepath(keepref=False)
	if aop.isref() and not refhistos.has_key(basepath):
	ao.path = aop.varpath(keepref=False, defaultvarid=0)
	refhistos[basepath] = ao
	else: #if not mchistos[infile].has_key(basepath):
	mchistos[infile].setdefault(basepath, {})[aop.varid(0)] = ao

	return refhistos, mchistos


	def getRivetRefData(anas=None):
	"Find all Rivet reference data files"
	refhistos = {}
	rivet_data_dirs = rivet.getAnalysisRefPaths()
	dirlist = []
	for d in rivet_data_dirs:
	if anas is None:
	import glob
	dirlist.append(glob.glob(os.path.join(d, '*.yoda')))
	else:
	dirlist.append([os.path.join(d, a+'.yoda') for a in anas])
	for filelist in dirlist:
	# TODO: delegate to getHistos?
	for infile in filelist:
	analysisobjects = yoda.read(infile, patterns=opts.PATHPATTERNS, unpatterns=opts.PATHUNPATTERNS)
	for path, ao in analysisobjects.iteritems():
	aop = rivet.AOPath(ao.path)
	if aop.isref():
	ao.path = aop.basepath(keepref=False)
	refhistos[ao.path] = ao
	return refhistos


	def parseArgs(args):
	"""Look at the argument list and split it at colons, in order to separate
	the file names from the plotting options. Store the file names and
	file specific plotting options."""
	filelist = []
	plotoptions = {}
	for a in args:
	asplit = a.split(':')
	path = asplit[0]
	filelist.append(path)
	plotoptions[path] = []
	has_title = False
	for i in xrange(1, len(asplit)):
	## Add 'Title' if there is no = sign before math mode
	if '=' not in asplit[i] or ('$' in asplit[i] and asplit[i].index('$') < asplit[i].index('=')):
	asplit[i] = 'Title=%s' % asplit[i]
	if asplit[i].startswith('Title='):
	has_title = True
	plotoptions[path].append(asplit[i])
	if path != "PLOT" and not has_title:
	plotoptions[path].append('Title=%s' % sanitiseString(os.path.basename( os.path.splitext(path)[0] )) )
	return filelist, plotoptions


	def setStyle(ao, istyle, variation=False):
	"""Set default plot styles (color and line width) colors borrowed from Google Ngrams"""
	# LINECOLORS = ['{[HTML]{EE3311}}', # red (Google uses 'DC3912')
	# '{[HTML]{3366FF}}', # blue
	# '{[HTML]{109618}}', # green
	# '{[HTML]{FF9900}}', # orange
	# '{[HTML]{990099}}'] # lilac
	LINECOLORS = ['red', 'blue', 'green', 'orange', 'lilac']
	LINESTYLES = ['solid', 'dashed', 'dashdotted', 'dotted']

	if opts.STYLE == 'talk':
	ao.setAnnotation('LineWidth', '1pt')
	if opts.STYLE == 'bw':
	LINECOLORS = ['black!90',
	'black!50',
	'black!30']

	jc = istyle % len(LINECOLORS)
	c = LINECOLORS[jc]
	js = (istyle / len(LINECOLORS)) % len(LINESTYLES)
	s = LINESTYLES[js]

	## If plotting a variation (i.e. band), fade the colour
	if variation:
	c += "!30"

	ao.setAnnotation('LineStyle', '%s' % s)
	ao.setAnnotation('LineColor', '%s' % c)


	def setOptions(ao, options):
	"Set arbitrary annotations"
	for opt in options:
	key, val = opt.split('=', 1)
	ao.setAnnotation(key, val)


	# TODO: move to rivet.utils
	def mkoutdir(outdir):
	"Function to make output directories"
	if not os.path.exists(outdir):
	try:
	os.makedirs(outdir)
	except:
	msg = "Can't make output directory '%s'" % outdir
	raise Exception(msg)
	if not os.access(outdir, os.W_OK):
	msg = "Can't write to output directory '%s'" % outdir
	raise Exception(msg)


	def mkOutput(hpath, aos, plot=None, special=None):
	"""
	Make the .dat file string. We can't use "yoda.writeFLAT(anaobjects, 'foobar.dat')"
	because the PLOT and SPECIAL blocks don't have a corresponding analysis object.
	"""
	output = ''

	if plot is not None:
	output += str(plot)

	if special is not None:
	output += "\n"
	output += "# BEGIN SPECIAL %s\n" % hpath
	output += special
	output += "# END SPECIAL\n\n"

	from cStringIO import StringIO
	sio = StringIO()
	yoda.writeFLAT(aos, sio)
	output += sio.getvalue()

	return output


	def writeOutput(output, h):
	"Choose output file name and dir"
	if opts.HIER_OUTPUT:
	hparts = h.strip("/").split("/", 1)
	ana = "_".join(hparts[:-1]) if len(hparts) > 1 else "ANALYSIS"
	outdir = os.path.join(opts.OUTDIR, ana)
	outfile = '%s.dat' % hparts[-1].replace("/", "_")
	else:
	hparts = h.strip("/").split("/")
	outdir = opts.OUTDIR
	outfile = '%s.dat' % "_".join(hparts)
	mkoutdir(outdir)
	outfilepath = os.path.join(outdir, outfile)
	f = open(outfilepath, 'w')
	f.write(output)
	f.close()


	#--------------------------------------------------------------------------------------------


	if __name__ == '__main__':

	## Command line parsing
	parser = getCommandLineOptions()
	opts, args = parser.parse_args()

	## Add pwd to search paths
	if opts.PATH_PWD:
	- rivet.addAnalysisLibPath(".")
	+ rivet.addAnalysisLibPath(os.path.abspath("."))
	+ rivet.addAnalysisDataPath(os.path.abspath("."))

	## Split the input file names and the associated plotting options
	## given on the command line into two separate lists
	filelist, plotoptions = parseArgs(args)
	## Remove the PLOT dummy file from the file list
	if "PLOT" in filelist:
	filelist.remove("PLOT")

	## Check that the files exist
	for f in filelist:
	if not os.access(f, os.R_OK):
	print "Error: cannot read from %s" % f
	sys.exit(1)

	## Read the .plot files
	plotdirs = opts.PLOTINFODIRS + [os.path.abspath(os.path.dirname(f)) for f in filelist]
	plotparser = rivet.mkStdPlotParser(plotdirs, opts.CONFIGFILES)

	## Create a list of all histograms to be plotted, and identify if they are 2D histos (which need special plotting)
	try:
	refhistos, mchistos = getHistos(filelist)
	except IOError, e:
	print "File reading error: ", e.strerror
	exit(1)
	hpaths, h2ds = [], []
	for aos in mchistos.values():
	for p in aos.keys():
	if p and p not in hpaths:
	hpaths.append(p)
	firstaop = aos[p][sorted(aos[p].keys())[0]]
	# TODO: Would be nicer to test via isHisto and dim or similar, or yoda.Scatter/Histo/Profile base classes
	if type(firstaop) in (yoda.Histo2D, yoda.Profile2D) and p not in h2ds:
	h2ds.append(p)

	## Take reference data from the Rivet search paths, if there is not already
	if opts.RIVETREFS:
	try:
	refhistos2 = getRivetRefData()
	except IOError, e:
	print "File reading error: ", e.strerror
	exit(1)
	refhistos2.update(refhistos)
	refhistos = refhistos2

	## Purge unmatched ref data entries to save memory
	for refhpath in refhistos.keys():
	if refhpath not in hpaths:
	del refhistos[refhpath]


	## Now loop over all MC histograms and plot them
	# TODO: factorize much of this into a rivet.utils mkplotfile(mchists, refhist, kwargs, is2d=False) function
	for hpath in hpaths:
	#print 'Currently looking at', h

	## The analysis objects to be plotted
	anaobjects = []
	## List of histos to be drawn, to sync the legend and plotted lines
	mainlines = []
	varlines = []
	## Is this a 2D histo?
	is2d = (hpath in h2ds)
	## Will we be drawing a ratio plot?
	showratio = opts.RATIO and not is2d


	## A Plot object to represent the PLOT section in the .dat file
	plot = Plot()
	if not is2d:
	plot['Legend'] = '1'
	plot['LogY'] = '1'
	headers = plotparser.getHeaders(hpath)
	if headers:
	plot.update(headers)
	# for key, val in headers.iteritems():
	# plot[key] = val
	if plotoptions.has_key("PLOT"):
	for key_val in plotoptions["PLOT"]:
	- key, val = [s.strip() for s in key_val.split("=")]
	+ key, val = [s.strip() for s in key_val.split("=",1)]
	plot[key] = val
	if opts.LINEAR:
	plot['LogY'] = '0'
	if opts.NOPLOTTITLE:
	plot['Title'] = ''
	if showratio and opts.RATIO_DEVIATION:
	plot['RatioPlotMode'] = 'deviation'
	if opts.STYLE == 'talk':
	plot['PlotSize'] = '8,6'
	elif opts.STYLE == 'bw' and showratio:
	plot['RatioPlotErrorBandColor'] = 'black!10'


	## Get a special object, if there is one for this path
	special = plotparser.getSpecial(hpath)


	## Handle reference data histogram, if there is one
	ratioreference, hasdataref = None, False
	if refhistos.has_key(hpath):
	hasdataref = True
	refdata = refhistos[hpath]
	refdata.setAnnotation('Title', opts.REFTITLE)
	if not is2d:
	refdata.setAnnotation('ErrorBars', '1')
	refdata.setAnnotation('PolyMarker', '*')
	refdata.setAnnotation('ConnectBins', '0')
	if showratio:
	ratioreference = hpath
	## For 1D
	anaobjects.append(refdata)
	mainlines.append(hpath)
	## For 2D
	if is2d:
	s = mkOutput(hpath, [refdata], plot, special)
	writeOutput(s, hpath)


	## Loop over the MC files to plot all instances of the histogram
	styleidx = 0
	for infile in filelist:
	if mchistos.has_key(infile) and mchistos[infile].has_key(hpath):
	hmcs = mchistos[infile][hpath]
	## For now, just plot all the different variation histograms (reversed, so [0] is on top)
	# TODO: calculate and plot an appropriate error band, somehow...
	for i in sorted(hmcs.keys(), reverse=True):
	iscanonical = (str(i) == "0")
	hmc = hmcs[i]
	## Default linecolor, linestyle
	if not is2d:
	setStyle(hmc, styleidx, not iscanonical)
	if opts.MC_ERRS:
	hmc.setAnnotation('ErrorBars', '1')
	## Plot defaults from .plot files
	histopts = plotparser.getHistogramOptions(hpath)
	if histopts:
	for key, val in histopts.iteritems():
	hmc.setAnnotation(key, val)
	## Command line plot options
	setOptions(hmc, plotoptions[infile])
	## Set path attribute
	fullpath = "/"+infile+hpath
	if not iscanonical:
	fullpath += "["+str(i)+"]"
	hmc.setAnnotation('Path', fullpath)
	## Add object / path to appropriate lists
	anaobjects.append(hmc)
	if iscanonical:
	mainlines.append(fullpath)
	else:
	varlines.append(fullpath)
	if showratio and ratioreference is None and iscanonical:
	ratioreference = fullpath
	## For 2D, plot each histo now (since overlay makes no sense)
	if is2d:
	s = mkOutput(hpath, [hmc], plot, special)
	writeOutput(s, fullpath)
	styleidx += 1


	## Finally render the combined plots; only show the first one if it's 2D
	# TODO: Only show the first MC one if 2D?
	if is2d:
	anaobjects = anaobjects[:1]
	## Add final attrs to Plot
	plot['DrawOnly'] = ' '.join(varlines + mainlines).strip()
	plot['LegendOnly'] = ' '.join(mainlines).strip()
	if showratio and len(varlines + mainlines) > 1:
	plot['RatioPlot'] = '1'
	plot['RatioPlotReference'] = ratioreference
	if not hasdataref and not plot.has_key("RatioPlotYLabel"):
	if plot.get('RatioPlotMode', '') == 'deviation':
	plot['RatioPlotYLabel'] = 'Deviation' #r'$\text{MC}-\text{MC}_\text{ref}$'
	else:
	plot['RatioPlotYLabel'] = 'Ratio' #r'$\text{MC}/\text{MC}_\text{ref}$'


	## Make the output and write to file
	o = mkOutput(hpath, anaobjects, plot, special)
	writeOutput(o, hpath)
	diff --git a/bin/rivet-completion b/bin/rivet-completion
	--- a/bin/rivet-completion
	+++ b/bin/rivet-completion
	@@ -1,228 +1,258 @@
	## -- sh --
	## Analysis name completion for Rivet scripts

	## Load bash completion compatibility if zsh is used
	if test -n "$ZSH_VERSION"; then
	autoload bashcompinit
	bashcompinit
	fi


	## Create a _filedir helper function if not already present
	(type _filedir &> /dev/null) \|\| \
	function _filedir() {
	local cur prev commands options command
	cur="${COMP_WORDS[COMP_CWORD]}"
	COMPREPLY=( $(compgen -W "$(ls ${cur}* 2> /dev/null)" -- ${cur}) )
	return 0
	}


	##########################


	function _rivet() {
	local cur prev commands options command
	COMPREPLY=()
	cur="${COMP_WORDS[COMP_CWORD]}"
	prev="${COMP_WORDS[COMP_CWORD-1]}"

	opts="--help --verbose --quiet --version --nevts --nskip --cross-section"
	- opts="$opts --analysis --analyses --runname --list-analyses --show-analysis" #< intentionally skip --show-analyses alias
	+ opts="$opts --analysis --analyses --runname --list-analyses --show-analysis --show-bibtex" #< intentionally skip --show-analyses alias
	opts="$opts --analysis-path --analysis-path-append --pwd"
	- opts="$opts --histo-file --histo-interval --event-timeout"
	+ opts="$opts --histo-file --no-histo-file --histo-interval --event-timeout"
	opts="$opts -a -A -n -h -x -H -l -v -q"
	if [[ ${cur} == -* ]] ; then
	COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
	if test -n "$COMPREPLY"; then
	return 0
	fi
	fi

	if (echo ${prev} \| egrep -- "-\<a\>\|--\<analysis\>\|--\<analyses\>\|--\<show-analysis\>\|--\<show-analyses\>\|--\<list-analyses\>" &> /dev/null); then
	anas=$(rivet --list-analyses --quiet)
	COMPREPLY=( $(compgen -W "$anas" -- ${cur}) )
	return 0
	fi

	if (echo ${prev} \| egrep -- "\<-n\>\|--\<nevts\>\|--\<runname\>\|--\<histo-interval\>\|--\<cross-section\>\|\<-x\>\|--\<event-timeout\>" &> /dev/null); then
	COMPREPLY=()
	return 0
	fi

	if (echo ${prev} \| egrep -- "--\<histo-file\>\|\<-H\>" &> /dev/null); then
	_filedir yoda
	return 0
	fi

	if (echo ${prev} \| egrep -- "--\<analysis-path\>\|--\<analysis-path-append\>" &> /dev/null); then
	_filedir -d
	return 0
	fi

	_filedir
	return 0
	}


	complete -F _rivet rivet


	##########################


	function _rivet_config() {
	local cur prev commands options command
	COMPREPLY=()
	cur="${COMP_WORDS[COMP_CWORD]}"
	prev="${COMP_WORDS[COMP_CWORD-1]}"

	opts="--help --version"
	opts="$opts --prefix --includedir --libdir --datadir"
	opts="$opts --pythonpath --cppflags --ldflags --libs"
	opts="$opts -h"
	if [[ ${cur} == -* ]] ; then
	COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
	if test -n "$COMPREPLY"; then
	return 0
	fi
	fi

	COMPREPLY=( $(compgen -W "$opts" -- ${cur}) )
	if test -n "$COMPREPLY"; then
	return 0
	fi

	return 0
	}


	complete -F _rivet_config rivet-config


	+##########################
	+
	+
	+function _rivet_buildplugin() {
	+ local cur prev commands options command
	+ COMPREPLY=()
	+ cur="${COMP_WORDS[COMP_CWORD]}"
	+ prev="${COMP_WORDS[COMP_CWORD-1]}"
	+
	+ opts="--help -h --with-root --cmd --dry-run"
	+ if [[ ${cur} == -* ]] ; then
	+ COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
	+ if test -n "$COMPREPLY"; then
	+ return 0
	+ fi
	+ fi
	+
	+ # COMPREPLY=( $(compgen -W "$opts" -- ${cur}) )
	+ # if test -n "$COMPREPLY"; then
	+ # return 0
	+ # fi
	+
	+ _filedir
	+ return 0
	+}
	+
	+
	+complete -F _rivet_buildplugin rivet-buildplugin
	+
	+
	##############################


	function _rivet_cmphistos() {
	local cur prev commands options command
	COMPREPLY=()
	cur="${COMP_WORDS[COMP_CWORD]}"
	prev="${COMP_WORDS[COMP_CWORD-1]}"

	opts="--help -h"
	opts="$opts --outdir -o"
	opts="$opts --rivet-refs -R --no-rivet-refs"
	opts="$opts --histogram-list -l"
	opts="$opts --hier-out --linear --logarithmic --mc-errs"
	opts="$opts --no-ratio --rel-ratio --abs-ratio"
	opts="$opts --all --show-mc-only --show-single --refid"
	opts="$opts --no-plottitle"
	opts="$opts --plotinfodir"
	opts="$opts --no-rmgapbins"
	opts="$opts --quiet -q --verbose -v"
	if [[ ${cur} == -* ]] ; then
	COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
	if test -n "$COMPREPLY"; then
	return 0
	fi
	fi

	if [[ ${prev} == "--plotinfodir" ]] ; then
	_filedir -d
	return 0
	fi

	if [[ ${prev} == "--show-single" ]]; then
	COMPREPLY=( $(compgen -W "no mc ref all" -- ${cur}) )
	return 0
	fi

	_filedir yoda
	return 0
	}


	complete -F _rivet_cmphistos -o default rivet-cmphistos


	##############################


	function _make_plots() {
	local cur prev commands options command
	COMPREPLY=()
	cur="${COMP_WORDS[COMP_CWORD]}"
	prev="${COMP_WORDS[COMP_CWORD-1]}"

	opts="--help -h"
	opts="$opts --num-threads -n"
	opts="$opts --palatino --cm --times --minion"
	opts="$opts --ps --pdf --eps --png --pdfpng --pspng"
	opts="$opts --tex --no-cleanup --full-range"
	opts="$opts --config -c"
	opts="$opts --quiet -q --verbose -v"
	if [[ ${cur} == -* ]] ; then
	COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
	if test -n "$COMPREPLY"; then
	return 0
	fi
	fi

	_filedir dat
	return 0
	}


	complete -F _make_plots -o default make-plots


	########################


	function _rivet_mkhtml() {
	local cur prev commands options command
	COMPREPLY=()
	cur="${COMP_WORDS[COMP_CWORD]}"
	prev="${COMP_WORDS[COMP_CWORD-1]}"

	opts="--help -h"
	opts="$opts --outputdir -o"
	opts="$opts --title -t"
	opts="$opts --config -c"
	opts="$opts --single -s"
	opts="$opts --no-ratio --mc-errs --refid"
	opts="$opts --num-threads --n"
	opts="$opts --pdf --ps --booklet"
	opts="$opts --ignore-unvalidated -i"
	opts="$opts --match -m"
	opts="$opts --unmatch -M"
	opts="$opts --verbose -v"
	if [[ ${cur} == -* ]] ; then
	COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
	if test -n "$COMPREPLY"; then
	return 0
	fi
	fi

	## Options with files / directories as the arg
	if (echo ${prev} \| egrep -- "--\<outputdir\>\|\<-o\>" &> /dev/null); then
	_filedir -d
	return 0
	fi
	if (echo ${prev} \| egrep -- "--\<config\>\|\<-c\>" &> /dev/null); then
	_filedir
	return 0
	fi

	## Options without an completeable arg
	if (echo ${prev} \| egrep -- "\<-t\>\|--\<title\>\|--\<refid\>\|--\<n\>\|--\<num-threads\>\|\<-m\>\|--\<match\>\|\<-M\>\|--\<unmatch\>" &> /dev/null); then
	COMPREPLY=()
	return 0
	fi

	_filedir yoda
	return 0
	}


	complete -F _rivet_mkhtml rivet-mkhtml
	diff --git a/bin/rivet-mkanalysis b/bin/rivet-mkanalysis
	--- a/bin/rivet-mkanalysis
	+++ b/bin/rivet-mkanalysis
	@@ -1,322 +1,306 @@
	#! /usr/bin/env python

	"""\
	%prog: make templates of analysis source files for Rivet

	Usage: %prog [--help\|-h] [--srcroot=<srcrootdir>] <analysisname>

	Without the --srcroot flag, the analysis files will be created in the current
	directory.
	"""

	import rivet, sys, os
	rivet.util.check_python_version()
	rivet.util.set_process_name(os.path.basename(__file__))
	import logging


	## Handle command line
	from optparse import OptionParser
	parser = OptionParser(usage=__doc__)
	parser.add_option("--srcroot", metavar="DIR", dest="SRCROOT", default=None,
	help="install the templates into the Rivet source tree (rooted " +
	"at directory DIR) rather than just creating all in the current dir")
	parser.add_option("-q", "--quiet", dest="LOGLEVEL", default=logging.INFO,
	action="store_const", const=logging.WARNING, help="only write out warning and error messages")
	parser.add_option("-v", "--verbose", dest="LOGLEVEL", default=logging.INFO,
	action="store_const", const=logging.DEBUG, help="provide extra debugging messages")
	parser.add_option("-i", "--inline-info", dest="INLINE", action="store_true",
	default=False, help="Put analysis info into source file instead of separate data file.")
	opts, args = parser.parse_args()
	logging.basicConfig(format="%(msg)s", level=opts.LOGLEVEL)
	ANANAMES = args


	## Work out installation paths
	ANAROOT = os.path.abspath(opts.SRCROOT or os.getcwd())
	if not os.access(ANAROOT, os.W_OK):
	logging.error("Can't write to source root directory %s" % ANAROOT)
	sys.exit(1)
	ANASRCDIR = os.getcwd()
	ANAINFODIR = os.getcwd()
	ANAPLOTDIR = os.getcwd()
	if opts.SRCROOT:
	ANASRCDIR = os.path.join(ANAROOT, "src/Analyses")
	ANAINFODIR = os.path.join(ANAROOT, "data/anainfo")
	ANAPLOTDIR = os.path.join(ANAROOT, "data/plotinfo")
	if not (os.path.exists(ANASRCDIR) and os.path.exists(ANAINFODIR) and os.path.exists(ANAPLOTDIR)):
	logging.error("Rivet analysis dirs do not exist under %s" % ANAROOT)
	sys.exit(1)
	if not (os.access(ANASRCDIR, os.W_OK) and os.access(ANAINFODIR, os.W_OK) and os.access(ANAPLOTDIR, os.W_OK)):
	logging.error("Can't write to Rivet analysis dirs under %s" % ANAROOT)
	sys.exit(1)


	## Check for disallowed characters in analysis names
	import string
	allowedchars = string.letters + string.digits + "_"
	all_ok = True
	for ananame in ANANAMES:
	for c in ananame:
	if c not in allowedchars:
	logging.error("Analysis name '%s' contains disallowed character '%s'!" % (ananame, c))
	all_ok = False
	break
	if not all_ok:
	logging.error("Exiting... please ensure that all analysis names are valid")
	sys.exit(1)


	## Now make each analysis
	for ANANAME in ANANAMES:
	logging.info("Writing templates for %s to %s" % (ANANAME, ANAROOT))

	## Extract some metadata from the name if it matches the standard pattern
	import re
	re_stdana = re.compile(r"^(\w+)_(\d{4})_(I\|S)(\d+)$")
	match = re_stdana.match(ANANAME)
	STDANA = False
	ANAEXPT = "<Insert the experiment name>"
	ANACOLLIDER = "<Insert the collider name>"
	ANAYEAR = "<Insert year of publication>"
	- INSPIRE_SPIRES = None
	+ INSPIRE_SPIRES = 'I'
	ANAINSPIREID = "<Insert the Inspire ID>"
	if match:
	STDANA = True
	ANAEXPT = match.group(1)
	if ANAEXPT.upper() in ("ALICE", "ATLAS", "CMS", "LHCB"):
	ANACOLLIDER = "LHC"
	elif ANAEXPT.upper() in ("CDF", "D0"):
	ANACOLLIDER = "Tevatron"
	elif ANAEXPT.upper() == "BABAR":
	ANACOLLIDER = "PEP-II"
	elif ANAEXPT.upper() == "BELLE":
	ANACOLLIDER = "KEKB"
	ANAYEAR = match.group(2)
	INSPIRE_SPIRES = match.group(3)
	ANAINSPIREID = match.group(4)
	if INSPIRE_SPIRES == "I":
	ANAREFREPO = "Inspire"
	else:
	ANAREFREPO = "Spires"
	KEYWORDS = {
	"ANANAME" : ANANAME,
	"ANAEXPT" : ANAEXPT,
	"ANACOLLIDER" : ANACOLLIDER,
	"ANAYEAR" : ANAYEAR,
	"ANAREFREPO" : ANAREFREPO,
	"ANAINSPIREID" : ANAINSPIREID
	}

	## Try to get bib info from SPIRES
	ANABIBKEY = ""
	ANABIBTEX = ""
	bibkey, bibtex = None, None
	if STDANA:
	try:
	logging.debug("Getting Inspire/SPIRES biblio data for '%s'" % ANANAME)
	bibkey, bibtex = rivet.spiresbib.get_bibtex_from_repo(INSPIRE_SPIRES, ANAINSPIREID)
	except Exception, e:
	logging.error("Inspire/SPIRES oops: %s" % e)
	if bibkey and bibtex:
	ANABIBKEY = bibkey
	ANABIBTEX = bibtex
	KEYWORDS["ANABIBKEY"] = ANABIBKEY
	KEYWORDS["ANABIBTEX"] = ANABIBTEX


	## Try to download YODA data file from HepData
	if STDANA:
	try:
	import urllib
	hdurl = None
	if INSPIRE_SPIRES == "I":
	hdurl = "http://hepdata.cedar.ac.uk/view/ins%s/yoda" % ANAINSPIREID
	elif INSPIRE_SPIRES == "S":
	hdurl = "http://hepdata.cedar.ac.uk/view/irn%s/yoda" % ANAINSPIREID
	if hdurl:
	logging.debug("Getting data file from HepData at %s" % hdurl)
	httpstream = urllib.urlopen(hdurl)
	yodastr = httpstream.read()
	if not yodastr or "<html>" in yodastr:
	logging.warning("Problem encountered when getting data from HepData (%s). No reference data file written." % hdurl)
	else:
	f = open("%s.yoda" % ANANAME, "w")
	f.write(yodastr)
	f.close()
	httpstream.close()
	else:
	logging.warning("Could not identify a URL for getting reference data from HepData. No reference data file written.")
	except Exception, e:
	logging.error("HepData oops: %s" % e)


	if opts.INLINE:
	KEYWORDS["ANAREFREPO_LOWER"] = KEYWORDS["ANAREFREPO"].lower()
	INLINEMETHODS="""
	public:
	string experiment() const { return "%(ANAEXPT)s"; }
	string year() const { return "%(ANAYEAR)s"; }
	string %(ANAREFREPO_LOWER)sId() const { return "%(ANAINSPIREID)s"; }
	string collider() const { return ""; }
	string summary() const { return ""; }
	string description() const { return ""; }
	string runInfo() const { return ""; }
	string bibKey() const { return "%(ANABIBKEY)s"; }
	string bibTeX() const { return "%(ANABIBTEX)s"; }
	string status() const { return "UNVALIDATED"; }
	vector<string> authors() const { return vector<string>(); }
	vector<string> references() const { return vector<string>(); }
	vector<std::string> todos() const { return vector<string>(); }
	""" % KEYWORDS
	del KEYWORDS["ANAREFREPO_LOWER"]
	else:
	INLINEMETHODS=""

	KEYWORDS["INLINEMETHODS"] = INLINEMETHODS


	ANASRCFILE = os.path.join(ANASRCDIR, ANANAME+".cc")
	logging.debug("Writing implementation template to %s" % ANASRCFILE)
	f = open(ANASRCFILE, "w")
	src = '''\
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	-/// @todo Include more projections as required, e.g. ChargedFinalState, FastJets, ZFinder...

	namespace Rivet {


	+ /// @brief Add a short analysis description here
	class %(ANANAME)s : public Analysis {
	public:

	/// Constructor
	- %(ANANAME)s()
	- : Analysis("%(ANANAME)s")
	- { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(%(ANANAME)s);


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	- /// @todo Initialise and register projections here
	+ // Initialise and register projections
	+ declare(FinalState(Cuts::abseta < 5 && Cuts::pT > 100*MeV), "FS");

	- /// @todo Book histograms here, e.g.:
	- // _h_XXXX = bookProfile1D(1, 1, 1);
	- // _h_YYYY = bookHisto1D(2, 1, 1);
	+ // Book histograms
	+ _h_XXXX = bookProfile1D(1, 1, 1);
	+ _h_YYYY = bookHisto1D(2, 1, 1);
	+ _h_ZZZZ = bookCounter(3, 1, 1);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	- const double weight = event.weight();

	/// @todo Do the event by event analysis here

	}


	/// Normalise histograms etc., after the run
	void finalize() {

	- /// @todo Normalise, scale and otherwise manipulate histograms here
	-
	- // scale(_h_YYYY, crossSection()/sumOfWeights()); // norm to cross section
	- // normalize(_h_YYYY); // normalize to unity
	+ normalize(_h_YYYY); // normalize to unity
	+ scale(_h_ZZZZ, crossSection()/picobarn/sumOfWeights()); // norm to cross section

	}

	//@}


	- private:
	-
	- // Data members like post-cuts event weight counters go here
	-
	-
	/// @name Histograms
	//@{
	Profile1DPtr _h_XXXX;
	Histo1DPtr _h_YYYY;
	+ CounterPtr _h_ZZZZ;
	//@}
	%(INLINEMETHODS)s

	};


	-
	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(%(ANANAME)s);


	}
	''' % KEYWORDS
	f.write(src)
	f.close()

	ANAPLOTFILE = os.path.join(ANAPLOTDIR, ANANAME+".plot")
	logging.debug("Writing plot template to %s" % ANAPLOTFILE)
	f = open(ANAPLOTFILE, "w")
	src = '''\
	# BEGIN PLOT /%(ANANAME)s/d01-x01-y01
	#Title=[Uncomment and insert title for histogram d01-x01-y01 here]
	#XLabel=[Uncomment and insert x-axis label for histogram d01-x01-y01 here]
	#YLabel=[Uncomment and insert y-axis label for histogram d01-x01-y01 here]
	# + any additional plot settings you might like, see make-plots documentation
	# END PLOT

	# ... add more histograms as you need them ...
	''' % KEYWORDS
	f.write(src)
	f.close()

	if opts.INLINE:
	sys.exit(0)
	ANAINFOFILE = os.path.join(ANAINFODIR, ANANAME+".info")
	logging.debug("Writing info template to %s" % ANAINFOFILE)
	f = open(ANAINFOFILE, "w")
	src = """\
	Name: %(ANANAME)s
	Year: %(ANAYEAR)s
	Summary: <Insert short %(ANANAME)s description>
	Experiment: %(ANAEXPT)s
	Collider: %(ANACOLLIDER)s
	%(ANAREFREPO)sID: %(ANAINSPIREID)s
	Status: UNVALIDATED
	Authors:
	- Your Name <your@email.address>
	#References:
	-# - <Example: Phys.Lett.B639:151-158,2006, Erratum-ibid.B658:285-289,2008>
	-# - <Example: doi:10.1016/j.physletb.2006.04.048>
	-# - <Example: arXiv:hep-ex/0511054 (plus erratum)>
	-RunInfo:
	- <Insert event types (not gen-specific), energy, any kinematic
	- efficiency cut(s) that may be needed; essentially any details needed to set
	- up a generator to reproduce the data.>
	-NumEvents: 1000000
	+#- '<Example: Eur.Phys.J. C76 (2016) no.7, 392>'
	+#- '<Example: DOI:10.1140/epjc/s10052-016-4184-8>'
	+#- '<Example: arXiv:1605.03814>'
	+RunInfo: <Describe event types, cuts, and other general generator config tips.>
	NeedCrossSection: no
	-#Beams: <Insert beam pair(s), e.g. [p-, p+] or [[p-, e-], [p-, e+]]>
	-#Energies: <Insert list of run energies or beam energy pairs in GeV,
	-# e.g. [1960] or [[8.0, 3.5]] or [630, 1800]. Order pairs to match "Beams">
	-#PtCuts: <Insert list of kinematic pT cuts in GeV, e.g. [0, 20]>
	-#NeedCrossSection: True
	+#Beams: <Insert beam pair(s), e.g. [p+, p+] or [[p-, e-], [p-, e+]]>
	+#Energies: <Run energies or beam energy pairs in GeV, e.g. [13000] or [[8.0, 3.5]] or [630, 1800]. Order pairs to match "Beams">
	Description:
	- '<Insert a fairly long description, including what is measured
	+ '<A fairly long description, including what is measured
	and if possible what it is useful for in terms of MC validation
	- and tuning. Use LaTeX for maths like $\pT > 50\;\GeV$.
	- Use single quotes around the block if required (see http://www.yaml.org)>'
	+ and tuning. Use LaTeX for maths like $\pT > 50\;\GeV$.>'
	BibKey: %(ANABIBKEY)s
	BibTeX: '%(ANABIBTEX)s'
	ToDo:
	- Implement the analysis, test it, remove this ToDo, and mark as VALIDATED :-)

	""" % KEYWORDS
	f.write(src)
	f.close()

	logging.info("Use e.g. 'rivet-buildplugin Rivet%s.so %s.cc' to compile the plugin" % (ANANAME, ANANAME))
	diff --git a/bin/rivet-mkhtml b/bin/rivet-mkhtml
	--- a/bin/rivet-mkhtml
	+++ b/bin/rivet-mkhtml
	@@ -1,454 +1,497 @@
	#! /usr/bin/env python

	"""\
	%prog [options] <yodafile1> [<yodafile2> <yodafile3>...] [PLOT:Key1=Val1:...]

	Make web pages from histogram files written out by Rivet. You can specify
	multiple Monte Carlo YODA files to be compared in the same syntax as for
	rivet-cmphistos, i.e. including plotting options.

	Reference data, analysis metadata, and plot style information should be found
	automatically (if not, set the RIVET_ANALYSIS_PATH or similar variables
	appropriately).

	Any existing output directory will be overwritten.

	ENVIRONMENT:
	* RIVET_ANALYSIS_PATH: list of paths to be searched for plugin
	analysis libraries at runtime
	* RIVET_DATA_PATH: list of paths to be searched for data files
	"""

	import rivet, sys, os
	rivet.util.check_python_version()
	rivet.util.set_process_name(os.path.basename(__file__))

	import glob, shutil
	from subprocess import Popen,PIPE


	from optparse import OptionParser, OptionGroup
	parser = OptionParser(usage=__doc__)
	parser.add_option("-o", "--outputdir", dest="OUTPUTDIR",
	- default="./rivet-plots", help="directory for webpage output")
	+ default="./rivet-plots", help="directory for Web page output")
	parser.add_option("-c", "--config", dest="CONFIGFILES", action="append", default=["~/.make-plots"],
	- help="plot config file(s) to be used with rivet-cmphistos.")
	+ help="plot config file(s) to be used with rivet-cmphistos")
	parser.add_option("-n", "--num-threads", metavar="NUMTHREADS", dest="NUMTHREADS", type=int,
	- default=None, help="request make-plots to use a specific number of threads.")
	+ default=None, help="request make-plots to use a specific number of threads")
	parser.add_option("--ignore-missing", dest="IGNORE_MISSING", action="store_true",
	- default=False, help="ignore missing YODA files.")
	+ default=False, help="ignore missing YODA files")
	parser.add_option("-i", "--ignore-unvalidated", dest="IGNORE_UNVALIDATED", action="store_true",
	- default=False, help="ignore unvalidated analyses.")
	+ default=False, help="ignore unvalidated analyses")
	# parser.add_option("--ref", "--refid", dest="REF_ID",
	# default=None, help="ID of reference data set (file path for non-REF data)")
	parser.add_option("--dry-run", help="don't actually do any plotting or HTML building", dest="DRY_RUN",
	action="store_true", default=False)
	+parser.add_option("--no-cleanup", dest="NO_CLEANUP", action="store_true", default=False,
	+ help="keep plotting temporary directory")
	+parser.add_option("--no-subproc", dest="NO_SUBPROC", action="store_true", default=False,
	+ help="don't use subprocesses to render the plots in parallel -- useful for debugging")
	parser.add_option("--pwd", dest="PATH_PWD", action="store_true", default=False,
	- help="append the current directory (pwd) to the analysis/data search paths (cf. $RIVET_ANALYSIS_PATH).")
	+ help="append the current directory (pwd) to the analysis/data search paths (cf. $RIVET_ANALYSIS_PATH)")

	stygroup = OptionGroup(parser, "Style options")
	stygroup.add_option("-t", "--title", dest="TITLE",
	default="Plots from Rivet analyses", help="title to be displayed on the main web page")
	stygroup.add_option("--reftitle", dest="REFTITLE",
	default="Data", help="legend entry for reference data")
	stygroup.add_option("--no-plottitle", dest="NOPLOTTITLE", action="store_true",
	default=False, help="don't show the plot title on the plot "
	"(useful when the plot description should only be given in a caption)")
	stygroup.add_option("-s", "--single", dest="SINGLE", action="store_true",
	default=False, help="display plots on single webpage.")
	stygroup.add_option("--no-ratio", dest="SHOW_RATIO", action="store_false",
	default=True, help="don't draw a ratio plot under each main plot.")
	stygroup.add_option("--mc-errs", dest="MC_ERRS", action="store_true",
	default=False, help="plot error bars.")
	stygroup.add_option("--offline", dest="OFFLINE", action="store_true",
	default=False, help="generate HTML that does not use external URLs.")
	stygroup.add_option("--pdf", dest="VECTORFORMAT", action="store_const", const="PDF",
	default="PDF", help="use PDF as the vector plot format.")
	stygroup.add_option("--ps", dest="VECTORFORMAT", action="store_const", const="PS",
	default="PDF", help="use PostScript as the vector plot format. DEPRECATED")
	stygroup.add_option("--booklet", dest="BOOKLET", action="store_true",
	- default=False, help="create booklet (currently only available for PDF with pdftk).")
	+ default=False, help="create booklet (currently only available for PDF with pdftk or pdfmerge).")
	stygroup.add_option("--font", dest="OUTPUT_FONT", choices="palatino,cm,times,helvetica,minion".split(","),
	default="palatino", help="choose the font to be used in the plots")
	stygroup.add_option("--palatino", dest="OUTPUT_FONT", action="store_const", const="palatino", default="palatino",
	help="use Palatino as font (default). DEPRECATED: Use --font")
	stygroup.add_option("--cm", dest="OUTPUT_FONT", action="store_const", const="cm", default="palatino",
	help="use Computer Modern as font. DEPRECATED: Use --font")
	stygroup.add_option("--times", dest="OUTPUT_FONT", action="store_const", const="times", default="palatino",
	help="use Times as font. DEPRECATED: Use --font")
	stygroup.add_option("--helvetica", dest="OUTPUT_FONT", action="store_const", const="helvetica", default="palatino",
	help="use Helvetica as font. DEPRECATED: Use --font")
	stygroup.add_option("--minion", dest="OUTPUT_FONT", action="store_const", const="minion", default="palatino",
	help="use Adobe Minion Pro as font. DEPRECATED: Use --font")
	parser.add_option_group(stygroup)

	selgroup = OptionGroup(parser, "Selective plotting")
	selgroup.add_option("-m", "--match", action="append", dest="PATHPATTERNS", default=[],
	help="only write out histograms whose $path/$name string matches any of these regexes")
	selgroup.add_option("-M", "--unmatch", action="append", dest="PATHUNPATTERNS", default=[],
	help="exclude histograms whose $path/$name string matches any of these regexes")
	selgroup.add_option("-a", "--ana-match", action="append", dest="ANAPATTERNS", default=[],
	help="only write out histograms from analyses whose name matches any of these regexes")
	selgroup.add_option("-A", "--ana-unmatch", action="append", dest="ANAUNPATTERNS", default=[],
	help="exclude histograms from analyses whose name matches any of these regexes")
	parser.add_option_group(selgroup)

	vrbgroup = OptionGroup(parser, "Verbosity control")
	vrbgroup.add_option("-v", "--verbose", help="add extra debug messages", dest="VERBOSE",
	action="store_true", default=False)
	parser.add_option_group(vrbgroup)

	opts, yodafiles = parser.parse_args()


	## Add pwd to search paths
	if opts.PATH_PWD:
	- rivet.addAnalysisLibPath(".")
	+ rivet.addAnalysisLibPath(os.path.abspath("."))
	+ rivet.addAnalysisDataPath(os.path.abspath("."))


	## Check that there are some arguments!
	if not yodafiles:
	print "Error: You need to specify some YODA files to be plotted!"
	sys.exit(1)


	## Make output directory
	if not opts.DRY_RUN:
	if os.path.exists(opts.OUTPUTDIR) and not os.path.realpath(opts.OUTPUTDIR)==os.getcwd():
	import shutil
	shutil.rmtree(opts.OUTPUTDIR)
	try:
	os.makedirs(opts.OUTPUTDIR)
	except:
	print "Error: failed to make new directory '%s'" % opts.OUTPUTDIR
	sys.exit(1)

	## Get set of analyses involved in the runs
	plotarg = None
	analyses = set()
	blocked_analyses = set()
	import yoda
	for yodafile in yodafiles:
	if yodafile.startswith("PLOT:"):
	plotarg = yodafile
	continue
	yodafilepath = os.path.abspath(yodafile.split(":")[0])
	if not os.access(yodafilepath, os.R_OK):
	print "Error: cannot read from %s" % yodafilepath
	if opts.IGNORE_MISSING:
	continue
	else:
	sys.exit(2)

	try:
	- ## Note: use -m/-M flags here as well as when calling rivet-cmphistos, to potentially speed this initial loading
	+ ## Note: we use -m/-M flags here as well as when calling rivet-cmphistos, to potentially speed this initial loading
	analysisobjects = yoda.read(yodafilepath, patterns=opts.PATHPATTERNS, unpatterns=opts.PATHUNPATTERNS)
	except IOError, e:
	print "File reading error: ", e.strerror
	- exit(1)
	+ sys.exit(1)

	for path, ao in analysisobjects.iteritems():
	## Make a path object and ensure the path is in standard form
	try:
	aop = rivet.AOPath(path)
	except Exception, e:
	#print e
	print "Found analysis object with non-standard path structure:", path, "... skipping"
	continue

	## We don't plot data objects with path components hidden by an underscore prefix
	if aop.istmp():
	continue

	## Identify analysis/histo name parts
	analysis = "ANALYSIS"
	if aop.basepathparts(keepref=False):
	analysis = aop.basepathparts(keepref=False)[0] #< TODO: for compatibility with rivet-cmphistos... generalise?
	#analysis = "_".join(aop.dirnameparts(keepref=False)[:-1]) #< TODO: would this be nicer? Currently incompatible with rivet-cmphistos

	## Optionally veto on analysis name pattern matching
	if analysis in analyses.union(blocked_analyses):
	continue
	import re
	matched = True
	if opts.ANAPATTERNS:
	matched = False
	for patt in opts.ANAPATTERNS:
	- if re.search(patt, analysis) is not None:
	+ if re.match(patt, analysis) is not None:
	matched = True
	break
	if matched and opts.ANAUNPATTERNS:
	for patt in opts.ANAUNPATTERNS:
	- if re.search(patt, analysis) is not None:
	+ if re.match(patt, analysis) is not None:
	matched = False
	break
	if matched:
	analyses.add(analysis)
	else:
	blocked_analyses.add(analysis)


	## Sort analyses: group ascending by analysis name (could specialise grouping by collider), then
	## descending by year, and finally descending by bibliographic archive ID code (INSPIRE first).
	def anasort(name):
	rtn = (1, name)
	if name.startswith("MC"):
	rtn = (99999999, name)
	else:
	stdparts = name.split("_")
	try:
	year = int(stdparts[1])
	rtn = (0, stdparts[0], -year, 0)
	idcode = (0 if stdparts[2][0] == "I" else 1e10) - int(stdparts[2][1:])
	rtn = (0, stdparts[0], -year, idcode)
	if len(stdparts) > 3:
	rtn += stdparts[3:]
	except:
	pass
	return rtn

	analyses = sorted(analyses, key=anasort)

	## Uncomment to test analysis ordering on index page
	# print analyses
	# sys.exit(0)


	## Run rivet-cmphistos to get plain .dat files from .yoda
	## We do this here since it also makes the necessary directories
	ch_cmd = ["rivet-cmphistos"]
	if opts.MC_ERRS:
	ch_cmd.append("--mc-errs")
	if not opts.SHOW_RATIO:
	ch_cmd.append("--no-ratio")
	if opts.NOPLOTTITLE:
	ch_cmd.append("--no-plottitle")
	# if opts.REF_ID is not None:
	# ch_cmd.append("--refid=%s" % os.path.abspath(opts.REF_ID))
	if opts.REFTITLE:
	ch_cmd.append("--reftitle=%s" % opts.REFTITLE )
	if opts.PATHPATTERNS:
	for patt in opts.PATHPATTERNS:
	- ch_cmd += ["-m", patt]
	+ ch_cmd += ["-m", patt] #"'"+patt+"'"]
	if opts.PATHUNPATTERNS:
	for patt in opts.PATHUNPATTERNS:
	- ch_cmd += ["-M", patt]
	+ ch_cmd += ["-M", patt] #"'"+patt+"'"]
	ch_cmd.append("--hier-out")
	# TODO: Need to be able to override this: provide a --plotinfodir cmd line option?
	ch_cmd.append("--plotinfodir=%s" % os.path.abspath("../"))
	for af in yodafiles:
	yodafilepath = os.path.abspath(af.split(":")[0])
	if af.startswith("PLOT:"):
	yodafilepath = "PLOT"
	elif not os.access(yodafilepath, os.R_OK):
	continue
	newarg = yodafilepath
	if ":" in af:
	newarg += ":" + af.split(":", 1)[1]
	# print newarg
	ch_cmd.append(newarg)

	## Pass rivet-mkhtml -c args to rivet-cmphistos
	for configfile in opts.CONFIGFILES:
	configfile = os.path.abspath(os.path.expanduser(configfile))
	if os.access(configfile, os.R_OK):
	ch_cmd += ["-c", configfile]

	if opts.VERBOSE:
	- # ch_cmd.append("--verbose")
	+ ch_cmd.append("--verbose")
	print "Calling rivet-cmphistos with the following command:"
	print " ".join(ch_cmd)

	## Run rivet-cmphistos in a subdir, after fixing any relative paths in Rivet env vars
	if not opts.DRY_RUN:
	- for var in ("RIVET_ANALYSIS_PATH", "RIVET_REF_PATH", "RIVET_INFO_PATH", "RIVET_PLOT_PATH"):
	+ for var in ("RIVET_ANALYSIS_PATH", "RIVET_DATA_PATH", "RIVET_REF_PATH", "RIVET_INFO_PATH", "RIVET_PLOT_PATH"):
	if var in os.environ:
	abspaths = map(os.path.abspath, os.environ[var].split(":"))
	os.environ[var] = ":".join(abspaths)
	- subproc = Popen(ch_cmd, cwd=opts.OUTPUTDIR,stdout=PIPE,stderr=PIPE)
	- out,err = subproc.communicate()
	+ subproc = Popen(ch_cmd, cwd=opts.OUTPUTDIR, stdout=PIPE, stderr=PIPE)
	+ out, err = subproc.communicate()
	retcode = subproc.returncode
	- if (opts.VERBOSE or retcode != 0) and out:
	- print 'Output from rivet-cmphistos\n', out
	+ if opts.VERBOSE or retcode != 0:
	+ print 'Output from rivet-cmphistos:\n', out
	if err :
	- print 'Errors from rivet-cmphistos\n', err
	+ print 'Errors from rivet-cmphistos:\n', err
	if retcode != 0:
	print 'Crash in rivet-cmphistos code = ', retcode, ' exiting'
	exit(retcode)



	## Write web page containing all (matched) plots
	## Make web pages first so that we can load it locally in
	## a browser to view the output before all plots are made
	if not opts.DRY_RUN:

	style = '''<style>
	html { font-family: sans-serif; }
	img { border: 0; }
	a { text-decoration: none; font-weight: bold; }
	</style>
	'''

	## Include MathJax configuration
	script = ''
	if not opts.OFFLINE:
	script = '''\
	<script type="text/x-mathjax-config">
	MathJax.Hub.Config({
	tex2jax: {inlineMath: [["$","$"]]}
	});
	</script>
	<script type="text/javascript"
	src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
	</script>
	'''

	## A helper function for metadata LaTeX -> HTML conversion
	from rivet.util import htmlify

	## A timestamp HTML fragment to be used on each page:
	import datetime
	timestamp = '<p>Generated at %s</p>\n' % datetime.datetime.now().strftime("%A, %d. %B %Y %I:%M%p")

	index = open(os.path.join(opts.OUTPUTDIR, "index.html"), "w")
	index.write('<html>\n<head>\n<title>%s</title>\n%s</head>\n<body>' % (opts.TITLE, style + script))
	if opts.BOOKLET and opts.VECTORFORMAT == "PDF":
	index.write('<h2><a href="booklet.pdf">%s</a></h2>\n\n' % opts.TITLE)
	else:
	index.write('<h2>%s</h2>\n\n' % opts.TITLE)

	if opts.SINGLE:
	## Write table of contents
	index.write('<ul>\n')
	for analysis in analyses:
	summary = analysis
	ana = rivet.AnalysisLoader.getAnalysis(analysis)
	if ana:
	summary = "%s (%s)" % (ana.summary(), analysis)
	if opts.IGNORE_UNVALIDATED and ana.status() != "VALIDATED":
	continue
	index.write('<li><a href="#%s">%s</a>\n' % (analysis, htmlify(summary)) )
	index.write('</ul>\n')

	for analysis in analyses:
	references = []
	summary = htmlify(analysis)
	description, inspireid, spiresid = None, None, None

	if analysis.find("_I") > 0:
	inspireid = analysis[analysis.rfind('_I')+2:len(analysis)]
	elif analysis.find("_S") > 0:
	spiresid = analysis[analysis.rfind('_S')+2:len(analysis)]

	ana = rivet.AnalysisLoader.getAnalysis(analysis)
	if ana:
	if ana.summary():
	summary = htmlify("%s (%s)" % (ana.summary(), analysis))
	references = ana.references()
	description = htmlify(ana.description())
	spiresid = ana.spiresId()
	if opts.IGNORE_UNVALIDATED and ana.status().upper() != "VALIDATED":
	continue

	if opts.SINGLE:
	index.write('\n<h3 style="clear:left; padding-top:2em;"><a name="%s">%s</a></h3>\n' % (analysis, summary))
	else:
	index.write('\n<h3><a href="%s/index.html" style="text-decoration:none;">%s</a></h3>\n' % (analysis, summary))

	reflist = []
	if inspireid:
	- reflist.append('<a href="http://inspirehep.net/record/%s">Spires</a>' % inspireid)
	+ reflist.append('<a href="http://inspire-hep.net/record/%s">Inspire</a>' % inspireid)
	+ reflist.append('<a href="http://hepdata.cedar.ac.uk/view/ins%s">HepData</a>' % inspireid)
	elif spiresid:
	- reflist.append('<a href="http://durpdg.dur.ac.uk/cgi-bin/spiface/hep/www?irn+%s">Spires</a>' % spiresid)
	+ # elif ana.spiresId():
	+ reflist.append('<a href="http://inspire-hep.net/search?p=find+key+%s">Inspire</a>' % spiresid)
	+ reflist.append('<a href="http://hepdata.cedar.ac.uk/view/irn%s">HepData</a>' % spiresid)
	reflist += references
	index.write('<p>%s</p>\n' % " \| ".join(reflist))

	if description:
	index.write('<p style="font-size:smaller;">%s</p>\n' % description)

	anapath = os.path.join(opts.OUTPUTDIR, analysis)
	if not opts.SINGLE:
	if not os.path.exists(anapath):
	os.makedirs(anapath)
	anaindex = open(os.path.join(anapath, "index.html"), 'w')
	anaindex.write('<html>\n<head>\n<title>%s – %s</title>\n%s</head>\n<body>\n' %
	(htmlify(opts.TITLE), analysis, style + script))
	anaindex.write('<h3>%s</h3>\n' % htmlify(analysis))
	anaindex.write('<p><a href="../index.html">Back to index</a></p>\n')
	if description:
	anaindex.write('<p>\n %s\n</p>\n' % description)
	else:
	anaindex = index

	datfiles = glob.glob("%s/*.dat" % anapath)
	#print datfiles

	anaindex.write('<div style="float:none; overflow:auto; width:100%">\n')
	for datfile in sorted(datfiles):
	obsname = os.path.basename(datfile).replace(".dat", "")
	pngfile = obsname+".png"
	vecfile = obsname+"."+opts.VECTORFORMAT.lower()
	srcfile = obsname+".dat"
	if opts.SINGLE:
	pngfile = os.path.join(analysis, pngfile)
	vecfile = os.path.join(analysis, vecfile)
	srcfile = os.path.join(analysis, srcfile)

	anaindex.write(' <div style="float:left; font-size:smaller; font-weight:bold;">\n')
	anaindex.write(' <a href="#%s-%s">⚓</a><a href="%s">&#8984</a> %s:<br/>\n' %
	(analysis, obsname, srcfile, os.path.splitext(vecfile)[0]) )
	anaindex.write(' <a name="%s-%s"><a href="%s">\n' % (analysis, obsname, vecfile) )
	anaindex.write(' <img src="%s">\n' % pngfile )
	anaindex.write(' </a></a>\n')
	anaindex.write(' </div>\n')
	anaindex.write('</div>\n')

	if not opts.SINGLE:
	anaindex.write('<div style="float:none">%s</body>\n</html></div>\n' % timestamp)
	anaindex.close()
	index.write('<br>%s</body>\n</html>' % timestamp)
	index.close()

	+# http://stackoverflow.com/questions/377017/test-if-executable-exists-in-python
	+def which(program):
	+ import os
	+ def is_exe(fpath):
	+ return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
	+
	+ fpath, fname = os.path.split(program)
	+ if fpath:
	+ if is_exe(program):
	+ return program
	+ else:
	+ for path in os.environ["PATH"].split(os.pathsep):
	+ path = path.strip('"')
	+ exe_file = os.path.join(path, program)
	+ if is_exe(exe_file):
	+ return exe_file
	+
	+ return None

	## Run make-plots on all generated .dat files
	# sys.exit(0)
	mp_cmd = ["make-plots"]
	if opts.NUMTHREADS:
	mp_cmd.append("--num-threads=%d" % opts.NUMTHREADS)
	+if opts.NO_CLEANUP:
	+ mp_cmd.append("--no-cleanup")
	+if opts.NO_SUBPROC:
	+ mp_cmd.append("--no-subproc")
	if opts.VECTORFORMAT == "PDF":
	mp_cmd.append("--pdfpng")
	elif opts.VECTORFORMAT == "PS":
	mp_cmd.append("--pspng")
	-if opts.OUTPUT_FONT.upper() == "PALATINO":
	- mp_cmd.append("--palatino")
	-if opts.OUTPUT_FONT.upper() == "CM":
	- mp_cmd.append("--cm")
	-elif opts.OUTPUT_FONT.upper() == "TIMES":
	- mp_cmd.append("--times")
	-elif opts.OUTPUT_FONT.upper() == "HELVETICA":
	- mp_cmd.append("--helvetica")
	-elif opts.OUTPUT_FONT.upper() == "MINION":
	- mp_cmd.append("--minion")
	+if opts.OUTPUT_FONT:
	+ mp_cmd.append("--font=%s" % opts.OUTPUT_FONT)
	+# if opts.OUTPUT_FONT.upper() == "PALATINO":
	+# mp_cmd.append("--palatino")
	+# if opts.OUTPUT_FONT.upper() == "CM":
	+# mp_cmd.append("--cm")
	+# elif opts.OUTPUT_FONT.upper() == "TIMES":
	+# mp_cmd.append("--times")
	+# elif opts.OUTPUT_FONT.upper() == "HELVETICA":
	+# mp_cmd.append("--helvetica")
	+# elif opts.OUTPUT_FONT.upper() == "MINION":
	+# mp_cmd.append("--minion")
	datfiles = []
	for analysis in analyses:
	anapath = os.path.join(opts.OUTPUTDIR, analysis)
	#print anapath
	anadatfiles = glob.glob("%s/*.dat" % anapath)
	datfiles += sorted(anadatfiles)
	if datfiles:
	mp_cmd += datfiles
	if opts.VERBOSE:
	mp_cmd.append("--verbose")
	print "Calling make-plots with the following options:"
	print " ".join(mp_cmd)
	if not opts.DRY_RUN:
	Popen(mp_cmd).wait()
	if opts.BOOKLET and opts.VECTORFORMAT=="PDF":
	- bookletcmd = ["pdftk"]
	- for analysis in analyses:
	- anapath = os.path.join(opts.OUTPUTDIR, analysis)
	- bookletcmd += sorted(glob.glob("%s/*.pdf" % anapath))
	- bookletcmd += ["cat", "output", "%s/booklet.pdf" % opts.OUTPUTDIR]
	- print bookletcmd
	- Popen(bookletcmd).wait()
	+ if which("pdftk") is not None:
	+ bookletcmd = ["pdftk"]
	+ for analysis in analyses:
	+ anapath = os.path.join(opts.OUTPUTDIR, analysis)
	+ bookletcmd += sorted(glob.glob("%s/*.pdf" % anapath))
	+ bookletcmd += ["cat", "output", "%s/booklet.pdf" % opts.OUTPUTDIR]
	+ print bookletcmd
	+ Popen(bookletcmd).wait()
	+ elif which("pdfmerge") is not None:
	+ bookletcmd = ["pdfmerge"]
	+ for analysis in analyses:
	+ anapath = os.path.join(opts.OUTPUTDIR, analysis)
	+ bookletcmd += sorted(glob.glob("%s/*.pdf" % anapath))
	+ bookletcmd += ["%s/booklet.pdf" % opts.OUTPUTDIR]
	+ print bookletcmd
	+ Popen(bookletcmd).wait()
	+ else:
	+ print "Neither pdftk nor pdfmerge available --- not booklet output possible"
	diff --git a/configure.ac b/configure.ac
	--- a/configure.ac
	+++ b/configure.ac
	@@ -1,374 +1,313 @@
	## Process this file with autoconf to produce a configure script.

	AC_PREREQ(2.59)
	AC_INIT([Rivet],[trunk],[rivet@projects.hepforge.org],[Rivet])

	## Check and block installation into the src/build dir
	if test "$prefix" = "$PWD"; then
	AC_MSG_ERROR([Installation into the build directory is not supported: use a different --prefix argument])
	fi
	## Force default prefix to have a path value rather than NONE
	if test "$prefix" = "NONE"; then
	prefix=/usr/local
	fi

	AC_CONFIG_SRCDIR([src/Core/Analysis.cc])
	AC_CONFIG_HEADERS([include/Rivet/Config/DummyConfig.hh include/Rivet/Config/RivetConfig.hh include/Rivet/Config/BuildOptions.hh])
	AM_INIT_AUTOMAKE([dist-bzip2 -Wall])
	m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
	m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
	AC_CONFIG_MACRO_DIR([m4])
	AC_SUBST(LT_OBJDIR)

	## Package-specific #defines
	AC_DEFINE_UNQUOTED(RIVET_VERSION, "$PACKAGE_VERSION", "Rivet version string")
	AC_DEFINE_UNQUOTED(RIVET_NAME, "$PACKAGE_NAME", "Rivet name string")
	AC_DEFINE_UNQUOTED(RIVET_STRING, "$PACKAGE_STRING", "Rivet name and version string")
	AC_DEFINE_UNQUOTED(RIVET_TARNAME, "$PACKAGE_TARNAME", "Rivet short name string")
	AC_DEFINE_UNQUOTED(RIVET_BUGREPORT, "$PACKAGE_BUGREPORT", "Rivet contact email address")

	## OS X
	AC_CEDAR_OSX

	## Work out the LCG platform tag
	AC_LCG_TAG

	## Set default compiler flags
	if test "x$CXXFLAGS" == "x"; then CXXFLAGS="-O2"; fi

	## Compiler setup
	AC_LANG(C++)
	AC_PROG_CXX
	AX_CXX_COMPILE_STDCXX([11], [noext], [mandatory])

	## Store and propagate the compiler identity and flags
	RIVETCXX="$CXX"
	AC_SUBST(RIVETCXX)
	RIVETCXXFLAGS="$CXXFLAGS"
	AC_SUBST(RIVETCXXFLAGS)

	## Checks for programs.
	AC_PROG_INSTALL
	AC_PROG_LN_S
	AC_DISABLE_STATIC
	AC_LIBTOOL_DLOPEN
	AC_PROG_LIBTOOL


	## YODA histogramming library
	# TODO: we could download, configure, and install YODA automatically... but that is NASTY
	AC_CEDAR_LIBRARYANDHEADERS([YODA], , , [AC_MSG_ERROR([YODA is required])])
	YODABINPATH=$YODALIBPATH/../bin
	AC_SUBST(YODABINPATH)
	AC_PATH_PROG(YODACONFIG, yoda-config, [], [$YODALIBPATH/../bin:$PATH])
	YODA_PYTHONPATH=""
	if test -f "$YODACONFIG"; then
	AC_MSG_CHECKING([YODA version using yoda-config])
	YODA_VERSION=`$YODACONFIG --version`
	AC_MSG_RESULT([$YODA_VERSION])
	YODA_VERSION1=[`echo $YODA_VERSION \| cut -d. -f1 \| sed -e 's/$[0-9]$./\1/g'`]
	YODA_VERSION2=[`echo $YODA_VERSION \| cut -d. -f2 \| sed -e 's/$[0-9]$./\1/g'`]
	YODA_VERSION3=[`echo $YODA_VERSION \| cut -d. -f3 \| sed -e 's/$[0-9]$./\1/g'`]
	let YODA_VERSION_INT=YODA_VERSION110000+YODA_VERSION2100+YODA_VERSION3
	if test $YODA_VERSION_INT -lt 10500; then
	AC_MSG_ERROR([YODA version isn't sufficient: at least version 1.5.0 required])
	fi
	AC_MSG_CHECKING([YODA Python path using yoda-config])
	YODA_PYTHONPATH=`$YODACONFIG --pythonpath`
	AC_MSG_RESULT([$YODA_PYTHONPATH])
	fi
	AC_SUBST(YODA_PYTHONPATH)


	## HepMC event record library
	AC_CEDAR_LIBRARYANDHEADERS([HepMC], , , [AC_MSG_ERROR([HepMC is required])])
	oldCPPFLAGS=$CPPFLAGS
	CPPFLAGS="$CPPFLAGS -I$HEPMCINCPATH"
	if test -e "$HEPMCINCPATH/HepMC/HepMCDefs.h"; then
	AC_LANG_CONFTEST([AC_LANG_SOURCE([#include <iostream>
	#include "HepMC/HepMCDefs.h"
	int main() { std::cout << HEPMC_VERSION << std::endl; return 0; }])])
	else
	AC_LANG_CONFTEST([AC_LANG_SOURCE([#include <iostream>
	#include "HepMC/defs.h"
	int main() { std::cout << VERSION << std::endl; return 0; }])])
	fi
	if test -f conftest.cc; then
	$CXX $CPPFLAGS conftest.cc -o conftest 2>&1 1>&5
	elif test -f conftest.C; then
	$CXX $CPPFLAGS conftest.C -o conftest 2>&1 1>&5
	else
	$CXX $CPPFLAGS conftest.cpp -o conftest 2>&1 1>&5
	fi
	hepmc_version=`./conftest`
	if test x$hepmc_version != x; then
	let hepmc_major=`echo "$hepmc_version" \| cut -d. -f1`
	let hepmc_minor=`echo "$hepmc_version" \| cut -d. -f2`
	fi
	rm -f conftest conftest.cpp conftest.cc conftest.C
	HEPMC_VERSION=$hepmc_major$hepmc_minor
	AC_MSG_NOTICE([HepMC version is $hepmc_version -> $HEPMC_VERSION])
	AC_SUBST(HEPMC_VERSION)
	CPPFLAGS=$oldCPPFLAGS


	## FastJet clustering library
	AC_CEDAR_LIBRARYANDHEADERS([fastjet], , , [AC_MSG_ERROR([FastJet is required])])
	AC_PATH_PROG(FJCONFIG, fastjet-config, [], $FASTJETPATH/bin:$PATH)
	if test -f "$FJCONFIG"; then
	AC_MSG_CHECKING([FastJet version using fastjet-config])
	fjversion=`$FJCONFIG --version`
	AC_MSG_RESULT([$fjversion])
	fjmajor=$(echo $fjversion \| cut -f1 -d.)
	fjminor=$(echo $fjversion \| cut -f2 -d.)
	fjmicro=$(echo $fjversion \| cut -f3 -d.)
	if test "$fjmajor" -lt 3; then
	AC_MSG_ERROR([FastJet version 3.0.0 or later is required])
	fi
	FASTJETCONFIGLIBADD="$($FJCONFIG --plugins --shared --libs)"
	else
	FASTJETCONFIGLIBADD="-L$FASTJETLIBPATH -l$FASTJETLIBNAME"
	FASTJETCONFIGLIBADD="$FASTJETCONFIGLIBADD -lSISConePlugin -lsiscone -lsiscone_spherical"
	FASTJETCONFIGLIBADD="$FASTJETCONFIGLIBADD -lCDFConesPlugin -lD0RunIIConePlugin -lNestedDefsPlugin"
	FASTJETCONFIGLIBADD="$FASTJETCONFIGLIBADD -lTrackJetPlugin -lATLASConePlugin -lCMSIterativeConePlugin"
	FASTJETCONFIGLIBADD="$FASTJETCONFIGLIBADD -lEECambridgePlugin -lJadePlugin"
	fi;
	AC_MSG_NOTICE([FastJet LIBADD = $FASTJETCONFIGLIBADD])
	AC_SUBST(FASTJETCONFIGLIBADD)
	# Check for FastJet headers that require the --enable-all(cxx)plugins option
	FASTJET_ERRMSG="Required FastJet plugin headers were not found: did you build FastJet with the --enable-allcxxplugins option?"
	oldCPPFLAGS=$CPPFLAGS
	CPPFLAGS="$CPPFLAGS -I$FASTJETINCPATH"
	AC_CHECK_HEADER([fastjet/D0RunIIConePlugin.hh], [], [AC_MSG_ERROR([$FASTJET_ERRMSG])])
	AC_CHECK_HEADER([fastjet/TrackJetPlugin.hh], [], [AC_MSG_ERROR([$FASTJET_ERRMSG])])
	CPPFLAGS=$oldCPPFLAGS


	## GNU Scientific Library
	AC_SEARCH_GSL
	AC_CEDAR_HEADERS([gsl], , , [AC_MSG_ERROR([GSL (GNU Scientific Library) is required])])
	oldCPPFLAGS=$CPPFLAGS
	CPPFLAGS="$CPPFLAGS -I$GSLINCPATH"
	AC_CHECK_HEADER([gsl/gsl_vector.h], [], [AC_MSG_ERROR([GSL vectors not found.])])
	CPPFLAGS=$oldCPPFLAGS


	-dnl ## Boost utility library
	-dnl BOOST_REQUIRE([1.55.0])
	-dnl BOOST_FOREACH
	-dnl BOOST_SMART_PTR
	-dnl BOOST_FIND_HEADER([boost/lexical_cast.hpp])
	-dnl BOOST_FIND_HEADER([boost/range.hpp])
	-dnl BOOST_FIND_HEADER([boost/assign.hpp])
	-dnl BOOST_BUG_IN_FOREACH
	-
	-
	## Disable build/install of standard analyses
	AC_ARG_ENABLE([analyses],
	[AC_HELP_STRING(--disable-analyses, [don't try to build or install standard analyses])],
	[], [enable_analyses=yes])
	if test x$enable_analyses != xyes; then
	AC_MSG_WARN([Not building standard Rivet analyses, by request])
	fi
	AM_CONDITIONAL(ENABLE_ANALYSES, [test x$enable_analyses = xyes])


	-## Enable build/install of unvalidated analyses
	-AC_ARG_ENABLE([unvalidated],
	- [AC_HELP_STRING(--enable-unvalidated, [build and install unvalidated analyses])],
	- [], [enable_unvalidated=no])
	-if test x$enable_unvalidated = xyes; then
	- AC_MSG_WARN([Building unvalidated Rivet analyses, by request])
	-else
	- AC_MSG_NOTICE([Not building unvalidated Rivet analyses])
	-fi
	-AM_CONDITIONAL(ENABLE_UNVALIDATED, [test x$enable_unvalidated = xyes])
	-
	-
	-## Disable build/install of validated-but-preliminary analyses
	-AC_ARG_ENABLE([preliminary],
	- [AC_HELP_STRING(--disable-preliminary, [build and install validated-but-preliminary analyses])],
	- [], [enable_preliminary=yes])
	-if test x$enable_preliminary = xyes; then
	- AC_MSG_NOTICE([Building preliminary Rivet analyses])
	-else
	- AC_MSG_NOTICE([Not building preliminary Rivet analyses, by request])
	-fi
	-AM_CONDITIONAL(ENABLE_PRELIMINARY, [test x$enable_preliminary = xyes])
	-
	-
	-## Disable build/install of now-obsolete preliminary analyses
	-AC_ARG_ENABLE([obsolete],
	- [AC_HELP_STRING(--disable-obsolete, [build and install now-obsolete analyses])],
	- [], [enable_obsolete=$enable_preliminary])
	-if test x$enable_obsolete = xyes; then
	- AC_MSG_NOTICE([Building obsolete Rivet analyses])
	-else
	- AC_MSG_NOTICE([Not building obsolete Rivet analyses, by request])
	-fi
	-AM_CONDITIONAL(ENABLE_OBSOLETE, [test x$enable_obsolete = xyes])
	-
	-
	## Build LaTeX docs if possible...
	AC_PATH_PROG(PDFLATEX, pdflatex)
	AM_CONDITIONAL(WITH_PDFLATEX, [test x$PDFLATEX != x])
	## ... unless told otherwise!
	AC_ARG_ENABLE([pdfmanual],
	[AC_HELP_STRING(--enable-pdfmanual, [build and install the manual])],
	[], [enable_pdfmanual=no])
	if test x$enable_pdfmanual = xyes; then
	AC_MSG_WARN([Building Rivet manual, by request])
	fi
	AM_CONDITIONAL(ENABLE_PDFMANUAL, [test x$enable_pdfmanual = xyes])

	## Build Doxygen documentation if possible
	AC_ARG_ENABLE([doxygen],
	[AC_HELP_STRING(--disable-doxygen, [don't try to make Doxygen documentation])],
	[], [enable_doxygen=yes])
	if test x$enable_doxygen = xyes; then
	AC_PATH_PROG(DOXYGEN, doxygen)
	fi
	AM_CONDITIONAL(WITH_DOXYGEN, [test x$DOXYGEN != x])

	## Build asciidoc docs if possible
	AC_PATH_PROG(ASCIIDOC, asciidoc)
	AM_CONDITIONAL(WITH_ASCIIDOC, [test x$ASCIIDOC != x])


	## Python extension
	AC_ARG_ENABLE(pyext, [AC_HELP_STRING(--disable-pyext,
	[don't build Python module (default=build)])],
	[], [enable_pyext=yes])
	-AZ_PYTHON_DEFAULT
	## Basic Python checks
	if test x$enable_pyext == xyes; then
	- AZ_PYTHON_PATH
	- AZ_PYTHON_VERSION_ENSURE([2.5])
	- PYTHON_VERSION=`$PYTHON -c "import sys; print '.'.join(map(str, sys.version_info@<:@:2@:>@));"`
	+ AX_PYTHON_DEVEL([>= '2.6'])
	AC_SUBST(PYTHON_VERSION)
	RIVET_PYTHONPATH=`$PYTHON -c "import distutils.sysconfig; print distutils.sysconfig.get_python_lib(prefix='$prefix', plat_specific=True);"`
	AC_SUBST(RIVET_PYTHONPATH)
	- ## Test for Python header
	- if test -x "$PYTHON"; then
	- AC_MSG_CHECKING([for Python include path])
	- python_incpath=`$PYTHON -c "import distutils.sysconfig; print distutils.sysconfig.get_python_inc();"`
	- AC_MSG_RESULT([$python_incpath])
	- python_header="$python_incpath/Python.h"
	- if test -z "$python_incpath"; then
	- AC_MSG_ERROR([Can't build Python extension since include directory cannot be determined from distutils])
	- enable_pyext=no
	- elif test ! -e "$python_header"; then
	- AC_MSG_ERROR([Can't build Python extension since header file $python_header cannot be found])
	- enable_pyext=no
	- fi
	- else
	+ if test -z "$PYTHON"; then
	AC_MSG_ERROR([Can't build Python extension since python can't be found])
	enable_pyext=no
	fi
	-fi
	-if test x$enable_pyext == xyes; then
	- AC_MSG_NOTICE([All Python build checks successful: 'yoda' Python extension will be built])
	+ if test -z "$PYTHON_CPPFLAGS"; then
	+ AC_MSG_ERROR([Can't build Python extension since Python.h header file cannot be found])
	+ enable_pyext=no
	+ fi
	fi
	AM_CONDITIONAL(ENABLE_PYEXT, [test x$enable_pyext == xyes])


	-## Set extra Python extension build flags (to cope with Cython output code oddities)
	-PYEXT_CXXFLAGS="$CXXFLAGS"
	-AC_CEDAR_CHECKCXXFLAG([-Wno-unused-but-set-variable], [PYEXT_CXXFLAGS="$PYEXT_CXXFLAGS -Wno-unused-but-set-variable"])
	-AC_CEDAR_CHECKCXXFLAG([-Wno-sign-compare], [PYEXT_CXXFLAGS="$PYEXT_CXXFLAGS -Wno-sign-compare"])
	-AC_SUBST(PYEXT_CXXFLAGS)
	-
	-
	## Cython checks
	if test x$enable_pyext == xyes; then
	- AM_CHECK_CYTHON([0.18], [:], [:])
	+ AM_CHECK_CYTHON([0.24.0], [:], [:])
	if test x$CYTHON_FOUND = xyes; then
	- AC_MSG_NOTICE([Cython >= 0.18 found: Python extension source can be rebuilt (for developers)])
	- cython_compiler=$CXX
	+ AC_MSG_NOTICE([Cython >= 0.24 found: Python extension source can be rebuilt (for developers)])
	fi
	+
	+ AC_CHECK_FILE([pyext/rivet/core.cpp],
	+ [],
	+ [if test "x$CYTHON_FOUND" != "xyes"; then
	+ AC_MSG_ERROR([Cython is required for --enable-pyext, no pre-built core.cpp was found.])
	+ fi])
	+
	+ cython_compiler=$CXX
	+ ## Set extra Python extension build flags (to cope with Cython output code oddities)
	+ PYEXT_CXXFLAGS="$CXXFLAGS"
	+ AC_CEDAR_CHECKCXXFLAG([-Wno-unused-but-set-variable], [PYEXT_CXXFLAGS="$PYEXT_CXXFLAGS -Wno-unused-but-set-variable"])
	+ AC_CEDAR_CHECKCXXFLAG([-Wno-sign-compare], [PYEXT_CXXFLAGS="$PYEXT_CXXFLAGS -Wno-sign-compare"])
	+ AC_SUBST(PYEXT_CXXFLAGS)
	+ AC_MSG_NOTICE([All Python build checks successful: 'rivet' Python extension will be built])
	fi
	AM_CONDITIONAL(WITH_CYTHON, [test x$CYTHON_FOUND = xyes])


	-if test x$enable_pyext == xyes; then
	- AC_MSG_NOTICE([All Python build checks successful: 'rivet' Python extension will be built])
	-fi
	-AM_CONDITIONAL(ENABLE_PYEXT, [test x$enable_pyext == xyes])
	-
	-
	## Set default build flags
	AM_CPPFLAGS="-I\$(top_srcdir)/include -I\$(top_builddir)/include"
	#AM_CPPFLAGS="$AM_CPPFLAGS -I\$(top_srcdir)/include/eigen3"
	AM_CPPFLAGS="$AM_CPPFLAGS \$(GSL_CPPFLAGS)"
	dnl AM_CPPFLAGS="$AM_CPPFLAGS \$(BOOST_CPPFLAGS)"
	AM_CPPFLAGS="$AM_CPPFLAGS -I\$(YODAINCPATH)"
	AM_CPPFLAGS="$AM_CPPFLAGS -I\$(HEPMCINCPATH)"
	AM_CPPFLAGS="$AM_CPPFLAGS -I\$(FASTJETINCPATH)"
	AC_CEDAR_CHECKCXXFLAG([-pedantic], [AM_CXXFLAGS="$AM_CXXFLAGS -pedantic"])
	AC_CEDAR_CHECKCXXFLAG([-Wall], [AM_CXXFLAGS="$AM_CXXFLAGS -Wall"])
	AC_CEDAR_CHECKCXXFLAG([-Wno-long-long], [AM_CXXFLAGS="$AM_CXXFLAGS -Wno-long-long"])
	AC_CEDAR_CHECKCXXFLAG([-Wno-format], [AM_CXXFLAGS="$AM_CXXFLAGS -Wno-format"])
	dnl AC_CEDAR_CHECKCXXFLAG([-Wno-unused-variable], [AM_CXXFLAGS="$AM_CXXFLAGS -Wno-unused-variable"])
	AC_CEDAR_CHECKCXXFLAG([-Werror=uninitialized], [AM_CXXFLAGS="$AM_CXXFLAGS -Werror=uninitialized"])
	AC_CEDAR_CHECKCXXFLAG([-Werror=delete-non-virtual-dtor], [AM_CXXFLAGS="$AM_CXXFLAGS -Werror=delete-non-virtual-dtor"])


	## Debug flag (default=-DNDEBUG, enabled=-g)
	AC_ARG_ENABLE([debug], [AC_HELP_STRING(--enable-debug,
	[build with debugging symbols @<:@default=no@:>@])], [], [enable_debug=no])
	if test x$enable_debug == xyes; then
	AM_CXXFLAGS="$AM_CXXFLAGS -g"
	fi


	## Extra warnings flag (default=none)
	AC_ARG_ENABLE([extra-warnings], [AC_HELP_STRING(--enable-extra-warnings,
	[build with extra compiler warnings (recommended for developers) @<:@default=no@:>@])], [], [enable_extra_warnings=no])
	if test x$enable_extra_warnings == xyes; then
	AC_CEDAR_CHECKCXXFLAG([-Wextra], [AM_CXXFLAGS="$AM_CXXFLAGS -Wextra "])
	fi


	AC_SUBST(AM_CPPFLAGS)
	AC_SUBST(AM_CXXFLAGS)

	AC_EMPTY_SUBST
	AC_CONFIG_FILES(include/Makefile include/Rivet/Makefile)
	AC_CONFIG_FILES(src/Makefile)
	AC_CONFIG_FILES(src/Core/Makefile src/Core/yamlcpp/Makefile)
	AC_CONFIG_FILES(src/Tools/Makefile)
	AC_CONFIG_FILES(src/Projections/Makefile)
	AC_CONFIG_FILES(src/Analyses/Makefile)
	AC_CONFIG_FILES(test/Makefile)
	AC_CONFIG_FILES(pyext/Makefile pyext/rivet/Makefile pyext/setup.py)
	AC_CONFIG_FILES(data/Makefile data/refdata/Makefile data/anainfo/Makefile data/plotinfo/Makefile data/texmf/Makefile)
	AC_CONFIG_FILES(doc/Makefile)
	AC_CONFIG_FILES(doc/rivetversion.sty doc/diffanas)
	AC_CONFIG_FILES(bin/Makefile bin/rivet-config bin/rivet-buildplugin)
	AC_CONFIG_FILES(Makefile Doxyfile)
	AC_CONFIG_FILES(rivetenv.sh rivetenv.csh rivet.pc)

	AC_OUTPUT

	if test x$enable_pyrivet == xyes; then
	cat <<EOF

	************************************************************
	RIVET CONFIGURED!

	Now build and install (to the $prefix tree) with e.g.
	make -j2 && make -j2 install

	To use Rivet, we recommend reading HepMC files from a file
	or pipe (the latter may be made with mkfifo) using the
	'rivet' executable.

	For a more pleasant command line experience, you can include
	the data/rivet-completion file into your .bashrc file,
	or your bash_completion.d directory if you have one.

	The rivetenv.*sh files will not be installed, but can help you
	to set up a Rivet runtime environment in future.
	************************************************************
	EOF
	fi
	diff --git a/countanas b/countanas
	new file mode 100755
	--- /dev/null
	+++ b/countanas
	@@ -0,0 +1,9 @@
	+#! /usr/bin/env bash
	+
	+ANADIR=src/Analyses
	+
	+for t in $(hg tags \| cut -d" " -f1 \| sort -r); do
	+ epoch=$(hg parent --rev $t -T "{date}")
	+ nanas=$(hg st -n --rev 0 --rev $t $ANADIR/*.cc \| wc -w)
	+ echo "$t $epoch $nanas"
	+done
	diff --git a/data/anainfo/ALEPH_1991_S2435284.info b/data/anainfo/ALEPH_1991_S2435284.info
	--- a/data/anainfo/ALEPH_1991_S2435284.info
	+++ b/data/anainfo/ALEPH_1991_S2435284.info
	@@ -1,39 +1,40 @@
	Name: ALEPH_1991_S2435284
	Year: 1991
	Summary: Hadronic Z decay charged multiplicity measurement
	Experiment: ALEPH
	Collider: LEP 1
	SpiresID: 2435284
	+InspireID: 319520
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Phys. Lett. B, 273, 181 (1991)
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	The charged particle multiplicity distribution of hadronic Z decays,
	as measured on the peak of the Z resonance using the ALEPH detector at
	LEP. The unfolding procedure was model independent, and the
	distribution was found to have a mean of $20.85 \pm 0.24$, Comparison with
	lower energy data supports the KNO scaling hypothesis. The shape of
	the multiplicity distribution is well described by a log-normal
	distribution, as predicted from a cascading model for multi-particle
	production.
	BibKey: Decamp:1991uz
	BibTeX: '@Article{Decamp:1991uz,
	author = "Decamp, D. and others",
	collaboration = "ALEPH",
	title = "{Measurement of the charged particle multiplicity
	distribution in hadronic Z decays}",
	journal = "Phys. Lett.",
	volume = "B273",
	year = "1991",
	pages = "181-192",
	doi = "10.1016/0370-2693(91)90575-B",
	SLACcitation = "%%CITATION = PHLTA,B273,181;%%"
	}'
	diff --git a/data/anainfo/ALEPH_1995_I382179.info b/data/anainfo/ALEPH_1995_I382179.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ALEPH_1995_I382179.info
	@@ -0,0 +1,31 @@
	+Name: ALEPH_1995_I382179
	+Year: 1995
	+Summary: Inclusive pi+-, K+- and (p, anti-p) differential cross-sections at the Z resonance
	+Experiment: ALEPH
	+Collider: LEP
	+InspireID: 382179
	+Status: VALIDATED
	+Authors:
	+ - Simone Amoroso <amoroso@cern.ch>
	+References:
	+ - Z.Phys. C66 (1995) 355-366
	+ - doi:10.1007/BF01556360
	+RunInfo: e+e- production at the Z-peak with hadronic decays
	+Beams: [e+,e-]
	+Energies: [91.2]
	+Description: Inclusive spectra of pions, Kaons, protons and antiprotons in hadronic decays of the Z0 measured as a function of z.
	+BibKey: Buskulic:1994ft
	+BibTeX: '@article{Buskulic:1994ft,
	+ author = "Buskulic, D. and others",
	+ title = "{Inclusive pi+-, K+- and (p, anti-p) differential
	+ cross-sections at the Z resonance}",
	+ collaboration = "ALEPH",
	+ journal = "Z. Phys.",
	+ volume = "C66",
	+ year = "1995",
	+ pages = "355-366",
	+ doi = "10.1007/BF01556360",
	+ reportNumber = "CERN-PPE-94-201, FSU-SCRI-95-62",
	+ SLACcitation = "%%CITATION = ZEPYA,C66,355;%%"
	+}'
	+
	diff --git a/data/anainfo/ALEPH_1996_S3196992.info b/data/anainfo/ALEPH_1996_S3196992.info
	--- a/data/anainfo/ALEPH_1996_S3196992.info
	+++ b/data/anainfo/ALEPH_1996_S3196992.info
	@@ -1,40 +1,41 @@
	Name: ALEPH_1996_S3196992
	Year: 1996
	Summary: Measurement of the quark to photon fragmentation function
	Experiment: ALEPH
	Collider: LEP Run 1
	SpiresID: 3196992
	+InspireID: 398193
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Z.Phys.C69:365-378,1996
	- doi:10.1007/s002880050037
	RunInfo:
	$e^+e^-\to$ jets with $\pi$ and $\eta$ decays turned off.
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Earlier measurements at LEP of isolated hard photons in hadronic Z decays,
	attributed to radiation from primary quark pairs, have been extended in the
	ALEPH experiment to include hard photon production inside hadron jets. Events
	are selected where all particles combine democratically to form hadron jets,
	one of which contains a photon with a fractional energy $z > 0.7$. After
	statistical subtraction of non-prompt photons, the quark-to-photon
	fragmentation function, $D(z)$, is extracted directly from the measured 2-jet
	rate.
	BibKey: Buskulic:1995au
	BibTeX: '@Article{Buskulic:1995au,
	author = "Buskulic, D. and others",
	collaboration = "ALEPH",
	title = "{First measurement of the quark to photon fragmentation
	function}",
	journal = "Z. Phys.",
	volume = "C69",
	year = "1996",
	pages = "365-378",
	doi = "10.1007/s002880050037",
	SLACcitation = "%%CITATION = ZEPYA,C69,365;%%"
	}'
	diff --git a/data/anainfo/ALEPH_1996_S3486095.info b/data/anainfo/ALEPH_1996_S3486095.info
	--- a/data/anainfo/ALEPH_1996_S3486095.info
	+++ b/data/anainfo/ALEPH_1996_S3486095.info
	@@ -1,33 +1,34 @@
	Name: ALEPH_1996_S3486095
	Year: 1996
	Summary: Studies of QCD with the ALEPH detector.
	Experiment: ALEPH
	Collider: LEP 1
	SpiresID: 3486095
	+InspireID: 428072
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	References:
	- Phys. Rept., 294, 1--165 (1998)
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Summary paper of QCD results as measured by ALEPH at LEP 1. The
	publication includes various event shape variables, multiplicities
	(identified particles and inclusive), and particle spectra.
	BibKey: Barate:1996fi
	BibTeX: '@Article{Barate:1996fi,
	author = "Barate, R. and others",
	collaboration = "ALEPH",
	title = "{Studies of quantum chromodynamics with the ALEPH detector}",
	journal = "Phys. Rept.",
	volume = "294",
	year = "1998",
	pages = "1-165",
	doi = "10.1016/S0370-1573(97)00045-8",
	SLACcitation = "%%CITATION = PRPLC,294,1;%%"
	}'
	diff --git a/data/anainfo/ALEPH_1999_S4193598.info b/data/anainfo/ALEPH_1999_S4193598.info
	--- a/data/anainfo/ALEPH_1999_S4193598.info
	+++ b/data/anainfo/ALEPH_1999_S4193598.info
	@@ -1,36 +1,37 @@
	Name: ALEPH_1999_S4193598
	Year: 1999
	Summary: Scaled energy distribution of $D^*$ at LEP
	Experiment: ALEPH
	Collider: LEP
	SpiresID: 4193598
	+InspireID: 507422
	Status: VALIDATED
	Authors:
	- Holger Schulz <hschulz@physik.hu-berlin.de>
	References:
	- Eur.Phys.J.C16:597-611,2000
	- hep-ex/9909032
	- CERN-EP-99-094
	RunInfo:
	Hadronic $Z$ decays at 91.2\;GeV.
	NumEvents: 1000000
	NeedCrossSection: no
	Beams: [e+, e-]
	Energies: [91.2]
	Description:
	'Study of charm production in $Z$ decays. Here, only the scaled energy distribution
	of $D^{*\pm}$ is implemented. Should be very important for fragmentation tuning.'
	BibKey: Barate:1999bg
	BibTeX: '@article{Barate:1999bg,
	author = "Barate, R. and others",
	title = "{Study of charm production in Z decays}",
	collaboration = "ALEPH Collaboration",
	journal = "Eur.Phys.J.",
	volume = "C16",
	pages = "597-611",
	doi = "10.1007/s100520000421",
	year = "2000",
	eprint = "hep-ex/9909032",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	}'
	diff --git a/data/anainfo/ALEPH_2001_S4656318.info b/data/anainfo/ALEPH_2001_S4656318.info
	--- a/data/anainfo/ALEPH_2001_S4656318.info
	+++ b/data/anainfo/ALEPH_2001_S4656318.info
	@@ -1,39 +1,40 @@
	Name: ALEPH_2001_S4656318
	Year: 2001
	Summary: Study of the fragmentation of b quarks into B mesons at the Z peak
	Experiment: ALEPH
	Collider: LEP 1
	SpiresID: 4656318
	+InspireID: 558327
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Lett.B512:30-48,2001.
	- hep-ex/0106051
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Measurement of the $b$-quark fragmentation function by ALEPH using
	LEP 1 data. The fragmentation function for both weakly decaying and
	leading $b$-quarks has been determined. The data used for the plots has
	been renormalised to give a differential distribution rather than the bin-by-bin
	average in HEPDATA.
	BibKey: Heister:2001jg
	BibTeX: '@Article{Heister:2001jg,
	author = "Heister, A. and others",
	collaboration = "ALEPH",
	title = "{Study of the fragmentation of b quarks into B mesons at
	the Z peak}",
	journal = "Phys. Lett.",
	volume = "B512",
	year = "2001",
	pages = "30-48",
	eprint = "hep-ex/0106051",
	archivePrefix = "arXiv",
	doi = "10.1016/S0370-2693(01)00690-6",
	SLACcitation = "%%CITATION = HEP-EX/0106051;%%"
	}'
	diff --git a/data/anainfo/ALEPH_2002_S4823664.info b/data/anainfo/ALEPH_2002_S4823664.info
	--- a/data/anainfo/ALEPH_2002_S4823664.info
	+++ b/data/anainfo/ALEPH_2002_S4823664.info
	@@ -1,37 +1,38 @@
	Name: ALEPH_2002_S4823664
	Year: 2002
	Summary: $\eta$ and $\omega$ Production in Hadronic $Z^0$ Decays
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 4823664
	+InspireID: 569165
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Lett. B528 (2002) 19-33
	- hep-ex/0201012
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: The production of $\eta$ and $\omega$ mesons measured using 4 millon $Z^0$ events
	by the ALEPH experiment at LEP. Only the fragmentation functions are implemented.
	BibKey: Heister:2001kp
	BibTeX: '@article{Heister:2001kp,
	author = "Heister, A. and others",
	title = "{Inclusive production of the omega and eta mesons in Z
	decays, and the muonic branching ratio of the omega}",
	collaboration = "ALEPH Collaboration",
	journal = "Phys.Lett.",
	volume = "B528",
	pages = "19-33",
	doi = "10.1016/S0370-2693(02)01220-0",
	year = "2002",
	eprint = "hep-ex/0201012",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-EP-2001-090",
	SLACcitation = "%%CITATION = HEP-EX/0201012;%%",
	}'
	diff --git a/data/anainfo/ALEPH_2004_S5765862.info b/data/anainfo/ALEPH_2004_S5765862.info
	--- a/data/anainfo/ALEPH_2004_S5765862.info
	+++ b/data/anainfo/ALEPH_2004_S5765862.info
	@@ -1,38 +1,39 @@
	Name: ALEPH_2004_S5765862
	Year: 2004
	Summary: Jet rates and event shapes at LEP I and II
	Experiment: ALEPH
	Collider: LEP Run 1 and 2
	SpiresID: 5765862
	+InspireID: 636645
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Eur.Phys.J.C35:457-486,2004
	- doi:10.1140/epjc/s2004-01891-4
	- http://cdsweb.cern.ch/record/690637/files/ep-2003-084.pdf
	RunInfo:
	$e^+ e^- \to$ jet jet (+ jets)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2, 133, 161, 172, 183, 189, 197, 200, 206]
	PtCuts: [0]
	Description:
	Jet rates, event-shape variables and inclusive charged particle spectra are
	measured in $e^+ e^-$ collisions at CMS energies between 91 and 209 GeV.
	The previously published data at 91.2 GeV and 133 GeV have been re-processed
	and the higher energy data are presented here for the first time.
	Note that the data have been corrected to include neutrinos.
	BibKey: Heister:2003aj
	BibTeX: '@Article{Heister:2003aj,
	author = "Heister, A. and others",
	collaboration = "ALEPH",
	title = "{Studies of QCD at e+ e- centre-of-mass energies between
	91-GeV and 209-GeV}",
	journal = "Eur. Phys. J.",
	volume = "C35",
	year = "2004",
	pages = "457-486",
	doi = "10.1140/epjc/s2004-01891-4",
	SLACcitation = "%%CITATION = EPHJA,C35,457;%%"
	}'
	diff --git a/data/anainfo/ALICE_2010_S8624100.info b/data/anainfo/ALICE_2010_S8624100.info
	--- a/data/anainfo/ALICE_2010_S8624100.info
	+++ b/data/anainfo/ALICE_2010_S8624100.info
	@@ -1,42 +1,43 @@
	Name: ALICE_2010_S8624100
	Year: 2010
	-Summary: Charged particle multiplicities at 0.9 and 2.36\;TeV in three different pseudorapidity intervals.
	+Summary: Charged particle multiplicities at 0.9 and 2.36\;TeV in three different pseudorapidity intervals
	Experiment: ALICE
	Collider: LHC
	SpiresID: 8624100
	+InspireID: 852450
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	- Jan Fiete Grosse-Oetringhaus@cern.ch <Jan.Fiete.Grosse-Oetringhaus@cern.ch>
	References:
	- Eur.Phys.J.C68:89-108,2010
	- arXiv:1004.3034 [hep-ex]
	RunInfo:
	QCD and diffractive events at $\sqrt{s} = 0.9\;\TeV$ and $\sqrt{s} = 2.36\;\TeV$
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [900, 2360]
	Description:
	'This is an ALICE analysis where charged particle multiplicities (including
	the zero bin) have been measured in three different pseudorapidity intervals
	($\|\eta\|<0.5; \|\eta\|<1.0; \|\eta\|<1.3$. Only the INEL distributions have
	been considered here, i.e. this analysis can only be meaningfully compared to
	PYTHIA 6 with diffractive processes disabled. The data were taken at 900 and
	2360\;GeV.'
	BibKey: Aamodt:2010ft
	BibTeX: '@Article{Aamodt:2010ft,
	author = "Aamodt, K. and others",
	collaboration = "ALICE",
	title = "{Charged-particle multiplicity measurement in proton-proton
	collisions at $\sqrt{s} = 0.9$ and 2.36 TeV with ALICE at
	LHC}",
	journal = "Eur. Phys. J.",
	volume = "C68",
	year = "2010",
	pages = "89-108",
	eprint = "1004.3034",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1140/epjc/s10052-010-1339-x",
	SLACcitation = "%%CITATION = 1004.3034;%%"
	}'
	diff --git a/data/anainfo/ALICE_2010_S8625980.info b/data/anainfo/ALICE_2010_S8625980.info
	--- a/data/anainfo/ALICE_2010_S8625980.info
	+++ b/data/anainfo/ALICE_2010_S8625980.info
	@@ -1,37 +1,38 @@
	Name: ALICE_2010_S8625980
	Year: 2010
	-Summary: Pseudorapidities at three energies, charged multiplicity at 7 TeV.
	+Summary: Pseudorapidities at three energies, charged multiplicity at 7 TeV
	Experiment: ALICE
	Collider: LHC
	SpiresID: 8625980
	+InspireID: 852264
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	- Jan Fiete Grosse-Oetringhaus@cern.ch <Jan.Fiete.Grosse-Oetringhaus@cern.ch>
	References:
	- Eur.Phys.J. C68 (2010) 345-354
	- arXiv:1004.3514 [hep-ex]
	RunInfo:
	Diffractive events need to be enabled.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [900, 2360, 7000]
	Description:
	'This is an ALICE publication with pseudorapities for 0.9, 2.36 and $7\;\TeV$
	and the charged multiplicity at $7\;\TeV$. The analysis requires at least on
	charged particle in the event. Only the INEL distributions are considered here'
	BibKey: Aamodt:2010pp
	BibTeX: '@article{Aamodt:2010pp,
	author = "Aamodt, K. and others",
	title = "{Charged-particle multiplicity measurement in
	proton-proton collisions at $\sqrt{s} = 7$ TeV with ALICE at LHC}",
	collaboration = "ALICE",
	journal = "Eur.Phys.J.",
	volume = "C68",
	pages = "345-354",
	doi = "10.1140/epjc/s10052-010-1350-2",
	year = "2010",
	eprint = "1004.3514",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	}'
	diff --git a/data/anainfo/ALICE_2010_S8706239.info b/data/anainfo/ALICE_2010_S8706239.info
	--- a/data/anainfo/ALICE_2010_S8706239.info
	+++ b/data/anainfo/ALICE_2010_S8706239.info
	@@ -1,40 +1,41 @@
	Name: ALICE_2010_S8706239
	Year: 2010
	Summary: Charged particle $\langle p_\perp \rangle$ vs. $N_\text{ch}$ in $pp$ collisions at 900 GeV
	Experiment: ALICE
	Collider: LHC
	SpiresID: 8706239
	+InspireID: 860416
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	- Jan Fiete Grosse-Oetringhaus@cern.ch <Jan.Fiete.Grosse-Oetringhaus@cern.ch>
	References:
	- Phys.Lett.B693:53-68,2010
	- arXiv:1007.0719 [hep-ex]
	RunInfo:
	Diffractive events need to be switched on
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [900]
	PtCuts:
	Description:
	'ALICE measurement of $\langle p_\perp \rangle$ vs. $N_\text{ch}$ and
	invariant particle yield (as function of $p_\perp$) in proton-proton
	collisions at $\sqrt{s} = 900\;\GeV$.'
	BibKey: Aamodt:2010my
	BibTeX: '@Article{Aamodt:2010my,
	author = "Aamodt, K and others",
	collaboration = "ALICE",
	title = "{Transverse momentum spectra of charged particles in
	proton-proton collisions at $\sqrt{s} = 900$~GeV with ALICE
	at the LHC}",
	journal = "Phys. Lett.",
	volume = "B693",
	year = "2010",
	pages = "53-68",
	eprint = "1007.0719",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1016/j.physletb.2010.08.026",
	SLACcitation = "%%CITATION = 1007.0719;%%"
	}'
	diff --git a/data/anainfo/ALICE_2011_S8909580.info b/data/anainfo/ALICE_2011_S8909580.info
	--- a/data/anainfo/ALICE_2011_S8909580.info
	+++ b/data/anainfo/ALICE_2011_S8909580.info
	@@ -1,38 +1,39 @@
	Name: ALICE_2011_S8909580
	Year: 2011
	Summary: Strange particle production in proton-proton collisions at $\sqrt{s} = 0.9$ TeV with ALICE at the LHC.
	Experiment: ALICE
	Collider: LHC
	SpiresID: 8909580
	+InspireID: 881474
	Status: VALIDATED
	Authors:
	- Pablo Bueno Gomez <UO189399@uniovi.es>
	- Eva Sicking <esicking@cern.ch>
	References:
	- Eur.Phys.J.C71:1594,2011.
	RunInfo:
	Diffractive events need to be switched on.
	NumEvents: 5000000
	Beams: [p+, p+]
	Energies: [900]
	PtCuts:
	Description:
	'Tranverse momentum spectra of strange particles ($K^0_S$, $\Lambda$, $\phi$
	and $\Xi$) in $pp$ collisions at $\sqrt{s} = 0.9$\;TeV with ALICE at the LHC.
	The ratio of cross-sections as a function of pT for $\Lambda/K^0_S$ is also included.'
	BibKey: Aamodt:2011zza
	BibTeX: '@article{Aamodt:2011zza,
	author = "Aamodt, K. and others",
	title = "{Strange particle production in proton--proton collisions at $\sqrt{s} = 0.9$ TeV with ALICE at the LHC}",
	collaboration = "ALICE Collaboration",
	journal = "Eur.Phys.J.",
	volume = "C71",
	pages = "1594",
	doi = "10.1140/epjc/s10052-011-1594-5",
	year = "2011",
	eprint = "1012.3257",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2010-065",
	SLACcitation = "%%CITATION = ARXIV:1012.3257;%%",
	}'
	diff --git a/data/anainfo/ALICE_2011_S8945144.info b/data/anainfo/ALICE_2011_S8945144.info
	--- a/data/anainfo/ALICE_2011_S8945144.info
	+++ b/data/anainfo/ALICE_2011_S8945144.info
	@@ -1,40 +1,41 @@
	Name: ALICE_2011_S8945144
	Year: 2011
	-Summary: Tranverse momentum spectra of pions, kaons and protons in pp collisions at 0.9 TeV
	+Summary: Transverse momentum spectra of pions, kaons and protons in pp collisions at 0.9 TeV
	Experiment: ALICE
	Collider: LHC
	SpiresID: 8945144
	+InspireID: 885104
	Status: VALIDATED
	Authors:
	- Pablo Bueno Gomez <UO189399@uniovi.es>
	- Eva Sicking <esicking@cern.ch>
	References:
	- Eur.Phys.J.C71:1655,2011.
	- arXiv:1101.4110 [hep-ex]
	RunInfo:
	Diffractive events need to be enabled.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [900]
	PtCuts:
	Description:
	'Obtaining the transverse momentum spectra of pions, kaons and protons in $pp$ collisions at
	$\sqrt{s} = 0.9$ TeV with ALICE at the LHC. Mean transverse momentum as a function of the
	mass of the emitted particle is also included.'
	BibKey: Aamodt:2011zj
	BibTeX: '@article{Aamodt:2011zj,
	author = "Aamodt, K. and others",
	title = "{Production of pions, kaons and protons in $pp$
	collisions at $\sqrt{s}= 900$ GeV with ALICE at the LHC}",
	collaboration = "ALICE",
	journal = "Eur.Phys.J.",
	volume = "C71",
	pages = "1655",
	doi = "10.1140/epjc/s10052-011-1655-9",
	year = "2011",
	eprint = "1101.4110",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2010-085",
	SLACcitation = "%%CITATION = ARXIV:1101.4110;%%",
	}'
	diff --git a/data/anainfo/ALICE_2012_I1116147.info b/data/anainfo/ALICE_2012_I1116147.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ALICE_2012_I1116147.info
	@@ -0,0 +1,38 @@
	+Name: ALICE_2012_I1116147
	+Year: 2012
	+Summary: pT of neutral pions and $\eta$ mesons in $pp$ collisions at $7\,$TeV and $0.9\,$TeV
	+Experiment: ALICE
	+Collider: LHC
	+InspireID: 1116147
	+Status: VALIDATED
	+Authors:
	+ - Hendrik Poppenborg hendrik.poppenborg@cern.ch
	+References:
	+ - "Phys.Lett. B717 (2012) 162-172"
	+ - "doi:10.1016/j.physletb.2012.09.015"
	+ - "arXiv:hep-ex/1205.5724"
	+RunInfo: Generic $pp$ collision events.
	+Beams: [p+, p+]
	+Energies: [900, 7000]
	+Description:
	+ Transverse momentum spectra of neutral pions and $\eta$ mesons and the ratio $\pi^0/\eta$,
	+ obtained at mid-rapidity in pp collisions at $\sqrt{s} = 7\,$TeV with ALICE at the LHC.
	+ The transverse momentum spectrum of neutral pions is also given for $\sqrt{s} = 0.9\,$TeV.
	+BibKey: Abelev:2012cn
	+BibTeX: '@article{Abelev:2012cn,
	+ author = "Abelev, B. and others",
	+ title = "{Neutral pion and $\eta$ meson production in
	+ proton-proton collisions at $\sqrt{s}=0.9$ TeV and
	+ $\sqrt{s}=7$ TeV}",
	+ collaboration = "ALICE",
	+ journal = "Phys. Lett.",
	+ volume = "B717",
	+ year = "2012",
	+ pages = "162-172",
	+ doi = "10.1016/j.physletb.2012.09.015",
	+ eprint = "1205.5724",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2012-001",
	+ SLACcitation = "%%CITATION = ARXIV:1205.5724;%%"
	+}'
	diff --git a/data/anainfo/ALICE_2015_I1357424.info b/data/anainfo/ALICE_2015_I1357424.info
	--- a/data/anainfo/ALICE_2015_I1357424.info
	+++ b/data/anainfo/ALICE_2015_I1357424.info
	@@ -1,39 +1,37 @@
	Name: ALICE_2015_I1357424
	Year: 2015
	-Summary: Tranverse momentum spectra of pions, kaons and protons in pp collisions at 7 TeV
	+Summary: Transverse momentum spectra of pions, kaons and protons in $pp$ collisions at 7 TeV
	Experiment: ALICE
	Collider: LHC
	InspireID: 1357424
	Status: VALIDATED
	Authors:
	- Andreas Morsch andreas.morsch@cern.ch
	#References:
	# - <Example: Phys.Lett.B639:151-158,2006, Erratum-ibid.B658:285-289,2008>
	# - <Example: doi:10.1016/j.physletb.2006.04.048>
	# - <Example: arXiv:hep-ex/0511054 (plus erratum)>
	RunInfo: Inelastic pp collisions at sqrt(s) = 7 TeV
	NumEvents: 1000000
	NeedCrossSection: no
	Beams: [p+, p+]
	Energies: [7000]
	#PtCuts: <Insert list of kinematic pT cuts in GeV, e.g. [0, 20]>
	#NeedCrossSection: True
	Description:
	'Obtaining the transverse momentum spectra of primary pions, kaons and protons in $pp$ collisions at
	$\sqrt{s} = 7$ TeV with ALICE at the LHC. K/pi and p/pi ratios are also included.'
	BibKey: Adam:2015qaa
	BibTeX: '@article{Adam:2015qaa,
	author = "Adam, Jaroslav and others",
	title = "{Measurement of pion, kaon and proton production in
	proton-proton collisions at $\sqrt{s}=7$ TeV}",
	collaboration = "ALICE",
	year = "2015",
	eprint = "1504.00024",
	archivePrefix = "arXiv",
	primaryClass = "nucl-ex",
	reportNumber = "CERN-PH-EP-2015-068",
	SLACcitation = "%%CITATION = ARXIV:1504.00024;%%",
	}'
	ToDo:
	-
	-
	diff --git a/data/anainfo/ARGUS_1993_S2653028.info b/data/anainfo/ARGUS_1993_S2653028.info
	--- a/data/anainfo/ARGUS_1993_S2653028.info
	+++ b/data/anainfo/ARGUS_1993_S2653028.info
	@@ -1,33 +1,34 @@
	Name: ARGUS_1993_S2653028
	Summary: Inclusive production of charged pions, kaons and protons in $\Upsilon(4S)$ decays.
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Z.Phys. C58 (1993) 191-198
	RunInfo:
	$e^+ e^-$ analysis on the $\Upsilon(4S)$ resonance.
	NumEvents: 1000000
	SpiresID: 2653028
	+InspireID: 340894
	Beams: [e+, e-]
	Energies: [10.58]
	PtCuts: [0]
	Description: Measurement of inclusive production of charged pions, kaons and protons
	from $\Upsilon(4S)$ decays. Kaon spectra are determined in two different ways using
	particle identification and detecting decays in-flight.
	Results are background continuum subtracted. This analysis is useful for
	tuning $B$ meson decay modes.
	BibKey: Albrecht:1992qf
	BibTeX: '@article{Albrecht:1992qf,
	author = "Albrecht, H. and others",
	title = "{Inclusive production of charged pions, kaons and protons
	in upsilon (4S) decays}",
	collaboration = "ARGUS Collaboration",
	journal = "Z.Phys.",
	volume = "C58",
	pages = "191-198",
	doi = "10.1007/BF01560337",
	year = "1993",
	reportNumber = "DESY-92-155",
	SLACcitation = "%%CITATION = ZEPYA,C58,191;%%",
	}'
	diff --git a/data/anainfo/ARGUS_1993_S2669951.info b/data/anainfo/ARGUS_1993_S2669951.info
	--- a/data/anainfo/ARGUS_1993_S2669951.info
	+++ b/data/anainfo/ARGUS_1993_S2669951.info
	@@ -1,33 +1,34 @@
	Name: ARGUS_1993_S2669951
	Summary: Production of the $\eta'(958)$ and $f_0(980)$ in $e^+e^-$ annihilation in the Upsilon region.
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Z.Phys. C58 (1993) 199-206
	RunInfo:
	$e^+ e^-$ analysis near the $\Upsilon(4S)$ resonance.
	NumEvents: 1000000
	SpiresID: 2669951
	+InspireID: 342061
	Beams: [e+, e-]
	Energies: [9.46,10.02,10.45]
	PtCuts: [0]
	Description: Measurement of the inclusive production of the $\eta'(958)$ and $f_0(980)$
	mesons in $e^+e^-$ annihilation in the Upsilon region.
	Data are taken on the $\Upsilon(1S)$, $\Upsilon(2S)$ and $\Upsilon(4S)$
	resonances and in the nearby continuum (9.36 to 10.45 GeV center-of-mass energy)
	BibKey: Albrecht:1992nu
	BibTeX: '@article{Albrecht:1992nu,
	author = "Albrecht, H. and others",
	title = "{Inclusive production of eta-prime (958) and f0 (975)
	mesons in the upsilon energy region}",
	collaboration = "ARGUS Collaboration",
	journal = "Z.Phys.",
	volume = "C58",
	pages = "199-206",
	doi = "10.1007/BF01560338",
	year = "1993",
	reportNumber = "DESY-92-174",
	SLACcitation = "%%CITATION = ZEPYA,C58,199;%%",
	}
	'
	diff --git a/data/anainfo/ARGUS_1993_S2789213.info b/data/anainfo/ARGUS_1993_S2789213.info
	--- a/data/anainfo/ARGUS_1993_S2789213.info
	+++ b/data/anainfo/ARGUS_1993_S2789213.info
	@@ -1,32 +1,33 @@
	Name: ARGUS_1993_S2789213
	Summary: Inclusive production of $K^*(892)$, $\rho^0(770)$, and $\omega(783)$ mesons in the upsilon energy region.
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Z.Phys. C61 (1994) 1-18
	RunInfo:
	$e^+ e^-$ analysis in the 10 GeV CMS energy range
	NumEvents: 1000000
	SpiresID: 2789213
	+InspireID: 356616
	Beams: [e+, e-]
	Energies: [9.46,10.45,10.58]
	PtCuts: [0]
	Description: Measurement of the inclusive production of the vector mesons $K^*(892)$,
	$\rho^0(770)$ and $\omega(783)$ in $e^+e^-$ annihilation in the Upsilon
	region by the Argus Collaboration. Useful for tuning simulations of B meson and
	bottomium decays.
	BibKey: Albrecht:1993fs
	BibTeX: '@article{Albrecht:1993fs,
	author = "Albrecht, H. and others",
	title = "{Inclusive production of $K^*(892)$, $\rho^0(770)$, and
	$\omega(783)$ mesons in the $\Upsilon$ energy region}",
	collaboration = "ARGUS Collaboration",
	journal = "Z.Phys.",
	volume = "C61",
	pages = "1-18",
	doi = "10.1007/BF01641882",
	year = "1994",
	reportNumber = "DESY-93-084",
	SLACcitation = "%%CITATION = ZEPYA,C61,1;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2010_S8591806.info b/data/anainfo/ATLAS_2010_S8591806.info
	--- a/data/anainfo/ATLAS_2010_S8591806.info
	+++ b/data/anainfo/ATLAS_2010_S8591806.info
	@@ -1,38 +1,39 @@
	Name: ATLAS_2010_S8591806
	Year: 2010
	Summary: Charged particles at 900 GeV in ATLAS
	Experiment: ATLAS
	Collider: LHC 900GeV
	SpiresID: 8591806
	+InspireID: 849050
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:1003.3124
	RunInfo:
	pp QCD interactions at 900 GeV including diffractive events.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [900]
	PtCuts: [0]
	Description:
	The first measurements with the ATLAS detector at the LHC.
	Data were collected using a minimum-bias trigger in December 2009 during
	proton-proton collisions at a centre of mass energy of 900 GeV. The charged-
	particle density, its dependence on transverse momentum and pseudorapid-
	ity, and the relationship between transverse momentum and charged-particle
	multiplicity are measured for events with at least one charged particle in
	the kinematic range $\|\eta\| < 2.5$ and $p_\perp > 500$ MeV.
	All data is corrected to the particle level.
	BibKey: Aad:2010rd
	BibTeX: '@Article{Aad:2010rd,
	author = "Aad, G. and others",
	collaboration = "ATLAS",
	title = "{Charged-particle multiplicities in $pp$ interactions at $\sqrt{s} = 900$ GeV measured with the ATLAS detector at the LHC}",
	year = "2010",
	eprint = "1003.3124",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1016/j.physletb.2010.03.064",
	SLACcitation = "%%CITATION = 1003.3124;%%"
	}'
	diff --git a/data/anainfo/ATLAS_2010_S8817804.info b/data/anainfo/ATLAS_2010_S8817804.info
	--- a/data/anainfo/ATLAS_2010_S8817804.info
	+++ b/data/anainfo/ATLAS_2010_S8817804.info
	@@ -1,39 +1,40 @@
	Name: ATLAS_2010_S8817804
	Year: 2010
	Summary: Inclusive jet cross section and di-jet mass and chi spectra at 7 TeV in ATLAS
	Experiment: ATLAS
	Collider: LHC 7TeV
	SpiresID: 8817804
	+InspireID: 871366
	Status: VALIDATED
	Authors:
	- James Monk <jmonk@cern.ch>
	References:
	- arXiv:1009.5908
	RunInfo:
	pp QCD jet production with a minimum jet pT of 60 GeV (inclusive) or 30 GeV (di-jets) at 7 TeV.
	NumEvents: 10000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [30, 60]
	Description:
	The first jet cross section measurement made with the ATLAS detector at the LHC.
	Anti-kt jets with $R=0.4$ and $R=0.6$ are resconstructed within
	$\|y\|<2.8$ and above 60~GeV for the inclusive jet
	cross section plots. For the di-jet plots the second jet must have pT>30~GeV.
	Jet pT and di-jet mass spectra are plotted in bins of rapidity between $\|y\| = $
	0.3, 0.8, 1.2, 2.1, and 2.8. Di-jet $\chi$ spectra are plotted in bins of
	di-jet mass between 340 GeV, 520 GeV, 800 GeV and 1200 GeV.
	NeedCrossSection: yes
	BibKey: Aad:2010wv
	BibTeX: '@Article{Aad:2010wv,
	author = "Aad, G. and others",
	collaboration = "ATLAS",
	title = "{Measurement of inclusive jet and dijet cross sections in
	proton-proton collisions at 7 TeV centre-of-mass energy
	with the ATLAS detector}",
	year = "2010",
	eprint = "1009.5908",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1009.5908;%%"
	}'
	diff --git a/data/anainfo/ATLAS_2010_S8894728.info b/data/anainfo/ATLAS_2010_S8894728.info
	--- a/data/anainfo/ATLAS_2010_S8894728.info
	+++ b/data/anainfo/ATLAS_2010_S8894728.info
	@@ -1,33 +1,34 @@
	Name: ATLAS_2010_S8894728
	Year: 2010
	Summary: Track-based underlying event at 900 GeV and 7 TeV in ATLAS
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 8894728
	+InspireID: 879407
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	References:
	- arXiv:1012.0791
	RunInfo:
	pp QCD interactions at 900 GeV and 7 TeV. Diffractive events should be
	included, but only influence the lowest bins. Multiple kinematic cuts
	should not be required.
	NumEvents: 10000000
	Beams: [p+, p+]
	Energies: [900, 7000]
	PtCuts: [0]
	Description:
	The underlying event measurements with the ATLAS detector at the LHC
	at the center of mass energies of 900 GeV and 7 TeV. The observables
	sensitive to the underlying event, i.e the charged particle density
	and charged pT sum, as well as their standard deviations and the
	average pT, are measured as functions of the leading track. A track pT
	cut of 500 MeV is applied for most observables, but the main profile
	plots are also shown for a lower track cut of 100 MeV, which includes
	much more of the soft cross-section. The angular distribution of the
	charged tracks with respect to the leading track is also studied, as
	are the correlation between mean transverse momentum and charged
	particle multiplicity, and the `plateau' height as a function of the
	leading track $\|\eta\|$.
	diff --git a/data/anainfo/ATLAS_2010_S8914702.info b/data/anainfo/ATLAS_2010_S8914702.info
	--- a/data/anainfo/ATLAS_2010_S8914702.info
	+++ b/data/anainfo/ATLAS_2010_S8914702.info
	@@ -1,33 +1,34 @@
	Name: ATLAS_2010_S8914702
	Year: 2010
	Summary: Inclusive isolated prompt photon analysis
	Experiment: ATLAS
	Collider: LHC 7TeV
	SpiresID: 8914702
	+InspireID: 882463
	Status: VALIDATED
	Authors:
	- Mike Hance <michael.hance@cern.ch>
	References:
	- arXiv:1012.4389 [hep-ex]
	RunInfo:
	Inclusive photon+X events (primary gamma+jet events) at $\sqrt{s} = 7$~TeV.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [15]
	Description:
	'A measurement of the cross section for inclusive isolated photon production at $\sqrt{s} = 7$ TeV.
	The measurement covers three ranges in $\|\eta\|$: [0.00,0.60), [0.60,1.37), and [1.52,1.81), for
	$E_T^\gamma>15$~GeV. The measurement uses 880~nb$^{-1}$ of integrated luminosity collected with
	the ATLAS detector.'
	NeedCrossSection: yes
	BibKey: Collaboration:2010sp
	BibTeX: '@Article{Collaboration:2010sp,
	author = "Collaboration, The ATLAS",
	title = "{Measurement of the inclusive isolated prompt photon cross section in $pp$ collisions at $\sqrt{s} = 7$ TeV with the ATLAS detector}",
	year = "2010",
	eprint = "1012.4389",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1012.4389;%%"
	}'
	diff --git a/data/anainfo/ATLAS_2010_S8918562.info b/data/anainfo/ATLAS_2010_S8918562.info
	--- a/data/anainfo/ATLAS_2010_S8918562.info
	+++ b/data/anainfo/ATLAS_2010_S8918562.info
	@@ -1,30 +1,31 @@
	Name: ATLAS_2010_S8918562
	Year: 2010
	Summary: Track-based minimum bias at 900 GeV and 2.36 and 7 TeV in ATLAS
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 8918562
	+InspireID: 882098
	Status: VALIDATED
	Authors:
	- Thomas Burgess <thomas.burgess@cern.ch>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- arXiv:1012.5104
	RunInfo:
	$pp$ QCD interactions at 0.9, 2.36, and 7 TeV. Diffractive events should
	be included. Multiple kinematic cuts should not be required.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [900, 2360, 7000]
	PtCuts: [0]
	Description:
	Measurements from proton-proton collisions at centre-of-mass energies
	of $\sqrt{s} = 0.9$, 2.36, and 7 TeV recorded with the ATLAS detector at
	the LHC. Events were collected using a single-arm minimum-bias
	trigger. The charged-particle multiplicity, its dependence on
	transverse momentum and pseudorapidity and the relationship between
	the mean transverse momentum and charged-particle multiplicity are
	measured. Measurements in different regions of phase-space are shown,
	providing diffraction-reduced measurements as well as more inclusive
	ones. The observed distributions are corrected to well-defined
	phase-space regions, using model-independent corrections.
	diff --git a/data/anainfo/ATLAS_2010_S8919674.info b/data/anainfo/ATLAS_2010_S8919674.info
	--- a/data/anainfo/ATLAS_2010_S8919674.info
	+++ b/data/anainfo/ATLAS_2010_S8919674.info
	@@ -1,42 +1,43 @@
	Name: ATLAS_2010_S8919674
	Year: 2010
	Summary: $W$ + jets jet multiplicities and $\pT$
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 8919674
	+InspireID: 882534
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:1012.5382 [hep-ex]
	RunInfo:
	W+jets events ideally with matrix element corrections to describe the
	higher jet multiplicities correctly. Both channels, electron and muon,
	are part of this analysis and should be run simultaneously.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [0]
	Description:
	'Cross sections, in both the electron and muon decay modes of the W boson,
	are presented as a function of jet multiplicity and of the transverse
	momentum of the leading and next-to-leading jets in the event.
	Measurements are also presented of the ratio of cross sections for inclusive
	jet multiplicities.
	The results, based on an integrated luminosity of 1.3 pb-1, have been
	corrected for all known detector effects and are quoted in a limited and
	well-defined range of jet and lepton kinematics.'
	NeedCrossSection: yes
	BibKey: Aad:2010pg
	BibTeX: '@Article{Aad:2010pg,
	author = "Collaboration, The ATLAS",
	title = "{Measurement of the production cross section for W-bosons in association with jets in $pp$ collisions at $\sqrt{s} = 7$ TeV with the ATLAS detector}",
	year = "2010",
	eprint = "1012.5382",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1012.5382;%%"
	}'
	ToDo:
	- Implement jet multiplicity ratio plots.
	- Export original data file from HepForge.
	diff --git a/data/anainfo/ATLAS_2011_I929691.info b/data/anainfo/ATLAS_2011_I929691.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2011_I929691.info
	@@ -0,0 +1,45 @@
	+Name: ATLAS_2011_I929691
	+Year: 2011
	+Summary: Jet fragmentation at 7 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 929691
	+Status: VALIDATED
	+Authors:
	+ - Stefan von Buddenbrock <stef.von.b@cern.ch>
	+References:
	+ - "Eur.Phys.J.C 71 (2011) 1795"
	+ - "doi:10.1140/epjc/s10052-011-1795-y"
	+ - "arXiv:1109.5816 [hep-ex]"
	+RunInfo:
	+ Inclusive jet production
	+Beams: [p+, p+]
	+Energies: [7000]
	+PtCuts: [0.5]
	+Description:
	+ The jet fragmentation function and transverse profile for jets with 25 GeV $< p_\text{T~jet} < 500$ GeV and
	+ $\|\eta_\text{jet}\| < 1.2$ produced in proton-proton collisions with a center-of-mass energy of 7 TeV are presented.
	+ The measurement is performed using data with an integrated luminosity of 36 pb${}^{-1}$. Jets are reconstructed and
	+ their momentum measured using calorimetric information. The momenta of the charged particle constituents are measured
	+ using the tracking system. The distributions corrected for detector effects are compared with various Monte Carlo event
	+ generators and generator tunes. Several of these choices show good agreement with the measured fragmentation function.
	+ None of these choices reproduce both the transverse profile and fragmentation function over the full kinematic range of
	+ the measurement.
	+BibKey: Aad:2011sc
	+BibTeX: '@article{Aad:2011sc,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the jet fragmentation function and
	+ transverse profile in proton-proton collisions at a
	+ center-of-mass energy of 7 TeV with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ journal = "Eur. Phys. J.",
	+ volume = "C71",
	+ year = "2011",
	+ pages = "1795",
	+ doi = "10.1140/epjc/s10052-011-1795-y",
	+ eprint = "1109.5816",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2011-148",
	+ SLACcitation = "%%CITATION = ARXIV:1109.5816;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2011_S8924791.info b/data/anainfo/ATLAS_2011_S8924791.info
	--- a/data/anainfo/ATLAS_2011_S8924791.info
	+++ b/data/anainfo/ATLAS_2011_S8924791.info
	@@ -1,24 +1,43 @@
	Name: ATLAS_2011_S8924791
	Year: 2010
	Summary: Jet shapes at 7 TeV in ATLAS
	Experiment: ATLAS
	Collider: LHC
	+InspireID: 882984
	SpiresID: 8924791
	+InspireID: 882984
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Francesc Vives <fvives@ifae.es>
	- Judith Katzy <judith.katzy@cern.ch>
	References:
	- arXiv:1101.0070
	RunInfo:
	$pp$ QCD interactions at 7 TeV GeV, corresponding to JX samples. Matching plots to
	kinematic $\pT$ cut samples, or merging from slices or $\pT$-enhanced sampling is advised.
	NumEvents: 10000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [10, 20, 40, 70, 150, 200, 300]
	Description:
	Measurement of jet shapes in inclusive jet production in $pp$ collisions at 7 TeV
	based on 3 pb$^{-1}$ of data. Jets are reconstructed in $\|\eta\| < 5$ using the
	anti-$k_\perp$ algorithm with $30 < \pT < 600$ GeV and $\|y\| < 2.8$.
	+BibKey: Aad:2011kq
	+BibTeX: '@article{Aad:2011kq,
	+ author = "Aad, G. and others",
	+ title = "{Study of jet shapes in inclusive jet production in $pp$
	+ collisions at $\sqrt{s}=7$~TeV using the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ journal = "Phys. Rev.",
	+ volume = "D83",
	+ year = "2011",
	+ pages = "052003",
	+ doi = "10.1103/PhysRevD.83.052003",
	+ eprint = "1101.0070",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2010-077",
	+ SLACcitation = "%%CITATION = ARXIV:1101.0070;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2011_S8971293.info b/data/anainfo/ATLAS_2011_S8971293.info
	--- a/data/anainfo/ATLAS_2011_S8971293.info
	+++ b/data/anainfo/ATLAS_2011_S8971293.info
	@@ -1,34 +1,35 @@
	Name: ATLAS_2011_S8971293
	Year: 2011
	Summary: Dijet azimuthal decorrelations
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 8971293
	+InspireID: 889546
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:1102.2696
	RunInfo:
	pp QCD interactions at 7000 GeV. The distributions are binned in leading pT
	starting at 110 GeV with the last bin starting at 800 GeV.
	NumEvents: 1000000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [20.0]
	Description:
	'Dijet azimuthal decorrelation measured by ATLAS at 7 TeV. Jets are anti-$k_t$ with
	$R = 0.6$, $p_\perp > 100$\;GeV, $\|\eta\| < 0.8$. The analysis is binned
	in leading jet $p_\perp$ bins. All data is fully corrected for detector effects.'
	BibKey: Aad:2011ni
	BibTeX: '@Article{Aad:2011ni,
	author = "Collaboration, The ATLAS",
	title = "{Measurement of dijet azimuthal decorrelations in $pp$ Collisions at $\sqrt{s} = 7$ TeV}",
	year = "2011",
	eprint = "1102.2696",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1102.2696;%%"
	}'
	ToDo:
	Check BibKey and BibTeX consistency when fixed on SPIRES.
	diff --git a/data/anainfo/ATLAS_2011_S8983313.info b/data/anainfo/ATLAS_2011_S8983313.info
	--- a/data/anainfo/ATLAS_2011_S8983313.info
	+++ b/data/anainfo/ATLAS_2011_S8983313.info
	@@ -1,35 +1,36 @@
	Name: ATLAS_2011_S8983313
	Year: 2011
	Summary: 0-lepton squark and gluino search
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 8983313
	+InspireID: 890749
	Status: VALIDATED
	Authors:
	- David Grellscheid <david.grellscheid@durham.ac.uk>
	References:
	- arXiv:1102.5290
	RunInfo:
	BSM signal events at 7000 GeV.
	NumEvents: 25000 for BSM signals
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'0-lepton search for squarks and gluinos by ATLAS at 7 TeV
	with an integrated luminosity of $35\,\mathrm{pb}^{-1}$.
	Event counts in four signal regions A-D are implemented as one-bin
	histograms.'
	BibKey: daCosta:2011qk
	BibTeX: '@Article{daCosta:2011qk,
	author = "da Costa, Joao Barreiro Guimaraes and others",
	collaboration = "ATLAS",
	title = "{Search for squarks and gluinos using final states with
	jets and missing transverse momentum with the ATLAS
	detector in $\sqrt{s}$ = 7 TeV proton-proton collisions}",
	year = "2011",
	eprint = "1102.5290",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1102.5290;%%"
	}
	'
	diff --git a/data/anainfo/ATLAS_2011_S8994773.info b/data/anainfo/ATLAS_2011_S8994773.info
	--- a/data/anainfo/ATLAS_2011_S8994773.info
	+++ b/data/anainfo/ATLAS_2011_S8994773.info
	@@ -1,24 +1,25 @@
	Name: ATLAS_2011_S8994773
	Year: 2011
	Summary: Calo-based underlying event at 900 GeV and 7 TeV in ATLAS
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 8994773
	+InspireID: 891834
	Status: VALIDATED
	Authors:
	- Jinlong Zhang <jinlong@mail.cern.ch>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- arXiv:1103.1816
	RunInfo:
	pp QCD interactions at 900 GeV and 7 TeV. Diffractive events should be
	included, but only influence the lowest bins. Multiple kinematic cuts
	should not be required.
	NumEvents: 10000000
	Beams: [p+, p+]
	Energies: [900, 7000]
	PtCuts: [0]
	Description:
	Underlying event measurements with the ATLAS detector at the LHC at
	center-of-mass energies of 900 GeV and 7 TeV, using calorimeter
	clusters rather than charged tracks.
	diff --git a/data/anainfo/ATLAS_2011_S9002537.info b/data/anainfo/ATLAS_2011_S9002537.info
	--- a/data/anainfo/ATLAS_2011_S9002537.info
	+++ b/data/anainfo/ATLAS_2011_S9002537.info
	@@ -1,23 +1,24 @@
	Name: ATLAS_2011_S9002537
	Year: 2011
	Summary: Muon charge asymmetry in W events at 7 TeV in ATLAS
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9002537
	+InspireID: 892704
	Status: VALIDATED
	Authors:
	- Frank Krauss <frank.krauss@durham.ac.uk>
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- arXiv:1103.2929
	RunInfo:
	$W \to \mu\nu$ events at 7 TeV
	NumEvents: 10000000
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	Measurement of the muon charge asymmetry from W bosons produced in
	proton-proton collisions at a centre-of-mass energy of 7 TeV with ATLAS.
	The asymmetry is measured in the $W \to \mu$ decay mode as a function
	of the muon pseudorapidity using a data sample corresponding to a total
	integrated luminosity of 31 pb$^{-1}$.
	diff --git a/data/anainfo/ATLAS_2011_S9019561.info b/data/anainfo/ATLAS_2011_S9019561.info
	--- a/data/anainfo/ATLAS_2011_S9019561.info
	+++ b/data/anainfo/ATLAS_2011_S9019561.info
	@@ -1,35 +1,36 @@
	Name: ATLAS_2011_S9019561
	Year: 2011
	Summary: Two lepton supersymmetry search
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9019561
	+InspireID: 894578
	Status: VALIDATED
	Authors:
	- Angela Chen <aqchen@fas.harvard.edu>
	References:
	- arXiv:1103.6214
	RunInfo:
	BSM signal events at 7000 GeV.
	NumEvents: 25000 for BSM signals
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'2-lepton search for supersymmetric particles by ATLAS at 7 TeV.
	Event counts in signal regions (3 same sign and 3 opposite sign) are implemented as one
	bin histograms. Histograms for missing transverse energy are implemented.'
	BibKey: Aad:2011xm
	BibTeX: '@Article{Aad:2011xm,
	author = "Aad, Georges and others",
	collaboration = "ATLAS",
	title = "{Search for supersymmetric particles in events with lepton
	pairs and large missing transverse momentum in sqrt{s} = 7
	TeV proton-proton collisions with the ATLAS experiment}",
	year = "2011",
	eprint = "1103.6214",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1103.6214;%%"
	}

	'
	diff --git a/data/anainfo/ATLAS_2011_S9035664.info b/data/anainfo/ATLAS_2011_S9035664.info
	--- a/data/anainfo/ATLAS_2011_S9035664.info
	+++ b/data/anainfo/ATLAS_2011_S9035664.info
	@@ -1,42 +1,43 @@
	Name: ATLAS_2011_S9035664
	Year: 2011
	Summary: Measurement of J/Psi production
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9035664
	+InspireID: 896268
	Status: VALIDATED
	Authors:
	-
	References:
	-
	- arXiv:1104.3038 [hep-ex]
	RunInfo:
	pp to hadrons including both prompt J/Psi production and the production in B decays
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts:
	Description:
	'The inclusive $J/\psi$ production cross-section and fraction of $J/\psi$ mesons produced in B-hadron decays are measured
	in proton-proton collisions at $\sqrt{s} = 7$ TeV with the ATLAS detector at the LHC, as a function of the transverse momentum
	and rapidity of the J/psi, using 2.3$\textrm{pb}^{-1}$ of integrated luminosity. The cross section is measured from a minimum $p_T$
	of 1 GeV to a maximum of 70 GeV and for rapidities within $\|y\| < 2.4$ giving the widest reach of any measurement of $J/\psi$ production
	to date.'
	NeedCrossSection: yes
	BibKey: Aad:2011sp
	BibTeX: '@article{Aad:2011sp,
	author = "Aad, Georges and others",
	title = "{Measurement of the differential cross-sections of
	inclusive, prompt and non-prompt $J/\psi$ production in
	proton-proton collisions at $\sqrt{s}=7$ TeV}",
	collaboration = "ATLAS Collaboration",
	journal = "Nucl.Phys.",
	volume = "B850",
	pages = "387-444",
	doi = "10.1016/j.nuclphysb.2011.05.015",
	year = "2011",
	eprint = "1104.3038",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = ARXIV:1104.3038;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2011_S9041966.info b/data/anainfo/ATLAS_2011_S9041966.info
	--- a/data/anainfo/ATLAS_2011_S9041966.info
	+++ b/data/anainfo/ATLAS_2011_S9041966.info
	@@ -1,21 +1,22 @@
	Name: ATLAS_2011_S9041966
	Year: 2011
	Summary: 1-lepton and 2-lepton search for first or second generation leptoquarks
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9041966
	+InspireID: 897002
	Status: OBSOLETE
	Authors:
	- Angela Chen <aqchen@fas.harvard.edu>
	References:
	- arXiv:1104.4481
	RunInfo:
	BSM signal events at 7000 GeV.
	NumEvents: 25000 for BSM signals
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'Single and dilepton search for first and second generation scalar leptoquarks by ATLAS at 7 TeV.
	Event counts in four signal regions (single lepton and dilepton for first and second generation) are implemented as one-bin histograms.
	Histograms for event transverse energy are implemented for dilepton signal regions and histograms for leptoquark mass are implemented for single lepton signal regions.
	Histograms for observables in six control regions are implemented.'
	diff --git a/data/anainfo/ATLAS_2011_S9108483.info b/data/anainfo/ATLAS_2011_S9108483.info
	--- a/data/anainfo/ATLAS_2011_S9108483.info
	+++ b/data/anainfo/ATLAS_2011_S9108483.info
	@@ -1,34 +1,35 @@
	Name: ATLAS_2011_S9108483
	Year: 2011
	Summary: Long-lived heavy charged particle search
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9108483
	+InspireID: 914491
	Status: UNVALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- arXiv:arXiv:1106.4495
	RunInfo:
	BSM signal events at 7000 GeV.
	NumEvents: 25000 for BSM signals
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'ATLAS search for long-lived heavy charged particles for four different mass cuts. Currently only the slepton search is implemented.'
	NeedCrossSection: yes
	BibKey: Aad:2011hz
	BibTeX: '@Article{Aad:2011hz,
	author = "Aad, Georges and others",
	collaboration = "ATLAS",
	title = "{Search for Heavy Long-Lived Charged Particles with the ATLAS detector in $pp$ collisions at $\sqrt{s} = 7$ TeV}",
	journal = "Phys. Lett.",
	volume = "B703",
	year = "2011",
	pages = "428-446",
	eprint = "1106.4495",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1016/j.physletb.2011.08.042",
	SLACcitation = "%%CITATION = 1106.4495;%%"
	}'
	diff --git a/data/anainfo/ATLAS_2011_S9120807.info b/data/anainfo/ATLAS_2011_S9120807.info
	--- a/data/anainfo/ATLAS_2011_S9120807.info
	+++ b/data/anainfo/ATLAS_2011_S9120807.info
	@@ -1,33 +1,34 @@
	Name: ATLAS_2011_S9120807
	Year: 2011
	Summary: Inclusive isolated diphoton analysis
	Experiment: ATLAS
	Collider: LHC 7TeV
	SpiresID: 9120807
	+InspireID: 916832
	Status: VALIDATED
	Authors:
	- Giovanni Marchiori <giovanni.marchiori@cern.ch>
	References:
	- arXiv:1107.0581 [hep-ex]
	RunInfo:
	Inclusive diphoton + $X$ events at $\sqrt{s} = 7$~TeV.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [16]
	Description:
	'A measurement of the cross section for inclusive isolated photon production at $\sqrt{s} = 7$ TeV.
	The measurement is done in bins of $M_{\gamma\gamma}$, $p_{T\gamma\gamma}$, and $\Delta\phi_{\gamma\gamma}$,
	for isolated photons with $\|\eta\|<2.37$ and $E_T^\gamma>16$~GeV.
	The measurement uses 37 pb$^{-1}$ of integrated luminosity collected with
	the ATLAS detector.'
	NeedCrossSection: yes
	BibTeX: '@Article{Aad:2011mh,
	author = "Aad, Georges and others",
	title = "{Measurement of the isolated di-photon cross-section in $pp$ collisions at $\sqrt{s} = 7$ TeV with the ATLAS detector}",
	collaboration = "ATLAS Collaboration",
	year = "2011",
	eprint = "1107.0581",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	}
	diff --git a/data/anainfo/ATLAS_2011_S9126244.info b/data/anainfo/ATLAS_2011_S9126244.info
	--- a/data/anainfo/ATLAS_2011_S9126244.info
	+++ b/data/anainfo/ATLAS_2011_S9126244.info
	@@ -1,43 +1,44 @@
	Name: ATLAS_2011_S9126244
	Year: 2011
	Summary: Measurement of dijet production with a veto on additional central jet activity
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9126244
	+InspireID: 917526
	Status: VALIDATED
	Authors:
	- Graham Jones <grahamj@cern.ch>
	References:
	- arXiv:1107.1641 [hep-ex]
	RunInfo:
	Require QCD interactions at 7TeV. A substantial number of events are required
	to populate the large rapidity seperation region.
	NumEvents: 10000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [0]
	Description:
	'A measurement of the jet activity in rapidity intervals bounded by a dijet
	system. The fraction of events passing a veto requirement are shown as a
	function of both the rapidity interval size and the average transverse
	momentum of the dijet system. The average number of jets above the veto
	threshold are also shown as a function of the same variables. There are
	two possible selection criteria applied to data. Either the two highest
	transverse momentum jets or the jets most forward and backward in rapidity
	are taken to define the dijet system, where the veto threhsold is 20\;GeV.
	Additionally for the latter selection an alternative veto transverse
	momentum threshold which is equal to the average transverse momentum is
	applied.
	Jet selections are based on the anti-$k_t$ algorithm with $R=0.6$,
	$p_\perp > 20$\;GeV and $\|y_\text{jet}\| < 4.4$.'
	BibTeX:
	'@Article{Aad:2011jz,
	author = "Aad, Georges and others",
	collaboration = "ATLAS",
	title = "{Measurement of dijet production with a veto on additional central jet activity
	in $pp$ collisions at $\sqrt{s} = 7$ TeV using the ATLAS detector}",
	year = "2011",
	eprint = "1107.1641",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	}'
	diff --git a/data/anainfo/ATLAS_2011_S9128077.info b/data/anainfo/ATLAS_2011_S9128077.info
	--- a/data/anainfo/ATLAS_2011_S9128077.info
	+++ b/data/anainfo/ATLAS_2011_S9128077.info
	@@ -1,37 +1,39 @@
	Name: ATLAS_2011_S9128077
	Year: 2011
	Summary: Measurement of multi-jet cross sections
	Experiment: ATLAS
	Collider: LHC
	+InspireID: 917599
	SpiresID: 9128077
	+InspireID: 917599
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:1107.2092
	RunInfo:
	Pure QCD, inclusive enough for jet pT down to 60 GeV.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [0]
	Description:
	'Inclusive multi-jet production is studied using an integrated luminosity of
	2.4 pb-1. Results on multi-jet cross sections are presented differential
	in pT of the four leading jets, HT. Additionally three-to-two jet fractions
	are presented differential in different observables.
	- Jets are anti-kt with $R=0.4$ and $R=0.6$, $p_\perp>80(60)$ GeV and $\|\eta\|<2.8$.'
	+ Jets are anti-$k_t$ with $R=0.4$ and $R=0.6$, $p_\perp>80(60)$ GeV and $\|\eta\|<2.8$.'
	NeedCrossSection: yes
	-BibKey: Collaboration:2011tq
	-BibTeX: '@Article{Collaboration:2011tq,
	+BibKey: Aad:2011tqa
	+BibTeX: '@Article{Aad:2011tqa,
	author = "Collaboration, ATLAS",
	title = "{Measurement of multi-jet cross sections in proton-proton
	collisions at a 7 TeV center-of-mass energy}",
	year = "2011",
	eprint = "1107.2092",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1107.2092;%%"
	}'
	ToDo:
	- Validate.
	diff --git a/data/anainfo/ATLAS_2011_S9131140.info b/data/anainfo/ATLAS_2011_S9131140.info
	--- a/data/anainfo/ATLAS_2011_S9131140.info
	+++ b/data/anainfo/ATLAS_2011_S9131140.info
	@@ -1,39 +1,40 @@
	Name: ATLAS_2011_S9131140
	Year: 2011
	Summary: Measurement of the Z pT with electrons and muons at 7 TeV
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9131140
	+InspireID: 917931
	Status: VALIDATED
	Authors:
	- Elena Yatsenko <elena.yatsenko@desy.de>
	- Judith Katzy <jkatzy@mail.cern.ch>
	References:
	- arXiv:1107.2381 [hep-ex]
	RunInfo:
	Run with inclusive $Z$ events, with $Z/\gamma^*$ decays to electrons and/or
	muons.
	NumEvents: 100k
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [20]
	Description:
	'The Z pT at $\sqrt{s} = 7$\;TeV is measured using electron and muon $Z$ decay
	channels. The dressed leptons definition uses photons clustered in a cone around
	the charged leptons, while the bare lepton definition uses the post-FSR charged
	leptons only in the $Z$ reconstruction. The data used in the bare leptons calculation
	are based on a forward application of a PHOTOS-based energy loss correction and are
	hence not quite model-independent.'
	BibKey: Aad:2011gj
	BibTeX: '@Article{Aad:2011gj,
	author = "Aad, Georges and others",
	collaboration = "ATLAS",
	title = "{Measurement of the transverse momentum distribution of
	$Z/\gamma^*$ bosons in proton-proton collisions at $\sqrt{s} =
	7$\;TeV with the ATLAS detector}",
	year = "2011",
	eprint = "1107.2381",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1107.2381;%%"
	}'
	diff --git a/data/anainfo/ATLAS_2011_S9212183.info b/data/anainfo/ATLAS_2011_S9212183.info
	--- a/data/anainfo/ATLAS_2011_S9212183.info
	+++ b/data/anainfo/ATLAS_2011_S9212183.info
	@@ -1,34 +1,35 @@
	Name: ATLAS_2011_S9212183
	Year: 2011
	Summary: 0-lepton squark and gluino search
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9212183
	+InspireID: 930002
	Status: VALIDATED
	Authors:
	- Chris Wymant <c.m.wymant@durham.ac.uk>
	- David Grellscheid <david.grellscheid@durham.ac.uk>
	References:
	- arXiv:1109.6572
	RunInfo:
	BSM signal events at 7000 GeV.
	NumEvents: 10000 for BSM signals
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'0-lepton search for squarks and gluinos by ATLAS at 7 TeV
	with an integrated luminosity of $1.04\,\mathrm{fb}^{-1}$.
	Event counts in five signal regions are implemented as one-bin
	histograms.'
	BibKey: Aad:2011ib
	BibTeX: '@article{Aad:2011ib,
	author = "Aad, Georges and others",
	title = "{Search for squarks and gluinos using final states with
	jets and missing transverse momentum with the ATLAS
	detector in $\sqrt{s}$ = 7 TeV proton-proton collisions}",
	collaboration = "ATLAS",
	year = "2011",
	eprint = "1109.6572",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	}'
	diff --git a/data/anainfo/ATLAS_2011_S9212353.info b/data/anainfo/ATLAS_2011_S9212353.info
	--- a/data/anainfo/ATLAS_2011_S9212353.info
	+++ b/data/anainfo/ATLAS_2011_S9212353.info
	@@ -1,36 +1,37 @@
	Name: ATLAS_2011_S9212353
	Year: 2011
	Summary: Single lepton search for supersymmetry
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9212353
	+InspireID: 930005
	Status: OBSOLETE
	References:
	- Phys. Rev.D85:012006,2012
	- arXiv:1109.6606
	RunInfo:
	BSM signal events at 7000 GeV.
	NumEvents: 25000 for BSM signals
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'Single lepton search for supersymmmetric particles by ATLAS at 7 TeV.
	Event counts in electron and muon signal regions are implemented as one-bin histograms.
	Histograms for missing transverse energy and effective mass are implemented for the two
	signal regions.'
	BibKey: ATLAS:2011ad
	BibTeX: '@Article{ATLAS:2011ad,
	author = "Aad, Georges and others",
	collaboration = "ATLAS",
	title = "{Search for supersymmetry in final states with jets,
	missing transverse momentum and one isolated lepton in
	sqrt{s} = 7 TeV pp collisions using 1 fb-1 of ATLAS data}",
	journal = "Phys. Rev.",
	volume = "D85",
	year = "2012",
	pages = "012006",
	eprint = "1109.6606",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1109.6606;%%"
	}'
	diff --git a/data/anainfo/ATLAS_2011_S9225137.info b/data/anainfo/ATLAS_2011_S9225137.info
	--- a/data/anainfo/ATLAS_2011_S9225137.info
	+++ b/data/anainfo/ATLAS_2011_S9225137.info
	@@ -1,43 +1,44 @@
	Name: ATLAS_2011_S9225137
	Year: 2011
	Summary: High jet multiplicity squark and gluino search
	Experiment: ATLAS
	Collider: LHC
	SpiresID: 9225137
	+InspireID: 939504
	Status: VALIDATED
	Authors:
	- Peter Richardson <peter.richardson@durham.ac.uk>
	References:
	- arXiv:1110.2299
	RunInfo:
	BSM signal events at 7000 GeV.
	NumEvents: 25000 for BSM signals
	Beams: [p+, p+]
	Energies: [7000]
	NeedCrossSection: yes
	Description:
	'Search for SUSY using events with 6 or more jets in
	association with missing transverse momentum produced in proton-proton
	collisions at a centre-of-mass energy of 7 TeV. The data sample has a total
	integrated luminosity of 1.34 fb$^{-1}$. Distributions
	in the $W$ and top control regions are not produced, while in addition to
	the plots from the paper the count of events in the different signal regions
	is included.'
	BibKey: Aad:2011qa
	BibTeX: '@article{Aad:2011qa,
	author = "Aad, Georges and others",
	title = "{Search for new phenomena in final states with large jet
	multiplicities and missing transverse momentum using
	$\sqrt{s} = 7$ TeV $pp$ collisions with the ATLAS detector.}",
	collaboration = "Atlas Collaboration",
	journal = "JHEP",
	volume = "1111",
	pages = "099",
	doi = "10.1007/JHEP11(2011)099",
	year = "2011",
	eprint = "1110.2299",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2011-155",
	SLACcitation = "%%CITATION = ARXIV:1110.2299;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2012_I1082009.info b/data/anainfo/ATLAS_2012_I1082009.info
	--- a/data/anainfo/ATLAS_2012_I1082009.info
	+++ b/data/anainfo/ATLAS_2012_I1082009.info
	@@ -1,39 +1,39 @@
	Name: ATLAS_2012_I1082009
	Year: 2012
	Summary: $D^{*\pm}$ production in jets
	Experiment: ATLAS
	Collider: LHC
	InspireID: 1082009
	-Status: UNVALIDATED
	+Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- arXiv:1112.4432
	RunInfo:
	All flavours of quark and gluon jet production at 7 TeV
	NumEvents: 10000000
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	Measurement of $D^{*\pm}$ meson production in jets from proton-proton collisions
	at a centre-of-mass energy of $\sqrt{s}=7$ TeV at the LHC.
	The measurement is based on a data sample recorded with the ATLAS detector with
	an integrated luminosity of $0.30\,\text{pb}^{-1}$ for jets with transverse momentum
	between 25 and 70 GeV in the pseudorapidity range $\|eta\| < 2.5$.
	BibKey: Aad:2011td
	BibTeX: '@Article{Aad:2011td,
	author = "Aad, Georges and others",
	title = "{Measurement of $D^{*\pm}$ meson production in jets from
	pp collisions at $\sqrt{s}=7$ TeV with the ATLAS detector}",
	collaboration = "ATLAS Collaboration",
	journal = "Phys.Rev.",
	volume = "D85",
	pages = "052005",
	year = "2012",
	note = "Long author list - awaiting processing",
	eprint = "1112.4432",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2011-180",
	SLACcitation = "%%CITATION = ARXIV:1112.4432;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2012_I1095236.info b/data/anainfo/ATLAS_2012_I1095236.info
	--- a/data/anainfo/ATLAS_2012_I1095236.info
	+++ b/data/anainfo/ATLAS_2012_I1095236.info
	@@ -1,39 +1,39 @@
	Name: ATLAS_2012_I1095236
	Year: 2011
	-Summary: b-jets search for supersymmetry with 0- and 1-leptons
	+Summary: $b$-jets search for supersymmetry with 0- and 1-leptons
	Experiment: ATLAS
	Collider: LHC
	InspireID: 1095236
	Status: UNVALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- arXiv:1203.6193
	RunInfo:
	BSM signal events at 7000 GeV.
	NumEvents: 25000 for BSM signals
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'Search for supersymmmetric particles by ATLAS at 7 TeV in events with b-jets,
	large missing
	energy, and zero or one leptons.
	Event counts in six zero lepton and two one lepton signal regions are implemented
	as one-bin histograms.
	Histograms for missing transverse energy, and effective mass are also
	implemented for some signal regions.'
	BibKey: ATLAS2012:1095236
	BibTeX: '@article{ATLAS2012:1095236,
	author = "Aad, Georges and others",
	title = "{Search for supersymmetry in $pp$ collisions at $\sqrt{s} = 7$ TeV in final states
	with missing transverse momentum and $b$-jets with the ATLAS detector}",
	collaboration = "ATLAS Collaboration",
	year = "2012",
	note = "15 pages plus author list (28 pages total), 11 figures, 8
	tables, submitted to Physical Review D",
	eprint = "1203.6193",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-052",
	SLACcitation = "%%CITATION = ARXIV:1203.6193;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2012_I1126136.info b/data/anainfo/ATLAS_2012_I1126136.info
	--- a/data/anainfo/ATLAS_2012_I1126136.info
	+++ b/data/anainfo/ATLAS_2012_I1126136.info
	@@ -1,35 +1,35 @@
	Name: ATLAS_2012_I1126136
	Year: 2012
	-Summary: SUSY Top partner search in jets with missing transverse momentum
	+Summary: SUSY top partner search in jets with missing transverse momentum
	Experiment: ATLAS
	Collider: LHC
	InspireID: 1126136
	Status: UNVALIDATED
	Authors:
	- Peter Richardson <peter.richardson@durham.ac.uk>
	References:
	- arXiv:1208.1447
	RunInfo:
	BSM signal events at 7000 GeV.
	NumEvents: 25000 for BSM signals
	Beams: [p+, p+]
	Energies: [7000]
	NeedCrossSection: yes
	Description:
	'Search for direct pair production of supersymmetric top squarks, assuming the stop_1 decays
	into a top quark and the lightest supersymmetric particle, and that both top quarks decay
	to purely hadronic final states. This search has an integrated luminosity
	of 4.7 fb$^{-1}$ at $\sqrt{s} = 8$\,TeV.'
	BibTeX: '@article{:2012si,
	author = "Aad, Georges and others",
	title = "{Search for a supersymmetric partner to the top quark in
	final states with jets and missing transverse momentum at
	$\sqrt{s} = 7$ TeV with the ATLAS detector}",
	collaboration = "ATLAS Collaboration",
	year = "2012",
	eprint = "1208.1447",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-201",
	SLACcitation = "%%CITATION = ARXIV:1208.1447;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2012_I1203852.info b/data/anainfo/ATLAS_2012_I1203852.info
	--- a/data/anainfo/ATLAS_2012_I1203852.info
	+++ b/data/anainfo/ATLAS_2012_I1203852.info
	@@ -1,47 +1,47 @@
	Name: ATLAS_2012_I1203852
	Year: 2013
	Summary: Measurement of the $ZZ(*)$ production cross-section in $pp$ collisions at 7 TeV with ATLAS
	Experiment: ATLAS
	Collider: LHC
	-SpiresID: 1203852
	+InspireID: 1203852
	Status: VALIDATED
	Authors:
	- Oldrich Kepka <oldrich.kepka@cern.ch>
	- Katerina Moudra <katerina.moudra@cern.ch>
	References:
	- arXiv:1211.6096 [hep-ex]
	RunInfo:
	Run with inclusive $Z$ events, with $Z$ decays to 4 leptons or 2 leptons + MET.
	NumEvents: 100k
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [20]
	NeedsCrossSection: yes
	Description:
	'Measurement of the fiducial cross section for $ZZ(*)$ production in proton proton collisions
	at a centre-of mass energy of 7 TeV, is presented, using data corresponding to an integrated
	luminosity of 4.6/fb collected by the ATLAS experiment at the Large Hadron Collider. The
	cross-section is measured using processes with two $Z$ bosons decaying to electrons or muons
	or with one $Z$ boson decaying to electrons or muons and a second $Z$ boson decaying to neutrinos.
	The fiducial region contains dressed leptons in restricted $p_T$ and $\eta$ ranges. The
	selection has specific requirements for both production processes. A measurement of the
	normalized fiducial cross-section as a function of $ZZ$ invariant mass, leading $Z$ $p_T$ and
	angle of two leptons coming from the leading $Z$ is also presented for both signal processes.'
	BibKey: Aad:2012awa
	BibTeX: '@article{Aad:2012awa,
	author = "Aad, Georges and others",
	title = "{Measurement of $ZZ$ production in $pp$ collisions at
	$\sqrt{s}=7$ TeV and limits on anomalous $ZZZ$ and
	$ZZ\gamma$ couplings with the ATLAS detector}",
	collaboration = "ATLAS Collaboration",
	journal = "JHEP",
	volume = "1303",
	pages = "128",
	doi = "10.1007/JHEP03(2013)128",
	year = "2013",
	eprint = "1211.6096",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-318",
	SLACcitation = "%%CITATION = ARXIV:1211.6096;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2013_I1190187.info b/data/anainfo/ATLAS_2013_I1190187.info
	--- a/data/anainfo/ATLAS_2013_I1190187.info
	+++ b/data/anainfo/ATLAS_2013_I1190187.info
	@@ -1,49 +1,49 @@
	Name: ATLAS_2013_I1190187
	Year: 2013
	Summary: Measurement of the $W^+ W^-$ production cross-section at 7 TeV
	Experiment: ATLAS
	Collider: LHC
	-SpiresID: 1190187
	+InspireID: 1190187
	Status: VALIDATED
	Authors:
	- Oldrich Kepka <oldrich.kepka@cern.ch>
	- Katerina Moudra <katerina.moudra@cern.ch>
	References:
	- arXiv:1210.2979 [hep-ex]
	RunInfo:
	Run with inclusive $W^+ W^-$ events, with $W$ decays to electron + MET,
	muon + MET, or tau + MET.
	NumEvents: 100k
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [20]
	NeedsCrossSection: yes
	Description:
	'Measurement of the fiducial cross section for $W^+ W^-$ production in proton proton
	collisions at a centre-of mass energy of 7 TeV, is presented, using data corresponding
	to an integrated luminosity of 4.6/fb collected by the ATLAS experiment at the Large
	Hadron Collider. The cross section is measured in the leptonic decay channels, using
	electron+MET and muon+MET $W$ decays. $W \to \tau$ processes with the tau decaying
	into electron + MET or muon + MET are also included in the measurement. The fiducial
	region contains dressed leptons in restricted $p_T$ and $\eta$ ranges. The selection
	has specific requirements for each production channel. A measurement of the normalized
	fiducial cross section as a function of the leading lepton transverse momentum is also presented.'
	BibKey: ATLAS:2012mec
	BibTeX: '@article{ATLAS:2012mec,
	author = "Aad, Georges and others",
	title = "{Measurement of $W^+W^-$ production in $pp$ collisions at
	$\sqrt{s}$=7ââTeV with the ATLAS detector and limits
	on anomalous $WWZ$ and $WW\gamma$ couplings}",
	collaboration = "ATLAS Collaboration",
	journal = "Phys.Rev.",
	number = "11",
	volume = "D87",
	pages = "112001",
	doi = "10.1103/PhysRevD.87.112001",
	year = "2013",
	eprint = "1210.2979",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-242",
	SLACcitation = "%%CITATION = ARXIV:1210.2979;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2013_I1217863_W.info b/data/anainfo/ATLAS_2013_I1217863_W.info
	--- a/data/anainfo/ATLAS_2013_I1217863_W.info
	+++ b/data/anainfo/ATLAS_2013_I1217863_W.info
	@@ -1,45 +1,45 @@
	Name: ATLAS_2013_I1217863_W
	Year: 2013
	Summary: W + gamma production at 7 TeV
	Experiment: ATLAS
	Collider: LHC
	-InspireID: 121786
	+InspireID: 1217863
	Status: VALIDATED
	Authors:
	- Chritian Gutschow <chris.g@cern.ch>
	References:
	- Phys.Rev. D87 (2013) 112003
	- doi:10.1103/PhysRevD.87.112003
	- arXiv:1302.1283 [hep-ex]
	RunInfo:
	W+gamma in the electron channel
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [25,15]
	NeedCrossSection: True
	Description:
	Measurements of the differential fiducial cross sections for the production of a W boson in association with a high-energy
	photon are measured using pp collisions at \sqrt{s}=7âTeV. The analysis uses a data sample with an integrated luminosity of
	4.6 fb-1 collected by the ATLAS detector during the 2011 LHC data-taking period. Events are selected using leptonic decays
	of the W bosons with the requirement of an associated isolated photon. The default routine will consider the electron decay
	channel of the W boson. Use ATLAS_2013_I1217863_W_EL and ATLAS_2013_I1217863_W_MU to specify the decay channel directly.
	BibKey: Aad:2013iz
	BibTeX: '@article{Aad:2013izg,
	author = "Aad, Georges and others",
	title = "{Measurements of WÎ³ and ZÎ³ production in pp collisions
	at $\sqrt{s}$=7ââTeV with the ATLAS detector at the
	LHC}",
	collaboration = "ATLAS Collaboration",
	journal = "Phys.Rev.",
	number = "11",
	volume = "D87",
	pages = "112003",
	doi = "10.1103/PhysRevD.87.112003",
	year = "2013",
	eprint = "1302.1283",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-345",
	SLACcitation = "%%CITATION = ARXIV:1302.1283;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2013_I1217863_W_EL.info b/data/anainfo/ATLAS_2013_I1217863_W_EL.info
	--- a/data/anainfo/ATLAS_2013_I1217863_W_EL.info
	+++ b/data/anainfo/ATLAS_2013_I1217863_W_EL.info
	@@ -1,45 +1,45 @@
	Name: ATLAS_2013_I1217863_W_EL
	Year: 2013
	Summary: W + gamma production at 7 TeV
	Experiment: ATLAS
	Collider: LHC
	-InspireID: 121786
	+InspireID: 1217863
	Status: VALIDATED
	Authors:
	- Chritian Gutschow <chris.g@cern.ch>
	References:
	- Phys.Rev. D87 (2013) 112003
	- doi:10.1103/PhysRevD.87.112003
	- arXiv:1302.1283 [hep-ex]
	RunInfo:
	W+gamma in the electron channel
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [25,15]
	NeedCrossSection: True
	Description:
	Measurements of the differential fiducial cross sections for the production of a W boson in association with a high-energy
	photon are measured using pp collisions at \sqrt{s}=7âTeV. The analysis uses a data sample with an integrated luminosity of
	4.6 fb-1 collected by the ATLAS detector during the 2011 LHC data-taking period. Events are selected using leptonic decays
	of the W bosons with the requirement of an associated isolated photon. The default routine will consider the electron decay
	channel of the W boson. Use ATLAS_2013_I1217863_W_EL and ATLAS_2013_I1217863_W_MU to specify the decay channel directly.
	BibKey: Aad:2013iz
	BibTeX: '@article{Aad:2013izg,
	author = "Aad, Georges and others",
	title = "{Measurements of WÎ³ and ZÎ³ production in pp collisions
	at $\sqrt{s}$=7ââTeV with the ATLAS detector at the
	LHC}",
	collaboration = "ATLAS Collaboration",
	journal = "Phys.Rev.",
	number = "11",
	volume = "D87",
	pages = "112003",
	doi = "10.1103/PhysRevD.87.112003",
	year = "2013",
	eprint = "1302.1283",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-345",
	SLACcitation = "%%CITATION = ARXIV:1302.1283;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2013_I1217863_W_MU.info b/data/anainfo/ATLAS_2013_I1217863_W_MU.info
	--- a/data/anainfo/ATLAS_2013_I1217863_W_MU.info
	+++ b/data/anainfo/ATLAS_2013_I1217863_W_MU.info
	@@ -1,45 +1,45 @@
	Name: ATLAS_2013_I1217863_W_MU
	Year: 2013
	Summary: W + gamma production at 7 TeV
	Experiment: ATLAS
	Collider: LHC
	-InspireID: 121786
	+InspireID: 1217863
	Status: VALIDATED
	Authors:
	- Chritian Gutschow <chris.g@cern.ch>
	References:
	- Phys.Rev. D87 (2013) 112003
	- doi:10.1103/PhysRevD.87.112003
	- arXiv:1302.1283 [hep-ex]
	RunInfo:
	W+gamma in the muon channel
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [25,15]
	NeedCrossSection: True
	Description:
	Measurements of the differential fiducial cross sections for the production of a W boson in association with a high-energy
	photon are measured using pp collisions at \sqrt{s}=7âTeV. The analysis uses a data sample with an integrated luminosity of
	4.6 fb-1 collected by the ATLAS detector during the 2011 LHC data-taking period. Events are selected using leptonic decays
	of the W bosons with the requirement of an associated isolated photon. The default routine will consider the electron decay
	channel of the W boson. Use ATLAS_2013_I1217863_W_EL and ATLAS_2013_I1217863_W_MU to specify the decay channel directly.
	BibKey: Aad:2013iz
	BibTeX: '@article{Aad:2013izg,
	author = "Aad, Georges and others",
	title = "{Measurements of WÎ³ and ZÎ³ production in pp collisions
	at $\sqrt{s}$=7ââTeV with the ATLAS detector at the
	LHC}",
	collaboration = "ATLAS Collaboration",
	journal = "Phys.Rev.",
	number = "11",
	volume = "D87",
	pages = "112003",
	doi = "10.1103/PhysRevD.87.112003",
	year = "2013",
	eprint = "1302.1283",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-345",
	SLACcitation = "%%CITATION = ARXIV:1302.1283;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2013_I1217863_Z.info b/data/anainfo/ATLAS_2013_I1217863_Z.info
	--- a/data/anainfo/ATLAS_2013_I1217863_Z.info
	+++ b/data/anainfo/ATLAS_2013_I1217863_Z.info
	@@ -1,45 +1,45 @@
	Name: ATLAS_2013_I1217863_Z
	Year: 2013
	Summary: Z + gamma production at 7 TeV
	Experiment: ATLAS
	Collider: LHC
	-InspireID: 121786
	+InspireID: 1217863
	Status: VALIDATED
	Authors:
	- Chritian Gutschow <chris.g@cern.ch>
	References:
	- Phys.Rev. D87 (2013) 112003
	- doi:10.1103/PhysRevD.87.112003
	- arXiv:1302.1283 [hep-ex]
	RunInfo:
	Z+gamma in the electron channel
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [25,15]
	NeedCrossSection: True
	Description:
	Measurements of the differential fiducial cross sections for the production of a Z boson in association with a high-energy
	photon are measured using pp collisions at \sqrt{s}=7âTeV. The analysis uses a data sample with an integrated luminosity of
	4.6 fb-1 collected by the ATLAS detector during the 2011 LHC data-taking period. Events are selected using leptonic decays
	of the Z bosons with the requirement of an associated isolated photon. The default routine will consider the electron decay
	channel of the Z boson. Use ATLAS_2013_I1217863_Z_EL and ATLAS_2013_I1217863_Z_MU to specify the decay channel directly.
	BibKey: Aad:2013iz
	BibTeX: '@article{Aad:2013izg,
	author = "Aad, Georges and others",
	title = "{Measurements of WÎ³ and ZÎ³ production in pp collisions
	at $\sqrt{s}$=7ââTeV with the ATLAS detector at the
	LHC}",
	collaboration = "ATLAS Collaboration",
	journal = "Phys.Rev.",
	number = "11",
	volume = "D87",
	pages = "112003",
	doi = "10.1103/PhysRevD.87.112003",
	year = "2013",
	eprint = "1302.1283",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-345",
	SLACcitation = "%%CITATION = ARXIV:1302.1283;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2013_I1217863_Z_EL.info b/data/anainfo/ATLAS_2013_I1217863_Z_EL.info
	--- a/data/anainfo/ATLAS_2013_I1217863_Z_EL.info
	+++ b/data/anainfo/ATLAS_2013_I1217863_Z_EL.info
	@@ -1,45 +1,45 @@
	Name: ATLAS_2013_I1217863_Z_EL
	Year: 2013
	Summary: Z + gamma production at 7 TeV
	Experiment: ATLAS
	Collider: LHC
	-InspireID: 121786
	+InspireID: 1217863
	Status: VALIDATED
	Authors:
	- Chritian Gutschow <chris.g@cern.ch>
	References:
	- Phys.Rev. D87 (2013) 112003
	- doi:10.1103/PhysRevD.87.112003
	- arXiv:1302.1283 [hep-ex]
	RunInfo:
	Z+gamma in the electron channel
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [25,15]
	NeedCrossSection: True
	Description:
	Measurements of the differential fiducial cross sections for the production of a Z boson in association with a high-energy
	photon are measured using pp collisions at \sqrt{s}=7âTeV. The analysis uses a data sample with an integrated luminosity of
	4.6 fb-1 collected by the ATLAS detector during the 2011 LHC data-taking period. Events are selected using leptonic decays
	of the Z bosons with the requirement of an associated isolated photon. The default routine will consider the electron decay
	channel of the Z boson. Use ATLAS_2013_I1217863_Z_EL and ATLAS_2013_I1217863_Z_MU to specify the decay channel directly.
	BibKey: Aad:2013iz
	BibTeX: '@article{Aad:2013izg,
	author = "Aad, Georges and others",
	title = "{Measurements of WÎ³ and ZÎ³ production in pp collisions
	at $\sqrt{s}$=7ââTeV with the ATLAS detector at the
	LHC}",
	collaboration = "ATLAS Collaboration",
	journal = "Phys.Rev.",
	number = "11",
	volume = "D87",
	pages = "112003",
	doi = "10.1103/PhysRevD.87.112003",
	year = "2013",
	eprint = "1302.1283",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-345",
	SLACcitation = "%%CITATION = ARXIV:1302.1283;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2013_I1217863_Z_MU.info b/data/anainfo/ATLAS_2013_I1217863_Z_MU.info
	--- a/data/anainfo/ATLAS_2013_I1217863_Z_MU.info
	+++ b/data/anainfo/ATLAS_2013_I1217863_Z_MU.info
	@@ -1,45 +1,45 @@
	Name: ATLAS_2013_I1217863_Z_MU
	Year: 2013
	Summary: Z + gamma production at 7 TeV
	Experiment: ATLAS
	Collider: LHC
	-InspireID: 121786
	+InspireID: 1217863
	Status: VALIDATED
	Authors:
	- Chritian Gutschow <chris.g@cern.ch>
	References:
	- Phys.Rev. D87 (2013) 112003
	- doi:10.1103/PhysRevD.87.112003
	- arXiv:1302.1283 [hep-ex]
	RunInfo:
	Z+gamma in the muon channel
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [25,15]
	NeedCrossSection: True
	Description:
	Measurements of the differential fiducial cross sections for the production of a Z boson in association with a high-energy
	photon are measured using pp collisions at \sqrt{s}=7âTeV. The analysis uses a data sample with an integrated luminosity of
	4.6 fb-1 collected by the ATLAS detector during the 2011 LHC data-taking period. Events are selected using leptonic decays
	of the Z bosons with the requirement of an associated isolated photon. The default routine will consider the electron decay
	channel of the Z boson. Use ATLAS_2013_I1217863_Z_EL and ATLAS_2013_I1217863_Z_MU to specify the decay channel directly.
	BibKey: Aad:2013iz
	BibTeX: '@article{Aad:2013izg,
	author = "Aad, Georges and others",
	title = "{Measurements of WÎ³ and ZÎ³ production in pp collisions
	at $\sqrt{s}$=7ââTeV with the ATLAS detector at the
	LHC}",
	collaboration = "ATLAS Collaboration",
	journal = "Phys.Rev.",
	number = "11",
	volume = "D87",
	pages = "112003",
	doi = "10.1103/PhysRevD.87.112003",
	year = "2013",
	eprint = "1302.1283",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-345",
	SLACcitation = "%%CITATION = ARXIV:1302.1283;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2013_I1243871.info b/data/anainfo/ATLAS_2013_I1243871.info
	--- a/data/anainfo/ATLAS_2013_I1243871.info
	+++ b/data/anainfo/ATLAS_2013_I1243871.info
	@@ -1,32 +1,32 @@
	Name: ATLAS_2013_I1243871
	Year: 2013
	Summary: Measurement of jet shapes in top quark pair events at $\sqrt{s} = 7$ TeV with ATLAS
	Experiment: ATLAS
	Collider: LHC
	-SpiresID: 1243871
	+InspireID: 1243871
	Status: VALIDATED
	Authors:
	- Javier Llorente <javier.llorente.merino@cern.ch>
	References:
	- arXiv:1307.5749 [hep-ex]
	RunInfo: Top quark pair production in $pp$ collisions at $\sqrt{s} = 7$ TeV
	NumEvents: 1000000
	NeedCrossSection: no
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: pT(jets) > 30 GeV
	Description:
	'Measurement of jet shapes in top pair events in the ATLAS 7 TeV run. b-jets are shown to
	have a wider energy density distribution than light-quark induced jets.'
	BibKey: Aad:2013fba
	BibTeX: '@article{Aad:2013fba,
	author = "Aad, Georges and others",
	title = "{Measurement of jet shapes in top pair events at $\sqrt{s} = 7$ TeV using the ATLAS detector}",
	collaboration = "ATLAS Collaboration",
	year = "2013",
	eprint = "1307.5749",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2013-067",
	SLACcitation = "%%CITATION = ARXIV:1307.5749;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2014_I1268975.info b/data/anainfo/ATLAS_2014_I1268975.info
	--- a/data/anainfo/ATLAS_2014_I1268975.info
	+++ b/data/anainfo/ATLAS_2014_I1268975.info
	@@ -1,59 +1,59 @@
	Name: ATLAS_2014_I1268975
	Year: 2014
	Summary: High-mass dijet cross section
	Experiment: ATLAS
	Collider: LHC
	-SpiresID: 1268975
	+InspireID: 1268975
	Status: VALIDATED
	Authors:
	- Christopher Meyer <chris.meyer@cern.ch>
	References:
	- arXiv:1312.3524 [hep-ex]
	- JHEP 1405 (2014) 059
	RunInfo:
	QCD jet production with a minimum leading jet pT of 100 GeV and minimum second jet pT of 50 GeV at 7 TeV.
	NeedCrossSection: True
	NumEvents: 10000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [100,50]
	Description:
	'Double-differential dijet cross sections measured in pp collisions
	at the LHC with a 7 TeV centre-of-mass energy are presented as
	functions of dijet mass and rapidity separation of the two highest-pT
	jets. These measurements are obtained using data corresponding to an
	integrated luminosity of 4.5/fb, recorded by the ATLAS detector in
	2011. The data are corrected for detector effects so that cross
	sections are presented at the particle level. Cross sections are
	measured up to 5 TeV dijet mass using jets reconstructed with the
	anti-kt algorithm for values of the jet radius parameter of 0.4 and
	0.6. The cross sections are compared with next-to-leading-order
	perturbative QCD calculations by NLOJET++ corrected to account for
	non-perturbative effects. Comparisons with POWHEG predictions, using a
	next-to-leading-order matrix element calculation interfaced to a
	parton-shower Monte Carlo simulation, are also shown. Electroweak
	effects are accounted for in both cases. The quantitative comparison
	of data and theoretical predictions obtained using various
	parameterizations of the parton distribution functions is performed
	using a frequentist method. An example setting a lower limit on the
	compositeness scale for a model of contact interactions is presented,
	showing that the unfolded results can be used to constrain
	contributions to dijet production beyond that predicted by the
	Standard Model.'
	BibKey: Aad:2013tea
	BibTeX: '@article{Aad:2013tea,
	author = "Aad, Georges and others",
	title = "{Measurement of dijet cross sections in $pp$ collisions
	at 7 TeV centre-of-mass energy using the ATLAS detector}",
	collaboration = "ATLAS Collaboration",
	journal = "JHEP",
	volume = "1405",
	pages = "059",
	doi = "10.1007/JHEP05(2014)059",
	year = "2014",
	eprint = "1312.3524",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2013-192",
	SLACcitation = "%%CITATION = ARXIV:1312.3524;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2014_I1282441.info b/data/anainfo/ATLAS_2014_I1282441.info
	--- a/data/anainfo/ATLAS_2014_I1282441.info
	+++ b/data/anainfo/ATLAS_2014_I1282441.info
	@@ -1,40 +1,40 @@
	Name: ATLAS_2014_I1282441
	Year: 2014
	Summary: The differential production cross section of the $\phi(1020)$ meson in $\sqrt{s}=7$ TeV $pp$ collisions measured with the ATLAS detector
	Experiment: ATLAS
	Collider: LHC
	-SpiresID: 1282441
	+InspireID: 1282441
	Status: VALIDATED
	Authors:
	- Tim Martin <tim.martin@cern.ch>
	- Kiran Joshi <kiran.joshi@cern.ch>
	References:
	- arXiv:1402.6162 [hep-ex]
	RunInfo:
	Run minimum bias events
	NumEvents: 1000k
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [0.5, 1.2]
	NeedsCrossSection: yes
	Description:
	'A measurement is presented of the $\phi \rightarrow K^+K^-$ production cross section at $\sqrt{s}$ = 7 TeV using pp collision data
	corresponding to an integrated luminosity of 383 $\mu$b$^{-1}$ collected with the ATLAS experiment at the LHC. Selection of $\phi(1020)$
	mesons is based on the identification of charged kaons by their energy loss in the pixel detector. The differential cross section is
	measured as a function of the transverse momentum, $pT,\phi$, and rapidity, $y_\phi$, of the $\phi(1020)$ meson in the fiducial region
	500 < $pT,\phi$ < 1200 MeV, \|$y_\phi$\| < 0.8, kaon $pT,K$ > 230 MeV and kaon momentum $p_K$ < 800 MeV. The integrated $\phi(1020)$
	production cross section in this fiducial range is measured to be $\sigma_{\phi \rightarrow K^+K^-}$ = 570 \pm 8 (stat) \pm 66 (syst) \pm 20 (lumi) $\mu$b.'
	BibKey: Aad:2014rca
	BibTeX: '@article{Aad:2014rca,
	author = "Aad, Georges and others",
	title = "{The differential production cross section of the
	$\phi(1020)$ meson in $\sqrt{s}$ = 7 TeV $pp$ collisions
	measured with the ATLAS detector}",
	collaboration = "ATLAS Collaboration",
	year = "2014",
	eprint = "1402.6162",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2012-269",
	SLACcitation = "%%CITATION = ARXIV:1402.6162;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2014_I1298023.info b/data/anainfo/ATLAS_2014_I1298023.info
	--- a/data/anainfo/ATLAS_2014_I1298023.info
	+++ b/data/anainfo/ATLAS_2014_I1298023.info
	@@ -1,47 +1,47 @@
	Name: ATLAS_2014_I1298023
	Year: 2014
	-Summary: same-sign WW cross section
	+Summary: Same-sign WW cross section
	Experiment: ATLAS
	Collider: LHC
	InspireID: 1298023
	Status: VALIDATED
	Authors:
	- Simone Pagan Griso <simone.pagan.griso@cern.ch>
	- Christian Gutschow <chris.g@cern.ch>
	References:
	- Phys.Rev.Lett. 113 (2014) 141803
	- doi:10.1103/PhysRevLett.113.141803
	- arXiv:1405.6241 [hep-ex]
	RunInfo:
	p + p -> W W j j, where the W bosons decay leptonically
	Beams: [p+, p+]
	Energies: [8000]
	PtCuts: [25,30]
	NeedCrossSection: True
	Description:
	First measurement of $W^\pm W^\pm jj$, same-electric-charge diboson production in association with two jets, using
	$20.3 {\rmâfb}^{-1}$ of proton-proton collision data at $\sqrt{s} = 8$\,TeV recorded by the ATLAS detector at the
	Large Hadron Collider. Events with two reconstructed same-charge leptons ($e^\pm e^\pm$, $e^\pm \mu^\pm$, and
	$\mu^\pm \mu^\pm$) and two or more jets are analyzed. Production cross sections are measured in two fiducial regions,
	with different sensitivities to the electroweak and strong production mechanisms. First evidence
	for $W^\pm W^\pm j j$ production and electroweak-only $W^\pm W^\pm jj$ production is observed with a significance of
	4.5 and 3.6 standard deviations, respectively.
	BibKey: Aad:2014zda
	BibTeX: '@article{Aad:2014zda,
	author = "Aad, Georges and others",
	title = "{Evidence for Electroweak Production of
	$W^{\pm}W^{\pm}jj$ in $pp$ Collisions at $\sqrt{s}=8$ TeV
	with the ATLAS Detector}",
	collaboration = "ATLAS",
	journal = "Phys.Rev.Lett.",
	number = "14",
	volume = "113",
	pages = "141803",
	doi = "10.1103/PhysRevLett.113.141803",
	year = "2014",
	eprint = "1405.6241",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2014-079",
	SLACcitation = "%%CITATION = ARXIV:1405.6241;%%",
	}'
	diff --git a/data/anainfo/ATLAS_2014_I1327229.info b/data/anainfo/ATLAS_2014_I1327229.info
	--- a/data/anainfo/ATLAS_2014_I1327229.info
	+++ b/data/anainfo/ATLAS_2014_I1327229.info
	@@ -1,44 +1,44 @@
	Name: ATLAS_2014_I1327229
	Year: 2014
	Summary: Inclusive multilepton search at 8 TeV
	Experiment: ATLAS
	Collider: LHC
	InspireID: 1327229
	Status: VALIDATED
	Authors:
	- Joern Mahlstedt <joern.mahlstedt@cern.ch>
	References:
	- arXiv:1411.2921 [hep-ex]
	RunInfo:
	- any process producing at least 3 leptons (e.g. pair production of doubly-charged Higgs or excited leptons)
	+ Any process producing at least 3 leptons (e.g. pair production of doubly-charged Higgs or excited leptons)
	Beams: [p+, p+]
	Energies: [8000]
	PtCuts: [1,5,10,10]
	NeedCrossSection: True
	Description:
	A generic search for anomalous production of events with at least three charged leptons is presented. The data sample consists of
	- $pp$ collisions at $\sqrt{s} = 8$\,TeV collected in 2012 by the ATLAS experiment at the CERN Large Hadron Collider, and corresponds
	- to an integratedi luminosity of 20.3\,$\text{fb}^{â1}$. Events are required to have at least three selected lepton candidates, at
	- least two of which must be electrons or muons, while the third may be a hadronically decaying tau. Selected events are categorized
	- based on their lepton flavour content and signal regions are constructed using several kinematic variables of interest. No significant
	- deviations from Standard Model predictions are observed. Model-independent upper limits on contributions from beyond the Standard Model
	- phenomena are provided for each signal region, along with prescription to re-interpret the limits for any model. Constraints are also
	- placed on models predicting doubly charged Higgs bosons and excited leptons. For doubly charged Higgs bosons decaying to $e\tau$ or
	- $\muon\tau$, lower limits on the mass are set at 400\,GeV at 95\,\% confidence level. For excited leptons, constraints are provided as
	- functions of both the mass of the excited state and the compositeness scale $\Lambda$, with the strongest mass constraints arising in
	+ $pp$ collisions at $\sqrt{s} = 8$\,TeV collected in 2012 by the ATLAS experiment at the CERN Large Hadron Collider, and corresponds
	+ to an integratedi luminosity of 20.3\,$\text{fb}^{â1}$. Events are required to have at least three selected lepton candidates, at
	+ least two of which must be electrons or muons, while the third may be a hadronically decaying tau. Selected events are categorized
	+ based on their lepton flavour content and signal regions are constructed using several kinematic variables of interest. No significant
	+ deviations from Standard Model predictions are observed. Model-independent upper limits on contributions from beyond the Standard Model
	+ phenomena are provided for each signal region, along with prescription to re-interpret the limits for any model. Constraints are also
	+ placed on models predicting doubly charged Higgs bosons and excited leptons. For doubly charged Higgs bosons decaying to $e\tau$ or
	+ $\muon\tau$, lower limits on the mass are set at 400\,GeV at 95\,\% confidence level. For excited leptons, constraints are provided as
	+ functions of both the mass of the excited state and the compositeness scale $\Lambda$, with the strongest mass constraints arising in
	regions where the mass equals $\Lambda$. In such scenarios, lower mass limits are set at 3.0\,TeV for excited electrons and muons,
	2.5\,TeV for excited taus, and 1.6\,TeV for every excited-neutrino flavour.
	BibKey: Aad:2014hja
	BibTeX: '@article{Aad:2014hja,
	author = "Aad, Georges and others",
	title = "{Search for new phenomena in events with three or more
	charged leptons in $pp$ collisions at $\sqrt{s}=8$ TeV
	with the ATLAS detector}",
	collaboration = "ATLAS",
	year = "2014",
	eprint = "1411.2921",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2014-255",
	SLACcitation = "%%CITATION = ARXIV:1411.2921;%%"
	}'
	diff --git a/data/anainfo/ATLAS_2015_I1351916.info b/data/anainfo/ATLAS_2015_I1351916.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1351916.info
	@@ -0,0 +1,45 @@
	+Name: ATLAS_2015_I1351916
	+Year: 2015
	+Summary: $Z$ forward-backward asymmetry
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1351916
	+Status: VALIDATED
	+Authors:
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - arXiv:1503.03709 [hep-ex]
	+ - JHEP 09 (2015) 049
	+ - doi:10.1007/JHEP09(2015)049
	+RunInfo:
	+ Inclusive $Z$ in the electron channel
	+Beams: [p+, p+]
	+Energies: [7000]
	+PtCuts: [25,25]
	+NeedCrossSection: True
	+Description:
	+ 'Measurements from the ATLAS experiment of the forward-backward asymmetry in the reaction
	+ $pp \rightarrow Z / \gamma^\ast \rightarrow \ell^+\ell^-$, with $\ell$ being electrons or muons.
	+ The results are based on the full set of data collected in 2011 in $pp$ collisions at the LHC at
	+ $\sqrt{s} = 7$~TeV, corresponding to an integrated luminosity of 4.8~$\text{fb}^{-1}$. The measured
	+ asymmetry values are found to be in agreement with the corresponding Standard Model predictions.
	+ The default routine will pick up the electron decay channel of the $Z$ boson. Individual channels can
	+ be specified directly with the plugins ATLAS_2014_I1312627_EL and ATLAS_2014_I1312627_MU, respectively.
	+ N.B. When running on multiple files, the asymmetry might have to be reconstructed in a post-processing
	+ step. To that end, the necessary Histo1D objects are written out as well. The asymmetry is a Scatter2D
	+ objects ending in y01 and is constructed from the Histo1D objects (ending in y02 and y03) in the
	+ following way: y01 = (y02 - y03) / (y02 + y03)'
	+BibKey: Aad:2015uau
	+BibTeX: '@article{Aad:2015uau,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the forward-backward asymmetry of
	+ electron and muon pair-production in $pp$ collisions at
	+ $\sqrt{s} = 7$~TeV with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ year = "2015",
	+ eprint = "1503.03709",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2014-259",
	+ SLACcitation = "%%CITATION = ARXIV:1503.03709;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1351916_EL.info b/data/anainfo/ATLAS_2015_I1351916_EL.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1351916_EL.info
	@@ -0,0 +1,45 @@
	+Name: ATLAS_2015_I1351916_EL
	+Year: 2015
	+Summary: $Z$ forward-backward asymmetry
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1351916
	+Status: VALIDATED
	+Authors:
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - arXiv:1503.03709 [hep-ex]
	+ - JHEP 09 (2015) 049
	+ - doi:10.1007/JHEP09(2015)049
	+RunInfo:
	+ Inclusive $Z$ in the electron channel
	+Beams: [p+, p+]
	+Energies: [7000]
	+PtCuts: [25,25]
	+NeedCrossSection: True
	+Description:
	+ 'Measurements from the ATLAS experiment of the forward-backward asymmetry in the reaction
	+ $pp \rightarrow Z / \gamma^\ast \rightarrow \ell^+\ell^-$, with $\ell$ being electrons or muons.
	+ The results are based on the full set of data collected in 2011 in $pp$ collisions at the LHC at
	+ $\sqrt{s} = 7$~TeV, corresponding to an integrated luminosity of 4.8~$\text{fb}^{-1}$. The measured
	+ asymmetry values are found to be in agreement with the corresponding Standard Model predictions.
	+ The default routine will pick up the electron decay channel of the $Z$ boson. Individual channels can
	+ be specified directly with the plugins ATLAS_2014_I1312627_EL and ATLAS_2014_I1312627_MU, respectively.
	+ N.B. When running on multiple files, the asymmetry might have to be reconstructed in a post-processing
	+ step. To that end, the necessary Histo1D objects are written out as well. The asymmetry is a Scatter2D
	+ objects ending in y01 and is constructed from the Histo1D objects (ending in y02 and y03) in the
	+ following way: y01 = (y02 - y03) / (y02 + y03)'
	+BibKey: Aad:2015uau
	+BibTeX: '@article{Aad:2015uau,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the forward-backward asymmetry of
	+ electron and muon pair-production in $pp$ collisions at
	+ $\sqrt{s} = 7$~TeV with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ year = "2015",
	+ eprint = "1503.03709",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2014-259",
	+ SLACcitation = "%%CITATION = ARXIV:1503.03709;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1351916_MU.info b/data/anainfo/ATLAS_2015_I1351916_MU.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1351916_MU.info
	@@ -0,0 +1,45 @@
	+Name: ATLAS_2015_I1351916_MU
	+Year: 2015
	+Summary: $Z$ forward-backward asymmetry
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1351916
	+Status: VALIDATED
	+Authors:
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - arXiv:1503.03709 [hep-ex]
	+ - JHEP 09 (2015) 049
	+ - doi:10.1007/JHEP09(2015)049
	+RunInfo:
	+ Inclusive $Z$ in the muon channel
	+Beams: [p+, p+]
	+Energies: [7000]
	+PtCuts: [20,20]
	+NeedCrossSection: True
	+Description:
	+ 'Measurements from the ATLAS experiment of the forward-backward asymmetry in the reaction
	+ $pp \rightarrow Z / \gamma^\ast \rightarrow \ell^+\ell^-$, with $\ell$ being electrons or muons.
	+ The results are based on the full set of data collected in 2011 in $pp$ collisions at the LHC at
	+ $\sqrt{s} = 7$~TeV, corresponding to an integrated luminosity of 4.8~$\text{fb}^{-1}$. The measured
	+ asymmetry values are found to be in agreement with the corresponding Standard Model predictions.
	+ The default routine will pick up the electron decay channel of the $Z$ boson. Individual channels can
	+ be specified directly with the plugins ATLAS_2014_I1312627_EL and ATLAS_2014_I1312627_MU, respectively.
	+ N.B. When running on multiple files, the asymmetry might have to be reconstructed in a post-processing
	+ step. To that end, the necessary Histo1D objects are written out as well. The asymmetry is a Scatter2D
	+ objects ending in y01 and is constructed from the Histo1D objects (ending in y02 and y03) in the
	+ following way: y01 = (y02 - y03) / (y02 + y03)'
	+BibKey: Aad:2015uau
	+BibTeX: '@article{Aad:2015uau,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the forward-backward asymmetry of
	+ electron and muon pair-production in $pp$ collisions at
	+ $\sqrt{s} = 7$~TeV with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ year = "2015",
	+ eprint = "1503.03709",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2014-259",
	+ SLACcitation = "%%CITATION = ARXIV:1503.03709;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1376945.info b/data/anainfo/ATLAS_2015_I1376945.info
	--- a/data/anainfo/ATLAS_2015_I1376945.info
	+++ b/data/anainfo/ATLAS_2015_I1376945.info
	@@ -1,38 +1,38 @@
	Name: ATLAS_2015_I1376945
	Year: 2015
	-Summary: Colour flow at 8TeV
	+Summary: Colour flow in hadronic top decay at 8 TeV
	Experiment: ATLAS
	Collider: LHC
	InspireID: 1376945
	Status: VALIDATED
	Authors:
	- Ben Nachman <benjamin.philip.nachman@cern.ch>
	- Christian Gutschow <chris.g@cern.ch>
	References:
	- arXiv:1506.05629 [hep-ex]
	RunInfo:
	ttbar production with one W decaying leptonically, the other one hadronically
	Beams: [p+, p+]
	Energies: [8000]
	PtCuts: [25,25,25]
	NeedCrossSection: False
	Description:
	The distribution and orientation of energy inside jets is predicted to be an experimental handle on colour connections between the
	hard-scatter quarks and gluons initiating the jets. This is a measurement of the distribution of one such variable, the jet pull angle.
	- The pull angle is measured for jets produced in $t\bar{t}$ events with one $W$ boson decaying leptonically and the other decaying to
	+ The pull angle is measured for jets produced in $t\bar{t}$ events with one $W$ boson decaying leptonically and the other decaying to
	jets using 20.3\,$\text{fb}^{-1}$ of data recorded with the ATLAS detector at a centre-of-mass energy of $\sqrt{s} = 8$\,TeV at the LHC.
	The jet pull angle distribution is corrected for detector resolution and acceptance effects.
	BibKey: Aad:2015lxa
	BibTeX: '@article{Aad:2015lxa,
	author = "Aad, Georges and others",
	title = "{Measurement of colour flow with the jet pull angle in
	$t\bar{t}$ events using the ATLAS detector at $\sqrt{s}=8$
	TeV}",
	collaboration = "ATLAS",
	year = "2015",
	eprint = "1506.05629",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-PH-EP-2015-128",
	SLACcitation = "%%CITATION = ARXIV:1506.05629;%%"
	}'
	diff --git a/data/anainfo/ATLAS_2015_I1390114.info b/data/anainfo/ATLAS_2015_I1390114.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1390114.info
	@@ -0,0 +1,52 @@
	+Name: ATLAS_2015_I1390114
	+Year: 2015
	+Summary: $tt+b(b)$ at 8 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1390114
	+Status: VALIDATED
	+Authors:
	+ - Matthias Danninger <matthias.danninger@cern.ch>
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - Eur.Phys.J. C76 (2016) no.1, 11
	+ - doi:10.1140/epjc/s10052-015-3852-4
	+ - arXiv:1508.06868 [hep-ex]
	+RunInfo:
	+ Top-antitop production
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [25,20]
	+NeedCrossSection: True
	+Description:
	+ 'Fiducial cross-sections for $t\bar{t}$ production with one or two additional $b$-jets are presented, using an integrated luminosity
	+ of 20.3 fb${}^{-1}$ of proton-proton collisions at a centre-of-mass energy of 8 TeV at the Large Hadron Collider, collected with the
	+ ATLAS detector. The cross-section times branching ratio for $t\bar{t}$ events with at least one additional $b$-jet is measured to be
	+ 950 $\pm$ 70 (stat.)~${}^{+240}_{-190}$ (syst.)~fb in the lepton-plus-jets channel and
	+ 50 $\pm$ 10 (stat.) ${}^{+15}_{-10}$ (syst.) fb in the $e\mu$ channel. The cross-section times branching ratio for events with at
	+ least two additional $b$-jets is measured to be 19.3 $\pm$ 3.5 (stat.) $\pm$ 5.7 (syst.) fb in the dilepton channel
	+ ($e\mu$, $\mu\mu$, $ee$) using a method based on tight selection criteria, and 13.5 $\pm$ 3.3 (stat.) $\pm$ 3.6 (syst.) fb using a
	+ looser selection that allows the background normalisation to be extracted from data. The latter method also measures a value of
	+ 1.30 $\pm$ 0.33 (stat.) $\pm$ 0.28 (syst.)$\%$ for the ratio of $t\bar{t}$ production with two additional $b$-jets to $t\bar{t}$
	+ production with any two additional jets.
	+ NB: When merging several output YODA files, the ratio (d02-x01-y01) needs to be reconstructed in a post-processing step.'
	+BibKey: Aad:2015yja
	+BibTeX: '@article{Aad:2015yja,
	+ author = "Aad, Georges and others",
	+ title = "{Measurements of fiducial cross-sections for $t\bar{t}$
	+ production with one or two additional $b$-jets in $pp$
	+ collisions at $\sqrt{s} = 8$ TeV using the ATLAS
	+ detector}",
	+ collaboration = "ATLAS",
	+ journal = "Eur. Phys. J.",
	+ volume = "C76",
	+ year = "2016",
	+ number = "1",
	+ pages = "11",
	+ doi = "10.1140/epjc/s10052-015-3852-4",
	+ eprint = "1508.06868",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2015-200",
	+ SLACcitation = "%%CITATION = ARXIV:1508.06868;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1393758.info b/data/anainfo/ATLAS_2015_I1393758.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1393758.info
	@@ -0,0 +1,50 @@
	+Name: ATLAS_2015_I1393758
	+Year: 2015
	+Summary: Jet charge
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1393758
	+Status: VALIDATED
	+Authors:
	+ - Ben Nachman <ibenjamin.philip.nachman@cern.ch>
	+References:
	+ - Phys.Rev. D93 (2016) no.5, 052003
	+ - doi:10.1103/PhysRevD.93.052003
	+ - arXiv:1509.05190 [hep-ex]
	+RunInfo:
	+ dijet production
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [25]
	+NeedCrossSection: False
	+Description:
	+ The momentum-weighted sum of the charges of tracks associated to a jet is sensitive to the charge of the initiating quark or
	+ gluon. This paper presents a measurement of the distribution of momentum-weighted sums, called jet charge, in dijet events using
	+ 20.3 fb${}^{-1}$ of data recorded with the ATLAS detector at $\sqrt{s} = 8$ TeV in $pp$ collisions at the LHC. The jet charge
	+ distribution is unfolded to remove distortions from detector effects and the resulting particle-level distribution is compared with
	+ several models. The $p_\text{T}$ dependence of the jet charge distribution average and standard deviation are compared to
	+ predictions obtained with several leading-order and next-to-leading-order parton distribution functions. The data are also compared
	+ to different Monte Carlo simulations of QCD dijet production using various settings of the free parameters within these models.
	+ The chosen value of the strong coupling constant used to calculate gluon radiation is found to have a significant impact on the predicted
	+ jet charge. There is evidence for a $p_\text{T}$ dependence of the jet charge distribution for a given jet flavor. In agreement with
	+ perturbative QCD predictions, the data show that the average jet charge of quark-initiated jets decreases in magnitude as the energy
	+ of the jet increases.
	+BibKey: Aad:2015cua
	+BibTeX: '@article{Aad:2015cua,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of jet charge in dijet events from
	+ $\sqrt{s}$=8ââTeV pp collisions with the ATLAS
	+ detector}",
	+ collaboration = "ATLAS",
	+ journal = "Phys. Rev.",
	+ volume = "D93",
	+ year = "2016",
	+ number = "5",
	+ pages = "052003",
	+ doi = "10.1103/PhysRevD.93.052003",
	+ eprint = "1509.05190",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2015-207",
	+ SLACcitation = "%%CITATION = ARXIV:1509.05190;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1397635.info b/data/anainfo/ATLAS_2015_I1397635.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1397635.info
	@@ -0,0 +1,44 @@
	+Name: ATLAS_2015_I1397635
	+Year: 2015
	+Summary: $Wt$ at 8 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1397635
	+Status: VALIDATED
	+Authors:
	+ - Reinhard Schwienhorst <schwier@cern.ch>
	+References:
	+ - JHEP01 (2016) 064
	+ - doi:10.1007/JHEP01(2016)064
	+ - arXiv:1510.03752 [hep-ex]
	+RunInfo:
	+ Single top $Wt$ + top--antitop production
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [25,20]
	+NeedCrossSection: True
	+Description:
	+ Fiducial cross-section for $Wt+t\bar{t}$ production in events with two leptons and exactly one jet, using an integrated
	+ luminosity of 20.3 fb${}^{-1}$ of proton-proton collisions at a centre-of-mass energy of 8~TeV at the Large Hadron Collider,
	+ collected with the ATLAS detector. The cross-section for the production of a top quark and a $W$ boson is measured in a
	+ fiducial acceptance requiring two leptons with $\pT > 25$~GeV and $\|\eta\| < 2.5$, one jet with $\pT > 20$~GeV
	+ and $\|\eta\| < 2.5$, and $E^\text{miss}_\text{T} â>â20$~GeV, including both $Wt$ and top-quark pair events as signal.
	+ The measured value of the fiducial cross-section is $0.85 \pm 0.01$ (stat.) $\pm 0.07$ (syst.) $\pm 0.03$ (lumi.)~pb.
	+BibKey: Aad:2015eto
	+BibTeX: '@article{Aad:2015eto,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the production cross-section of a single
	+ top quark in association with a $W$ boson at 8~TeV with
	+ the ATLAS experiment}",
	+ collaboration = "ATLAS",
	+ journal = "JHEP",
	+ volume = "01",
	+ year = "2016",
	+ pages = "064",
	+ doi = "10.1007/JHEP01(2016)064",
	+ eprint = "1510.03752",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-2015-230, CERN-PH-EP-2015-230",
	+ SLACcitation = "%%CITATION = ARXIV:1510.03752;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1397637.info b/data/anainfo/ATLAS_2015_I1397637.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1397637.info
	@@ -0,0 +1,47 @@
	+Name: ATLAS_2015_I1397637
	+Year: 2015
	+Summary: Boosted ttbar differential cross-section
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1397637
	+Status: VALIDATED
	+Authors:
	+ - Lorenzo Massa <lorenzo.massa@cern.ch>
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - Phys.Rev. D93 (2016) no.3, 032009
	+ - doi:10.1103/PhysRevD.93.032009
	+ - arXiv:1510.03818 [hep-ex]
	+RunInfo:
	+ Top-antitop production
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [25,25]
	+NeedCrossSection: True
	+Description:
	+ The differential cross-section for pair production of top quarks with high transverse momentum is measured in 20.3fb${}^{-1}$ of
	+ proton-proton collisions at a center-of-mass energy of 8~TeV. The measurement is performed for $t\bar{t}$ events in the lepton+jets
	+ channel. The cross-section is reported as a function of the hadronically decaying top quark transverse momentum for values above
	+ 300~GeV. The hadronically decaying top quark is reconstructed as an anti-$k_\text{t}$ jet with radius parameter $R=1.0$ and
	+ identified with jet substructure techniques. The observed yield is corrected for detector effects to obtain a cross-section at
	+ particle level in a fiducial region close to the event selection.
	+BibKey: Aad:2015hna
	+BibTeX: '@article{Aad:2015hna,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the differential cross-section of highly
	+ boosted top quarks as a function of their transverse
	+ momentum in $\sqrt{s}$ = 8~TeV proton--proton collisions
	+ using the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ journal = "Phys. Rev.",
	+ volume = "D93",
	+ year = "2016",
	+ number = "3",
	+ pages = "032009",
	+ doi = "10.1103/PhysRevD.93.032009",
	+ eprint = "1510.03818",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2015-237",
	+ SLACcitation = "%%CITATION = ARXIV:1510.03818;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1404878.info b/data/anainfo/ATLAS_2015_I1404878.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1404878.info
	@@ -0,0 +1,46 @@
	+Name: ATLAS_2015_I1404878
	+Year: 2015
	+Summary: ttbar (to l+jets) differential cross sections at 8 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1404878
	+Status: VALIDATED
	+Authors:
	+ - Francesco La Ruffa <francesco.la.ruffa@cern.ch>
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - Submitted to EPJC
	+ - arXiv:1511.04716 [hep-ex]
	+RunInfo:
	+ non-all-hadronic ttbar production at 8 TeV
	+NeedCrossSection: yes
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [25.]
	+Description:
	+ Measurements of normalized differential cross-sections of top-quark pair production are presented as a function of the top-quark,
	+ $t\bar{t}$ system and event-level kinematic observables in proton-proton collisions at a centre-of-mass energy of
	+ $\sqrt{s} = 8$ TeV. The observables have been chosen to emphasize the $t\bar{t}$ production process and to be sensitive to effects
	+ of initial- and final-state radiation, to the different parton distribution functions, and to non-resonant processes and higher-order
	+ corrections. The dataset corresponds to an integrated luminosity of 20.3 fb${}^{-1}$, recorded in 2012 with the ATLAS detector at the
	+ CERN Large Hadron Collider. Events are selected in the lepton$+$jets channel, requiring exactly one charged lepton and at least four
	+ jets with at least two of the jets tagged as originating from a $b$-quark. The measured spectra are corrected for detector effects and
	+ are compared to several Monte Carlo simulations. The results are in fair agreement with the predictions over a wide kinematic range.
	+ Nevertheless, most generators predict a harder top-quark transverse momentum distribution at high values than what is observed in
	+ the data. Predictions beyond NLO accuracy improve the agreement with data at high top-quark transverse momenta. Using the current
	+ settings and parton distribution functions, the rapidity distributions are not well modelled by any generator under consideration.
	+ However, the level of agreement is improved when more recent sets of parton distribution functions are used.
	+BibKey: Aad:2015mbv
	+BibTeX: '@article{Aad:2015mbv,
	+ author = "Aad, Georges and others",
	+ title = "{Measurements of top-quark pair differential
	+ cross-sections in the lepton+jets channel in $pp$
	+ collisions at $\sqrt{s}=8$ TeV using the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ year = "2015",
	+ eprint = "1511.04716",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2015-239",
	+ SLACcitation = "%%CITATION = ARXIV:1511.04716;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1408516.info b/data/anainfo/ATLAS_2015_I1408516.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1408516.info
	@@ -0,0 +1,40 @@
	+Name: ATLAS_2015_I1408516
	+Year: 2015
	+Summary: $Z$ $p_T$ and $Z$ $\phi^*$
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1408516
	+Status: VALIDATED
	+Authors:
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - arXiv:1512.02192 [hep-ex]
	+ - submitted to EPJC
	+RunInfo:
	+ inclusive Z production in the electron channel
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [12,20]
	+NeedCrossSection: True
	+Description:
	+ Distributions of transverse momentum $p_\text{T}^{\ell\ell}$ and the angular variable $\phi^\ast_\eta$ of Drell-Yan lepton pairs
	+ are measured in $20.3\,\text{fb}^{-1}$ of proton-proton collisions at $\sqrt{s}=8$\,TeV with the ATLAS detector at the LHC.
	+ Measurements in electron-pair and muon-pair final states are corrected for detector effects. Compared to previous measurements
	+ in proto--proton collisions at i$\sqrt{s}=7$\,TeV, these new measurements benefit from a larger data sample and improved control
	+ of systematic uncertainties. Measurements are performed in bins of lepton-pair mass above, around and below the $Z$-boson mass peak.
	+ Specify the lepton channel (default is Z->ee) by using the dedicated plugins ATLAS_2015_I1408516_EL and ATLAS_2015_I1408516_MU.
	+BibKey: Aad:2015auj
	+BibTeX: '@article{Aad:2015auj,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the transverse momentum and
	+ $\phi^*_{\eta}$ distributions of Drell-Yan lepton pairs in
	+ proton--proton collisions at $\sqrt{s}=8$~TeV with the
	+ ATLAS detector}",
	+ collaboration = "ATLAS",
	+ year = "2015",
	+ eprint = "1512.02192",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2015-275",
	+ SLACcitation = "%%CITATION = ARXIV:1512.02192;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1408516_EL.info b/data/anainfo/ATLAS_2015_I1408516_EL.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1408516_EL.info
	@@ -0,0 +1,40 @@
	+Name: ATLAS_2015_I1408516_EL
	+Year: 2015
	+Summary: $Z$ $p_T$ and $Z$ $\phi^*$ in electron channel
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1408516
	+Status: VALIDATED
	+Authors:
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - arXiv:1512.02192 [hep-ex]
	+ - submitted to EPJC
	+RunInfo:
	+ inclusive Z production in the electron channel
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [12,20]
	+NeedCrossSection: True
	+Description:
	+ Distributions of transverse momentum $p_\text{T}^{\ell\ell}$ and the angular variable $\phi^\ast_\eta$ of Drell-Yan lepton pairs
	+ are measured in $20.3\,\text{fb}^{-1}$ of proton-proton collisions at $\sqrt{s}=8$\,TeV with the ATLAS detector at the LHC.
	+ Measurements in electron-pair and muon-pair final states are corrected for detector effects. Compared to previous measurements
	+ in proto--proton collisions at i$\sqrt{s}=7$\,TeV, these new measurements benefit from a larger data sample and improved control
	+ of systematic uncertainties. Measurements are performed in bins of lepton-pair mass above, around and below the $Z$-boson mass peak.
	+ Specify the lepton channel (default is Z->ee) by using the dedicated plugins ATLAS_2015_I1408516_EL and ATLAS_2015_I1408516_MU.
	+BibKey: Aad:2015auj
	+BibTeX: '@article{Aad:2015auj,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the transverse momentum and
	+ $\phi^*_{\eta}$ distributions of Drell-Yan lepton pairs in
	+ proton-proton collisions at $\sqrt{s}=8$~TeV with the
	+ ATLAS detector}",
	+ collaboration = "ATLAS",
	+ year = "2015",
	+ eprint = "1512.02192",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2015-275",
	+ SLACcitation = "%%CITATION = ARXIV:1512.02192;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2015_I1408516_MU.info b/data/anainfo/ATLAS_2015_I1408516_MU.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2015_I1408516_MU.info
	@@ -0,0 +1,40 @@
	+Name: ATLAS_2015_I1408516_MU
	+Year: 2015
	+Summary: $Z$ $p_T$ and $Z$ $\phi^*$ in muon channel
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1408516
	+Status: VALIDATED
	+Authors:
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - arXiv:1512.02192 [hep-ex]
	+ - submitted to EPJC
	+RunInfo:
	+ inclusive Z production in the muon channel
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [12,20]
	+NeedCrossSection: True
	+Description:
	+ Distributions of transverse momentum $p_\text{T}^{\ell\ell}$ and the angular variable $\phi^\ast_\eta$ of Drell-Yan lepton pairs
	+ are measured in $20.3\,\text{fb}^{-1}$ of proton-proton collisions at $\sqrt{s}=8$\,TeV with the ATLAS detector at the LHC.
	+ Measurements in electron-pair and muon-pair final states are corrected for detector effects. Compared to previous measurements
	+ in proto--proton collisions at i$\sqrt{s}=7$\,TeV, these new measurements benefit from a larger data sample and improved control
	+ of systematic uncertainties. Measurements are performed in bins of lepton-pair mass above, around and below the $Z$-boson mass peak.
	+ Specify the lepton channel (default is Z->ee) by using the dedicated plugins ATLAS_2015_I1408516_EL and ATLAS_2015_I1408516_MU.
	+BibKey: Aad:2015auj
	+BibTeX: '@article{Aad:2015auj,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the transverse momentum and
	+ $\phi^*_{\eta}$ distributions of Drell-Yan lepton pairs in
	+ proton-proton collisions at $\sqrt{s}=8$~TeV with the
	+ ATLAS detector}",
	+ collaboration = "ATLAS",
	+ year = "2015",
	+ eprint = "1512.02192",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2015-275",
	+ SLACcitation = "%%CITATION = ARXIV:1512.02192;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_CONF_2016_037.info b/data/anainfo/ATLAS_2016_CONF_2016_037.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_CONF_2016_037.info
	@@ -0,0 +1,23 @@
	+Name: ATLAS_2016_CONF_2016_037
	+Year: 2016
	+Summary: Search for SUSY in events with 2 same-sign leptons or 3 leptons, at 13~\TeV
	+Experiment: ATLAS
	+Collider: LHC
	+Status: UNVALIDATED
	+Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	+RunInfo: BSM signal events
	+NumEvents: 100000
	+NeedCrossSection: no
	+Beams: [p+, p+]
	+Energies: [13000]
	+Description:
	+ 'A search for strongly produced supersymmetric particles using signatures
	+ involving multiple energetic jets and either two isolated same-sign leptons
	+ ($e$ or $\mu$) or at least three isolated leptons. The analysis also utilises
	+ other observables, such as $b$-tagged jets or missing transverse momentum,
	+ to extend its sensitivity. A data sample of proton--proton collisions at
	+ $\sqrt{s} = 13~\TeV$ recorded with the ATLAS detector at the Large Hadron Collider
	+ in 2015 and 2016, corresponding to a total integrated luminosity of 13.2/fb,
	+ is used for the search. No significant excess over the Standard Model
	+ expectation is observed.'
	diff --git a/data/anainfo/ATLAS_2016_CONF_2016_054.info b/data/anainfo/ATLAS_2016_CONF_2016_054.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_CONF_2016_054.info
	@@ -0,0 +1,19 @@
	+Name: ATLAS_2016_CONF_2016_054
	+Year: 2016
	+Summary: ATLAS 2016 1-lepton SUSY search at 13~\TeV, from 14.8/fb CONF note
	+Experiment: ATLAS
	+Collider: LHC
	+Status: UNVALIDATED
	+Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	+RunInfo: BSM signal events
	+NumEvents: 100000
	+NeedCrossSection: no
	+Beams: [p+, p+]
	+Energies: [13000]
	+Description:
	+ 'A search for squarks and gluinos in final states with an isolated electron or
	+ muon, multiple jets and large missing transverse momentum using proton--proton
	+ collision data at a centre-of-mass energy of $\sqrt{s} = 13~\TeV$. The dataset
	+ corresponds to an integrated luminosity of 14.8/fb, recorded in 2015 and 2016
	+ by the ATLAS experiment at the Large Hadron Collider.'
	diff --git a/data/anainfo/ATLAS_2016_CONF_2016_078.info b/data/anainfo/ATLAS_2016_CONF_2016_078.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_CONF_2016_078.info
	@@ -0,0 +1,17 @@
	+Name: ATLAS_2016_CONF_2016_078
	+Year: 2016
	+Summary: ATLAS ICHEP16 0-lepton SUSY search at 13~\TeV with 13.2/fb
	+Experiment: ATLAS
	+Collider: LHC
	+Status: UNVALIDATED
	+Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	+RunInfo: BSM signal events.
	+NumEvents: 10000
	+NeedCrossSection: yes
	+Beams: [p+, p+]
	+Energies: [13000]
	+Description:
	+ 'ATLAS search for SUSY in 13~TeV $pp$ collisions at LHC Run~2, using 13.2/fb of
	+ integrated luminosity and events containing missing transverse momentum and
	+ no isolated high-energy leptons.'
	diff --git a/data/anainfo/ATLAS_2016_CONF_2016_094.info b/data/anainfo/ATLAS_2016_CONF_2016_094.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_CONF_2016_094.info
	@@ -0,0 +1,18 @@
	+Name: ATLAS_2016_CONF_2016_094
	+Year: 2016
	+Summary: ATLAS 2016 1-lepton + many jets SUSY search at 13~\TeV, from 14.8/fb CONF note
	+Experiment: ATLAS
	+Collider: LHC
	+Status: UNVALIDATED
	+Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	+RunInfo: BSM signal events
	+NumEvents: 100000
	+NeedCrossSection: no
	+Beams: [p+, p+]
	+Energies: [13000]
	+Description:
	+ 'A search for new phenomena in final states characterized by high jet multiplicity,
	+ an isolated lepton (electron or muon), and either zero or at least three $b$-tagged
	+ jets is. The search uses 14.8/fb of $\sqrt{s} = 13~\TeV$ proton--proton collision
	+ data collected by the ATLAS experiment at the Large Hadron Collider in 2015 and 2016.'
	diff --git a/data/anainfo/ATLAS_2016_I1419070.info b/data/anainfo/ATLAS_2016_I1419070.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1419070.info
	@@ -0,0 +1,46 @@
	+Name: ATLAS_2016_I1419070
	+Year: 2016
	+Summary: Number of tracks in jets
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1419070
	+Status: VALIDATED
	+Authors:
	+ - Ben Nachman <ibenjamin.philip.nachman@cern.ch>
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - arXiv:1602.00988 [hep-ex]
	+ - Eur.Phys.J. C76 (2016) no.6, 322
	+ - doi:10.1140/epjc/s10052-016-4126-5
	+RunInfo:
	+ dijet production
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [25]
	+NeedCrossSection: False
	+Description:
	+ The number of charged particles inside jets is a widely used discriminant for identifying the quark or gluon nature of the
	+ initiating parton and is sensitive to both the perturbative and non-perturbative components of fragmentation. This analysis
	+ presents a measurement of the average number of charged particles with $p_\text{T}>500$ MeV inside high-momentum jets in dijet
	+ events using 20.3 fb${}^{-1}$ of data recorded with the ATLAS detector in $pp$ collisions at $\sqrt{s}=8$ TeV collisions at the
	+ LHC. The jets considered have transverse momenta from 50 GeV up to and beyond 1.5 TeV. The reconstructed charged-particle track
	+ multiplicity distribution is unfolded to remove distortions from detector effects.
	+BibKey: Aad:2016oit
	+BibTeX: '@article{Aad:2016oit,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the charged-particle multiplicity inside
	+ jets from $\sqrt{s}=8$ TeV $pp$ collisions with the ATLAS
	+ detector}",
	+ collaboration = "ATLAS",
	+ journal = "Eur. Phys. J.",
	+ volume = "C76",
	+ year = "2016",
	+ number = "6",
	+ pages = "322",
	+ doi = "10.1140/epjc/s10052-016-4126-5",
	+ eprint = "1602.00988",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2016-001, CERN-EP-2016-001",
	+ SLACcitation = "%%CITATION = ARXIV:1602.00988;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1419652.info b/data/anainfo/ATLAS_2016_I1419652.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1419652.info
	@@ -0,0 +1,42 @@
	+Name: ATLAS_2016_I1419652
	+Year: 2016
	+Summary: Track-based minimum bias at 13 TeV in ATLAS
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1419652
	+Status: VALIDATED
	+Authors:
	+ - Roman Lysak <roman.lysak@cern.ch>
	+References:
	+ - arXiv:1602.01633
	+ - doi:10.1016/j.physletb.2016.04.050
	+ - Physics Letters B (2016), Vol. 758, pp. 67-88
	+RunInfo:
	+ $pp$ QCD interactions at 13 TeV. Diffractive events should
	+ be included. Multiple kinematic cuts should not be required.
	+Beams: [p+, p+]
	+Energies: [13000]
	+PtCuts: [0.5]
	+Description:
	+ Measurements from proton-proton collisions at centre-of-mass energy
	+ of $\sqrt{s} = 13$ TeV recorded with the ATLAS detector at
	+ the LHC. Events were collected using a single-arm minimum-bias
	+ trigger. The charged-particle multiplicity, its dependence on
	+ transverse momentum and pseudorapidity and the relationship between
	+ the mean transverse momentum and charged-particle multiplicity are
	+ measured. The observed distributions are corrected to well-defined
	+ phase-space regions ($p_\text{T} > 500$ MeV and $\|\eta\| < 2.5$ of the particles),
	+ using model-independent corrections.
	+BibKey: Aad:2016mok
	+BibTeX: '@article{Aad:2016mok,
	+ author = "Aad, Georges and others",
	+ title = "{Charged-particle distributions in $\sqrt{s}=13$ TeV $pp$
	+ interactions measured with the ATLAS detector at the LHC}",
	+ collaboration = "ATLAS",
	+ year = "2016",
	+ eprint = "1602.01633",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-014",
	+ SLACcitation = "%%CITATION = ARXIV:1602.01633;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1424838.info b/data/anainfo/ATLAS_2016_I1424838.info
	--- a/data/anainfo/ATLAS_2016_I1424838.info
	+++ b/data/anainfo/ATLAS_2016_I1424838.info
	@@ -1,36 +1,37 @@
	Name: ATLAS_2016_I1424838
	Year: 2015
	-Summary: Event shapes in leptonic Z-events
	+Summary: Event shapes in leptonic $Z$-events
	Experiment: ATLAS
	Collider: LHC
	InspireID: 1424838
	Status: VALIDATED
	Authors:
	- Holger Schulz <hschulz@cern.ch>
	#References:
	# - <Example: Phys.Lett.B639:151-158,2006, Erratum-ibid.B658:285-289,2008>
	# - <Example: doi:10.1016/j.physletb.2006.04.048>
	# - <Example: arXiv:hep-ex/0511054 (plus erratum)>
	RunInfo:
	$Z \to \ell\ell$ with $p_\perp(\ell)>20$~GeV
	NumEvents: 1000000
	NeedCrossSection: no
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	- 'Measurement of event-shape observables (Nch, SumPt, Thrust, Beamthrust, F-parameter, Spherocity) in Z $\to\ell\ell$ events at 7 TeV for different Z-pT regions.'
	+ 'Measurement of transverse event-shape observables ($N_\text{ch}$,
	+ $\sum\pT$, thrust, beam-thrust, $F$-parameter, and spherocity)
	+ in $Z \to \ell\ell$ events at 7~TeV for different $\pT(Z)$ regions.'
	BibKey: Aad:2016ria
	BibTeX: '@article{Aad:2016ria,
	author = "Aad, Georges and others",
	title = "{Measurement of event-shape observables in $Z \to
	- \ell^{+} \ell^{-}$ events in $pp$ collisions at
	- $\sqrt{s}=7$ TeV with the ATLAS detector at the LHC}",
	+ \ell^+ \ell^-$ events in $pp$ collisions at
	+ $\sqrt{s}=7$~\TeV with the ATLAS detector at the LHC}",
	collaboration = "ATLAS",
	year = "2016",
	eprint = "1602.08980",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-EP-2016-015",
	SLACcitation = "%%CITATION = ARXIV:1602.08980;%%"
	}'
	-
	diff --git a/data/anainfo/ATLAS_2016_I1426695.info b/data/anainfo/ATLAS_2016_I1426695.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1426695.info
	@@ -0,0 +1,46 @@
	+Name: ATLAS_2016_I1426695
	+Year: 2016
	+Summary: Track-based minimum bias at 8 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1426695
	+Status: VALIDATED
	+Authors:
	+ - Roman Lysak <roman.lysak@cern.ch>
	+References:
	+ - Eur.Phys.J. C76 (2016) no.7, 403
	+ - doi:10.1140/epjc/s10052-016-4203-9
	+ - arXiv:1603.02439 [hep-ex]
	+RunInfo:
	+ $pp$ QCD interactions at 8 TeV. Diffractive events should
	+ be included. Multiple kinematic cuts should not be required.
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [0.1, 0.5]
	+Description:
	+ This paper presents measurements of distributions of charged particles which are produced in proton-proton collisions at a
	+ centre-of-mass energy of $\sqrt{s} = 8$ TeV and recorded by the ATLAS detector at the LHC. A special dataset recorded in 2012
	+ with a small number of interactions per beam crossing (below 0.004) and corresponding to an integrated luminosity of
	+ 160 $\mu\text{b}^{-1}$ was used. A minimum-bias trigger was utilised to select a data sample of more than 9 million collision
	+ events. The multiplicity, pseudorapidity, and transverse momentum distributions of charged particles are shown in different
	+ regions of kinematics and charged-particle multiplicity, including measurements of final states at high multiplicity. The results are
	+ corrected for detector effects and are compared to the predictions of various Monte Carlo event generator models which simulate
	+ the full hadronic final state.
	+BibKey: Aad:2016xww
	+BibTeX: '@article{Aad:2016xww,
	+ author = "Aad, Georges and others",
	+ title = "{Charged-particle distributions in $pp$ interactions at
	+ $\sqrt{s}=$ 8 TeV measured with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ journal = "Eur. Phys. J.",
	+ volume = "C76",
	+ year = "2016",
	+ number = "7",
	+ pages = "403",
	+ doi = "10.1140/epjc/s10052-016-4203-9",
	+ eprint = "1603.02439",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-020",
	+ SLACcitation = "%%CITATION = ARXIV:1603.02439;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1444991.info b/data/anainfo/ATLAS_2016_I1444991.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1444991.info
	@@ -0,0 +1,48 @@
	+Name: ATLAS_2016_I1444991
	+Year: 2016
	+Summary: Higgs-to-WW differential cross sections at 8 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1444991
	+Status: VALIDATED
	+Authors:
	+ - Kathrin Becker <kathrin.becker@cern.ch>
	+References:
	+ - JHEP 1608 (2016) 104
	+ - doi:10.1007/JHEP08(2016)104
	+ - arXiv:1604.02997 [hep-ex]
	+RunInfo:
	+ gg -> H -> W W* -> enu munu production at 8 TeV
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [25]
	+NeedCrossSection: yes
	+Description:
	+ This paper describes a measurement of fiducial and differential cross sections of gluon-fusion Higgs boson production in the
	+ $H\rightarrow W W^\ast \rightarrow e\nu\mu\nu$ channel, using 20.3 fb$^{-1}$ of proton-proton collision data. The data were
	+ produced at a centre-of-mass energy of $\sqrt{s} = 8$ TeV at the CERN Large Hadron Collider and recorded by the ATLAS detector
	+ in 2012. Cross sections are measured from the observed $H\rightarrow W W^\ast \rightarrow e\nu\mu\nu$ signal yield in categories
	+ distinguished by the number of associated jets. The total cross section is measured in a fiducial region defined by the kinematic
	+ properties of the charged leptons and neutrinos. Differential cross sections are reported as a function of the number of jets,
	+ the Higgs boson transverse momentum, the dilepton rapidity, and the transverse momentum of the leading jet. The jet-veto efficiency,
	+ or fraction of events with no jets above a given transverse momentum threshold, is also reported. All measurements are compared to
	+ QCD predictions from Monte Carlo generators and fixed-order calculations, and are in agreement with the Standard Model predictions.
	+BibKey: Aad:2016lvc
	+BibTeX: '@article{Aad:2016lvc,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of fiducial differential cross sections of
	+ gluon-fusion production of Higgs bosons decaying to
	+ $WW^{*} \rightarrow e\nu\mu\nu$ with the ATLAS detector at $
	+ \sqrt{s}=8 $ TeV}",
	+ collaboration = "ATLAS",
	+ journal = "JHEP",
	+ volume = "08",
	+ year = "2016",
	+ pages = "104",
	+ doi = "10.1007/JHEP08(2016)104",
	+ eprint = "1604.02997",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-019",
	+ SLACcitation = "%%CITATION = ARXIV:1604.02997;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1452559.info b/data/anainfo/ATLAS_2016_I1452559.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1452559.info
	@@ -0,0 +1,50 @@
	+Name: ATLAS_2016_I1452559
	+Year: 2016
	+Summary: Monojet + missing energy search with 3.2/fb of 13 TeV $pp$ data
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1452559
	+Status: UNVALIDATED
	+Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	+ - Shehu AbdusSalam <shehu@cantab.net>
	+References:
	+ - 'Phys.Rev. D94 (2016) no.3, 032005'
	+ - 'DOI: 10.1103/PhysRevD.94.032005'
	+ - 'CERN-EP-2016-075'
	+ - 'arXiv:1604.07773'
	+RunInfo: 'BSM signal events'
	+NumEvents: 10000
	+NeedCrossSection: no
	+Beams: [p+, p+]
	+Energies: [13000]
	+Description:
	+ 'A search for new phenomena in final states with an energetic jet and large missing
	+ transverse momentum. The search uses proton-proton collision data corresponding to
	+ an integrated luminosity of 3.2/fb of $pp$ collisions at 13\;\TeV, collected in 2015
	+ with the ATLAS detector. Events are required to have at least one jet with a
	+ transverse momentum above 250 GeV and no leptons. Several signal regions are considered
	+ with increasing missing-transverse-momentum requirements between $E_T^\mathrm{miss} >
	+ 250\;\GeV$ and 700\;\GeV. Good agreement is observed between the number of events
	+ in data and Standard Model predictions.'
	+
	+BibKey: Aaboud:2016tnv
	+BibTeX: '@article{Aaboud:2016tnv,
	+ author = "Aaboud, Morad and others",
	+ title = "{Search for new phenomena in final states with an
	+ energetic jet and large missing transverse momentum in
	+ $pp$ collisions at $\sqrt{s}=13\;\TeV$ using the ATLAS
	+ detector}",
	+ collaboration = "ATLAS",
	+ journal = "Phys. Rev.",
	+ volume = "D94",
	+ year = "2016",
	+ number = "3",
	+ pages = "032005",
	+ doi = "10.1103/PhysRevD.94.032005",
	+ eprint = "1604.07773",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-075",
	+ SLACcitation = "%%CITATION = ARXIV:1604.07773;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1457605.info b/data/anainfo/ATLAS_2016_I1457605.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1457605.info
	@@ -0,0 +1,38 @@
	+Name: ATLAS_2016_I1457605
	+Year: 2016
	+Summary: Inclusive prompt photons at 8 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1457605
	+Status: VALIDATED
	+Authors:
	+ - Mark Stockton <chris.g@cern.ch>
	+References:
	+ - arXiv:1605.03495 [hep-ex]
	+RunInfo:
	+ Inclusive prompt photon production
	+Beams: [p+, p+]
	+Energies: [8000]
	+PtCuts: [25]
	+NeedCrossSection: True
	+Description:
	+ A measurement of the cross section for the inclusive production of isolated prompt photons in proton-proton collisions at a
	+ centre-of-mass energy of $\sqrt{s} = 8$~TeV is presented. The measurement covers the pseudorapidity ranges $\|\eta^\gamma\| < 1.37$
	+ $1.56 < \|\eta^\gamma\| < 2.37$ in the transverse energy range $25 < E^\gamma_\text{T} < 1500$~GeV. The results are based on an
	+ integrated luminosity of 20.2~fb${}^{-1}$, recorded by the ATLAS detector at the LHC. Photon candidates are identified by combining
	+ information from the calorimeters and the inner tracker. The background is subtracted using a data-driven technique, based on the
	+ observed calorimeter shower-shape variables and the deposition of hadronic energy in a narrow cone around the photon candidate.
	+BibKey: Aad:2016xcr
	+BibTeX: '@article{Aad:2016xcr,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the inclusive isolated prompt photon
	+ cross section in $pp$ collisions at $\sqrt{s} = 8$~TeV
	+ with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ year = "2016",
	+ eprint = "1605.03495",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-035",
	+ SLACcitation = "%%CITATION = ARXIV:1605.03495;%%"
	+}
	diff --git a/data/anainfo/ATLAS_2016_I1458270.info b/data/anainfo/ATLAS_2016_I1458270.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1458270.info
	@@ -0,0 +1,45 @@
	+Name: ATLAS_2016_I1458270
	+Year: 2016
	+Summary: 0-lepton SUSY search with 3.2/fb of 13 TeV $pp$ data
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1458270
	+Status: VALIDATED
	+Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	+References:
	+- 'Eur.Phys.J. C76 (2016) no.7, 392'
	+- 'DOI:10.1140/epjc/s10052-016-4184-8'
	+- 'arXiv:1605.03814'
	+Keywords:
	+ - susy
	+ - 0lepton
	+ - met
	+RunInfo: 'BSM signal events'
	+NumEvents: 10000
	+Luminosity_fb: 3.2
	+NeedCrossSection: no
	+Beams: [p+, p+]
	+Energies: [13000]
	+Description:
	+ 'ATLAS 0-lepton SUSY search using 3.2/fb of LHC $pp$ data at 13\;\TeV, recorded in
	+ 2015. The event selection is via signal regions requiring from 2-6 high-energy jets,
	+ and significant missing transverse energy.'
	+BibKey: Aaboud:2016zdn
	+BibTeX: '@article{Aaboud:2016zdn,
	+ author = "Aaboud, Morad and others",
	+ title = "{Search for squarks and gluinos in final states with jets
	+ and missing transverse momentum at $\sqrt{s} = 13\;\TeV$ with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ journal = "Eur. Phys. J.",
	+ volume = "C76",
	+ year = "2016",
	+ number = "7",
	+ pages = "392",
	+ doi = "10.1140/epjc/s10052-016-4184-8",
	+ eprint = "1605.03814",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-080",
	+ SLACcitation = "%%CITATION = ARXIV:1605.03814;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1467230.info b/data/anainfo/ATLAS_2016_I1467230.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1467230.info
	@@ -0,0 +1,50 @@
	+Name: ATLAS_2016_I1467230
	+Year: 2016
	+Summary: Track-based minimum bias with low-pT tracks at 13 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+SpiresID: 1467230
	+Status: VALIDATED
	+Authors:
	+ - Roman Lysak <roman.lysak@cern.ch>
	+References:
	+ - "Eur.Phys.J. C76 (2016) no.9, 502"
	+ - "doi:10.1140/epjc/s10052-016-4335-y"
	+ - "arXiv:1606.01133 [hep-ex]"
	+Keywords:
	+ - minbias
	+ - lowpt
	+RunInfo:
	+ "$pp$ QCD interactions at 13 TeV. Diffractive events should
	+ be included. Multiple kinematic cuts should not be required."
	+Luminosity_fb: 1.51*E-07
	+Beams: [p+, p+]
	+Energies: [13000]
	+PtCuts: [0.1]
	+Description:
	+ "Measurements of distributions of charged particles produced in proton-proton collisions with a centre-of-mass energy of 13 TeV
	+ are presented. The data were recorded by the ATLAS detector at the LHC and correspond to an integrated luminosity of
	+ 151 $\\mu$b$^{-1}$. The particles are required to have a transverse momentum greater than 100 MeV and an absolute pseudorapidity
	+ less than 2.5. The charged-particle multiplicity, its dependence on transverse momentum and pseudorapidity and the dependence of
	+ the mean transverse momentum on multiplicity are measured in events containing at least two charged particles satisfying the
	+ above kinematic criteria. The results are corrected for detector effects and compared to the predictions from several Monte Carlo
	+ event generators."
	+BibKey: Aaboud:2016itf
	+BibTeX: '@article{Aaboud:2016itf,
	+ author = "Aaboud, Morad and others",
	+ title = "{Charged-particle distributions at low transverse
	+ momentum in $\sqrt{s} = 13$ TeV pp interactions measured
	+ with the ATLAS detector at the LHC}",
	+ collaboration = "ATLAS",
	+ journal = "Eur. Phys. J.",
	+ volume = "C76",
	+ year = "2016",
	+ number = "9",
	+ pages = "502",
	+ doi = "10.1140/epjc/s10052-016-4335-y",
	+ eprint = "1606.01133",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-099",
	+ SLACcitation = "%%CITATION = ARXIV:1606.01133;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1467454.info b/data/anainfo/ATLAS_2016_I1467454.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1467454.info
	@@ -0,0 +1,52 @@
	+Name: ATLAS_2016_I1467454
	+Year: 2016
	+Summary: High-mass Drell-Yan at 8 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1467454
	+Status: VALIDATED
	+Authors:
	+ - Markus Zinser <markus.zinser@cern.ch>
	+References:
	+ - JHEP 1608 (2016) 009
	+ - doi:10.1007/JHEP08(2016)009
	+ - arXiv:1606.01736 [hep-ex]
	+Keywords:
	+ - drellyan
	+ - vjets
	+RunInfo:
	+ Drell-Yan production in $pp$ collisons at 8 TeV, leptonic $Z$ decays
	+Luminosity_fb: 20.3
	+Beams: [p+, p+]
	+Energies: [8000]
	+NeedCrossSection: yes
	+Description:
	+ 'This paper presents a measurement of the double-differential cross section for the Drell-Yan
	+ $Z/\gamma^\ast \rightarrow \ell^+\ell^-$ and photon-induced $\gamma\gamma \rightarrow \ell^+\ell^-$ processes where
	+ $\ell$ is an electron or muon. The measurement is performed for invariant masses of the lepton pairs, $m_{\ell\ell}$,
	+ between 116 GeV and 1500 GeV using a sample of 20.3 fb$^{-1}$ of pp collisions data at centre-of-mass energy of
	+ $\sqrt{s} = 8$ TeV collected by the ATLAS detector at the LHC in 2012. The data are presented double differentially
	+ in invariant mass and absolute dilepton rapidity as well as in invariant mass and absolute pseudorapidity separation
	+ of the lepton pair. The single-differential cross section as a function of $m_{\ell\ell}$ is also reported. The electron
	+ and muon channel measurements are combined and a total experimental precision of better than 1\% is achieved at low
	+ $m_{\ell\ell}$. A comparison to next-to-next-to-leading order perturbative QCD predictions using several recent parton
	+ distribution functions and including next-to-leading order electroweak effects indicates the potential of the data to
	+ constrain parton distribution functions. In particular, a large impact of the data on the photon PDF is demonstrated.'
	+BibKey: Aad:2016zzw
	+BibTeX: '@article{Aad:2016zzw,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the double-differential high-mass
	+ Drell-Yan cross section in pp collisions at $ \sqrt{s}=8 $
	+ TeV with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ journal = "JHEP",
	+ volume = "08",
	+ year = "2016",
	+ pages = "009",
	+ doi = "10.1007/JHEP08(2016)009",
	+ eprint = "1606.01736",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-079",
	+ SLACcitation = "%%CITATION = ARXIV:1606.01736;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1467454_EL.info b/data/anainfo/ATLAS_2016_I1467454_EL.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1467454_EL.info
	@@ -0,0 +1,52 @@
	+Name: ATLAS_2016_I1467454_EL
	+Year: 2016
	+Summary: High-mass Drell-Yan at 8 TeV, electron channel
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1467454
	+Status: VALIDATED
	+Authors:
	+ - Markus Zinser <markus.zinser@cern.ch>
	+References:
	+ - JHEP 1608 (2016) 009
	+ - doi:10.1007/JHEP08(2016)009
	+ - arXiv:1606.01736 [hep-ex]
	+Keywords:
	+ - drellyan
	+ - vjets
	+RunInfo:
	+ Drell-Yan production in $pp$ collisons at 8 TeV, $Z$ decaying to muons
	+Luminosity_fb: 20.3
	+Beams: [p+, p+]
	+Energies: [8000]
	+NeedCrossSection: yes
	+Description:
	+ 'This paper presents a measurement of the double-differential cross section for the Drell-Yan
	+ $Z/\gamma^\ast \rightarrow \ell^+\ell^-$ and photon-induced $\gamma\gamma \rightarrow \ell^+\ell^-$ processes where
	+ $\ell$ is an electron or muon. The measurement is performed for invariant masses of the lepton pairs, $m_{\ell\ell}$,
	+ between 116 GeV and 1500 GeV using a sample of 20.3 fb$^{-1}$ of pp collisions data at centre-of-mass energy of
	+ $\sqrt{s} = 8$ TeV collected by the ATLAS detector at the LHC in 2012. The data are presented double differentially
	+ in invariant mass and absolute dilepton rapidity as well as in invariant mass and absolute pseudorapidity separation
	+ of the lepton pair. The single-differential cross section as a function of $m_{\ell\ell}$ is also reported. The electron
	+ and muon channel measurements are combined and a total experimental precision of better than 1\% is achieved at low
	+ $m_{\ell\ell}$. A comparison to next-to-next-to-leading order perturbative QCD predictions using several recent parton
	+ distribution functions and including next-to-leading order electroweak effects indicates the potential of the data to
	+ constrain parton distribution functions. In particular, a large impact of the data on the photon PDF is demonstrated.'
	+BibKey: Aad:2016zzw
	+BibTeX: '@article{Aad:2016zzw,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the double-differential high-mass
	+ Drell-Yan cross section in pp collisions at $ \sqrt{s}=8 $
	+ TeV with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ journal = "JHEP",
	+ volume = "08",
	+ year = "2016",
	+ pages = "009",
	+ doi = "10.1007/JHEP08(2016)009",
	+ eprint = "1606.01736",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-079",
	+ SLACcitation = "%%CITATION = ARXIV:1606.01736;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1467454_MU.info b/data/anainfo/ATLAS_2016_I1467454_MU.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1467454_MU.info
	@@ -0,0 +1,52 @@
	+Name: ATLAS_2016_I1467454_MU
	+Year: 2016
	+Summary: High-mass Drell-Yan at 8 TeV, muon channel
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1467454
	+Status: VALIDATED
	+Authors:
	+ - Markus Zinser <markus.zinser@cern.ch>
	+References:
	+ - JHEP 1608 (2016) 009
	+ - doi:10.1007/JHEP08(2016)009
	+ - arXiv:1606.01736 [hep-ex]
	+Keywords:
	+ - drellyan
	+ - vjets
	+RunInfo:
	+ Drell-Yan production in $pp$ collisons at 8 TeV, $Z$ decaying to muons
	+Luminosity_fb: 20.3
	+Beams: [p+, p+]
	+Energies: [8000]
	+NeedCrossSection: yes
	+Description:
	+ 'This paper presents a measurement of the double-differential cross section for the Drell-Yan
	+ $Z/\gamma^\ast \rightarrow \ell^+\ell^-$ and photon-induced $\gamma\gamma \rightarrow \ell^+\ell^-$ processes where
	+ $\ell$ is an electron or muon. The measurement is performed for invariant masses of the lepton pairs, $m_{\ell\ell}$,
	+ between 116 GeV and 1500 GeV using a sample of 20.3 fb$^{-1}$ of pp collisions data at centre-of-mass energy of
	+ $\sqrt{s} = 8$ TeV collected by the ATLAS detector at the LHC in 2012. The data are presented double differentially
	+ in invariant mass and absolute dilepton rapidity as well as in invariant mass and absolute pseudorapidity separation
	+ of the lepton pair. The single-differential cross section as a function of $m_{\ell\ell}$ is also reported. The electron
	+ and muon channel measurements are combined and a total experimental precision of better than 1\% is achieved at low
	+ $m_{\ell\ell}$. A comparison to next-to-next-to-leading order perturbative QCD predictions using several recent parton
	+ distribution functions and including next-to-leading order electroweak effects indicates the potential of the data to
	+ constrain parton distribution functions. In particular, a large impact of the data on the photon PDF is demonstrated.'
	+BibKey: Aad:2016zzw
	+BibTeX: '@article{Aad:2016zzw,
	+ author = "Aad, Georges and others",
	+ title = "{Measurement of the double-differential high-mass
	+ Drell-Yan cross section in pp collisions at $ \sqrt{s}=8 $
	+ TeV with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ journal = "JHEP",
	+ volume = "08",
	+ year = "2016",
	+ pages = "009",
	+ doi = "10.1007/JHEP08(2016)009",
	+ eprint = "1606.01736",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-079",
	+ SLACcitation = "%%CITATION = ARXIV:1606.01736;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1468167.info b/data/anainfo/ATLAS_2016_I1468167.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1468167.info
	@@ -0,0 +1,37 @@
	+Name: ATLAS_2016_I1468167
	+Year: 2016
	+Summary: Measurement of the inelastic proton--proton cross-section at $\sqrt{s} = 13\,\TeV$
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1468167
	+Status: VALIDATED
	+Authors:
	+ - Zachary Marshall <zach.marshall@cern.ch>
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - 'arXiv:1606.02625 [hep-ex]'
	+Keywords:
	+ - minbias
	+RunInfo:
	+ Inelastic events (non-diffractive and inelastic diffractive).
	+Luminosity_fb: 6.0*E-08
	+Beams: [p+, p+]
	+Energies: [13000]
	+Description:
	+ 'Inelastic cross-section is measured for $\xi > 1 \times 10^{-6}$, where
	+ $\xi=M_X^2/s$ is calculated from the invariant mass, $M_X$,
	+ of hadrons selected using the largest rapidity gap in the event.'
	+BibKey: Aaboud:2016mmw
	+BibTeX: '@article{Aaboud:2016mmw,
	+ author = "Aaboud, Morad and others",
	+ title = "{Measurement of the Inelastic Proton-Proton Cross Section
	+ at $\sqrt{s} = 13$ TeV with the ATLAS Detector at the
	+ LHC}",
	+ collaboration = "ATLAS",
	+ year = "2016",
	+ eprint = "1606.02625",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-140",
	+ SLACcitation = "%%CITATION = ARXIV:1606.02625;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1468168.info b/data/anainfo/ATLAS_2016_I1468168.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1468168.info
	@@ -0,0 +1,46 @@
	+Name: ATLAS_2016_I1468168
	+Year: 2016
	+Summary: Dileptonic $e \mu$ $t\bar{t}$ early cross-section measurement at 13~TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1468168
	+Status: VALIDATED
	+Authors:
	+ - Tom Neep <tom.neep@cern.ch>
	+ - Barbara Alvarez Gonzalez <barbara.alvarez.gonzalez@cern.ch>
	+ - Yang Qin <yang.qin@cern.ch>
	+References:
	+ - Submitted to PLB
	+ - arXiv:1606.02699 [hep-ex]
	+RunInfo:
	+ $t\bar{t}$ production
	+Beams: [p+, p+]
	+Energies: [13000]
	+PtCuts: [25,25]
	+NeedCrossSection: True
	+Description:
	+ 'This paper describes a measurement of the inclusive top quark pair production cross-section ($\sigma_{t\bar{t}}$) with a data
	+ sample of 3.2~fb${}^{-1}$ of proton-proton collisions at a centre-of-mass energy of $\sqrt{s}=13$~TeV, collected in 2015 by the
	+ ATLAS detector at the LHC. This measurement uses events with an opposite-charge electron-muon pair in the final state. Jets
	+ containing $b$-quarks are tagged using an algorithm based on track impact parameters and reconstructed secondary vertices. The
	+ numbers of events with exactly one and exactly two $b$-tagged jets are counted and used to determine simultaneously
	+ $\sigma_{t\bar{t}}$ and the efficiency to reconstruct and $b$-tag a jet from a top quark decay, thereby minimising the associated
	+ systematic uncertainties. The cross-section is measured to be: $\sigma_{t\bar{t}} = 818 \pm 8$ (stat) $\pm 27$ (syst) $\pm 19$
	+ (lumi) $\pm 12$ (beam) pb, where the four uncertainties arise from data statistics, experimental and theoretical systematic effects,
	+ the integrated luminosity and the LHC beam energy, giving a total relative uncertainty of 4.4\%. The result is consistent with
	+ theoretical QCD calculations at next-to-next-to-leading order. A fiducial measurement corresponding to the experimental acceptance
	+ of the leptons is also presented.'
	+BibKey: Aaboud:2016pbd
	+BibTeX: '@article{Aaboud:2016pbd,
	+ author = "Aaboud, Morad and others",
	+ title = "{Measurement of the $t\bar{t}$ production cross-section
	+ using $e\mu$ events with $b$-tagged jets in $pp$ collisions at
	+ $\sqrt{s}=13$~TeV with the ATLAS detector}",
	+ collaboration = "ATLAS",
	+ year = "2016",
	+ eprint = "1606.02699",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-088",
	+ SLACcitation = "%%CITATION = ARXIV:1606.02699;%%"
	+}'
	diff --git a/data/anainfo/ATLAS_2016_I1479760.info b/data/anainfo/ATLAS_2016_I1479760.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/ATLAS_2016_I1479760.info
	@@ -0,0 +1,42 @@
	+Name: ATLAS_2016_I1479760
	+Year: 2016
	+Summary: Hard double-parton scattering in four-jet events at 7 TeV
	+Experiment: ATLAS
	+Collider: LHC
	+InspireID: 1479760
	+Status: VALIDATED
	+Authors:
	+ - Orel Gueta <orel.gueta@cern.ch>
	+ - Christian Gutschow <chris.g@cern.ch>
	+References:
	+ - 'arXiv:1608.01857 [hep-ex]'
	+Keywords:
	+ - jets
	+ - DPS
	+RunInfo:
	+ Four-jet events at 7 TeV
	+Luminosity_fb: 3.73E-02
	+Beams: [p+, p+]
	+Energies: [7000]
	+PtCuts: [20, 42.5]
	+NeedCrossSection: False
	+Description:
	+ 'Inclusive four-jet events produced in $pp$ collisions at a centre-of-mass energy of $\sqrt{s} = 7$ TeV have been
	+ analysed for the presence of hard double-parton scattering using data corresponding to an integrated luminosity of
	+ $(37.3 \pm 1.3)$ $\mathrm{pb}^{-1}$, collected with the ATLAS detector at the LHC. The distributions of observables
	+ sensitive to the contribution of hard double-parton scattering are provided for events containing at least four jets
	+ with $p_{\mathrm{T}} \geq 20$ GeV and $\eta \leq 4.4$, and at least one of which has $p_{\text{T}} \geq 42.5$ GeV.'
	+BibKey: Aaboud:2016dea
	+BibTeX: '@article{Aaboud:2016dea,
	+ author = "Aaboud, Morad and others",
	+ title = "{Study of hard double-parton scattering in four-jet
	+ events in $pp$ collisions at $\sqrt{s} = 7$ TeV with the
	+ ATLAS experiment}",
	+ collaboration = "ATLAS",
	+ year = "2016",
	+ eprint = "1608.01857",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2016-183",
	+ SLACcitation = "%%CITATION = ARXIV:1608.01857;%%"
	+}'
	diff --git a/data/anainfo/BABAR_2005_S6181155.info b/data/anainfo/BABAR_2005_S6181155.info
	--- a/data/anainfo/BABAR_2005_S6181155.info
	+++ b/data/anainfo/BABAR_2005_S6181155.info
	@@ -1,41 +1,42 @@
	Name: BABAR_2005_S6181155
	Summary: Production and decay of $\Xi^0_c$ at BABAR.
	Experiment: BaBar
	Collider: PEP-II
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Rev.Lett. 95 (2005) 142003
	- hep-ex/0504014
	RunInfo:
	$e^+ e^-$ analysis on the $\Upsilon(4S)$ resonance, with CoM boosts
	of 8.0~GeV~($e^-$) and 3.5~GeV~($e^+$)
	NumEvents: 1000000
	SpiresID: 6895344
	+InspireID: 679961
	Beams: [e+, e-]
	Energies: [[3.5, 8.0],[3.5,7.91]]
	PtCuts: [0]
	Description: Analysis of $\Xi_c^0$ production in B decays and from the $c\bar{c}$ continuum, with the $\Xi_c^0$
	decaying into $\Omega^- K^+$ and $\Xi^- \pi^+$ final states measured using 116.1 $\text{fb}^{-1}$ of data
	collected by the BABAR detector.
	The normalisation of the data as been modifed from that presented in the original paper in order
	to produce a differential cross section rather than the cross section in each bin. In addition to the data
	presented in the paper plots are alos made with unit normalisation which can be more useful for
	Monte Carlo tuning.
	BibKey: Aubert:2005cu
	BibTeX: '@article{Aubert:2005cu,
	author = "Aubert, Bernard and others",
	title = "{Production and decay of $\Xi_c^0$ at BABAR}",
	collaboration = "BABAR Collaboration",
	journal = "Phys.Rev.Lett.",
	volume = "95",
	pages = "142003",
	doi = "10.1103/PhysRevLett.95.142003",
	year = "2005",
	eprint = "hep-ex/0504014",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "SLAC-PUB-11100, BABAR-PUB-05-008",
	SLACcitation = "%%CITATION = HEP-EX/0504014;%%",
	}'
	diff --git a/data/anainfo/BABAR_2007_S6895344.info b/data/anainfo/BABAR_2007_S6895344.info
	--- a/data/anainfo/BABAR_2007_S6895344.info
	+++ b/data/anainfo/BABAR_2007_S6895344.info
	@@ -1,37 +1,38 @@
	Name: BABAR_2007_S6895344
	Summary: Inclusive $\Lambda_c^+$ Production in $e^+e^-$ Annihilation at $\sqrt{s}=10.54$ GeV and in $\Upsilon(4S)$ Decays.
	Experiment: BaBar
	Collider: PEP-II
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Rev. D75 (2007) 012003
	- hep-ex/0609004
	RunInfo:
	$e^+ e^-$ analysis on the $\Upsilon(4S)$ resonance, with CoM boosts
	of 8.0~GeV~($e^-$) and 3.5~GeV~($e^+$)
	NumEvents: 1000000
	SpiresID: 6895344
	+InspireID: 725377
	Beams: [e+, e-]
	Energies: [[3.5, 8.0],[3.5,7.91]]
	PtCuts: [0]
	Description: Measurements of the total production rates and momentum distributions of the charmed baryon $\Lambda_c^+$ in
	$e^+e^- \to$ hadrons at a centre-of-mass energy of 10.54 GeV and in $\Upsilon(4S)$ decays.
	BibKey: Aubert:2006cp
	BibTeX: '@article{Aubert:2006cp,
	author = "Aubert, Bernard and others",
	title = "{Inclusive $\Lambda_c^+$ Production in $e^+ e^-$ Annihilations
	at $\sqrt{s}=10.54$ GeV and in $\Upsilon(4S)$ Decays}",
	collaboration = "BABAR Collaboration",
	journal = "Phys.Rev.",
	volume = "D75",
	pages = "012003",
	doi = "10.1103/PhysRevD.75.012003",
	year = "2007",
	eprint = "hep-ex/0609004",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "SLAC-PUB-12074, BABAR-PUB-06-054",
	SLACcitation = "%%CITATION = HEP-EX/0609004;%%",
	}'
	diff --git a/data/anainfo/BABAR_2007_S7266081.info b/data/anainfo/BABAR_2007_S7266081.info
	--- a/data/anainfo/BABAR_2007_S7266081.info
	+++ b/data/anainfo/BABAR_2007_S7266081.info
	@@ -1,41 +1,42 @@
	Name: BABAR_2007_S7266081
	Summary: Measurements of Semi-Leptonic Tau Decays into Three Charged Hadrons
	Status: VALIDATED
	Experiment: BaBar
	Collider: PEP-II
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Rev.Lett.100:011801,2008
	- arXiv:0707.2981
	- SLAC-R-936
	RunInfo:
	Tau production, can be any process but original data was in
	$e^+ e^-$ at the $\Upsilon(4S)$ resonance, with CoM boosts of
	8.0 GeV~($e^-$) and 3.5~GeV~($e^+$)
	NumEvents: 1000000
	SpiresID: 7266081
	+InspireID: 756323
	Beams: [e+, e-]
	Energies: [[3.5, 8.0]]
	PtCuts: [0]
	Description: Measurement of tau decays to three charged hadrons using
	a data sample corresponding to an integrated luminosity of 342 fb$^{-1}$ collected
	with the BABAR detector at the SLAC PEP-II electron-positron storage ring operating
	at a center-of-mass energy near 10.58 GeV.
	BibKey: Aubert:2007mh
	BibTeX: '@Article{Aubert:2007mh,
	author = "Aubert, Bernard and others",
	collaboration = "BABAR",
	title = "{Exclusive branching fraction measurements of semileptonic
	tau decays into three charged hadrons, $\tau^- \to \phi
	\pi^- \nu_\tau$ and $\tau^- \to \phi K^- \nu_\tau$}",
	journal = "Phys. Rev. Lett.",
	volume = "100",
	year = "2008",
	pages = "011801",
	eprint = "0707.2981",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevLett.100.011801",
	SLACcitation = "%%CITATION = 0707.2981;%%"
	}'
	diff --git a/data/anainfo/BABAR_2013_I1116411.info b/data/anainfo/BABAR_2013_I1116411.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/BABAR_2013_I1116411.info
	@@ -0,0 +1,37 @@
	+Name: BABAR_2013_I1116411
	+Year: 2013
	+Summary: Exclusive semileptonic Bplus to omega decays.
	+Experiment: BABAR
	+Collider: PEP-II
	+InspireID: 1116411
	+Status: VALIDATED
	+Keywords:
	+ - bdecays
	+ - semileptonic
	+Authors:
	+ - Holger Schulz <holger.schulz@cern.ch>
	+RunInfo:
	+ Events with B-decays, either particle guns or collisions.
	+NumEvents: 10000
	+NeedCrossSection: no
	+Description:
	+ 'Implementation of Lorentz invariant q2 distributions ("form factor") for semileptonic Bplus decays'
	+BibKey: Lees:2012mq
	+BibTeX: '@article{Lees:2012mq,
	+ author = "Lees, J. P. and others",
	+ title = "{Branching fraction measurement of $B^+ \to \omega \ell^+
	+ \nu$ decays}",
	+ collaboration = "BaBar",
	+ journal = "Phys. Rev.",
	+ volume = "D87",
	+ year = "2013",
	+ number = "3",
	+ pages = "032004",
	+ doi = "10.1103/PhysRevD.87.099904, 10.1103/PhysRevD.87.032004",
	+ note = "[Erratum: Phys. Rev.D87,no.9,099904(2013)]",
	+ eprint = "1205.6245",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "SLAC-PUB-15029, BABAR-PUB-12-005",
	+ SLACcitation = "%%CITATION = ARXIV:1205.6245;%%"
	+}'
	diff --git a/data/anainfo/BABAR_2015_I1334693.info b/data/anainfo/BABAR_2015_I1334693.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/BABAR_2015_I1334693.info
	@@ -0,0 +1,37 @@
	+Name: BABAR_2015_I1334693
	+Year: 2015
	+Summary: Exclusive semileptonic D0 to piminus decays.
	+Experiment: BABAR
	+Collider: PEP-II
	+InspireID: 1334693
	+Status: VALIDATED
	+Keywords:
	+ - ddecays
	+ - semileptonic
	+Authors:
	+ - Holger Schulz <holger.schulz@cern.ch>
	+RunInfo:
	+ Events with D-decays, either particle guns or collisions.
	+NumEvents: 10000
	+NeedCrossSection: no
	+Description:
	+ 'Implementation of Lorentz invariant q2 distributions ("form factor") for semileptonic D0 decays'
	+BibKey: Lees:2014ihu
	+BibTeX: '@article{Lees:2014ihu,
	+ author = "Lees, J. P. and others",
	+ title = "{Measurement of the $D^0 \to \pi^- e^+ \nu_e$
	+ differential decay branching fraction as a function of
	+ $q^2$ and study of form factor parameterizations}",
	+ collaboration = "BaBar",
	+ journal = "Phys. Rev.",
	+ volume = "D91",
	+ year = "2015",
	+ number = "5",
	+ pages = "052022",
	+ doi = "10.1103/PhysRevD.91.052022",
	+ eprint = "1412.5502",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "BABAR-PUB-14-014, SLAC-PUB-16172",
	+ SLACcitation = "%%CITATION = ARXIV:1412.5502;%%"
	+}'
	diff --git a/data/anainfo/BELLE_2001_S4598261.info b/data/anainfo/BELLE_2001_S4598261.info
	--- a/data/anainfo/BELLE_2001_S4598261.info
	+++ b/data/anainfo/BELLE_2001_S4598261.info
	@@ -1,39 +1,40 @@
	Name: BELLE_2001_S4598261
	Summary: Measurement of inclusive production of neutral pions from $\Upsilon(4S)$ decays.
	Status: VALIDATED
	Experiment: Belle
	Collider: KEKB
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Rev. D64 (2001) 072001
	- hep-ex/0103041
	RunInfo:
	$e^+ e^-$ analysis on the $\Upsilon(4S)$ resonance, with CoM boosts of
	8.0~GeV~($e^-$) and 3.5~GeV~($e^+$)
	NumEvents: 1000000
	SpiresID: 4598261
	+InspireID: 554520
	Beams: [e+, e-]
	Energies: [[3.5, 8.0]]
	PtCuts: [0]
	Description: Measurement of the mean multiplicity and the momentum spectrum of
	neutral pions from the decays of the Upsilon(4S) resonance using the Belle
	detector operating at the KEKB $e^+e^-$ storage ring. Useful for tuning
	$B$ meson decay models.
	BibKey: Abe:2001hj
	BibTeX: '@article{Abe:2001hj,
	author = "Abe, K. and others",
	title = "{Measurement of inclusive production of neutral pions
	from Upsilon(4S) decays}",
	collaboration = "Belle Collaboration",
	journal = "Phys.Rev.",
	volume = "D64",
	pages = "072001",
	doi = "10.1103/PhysRevD.64.072001",
	year = "2001",
	eprint = "hep-ex/0103041",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "KEK-PREPRINT-2001-2, BELLE-PREPRINT-2001-3",
	SLACcitation = "%%CITATION = HEP-EX/0103041;%%",
	}'
	diff --git a/data/anainfo/BELLE_2011_I878990.info b/data/anainfo/BELLE_2011_I878990.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/BELLE_2011_I878990.info
	@@ -0,0 +1,35 @@
	+Name: BELLE_2011_I878990
	+Year: 2011
	+Summary: Exclusive semileptonic B0 to pi minus decays.
	+Experiment: BELLE
	+Collider: KEKB
	+InspireID: 878990
	+Status: VALIDATED
	+Keywords:
	+ - bdecays
	+ - semileptonic
	+Authors:
	+ - Holger Schulz <holger.schulz@cern.ch>
	+RunInfo:
	+ Events with B-decays, either particle guns or collisions.
	+NumEvents: 10000
	+NeedCrossSection: no
	+Description:
	+ 'Implementation of Lorentz invariant q2 distributions ("form factor") for semileptonic B0 decays'
	+BibKey: Ha:2010rf
	+BibTeX: '@article{Ha:2010rf,
	+ author = "Ha, H. and others",
	+ title = "{Measurement of the decay $B^0\to\pi^-\ell^+\nu$ and
	+ determination of $\|V_{ub}\|$}",
	+ collaboration = "Belle",
	+ journal = "Phys. Rev.",
	+ volume = "D83",
	+ year = "2011",
	+ pages = "071101",
	+ doi = "10.1103/PhysRevD.83.071101",
	+ eprint = "1012.0090",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "BELLE-PREPRINT-2010-22, KEK-PREPRINT-2010-37",
	+ SLACcitation = "%%CITATION = ARXIV:1012.0090;%%"
	+}'
	diff --git a/data/anainfo/BELLE_2013_I1216515.info b/data/anainfo/BELLE_2013_I1216515.info
	--- a/data/anainfo/BELLE_2013_I1216515.info
	+++ b/data/anainfo/BELLE_2013_I1216515.info
	@@ -1,41 +1,44 @@
	Name: BELLE_2013_I1216515
	Summary: Pion and kaon identified particle spectra at $\sqrt{s}=10.52$ GeV
	Status: VALIDATED
	Experiment: Belle
	Collider: KEKB
	Authors:
	- Peter Richardson
	References:
	- Phys.Rev.Lett. 111 (2013) 6, 062002
	- arXiv:1301.6183
	- doi:10.1103/PhysRevLett.111.062002

	+Keywords:
	+ - bdecays
	+ - semileptonic
	RunInfo:
	$e^+ e^-$ analysis at 10.52
	NumEvents: 1000000
	InspireID: 1216515
	Beams: [e+, e-]
	Energies: [[3.5,7.91]]
	PtCuts: [0]
	Description:
	Analysis of the identified particle spectra for charged pions and kaons at 10.52 GeV. This
	is continuum data below the $\Upsilon(4S)$ resonance.
	BibKey: Leitgab:2013qh
	BibTeX: '@article{Leitgab:2013qh,
	author = "Leitgab, M. and others",
	title = "{Precision Measurement of Charged Pion and Kaon
	Differential Cross Sections in e+e- Annihilation at
	s=10.52ââGeV}",
	collaboration = "Belle Collaboration",
	journal = "Phys.Rev.Lett.",
	number = "6",
	volume = "111",
	pages = "062002",
	doi = "10.1103/PhysRevLett.111.062002",
	year = "2013",
	eprint = "1301.6183",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "BELLE-PREPRINT-2013-2, KEK-PREPRINT-2012-38",
	SLACcitation = "%%CITATION = ARXIV:1301.6183;%%",
	}'
	diff --git a/data/anainfo/BELLE_2013_I1238273.info b/data/anainfo/BELLE_2013_I1238273.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/BELLE_2013_I1238273.info
	@@ -0,0 +1,34 @@
	+Name: BELLE_2013_I1238273
	+Year: 2013
	+Summary: Exclusive semileptonic B-decays
	+Experiment: BELLE
	+Collider: KEKB
	+InspireID: 1238273
	+Status: VALIDATED
	+Authors:
	+ - Holger Schulz <holger.schulz@cern.ch>
	+RunInfo:
	+ Events with B-decays, either particle guns or collisions.
	+NumEvents: 10000
	+NeedCrossSection: no
	+Description:
	+ 'Implementation of Lorentz invariant q2 distributions ("form factor") for semileptonic B decays'
	+BibKey: Sibidanov:2013rkk
	+BibTeX: '@article{Sibidanov:2013rkk,
	+ author = "Sibidanov, A. and others",
	+ title = "{Study of Exclusive $B \to X_u \ell \nu$ Decays and
	+ Extraction of $\\|V_{ub}\\|$ using Full Reconstruction
	+ Tagging at the Belle Experiment}",
	+ collaboration = "Belle",
	+ journal = "Phys. Rev.",
	+ volume = "D88",
	+ year = "2013",
	+ number = "3",
	+ pages = "032005",
	+ doi = "10.1103/PhysRevD.88.032005",
	+ eprint = "1306.2781",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "BELLE-PREPRINT-2013-9, KEK-PREPRINT-2013-8",
	+ SLACcitation = "%%CITATION = ARXIV:1306.2781;%%"
	+}'
	diff --git a/data/anainfo/BELLE_2015_I1397632.info b/data/anainfo/BELLE_2015_I1397632.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/BELLE_2015_I1397632.info
	@@ -0,0 +1,37 @@
	+Name: BELLE_2015_I1397632
	+Year: 2015
	+Summary: Exclusive semileptonic B to D decays.
	+Experiment: BELLE
	+Collider: KEKB
	+InspireID: 1397632
	+Status: VALIDATED
	+Authors:
	+ - Holger Schulz <holger.schulz@cern.ch>
	+RunInfo:
	+ Events with B-decays, either particle guns or collisions.
	+Keywords:
	+ - bdecays
	+ - semileptonic
	+NumEvents: 10000
	+NeedCrossSection: no
	+Description:
	+ 'Implementation of Lorentz invariant recoil w distributions for semileptonic B decays'
	+BibKey: Glattauer:2015teq
	+BibTeX: '@article{Glattauer:2015teq,
	+ author = "Glattauer, R. and others",
	+ title = "{Measurement of the decay $B\to D\ell\nu_\ell$ in fully
	+ reconstructed events and determination of the
	+ Cabibbo-Kobayashi-Maskawa matrix element $\|V_{cb}\|$}",
	+ collaboration = "Belle",
	+ journal = "Phys. Rev.",
	+ volume = "D93",
	+ year = "2016",
	+ number = "3",
	+ pages = "032006",
	+ doi = "10.1103/PhysRevD.93.032006",
	+ eprint = "1510.03657",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "BELLE-PREPRINT-2015-16, KEK-PREPRINT-2015-43",
	+ SLACcitation = "%%CITATION = ARXIV:1510.03657;%%"
	+}'
	diff --git a/data/anainfo/CDF_1988_S1865951.info b/data/anainfo/CDF_1988_S1865951.info
	--- a/data/anainfo/CDF_1988_S1865951.info
	+++ b/data/anainfo/CDF_1988_S1865951.info
	@@ -1,33 +1,34 @@
	Name: CDF_1988_S1865951
	SpiresID: 1865951
	+InspireID: 263320
	Summary: CDF transverse momentum distributions at 630 GeV and 1800 GeV.
	Description:
	Transverse momentum distributions at 630 GeV and 1800 GeV
	based on data from the CDF experiment at the Tevatron collider.
	Status: VALIDATED
	Experiment: CDF
	Collider: Tevatron Run I
	Year: 1988
	Authors:
	- Christophe Vaillant <c.l.j.j.vaillant@durham.ac.uk>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Phys.Rev.Lett.61:1819,1988
	- doi:10.1103/PhysRevLett.61.1819
	RunInfo: QCD min bias events at $\sqrt{s} = 630$ GeV and 1800 GeV, $\|\eta\| < 1.0$.
	Beams: [p-, p+]
	Energies: [630, 1800]
	PtCuts: [0]
	NeedCrossSection: yes
	BibKey: Abe:1988yu
	BibTeX: '@Article{Abe:1988yu,
	author = "Abe, F. and others",
	collaboration = "CDF",
	title = "{Transverse momentum distributions of charged particles produced in $\bar{p}p$ interactions at $\sqrt{s} = 630$ GeV and 1800 GeV}",
	journal = "Phys. Rev. Lett.",
	volume = "61",
	year = "1988",
	pages = "1819",
	doi = "10.1103/PhysRevLett.61.1819",
	SLACcitation = "%%CITATION = PRLTA,61,1819;%%"
	}'
	diff --git a/data/anainfo/CDF_1990_S2089246.info b/data/anainfo/CDF_1990_S2089246.info
	--- a/data/anainfo/CDF_1990_S2089246.info
	+++ b/data/anainfo/CDF_1990_S2089246.info
	@@ -1,39 +1,40 @@
	Name: CDF_1990_S2089246
	Year: 1990
	Summary: CDF pseudorapidity distributions at 630 and 1800 GeV
	Experiment: CDF
	Collider: Tevatron Run 0
	SpiresID: 2089246
	+InspireID: 283352
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Phys.Rev.D41:2330,1990
	- doi:10.1103/PhysRevD.41.2330
	RunInfo:
	QCD min bias events at $\sqrt{s} = 630$ and 1800 GeV.
	Particles with $c \tau > 10$\;mm should be set stable.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [630, 1800]
	PtCuts: [0]
	Description:
	Pseudorapidity distributions based on the CDF 630 and 1800 GeV runs
	from 1987. All data is detector corrected. The data confirms the UA5
	measurement of a $\mathrm{d}{N}/\mathrm{d}{\eta}$ rise with energy faster than
	$\ln{\sqrt{s}}$, and as such this analysis is important for
	constraining the energy evolution of minimum bias and underlying event
	characteristics in MC simulations.
	BibKey: Abe:1989td
	BibTeX: '@Article{Abe:1989td,
	author = "Abe, F. and others",
	collaboration = "CDF",
	title = "{Pseudorapidity distributions of charged particles produced in
	$\bar{p}p$ interactions at $\sqrt{s} = 630$ GeV and 1800 GeV}",
	journal = "Phys. Rev.",
	volume = "D41",
	year = "1990",
	pages = "2330",
	doi = "10.1103/PhysRevD.41.2330",
	SLACcitation = "%%CITATION = PHRVA,D41,2330;%%"
	}'
	diff --git a/data/anainfo/CDF_1993_S2742446.info b/data/anainfo/CDF_1993_S2742446.info
	--- a/data/anainfo/CDF_1993_S2742446.info
	+++ b/data/anainfo/CDF_1993_S2742446.info
	@@ -1,40 +1,44 @@
	Name: CDF_1993_S2742446
	Year: 1993
	Summary: Angular distribution of prompt photon
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 2742446
	+InspireID: 354237
	Status: UNVALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.Lett.71:679-683,1993
	- doi:10.1103/PhysRevLett.71.679
	RunInfo:
	All prompt photon production processes in $p \bar{p}$ at 1800 GeV.
	Hadronisation should be switched off, because non-prompt photon production
	has been corrected for.
	NumEvents: 10000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [15]
	Description:
	Data taken with the Collider Detector at Fermilab (CDF) during the 1988-1989
	run of the Tevatron are used to measure the distribution of the center-of-mass
	(rest frame of the initial state partons) angle between isolated prompt
	- photons and the beam direction.
	+ photons and the beam direction.
	+ WARNING --- Implemented is the simplified c.m. definition
	+ given in the paper. The rise of the data and the MC predictions presented in the
	+ latter could not be reproduced.
	BibKey: Abe:1993cv
	BibTeX: '@Article{Abe:1993cv,
	author = "Abe, F. and others",
	collaboration = "CDF",
	title = "{The Center-of-mass angular distribution of prompt photons
	produced in $p\bar{p}$ collisions at $\sqrt{s} = 1.8$
	TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "71",
	year = "1993",
	pages = "679-683",
	doi = "10.1103/PhysRevLett.71.679",
	SLACcitation = "%%CITATION = PRLTA,71,679;%%"
	}'
	ToDo:
	diff --git a/data/anainfo/CDF_1994_S2952106.info b/data/anainfo/CDF_1994_S2952106.info
	--- a/data/anainfo/CDF_1994_S2952106.info
	+++ b/data/anainfo/CDF_1994_S2952106.info
	@@ -1,42 +1,43 @@
	Name: CDF_1994_S2952106
	Year: 1994
	Summary: CDF Run I color coherence analysis.
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 2952106
	+InspireID: 374155
	Status: VALIDATED
	Authors:
	- Lars Sonnenschein <Lars.Sonnenschein@cern.ch>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Phys.Rev.D50,5562,1994
	- doi:10.1103/PhysRevD.50.5562
	RunInfo:
	QCD events at $\sqrt{s} = 1800$ GeV. Leading jet $\pT_\text{min} = 100$ GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [90]
	Description:
	CDF Run I color coherence analysis. Events with $\ge 3$ jets are
	selected and Et distributions of the three highest-pT jets are
	obtained. The plotted quantities are the $\Delta{R}$ between the 2nd
	and 3rd leading jets in the pT and pseudorapidity of the 3rd jet, and
	$\alpha = \mathrm{d}{\eta}/\mathrm{d}{\phi}$, where $\mathrm{d}{\eta}$
	is the pseudorapidity difference between the 2nd and 3rd jets and
	$\mathrm{d}{\phi}$ is their azimuthal angle difference. Since the
	data has not been detector-corrected, a bin by bin correction is
	applied, based on the distributions with ideal and CDF simulation as
	given in the publication.
	BibKey: Abe:1994nj
	BibTeX: '@Article{Abe:1994nj,
	author = "Abe, F. and others",
	collaboration = "CDF",
	title = "{Evidence for color coherence in $p\bar{p}$ collisions at $\sqrt{s} = 1.8$ TeV}",
	journal = "Phys. Rev.",
	volume = "D50",
	year = "1994",
	pages = "5562-5579",
	doi = "10.1103/PhysRevD.50.5562",
	SLACcitation = "%%CITATION = PHRVA,D50,5562;%%"
	}'
	diff --git a/data/anainfo/CDF_1996_S3108457.info b/data/anainfo/CDF_1996_S3108457.info
	--- a/data/anainfo/CDF_1996_S3108457.info
	+++ b/data/anainfo/CDF_1996_S3108457.info
	@@ -1,37 +1,41 @@
	Name: CDF_1996_S3108457
	Year: 1996
	Summary: Properties of high-mass multijet events
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 3108457
	-Status: UNVALIDATED
	+InspireID: 393345
	+Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.Lett.75:608-612,1995
	- doi:10.1103/PhysRevLett.75.608
	RunInfo:
	- Pure QCD events without underlying event.
	+ Pure QCD events without underlying event (the paper states that UE was
	+ corrected for).
	+ Several runs with different kinematic cuts might be needed to fill the
	+ 2,3,4,5 and 6-jet properly.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [20]
	Description:
	Properties of two-, three-, four-, five-, and six-jet events...
	Multijet-mass, leading jet angle, jet pT.
	NeedCrossSection: yes
	ToDo:
	- This is at 1800 GeV only, or also 630 GeV?
	BibKey: Abe:1995rw
	BibTeX: '@Article{Abe:1995rw,
	author = "Abe, F. and others",
	collaboration = "CDF",
	title = "{Properties of high mass multi - jet events at the Fermilab
	$p\bar{p}$ collider}",
	journal = "Phys. Rev. Lett.",
	volume = "75",
	year = "1995",
	pages = "608-612",
	doi = "10.1103/PhysRevLett.75.608",
	SLACcitation = "%%CITATION = PRLTA,75,608;%%"
	}'
	diff --git a/data/anainfo/CDF_1996_S3349578.info b/data/anainfo/CDF_1996_S3349578.info
	--- a/data/anainfo/CDF_1996_S3349578.info
	+++ b/data/anainfo/CDF_1996_S3349578.info
	@@ -1,37 +1,41 @@
	Name: CDF_1996_S3349578
	Year: 1996
	Summary: Further properties of high-mass multijet events
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 3349578
	-Status: UNVALIDATED
	+InspireID: 418504
	+Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.D54:4221-4233,1996
	- doi:10.1103/PhysRevD.54.4221
	- arXiv:hep-ex/9605004
	RunInfo:
	- Pure QCD events without underlying event.
	+ Pure QCD events without underlying event (the paper states that UE was
	+ corrected for).
	+ Several runs with different kinematic cuts might be needed to fill the
	+ 2,3,4,5 and 6-jet properly.
	NumEvents: 10000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [20]
	Description:
	Multijet distributions corresponding to ($4N-4$) variables that span
	the $N$-body parameter space in inclusive $N = 3$-, 4-, and 5-jet events.
	BibKey: Abe:1996nn
	BibTeX: '@Article{Abe:1996nn,
	author = "Abe, F. and others",
	collaboration = "CDF",
	title = "{Further Properties of High-Mass Multijet Events at the
	Fermilab Proton-Antiproton Collider}",
	journal = "Phys. Rev.",
	volume = "D54",
	year = "1996",
	pages = "4221-4233",
	eprint = "hep-ex/9605004",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.54.4221",
	SLACcitation = "%%CITATION = HEP-EX/9605004;%%"
	}'
	diff --git a/data/anainfo/CDF_1996_S3418421.info b/data/anainfo/CDF_1996_S3418421.info
	--- a/data/anainfo/CDF_1996_S3418421.info
	+++ b/data/anainfo/CDF_1996_S3418421.info
	@@ -1,36 +1,37 @@
	Name: CDF_1996_S3418421
	Year: 1996
	Summary: Dijet angular distributions
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 3418421
	+InspireID: 423414
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.Lett.77:5336-5341,1996
	- doi:10.1103/PhysRevLett.77.5336
	- arXiv:hep-ex/9609011
	RunInfo:
	QCD dijet events at Tevatron $\sqrt{s}=1.8$ TeV without MPI.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	Measurement of jet angular distributions in events with two jets in the final
	state in 5 bins of dijet invariant mass. Based on $106 \mathrm{pb}^{-1}$
	BibKey: Abe:1996mj
	BibTeX: '@Article{Abe:1996mj,
	author = "Abe, F. and others",
	collaboration = "CDF",
	title = "{Measurement of dijet angular distributions at CDF}",
	journal = "Phys. Rev. Lett.",
	volume = "77",
	year = "1996",
	pages = "5336-5341",
	eprint = "hep-ex/9609011",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevLett.77.5336",
	SLACcitation = "%%CITATION = HEP-EX/9609011;%%"
	}'
	diff --git a/data/anainfo/CDF_1997_S3541940.info b/data/anainfo/CDF_1997_S3541940.info
	--- a/data/anainfo/CDF_1997_S3541940.info
	+++ b/data/anainfo/CDF_1997_S3541940.info
	@@ -1,35 +1,36 @@
	Name: CDF_1997_S3541940
	Year: 1997
	-Summary: Properties of six jet events with large six jet mass
	+Summary: Properties of six-jet events with large six-jet mass
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 3541940
	-Status: UNVALIDATED
	+InspireID: 442265
	+Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.D56:2532-2543,1997
	- doi:10.1103/PhysRevD.56.2532
	- http://lss.fnal.gov/archive/1997/pub/Pub-97-093-E.pdf
	RunInfo:
	Pure QCD events without underlying event.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	Multijet distributions corresponding to 20 variables that span the 6-body
	parameter space in inclusive 6-jet events.
	BibKey: Abe:1997yb
	BibTeX: '@Article{Abe:1997yb,
	author = "Abe, F. and others",
	collaboration = "CDF",
	title = "{Properties of six-jet events with large six-jet mass at
	the Fermilab $p\bar{p}$ collider}",
	journal = "Phys. Rev.",
	volume = "D56",
	year = "1997",
	pages = "2532-2543",
	doi = "10.1103/PhysRevD.56.2532",
	SLACcitation = "%%CITATION = PHRVA,D56,2532;%%"
	}'
	diff --git a/data/anainfo/CDF_1998_S3618439.info b/data/anainfo/CDF_1998_S3618439.info
	--- a/data/anainfo/CDF_1998_S3618439.info
	+++ b/data/anainfo/CDF_1998_S3618439.info
	@@ -1,39 +1,40 @@
	Name: CDF_1998_S3618439
	Year: 1998
	Summary: Differential cross-section for events with large total transverse energy
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 3618439
	+InspireID: 448075
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.Lett.80:3461-3466,1998
	- 10.1103/PhysRevLett.80.3461
	RunInfo:
	QCD events at Tevatron with $\sqrt{s}=1.8$ TeV without MPI.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	Measurement of the differential cross section
	$\mathrm{d}\sigma/\mathrm{d}E_\perp^j$ for the
	production of multijet events in $p\bar{p}$ collisions where the
	sum is over all jets with transverse energy
	$E_\perp^j > E_\perp^\mathrm{min}$.
	NeedCrossSection: yes
	BibKey: Abe:1997eua
	BibTeX: '@Article{Abe:1997eua,
	author = "Abe, F. and others",
	collaboration = "CDF",
	title = "{Measurement of the differential cross section for events
	with large total transverse energy in $p\bar{p}$ collisions
	at $\sqrt{s} = 1.8$ TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "80",
	year = "1998",
	pages = "3461-3466",
	doi = "10.1103/PhysRevLett.80.3461",
	SLACcitation = "%%CITATION = PRLTA,80,3461;%%"
	}'
	diff --git a/data/anainfo/CDF_2000_S4155203.info b/data/anainfo/CDF_2000_S4155203.info
	--- a/data/anainfo/CDF_2000_S4155203.info
	+++ b/data/anainfo/CDF_2000_S4155203.info
	@@ -1,52 +1,53 @@
	Name: CDF_2000_S4155203
	Year: 2000
	Summary: Z pT measurement in CDF Z -> $e^+e^-$ events
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 4155203
	+InspireID: 505738
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Phys.Rev.Lett.84:845-850,2000
	- arXiv:hep-ex/0001021
	- doi:10.1103/PhysRevLett.84.845
	RunInfo:
	$p\bar{p}$ collisions at 1800 GeV.
	$Z/\gamma^*$ Drell-Yan events with $e^+e^-$ decay mode only.
	Restrict $Z/\gamma^*$ mass range to roughly $50~\text{GeV}/c^2 < m_{ee}
	< 120~\text{GeV}/c^2$ for efficiency.
	NumEvents: 100000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	Measurement of transverse momentum and total cross section of $e^+e^-$
	pairs in the Z-boson region of $66~\text{GeV}/c^2 < m_{ee} <
	116~\text{GeV}/c^2$ from pbar-p collisions at $\sqrt{s} = 1.8$ TeV, with
	the Tevatron CDF detector. The $Z$ $\pT$, in a fully-factorised picture,
	is generated by the momentum balance against initial state radiation
	(ISR) and the primordial/intrinsic $\pT$ of the $Z$'s parent partons in the
	incoming hadrons. The $Z$ $\pT$ is important in generator tuning to fix the
	interplay of ISR and multi-parton interactions (MPI) in generating
	`underlying event' activity.

	This analysis is subject to ambiguities in the experimental Z pT
	definition, since the Rivet implementation reconstructs the Z momentum from the
	dilepton pair with finite cones for QED bremstrahlung summation, rather than
	non-portable direct use of the (sometimes absent) Z in the event record.
	NeedCrossSection: yes
	BibKey: Affolder:1999jh
	BibTeX: '@Article{Affolder:1999jh,
	author = "Affolder, Anthony Allen and others",
	collaboration = "CDF",
	title = "{The transverse momentum and total cross section of $e^+e^-$ pairs in the $Z$ boson region from $p\bar{p}$ collisions at $\sqrt{s} = 1.8$ TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "84",
	year = "2000",
	pages = "845-850",
	eprint = "hep-ex/0001021",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevLett.84.845",
	SLACcitation = "%%CITATION = HEP-EX/0001021;%%"
	}'
	diff --git a/data/anainfo/CDF_2000_S4266730.info b/data/anainfo/CDF_2000_S4266730.info
	--- a/data/anainfo/CDF_2000_S4266730.info
	+++ b/data/anainfo/CDF_2000_S4266730.info
	@@ -1,39 +1,40 @@
	Name: CDF_2000_S4266730
	Year: 2000
	Summary: Inclusive jet cross section differential in dijet mass
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 4266730
	+InspireID: 511377
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.D61:091101,2000
	- doi:10.1103/PhysRevD.61.091101
	- arXiv:hep-ex/9912022
	RunInfo:
	Dijet events at Tevatron with $\sqrt{s}=1.8$ TeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	Measurement of the cross section for production of two or more jets as a
	function of dijet mass in the range 180 to 1000 GeV.
	It is based on an integrated luminosity of $86 \mathrm{pb}^{-1}$.
	NeedCrossSection: yes
	BibKey: Affolder:1999ua
	BibTeX: '@Article{Affolder:1999ua,
	author = "Affolder, Anthony Allen and others",
	collaboration = "CDF",
	title = "{A measurement of the differential dijet mass cross section
	in $p\bar{p}$ collisions at $\sqrt{s} = 1.8$ TeV}",
	journal = "Phys. Rev.",
	volume = "D61",
	year = "2000",
	pages = "091101",
	eprint = "hep-ex/9912022",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.61.091101",
	SLACcitation = "%%CITATION = HEP-EX/9912022;%%"
	}'
	diff --git a/data/anainfo/CDF_2001_S4517016.info b/data/anainfo/CDF_2001_S4517016.info
	--- a/data/anainfo/CDF_2001_S4517016.info
	+++ b/data/anainfo/CDF_2001_S4517016.info
	@@ -1,43 +1,44 @@
	Name: CDF_2001_S4517016
	Year: 2001
	Summary: Two jet triply-differential cross-section
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 4517016
	+InspireID: 538041
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.D64:012001,2001
	- doi:10.1103/PhysRevD.64.012001
	- arXiv:hep-ex/0012013
	RunInfo:
	Dijet events at Tevatron with $\sqrt{s}=1.8$ TeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	A measurement of the two-jet differential cross section,
	$\mathrm{d}^3\sigma/\mathrm{d}E_T \, \mathrm{d}\eta_1 \, \mathrm{d}\eta_2$,
	based on an integrated luminosity of $86 \mathrm{pb}^{-1}$.
	The differential cross section is measured as a function of the transverse
	energy, $E_\perp$, of a jet in the pseudorapidity region $0.1 < \|\eta_1\| < 0.7$ for
	four different pseudorapidity bins of a second jet restricted to
	$0.1 < \|\eta_2\| < 3.0$.
	NeedCrossSection: yes
	BibKey: Affolder:2000ew
	BibTeX: '@Article{Affolder:2000ew,
	author = "Affolder, Anthony Allen and others",
	collaboration = "CDF",
	title = "{Measurement of the two-jet differential cross section in
	$p\bar{p}$ collisions at $\sqrt{s} = 1800$ GeV}",
	journal = "Phys. Rev.",
	volume = "D64",
	year = "2001",
	pages = "012001",
	eprint = "hep-ex/0012013",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.64.012001",
	SLACcitation = "%%CITATION = HEP-EX/0012013;%%"
	}'
	diff --git a/data/anainfo/CDF_2001_S4563131.info b/data/anainfo/CDF_2001_S4563131.info
	--- a/data/anainfo/CDF_2001_S4563131.info
	+++ b/data/anainfo/CDF_2001_S4563131.info
	@@ -1,39 +1,40 @@
	Name: CDF_2001_S4563131
	Year: 2001
	-Summary: Inclusive jet cross section
	+Summary: Inclusive jet cross-section
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 4563131
	-Status: UNVALIDATED
	+InspireID: 552797
	+Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.D64:032001,2001
	- doi:10.1103/PhysRevD.64.032001
	- arXiv:hep-ph/0102074
	RunInfo:
	Dijet events at Tevatron with $\sqrt{s}=1.8$ TeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	- Measurement of the inclusive jet cross section for jet transverse energies
	- from 40 to 465 GeV in the pseudo-rapidity range $0.1<\|\eta\|<0.7$.
	+ Measurement of the inclusive jet cross-section for jet transverse energies
	+ from 40 to 465~GeV in the pseudorapidity range $0.1<\|\eta\|<0.7$.
	The results are based on 87 $\mathrm{pb}^{-1}$ of data.
	NeedCrossSection: yes
	BibKey: Affolder:2001fa
	BibTeX: '@Article{Affolder:2001fa,
	author = "Affolder, Anthony Allen and others",
	collaboration = "CDF",
	title = "{Measurement of the inclusive jet cross section in
	$\bar{p}p$ collisions at $\sqrt{s} = 1.8$ TeV}",
	journal = "Phys. Rev.",
	volume = "D64",
	year = "2001",
	pages = "032001",
	eprint = "hep-ph/0102074",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.64.032001",
	SLACcitation = "%%CITATION = HEP-PH/0102074;%%"
	}'
	diff --git a/data/anainfo/CDF_2001_S4751469.info b/data/anainfo/CDF_2001_S4751469.info
	--- a/data/anainfo/CDF_2001_S4751469.info
	+++ b/data/anainfo/CDF_2001_S4751469.info
	@@ -1,44 +1,45 @@
	Name: CDF_2001_S4751469
	Year: 2001
	Summary: Field & Stuart Run I underlying event analysis.
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 4751469
	+InspireID: 564673
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Phys.Rev.D65:092002,2002
	- FNAL-PUB 01/211-E
	RunInfo:
	$p\bar{p}$ QCD interactions at 1800 GeV. The leading jet is binned from
	0--49 GeV, and histos can usually can be filled with a single generator
	run without kinematic sub-samples.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	The original CDF underlying event analysis, based on decomposing each
	event into a transverse structure with ``toward'', ``away'' and
	``transverse'' regions defined relative to the azimuthal direction of
	the leading jet in the event. Since the toward region is by definition
	dominated by the hard process, as is the away region by momentum
	balance in the matrix element, the transverse region is most sensitive
	to multi-parton interactions. The transverse regions occupy $\|\phi\|
	\in [60\degree, 120\degree]$ for $\|\eta\| < 1$. The $\pT$ ranges for the
	leading jet are divided experimentally into the `min-bias' sample from
	0--20 GeV, and the `JET20' sample from 18--49 GeV.
	BibKey: Affolder:2001xt
	BibTeX: '@Article{Affolder:2001xt,
	author = "Affolder, Anthony Allen and others",
	collaboration = "CDF",
	title = "{Charged jet evolution and the underlying event in
	$p\bar{p}$ collisions at 1.8 TeV}",
	journal = "Phys. Rev.",
	volume = "D65",
	year = "2002",
	pages = "092002",
	doi = "10.1103/PhysRevD.65.092002",
	SLACcitation = "%%CITATION = PHRVA,D65,092002;%%"
	}'
	diff --git a/data/anainfo/CDF_2002_S4796047.info b/data/anainfo/CDF_2002_S4796047.info
	--- a/data/anainfo/CDF_2002_S4796047.info
	+++ b/data/anainfo/CDF_2002_S4796047.info
	@@ -1,47 +1,48 @@
	Name: CDF_2002_S4796047
	Year: 2002
	Summary: CDF Run 1 charged multiplicity measurement
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 4796047
	+InspireID: 567774
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Phys.Rev.D65:072005,2002
	- doi:10.1103/PhysRevD.65.072005
	RunInfo:
	QCD events at $\sqrt{s} = 630$ and 1800 GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [630, 1800]
	PtCuts: [0]
	Description:
	A study of $p\bar{p}$ collisions at $\sqrt{s} = 1800$ and 630 GeV collected
	using a minimum bias trigger in which the data set is divided into two
	classes corresponding to `soft' and `hard' interactions. For each
	subsample, the analysis includes measurements of the multiplicity,
	transverse momentum (pT) spectra, and the average pT and event-by-event
	pT dispersion as a function of multiplicity. A comparison of
	results shows distinct differences in the behavior of the two samples
	as a function of the center of mass energy. The properties of the soft
	sample are invariant as a function of c.m. energy.

	It should be noticed that minimum bias tunings of PYTHIA made by ATLAS
	in early 2010, which used this among all other available data from CDF
	and from ATLAS at 900~GeV and 7~TeV, found an unavoidable tension between
	this data and the rest. Accordingly, this data was excluded from the fits.
	Whether this reflects a problem with this dataset or with the PYTHIA MPI
	model is a judgement for users to make!
	BibKey: Acosta:2001rm
	BibTeX: '@Article{Acosta:2001rm,
	author = "Acosta, Darin E. and others",
	collaboration = "CDF",
	title = "{Soft and hard interactions in $p\bar{p}$ collisions at $\sqrt{s} = $ 1800~GeV and 630~GeV}",
	journal = "Phys. Rev.",
	volume = "D65",
	year = "2002",
	pages = "072005",
	doi = "10.1103/PhysRevD.65.072005",
	SLACcitation = "%%CITATION = PHRVA,D65,072005;%%"
	}'
	diff --git a/data/anainfo/CDF_2004_S5839831.info b/data/anainfo/CDF_2004_S5839831.info
	--- a/data/anainfo/CDF_2004_S5839831.info
	+++ b/data/anainfo/CDF_2004_S5839831.info
	@@ -1,52 +1,53 @@
	Name: CDF_2004_S5839831
	Year: 2004
	Summary: Transverse cone and `Swiss cheese' underlying event studies
	Experiment: CDF
	Collider: Tevatron Run 1
	SpiresID: 5839831
	+InspireID: 647490
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Phys. Rev. D70, 072002 (2004)
	- arXiv:hep-ex/0404004
	RunInfo:
	QCD events at $\sqrt{s} = 630$ \& 1800 GeV.
	Several $\pT^\text{min}$ cutoffs are probably required to fill the
	profile histograms, e.g. 0 (min bias), 30, 90, 150 GeV at 1800 GeV,
	and 0 (min bias), 20, 90, 150 GeV at 630 GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [630, 1800]
	PtCuts: [0, 30, 90, 150] # for 1800, [0, 20, 90, 150] for 630
	Description:
	This analysis studies the underlying event via transverse cones of
	$R = 0.7$ at 90 degrees in \phi relative to the leading (highest E) jet,
	at $\sqrt{s} = 630$ and 1800 GeV. This is similar to the 2001 CDF UE
	analysis, except that cones, rather than the whole central \eta range
	are used. The transverse cones are categorised as `TransMIN' and
	`TransMAX' on an event-by-event basis, to give greater sensitivity to
	the UE component.

	`Swiss Cheese' distributions, where cones around
	the leading $n$ jets are excluded from the distributions, are also
	included for $n = 2, 3$. This analysis is useful for constraining the
	energy evolution of the underlying event, since it performs the same
	analyses at two distinct CoM energies.

	WARNING! The pT plots are normalised to raw number of events. The min bias
	data have not been reproduced by MC, and are not recommended for tuning.
	BibKey: Acosta:2004wqa
	BibTeX: '@Article{Acosta:2004wqa,
	author = "Acosta, Darin E. and others",
	collaboration = "CDF",
	title = "{The underlying event in hard interactions at the Tevatron $\bar{p}p$ collider}",
	journal = "Phys. Rev.",
	volume = "D70",
	year = "2004",
	pages = "072002",
	eprint = "hep-ex/0404004",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.70.072002",
	SLACcitation = "%%CITATION = HEP-EX/0404004;%%"
	}'
	diff --git a/data/anainfo/CDF_2005_S6080774.info b/data/anainfo/CDF_2005_S6080774.info
	--- a/data/anainfo/CDF_2005_S6080774.info
	+++ b/data/anainfo/CDF_2005_S6080774.info
	@@ -1,44 +1,45 @@
	Name: CDF_2005_S6080774
	Year: 2005
	Summary: Differential cross sections for prompt diphoton production
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 6080774
	+InspireID: 667384
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys. Rev. Lett. 95, 022003
	- doi:10.1103/PhysRevLett.95.022003
	- arXiv:hep-ex/0412050
	RunInfo:
	$p \bar{p} \to \gamma \gamma$ [+ jets] at 1960 GeV. The analysis uses photons
	with pT larger then 13 GeV. To allow for shifts in the shower, the ME
	cut on the transverse photon momentum shouldn't be too hard, e.g. 5 GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [5]
	Description:
	Measurement of the cross section of prompt diphoton production in $p\bar{p}$
	collisions at $\sqrt{s} = 1.96$ TeV using a data sample of
	207~pb$^{-1}$ as a function of the diphoton mass, the transverse
	momentum of the diphoton system, and the azimuthal angle between the two
	photons.
	NeedCrossSection: yes
	BibKey: Acosta:2004sn
	BibTeX: '@Article{Acosta:2004sn,
	author = "Acosta, Darin E. and others",
	collaboration = "CDF",
	title = "{Measurement of the cross section for prompt diphoton
	production in $p\bar{p}$ collisions at $\sqrt{s} = 1.96$
	TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "95",
	year = "2005",
	pages = "022003",
	eprint = "hep-ex/0412050",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevLett.95.022003",
	SLACcitation = "%%CITATION = HEP-EX/0412050;%%"
	}'
	diff --git a/data/anainfo/CDF_2005_S6217184.info b/data/anainfo/CDF_2005_S6217184.info
	--- a/data/anainfo/CDF_2005_S6217184.info
	+++ b/data/anainfo/CDF_2005_S6217184.info
	@@ -1,41 +1,42 @@
	Name: CDF_2005_S6217184
	Year: 2005
	Summary: CDF Run II jet shape analysis
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 6217184
	+InspireID: 682179
	Status: VALIDATED
	Authors:
	- Lars Sonnenschein <Lars.Sonnenschein@cern.ch>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Phys.Rev.D71:112002,2005
	- doi:10.1103/PhysRevD.71.112002
	- arXiv:hep-ex/0505013
	RunInfo:
	QCD events at $\sqrt{s} = 1960$ GeV.
	Jet $\pT^\text{min}$ in plots is 37 GeV/$c$ -- choose a
	generator min $\pT$ well below this.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [30]
	Description:
	Measurement of jet shapes in inclusive jet production in $p \bar{p}$
	collisions at center-of-mass energy $\sqrt{s} = 1.96$ TeV. The data cover
	jet transverse momenta from 37--380 GeV and absolute jet rapidities in
	the range 0.1--0.7.
	BibKey: Acosta:2005ix
	BibTeX: '@Article{Acosta:2005ix,
	author = "Acosta, Darin E. and others",
	collaboration = "CDF",
	title = "{Study of jet shapes in inclusive jet production in $p\bar{p}$ collisions at $\sqrt{s} = 1.96$ TeV}",
	journal = "Phys. Rev.",
	volume = "D71",
	year = "2005",
	pages = "112002",
	eprint = "hep-ex/0505013",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.71.112002",
	SLACcitation = "%%CITATION = HEP-EX/0505013;%%"
	}'
	diff --git a/data/anainfo/CDF_2006_S6450792.info b/data/anainfo/CDF_2006_S6450792.info
	--- a/data/anainfo/CDF_2006_S6450792.info
	+++ b/data/anainfo/CDF_2006_S6450792.info
	@@ -1,42 +1,43 @@
	Name: CDF_2006_S6450792
	Year: 2006
	Summary: Inclusive jet cross section differential in pT
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 6450792
	+InspireID: 699933
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.D74:071103,2006
	- doi:10.1103/PhysRevD.74.071103
	- arXiv:hep-ex/0512020
	RunInfo:
	$p\bar{p}$ -> jets at 1960 GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [61]
	Description:
	Measurement of the inclusive jet cross section in ppbar interactions at
	$\sqrt{s}=1.96$ TeV using 385 $\mathrm{pb}^{-1}$ of data. The data cover the jet
	transverse momentum range from 61 to 620 GeV/c in $0.1 < \|y\| < 0.7$.
	This analysis has been updated with more data in more rapidity bins in
	CDF_2008_S7828950.
	NeedCrossSection: yes
	BibKey: Abulencia:2005yg
	BibTeX: '@Article{Abulencia:2005yg,
	author = "Abulencia, A. and others",
	collaboration = "CDF",
	title = "{Measurement of the inclusive jet cross section in
	$p\bar{p}$ interactions at $\sqrt{s} =$ 1.96-TeV using a
	cone-based jet algorithm}",
	journal = "Phys. Rev.",
	volume = "D74",
	year = "2006",
	pages = "071103",
	eprint = "hep-ex/0512020",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.74.071103",
	SLACcitation = "%%CITATION = HEP-EX/0512020;%%"
	}'
	diff --git a/data/anainfo/CDF_2006_S6653332.info b/data/anainfo/CDF_2006_S6653332.info
	--- a/data/anainfo/CDF_2006_S6653332.info
	+++ b/data/anainfo/CDF_2006_S6653332.info
	@@ -1,43 +1,44 @@
	Name: CDF_2006_S6653332
	Year: 2006
	Summary: b-jet cross section in Z + jets events
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 6653332
	+InspireID: 717572
	Status: VALIDATED
	Authors:
	- Lars Sonnenschein <Lars.Sonnenschein@cern.ch>
	- Steffen Schumann <s.schumann(at)thphys.uni-heidelberg.de>
	References:
	- Phys.Rev.D.74:032008,2006
	- doi:10.1103/PhysRevD.74.032008
	- arXiv:hep-ex/0605099v2
	RunInfo:
	Z + jets events at $\sqrt{s} = 1960$ GeV.
	Jets min $\pT$ cut = 20~GeV, leptons min $\pT$ cut = 10\;GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	PtCuts: [10]
	Energies: [1960]
	Description:
	Measurement of the $b$-jet cross section in events with $Z$ boson in
	$p\bar{p}$ collisions at center-of-mass energy $\sqrt{s} = 1.96$ TeV. The data
	cover jet transverse momenta above 20 GeV and jet pseudorapidities in
	the range -1.5 to 1.5. $Z$ bosons are identified in their electron and
	muon decay modes in an invariant dilepton mass range between 66 and
	116 GeV.
	NeedCrossSection: yes
	BibKey: Abulencia:2006ce
	BibTeX: '@Article{Abulencia:2006ce,
	author = "Abulencia, A. and others",
	collaboration = "CDF",
	title = "{Measurement of the $b$ jet cross-section in events with a $Z$ boson in $p \bar{p}$ collisions at $\sqrt{s} = 1.96$ TeV}",
	journal = "Phys. Rev.",
	volume = "D74",
	year = "2006",
	pages = "032008",
	eprint = "hep-ex/0605099",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.74.032008",
	SLACcitation = "%%CITATION = HEP-EX/0605099;%%"
	}'
	diff --git a/data/anainfo/CDF_2007_S7057202.info b/data/anainfo/CDF_2007_S7057202.info
	--- a/data/anainfo/CDF_2007_S7057202.info
	+++ b/data/anainfo/CDF_2007_S7057202.info
	@@ -1,48 +1,49 @@
	Name: CDF_2007_S7057202
	Year: 2007
	Summary: CDF Run II inclusive jet cross-section using the kT algorithm
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 7057202
	+InspireID: 743342
	Status: VALIDATED
	Authors:
	- David Voong
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.D75:092006,2007
	- Erratum-ibid.D75:119901,2007
	- FNAL-PUB 07/026-E
	- hep-ex/0701051
	RunInfo:
	p-pbar collisions at 1960~GeV. Jet pT bins from 54~GeV to 700~GeV.
	Jet rapidity $< \|2.1\|$.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	CDF Run II measurement of inclusive jet cross sections at a p-pbar
	collision energy of 1.96~TeV. Jets are reconstructed in the central
	part of the detector ($\|y\|<2.1$) using the kT algorithm with an $R$
	parameter of 0.7. The minimum jet pT considered is 54~GeV, with a
	maximum around 700~GeV. The inclusive jet pT is plotted in bins of
	rapidity $\|y\|<0.1$, $0.1<\|y\|<0.7$, $0.7<\|y\|<1.1$, $1.1<\|y\|<1.6$ and
	$1.6<\|y\|<2.1$.
	NeedCrossSection: yes
	BibKey: Abulencia:2007ez
	BibTeX: '@Article{Abulencia:2007ez,
	author = "Abulencia, A. and others",
	collaboration = "CDF",
	title = "{Measurement of the Inclusive Jet Cross Section using the
	{\boldmath $k_{\rm T}$} algorithmin{\boldmath
	$p\overline{p}$} Collisions at{\boldmath $\sqrt{s}$} = 1.96
	TeV with the CDF II Detector}",
	journal = "Phys. Rev.",
	volume = "D75",
	year = "2007",
	pages = "092006",
	eprint = "hep-ex/0701051",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.75.092006",
	SLACcitation = "%%CITATION = HEP-EX/0701051;%%"
	}'
	diff --git a/data/anainfo/CDF_2008_S7540469.info b/data/anainfo/CDF_2008_S7540469.info
	--- a/data/anainfo/CDF_2008_S7540469.info
	+++ b/data/anainfo/CDF_2008_S7540469.info
	@@ -1,41 +1,42 @@
	Name: CDF_2008_S7540469
	Year: 2008
	Summary: Measurement of differential Z/$\gamma^*$ + jet + X cross sections
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 7540469
	+InspireID: 768451
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.Lett.100:102001,2008
	- arXiv:0711.3717 [hep-ex]
	RunInfo:
	$p \bar{p} \to e^+ e^-$ + jets at 1960 GeV. Needs mass cut on lepton pair to
	avoid photon singularity, looser than $66 < m_{ee} < 116$
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Cross sections as a function of jet transverse momentum in 1 and 2 jet
	events, and jet multiplicity in $p \bar{p}$ collisions at $\sqrt{s} = 1.96$
	TeV, based on an integrated luminosity of $1.7~\text{fb}^{-1}$. The
	measurements cover the rapidity region $\|y_\text{jet}\| < 2.1$ and
	the transverse momentum range $\pT^\text{jet} > 30~\GeV/c$.
	NeedCrossSection: yes
	BibKey: :2007cp
	BibTeX: '@Article{:2007cp,
	author = "Aaltonen, T. and others",
	collaboration = "CDF",
	title = "{Measurement of inclusive jet cross-sections in $Z/\gamma^* \to e^+ e^-$ + jets production in $p \bar{p}$ collisions at $\sqrt{s}$ = 1.96\;TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "100",
	year = "2008",
	pages = "102001",
	eprint = "0711.3717",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "",
	SLACcitation = "%%CITATION = 0711.3717;%%"
	}'
	diff --git a/data/anainfo/CDF_2008_S7541902.info b/data/anainfo/CDF_2008_S7541902.info
	--- a/data/anainfo/CDF_2008_S7541902.info
	+++ b/data/anainfo/CDF_2008_S7541902.info
	@@ -1,59 +1,60 @@
	Name: CDF_2008_S7541902
	Year: 2008
	Summary: Jet pT and multiplicity distributions in W + jets events
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 7541902
	-Status: UNVALIDATED
	+InspireID: 768579
	+Status: VALIDATED
	Authors:
	- Ben Cooper <b.d.cooper@qmul.ac.uk>
	- Emily Nurse <nurse@hep.ucl.ac.uk>
	References:
	- arXiv:0711.4044 [hep-ex]
	- Phys.Rev.D77:011108,2008
	RunInfo:
	Requires the process $p\bar{p} \rightarrow {W} \rightarrow {e}\nu$.
	Additional hard jets will also have to be included to get a good
	description. The LO process in Herwig is set with IPROC=1451.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Measurement of the cross section for W boson production in association
	with jets in $p\bar{p}$ collisions at $\sqrt{s}=1.96$ TeV. The
	analysis uses 320 pb$^{-1}$ of data collected with the CDF II
	detector. W bosons are identified in their $e\nu$ decay channel and
	jets are reconstructed using an $R < 0.4$ cone algorithm. For each $W
	+ \geq$ n-jet sample (where n = 1--4) a measurement of
	d$\sigma({p}\bar{p} \rightarrow W + \geq$ n jet)/d$E_T(n^{th}$-jet)
	$\times$ BR($W \rightarrow{e}\nu$) is made, where d$E_T(n^{th}$-jet)
	is the Et of the n$^{th}$-highest Et jet above 20 GeV. A measurement
	of the total cross section, $\sigma(p\bar{p} \rightarrow W + \geq$
	$n$-jet) $\times$ BR($W \rightarrow{e}\nu)$ with $E_T(n^{th}-jet) > 25$
	GeV is also made. Both measurements are made for jets with $\|\eta\| <
	2$ and for a limited region of the $W \rightarrow{e}\nu$ decay phase
	space; $\|\eta^{e}\| < 1.1$, $p_{T}^{e} > 20$ GeV, $p_{T}^{\nu} > 30$
	GeV and $M_{T} > 20$ GeV. The cross sections are corrected for all
	detector effects and can be directly compared to particle level $W$ +
	jet(s) predictions. These measurements can be used to test and tune
	QCD predictions for the number of jets in and kinematics of $W$ + jets
	events.
	NeedCrossSection: yes
	BibKey: Aaltonen:2007ip
	BibTeX: '@Article{Aaltonen:2007ip,
	author = "Aaltonen, T. and others",
	collaboration = "CDF",
	title = "{Measurement of the cross section for $W^-$ boson
	production in association with jets in ppbar collisions at
	$\sqrt{s}$ = 1.96-TeV}",
	journal = "Phys. Rev.",
	volume = "D77",
	year = "2008",
	pages = "011108",
	eprint = "0711.4044",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevD.77.011108",
	SLACcitation = "%%CITATION = 0711.4044;%%"
	}'
	diff --git a/data/anainfo/CDF_2008_S7782535.info b/data/anainfo/CDF_2008_S7782535.info
	--- a/data/anainfo/CDF_2008_S7782535.info
	+++ b/data/anainfo/CDF_2008_S7782535.info
	@@ -1,51 +1,52 @@
	Name: CDF_2008_S7782535
	Year: 2008
	Summary: CDF Run II $b$-jet shape paper
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 7782535
	-Status: UNVALIDATED
	+InspireID: 787780
	+Status: VALIDATED
	Authors:
	- Alison Lister <alister@fnal.gov>
	- Emily Nurse <nurse@hep.ucl.ac.uk>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- arXiv:0806.1699
	- Phys.Rev.D78:072005,2008
	RunInfo:
	Requires $2 \rightarrow 2$ QCD scattering processes. The minimum jet $E_\perp$ is 52\;GeV,
	so kinematic cuts on pTmin may be required for statistical validity.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	A measurement of the shapes of $b$-jets using 300 pb$^{-1}$ of data
	obtained with CDF II in $p\bar{p}$ collisions at $\sqrt{s}=1.96$ TeV.
	The measured quantity is the average integrated jet shape, which is
	computed over an ensemble of jets. This quantity is expressed as
	$\Psi(r/R) = \langle\frac{p_\perp(0 \rightarrow r)}{p_\perp(0 \rightarrow
	R)}\rangle$, where $p_\perp(0 \rightarrow r)$ is the scalar sum of the
	transverse momenta of all objects inside a sub-cone of radius $r$ around
	the jet axis. The integrated shapes are by definition normalized such
	that $\Psi(r/R =1) = 1$. The measurement is done in bins of jet pT
	in the range 52 to 300\;GeV/$c$. The jets have $\|\eta\| < 0.7$. The $b$-jets
	are expected to be broader than inclusive jets. Moreover, $b$-jets
	containing a single $b$-quark are expected to be narrower than those
	containing a $b \bar{b}$ pair from gluon splitting.
	BibKey: Aaltonen:2008de
	BibTeX: '@Article{Aaltonen:2008de,
	author = "Aaltonen, T. and others",
	collaboration = "CDF",
	title = "{Measurement of $b$-jet Shapes in Inclusive Jet Production
	in $p \bar{p}$ Collisions at $\sqrt{s}$ = 1.96-TeV}",
	journal = "Phys. Rev.",
	volume = "D78",
	year = "2008",
	pages = "072005",
	eprint = "0806.1699",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevD.78.072005",
	SLACcitation = "%%CITATION = 0806.1699;%%"
	}'
	diff --git a/data/anainfo/CDF_2008_S7828950.info b/data/anainfo/CDF_2008_S7828950.info
	--- a/data/anainfo/CDF_2008_S7828950.info
	+++ b/data/anainfo/CDF_2008_S7828950.info
	@@ -1,47 +1,48 @@
	Name: CDF_2008_S7828950
	Year: 2008
	Summary: CDF Run II inclusive jet cross-section using the Midpoint algorithm
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 7828950
	+InspireID: 790693
	Status: VALIDATED
	Authors:
	- Craig Group <group@fnal.gov>
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:0807.2204
	- Phys.Rev.D78:052006,2008
	RunInfo:
	Requires $2\rightarrow{2}$ QCD scattering processes. The minimum jet
	$E_\perp$ is 62 GeV, so a cut on kinematic pTmin may be required for
	good statistics.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [62]
	Description:
	Measurement of the inclusive jet cross section in $p\bar{p}$
	collisions at $\sqrt{s}=1.96$ TeV as a function of jet $E_\perp$, for $E_\perp >$
	62 GeV. The data is collected by the CDF II detector and has an
	integrated luminosity of 1.13 fb$^{-1}$. The measurement was made
	using the cone-based Midpoint jet clustering algorithm in rapidity
	bins within $\|y\|<2.1$. This measurement can be used to provide
	increased precision in PDFs at high parton momentum fraction $x$.
	NeedCrossSection: yes
	BibKey: Aaltonen:2008eq
	BibTeX: '@Article{Aaltonen:2008eq,
	author = "Aaltonen, T. and others",
	collaboration = "CDF",
	title = "{Measurement of the Inclusive Jet Cross Section at the
	Fermilab Tevatron p-pbar Collider Using a Cone-Based Jet
	Algorithm}",
	journal = "Phys. Rev.",
	volume = "D78",
	year = "2008",
	pages = "052006",
	eprint = "0807.2204",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevD.78.052006",
	SLACcitation = "%%CITATION = 0807.2204;%%"
	}'
	diff --git a/data/anainfo/CDF_2008_S8093652.info b/data/anainfo/CDF_2008_S8093652.info
	--- a/data/anainfo/CDF_2008_S8093652.info
	+++ b/data/anainfo/CDF_2008_S8093652.info
	@@ -1,37 +1,38 @@
	Name: CDF_2008_S8093652
	Year: 2008
	Summary: Dijet mass spectrum
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 8093652
	+InspireID: 805902
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:0812.4036 [hep-ex]
	RunInfo:
	$p \bar{p} \to$ jets at 1960 GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Dijet mass spectrum from 0.2 TeV to 1.4 TeV in $p \bar{p}$ collisions at
	$\sqrt{s} = 1.96$ TeV, based on an integrated luminosity of
	1.13 fb$^{-1}$.
	NeedCrossSection: yes
	BibKey: Aaltonen:2008dn
	BibTeX: '@Article{Aaltonen:2008dn,
	author = "Aaltonen, T. and others",
	collaboration = "CDF",
	title = "{Search for new particles decaying into dijets in proton-antiproton collisions at $\sqrt{s} = 1.96$ TeV}",
	journal = "Phys. Rev.",
	volume = "D79",
	year = "2009",
	pages = "112002",
	eprint = "0812.4036",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevD.79.112002",
	SLACcitation = "%%CITATION = 0812.4036;%%"
	}'
	diff --git a/data/anainfo/CDF_2008_S8095620.info b/data/anainfo/CDF_2008_S8095620.info
	--- a/data/anainfo/CDF_2008_S8095620.info
	+++ b/data/anainfo/CDF_2008_S8095620.info
	@@ -1,48 +1,49 @@
	Name: CDF_2008_S8095620
	Year: 2008
	Summary: CDF Run II Z+b-jet cross section paper, 2 fb-1
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 8095620
	+InspireID: 806082
	Status: VALIDATED
	Authors:
	- Emily Nurse <nurse@hep.ucl.ac.uk>
	- Steffen Schumann <s.schumann(at)thphys.uni-heidelberg.de>
	References:
	- arXiv:0812.4458
	RunInfo:
	Requires the process $p\bar{p} \rightarrow {Z} \rightarrow{\ell}\ell$, where $\ell$ is $e$ or $\mu$. Additional hard jets will also have to be included to get a good description.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Measurement of the b-jet production cross section for events
	containing a $Z$ boson produced in $p\bar{p}$ collisions at
	$\sqrt{s}=1.96$ TeV, using data corresponding to an integrated
	luminosity of 2 fb$^{-1}$ collected by the CDF II detector at the
	Tevatron. $Z$ bosons are selected in the electron and muon decay
	modes. Jets are considered with transverse energy $E_T>20$ GeV and
	pseudorapidity $\|\eta\|<1.5$. The ratio of the integrated $Z$ + b-jet
	cross section to the inclusive $Z$ production cross section is
	measured differentially in jet $E_T$, jet $\eta$, $Z$-boson transverse
	momentum, number of jets, and number of b-jets. The first two
	measurements have an entry for each b-jet in the event, the last three
	measurements have one entry per event.
	BibKey: Aaltonen:2008mt
	BibTeX: '@Article{Aaltonen:2008mt,
	author = "Aaltonen, T. and others",
	collaboration = "CDF",
	title = "{Measurement of Cross Sections for $b$ Jet Production in
	Events with a $Z$ Boson in $p^-$ anti-p Collisions at
	$\sqrt{s}$ = 1.96-TeV}",
	journal = "Phys. Rev.",
	volume = "D79",
	year = "2009",
	pages = "052008",
	eprint = "0812.4458",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevD.79.052008",
	SLACcitation = "%%CITATION = 0812.4458;%%"
	}'
	diff --git a/data/anainfo/CDF_2009_S8383952.info b/data/anainfo/CDF_2009_I856131.info
	rename from data/anainfo/CDF_2009_S8383952.info
	rename to data/anainfo/CDF_2009_I856131.info
	--- a/data/anainfo/CDF_2009_S8383952.info
	+++ b/data/anainfo/CDF_2009_I856131.info
	@@ -1,37 +1,37 @@
	-Name: CDF_2009_S8383952
	+Name: CDF_2009_I856131
	Year: 2009
	Summary: Z rapidity measurement
	Experiment: CDF
	Collider: Tevatron Run 2
	-SpiresID: 8383952
	+InspireID: 856131
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:0908.3914 [hep-ex]
	RunInfo:
	$p \bar{p} \to e^+ e^-$ + jets at 1960 GeV. Needs mass cut on lepton pair to
	avoid photon singularity, looser than $66 < m_{ee} < 116$ GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	CDF measurement of the total cross section and rapidity distribution,
	$\mathrm{d}\sigma/\mathrm{d}y$, for $q\bar{q}\to \gamma^{*}/Z\to e^{+}e^{-}$ events in the $Z$
	boson mass region ($66<M_{ee}<116$ GeV/c$^2$) produced in $p\bar{p}$
	collisions at $\sqrt{s}=1.96$ TeV with 2.1 fb$^{-1}$ of integrated luminosity.
	NeedCrossSection: yes
	BibKey: Aaltonen:2009pc
	BibTeX: '@Article{Aaltonen:2009pc,
	author = "Aaltonen, T. and others",
	collaboration = "CDF",
	title = "{Measurement of $d\sigma/dy$ of Drell-Yan $e^+e^-$ pairs in
	the $Z$ Mass Region from $p\bar{p}$ Collisions at
	$\sqrt{s}=1.96$ TeV}",
	year = "2009",
	eprint = "0908.3914",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 0908.3914;%%"
	}'
	diff --git a/data/anainfo/CDF_2009_S8233977.info b/data/anainfo/CDF_2009_S8233977.info
	--- a/data/anainfo/CDF_2009_S8233977.info
	+++ b/data/anainfo/CDF_2009_S8233977.info
	@@ -1,43 +1,44 @@
	Name: CDF_2009_S8233977
	Year: 2009
	Summary: CDF Run 2 min bias cross-section analysis
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 8233977
	+InspireID: 817466
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	- Niccolo' Moggi <niccolo.moggi@bo.infn.it>
	References:
	- Phys.Rev.D79:112005,2009
	- doi:10.1103/PhysRevD.79.112005
	- arXiv:0904.1098 [hep-ex]
	RunInfo:
	$p\bar{p}$ QCD interactions at 1960~GeV. Particles with $c \tau > 10$ mm
	should be set stable.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Niccolo Moggi's min bias analysis. Minimum bias events are used to
	measure the average track pT vs. charged multiplicity, a track pT
	distribution and an inclusive $\sum E_T$ distribution.
	NeedCrossSection: yes
	BibKey: Aaltonen:2009ne
	BibTeX: '@Article{Aaltonen:2009ne,
	author = "Aaltonen, T. and others",
	collaboration = "CDF",
	title = "{Measurement of Particle Production and Inclusive
	Differential Cross Sections in $p\bar{p}$ Collisions at
	$\sqrt{s}=1.96$ TeV}",
	journal = "Phys. Rev.",
	volume = "D79",
	year = "2009",
	pages = "112005",
	eprint = "0904.1098",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevD.79.112005",
	SLACcitation = "%%CITATION = 0904.1098;%%"
	}'
	diff --git a/data/anainfo/CDF_2009_S8436959.info b/data/anainfo/CDF_2009_S8436959.info
	--- a/data/anainfo/CDF_2009_S8436959.info
	+++ b/data/anainfo/CDF_2009_S8436959.info
	@@ -1,42 +1,43 @@
	Name: CDF_2009_S8436959
	Year: 2009
	Summary: Measurement of the inclusive isolated prompt photon cross-section
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 8436959
	+InspireID: 834437
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:0910.3623 [hep-ex]
	RunInfo:
	$\gamma$ + jet processes in ppbar collisions at $\sqrt{s} = 1960$~GeV.
	Minimum pT cut on the photon in the analysis is 30~GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [30]
	Description:
	A measurement of the cross section for the inclusive production of isolated
	photons. The measurement covers the pseudorapidity region $\|\eta^\gamma\|<1.0$
	and the transverse energy range $E_T^\gamma>30$~GeV and is based on 2.5~fb$^{-1}$
	of integrated luminosity. The cross section is measured differential in
	$E_\perp(\gamma)$.
	NeedCrossSection: yes
	BibKey: Aaltonen:2009ty
	BibTeX: '@Article{Aaltonen:2009ty,
	author = "Aaltonen, T. and others",
	collaboration = "CDF",
	title = "{Measurement of the Inclusive Isolated Prompt Photon Cross
	Section in ppbar Collisions at sqrt{s} = 1.96 TeV using the
	CDF Detector}",
	journal = "Phys. Rev.",
	volume = "D80",
	year = "2009",
	pages = "111106",
	eprint = "0910.3623",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevD.80.111106",
	SLACcitation = "%%CITATION = 0910.3623;%%"
	}'
	diff --git a/data/anainfo/CDF_2010_S8591881_DY.info b/data/anainfo/CDF_2010_S8591881_DY.info
	--- a/data/anainfo/CDF_2010_S8591881_DY.info
	+++ b/data/anainfo/CDF_2010_S8591881_DY.info
	@@ -1,30 +1,31 @@
	Name: CDF_2010_S8591881_DY
	Year: 2010
	Summary: CDF Run 2 underlying event in Drell-Yan
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 8591881
	+InspireID: 849042
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Phys.Rev.D82:034001,2010
	RunInfo:
	"ppbar collisions at 1960 GeV.
	* Drell-Yan events with $Z/\\gamma* -> e e$ and $Z/\\gamma* -> \\mu\\mu$.
	* A mass cut $m_{ll} > 70~\\text{GeV}$ can be applied on generator level.
	* Particles with $c \\tau > 10~\\text{mm}$ should be set stable."
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Deepak Kar and Rick Field's measurement of the underlying event in
	Drell-Yan events. $Z -> ee$ and $Z -> \mu\mu$ events are selected using
	a $Z$ mass window cut between 70 and 110~GeV. ``Toward'', ``away'' and
	``transverse'' regions are defined in the same way as in the original
	(2001) CDF underlying event analysis. The reconstructed $Z$ defines the
	$\phi$ direction of the toward region. The leptons are ignored after
	the $Z$ has been reconstructed. Thus the region most sensitive to the
	underlying event is the toward region (the recoil jet is boosted into
	the away region).
	diff --git a/data/anainfo/CDF_2010_S8591881_QCD.info b/data/anainfo/CDF_2010_S8591881_QCD.info
	--- a/data/anainfo/CDF_2010_S8591881_QCD.info
	+++ b/data/anainfo/CDF_2010_S8591881_QCD.info
	@@ -1,30 +1,31 @@
	Name: CDF_2010_S8591881_QCD
	Year: 2010
	Summary: CDF Run 2 underlying event in leading jet events
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 8591881
	+InspireID: 849042
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Phys.Rev.D82:034001,2010
	RunInfo:
	$p\bar{p}$ QCD interactions at 1960~GeV. Particles with
	$c \tau > {}$10 mm should be set stable. Several $p_\perp^\text{min}$
	cutoffs are probably required to fill the profile histograms.
	$p_\perp^\text{min} = {}$ 0 (min bias), 10, 20, 50, 100, 150 GeV.
	The corresponding merging points are at $p_T = $ 0, 30, 50, 80,
	130, 180 GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0, 10, 20, 50, 100, 150]
	Description:
	Rick Field's measurement of the underlying event in leading jet
	events. If the leading jet of the event is within $\|\eta\| < 2$, the
	event is accepted and ``toward'', ``away'' and ``transverse'' regions
	are defined in the same way as in the original (2001) CDF underlying
	event analysis. The leading jet defines the $\phi$ direction of the
	toward region. The transverse regions are most sensitive to the
	underlying event.
	diff --git a/data/anainfo/CDF_2015_1388868.info b/data/anainfo/CDF_2015_1388868.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/CDF_2015_1388868.info
	@@ -0,0 +1,48 @@
	+Name: CDF_2015_I1388868
	+Year: 2015
	+Summary: Studies of the underlying event at 300, 900 and 1960 GeV with leading charged particles
	+Experiment: CDF
	+Collider: Tevatron
	+InspireID:
	+Status: VALIDATED
	+Authors:
	+ - Oreste Tumbarell Aranda
	+ - Hannes Jung (hannes.jung@cern.ch)
	+ - Paolo Gunnellini (paolo.gunnellini@desy.de)
	+ - Andy Buckley (cleaining/integration)
	+References:
	+ - 'Phys. Rev. D 92, 092009 (2015)'
	+ - 'arXiv:1508.05340'
	+RunInfo:
	+ 'Minimum bias proton-antiproton collision events at 300, 900 and 1960 GeV.
	+ Set particles with c*tau > 10 mm stable.'
	+NumEvents: 1000000
	+Beams: [p+, p-]
	+Energies: [300], [900], [1960]
	+Description:
	+ 'We study charged particle production in proton--antiproton collisions at 300 GeV,
	+ 900 GeV, and 1.96 TeV. We use the direction of the charged particle with the largest
	+ transverse momentum in each event to define three regions of $\eta$--$\phi$ space;
	+ toward, away, and transverse. The average number and the average scalar pT sum of
	+ charged particles in the transverse region are sensitive to the modeling of the
	+ underlying event. The transverse region is divided into a MAX and MIN transverse
	+ region, which helps separate the hard component (initial and final-state radiation)
	+ from the beam-beam remnant and multiple parton interaction components of the scattering.'
	+BibKey: :2015aoa
	+BibTeX: @article{Aaltonen:2015aoa,
	+ author = "Aaltonen, Timo Antero and others",
	+ title = "{Study of the energy dependence of the underlying event
	+ in proton-antiproton collisions}",
	+ collaboration = "CDF",
	+ journal = "Phys. Rev.",
	+ volume = "D92",
	+ year = "2015",
	+ number = "9",
	+ pages = "092009",
	+ doi = "10.1103/PhysRevD.92.092009",
	+ eprint = "1508.05340",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "FERMILAB-PUB-15-361-E",
	+ SLACcitation = "%%CITATION = ARXIV:1508.05340;%%"
	+}
	diff --git a/data/anainfo/CLEO_2004_S5809304.info b/data/anainfo/CLEO_2004_S5809304.info
	--- a/data/anainfo/CLEO_2004_S5809304.info
	+++ b/data/anainfo/CLEO_2004_S5809304.info
	@@ -1,36 +1,37 @@
	Name: CLEO_2004_S5809304
	Summary: Charm hadrons from fragmentation near the $\Upsilon(4S)$
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Rev.D70:112001,2004.
	- arXiv:hep-ex/0402040
	RunInfo:
	$e^+ e^-$ analysis near the $\Upsilon(4S)$ resonance
	NumEvents: 1000000
	SpiresID: 6265367
	+InspireID: 645209
	Beams: [e+, e-]
	Energies: [10.52]
	PtCuts: [0]
	Description:
	Analysis of charm quark fragmentation at 10.5 GeV, based on a data
	sample of 103 fb collected by the CLEO experiment.
	Fragmentation into charm is studied for the charmed hadron ground states,
	namely $D^0$, $D^+$, as well as the excited states
	$D^{0}$ and $D^{+}$. This analysis can be used to constrain charm fragmentation
	in Monte Carlo generators.
	BibKey: Artuso:2004pj
	BibTeX: '@Article{Artuso:2004pj,
	author = "Artuso, M. and others",
	collaboration = "CLEO",
	title = "{Charm meson spectra in $e+ e-$ annihilation at 10.5 GeV}",
	journal = "Phys. Rev.",
	volume = "D70",
	year = "2004",
	pages = "112001",
	eprint = "hep-ex/0402040",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.70.112001",
	SLACcitation = "%%CITATION = HEP-EX/0402040;%%"
	}'
	diff --git a/data/anainfo/CMS_QCD_10_024.info b/data/anainfo/CMS_2010_PAS_QCD_10_024.info
	rename from data/anainfo/CMS_QCD_10_024.info
	rename to data/anainfo/CMS_2010_PAS_QCD_10_024.info
	diff --git a/data/anainfo/CMS_2010_S8547297.info b/data/anainfo/CMS_2010_S8547297.info
	--- a/data/anainfo/CMS_2010_S8547297.info
	+++ b/data/anainfo/CMS_2010_S8547297.info
	@@ -1,50 +1,51 @@
	Name: CMS_2010_S8547297
	Year: 2010
	Summary: Charged particle transverse momentum and pseudorapidity spectra from proton-proton collisions at 900 and 2360 GeV.
	Experiment: CMS
	Collider: LHC
	SpiresID: 8547297
	+InspireID: 845323
	Status: VALIDATED
	Authors:
	- A. Knutsson
	References:
	- JHEP 02 (2010) 041
	- doi:10.1007/JHEP02(2010)041
	- arXiv:1002.0621 [hep-ex]
	RunInfo:
	Non-single-diffractive (NSD) events only. Should include double-diffractive (DD)
	events and non-diffractive (ND) events but NOT single-diffractive (SD) events. Examples,
	in Pythia6 the SD processes to be turned off are 92 and 93, and in Pythia8 the SD processes
	are 103 and 104 (also called SoftQCD:singleDiffractive).
	NumEvents: 200000
	Beams: [p+, p+]
	Energies: [900, 2360]
	PtCuts:
	Description:
	Charged particle spectra are measured in proton-proton collisions at center-of-mass
	energies 900 and 2360 GeV. The spectra are normalized to all non-single-diffractive
	(NSD) events using corrections for trigger and selection efficiency, acceptance, and
	branching ratios. There are transverse-momentum (pT) spectra from 0.1 to 2 GeV in bins
	of pseudorapidity (eta) and pT spectra from 0.1 to 4 GeV for \|eta\|<2.4. The eta spectra
	come from the average of three methods and cover \|eta\|<2.5 and are corrected to include
	all pT.

	The data were corrected according to the SD/DD/ND content of the CMS
	trigger, as predicted by PYTHIA6. The uncertainties connected with
	correct or incorrect modelling of diffraction were included in the
	systematic errors.
	BibKey: Khachatryan:2010xs
	BibTeX: '@Article{Khachatryan:2010xs,
	author ="Khachatryan, Vardan and others",
	collaboration ="CMS",
	title ="{Transverse momentum and pseudorapidity distributions of
	charged hadrons in $pp$ collisions at $\sqrt{s} = 0.9$ and 2.36 TeV}",
	journal ="JHEP",
	volume ="02",
	year ="2010",
	pages ="041",
	eprint ="1002.0621",
	archivePrefix ="arXiv",
	primaryClass ="hep-ex",
	doi ="10.1007/JHEP02(2010)041",
	SLACcitation ="%%CITATION = 1002.0621;%%"}'
	diff --git a/data/anainfo/CMS_2010_S8656010.info b/data/anainfo/CMS_2010_S8656010.info
	--- a/data/anainfo/CMS_2010_S8656010.info
	+++ b/data/anainfo/CMS_2010_S8656010.info
	@@ -1,48 +1,49 @@
	Name: CMS_2010_S8656010
	Year: 2010
	Summary: Charged particle transverse momentum and pseudorapidity spectra from proton-proton collisions at 7000 GeV.
	Experiment: CMS
	Collider: LHC
	SpiresID: 8656010
	+InspireID: 855299
	Status: VALIDATED
	Authors:
	- A. Knutsson
	References:
	- Phys.Rev.Lett.105:022002,2010
	- doi:10.1103/PhysRevLett.105.022002
	- arXiv:1005.3299 [hep-ex]
	RunInfo:
	Non-single-diffractive (NSD) events only. Should include double-diffractive (DD) events
	and non-diffractive (ND) events but NOT single-diffractive (SD) events. For example, in
	Pythia6 the SD processes to be turned off are 92 and 93, and in Pythia8 the SD processes
	are 103 and 104 (also called SoftQCD:singleDiffractive).
	NumEvents: 200000
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	Charged particle spectra are measured in proton-proton collisions at center-of-mass
	energies 7000 GeV. The spectra are normalized to all non-single-diffractive
	(NSD) events using corrections for trigger and selection efficiency, acceptance, and
	branching ratios. There are transverse-momentum ($\pT$) spectra from 0.1 to 2 GeV in bins
	of pseudorapidity ($\eta$) and the $\pT$ spectrum from 0.1 to 6 GeV for $\|\eta\| < 2.4$.
	The $\eta$ spectra come from the average of three methods and cover $\|\eta\| < 2.5$ and
	are corrected to include all $\pT$.

	The data were corrected according to the SD/DD/ND content of the CMS
	trigger, as predicted by PYTHIA6. The uncertainties connected with
	correct or incorrect modelling of diffraction were included in the
	systematic errors.
	BibKey: Khachatryan:2010us
	BibTeX: '@Article{Khachatryan:2010us,
	author = "Khachatryan, Vardan and others",
	collaboration = "CMS",
	title = "{Transverse-momentum and pseudorapidity distributions of charged hadrons in $pp$ collisions at $\sqrt{s} = 7$ TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "105",
	year = "2010",
	pages = "022002",
	eprint = "1005.3299",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevLett.105.022002",
	SLACcitation = "%%CITATION = 1005.3299;%%"}'
	diff --git a/data/anainfo/CMS_2011_S8884919.info b/data/anainfo/CMS_2011_S8884919.info
	--- a/data/anainfo/CMS_2011_S8884919.info
	+++ b/data/anainfo/CMS_2011_S8884919.info
	@@ -1,48 +1,49 @@
	Name: CMS_2011_S8884919
	Year: 2011
	Summary: Measurement of the NSD charged particle multiplicity at $\sqrt{s} = 0.9$, 2.36, and 7 TeV with the CMS detector.
	Experiment: CMS
	Collider: LHC
	SpiresID: 8884919
	+InspireID: 879315
	Status: VALIDATED
	Authors:
	- Romain Rougny <romain.rougny@cern.ch>
	References:
	- J. High Energy Phys. 01 (2011) 079
	- doi:10.1007/JHEP01(2011)079
	- arXiv:1011.5531 [hep-ex]
	RunInfo:
	Non-single-diffractive (NSD) events only. Should include double-diffractive (DD) events
	and non-diffractive (ND) events but NOT single-diffractive (SD) events. For example, in Pythia6 the
	SD processes to be turned off are 92 and 93 and in Pythia8 the SD processes are 103 and
	104 (also called SoftQCD:singleDiffractive).
	NumEvents: 100000
	Beams: [p+, p+]
	Energies: [900, 2360, 7000]
	PtCuts:
	Description:
	Measurements of primary charged hadron multiplicity distributions are presented
	for non-single-diffractive events in proton-proton collisions at centre-of-mass energies
	of $\sqrt{s} = 0.9$, 2.36, and 7 TeV, in five pseudorapidity ranges from $\|\eta\| < 0.5$ to $\|\eta\| < 2.4$.
	The data were collected with the minimum-bias trigger of the CMS experiment during the LHC commissioning runs
	in 2009 and the 7 TeV run in 2010. The average transverse momentum as a function of the multiplicity is also presented.
	The measurement of higher-order moments of the multiplicity distribution confirms the violation of
	Koba-Nielsen-Olesen scaling that has been observed at lower energies.

	BibKey: Khachatryan:2010nk
	BibTeX: '@Article{Khachatryan:2010nk,
	author = "Khachatryan, Vardan and others",
	collaboration = "CMS",
	title = "{Charged particle multiplicities in $pp$ interactions at $\sqrt{s} = 0.9$, 2.36, and 7 TeV}",
	journal = "JHEP",
	volume = "01",
	year = "2011",
	pages = "079",
	eprint = "1011.5531",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1007/JHEP01(2011)079",
	SLACcitation = "%%CITATION = 1011.5531;%%"
	}'
	ToDo:

	diff --git a/data/anainfo/CMS_2011_S8941262.info b/data/anainfo/CMS_2011_S8941262.info
	--- a/data/anainfo/CMS_2011_S8941262.info
	+++ b/data/anainfo/CMS_2011_S8941262.info
	@@ -1,45 +1,46 @@
	Name: CMS_2011_S8941262
	Year: 2011
	Summary: Production cross-sections of muons from $b$ hadron decays in $pp$ collisions
	Experiment: CMS
	Collider: LHC
	SpiresID: 8941262
	+InspireID: 884811
	Status: VALIDATED
	Authors:
	- Wolfram Erdmann <wolfram.erdmann@psi.ch>
	References:
	- JHEP 1103,090
	- doi:10.1007/JHEP03(2011)090
	- arXiv:hep-ex/1101.3512
	RunInfo:
	Inclusive QCD at 7 TeV, with no pT cuts.
	NumEvents: 10000000
	Beams: [p+, p+]
	Energies: [7000]
	NeedsCrossSection: true
	Description:
	'A measurement of the $b$-hadron production cross-section in proton-proton
	collisions at $\sqrt{s} = 7$~TeV. The dataset, corresponding to 85
	inverse nanobarns, was recorded with the CMS experiment at the LHC using a
	low-threshold single-muon trigger. Events are selected by the presence of a
	muon with transverse momentum greater than 6 GeV with respect to the beam
	direction and pseudorapidity less than 2.1. The transverse momentum of the
	muon with respect to the closest jet discriminates events containing $b$ hadrons
	from background. The inclusive $b$-hadron production cross section is presented
	as a function of muon transverse momentum and pseudorapidity.'
	BibKey: Khachatryan:2011hf
	BibTeX: '@Article{Khachatryan:2011hf,
	author = "Khachatryan, Vardan and others",
	collaboration = "CMS",
	title = "{Inclusive $b$-hadron production cross-section with muons in
	$pp$ collisions at $\sqrt{s} = 7$~TeV}",
	journal = "JHEP",
	volume = "03",
	year = "2011",
	pages = "090",
	eprint = "1101.3512",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1007/JHEP03(2011)090",
	SLACcitation = "%%CITATION = 1101.3512;%%"
	}'
	diff --git a/data/anainfo/CMS_2011_S8950903.info b/data/anainfo/CMS_2011_S8950903.info
	--- a/data/anainfo/CMS_2011_S8950903.info
	+++ b/data/anainfo/CMS_2011_S8950903.info
	@@ -1,37 +1,38 @@
	Name: CMS_2011_S8950903
	Year: 2011
	Summary: Dijet azimuthal decorrelations in $pp$ collisions at $\sqrt{s} = 7$ TeV
	Experiment: CMS
	Collider: LHC
	SpiresID: 8950903
	+InspireID: 885663
	Status: VALIDATED
	Authors:
	- Tomo Umer <tomo.umer@cern.ch>
	References:
	- Phys. Rev. Lett. 106 (2011) 122003
	- arXiv:1101.5029 [hep-ex]
	RunInfo:
	Inclusive QCD at $\sqrt{s} = 7\;\TeV$, $\hat{\pT} (or equivalent) greater than 20 GeV
	NumEvents: 100k
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [20]
	Description:
	Measurements of dijet azimuthal decorrelations in $pp$ collisions at $\sqrt{s} = 7$ TeV using the CMS
	detector at the CERN LHC are presented. The analysis is based on an inclusive dijet event sample
	corresponding to an integrated luminosity of 2.9/pb.
	Jets are anti-$k_t$ with $R = 0.5$, $p_\perp > 80 (30)$ GeV and $\|\eta\| < 1.1$.
	BibKey: Khachatryan:2011zj
	BibTeX: '@article{Khachatryan:2011zj,
	author = "Khachatryan, Vardan and others",
	title = "{Dijet azimuthal decorrelations in $pp$ collisions at $\sqrt{s} = 7$~TeV}",
	collaboration = "CMS Collaboration",
	journal = "Phys.Rev.Lett.",
	volume = "106",
	pages = "122003",
	doi = "10.1103/PhysRevLett.106.122003",
	year = "2011",
	eprint = "1101.5029",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",}'

	diff --git a/data/anainfo/CMS_2011_S8957746.info b/data/anainfo/CMS_2011_S8957746.info
	--- a/data/anainfo/CMS_2011_S8957746.info
	+++ b/data/anainfo/CMS_2011_S8957746.info
	@@ -1,39 +1,40 @@
	Name: CMS_2011_S8957746
	Year: 2011
	Summary: Event shapes
	Experiment: CMS
	Collider: LHC
	SpiresID: 8957746
	+InspireID: 886332
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Phys.Lett.B699:48-67,2011
	- arXiv:1102.0068
	RunInfo:
	pp QCD interactions at 7000 GeV. Particles with c*tau>10mm are stable.
	NumEvents: 1000000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [30.0]
	Description:
	Central transverse Thrust and Minor have been measured in proton-proton
	collisions at $\sqrt{s} = 7$ TeV, with a data sample collected with the CMS
	detector at the LHC. The sample corresponds to an integrated luminosity of
	3.2 inverse picobarns.
	Input for the variables are anti-$k_t$ jets with $R = 0.5$.
	BibKey: Khachatryan:2011dx
	BibTeX: '@Article{Khachatryan:2011dx,
	author = "Khachatryan, Vardan and others",
	collaboration = "CMS",
	title = "{First measurement of hadronic event shapes in $pp$ collisions at $\sqrt{s} = 7$ TeV}",
	journal = "Phys. Lett.",
	volume = "B699",
	year = "2011",
	pages = "48-67",
	eprint = "1102.0068",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1016/j.physletb.2011.03.060",
	SLACcitation = "%%CITATION = 1102.0068;%%"
	}'
	diff --git a/data/anainfo/CMS_2011_S8968497.info b/data/anainfo/CMS_2011_S8968497.info
	--- a/data/anainfo/CMS_2011_S8968497.info
	+++ b/data/anainfo/CMS_2011_S8968497.info
	@@ -1,38 +1,39 @@
	Name: CMS_2011_S8968497
	Year: 2011
	Summary: Measurement of dijet angular distributions and search for quark compositeness in $pp$ collisions at $\sqrt{s} = 7$ TeV
	Experiment: CMS
	Collider: LHC
	SpiresID: 8968497
	+InspireID: 889175
	Status: VALIDATED
	Authors:
	- A. Hinzmann
	References:
	- Phys.Rev.Lett.106:201804,2011
	- doi:10.1103/PhysRevLett.106.201804
	- arXiv:hep-ex/1102.2020
	Beams: [p+, p+]
	Energies: [7000]
	#RunInfo:
	Description:
	Measurement of dijet angular distributions in proton-proton collisions at a
	center-of-mass energy of 7 TeV. The data sample, collected with single jet
	triggers, has a total integrated luminosity of 36 pb$^{-1}$, with jets being
	reconstructed using the anti-$k_t$ clustering algorithm with $R=0.5$. The data
	are presented for the variable $\chi$ defined as $\chi = \exp(\|y_1 - y_2\|)$
	where $y_1$ and $y_2$ are the rapidities of the two leading (highest $\pT$) jets.'
	BibKey: Khachatryan:2011as
	BibTeX: '@Article{Khachatryan:2011as,
	author = "Khachatryan, Vardan and others",
	collaboration = "CMS",
	title = "{Measurement of Dijet Angular Distributions and Search for Quark Compositeness in pp Collisions at 7 TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "106",
	year = "2011",
	pages = "201804",
	eprint = "1102.2020",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevLett.106.201804",
	SLACcitation = "%%CITATION = 1102.2020;%%"
	}'
	diff --git a/data/anainfo/CMS_2011_S8973270.info b/data/anainfo/CMS_2011_S8973270.info
	--- a/data/anainfo/CMS_2011_S8973270.info
	+++ b/data/anainfo/CMS_2011_S8973270.info
	@@ -1,42 +1,43 @@
	Name: CMS_2011_S8973270
	Year: 2011
	Summary: '$B/\bar{B}$ angular correlations based on secondary vertex reconstruction in $pp$ collisions'
	Experiment: CMS
	Collider: LHC
	SpiresID: 8973270
	+InspireID: 889807
	Status: VALIDATED
	Authors:
	- Lukas Wehrli <wehrlilu@cern.ch>
	References:
	- JHEP 1103 136
	- doi:10.1007/JHEP03(2011)136
	- arXiv:1102.3194
	RunInfo:
	Inclusive QCD at 7 TeV. A $\hat{\pT}$ cut (or similar) is recommended since
	a leading jet $\pT > 56$ GeV is required.
	NumEvents: 100000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [56, 84, 120]
	NeedsCrossSection: true
	Description: 'The differential $B\bar{B}$ cross-section is measured as a function of the opening angle $\Delta{R}$ and $\Delta\phi$
	using data collected with the CMS detector during 2010 and corresponding to an integrated luminosity of 3.1 pb$^{-1}$.
	The measurement is performed for three different event energy scales, characterized by the transverse momentum of the
	leading jet in the event (above 56 GeV, above 84 GeV and above 120 GeV). Simulated events are normalised in the region
	$\Delta{R} > 2.4$ and $\Delta\phi > 3/4\pi$ respectively.'
	BibKey: Khachatryan:2011wq
	BibTeX: '@Article{Khachatryan:2011wq,
	author = "Khachatryan, Vardan and others",
	collaboration = "CMS",
	title = "{Measurement of $B \bar{B}$ angular correlations based on
	secondary vertex reconstruction at $\sqrt{s} = 7$~TeV}",
	journal = "JHEP",
	volume = "03",
	year = "2011",
	pages = "136",
	eprint = "1102.3194",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1007/JHEP03(2011)136",
	SLACcitation = "%%CITATION = 1102.3194;%%"
	}'
	diff --git a/data/anainfo/CMS_2011_S8978280.info b/data/anainfo/CMS_2011_S8978280.info
	--- a/data/anainfo/CMS_2011_S8978280.info
	+++ b/data/anainfo/CMS_2011_S8978280.info
	@@ -1,53 +1,54 @@
	Name: CMS_2011_S8978280
	Year: 2011
	Summary: $K_s$, $\Lambda$, and Cascade$-$ transverse momentum and rapidity spectra at 900 and 7000 GeV.
	Experiment: CMS
	Collider: LHC
	SpiresID: 8978280
	+InspireID: 890166
	Status: VALIDATED
	Authors:
	- Kevin Stenson <kevin.stenson@colorado.edu>
	References:
	- JHEP 05 (2011) 064
	- doi:10.1007/JHEP05(2011)064
	- arXiv:1102.4282 [hep-ex]
	RunInfo:
	Non-single-diffractive (NSD) events only. Should include double-diffractive (DD) events
	and non-diffractive (ND) events but NOT single-diffractive (SD) events. For example, in Pythia6 the
	SD processes to be turned off are 92 and 93, and in Pythia8 the SD processes are 103 and
	104 (also called SoftQCD:singleDiffractive).
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [900, 7000]
	PtCuts:
	Description:
	The spectra of $K_S$, $\Lambda$, and Cascade- particles were measured versus
	transverse-momentum ($\pT$) and rapidity ($y$) in proton-proton collisions at center-of-mass
	energies 900 and 7000 GeV. The production is normalized to all non-single-diffractive
	(NSD) events using corrections for trigger and selection efficiency, acceptance, and
	branching ratios. The results cover a rapidity range of $\|y\| < 2$ and a $\pT$ range from 0 to
	10 GeV ($K_S$ and $\Lambda$) and 0 to 6 GeV (Cascade-). Antiparticles are included in all
	measurements so only the sums of $\Lambda$ and $\bar{\Lambda}$, and Cascade$-$ and anti-Cascade$-$
	are given. The rapidity distributions are shown versus $\|y\|$ but normalized to a unit of $y$.
	Ratios of $\Lambda$/$K_S$ and Cascade$-$/$\Lambda$ production versus $\pT$ and $\|y\|$ are also given,
	with somewhat smaller systematic uncertainties than obtained from taking the ratio of
	the individual distributions.'

	The data were corrected according to the SD/DD/ND content of the CMS
	trigger, as predicted by PYTHIA6. The uncertainties connected with
	correct or uncorrect modelling of diffraction were included in the
	systematic errors.
	BibKey: Khachatryan:2011tm
	BibTeX: '@Article{Khachatryan:2011tm,
	author = "Khachatryan, Vardan and others",
	collaboration = "CMS",
	title = "{Strange particle production in $pp$ collisions at $\sqrt{s} = 0.9$ and 7 TeV}",
	journal = "JHEP",
	volume = "05",
	year = "2011",
	pages = "064",
	eprint = "1102.4282",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1007/JHEP05(2011)064",
	SLACcitation = "%%CITATION = 1102.4282;%%"}'
	diff --git a/data/anainfo/CMS_2011_S9086218.info b/data/anainfo/CMS_2011_S9086218.info
	--- a/data/anainfo/CMS_2011_S9086218.info
	+++ b/data/anainfo/CMS_2011_S9086218.info
	@@ -1,40 +1,41 @@
	Name: CMS_2011_S9086218
	Year: 2011
	Summary: Measurement of the inclusive jet cross-section in $pp$ collisions at $\sqrt{s} = 7$ TeV
	Experiment: CMS
	Collider: LHC
	SpiresID: 9086218
	+InspireID: 902309
	Status: VALIDATED
	Authors:
	- Rasmus Sloth Hansen<rsh07@phys.au.dk>
	References:
	- http://cdsweb.cern.ch/record/1355680
	RunInfo:
	Inclusive QCD at 7TeV comEnergy, ptHat (or equivalent) greater than 10 GeV
	NumEvents: 100k
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts:
	jet PT higher than 18 GeV
	Description:
	The inclusive jet cross section is measured in pp collisions with a center-of-mass
	energy of 7 TeV at the LHC using the CMS experiment. The data sample corresponds to an
	integrated luminosity of 34 inverse picobarns. The measurement is made for jet transverse
	momenta in the range 18-1100 GeV and for absolute values of rapidity less than 3.
	Jets are anti-kt with $R=0.5$, $p_\perp>18$ GeV and $\|y\|<3.0$.
	NeedCrossSection: yes
	BibKey: :2011me
	BibTeX: '@article{:2011me,
	author = "Chatrchyan, Serguei and others",
	title = "{Measurement of the inclusive jet cross section in $pp$ collisions at $\sqrt{s} = 7$ TeV}",
	collaboration = "CMS Collaboration",
	journal = "Phys. Rev. Lett.",
	volume = "107",
	pages = "132001",
	doi = "10.1103/PhysRevLett.107.132001",
	year = "2011",
	note = "Long author list - awaiting processing",
	eprint = "1106.0208",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	}'
	diff --git a/data/anainfo/CMS_2011_S9088458.info b/data/anainfo/CMS_2011_S9088458.info
	--- a/data/anainfo/CMS_2011_S9088458.info
	+++ b/data/anainfo/CMS_2011_S9088458.info
	@@ -1,39 +1,40 @@
	Name: CMS_2011_S9088458
	Year: 2011
	Summary: Measurement of ratio of the 3-jet over 2-jet cross section in $pp$ collisions at $\sqrt{s} = 7$ TeV
	Experiment: CMS
	Collider: LHC
	SpiresID: 9088458
	+InspireID: 912560
	Status: VALIDATED
	Authors:
	- Tomo Umer <tomo.umer@cern.ch>
	References:
	- Phys. Lett. B 702 (2011) 336
	RunInfo:
	Inclusive QCD at 7 TeV. $\hat{\pT}$ (or equivalent) greater than 30 GeV
	NumEvents: 100k
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts:
	jet PT higher than 50 GeV
	Description:
	A measurement of the ratio of the inclusive 3-jet to 2-jet cross sections as a function of the total jet
	transverse momentum, $H_T$, in the range $0.2 < H_T < 2.5$ TeV is presented. The data have been collected
	at a proton--proton centre-of-mass energy of 7\;TeV with the CMS detector at the LHC, and correspond
	to an integrated luminosity of 36/pb.
	Jets are anti-$k_t$ with $R = 0.5$, $p_\perp > 50\;\GeV$ and $\|\eta\| < 2.5$.
	BibKey: Chatrchyan:2011wn
	BibTeX: '@article{Chatrchyan:2011wn,
	author = "Chatrchyan, Serguei and others",
	title = "{Measurement of the ratio of the 3-jet to 2-jet cross sections in $pp$ collisions at $\sqrt{s} = 7$ TeV}",
	collaboration = "CMS Collaboration",
	journal = "Phys.Lett.",
	volume = "B702",
	pages = "336-354",
	year = "2011",
	eprint = "1106.0647",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",}'



	diff --git a/data/anainfo/CMS_2011_S9120041.info b/data/anainfo/CMS_2011_S9120041.info
	--- a/data/anainfo/CMS_2011_S9120041.info
	+++ b/data/anainfo/CMS_2011_S9120041.info
	@@ -1,40 +1,41 @@
	Name: CMS_2011_S9120041
	Year: 2011
	Summary: Traditional leading jet UE measurement at $\sqrt{s} = 0.9$ and 7 TeV
	Experiment: CMS
	Collider: LHC
	SpiresID: 9120041
	+InspireID: 916908
	Status: VALIDATED
	Authors:
	- Mohammed Zakaria (mzakaria@ufl.edu)
	References:
	- J. High Energy Phys 09 (2011) 109
	RunInfo:
	Requires inclusive inelastic events (non-diffractive and inelastic
	diffractive). The profile plots require large statistics.
	Beams: [p+, p+]
	Energies: [900, 7000]
	Description:
	A measurement of the underlying activity in scattering processes with a hard
	scale in the several-GeV region is performed in proton-proton collisions at
	Energies of 0.9 and 7\;TeV, using data collected by the CMS experiment at the
	LHC. The production of charged particles with pseudorapidity \|eta\| < 2 and
	transverse momentum $\pT > 0.5$\;GeV/$c$ is studied in the azimuthal region transverse
	to that of the leading set of charged particles forming a track-jet. Various
	comparisons are made between the two different energies and also beteen two
	sets of cuts on \pT for leading track jet \pT-leading $> 3$\;GeV and pT-leading $> 20$\;GeV.
	The activity is studied using 5 types of plots. Two profile plots for the
	multiplicity of charged particles and the scalar sum of \pT. and three distributions
	for the two previous quantities as well as \pT for all the particles in the
	transverse region.
	BibKey: Chatrchyan:2011id
	BibTeX: '@article{Chatrchyan:2011id,
	author = "Chatrchyan, Serguei and others",
	title = "{Measurement of the Underlying Event Activity at the LHC
	with $\sqrt{s} = 7$\;TeV and comparison with $\sqrt{s} = 0.9$\;TeV}",
	collaboration = "CMS Collaboration",
	year = "2011",
	eprint = "1107.0330",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",}'

	diff --git a/data/anainfo/CMS_2011_S9215166.info b/data/anainfo/CMS_2011_S9215166.info
	--- a/data/anainfo/CMS_2011_S9215166.info
	+++ b/data/anainfo/CMS_2011_S9215166.info
	@@ -1,37 +1,38 @@
	Name: CMS_2011_S9215166
	Year: 2011
	Summary: Forward energy flow in MB and dijet events at 0.9 and 7 TeV
	Experiment: CMS
	Collider: LHC
	SpiresID: 9215166
	+InspireID: 930319
	Status: VALIDATED
	Authors:
	- S. Dooling <samantha.dooling@cern.ch>
	- A. Knutsson <albert.knutsson@cern.ch>
	References:
	- JHEP 1111 148
	- doi:10.1007/JHEP11(2011)148
	- arXiv:hep-ex/1110.0211
	RunInfo:
	$pp$ MB and QCD interactions at 0.9 and 7~TeV. No pT-cuts.
	NumEvents: 500000
	Beams: [p+, p+]
	Energies: [900, 7000]
	Description:
	Forward energy flow measured by CMS at $\sqrt{s} = 0.9$ and 7~TeV in MB and dijet events.
	BibKey: Chatrchyan:2011wm
	BibTeX: '@Article{Chatrchyan:2011wm,
	author = "Chatrchyan, Serguei and others",
	collaboration = "CMS",
	title = "{Measurement of energy flow at large pseudorapidities in $pp$
	collisions at $\sqrt{s}$ = 0.9 and 7 TeV}",
	journal = "JHEP",
	volume = "11",
	year = "2011",
	pages = "148",
	eprint = "1110.0211",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1007/JHEP11(2011)148",
	SLACcitation = "%%CITATION = 1110.0211;%%"
	}'
	diff --git a/data/anainfo/CMS_2012_I1090423.info b/data/anainfo/CMS_2012_I1090423.info
	--- a/data/anainfo/CMS_2012_I1090423.info
	+++ b/data/anainfo/CMS_2012_I1090423.info
	@@ -1,38 +1,38 @@
	Name: CMS_2012_I1090423
	Year: 2012
	Summary: Dijet angular distributions in $pp$ collisions at $\sqrt{s} = 7$ TeV
	Experiment: CMS
	Collider: LHC
	-SpiresID: 1090423
	+InspireID: 1090423
	Status: VALIDATED
	Authors:
	- A. Hinzmann
	References:
	- JHEP 05 (2012) 055
	- doi:10.1007/JHEP05(2012)055
	- arXiv:hep-ex/1202.5535
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'Measurement of dijet angular distributions in proton-proton collisions at a
	center-of-mass energy of 7 TeV. The data sample has a total integrated
	luminosity of 2.2 inverse femtobarns, recorded by the CMS experiment at the LHC.
	Normalized dijet angular distributions have been measured for dijet invariant
	masses from 0.4 TeV to above 3 TeV.'
	BibKey: Chatrchyan:2012bf
	BibTeX: '@article{Chatrchyan:2012bf,
	author = "Chatrchyan, Serguei and others",
	title = "{Search for quark compositeness in dijet angular
	distributions from $pp$ collisions at $\sqrt{s}=7$ TeV}",
	collaboration = "CMS Collaboration",
	journal = "JHEP",
	volume = "1205",
	pages = "055",
	doi = "10.1007/JHEP05(2012)055",
	year = "2012",
	eprint = "1202.5535",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-EXO-11-017, CERN-PH-EP-2012-044",
	SLACcitation = "%%CITATION = ARXIV:1202.5535;%%",
	}'
	diff --git a/data/anainfo/CMS_2012_I1184941.info b/data/anainfo/CMS_2012_I1184941.info
	--- a/data/anainfo/CMS_2012_I1184941.info
	+++ b/data/anainfo/CMS_2012_I1184941.info
	@@ -1,40 +1,40 @@
	Name: CMS_2012_I1184941
	Year: 2012
	Summary: Measurement of the differential cross section for inclusive dijet production as a function of $\xi$ in 7 TeV proton-proton collisions.
	Experiment: CMS
	Collider: LHC
	SpireID: 9762035
	InspireID: 1184941
	Status: VALIDATED
	Authors:
	- Sercan Sen <ssen@cern.ch>
	- Alexander Proskuryakov <aproskur@mail.cern.ch>
	References:
	- arXiv:1209.1805 [hep-ex]
	- Submitted to Phys. Rev. D
	RunInfo:
	High statistics is needed to observe events in the lowest (xi) bin.
	Distributions are presented for hard QCD events (i.e. with $\hat{\pT}$ greater than
	15 GeV) and diffractive-enhanced events.
	NumEvents: 100000000
	NeedCrossSection: no
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [15]
	Description:
	Measurement of the differential cross section for inclusive dijet production as a function of $\xi$
	which approximates the fractional momentum loss of the scattered proton in single-diffraction events. The
	data used has a total integrated luminosity of 2.7 nb$^{-1}$ collected during 2010 with low instantaneous luminosity.
	Events are selected with at least two jets in $\|\eta\| < 4.4$ with $\pT > 20$ GeV and all final states particles
	are used for the reconstruction of $\xi$.
	-BibKey: :2012vc
	-BibTeX: '@article{:2012vc,
	+BibKey: Chatrchyan:2012vc
	+BibTeX: '@article{Chatrchyan:2012vc,
	author = "Chatrchyan, Serguei and others",
	title = "{Observation of a diffractive contribution to dijet production in proton-proton collisions at $\sqrt{s} = 7$ TeV}",
	collaboration = "CMS Collaboration",
	year = "2012",
	eprint = "1209.1805",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-FWD-10-004, CERN-PH-EP-2012-248",
	SLACcitation = "%%CITATION = ARXIV:1209.1805;%%",}'
	diff --git a/data/anainfo/CMS_2012_I1298807.info b/data/anainfo/CMS_2012_I1298807.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/CMS_2012_I1298807.info
	@@ -0,0 +1,44 @@
	+Name: CMS_2012_I1298807
	+Year: 2012
	+Summary: Inclusive ZZ production cross section and constraints on anomalous triple gauge couplings at 8 TeV
	+Experiment: CMS
	+Collider: LHC
	+InspireID: 1298807
	+Status: VALIDATED
	+Authors:
	+ - Alexander Savin
	+ - Ian Ross
	+References:
	+ - arXiv:hep-ex/1406.0113
	+NeedCrossSection: no
	+Beams: [p+, p+]
	+Energies: [8000]
	+Description:
	+ 'A measurement of the inclusive ZZ production cross section and constraints on anomalous triple gauge
	+ couplings in proton-proton collisions at $\sqrt{s} = 8 TeV$ are presented. The analysis is based on a
	+ data sample, corresponding to an integrated luminosity of 19.6/fb, collected with the CMS experiment
	+ at the LHC. The measurements are performed in the leptonic decay modes $ZZ \to lll^\prime l^\prime$, where $l = e,\mu$
	+ and $l^\prime = e, \mu, \tau$. The measured total cross section $ \sigma (pp \to ZZ) = 7.7 \pm 0.5 (stat)
	+ + 0.5 -0.4 (syst) \pm 0.4 (theo) \pm 0.2 (lumi) pb$, for both Z bosons produced in the mass range
	+ $60 < m_Z < 120 \GeV$, is consistent with standard model predictions. Differential cross sections, in
	+ phase space $p_T(\mu) > 5 \GeV$, $p_T(e) > 7 \GeV$, $\|\eta(\mu)\|<2.4$ , $\|\eta(e)\|<2.5$ and the
	+ 60--120 GeV mass requirement, are measured and well described by the theoretical predictions. The
	+ invariant mass distribution of the four-lepton system is used to set limits on anomalous $ZZZ$ and
	+ $ZZ\gamma$ couplings at the $95\%$ confidence level, $-0.004 < f4Z < 0.004$, $-0.004 < f5Z < 0.004$,
	+ $-0.005 < f4\gamma < 0.005$, and $â0.005 < f5\gamma < 0.005.$'
	+BibKey: Chatrchyan:2011wt
	+BibTeX: '@article{Chatrchyan:2011wt,
	+ author = "Chatrchyan, Serguei and others",
	+ title = "{Measurement of the $pp$ to $ZZ$ production cross section and constraints on anomalous triple gauge couplings in four-lepton final states at $\sqrt{s} = 8$~TeV}",
	+ collaboration = "CMS Collaboration",
	+ journal = "Phys. Lett.",
	+ volume = "B740",
	+ pages = "250",
	+ doi = "10.1016/j.physletb.2014.11.059",
	+ year = "2015",
	+ eprint = "1406.0113",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2014-080",
	+ SLACcitation = "%%CITATION = ARXIV:1406.0113;%%",
	+}'
	diff --git a/data/anainfo/CMS_2012_I941555.info b/data/anainfo/CMS_2012_I941555.info
	--- a/data/anainfo/CMS_2012_I941555.info
	+++ b/data/anainfo/CMS_2012_I941555.info
	@@ -1,50 +1,50 @@
	Name: CMS_2012_I941555
	Year: 2010
	Summary: Measurement of differential $Z/\gamma^*$ $p_T$ and y
	Experiment: CMS
	Collider: LHC
	-SpiresID: 941555
	+InspireID: 941555
	Status: VALIDATED
	Authors:
	- Luca Perrozzi <luca.perrozzi@cern.ch>
	- Justin Hugon <justin.hugon@cern.ch>
	References:
	- Phys.Rev. D85 (2012) 032002
	- arXiv:1110.4973
	- CMS-EWK-10-010
	- CERN-PH-EP-2011-169
	RunInfo:
	$p p \to \mu^+ \mu^-$+X 7 TeV.
	Needs mass cut on lepton pair to avoid photon singularity,
	restrict $Z/\gamma^*$ mass range to roughly $50~\text{GeV}/c^2 < m_{\mu\mu}
	< 130~\text{GeV}/c^2$ for efficiency.
	Result is corrected for QED FSR (i.e. leptons are dressed), so turn off in generator.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [0]
	Description:
	Cross section as a function of $p_T$ and y of the Z boson decaying into muons
	in p p collisions at $\sqrt{s}$ = 7 TeV. $p_T$ and y cross sections are measured for
	$60 < m_{\mu\mu} < 120$ GeV. The $p_T$ cross section is measured for lepton $p_T > 20$ GeV
	and $\eta < 2.1$, while the y cross section is extrapolated to all lepton $p_T$ and $\eta$.
	This measurement was performed using 36 pb$^{-1}$ of data collected during 2010 with
	the CMS detector at the LHC.
	BibKey: 'Chatrchyan:2011wt'
	BibTeX: '@article{Chatrchyan:2011wt,
	author = "Chatrchyan, Serguei and others",
	title = "{Measurement of the Rapidity and Transverse Momentum
	Distributions of $Z$ Bosons in $pp$ Collisions at
	$\sqrt{s}=7$ TeV}",
	collaboration = "CMS Collaboration",
	journal = "Phys.Rev.",
	volume = "D85",
	pages = "032002",
	doi = "10.1103/PhysRevD.85.032002",
	year = "2012",
	eprint = "1110.4973",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-EWK-10-010, CERN-PH-EP-2011-169",
	SLACcitation = "%%CITATION = ARXIV:1110.4973;%%",
	}'
	diff --git a/data/anainfo/CMS_2012_PAS_FSQ_12_020.info b/data/anainfo/CMS_2012_PAS_FSQ_12_020.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/CMS_2012_PAS_FSQ_12_020.info
	@@ -0,0 +1,37 @@
	+Name: CMS_PAS_FSQ_12_020
	+Year: 2015
	+Summary: Studies of the underlying event at 7 TeV with leading charged particles
	+Experiment: CMS
	+Collider: LHC
	+Status: VALIDATED
	+Authors:
	+ - Hannes Jung (hannes.jung@cern.ch)
	+ - Paolo Gunnellini (paolo.gunnellini@desy.de)
	+References:
	+ - CERN-PH-EP-2015-291
	+RunInfo:
	+ Minimum bias events at 7 TeV.
	+NumEvents: 1000000
	+Beams: [p+, p+]
	+Energies: [7000]
	+Description:
	+ 'We study charged particle production in proton--proton collisions at 7 TeV. We use the direction
	+ of the charged particle with the largest transverse momentum in each event to define three
	+ regions of $\eta$--$\phi$ space: toward, away, and transverse. The average number and the
	+ average scalar pT sum of charged particles in the transverse region are sensitive to the
	+ modeling of the underlying event. The transverse region is divided into a MAX and MIN transverse
	+ region, which helps separate the hard component (initial and final-state radiation) from the
	+ beam--beam remnant and multiple parton interaction components of the scattering.'
	+BibKey: :2015pea
	+BibTeX: @article{Khachatryan:2015pea,
	+ author = "Khachatryan, Vardan and others",
	+ title = "{Event generator tunes obtained from underlying event and
	+ multiparton scattering measurements}",
	+ collaboration = "CMS",
	+ year = "2015",
	+ eprint = "1512.00815",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CMS-GEN-14-001, CERN-PH-EP-2015-291",
	+ SLACcitation = "%%CITATION = ARXIV:1512.00815;%%"
	+}
	diff --git a/data/anainfo/CMS_2013_I1209721.info b/data/anainfo/CMS_2013_I1209721.info
	--- a/data/anainfo/CMS_2013_I1209721.info
	+++ b/data/anainfo/CMS_2013_I1209721.info
	@@ -1,51 +1,51 @@
	Name: CMS_2013_I1209721
	Year: 2011
	Summary: 'Azimuthal correlations and event shapes in $Z$ + jets in $pp$ collisions at 7 TeV'
	Experiment: CMS
	Collider: LHC
	-SpiresID: 1209721
	+InspireID: 1209721
	Status: VALIDATED
	Authors:
	- Io Odderskov <io.odderskov@gmail.com>
	References:
	- http://cms.cern.ch/iCMS/analysisadmin/cadi?ancode=EWK-11-021
	- https://cds.cern.ch/record/1503578
	- http://inspirehep.net/record/1209721
	- arXiv:1301.1646 [hep-ex] (http://arxiv.org/abs/arXiv:1301.1646)
	- Submitted to Phys. Lett. B
	RunInfo:
	Run MC generators with Z decaying to leptonic modes at 7TeV comEnergy
	NumEvents: 100k
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts:
	$pT_\ell > 20$\;GeV and $\|\eta_\ell\| < 2.4$, jet $pT > 50$\;GeV
	Description:
	'Measurements are presented of event shapes and azimuthal correlations in the
	inclusive production of a Z boson in association with jets in proton-proton collisions. The
	data correspond to an integrated luminosity of 5.0/fb, collected with the CMS detector
	at the CERN LHC at $\sqrt{s} = 7$\;TeV. This to test perturbative QCD predictions
	and evaluate a substantial background to most physics channels. Studies performed
	as a function of jet multiplicity for inclusive $Z$ boson production and for $Z$ bosons with
	transverse-momenta greater than 150\;GeV, are compared to predictions from Monte
	Carlo event generators that include leading-order multiparton matrix-element (with
	up to four hard partons in the final state) and next-to-leading-order simulations of
	Z + 1-jet events. The results are corrected for detector effects, and can therefore be
	used as input to improve models for describing these processes.'
	BibKey: 'Chatrchyan:2013tna'
	BibTeX: '@article{Chatrchyan:2013tna,
	author = "Chatrchyan, Serguei and others",
	title = "{Event shapes and azimuthal correlations in $Z$ + jets
	events in $pp$ collisions at $\sqrt{s}=7$ TeV}",
	collaboration = "CMS Collaboration",
	journal = "Phys.Lett.",
	volume = "B722",
	pages = "238-261",
	doi = "10.1016/j.physletb.2013.04.025",
	year = "2013",
	eprint = "1301.1646",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-EWK-11-021, CERN-PH-EP-2013-001",
	SLACcitation = "%%CITATION = ARXIV:1301.1646;%%",
	}'
	diff --git a/data/anainfo/CMS_2013_I1218372.info b/data/anainfo/CMS_2013_I1218372.info
	--- a/data/anainfo/CMS_2013_I1218372.info
	+++ b/data/anainfo/CMS_2013_I1218372.info
	@@ -1,42 +1,42 @@
	Name: CMS_2013_I1218372
	Year: 2013
	Summary: Study of the underlying event at forward rapidity in proton--proton collisions at the LHC
	Experiment: CMS
	Collider: LHC
	-SpiresID: 1218372
	+InspireID: 1218372
	Status: VALIDATED
	Authors:
	- Samantha Dooling <samantha.dooling@desy.de>
	References:
	- JHEP 1304 (2013) 072
	- 10.1007/JHEP04(2013)072
	- CMS-FWD-11-003
	- arXiv:1302.2394
	RunInfo:
	Inelastic events (non-diffractive and diffractive) at $\sqrt{s}$ = 0.9, 2.76 and 7 TeV.
	NumEvents: 1 Mio
	Beams: [p+, p+]
	Energies: [900, 2760, 7000]
	Description:
	'Ratio of the energy deposited in the pseudorapidity range $-6.6 < \eta < -5.2$
	for events with a charged particle jet with $\|\eta\|<2$ with respect to the
	energy in inclusive events, as a function of charged particle jet transverse
	momentum for $\sqrt{s}=$0.9, 2.76 and 7 TeV.'

	BibKey: 'Chatrchyan:2013gfi'
	BibTeX: '@article{Chatrchyan:2013gfi,
	author = "Chatrchyan, Serguei and others",
	title = "{Study of the underlying event at forward rapidity in pp
	collisions at $\sqrt{s}$ = 0.9, 2.76, and 7 TeV}",
	collaboration = "CMS Collaboration",
	journal = "JHEP",
	volume = "1304",
	pages = "072",
	doi = "10.1007/JHEP04(2013)072",
	year = "2013",
	eprint = "1302.2394",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-FWD-11-003, CERN-PH-EP-2013-012",
	SLACcitation = "%%CITATION = ARXIV:1302.2394;%%",
	}'
	diff --git a/data/anainfo/CMS_2013_I1223519.info b/data/anainfo/CMS_2013_I1223519.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/CMS_2013_I1223519.info
	@@ -0,0 +1,46 @@
	+Name: CMS_2013_I1223519
	+Year: 2013
	+Summary: Searches for SUSY using $\alpha_T$ and $b$-quark multiplicity at 8~\TeV
	+Experiment: CMS
	+Collider: LHC
	+InspireID: 1223519
	+Status: UNVALIDATED
	+Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	+References:
	+- 'arXiv:1303.2985'
	+RunInfo: SM background or BSM physics model, depending on interpretation usage
	+NumEvents: 50000
	+NeedCrossSection: yes
	+Beams: [p+, p+]
	+Energies: [8000]
	+Description:
	+ 'An inclusive search for supersymmetric processes that produce final states with jets
	+ and missing transverse energy in $pp$ collisions at 8\;\TeV. The data sample corresponds
	+ to an integrated luminosity of 11.7/fb collected by the CMS experiment. In this search,
	+ a dimensionless kinematic variable, $\alpha_T$, is used to discriminate between events
	+ with genuine and misreconstructed missing transverse energy. The search was based on
	+ an examination of the number of reconstructed jets per event, the scalar sum of
	+ transverse energies of these jets, and the number of these jets identified as originating
	+ from bottom quarks. No significant excess of events over the standard model expectation
	+ was found.'
	+BibKey: Chatrchyan:2013mys
	+BibTeX: '@article{Chatrchyan:2013mys,
	+ author = "Chatrchyan, Serguei and others",
	+ title = "{Search for supersymmetry in hadronic final states with
	+ missing transverse energy using the variables $\alpha_T$
	+ and b-quark multiplicity in pp collisions at $\sqrt s=8$
	+ TeV}",
	+ collaboration = "CMS",
	+ journal = "Eur. Phys. J.",
	+ volume = "C73",
	+ year = "2013",
	+ number = "9",
	+ pages = "2568",
	+ doi = "10.1140/epjc/s10052-013-2568-6",
	+ eprint = "1303.2985",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CMS-SUS-12-028, CERN-PH-EP-2013-037",
	+ SLACcitation = "%%CITATION = ARXIV:1303.2985;%%"
	+}'
	diff --git a/data/anainfo/CMS_2013_I1258128.info b/data/anainfo/CMS_2013_I1258128.info
	--- a/data/anainfo/CMS_2013_I1258128.info
	+++ b/data/anainfo/CMS_2013_I1258128.info
	@@ -1,65 +1,65 @@
	Name: CMS_2013_I1258128
	Year: 2013
	Summary: Rapidity distributions in exclusive $Z$ + jet and $\gamma$ + jet events in $pp$ collisions at $\sqrt{s} = 7$ TeV
	Experiment: CMS
	Collider: LHC
	-InspireID: I1258128
	+InspireID: 1258128
	Status: VALIDATED
	Authors:
	- Steve Linn <linn@cern.ch>,
	- Shin-Shan Eiko Yu <syu@cern.ch>,
	- Anil Sing Pratap <singh.ap79@gmail.com>,
	- Lovedeep Kaur Saini <lvdeep9@gmail.com>,
	- Kittikul Kovitanggoon <kovitang.cern@gmail.com>,
	- Luis Lebolo <luis.lebolo@cern.ch>,
	- Vanessa Gaultney Werner <vgaul001@fiu.edu>,
	- Yun-Ju Lu <Yun-Ju.Lu@cern.ch>,
	- Syue-Wei Li <Syue-Wei.Li@cern.ch>,
	- Yu-Hsiang Chang <index0192@yahoo.com.tw>,
	- Sung-Won Lee <Sungwon.Lee@ttu.edu>,
	- Pete E.C. Markowitz <markowit@fiu.edu>,
	- Darko Mekterovic <Darko.Mekterovic@cern.ch>,
	- Jorge Rodriguez <jrodriguez@cern.ch>,
	- Bhawan Uppal
	References:
	- arXiv:1310.3082
	- https://twiki.cern.ch/twiki/bin/view/CMSPublic/PhysicsResultsSMP12004
	- Submitted to Phys. Rev. Lett
	RunInfo:
	Run MC generators with $Z$ decaying to leptonic modes + jets
	and photon + jets at 7 TeV centre-of-mass energy.
	NumEvents: 2500000 for each process
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts:
	'$Z$+jet: lepton $pT > 20$ GeV and lepton $\|\eta\| < 2.1$;
	jet $pT > 30$ GeV, jet $\|\eta\| < 2.1$, exclusive 1 jet;
	$Z pT > 40$ GeV, $76 < M_Z < 106$ GeV
	$\gamma+jet: jet $pT > 30$ GeV, jet $\|\eta\| < 2.1$, exclusive 1 jet;
	photon $pT > 40$ GeV, photon $\|\eta\| < 1.4442$'
	Description:
	'Rapidity distributions are presented for events containing either a
	$Z$ boson or a photon in association with a single jet in proton-proton
	collisions produced at the CERN LHC. The data, collected with the CMS
	detector at $\sqrt{s} = 7$ TeV, correspond to an integrated luminosity of 5.0/fb.
	The individual rapidity distributions of the boson and the jet are
	consistent within 5\% with expectations from perturbative QCD. However,
	QCD predictions for the sum and the difference in rapidities of the two
	final-state objects show significant discrepancies with CMS data. In
	particular, next-to-leading-order QCD calculations, and two Monte Carlo
	event generators using different methods to merge matrix-element
	partons with evolved parton showers, appear inconsistent with the data
	as well as with each other.'
	BibKey: Chatrchyan:2013oda
	BibTeX: '@article{Chatrchyan:2013oda,
	author = "Chatrchyan, Serguei and others",
	title = "{Rapidity distributions in exclusive $Z$+jet and photon+jet events in $pp$ collisions at $\sqrt{s}=7$ TeV}",
	collaboration = "CMS Collaboration",
	year = "2013",
	eprint = "1310.3082",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-SMP-12-004, CERN-PH-EP-2013-169",
	SLACcitation = "%%CITATION = ARXIV:1310.3082;%%",}'
	ToDo:
	- Update reference when paper published
	diff --git a/data/anainfo/CMS_2013_I1261026.info b/data/anainfo/CMS_2013_I1261026.info
	--- a/data/anainfo/CMS_2013_I1261026.info
	+++ b/data/anainfo/CMS_2013_I1261026.info
	@@ -1,47 +1,47 @@
	Name: CMS_2013_I1261026
	Year: 2013
	Summary: Jet and underlying event properties as a function of particle multiplicity
	Experiment: CMS
	Collider: LHC
	-SpiresID: 1261026
	+InspireID: 1261026
	Status: VALIDATED
	Authors:
	- Maxim Azarkin <Maksim.Azarkin@cern.ch>
	References:
	- Eur.Phys.J. C73 (2013) 2674
	- arXiv:1310.4554
	- CMS-FSQ-12-022,
	- CERN-PH-EP-2013-195
	RunInfo: QCD MB
	Beams: [p+, p+]
	Energies: [7000]
	NumEvents: 10000000
	NeedCrossSection: no
	Description:
	'Characteristics of multi-particle production in proton-proton
	collisions at $\sqrt{s} = 7$ TeV are studied as a function of the
	charged-particle multiplicity ($N_{ch}$). The produced particles are separated
	into two classes: those belonging to jets and those belonging to the
	underlying event. Charged particles are measured with pseudorapidity
	$\|\eta\| < 2.4$ and transverse momentum $p_T > 0.25$ GeV. Jets are
	reconstructed from charged-particles only and required to have
	$\pt > 5$ GeV. The distributions of jet \pt, average \pt of charged particles
	belonging to the underlying event or to jets, jet rates, and jet shapes
	are presented as functions of $N_{ch}$.'
	BibKey: Chatrchyan:2013ala
	BibTeX: '@article{Chatrchyan:2013ala,
	author = "Chatrchyan, Serguei and others",
	title = "{Jet and underlying event properties as a function of
	particle multiplicity in proton-proton collisions at
	$\sqrt{s} = 7$ TeV}",
	collaboration = "CMS Collaboration",
	journal = "Eur.Phys.J.",
	volume = "C73",
	pages = "2674",
	doi = "10.1140/epjc/s10052-013-2674-5",
	year = "2013",
	eprint = "1310.4554",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-FSQ-12-022, CERN-PH-EP-2013-195",
	SLACcitation = "%%CITATION = ARXIV:1310.4554;%%",}'
	diff --git a/data/anainfo/CMS_2013_I1272853.info b/data/anainfo/CMS_2013_I1272853.info
	--- a/data/anainfo/CMS_2013_I1272853.info
	+++ b/data/anainfo/CMS_2013_I1272853.info
	@@ -1,38 +1,38 @@
	Name: CMS_2013_I1272853
	Year: 2013
	Summary: Study of observables sensitive to double parton scattering in $W + 2$ jets process in $pp$ collisions at $\sqrt{s} = 7$~TeV
	Experiment: CMS
	Collider: LHC
	-SpiresID: 1272853
	+InspireID: 1272853
	Status: VALIDATED
	Authors:
	- Sunil Bansal (sunil.bansal@cern.ch)
	References:
	- CMS-FSQ-12-028
	- CERN-PH-EP-2013-224
	- arXiv:1312.5729
	- Submitted to JHEP
	RunInfo: Only muonic decay of W boson
	Beams: [p+, p+]
	Energies: [7000]
	NeedCrossSection: yes
	PtCuts: muon with pT > 35 GeV, jets with pT > 20 GeV
	Description:
	Double parton scattering is investigated in proton-proton collisions
	at $\sqrt{s} = 7$~TeV where the final state includes a $W$ boson, which
	decays into a muon and a neutrino, and two jets. The data sample
	corresponds to an integrated luminosity of 5 inverse femtobarns,
	collected with the CMS detector at the LHC.
	BibKey: Chatrchyan:2013xxa
	BibTeX: '@article{Chatrchyan:2013xxa,
	author = "Chatrchyan, Serguei and others",
	title = "{Study of double parton scattering using $W + 2$-jet events
	in proton-proton collisions at $\sqrt{s} = 7$~TeV}",
	collaboration = " CMS Collaboration",
	year = "2013",
	eprint = "1312.5729",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-FSQ-12-028, CERN-PH-EP-2013-224",
	SLACcitation = "%%CITATION = ARXIV:1312.5729;%%",
	}'
	diff --git a/data/anainfo/CMS_2013_I1273574.info b/data/anainfo/CMS_2013_I1273574.info
	--- a/data/anainfo/CMS_2013_I1273574.info
	+++ b/data/anainfo/CMS_2013_I1273574.info
	@@ -1,44 +1,44 @@
	Name: CMS_2013_I1273574
	Year: 2013
	Summary: Studies of 4-jet production in proton-proton collisions at $\sqrt{s} = 7$ TeV
	Experiment: CMS
	Collider: LHC
	-SpiresID: 1273574
	+InspireID: 1273574
	Status: VALIDATED
	Authors:
	- P. Gunnellini
	- A. Buckley
	References:
	- CMS-FSQ-12-013
	- CERN-PH-EP-2013-229
	- arXiv:1312.6440
	- Submitted to Phys. Rev. D
	RunInfo:
	Hard QCD events with \pT cut at generator level of 45 GeV
	NumEvents: 500000
	NeedCrossSection: yes
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: 2 jets with $\pT > 50$ GeV; 2 jets with $\pT > 20$ GeV
	Description:
	Measurements are presented of exclusive 4-jet production cross
	sections as a function of the transverse momentum $p_T$,
	pseudorapidity $\eta$, as well as of correlations in azimuthal
	angle and $p_T$ balance among the jets. The data sample was
	collected at a centre-of-mass energy of 7 TeV with the CMS
	detector at the LHC, corresponding to an integrated luminosity
	of 36 pb$^{-1}$. The jets are reconstructed with the
	anti-$k_T$ jet algorithm in a range of $\|\eta\|<4.7$.
	BibKey: Chatrchyan:2013qza
	BibTeX: '@article{Chatrchyan:2013qza,
	author = "Chatrchyan, Serguei and others",
	title = "{Measurement of four-jet production in proton-proton
	collisions at sqrt(s)=7 TeV}",
	collaboration = " CMS Collaboration",
	year = "2013",
	eprint = "1312.6440",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-FSQ-12-013, CERN-PH-EP-2013-229",
	SLACcitation = "%%CITATION = ARXIV:1312.6440;%%",
	}'
	diff --git a/data/anainfo/CMS_2014_I1303894.info b/data/anainfo/CMS_2014_I1303894.info
	--- a/data/anainfo/CMS_2014_I1303894.info
	+++ b/data/anainfo/CMS_2014_I1303894.info
	@@ -1,47 +1,47 @@
	Name: CMS_2014_I1303894
	Year: 2011
	Summary: Differential cross-section of $W$ bosons + jets in $pp$ collisions at $\sqrt{s}=7$ TeV
	Experiment: CMS
	Collider: LHC
	-InspireID: I1303894
	+InspireID: 1303894
	Status: VALIDATED
	Authors:
	- Darin Baumgartel (darinb@cern.ch)
	- Emanuela Barberis (barberis@fnal.gov)
	References:
	- Phys. Lett. B741 (2014) 12-37
	- https://inspirehep.net/record/1303894
	- http://arxiv.org/abs/1406.7533
	RunInfo:
	Run MC generators with $W$ decaying leptonically at 7 TeV CoM energy. A large number of
	events are required to populate the high jet multiplicity region. Suitable results can
	be achieved with 85M events.
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts:
	Leading muon $pT > 25 GeV$ and leading muon $\|eta\| < 2.1$
	Jet $pT > 30 GeV$ and $\|eta\| < 2.4$
	Description:
	A study of jet production in association with $W$ bosons has been performed, in
	events with the $W$ decaying to a muon. Jets are required to have $pT > 30$ GeV and $\|eta\| < 2.4$.
	Muons are required to have $pT > 25$ and $\|eta\| < 2.1$. Jets are only considered if they are
	separated from the muon by $\Delta{R} > 0.5$. Muons are dressed with photons in a cone of $0.1$
	around the muon.
	BibKey: Khachatryan:2014uva
	BibTeX: '@article{Khachatryan:2014uva,
	author = "Khachatryan, Vardan and others",
	title = "{Differential cross section measurements for the
	production of a $W$ boson in association with jets in
	protonâproton collisions at $\sqrt{s} = 7$ TeV}",
	collaboration = "CMS Collaboration",
	journal = "Phys.Lett.",
	volume = "B741",
	pages = "12-37",
	doi = "10.1016/j.physletb.2014.12.003",
	year = "2014",
	eprint = "1406.7533",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-SMP-12-023, CERN-PH-EP-2014-134",
	SLACcitation = "%%CITATION = ARXIV:1406.7533;%%",
	}
	diff --git a/data/anainfo/CMS_2014_I1305624.info b/data/anainfo/CMS_2014_I1305624.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/CMS_2014_I1305624.info
	@@ -0,0 +1,117 @@
	+Name: CMS_2014_I1305624
	+Year: 2014
	+Summary: Study of hadronic event-shape variables in multijet final states in $pp$ collisions at $\sqrt{s} = 7$ TeV
	+Experiment: CMS
	+Collider: LHC
	+InspireID: 1305624
	+Status: VALIDATED
	+Authors:
	+ - Sunanda Banerjee <Sunanda.Banerjee@cern.ch>
	+ - Sandeep Bhowmik <Sandeep.Bhowmik@cern.ch>
	+ - Monoranjan Guchait <Monoranjan.Guchait@cern.ch>
	+ - Gobinda Majumder <Gobinda.Majumder@cern.ch>
	+ - Manas Maity < Manas.Maity@cern.ch>
	+ - Debarati Roy <Debarati.Roy@cern.ch>
	+References:
	+ - 10.1007/JHEP10(2014)087
	+ - arXiv:1407.2856
	+ - CMS-PAS-SMP-12-022
	+ - CERN-PH-EP-2014-146
	+RunInfo:
	+ $pp$ QCD interactions at $\sqrt{s} = 7$ TeV. Data collected by CMS during the year 2011.
	+NumEvents: 2234304
	+Beams: [p+, p+]
	+Energies: [7000]
	+PtCuts: [30.0]
	+Description:
	+ 'Event-shape variables, which are sensitive to perturbative and nonperturbative
	+ aspects of quantum chromodynamic (QCD) interactions, are studied in multijet
	+ events recorded in proton-proton collisions at $\sqrt{s}=7$ TeV. Events are
	+ selected with at least one jet with transverse momentum $p_T > 110$ GeV and
	+ pseudorapidity $\mid\eta\mid < 2.4$, in a data sample corresponding to
	+ integrated luminosities of up to $5 fb^{-1}$. The distributions of five
	+ event-shape variables in various leading jet $p_T$ ranges are compared to
	+ predictions from different QCD Monte Carlo event generators.
	+
	+ Five event-shape variables are analyzed in this paper: the transverse thrust
	+ $\tau_{\perp}$, the total jet broadening $B_{tot}$, the total jet mass
	+ $\rho_{tot}$, the total transverse jet mass $\rho^T_{tot}$ and the third-jet
	+ resolution parameter $Y_{23}$. In the formulae below, $p_{T,i}$, $\eta_i$, and
	+ $\phi_i$ represent the transverse momentum, pseudorapidity, and azimuthal angle
	+ of the $i$th jet, and $\hat{n}_{T}$ is the unit vector that maximizes the sum of
	+ the projections of $\vec{p}_{T,i}$. The transverse thrust axis $\hat{n}_{T}$ and
	+ the beam form the so-called event plane. Based on the direction of
	+ $\hat{n}_{T}$, the transverse region is separated into an upper side
	+ $\cal{C}_U$, consisting of all jets with $\vec{p}_{T}\cdot\hat{n}_{T}$ $>$ 0,
	+ and a lower side $\cal{C}_L$, with $\vec{p}_{T}\cdot\hat{n}_{T}$ $<$ 0. The jet
	+ broadening and third-jet resolution variables require at least three jets,
	+ whereas the calculation of other variables requires at least two jets. The
	+ $\hat{n}_{T}$ vector is defined only up to a global sign - choosing one sign or
	+ the other has no consequence since it simply exchanges the upper and lower
	+ events regions.
	+
	+ Transverse Thrust : The event thrust observable in the transverse plane is
	+ defined as \begin{eqnarray} \tau_{\perp} & \equiv & 1 - \max_{\hat{n}_{T}}
	+ \frac{\sum_i \|\vec{p}_{T,i} \cdot \hat{n}_{T} \|}{\sum_i p_{T,i}}
	+ \end{eqnarray} This variable probes the hadronization process and is sensitive
	+ to the modeling of two-jet and multijet topologies. In this paper ``multijet''
	+ refers to ``more-than-two-jet''. In the limit of a perfectly balanced two-jet
	+ event, $\tau_{\perp}$ is zero, while in isotropic multijet events it amounts
	+ to $(1-2/\pi)$.
	+
	+ Jet Broadenings : The pseudorapidities and the azimuthal angles of the axes for
	+ the upper and lower event regions are defined by \begin{eqnarray} \eta_X &
	+ \equiv & \frac{\sum_{i\in{\cal{C}}_X} p_{T,i}\eta_i}{\sum_{i\in{\cal{C}}_X}
	+ p_{T,i}} ~, \\ \phi_X & \equiv & \frac{\sum_{i\in{\cal{C}}_X}
	+ p_{T,i}\phi_i}{\sum_{i\in{\cal{C}}_X} p_{T,i}} ~, \end{eqnarray} where $X$
	+ refers to upper ($U$) or lower ($L$) side. From these, the jet broadening
	+ variable in each region is defined as \begin{eqnarray} B_{X} & \equiv &
	+ \frac{1}{2P_{T}} \sum_{i\in{\cal{C}}_X}p_{T,i}\sqrt{(\eta_i -\eta_X)^2 +
	+ (\phi_i - \phi_X)^2} ~, \end{eqnarray} where $P_{T}$ is the scalar sum of
	+ the transverse momenta of all the jets. The total jet broadening is then
	+ defined as \begin{eqnarray} B_{tot} & \equiv & B_{U} + B_{L}.
	+ \end{eqnarray} Jet Masses : The normalized squared invariant mass of the
	+ jets in the upper and lower regions of the event is defined by
	+ \begin{eqnarray} \rho_X & \equiv & \frac{M^2_X}{P^2}, \end{eqnarray} where
	+ $M_X$ is the invariant mass of the constituents of the jets in the region
	+ $X$, and $P$ is the scalar sum of the momenta of all constituents in both
	+ sides. The jet mass variable is defined as the sum of the masses in the
	+ upper and lower regions, \begin{eqnarray} \rho_{tot} & \equiv & \rho_U +
	+ \rho_L ~. \end{eqnarray} The corresponding jet mass in the transverse
	+ plane, $\rho^T_{tot}$, is also similarly calculated in transverse plane.
	+
	+ Third-jet resolution parameter : The third-jet resolution parameter is defined
	+ as \begin{eqnarray} Y_{23} \equiv
	+ \frac{\mathrm{min}(p_{T,3}^2,[\mathrm{min}(p_{T,i}, p_{T,j})^2 \times (\Delta
	+ R_{ij})^2/R^2])}{P_{12}^2} ~, \end{eqnarray} where i, j run over all three
	+ jets, $(\Delta R_{ij})^2 = (\eta_i - \eta_j)^2 + (\phi_i - \phi_j)^2$, and
	+ $p_{T,3}$ is the transverse momentum of the third jet in the event. If there
	+ are more than three jets in the event, they are iteratively merged using the
	+ $k_T$ algorithm with a distance parameter $R = 0.6$. To compute $P_{12}$,
	+ three jets are merged into two using the procedure described above and
	+ $P_{12}$ is then defined as the scalar sum of the transverse momenta of the
	+ two remaining jets. The $Y_{23}$ variable estimates the relative strength of
	+ the $p_T$ of the third jet with respect to the other two jets. It vanishes for
	+ two-jet events, and a nonzero value of $Y_{23}$ indicates the presence of hard
	+ parton emission, which tests the parton showering model of QCD event
	+ generators. A test like this is less sensitive to the details of the
	+ underlying event (UE) and parton hadronization models than the other
	+ event-shape variables.'
	+
	+BibKey: 'Khachatryan:2014ika'
	+BibTeX: '@article{Khachatryan:2014ika,
	+ author = "Khachatryan, Vardan and others",
	+ title = "{Study of hadronic event-shape variables in multijet
	+ final states in $pp$ collisions at $\sqrt{s} = 7$~TeV}",
	+ collaboration = "CMS Collaboration",
	+ journal = "JHEP",
	+ volume = "1410",
	+ pages = "87",
	+ doi = "10.1007/JHEP10(2014)087",
	+ year = "2014",
	+ eprint = "1407.2856",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CMS-SMP-12-022, CERN-PH-EP-2014-146",
	+ SLACcitation = "%%CITATION = ARXIV:1407.2856;%%",
	+}'
	diff --git a/data/anainfo/CMS_2015_I1310737.info b/data/anainfo/CMS_2015_I1310737.info
	--- a/data/anainfo/CMS_2015_I1310737.info
	+++ b/data/anainfo/CMS_2015_I1310737.info
	@@ -1,60 +1,60 @@
	Name: CMS_2015_I1310737
	Year: 2015
	Summary: Jet multiplicity and differential cross-sections of $Z$+jets events in $pp$ at $\sqrt{s} = 7$ TeV
	Experiment: CMS
	Collider: LHC
	-InspireID: I1310737
	+InspireID: 1310737
	Status: VALIDATED
	Authors:
	- Fabio Cossutti (fabio.cossutti@ts.infn.it)
	- Chiara La Licata (chiara.lalicata@ts.infn.it)
	References:
	- Phys.Rev. D91 (2015) 052008
	- http://dx.doi.org/10.1103/PhysRevD.91.052008
	- http://arxiv.org/abs/arXiv:1408.3104
	- http://inspirehep.net/record/1310737
	RunInfo:
	'Run MC generators with Z decaying leptonically into both electrons and muons at 7 TeV CoM energy.
	Order of 5 million unweighted events can give a reasonable global comparison, but precision in the
	high jet multiplicity region/high jet pt may require substantially larger samples or statistical
	enhancement of high jet multiplicities.'
	NeedCrossSection: yes
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'Measurements of differential cross sections are presented for
	the production of a Z boson and at least one hadronic jet in
	proton-proton collisions at $\sqrt{s}=7$~TeV, recorded by
	the CMS detector, using a data sample corresponding to an integrated
	luminosity of 4.9 $\text{fb}^{-1}$. The jet multiplicity distribution
	is measured for up to six jets. The differential cross sections are
	measured as a function of jet transverse momentum and pseudorapidity
	for the four highest transverse momentum jets. The distribution of
	the scalar sum of jet transverse momenta is also measured as a function
	of the jet multiplicity. The measurements are compared with theoretical
	predictions at leading and next-to-leading order in perturbative QCD.

	Cuts:
	First two leading electrons or muons with $p_T > 20$ GeV and $\|\eta\| < 2.4$
	Dilepton invariant mass in the [71,111] GeV range
	Jets $p_T > 30$ GeV and $\|\eta\| < 2.4$
	$\Delta{R}($lepton,jet$) > 0.5$'
	BibKey: Khachatryan:2014zya
	BibTeX: '@article{Khachatryan:2014zya,
	author = "Khachatryan, V. and others",
	title = "{Measurements of jet multiplicity and differential
	production cross sections of $Z +$ jets events in
	proton-proton collisions at $\sqrt{s}=7 TeV}",
	collaboration = "CMS",
	journal = "Phys.Rev.",
	number = "5",
	volume = "D91",
	pages = "052008",
	doi = "10.1103/PhysRevD.91.052008",
	year = "2015",
	eprint = "1408.3104",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-SMP-12-017, CERN-PH-EP-2014-205",
	SLACcitation = "%%CITATION = ARXIV:1408.3104;%%",
	}'
	diff --git a/data/anainfo/CMS_2015_I1346843.info b/data/anainfo/CMS_2015_I1346843.info
	--- a/data/anainfo/CMS_2015_I1346843.info
	+++ b/data/anainfo/CMS_2015_I1346843.info
	@@ -1,53 +1,52 @@
	Name: CMS_2015_I1346843
	Year: 2014
	-Summary: Measurement of differential cross section of FSR Photons in Z decays.
	+Summary: Measurement of differential cross-section of FSR photons in $Z$ decays
	Experiment: CMS
	Collider: LHC
	InspireID: 1346843
	Status: VALIDATED
	Authors:
	- Andrew Kubik <Andrew.Michael.Kubik@cern.ch>
	- Michael Schmitt <schmittm@lotus.phys.northwestern.edu>
	References:
	- arXiv:1502.07940 [hep-ex]
	RunInfo:
	$p p \to \mu^+ \mu^- \gamma$+X 7 TeV.
	These cross sections are given for the fiducial region defined as follows
	- Leading muon $p_T > 31$ GeV and abs(eta) < 2.4
	- Trailing muon $p_T > 9$ GeV and abs(eta) < 2.4
	- Photon $p_T > 5$ GeV
	- Photon abs(eta) < 2.4 but not 1.4 < abs(eta) < 1.6
	- Separation between photon and closest muon 0.05 < DeltaR < 3.0
	- Di-muon invariant mass 30 < M_mumu < 87 GeV
	NumEvents: 1000000
	NeedCrossSection: true
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'The differential cross sections for the production of photons in Z to mu+ mu-
	gamma decays are presented as a function of the transverse energy of the
	photon and its separation from the nearest muon. The data for these
	measurements were collected with the CMS detector and correspond to an
	integrated luminosity of 4.7 inverse femtobarns of pp collisions at sqrt(s) =
	7 TeV delivered by the CERN LHC.'
	BibKey: Khachatryan:2015rja
	BibTeX: '@article{Khachatryan:2015rja,
	author = "Khachatryan, V. and others",
	title = "{Study of final-state radiation in decays of Z bosons
	produced in $pp$ collisions at 7Â TeV}",
	collaboration = "CMS",
	journal = "Phys.Rev.",
	number = "9",
	volume = "D91",
	pages = "092012",
	doi = "10.1103/PhysRevD.91.092012",
	year = "2015",
	eprint = "1502.07940",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CMS-EWK-11-016, CERN-PH-EP-2015-031",
	SLACcitation = "%%CITATION = ARXIV:1502.07940;%%",
	}'
	ToDo:
	- Implement the analysis, test it, remove this ToDo, and mark as VALIDATED :-)
	-
	diff --git a/data/anainfo/CMS_2015_I1397174.info b/data/anainfo/CMS_2015_I1397174.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/CMS_2015_I1397174.info
	@@ -0,0 +1,52 @@
	+Name: CMS_2015_I1397174
	+Year: 2016
	+Summary: Measurement of ttbar production with additional jet activity, including b quark jets, in the dilepton decay channel using pp collisions at sqrt(s)=8 TeV
	+Experiment: CMS
	+Collider: LHC
	+InspireID: 1397174
	+Status: VALIDATED
	+Authors:
	+ - Javier Fernandez <Javier.Fernandez@cern.ch>
	+ - Jungwan John Goh <Junghwan.Goh@cern.ch>
	+ - Efe Yazgan <efe.yazgan@cern.ch>
	+ - Markus Seidel <markus.seidel@cern.ch>
	+ - James Keaveney <james.keaveney@vub.ac.be>
	+ - Elvire Bouvier <e.bouvier@cern.ch>
	+ - Benedikt Maier <benedikt.maier@cern.ch>
	+ - Andy Buckley <andy.buckley@cern.ch>
	+References:
	+ - arXiv:1510.03072
	+RunInfo:
	+ 'ttbar events at $\sqrt{s}=8\;\TeV. Top quarks are expected in the event record to identify
	+ additional jets. Gap fractions require high statistics in a single run or custom merging of
	+ the YODA files.'
	+Luminosity: 19.7/fb
	+Beams: [p+, p+]
	+Energies: [8000]
	+Description:
	+ 'Jet multiplicity distributions in top quark pair ($t\bar{t}$) events are measured in $pp$
	+ collisions at a centre-of-mass energy of 8\;\TeV with the CMS detector at the LHC, using
	+ a data set corresponding to an integrated luminosity of 19.7/fb. The measurement is
	+ performed in the dilepton decay channels $e^+e^-$, $\mu^+\mu^-$, and $e^\pm\mu^\mp$).
	+ The absolute and normalized differential cross-sections for $t\bar{t}$ production are
	+ measured as a function of jet multiplicity for different jet transverse momentum thresholds
	+ and the kinematic properties of the leading additional jets. The differential $t\bar{t}b$
	+ and $t\bar{t}b\bar{b}$ cross-sections are presented for the first time as a function of
	+ the kinematic properties of the leading additional $b$-jets. Furthermore, the fraction of
	+ events without additional jets above a threshold is measured as a function of the transverse
	+ momenta of the leading additional jets and the scalar sum of the transverse momenta of all
	+ additional jets.'
	+BibKey: Khachatryan:2015mva
	+BibTeX: '@article{Khachatryan:2015mva,
	+ author = "Khachatryan, Vardan and others",
	+ title = "{Measurement of $\mathrm{ t \bar{t} } $ production with
	+ additional jet activity, including $b$ quark jets, in the
	+ dilepton decay channel using $pp$ collisions at $\sqrt{s} = 8\;\TeV$}",
	+ collaboration = "CMS",
	+ year = "2015",
	+ eprint = "1510.03072",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CMS-TOP-12-041, CERN-PH-EP-2015-240",
	+ SLACcitation = "%%CITATION = ARXIV:1510.03072;%%"
	+}'
	diff --git a/data/anainfo/CMS_2016_I1459051.info b/data/anainfo/CMS_2016_I1459051.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/CMS_2016_I1459051.info
	@@ -0,0 +1,55 @@
	+Name: CMS_2016_I1459051
	+Year: 2016
	+Summary: Measurement of the inclusive jet cross-section in $pp$ collisions at $\sqrt{s} = 13\;\TeV$
	+Experiment: CMS
	+Collider: LHC
	+SpiresID: 1459051
	+Status: VALIDATED
	+Authors:
	+ - Paolo Gunnellini <paolo.gunnellini@desy.de>
	+References:
	+ - Eur.Phys.J. C76 (2016) no.8, 451
	+ - CERN-EP-2016-104
	+ - CMS-SMP-15-007
	+RunInfo:
	+ Inclusive hard QCD at 13 TeV center-of-mass energy, and ptHat (or equivalent) greater than 90 GeV
	+NumEvents: 200k
	+Beams: [p+, p+]
	+Energies: [13000]
	+PtCuts: Jet pT higher than 114 GeV
	+Description:
	+ 'A measurement of the double-differential inclusive jet cross section as a function of
	+ jet transverse momentum pT and absolute jet rapidity \|y\| is presented. The analysis is
	+ based on proton-proton collisions collected by the CMS experiment at the LHC at a
	+ centre-of-mass energy of 13 TeV. The data samples correspond to integrated luminosities
	+ of 71 and 44 pbâ1 for \|y\| < 3 and 3.2 < \|y\| < 4.7, respectively. Jets are reconstructed
	+ with the anti-kt clustering algorithm for two jet sizes, R, of 0.7 and 0.4, in a phase
	+ space region covering jet pT up to 2 TeV and jet rapidity up to \|y\| = 4.7. Predictions
	+ of perturbative quantum chromodynamics at next-to-leading order precision, complemented
	+ with electroweak and nonperturbative corrections, are used to compute the absolute scale
	+ and the shape of the inclusive jet cross section. The cross-section difference in $R$,
	+ when going to a smaller jet size of 0.4, is best described by Monte Carlo event generators
	+ with next-to-leading order predictions matched to parton showering, hadronisation, and
	+ multiparton interactions. In the phase space accessible with the new data, this
	+ measurement provides a first indication that jet physics is as well understood at
	+ $\sqrt(s) = 13\;\TeV$ as at smaller centre-of-mass energies.'
	+NeedCrossSection: yes
	+BibKey: :Khachatryan:2016wdh
	+BibTeX: '@article{Khachatryan:2016wdh,
	+ author = "Khachatryan, Vardan and others",
	+ title = "{Measurement of the double-differential inclusive jet
	+ cross section in protonâproton collisions at $\sqrt{s} =
	+ 13\,\text {TeV} $}",
	+ collaboration = "CMS",
	+ journal = "Eur. Phys. J.",
	+ volume = "C76",
	+ year = "2016",
	+ number = "8",
	+ pages = "451",
	+ doi = "10.1140/epjc/s10052-016-4286-3",
	+ eprint = "1605.04436",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CMS-SMP-15-007, CERN-EP-2016-104",
	+ SLACcitation = "%%CITATION = ARXIV:1605.04436;%%"
	+}'
	diff --git a/data/anainfo/CMS_2016_I1473674.info b/data/anainfo/CMS_2016_I1473674.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/CMS_2016_I1473674.info
	@@ -0,0 +1,36 @@
	+Name: CMS_2016_I1473674
	+Year: 2016
	+Summary: Measurement of the differential cross sections for top quark pair production as a function of kinematic event variables at sqrt(s) = 8 TeV
	+Experiment: CMS
	+Collider: LHC
	+InspireID: 1473674
	+Status: VALIDATED
	+Authors:
	+ - Markus Seidel <markus.seidel@cern.ch>
	+ - Lukas Kreczko <kreczko@cern.ch>
	+ - Emyr Clement <Emyr.Clement@bristol.ac.uk>
	+References:
	+ - arXiv:1607.00837
	+RunInfo:
	+ ttbar events at sqrt(s) = 8 TeV (inclusive or lepton+jets decay mode)
	+Luminosity: 19.7 / fb
	+Beams: [p+, p+]
	+Energies: [8000]
	+Description:
	+ 'Measurements are reported of the normalized differential cross sections for top quark pair production with respect to four kinematic event variables: the missing transverse energy; the scalar sum of the jet transverse momentum (pT); the scalar sum of the pT of all objects in the event; and the pT of leptonically decaying W bosons from top quark decays.'
	+
	+BibKey: Khachatryan:2016oou
	+BibTeX: '@article{Khachatryan:2016oou,
	+ author = "Khachatryan, Vardan and others",
	+ title = "{Measurement of the differential cross sections for top
	+ quark pair production as a function of kinematic event
	+ variables in pp collisions at $\sqrt{s}$ = 7 and 8 TeV}",
	+ collaboration = "CMS",
	+ journal = "Submitted to: Phys. Rev. D",
	+ year = "2016",
	+ eprint = "1607.00837",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CMS-TOP-12-042, CERN-EP-2016-139",
	+ SLACcitation = "%%CITATION = ARXIV:1607.00837;%%"
	+}'
	diff --git a/data/anainfo/CMS_2016_PAS_SUS_16_14.info b/data/anainfo/CMS_2016_PAS_SUS_16_14.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/CMS_2016_PAS_SUS_16_14.info
	@@ -0,0 +1,22 @@
	+Name: CMS_2016_PAS_SUS_16_14
	+Year: 2013
	+Summary: Search for supersymmetry in events with jets and missing transverse momentum at 13~\TeV
	+Experiment: CMS
	+Collider: LHC
	+Status: UNVALIDATED
	+Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	+RunInfo: BSM physics signal events
	+NumEvents: 50000
	+NeedCrossSection: yes
	+Beams: [p+, p+]
	+Energies: [13000]
	+Description:
	+ 'A search for supersymmetry in all-hadronic events with large missing transverse
	+ momentum, produced in proton--proton collisions at $\sqrt{s} = 13~\TeV$. The data
	+ sample, corresponding to an integrated luminosity of 12.9/fb, was collected with
	+ the CMS detector at the CERN LHC in 2016. The data are examined in search regions
	+ of jet multiplicity, tagged bottom quark jet multiplicity, missing transverse momentum,
	+ and the scalar sum of jet transverse momenta. The observed numbers of events in all
	+ search regions are found to be consistent with the expectations from standard model
	+ processes.'
	diff --git a/data/anainfo/D0_1995_I398175.info b/data/anainfo/D0_1995_I398175.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/D0_1995_I398175.info
	@@ -0,0 +1,31 @@
	+Name: D0_1995_I398175
	+Year: 1995
	+Summary: Transverse energy distributions within jets in $p\bar{p}$ collisions at 1800 GeV
	+Experiment: D0
	+Collider: Tevatron
	+InspireID: 398175
	+Status: VALIDATED
	+Authors:
	+ - Simone Amoroso <amoroso@cern.ch>
	+References:
	+ - Phys.Lett. B357 (1995) 500-508
	+ - doi:10.1016/0370-2693(95)00889-S
	+RunInfo: proton-antiproton collisions at a c.o.m. energy of 1.8 TeV
	+Beams: [p-, p+]
	+Energies: [1800]
	+Description: D0 measurement of the jet shape as a function of jet transverse energy in both the central ($\|\eta\|<0.2$)
	+ and forward ($2.5<\|\eta\|<3.5$) rapidity regions.
	+BibKey: Abachi:1995zw
	+BibTeX: '@article{Abachi:1995zw,
	+ author = "Abachi, S. and others",
	+ title = "{Transverse energy distributions within jets in
	+ $p\bar{p}$ collisions at $\sqrt{s} = 1.8$ TeV}",
	+ collaboration = "D0",
	+ journal = "Phys. Lett.",
	+ volume = "B357",
	+ year = "1995",
	+ pages = "500-508",
	+ doi = "10.1016/0370-2693(95)00889-S",
	+ reportNumber = "FERMILAB-PUB-95-203-E",
	+ SLACcitation = "%%CITATION = PHLTA,B357,500;%%"
	+}'
	diff --git a/data/anainfo/D0_1996_S3214044.info b/data/anainfo/D0_1996_S3214044.info
	--- a/data/anainfo/D0_1996_S3214044.info
	+++ b/data/anainfo/D0_1996_S3214044.info
	@@ -1,45 +1,48 @@
	Name: D0_1996_S3214044
	Year: 1996
	Summary: Topological distributions of inclusive three- and four-jet events
	Experiment: D0
	Collider: Tevatron Run 1
	SpiresID: 3214044
	-Status: UNVALIDATED - currently wrong jet algorithm!
	+InspireID: 399364
	+Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.D53:6000-6016,1996
	- doi:10.1103/PhysRevD.53.6000
	- arXiv:hep-ex/9509005
	RunInfo:
	$p \bar{p} \to$ jets at 1800 GeV with minimum jet pT in analysis = 20 GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [10]
	Description:
	The global topologies of inclusive three- and four-jet events produced in
	pbar p interactions are described. The three- and four-jet events are
	selected from data recorded by the D0 detector at the Fermilab Tevatron
	Collider operating at a center-of-mass energy of $\sqrt{s}$=1800 GeV.
	The studies also show that the topological distributions of the different
	subprocesses involving different numbers of quarks are very similar and
	reproduce the measured distributions well. The parton-shower Monte Carlo
	generators provide a less satisfactory description of the topologies of the
	three- and four-jet events.
	BibKey: Abachi:1995zv
	BibTeX: '@Article{Abachi:1995zv,
	author = "Abachi, S. and others",
	collaboration = "D0",
	title = "{Studies of Topological Distributions of the Three- and
	Four-Jet Events in $\bar{p}p$ Collisions at $\sqrt{s}=1800$
	GeV with the D\O\\ Detector}",
	journal = "Phys. Rev.",
	volume = "D53",
	year = "1996",
	pages = "6000-6016",
	eprint = "hep-ex/9509005",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.53.6000",
	SLACcitation = "%%CITATION = HEP-EX/9509005;%%"
	}'
	+ToDo:
	+ - Currently using wrong jet algorithm!
	diff --git a/data/anainfo/D0_1996_S3324664.info b/data/anainfo/D0_1996_S3324664.info
	--- a/data/anainfo/D0_1996_S3324664.info
	+++ b/data/anainfo/D0_1996_S3324664.info
	@@ -1,40 +1,42 @@
	Name: D0_1996_S3324664
	Year: 1996
	Summary: Azimuthal decorrelation of jets widely separated in rapidity
	Experiment: D0
	Collider: Tevatron Run 1
	SpiresID: 3324664
	-Status: UNVALIDATED - currently uses wrong jet algorithm!
	+InspireID: 416886
	+Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.Lett.77:595-600,1996
	- doi:10.1103/PhysRevLett.77.595
	- arXiv:hep-ex/9603010
	RunInfo:
	$p \bar{p} \to \,\text{jets}$ at 1800\;\GeV
	NumEvents: 10000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [10]
	Description:
	First measurement of the azimuthal decorrelation between jets with
	pseudorapidity separation up to five units. The data were accumulated using
	the D0 detector during Tevatron Run 1 at $\sqrt{s} = 1.8\;\TeV$.
	+ Requires di-jet events with at least one jet above 50 GeV and two jets
	+ above 20 GeV.
	BibKey: Abachi:1996et
	BibTeX: '@Article{Abachi:1996et,
	author = "Abachi, S. and others",
	collaboration = "D0",
	title = "{The azimuthal decorrelation of jets widely separated in rapidity}",
	journal = "Phys. Rev. Lett.",
	volume = "77",
	year = "1996",
	pages = "595-600",
	eprint = "hep-ex/9603010",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevLett.77.595",
	SLACcitation = "%%CITATION = HEP-EX/9603010;%%"
	}'
	ToDo:
	- - So far, this analysis is using the wrong jet algorithm, namely the D0 Run
	- II Improved Legacy cone.
	+ - So far, this analysis is using the wrong jet algorithm.
	diff --git a/data/anainfo/D0_2000_S4480767.info b/data/anainfo/D0_2000_S4480767.info
	--- a/data/anainfo/D0_2000_S4480767.info
	+++ b/data/anainfo/D0_2000_S4480767.info
	@@ -1,41 +1,42 @@
	Name: D0_2000_S4480767
	Year: 2000
	Summary: Transverse momentum of the W boson
	Experiment: D0
	Collider: Tevatron Run 1
	SpiresID: 4480767
	-Status: UNVALIDATED
	+InspireID: 535017
	+Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Lett. B513 (2001) 292-300
	- doi:10.1016/S0370-2693(01)00628-1
	- arXiv:hep-ex/0010026
	RunInfo:
	Production of W+ and W- decaying into the electron channel.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	Measurement of the differential cross section for W boson production as a
	function of its transverse momentum. The data were collected by the D0
	experiment at the Fermilab Tevatron Collider during 1994-1995 and correspond
	to an integrated luminosity of 85 pb$^{-1}$.
	NeedCrossSection: yes
	BibKey: Abbott:2000xv
	BibTeX: '@Article{Abbott:2000xv,
	author = "Abbott, B. and others",
	collaboration = "D0",
	title = "{Differential cross section for $W$ boson production as a
	function of transverse momentum in $p\bar{p}$ collisions at
	$\sqrt{s} = 1.8$ TeV}",
	journal = "Phys. Lett.",
	volume = "B513",
	year = "2001",
	pages = "292-300",
	eprint = "hep-ex/0010026",
	archivePrefix = "arXiv",
	doi = "10.1016/S0370-2693(01)00628-1",
	SLACcitation = "%%CITATION = HEP-EX/0010026;%%"
	}'
	diff --git a/data/anainfo/D0_2001_S4674421.info b/data/anainfo/D0_2001_S4674421.info
	--- a/data/anainfo/D0_2001_S4674421.info
	+++ b/data/anainfo/D0_2001_S4674421.info
	@@ -1,41 +1,42 @@
	Name: D0_2001_S4674421
	Year: 2001
	Summary: Tevatron Run I differential W/Z boson cross-section analysis
	Experiment: D0
	Collider: Tevatron Run 1
	SpiresID: 4674421
	+InspireID: 559624
	Status: VALIDATED
	Authors:
	- Lars Sonnenschein <Lars.Sonnenschein@cern.ch>
	References:
	- Phys.Lett.B517:299-308,2001
	- doi:10.1016/S0370-2693(01)01020-6
	- arXiv:hep-ex/0107012v2
	RunInfo:
	$W/Z$ events with decays to first generation leptons, in $p\bar{p}$
	collisions at $\sqrt{s} = 1800\;\GeV$
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	Measurement of differential W/Z boson cross section and ratio in $p
	\bar{p}$ collisions at center-of-mass energy $\sqrt{s} = 1.8\;\TeV$. The data
	cover electrons and neutrinos in a pseudorapidity range of -2.5 to 2.5.
	NeedCrossSection: yes
	BibKey: Abazov:2001nta
	BibTeX: '@Article{Abazov:2001nta,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of the ratio of differential cross sections
	for $W$ and $Z$ boson production as a function of
	transverse momentum in $p\bar{p}$ collisions at $\sqrt{s} = 1.8$\;TeV}",
	journal = "Phys. Lett.",
	volume = "B517",
	year = "2001",
	pages = "299-308",
	eprint = "hep-ex/0107012",
	archivePrefix = "arXiv",
	doi = "10.1016/S0370-2693(01)01020-6",
	SLACcitation = "%%CITATION = HEP-EX/0107012;%%"
	}'
	diff --git a/data/anainfo/D0_2004_S5992206.info b/data/anainfo/D0_2004_S5992206.info
	--- a/data/anainfo/D0_2004_S5992206.info
	+++ b/data/anainfo/D0_2004_S5992206.info
	@@ -1,38 +1,39 @@
	Name: D0_2004_S5992206
	Year: 2004
	Summary: Run II jet azimuthal decorrelation analysis
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 5992206
	+InspireID: 659398
	Status: VALIDATED
	Authors:
	- Lars Sonnenschein <lars.sonnenschein@cern.ch>
	References:
	- Phys. Rev. Lett., 94, 221801 (2005)
	- arXiv:hep-ex/0409040
	RunInfo:
	QCD events in ppbar interactions at $\sqrt{s} = 1960$ GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Correlations in the azimuthal angle between the two largest pT jets
	have been measured using the D0 detector in ppbar collisions at
	1960~GeV. The analysis is based on an inclusive dijet event sample in
	the central rapidity region. The correlations are determined for four
	different pT intervals.
	BibKey: Abazov:2004hm
	BibTeX: '@Article{Abazov:2004hm,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of dijet azimuthal decorrelations at central rapidities in $p\bar{p}$ collisions at $\sqrt{s} = 1.96$ TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "94",
	year = "2005",
	pages = "221801",
	eprint = "hep-ex/0409040",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevLett.94.221801",
	SLACcitation = "%%CITATION = HEP-EX/0409040;%%"
	}'
	diff --git a/data/anainfo/D0_2006_S6438750.info b/data/anainfo/D0_2006_S6438750.info
	--- a/data/anainfo/D0_2006_S6438750.info
	+++ b/data/anainfo/D0_2006_S6438750.info
	@@ -1,48 +1,49 @@
	Name: D0_2006_S6438750
	Year: 2006
	Summary: Inclusive isolated photon cross-section, differential in pT(gamma)
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 6438750
	+InspireID: 698784
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Gavin Hesketh <gavin.hesketh@cern.ch>
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Lett.B639:151-158,2006, Erratum-ibid.B658:285-289,2008
	- doi:10.1016/j.physletb.2006.04.048
	- arXiv:hep-ex/0511054 (plus erratum)
	RunInfo:
	ppbar collisions at $\sqrt{s} = 1960$ GeV. Requires gamma + jet (q,qbar,g)
	hard processes, which for Pythia 6 means MSEL=10 for with MSUB indices
	14, 18, 29, 114, 115 enabled.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [15]
	Description:
	Measurement of differential cross section for inclusive production of
	isolated photons in p pbar collisions at $\sqrt{s} = 1.96$ TeV with the
	D\O detector at the Fermilab Tevatron collider. The photons span
	transverse momenta 23--300 GeV and have pseudorapidity $\|\eta\| < 0.9$.
	Isolated direct photons are probes of pQCD via the annihilation ($q
	\bar{q} -> \gamma g$) and quark-gluon Compton scattering ($q g -> \gamma q$)
	processes, the latter of which is also sensitive to the gluon PDF. The
	initial state radiation / resummation formalisms are sensitive to the
	resulting photon pT spectrum
	NeedCrossSection: yes
	BibKey: Abazov:2005wc
	BibTeX: '@Article{Abazov:2005wc,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of the isolated photon cross section in $p \bar{p}$ collisions at $\sqrt{s} = 1.96$ TeV}",
	journal = "Phys. Lett.",
	volume = "B639",
	year = "2006",
	pages = "151-158",
	eprint = "hep-ex/0511054",
	archivePrefix = "arXiv",
	doi = "10.1016/j.physletb.2006.04.048",
	SLACcitation = "%%CITATION = HEP-EX/0511054;%%"
	}'
	diff --git a/data/anainfo/D0_2007_S7075677.info b/data/anainfo/D0_2007_S7075677.info
	--- a/data/anainfo/D0_2007_S7075677.info
	+++ b/data/anainfo/D0_2007_S7075677.info
	@@ -1,41 +1,42 @@
	Name: D0_2007_S7075677
	Year: 2007
	Summary: $Z/\gamma^* + X$ cross-section shape, differential in $y(Z)$
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 7075677
	+InspireID: 744624
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Gavin Hesketh <ghesketh@fnal.gov>
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Rev.D76:012003,2007
	- arXiv:hep-ex/0702025
	RunInfo:
	Drell-Yan $p \bar{p} \to Z/\gamma^*$ + jets events at $\sqrt{s}$ = 1960 GeV.
	Needs mass cut on lepton pair to avoid photon singularity, looser than $71 < m_{ee} < 111$ GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Cross sections as a function of di-electron rapidity $p \bar{p}$
	collisions at $\sqrt{s}$ = 1.96 TeV, based on an integrated luminosity
	of $0.4~\text{fb}^{-1}$.
	BibKey: Abazov:2007jy
	BibTeX: '@Article{Abazov:2007jy,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of the shape of the boson rapidity
	distribution for $p \bar{p} \to Z/gamma^* \to e^{+} e^{-}$
	+ $X$ events produced at $\sqrt{s}$ of 1.96-TeV}",
	journal = "Phys. Rev.",
	volume = "D76",
	year = "2007",
	pages = "012003",
	eprint = "hep-ex/0702025",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.76.012003",
	SLACcitation = "%%CITATION = HEP-EX/0702025;%%"
	}'
	diff --git a/data/anainfo/D0_2008_S6879055.info b/data/anainfo/D0_2008_S6879055.info
	--- a/data/anainfo/D0_2008_S6879055.info
	+++ b/data/anainfo/D0_2008_S6879055.info
	@@ -1,40 +1,41 @@
	Name: D0_2008_S6879055
	Year: 2008
	Summary: Measurement of the ratio $\sigma(Z/\gamma^* + n \text{ jets})/\sigma(Z/\gamma^*)$
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 6879055
	+InspireID: 724239
	Status: VALIDATED
	Authors:
	- Giulio Lenzi
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- hep-ex/0608052
	RunInfo:
	$p \bar{p} \to e^+ e^-$ + jets at 1960~GeV.
	Needs mass cut on lepton pair to avoid photon singularity,
	looser than $75 < m_{ee} < 105$ GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Cross sections as a function of $\pT$ of the three leading jets and $n$-jet
	cross section ratios in $p \bar{p}$ collisions at $\sqrt{s}$ = 1.96 TeV, based
	on an integrated luminosity of $0.4~\text{fb}^{-1}$.
	BibKey: Abazov:2006gs
	BibTeX: '@Article{Abazov:2006gs,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of the ratios of the $Z/\gamma^* + \ge n$-jet
	production cross-sections to the total inclusive $Z/\gamma^*$
	cross section in $p \bar{p}$ collisions at $\sqrt{s} = 1.96$ TeV}",
	journal = "Phys. Lett.",
	volume = "B658",
	year = "2008",
	pages = "112-119",
	eprint = "hep-ex/0608052",
	archivePrefix = "arXiv",
	doi = "10.1016/j.physletb.2007.10.046",
	SLACcitation = "%%CITATION = HEP-EX/0608052;%%"
	}'
	diff --git a/data/anainfo/D0_2008_S7554427.info b/data/anainfo/D0_2008_S7554427.info
	--- a/data/anainfo/D0_2008_S7554427.info
	+++ b/data/anainfo/D0_2008_S7554427.info
	@@ -1,42 +1,43 @@
	Name: D0_2008_S7554427
	Year: 2008
	Summary: $Z/\gamma^* + X$ cross-section shape, differential in $pT(Z)$
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 7554427
	+InspireID: 769689
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:0712.0803
	RunInfo:
	"* $p \\bar{p} \\to e^+ e^-$ + jets at 1960~GeV.
	* Needs mass cut on lepton pair to avoid photon singularity,
	looser than $40 < m_{ee} < 200$ GeV."
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Cross sections as a function of $\pT$ of the vector boson inclusive and
	in forward region ($\|y\| > 2$, $\pT<30$ GeV) in the di-electron channel
	in $p \bar{p}$ collisions
	at $\sqrt{s}$ = 1.96 TeV, based on an integrated luminosity of 0.98~fb$^{-1}$.
	BibKey: :2007nt
	BibTeX: '@Article{:2007nt,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of the shape of the boson transverse momentum
	distribution in $p \bar{p} \to Z / \gamma^{*} \to e^+ e^- +
	X$ events produced at $\sqrt{s}$=1.96-TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "100",
	year = "2008",
	pages = "102002",
	eprint = "0712.0803",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevLett.100.102002",
	SLACcitation = "%%CITATION = 0712.0803;%%"
	}'
	diff --git a/data/anainfo/D0_2008_S7662670.info b/data/anainfo/D0_2008_S7662670.info
	--- a/data/anainfo/D0_2008_S7662670.info
	+++ b/data/anainfo/D0_2008_S7662670.info
	@@ -1,42 +1,43 @@
	Name: D0_2008_S7662670
	Year: 2008
	Summary: Measurement of D0 Run II differential jet cross sections
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 7662670
	+InspireID: 779574
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Gavin Hesketh <gavin.hesketh@cern.ch>
	References:
	- Phys.Rev.Lett.101:062001,2008
	- doi:10.1103/PhysRevLett.101.062001
	- arXiv:0802.2400v3 [hep-ex]
	RunInfo:
	QCD events at $\sqrt{s} = 1960\;\GeV$. A $\pT^\text{min} cut is probably necessary since
	the lowest jet $\pT$ bin is at 50\;GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [40]
	Description:
	Measurement of the inclusive jet cross section in $p \bar{p}$ collisions at
	center-of-mass energy $\sqrt{s} = 1.96\;\TeV$. The data cover jet
	transverse momenta from 50--600\;GeV and jet rapidities in the range
	-2.4 to 2.4.
	NeedCrossSection: yes
	BibKey: :2008hua
	BibTeX: '@Article{:2008hua,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of the inclusive jet cross-section in $p \bar{p}$ collisions at $s^{1/2} = $1.96 TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "101",
	year = "2008",
	pages = "062001",
	eprint = "0802.2400",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevLett.101.062001",
	SLACcitation = "%%CITATION = 0802.2400;%%"
	}'
	diff --git a/data/anainfo/D0_2008_S7719523.info b/data/anainfo/D0_2008_S7719523.info
	--- a/data/anainfo/D0_2008_S7719523.info
	+++ b/data/anainfo/D0_2008_S7719523.info
	@@ -1,53 +1,54 @@
	Name: D0_2008_S7719523
	Year: 2008
	Summary: Isolated $\gamma$ + jet cross-sections, differential in pT($\gamma$) for various $y$ bins
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 7719523
	+InspireID: 782968
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Gavin Hesketh <gavin.hesketh@cern.ch>
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Lett.B666:435-445,2008
	- doi:10.1016/j.physletb.2008.06.076
	- arXiv:0804.1107v2 [hep-ex]
	RunInfo:
	"Produce only gamma + jet ($q,\\bar{q},g$) hard processes (for Pythia 6, this means MSEL=10
	and MSUB indices 14, 29 & 115 enabled). The lowest bin edge is at 30 GeV, so a kinematic
	pTmin cut is probably required to fill the histograms."
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [20]
	Description:
	The process $p \bar{p}$ -> photon + jet + X as studied by the D0 detector
	at the Fermilab Tevatron collider at center-of-mass energy $\sqrt{s} = 1.96\;\TeV$.
	Photons are reconstructed in the central rapidity region
	$\|y_\gamma\| < 1.0$ with transverse momenta in the range 30--400\;GeV,
	while jets are reconstructed in either the central $\|y_\text{jet}\| < 0.8$ or
	forward $1.5 < \|y_\text{jet}\| < 2.5$ rapidity intervals with
	$\pT^\text{jet} > 15\;\GeV$. The differential cross section
	$\mathrm{d}^3 \sigma / \mathrm{d}{\pT^\gamma} \mathrm{d}{y_\gamma}
	\mathrm{d}{y_\text{jet}}$ is measured as a function of $\pT^\gamma$ in four
	regions, differing by the relative orientations of the photon and the
	jet. MC predictions have trouble with simultaneously describing the
	measured normalization and $\pT^\gamma$ dependence of the cross section
	in any of the four measured regions.
	NeedCrossSection: yes
	BibKey: Abazov:2008er
	BibTeX: '@Article{Abazov:2008er,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of the differential cross-section for the production of an isolated photon with associated jet in $p \bar{p}$ collisions at $\sqrt{s} = 1.96$ TeV}",
	journal = "Phys. Lett.",
	volume = "B666",
	year = "2008",
	pages = "435-445",
	eprint = "0804.1107",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1016/j.physletb.2008.06.076",
	SLACcitation = "%%CITATION = 0804.1107;%%"
	}'
	diff --git a/data/anainfo/D0_2008_S7837160.info b/data/anainfo/D0_2008_S7837160.info
	--- a/data/anainfo/D0_2008_S7837160.info
	+++ b/data/anainfo/D0_2008_S7837160.info
	@@ -1,46 +1,47 @@
	Name: D0_2008_S7837160
	Year: 2008
	Summary: Measurement of W charge asymmetry from D0 Run II
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 7837160
	+InspireID: 791230
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Gavin Hesketh <gavin.hesketh@cern.ch>
	References:
	- Phys.Rev.Lett.101:211801,2008
	- doi:10.1103/PhysRevLett.101.211801
	- arXiv:0807.3367v1 [hep-ex]
	RunInfo:
	"* Event type: W production with decay to $e \\, \\nu_e$ only
	* for Pythia 6: MSEL = 12, MDME(206,1) = 1
	* Energy: 1.96 TeV"
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Measurement of the electron charge asymmetry in $p \bar p \to W + X \to
	e \nu_e + X$ events at a center of mass energy of 1.96 TeV. The asymmetry
	is measured as a function of the electron transverse momentum and
	pseudorapidity in the interval (-3.2, 3.2). This data is sensitive to
	proton parton distribution functions due to the valence asymmetry in
	the incoming quarks which produce the W. Initial state radiation
	should also affect the pT distribution.
	BibKey: Abazov:2008qv
	BibTeX: '@Article{Abazov:2008qv,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of the electron charge asymmetry in $p \bar{p}
	\to W + X \to e \nu + X$ events at $\sqrt{s}$ = 1.96-TeV}",
	journal = "Phys. Rev. Lett.",
	volume = "101",
	year = "2008",
	pages = "211801",
	eprint = "0807.3367",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevLett.101.211801",
	SLACcitation = "%%CITATION = 0807.3367;%%"
	}'
	diff --git a/data/anainfo/D0_2008_S7863608.info b/data/anainfo/D0_2008_S7863608.info
	--- a/data/anainfo/D0_2008_S7863608.info
	+++ b/data/anainfo/D0_2008_S7863608.info
	@@ -1,46 +1,47 @@
	Name: D0_2008_S7863608
	Year: 2008
	Summary: Measurement of differential $Z/\gamma^*$ + jet + $X$ cross sections
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 7863608
	+InspireID: 792812
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Gavin Hesketh <gavin.hesketh@fnal.gov>
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Phys.Lett. B669 (2008) 278-286
	- doi:10.1016/j.physletb.2008.09.060
	- arXiv:0808.1296 [hep-ex]
	RunInfo:
	$p \bar{p} \to \mu^+ \mu^-$ + jets at 1960~GeV.
	Needs mass cut on lepton pair to avoid photon singularity,
	looser than $65 < m_{\mu\mu} < 115$ GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Cross sections as a function of pT and rapidity of the boson and pT
	and rapidity of the leading jet in the di-muon channel in
	$p \bar{p}$ collisions at $\sqrt{s}$ = 1.96
	TeV, based on an integrated luminosity of 1.0 fb$^{-1}$.
	NeedCrossSection: yes
	BibKey: Abazov:2008ez
	BibTeX: '@Article{Abazov:2008ez,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of differential $Z / \gamma^{*}$ + jet + $X$
	cross sections in $p \bar{p}$ collisions at $\sqrt{s}$ =
	1.96-TeV}",
	journal = "Phys. Lett.",
	volume = "B669",
	year = "2008",
	pages = "278-286",
	eprint = "0808.1296",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1016/j.physletb.2008.09.060",
	SLACcitation = "%%CITATION = 0808.1296;%%"
	}'
	diff --git a/data/anainfo/D0_2009_S8202443.info b/data/anainfo/D0_2009_S8202443.info
	--- a/data/anainfo/D0_2009_S8202443.info
	+++ b/data/anainfo/D0_2009_S8202443.info
	@@ -1,41 +1,42 @@
	Name: D0_2009_S8202443
	Year: 2009
	Summary: $Z/\gamma^*$ + jet + $X$ cross sections differential in pT(jet 1,2,3)
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 8202443
	+InspireID: 815094
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:0903.1748 [hep-ex]
	RunInfo:
	$p \bar{p} \to e^+ e^-$ + jets at 1960~GeV.
	Needs mass cut on lepton pair to avoid photon singularity,
	looser than $65 < m_{ee} < 115$ GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Cross sections as a function of pT of the three leading jets in
	$Z/\gamma^{*} (\to e^{+} e^{-})$ + jet + X production in $p \bar{p}$
	collisions at $\sqrt{s} = 1.96$ TeV, based on an integrated luminosity
	of 1.0 fb$^{-1}$.
	BibKey: Abazov:2009av
	BibTeX: '@Article{Abazov:2009av,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurements of differential cross sections of $Z
	/\gamma^\ast$+jets+X events in proton anti-proton
	collisions at $\sqrt{s}$=1.96 TeV}",
	journal = "Phys. Lett.",
	volume = "B678",
	year = "2009",
	pages = "45-54",
	eprint = "0903.1748",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1016/j.physletb.2009.05.058",
	SLACcitation = "%%CITATION = 0903.1748;%%"
	}'
	diff --git a/data/anainfo/D0_2009_S8320160.info b/data/anainfo/D0_2009_S8320160.info
	--- a/data/anainfo/D0_2009_S8320160.info
	+++ b/data/anainfo/D0_2009_S8320160.info
	@@ -1,38 +1,39 @@
	Name: D0_2009_S8320160
	Year: 2009
	Summary: Dijet angular distributions
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 8320160
	+InspireID: 824127
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:0906.4819 [hep-ex]
	RunInfo:
	$p \bar{p} \to$ jets at 1960 GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Dijet angular distributions in different bins of dijet mass from 0.25
	TeV to above 1.1 TeV in $p \bar{p}$ collisions at $\sqrt{s} = 1.96$ TeV,
	based on an integrated luminosity of 0.7 fb$^{-1}$.
	BibKey: :2009mh
	BibTeX: '@Article{:2009mh,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of dijet angular distributions at
	sqrt{s}=1.96TeV and searches for quark compositeness and
	extra spatial dimensions}",
	journal = "Phys. Rev. Lett.",
	volume = "103",
	year = "2009",
	pages = "191803",
	eprint = "0906.4819",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1103/PhysRevLett.103.191803",
	SLACcitation = "%%CITATION = 0906.4819;%%"
	}'
	diff --git a/data/anainfo/D0_2009_S8349509.info b/data/anainfo/D0_2009_S8349509.info
	--- a/data/anainfo/D0_2009_S8349509.info
	+++ b/data/anainfo/D0_2009_S8349509.info
	@@ -1,49 +1,50 @@
	Name: D0_2009_S8349509
	Year: 2009
	Summary: Z+jets angular distributions
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 8349509
	+InspireID: 826756
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:0907.4286 [hep-ex]
	RunInfo:
	$p \bar{p} \to \mu^+ \mu^-$ + jets at 1960~GeV.
	Needs mass cut on lepton pair to avoid photon singularity,
	looser than $65 < m_{ee} < 115$ GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	First measurements at a hadron collider of differential cross
	sections for $Z (\to \mu\mu)$+jet+X production in $\Delta\phi(Z, j)$,
	$\|\Delta y(Z, j)\|$ and $\|y_\mathrm{boost}(Z, j)\|$.
	Vector boson production in association with jets is an excellent
	probe of QCD and constitutes the main background to many small
	cross section processes, such as associated Higgs production.
	These measurements are crucial tests of the predictions of perturbative
	QCD and current event generators, which have varied success in
	describing the data.
	Using these measurements as inputs in tuning event generators will
	increase the experimental sensitivity to rare signals.
	NeedCrossSection: yes
	BibKey: Abazov:2009pp
	BibTeX: '@Article{Abazov:2009pp,
	author = "Abazov, Victor Mukhamedovich and others",
	collaboration = "D0",
	title = "{Measurement of $Z / \gamma^\ast +jet+X$ angular
	distributions in $p \bar{p}$ collisions at $\sqrt{s}=1.96$
	TeV}",
	journal = "Phys. Lett.",
	volume = "B682",
	year = "2010",
	pages = "370-380",
	eprint = "0907.4286",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	doi = "10.1016/j.physletb.2009.11.012",
	SLACcitation = "%%CITATION = 0907.4286;%%"
	}'
	diff --git a/data/anainfo/D0_2010_S8566488.info b/data/anainfo/D0_2010_S8566488.info
	--- a/data/anainfo/D0_2010_S8566488.info
	+++ b/data/anainfo/D0_2010_S8566488.info
	@@ -1,37 +1,38 @@
	Name: D0_2010_S8566488
	Year: 2010
	Summary: Dijet invariant mass
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 8566488
	+InspireID: 846483
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:1002.4594
	RunInfo:
	$p \bar{p} \to$ jets at 1960 GeV. Analysis needs two hard jets above 40 GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [30]
	Description:
	The inclusive dijet production double differential cross section as a
	function of the dijet invariant mass and of the largest absolute rapidity
	($\|y\|_\text{max}$) of the two jets with the largest transverse momentum in an
	event is measured using 0.7 fb$^{-1}$ of data.
	The measurement is performed in six rapidity regions up to
	$\|y\|_\text{max}=2.4$.
	NeedCrossSection: yes
	BibKey: Abazov:2010fr
	BibTeX: '@Article{Abazov:2010fr,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of the dijet invariant mass cross section in
	$p\overline{p}$ collisions at $\sqrt{s} =$ 1.96 TeV}",
	year = "2010",
	eprint = "1002.4594",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1002.4594;%%"
	}'
	diff --git a/data/anainfo/D0_2010_S8570965.info b/data/anainfo/D0_2010_S8570965.info
	--- a/data/anainfo/D0_2010_S8570965.info
	+++ b/data/anainfo/D0_2010_S8570965.info
	@@ -1,43 +1,44 @@
	Name: D0_2010_S8570965
	Year: 2010
	Summary: Direct photon pair production
	Experiment: CDF
	Collider: Tevatron Run 2
	SpiresID: 8570965
	+InspireID: 846997
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:1002.4917
	RunInfo:
	All processes that can produce prompt photon pairs, e.g. $jj \to jj$,
	$jj \to j\gamma$ and $jj \to \gamma \gamma$.
	Non-prompt photons from hadron decays like $\pi$ and $\eta$ have been
	corrected for.
	NumEvents: 10000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Direct photon pair production cross sections are measured using 4.2 fb$^{-1}$
	of data. They are binned in diphoton mass, the transverse momentum of the
	diphoton system, the azimuthal angle between the photons, and the polar
	scattering angle of the photons. Also available are double differential cross
	sections considering the last three kinematic variables in three diphoton
	mass bins.
	Note, the numbers in version 1 of the arXiv preprint were missing the dM
	normalisation in the double differential cross sections. This has been
	reported to and fixed by the authors in v2 and the journal submission.
	HepData as well as the Rivet analysis have also been updated.
	NeedCrossSection: yes
	BibKey: Abazov:2010ah
	BibTeX: '@Article{Abazov:2010ah,
	author = "Abazov, V. M. and others",
	collaboration = "D0",
	title = "{Measurement of direct photon pair production cross sections in $p \bar{p}$ collisions at $\sqrt{s} = 1.96$ TeV}",
	year = "2010",
	eprint = "1002.4917",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1002.4917;%%"
	}'
	diff --git a/data/anainfo/D0_2010_S8671338.info b/data/anainfo/D0_2010_S8671338.info
	--- a/data/anainfo/D0_2010_S8671338.info
	+++ b/data/anainfo/D0_2010_S8671338.info
	@@ -1,42 +1,43 @@
	Name: D0_2010_S8671338
	Year: 2010
	Summary: Measurement of differential $Z/\gamma^*$ pT
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 8671338
	+InspireID: 856972
	Status: VALIDATED
	Authors:
	- Flavia Dias <fladias@gmail.com>
	- Gavin Hesketh <gavin.hesketh@cern.ch>
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:1006.0618 [hep-ex]
	RunInfo:
	$p \bar{p} \to \mu^+ \mu^-$ + jets at 1960~GeV.
	Needs mass cut on lepton pair to avoid photon singularity,
	looser than $65 < m_{\mu\mu} < 115$ GeV.
	Restrict $Z/\gamma^*$ mass range to roughly $50~\text{GeV}/c^2 < m_{\mu\mu}
	< 120~\text{GeV}/c^2$ for efficiency.
	Weighted events and kinematic sampling enhancement can help to fill the pT tail.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	PtCuts: [0]
	Description:
	Cross section as a function of pT of the Z boson decaying into muons
	in $p \bar{p}$ collisions at $\sqrt{s}$ = 1.96
	TeV, based on an integrated luminosity of 0.97 fb$^{-1}$.
	NeedCrossSection: yes
	BibKey: Abazov:2010kn
	BibTeX: '@Article{Abazov:2010kn,
	author = "Abazov, Victor Mukhamedovich and others",
	collaboration = "D0",
	title = "{Measurement of the normalized $Z/\gamma^*\to \mu^+\mu^-$
	transverse momentum distribution in $p\bar{p}$ collisions
	at $\sqrt{s}=1.96$ TeV}",
	year = "2010",
	eprint = "1006.0618",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1006.0618;%%"
	}'
	diff --git a/data/anainfo/D0_2010_S8821313.info b/data/anainfo/D0_2010_S8821313.info
	--- a/data/anainfo/D0_2010_S8821313.info
	+++ b/data/anainfo/D0_2010_S8821313.info
	@@ -1,37 +1,38 @@
	Name: D0_2010_S8821313
	Year: 2010
	Summary: Precise study of Z pT using novel technique
	Experiment: D0
	Collider: Tevatron Run 2
	SpiresID: 8821313
	+InspireID: 871787
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- arXiv:1010.0262
	RunInfo:
	Inclusive $Z/\gamma^*$ production in both electron and muon channels.
	Cut on invariant lepton mass should be wider than $70 < m_{\ell\ell} < 110$ GeV.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1960]
	Description:
	Using 7.3 pb$^{-1}$ the distribution of the variable $\phi^*$ is measured, which
	probes the same physical effects as the $Z/\gamma^*$ boson transverse
	momentum, but is less susceptible to the effects of experimental resolution
	and efficiency. Results are presented for both the di-electron and di-muon
	channel.
	BibKey: Abazov:2010mk
	BibTeX: '@Article{Abazov:2010mk,
	author = "Abazov, Victor Mukhamedovich and others",
	collaboration = "D0",
	title = "{Precise study of the Z/gamma* boson transverse momentum
	distribution in ppbar collisions using a novel technique}",
	year = "2010",
	eprint = "1010.0262",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	SLACcitation = "%%CITATION = 1010.0262;%%"
	}'
	ToDo:

	diff --git a/data/anainfo/D0_2015_I1324946.info b/data/anainfo/D0_2015_I1324946.info
	--- a/data/anainfo/D0_2015_I1324946.info
	+++ b/data/anainfo/D0_2015_I1324946.info
	@@ -1,46 +1,43 @@
	Name: D0_2015_I1324946
	Year: 2015
	Summary: D0 measurement of the $\phi^*$ distribution of muon pairs with masses between 30 and 500 GeV in 10.4 fbâ1
	Experiment: D0
	Collider: Tevatron
	InspireID: 1324946
	Status: VALIDATED
	Authors:
	- Simone Amoroso <amoroso@cern.ch>
	References:
	- Phys.Rev. D91 (2015) 072002
	- doi:10.1103/PhysRevD.91.072002
	- - arXiv:hep-ex/1410.8052
	+ - arXiv:hep-ex/1410.8052
	RunInfo: $Z/\gamma^*$ production with decays to muons.
	NumEvents: 1000000
	NeedCrossSection: no
	Beams: [p-,p+]
	Energies: [1960]
	NeedCrossSection: True
	Description:
	'D0 measurement of the distribution of the variable $\phi^*$ for muon pairs with masses between 30 and 500 GeV,
	using the complete run II data set collected at the Tevatron proton-antiproton collider.
	This corresponds to an integrated luminosity of 10.4ââfbâ1 at \sqrt{s}=1.96âTeV.
	The data are corrected for detector effects and presented in bins of dimuon rapidity and mass.'
	BibKey: Abazov:2014mza
	BibTeX: '@article{Abazov:2014mza,
	author = "Abazov, Victor Mukhamedovich and others",
	title = "{Measurement of the $\phi^*_\eta$ distribution of muon
	pairs with masses between 30 and 500 GeV in 10.4 fb$^{-1}$
	of $p\bar{p}$ collisions}",
	collaboration = "D0",
	journal = "Phys.Rev.",
	number = "7",
	volume = "D91",
	pages = "072002",
	doi = "10.1103/PhysRevD.91.072002",
	year = "2015",
	eprint = "1410.8052",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "FERMILAB-PUB-14-430-E",
	SLACcitation = "%%CITATION = ARXIV:1410.8052;%%",
	}'
	-ToDo:
	- - Implement the analysis, test it, remove this ToDo, and mark as VALIDATED :-)
	-
	diff --git a/data/anainfo/DELPHI_1995_S3137023.info b/data/anainfo/DELPHI_1995_S3137023.info
	--- a/data/anainfo/DELPHI_1995_S3137023.info
	+++ b/data/anainfo/DELPHI_1995_S3137023.info
	@@ -1,34 +1,35 @@
	Name: DELPHI_1995_S3137023
	Year: 1995
	Summary: Strange baryon production in $Z$ hadronic decays at Delphi
	Experiment: DELPHI
	Collider: LEP 1
	SpiresID: 3137023
	+InspireID: 394716
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Z. Phys. C, 67, 543--554 (1995)
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Measurement of the $\Xi^-$ and $\Sigma^+(1385)/\Sigma^-(1385)$ scaled
	momentum distributions by DELPHI at LEP 1. The paper also has the
	production cross-sections of these particles, but that's not
	implemented in Rivet.
	BibKey: Abreu:1995qx
	BibTeX: '@Article{Abreu:1995qx,
	author = "Abreu, P. and others",
	collaboration = "DELPHI",
	title = "{Strange baryon production in Z hadronic decays}",
	journal = "Z. Phys.",
	volume = "C67",
	year = "1995",
	pages = "543-554",
	doi = "10.1007/BF01553980",
	SLACcitation = "%%CITATION = ZEPYA,C67,543;%%"
	}'
	diff --git a/data/anainfo/DELPHI_1996_S3430090.info b/data/anainfo/DELPHI_1996_S3430090.info
	--- a/data/anainfo/DELPHI_1996_S3430090.info
	+++ b/data/anainfo/DELPHI_1996_S3430090.info
	@@ -1,40 +1,41 @@
	Name: DELPHI_1996_S3430090
	Year: 1996
	Summary: Delphi MC tuning on event shapes and identified particles.
	Experiment: DELPHI
	Collider: LEP 1
	SpiresID: 3430090
	+InspireID: 424112
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Z.Phys.C73:11-60,1996
	- doi:10.1007/s002880050295
	RunInfo:
	$\sqrt{s} = 91.2$ GeV, $e^+ e^- -> Z^0$ production with hadronic decays only
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Event shape and charged particle inclusive distributions measured
	using 750000 decays of Z bosons to hadrons from the DELPHI detector at
	LEP. This data, combined with identified particle distributions from
	all LEP experiments, was used for tuning of shower-hadronisation event
	generators by the original PROFESSOR method. This is a critical
	analysis for MC event generator tuning of final state radiation and
	both flavour and kinematic aspects of hadronisation models.
	BibKey: Abreu:1996na
	BibTeX: '@Article{Abreu:1996na,
	author = "Abreu, P. and others",
	collaboration = "DELPHI",
	title = "{Tuning and test of fragmentation models based on
	identified particles and precision event shape data}",
	journal = "Z. Phys.",
	volume = "C73",
	year = "1996",
	pages = "11-60",
	doi = "10.1007/s002880050295",
	SLACcitation = "%%CITATION = ZEPYA,C73,11;%%"
	}'
	diff --git a/data/anainfo/DELPHI_1999_S3960137.info b/data/anainfo/DELPHI_1999_S3960137.info
	--- a/data/anainfo/DELPHI_1999_S3960137.info
	+++ b/data/anainfo/DELPHI_1999_S3960137.info
	@@ -1,33 +1,34 @@
	Name: DELPHI_1999_S3960137
	Year: 1999
	Summary: Measurement of inclusive $\rho^0$, $f_0(980)$, $f_2(1270)$, $K^{*0}_2(1430)$ and $f'_2(1525)$ production in $Z^0$ decays
	Experiment: DELPHI
	Collider: LEP 1
	SpiresID: 3960137
	+InspireID: 482816
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Lett.B449:364-382,1999
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: DELPHI results for the production of $\rho^0$, $f_0(980)$, $f_2(1270)$, $K^{*0}_2(1430)$
	and $f'_2(1525)$ in $Z^0$ decays. Only the identified particle spectra for
	$\rho^0$, $f_0(980)$ and $f_2(1270)$ are implemented.
	BibKey: Abreu:1998nn
	BibTeX: '@Article{Abreu:1998nn,
	author = "Abreu, P. and others",
	collaboration = "DELPHI",
	title = "{Measurement of inclusive $\rho^0$, $f^0(980)$, $f_2(1270)$,
	$K^{*0}_2(1430)$ and $f^\prime_2(1525)$ production in $Z^0$ decays}",
	journal = "Phys. Lett.",
	volume = "B449",
	year = "1999",
	pages = "364-382",
	doi = "10.1016/S0370-2693(99)00105-7",
	SLACcitation = "%%CITATION = PHLTA,B449,364;%%"
	}'
	diff --git a/data/anainfo/DELPHI_2000_S4328825.info b/data/anainfo/DELPHI_2000_S4328825.info
	--- a/data/anainfo/DELPHI_2000_S4328825.info
	+++ b/data/anainfo/DELPHI_2000_S4328825.info
	@@ -1,38 +1,39 @@
	Name: DELPHI_2000_S4328825
	Year: 2000
	Summary: Hadronization properties of $b$ quarks compared to light quarks in $e^+ e^-\to q \bar{q}$ from 183\;GeV to 200\;GeV
	Experiment: OPAL
	Collider: LEP 2
	SpiresID: 4328825
	+InspireID: 524693
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Lett.B479:118-128,2000
	- hep-ex/0103022
	- DELPHI 2002-052 CONF 586
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$\;GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [183,189,192,196,200,206]
	PtCuts: [0]
	Description: Measurements of the mean charged multiplicities separately for $b\bar b$,
	$c\bar{c}$ and light quark ($uds$) initiated events in $e^+e^-$ interactions at energies
	above the $Z^0$ mass. In addition to the energy points in the original paper
	one additional point at 206;GeV is included from a later preliminary result.
	BibKey: Abreu:2000nt
	BibTeX: '@Article{Abreu:2000nt,
	author = "Abreu, P. and others",
	collaboration = "DELPHI",
	title = "{Hadronization properties of b quarks compared to light
	quarks in $e^+ e^- \to q \bar{q}$ from 183\;GeV to 200\;GeV}",
	journal = "Phys. Lett.",
	volume = "B479",
	year = "2000",
	pages = "118-128",
	eprint = "hep-ex/0103022",
	archivePrefix = "arXiv",
	doi = "10.1016/S0370-2693(00)00312-9",
	SLACcitation = "%%CITATION = HEP-EX/0103022;%%"
	}'
	diff --git a/data/anainfo/DELPHI_2002_069_CONF_603.info b/data/anainfo/DELPHI_2002_069_CONF_603.info
	--- a/data/anainfo/DELPHI_2002_069_CONF_603.info
	+++ b/data/anainfo/DELPHI_2002_069_CONF_603.info
	@@ -1,22 +1,23 @@
	Name: DELPHI_2002_069_CONF_603
	Year: 2002 (note)
	Summary: Study of the b-quark fragmentation function at LEP 1
	Experiment: DELPHI
	Collider: LEP 1
	-Status: PRELIMINARY
	+Status: OBSOLETE
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- DELPHI note 2002-069-CONF-603 (ICHEP 2002)
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Measurement of the $b$-quark fragmentation function by DELPHI using 1994
	LEP 1 data. The fragmentation function for both weakly decaying and
	primary $b$-quarks has been determined in a model independent way.
	Nevertheless the authors trust $f(x_B^\text{weak})$ more than
	- $f(x_B^\text{prim})$.
	+ $f(x_B^\text{prim})$. Note --- this analysis is superseded by
	+ DELPHI_2011_I890503.
	diff --git a/data/anainfo/DELPHI_2011_I890503.info b/data/anainfo/DELPHI_2011_I890503.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/DELPHI_2011_I890503.info
	@@ -0,0 +1,40 @@
	+Name: DELPHI_2011_I890503
	+Year: 2011
	+Summary: Study of the b-quark fragmentation function at LEP 1
	+Experiment: DELPHI
	+Collider: LEP1
	+InspireID: 890503
	+Status: VALIDATED
	+Authors:
	+ - Holger Schulz <holger.schulz@cern.ch>
	+References:
	+ - 10.1140/epjc/s10052-011-1557-x
	+RunInfo:
	+ Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	+NumEvents: 1000000
	+Beams: [e+, e-]
	+Energies: [91.2]
	+PtCuts: [0]
	+Description:
	+ Measurement of the $b$-quark fragmentation function by DELPHI using 1994
	+ LEP 1 data. The fragmentation function for weakly decaying $b$-quarks has
	+ been determined in a model independent way. Note --- this analysis
	+ supersedes DELPHI_2002_069_CONF_603.
	+BibKey: DELPHI:2011aa
	+BibTeX: '@article{DELPHI:2011aa,
	+ author = "Abdallah, J. and others",
	+ title = "{A study of the b-quark fragmentation function with the
	+ DELPHI detector at LEP I and an averaged distribution
	+ obtained at the Z Pole}",
	+ collaboration = "DELPHI",
	+ journal = "Eur. Phys. J.",
	+ volume = "C71",
	+ year = "2011",
	+ pages = "1557",
	+ doi = "10.1140/epjc/s10052-011-1557-x",
	+ eprint = "1102.4748",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2010-057",
	+ SLACcitation = "%%CITATION = ARXIV:1102.4748;%%"
	+}'
	diff --git a/data/anainfo/E735_1998_S3905616.info b/data/anainfo/E735_1998_S3905616.info
	--- a/data/anainfo/E735_1998_S3905616.info
	+++ b/data/anainfo/E735_1998_S3905616.info
	@@ -1,35 +1,37 @@
	Name: E735_1998_S3905616
	Year: 1998
	-Summary: Charged particle multiplicity in ppbar collisions at $\sqrt{s} = 1.8\;\TeV$
	+Summary: Charged particle multiplicity in $p\bar{p}$ collisions at $\sqrt{s} = 1.8\;\TeV$
	Experiment: E735
	Collider: Tevatron
	SpiresID: 3905616
	+InspireID: 480349
	+InspireID: 480349
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Phys.Lett.B435:453-457,1998
	RunInfo: QCD events, diffractive processes need to be switched
	on in order to fill the low multiplicity regions. The measurement was done in
	$\|\eta\| \lesssim 3.25$ and was extrapolated to full phase space. However, the method of
	extrapolation remains unclear.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [1800]
	PtCuts: [0]
	Description:
	A measurement of the charged multiplicity distribution at $\sqrt{s} = 1.8\;\TeV$. The
	analysis is reproduced to the best of abilities. There is no theory curve in the paper
	to compare to.
	BibKey: Alexopoulos:1998bi
	BibTeX: '@Article{Alexopoulos:1998bi,
	author = "Alexopoulos, T. and others",
	title = "{The role of double parton collisions in soft hadron interactions}",
	journal = "Phys. Lett.",
	volume = "B435",
	year = "1998",
	pages = "453-457",
	doi = "10.1016/S0370-2693(98)00921-6",
	SLACcitation = "%%CITATION = PHLTA,B435,453;%%"
	}'
	diff --git a/data/anainfo/H1_1994_S2919893.info b/data/anainfo/H1_1994_S2919893.info
	--- a/data/anainfo/H1_1994_S2919893.info
	+++ b/data/anainfo/H1_1994_S2919893.info
	@@ -1,40 +1,41 @@
	Name: H1_1994_S2919893
	Year: 1994
	Summary: H1 energy flow and charged particle spectra in DIS
	Experiment: H1
	Collider: HERA
	SpiresID: 2919893
	+InspireID: 372350
	Status: VALIDATED
	Authors:
	- Peter Richardson <peter.richardson@durham.ac.uk>
	References:
	- Z.Phys.C63:377-390,1994
	- doi:10.1007/BF01580319
	RunInfo:
	$e^- p$ / $e^+ p$ deep inelastic scattering,
	820~GeV protons colliding with 26.7~GeV electrons
	NumEvents: 1000000
	Beams: [[p+, e-], [p+, e+]]
	Energies: [[820, 26.7]]
	PtCuts: [0]
	Description:
	Global properties of the hadronic final state in deep inelastic
	scattering events at HERA are investigated. The data are corrected for
	detector effects. Energy flows in both the laboratory frame and the
	hadronic centre of mass system, and energy-energy correlations in the
	laboratory frame are presented. Historically, the Ariadne colour
	dipole model provided the only satisfactory description of this data,
	hence making it a useful 'target' analysis for MC shower models.
	BibKey: Abt:1994ye
	BibTeX: '@Article{Abt:1994ye,
	author = "Abt, I. and others",
	collaboration = "H1",
	title = "{Energy flow and charged particle spectrum in deep
	inelastic scattering at HERA}",
	journal = "Z. Phys.",
	volume = "C63",
	year = "1994",
	pages = "377-390",
	doi = "10.1007/BF01580319",
	SLACcitation = "%%CITATION = ZEPYA,C63,377;%%"
	}'
	diff --git a/data/anainfo/H1_1995_S3167097.info b/data/anainfo/H1_1995_S3167097.info
	--- a/data/anainfo/H1_1995_S3167097.info
	+++ b/data/anainfo/H1_1995_S3167097.info
	@@ -1,42 +1,43 @@
	Name: H1_1995_S3167097
	Year: 1995
	Summary: Transverse energy and forward jet production in the low-$x$ regime at H1
	Experiment: H1
	Collider: HERA Run I
	SpiresID: 3167097
	+InspireID: 396365
	Status: UNVALIDATED
	Authors:
	- Leif Lonnblad <leif.lonnblad@thep.lu.se>
	References:
	- Phys.Lett.B356:118,1995
	- hep-ex/9506012
	RunInfo:
	820~GeV protons colliding with 26.7~GeV electrons.
	DIS events with an outgoing electron energy $> 12~\text{GeV}$.
	$5~\text{GeV}^2 < Q^2 < 100~\text{GeV}^2$, $10^{-4} < x < 10^{-2}$.
	NumEvents: 1000000
	Beams: [p+, e-]
	Energies: [[820, 26.7]]
	PtCuts: [0]
	Description:
	DIS events at low $x$ may be sensitive to new QCD dynamics such as BFKL
	or CCFM radiation. In particular, BFKL is expected to produce more
	radiation at high transverse energy in the rapidity span between the
	proton remnant and the struck quark jet. Performing a transverse
	energy sum in bins of $x$ and $\eta$ may distinguish between DGLAP and
	BFKL evolution.
	BibKey: Aid:1995we
	BibTeX: '@Article{Aid:1995we,
	author = "Aid, S. and others",
	collaboration = "H1",
	title = "{Transverse energy and forward jet production in the low x
	regime at HERA}",
	journal = "Phys. Lett.",
	volume = "B356",
	year = "1995",
	pages = "118-128",
	eprint = "hep-ex/9506012",
	archivePrefix = "arXiv",
	doi = "10.1016/0370-2693(95)00804-T",
	SLACcitation = "%%CITATION = HEP-EX/9506012;%%"
	}'
	diff --git a/data/anainfo/H1_2000_S4129130.info b/data/anainfo/H1_2000_S4129130.info
	--- a/data/anainfo/H1_2000_S4129130.info
	+++ b/data/anainfo/H1_2000_S4129130.info
	@@ -1,48 +1,49 @@
	Name: H1_2000_S4129130
	Year: 2000
	Summary: H1 energy flow in DIS
	Experiment: H1
	Collider: HERA
	SpiresID: 4129130
	+InspireID: 503947
	Status: VALIDATED
	Authors:
	- Peter Richardson <peter.richardson@durham.ac.uk>
	References:
	- Eur.Phys.J.C12:595-607,2000
	- doi:10.1007/s100520000287
	- arXiv:hep-ex/9907027v1
	RunInfo:
	$e^+ p$ deep inelastic scattering with $p$ at 820\;GeV,
	$e^+$ at 27.5 GeV \to $\sqrt{s} = 300\;\GeV$
	NumEvents: 1000000
	Beams: [p+, e+]
	Energies: [[820, 27.5]]
	PtCuts: [0]
	Description:
	Measurements of transverse energy flow for neutral current deep-
	inelastic scattering events produced in positron-proton collisions at
	HERA. The kinematic range covers squared momentum transfers $Q^2$ from
	3.2 to 2200 GeV$^2$; the Bjorken scaling variable $x$ from $8 \times 10^{-5}$ to
	0.11 and the hadronic mass $W$ from 66 to 233 GeV. The transverse
	energy flow is measured in the hadronic centre of mass frame and is
	studied as a function of $Q^2$, $x$, $W$ and pseudorapidity. The
	behaviour of the mean transverse energy in the central pseudorapidity
	region and an interval corresponding to the photon fragmentation
	region are analysed as a function of $Q^2$ and $W$. This analysis is
	useful for exploring the effect of photon PDFs and for tuning models
	of parton evolution and treatment of fragmentation and the proton
	remnant in DIS.
	BibKey: Adloff:1999ws
	BibTeX: '@Article{Adloff:1999ws,
	author = "Adloff, C. and others",
	collaboration = "H1",
	title = "{Measurements of transverse energy flow in deep inelastic-scattering at HERA}",
	journal = "Eur. Phys. J.",
	volume = "C12",
	year = "2000",
	pages = "595-607",
	eprint = "hep-ex/9907027",
	archivePrefix = "arXiv",
	doi = "10.1007/s100520000287",
	SLACcitation = "%%CITATION = HEP-EX/9907027;%%"
	}'
	diff --git a/data/anainfo/JADE_1998_S3612880.info b/data/anainfo/JADE_1998_S3612880.info
	--- a/data/anainfo/JADE_1998_S3612880.info
	+++ b/data/anainfo/JADE_1998_S3612880.info
	@@ -1,39 +1,40 @@
	Name: JADE_1998_S3612880
	Year: 1998
	Summary: Event shapes for 22, 35 and 44 GeV
	Experiment: JADE
	Collider: PETRA
	SpiresID: 3612880
	+InspireID: 447560
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	References:
	- arXiv:hep-ex/9708034
	- Eur.Phys.J.C1:461-478,1998
	RunInfo:
	Z->hadronic final states, bbar contributions have been corrected for as well as ISR
	NumEvents: 1000000
	Beams: [e-, e+]
	Energies: [22, 35,44]
	PtCuts: Use an inv. mass cut close to sqrt{s} to avoid photon cotribution (e.g. CKIN(1))
	Description:
	Thrust, Jet Mass and Broadenings, Y23 for 35 and 44 GeV and only Y23 at 22 GeV.
	BibKey: MovillaFernandez:1997fr
	BibTeX: '@Article{MovillaFernandez:1997fr,
	author = "Movilla Fernandez, P. A. and Biebel, O. and Bethke, S. and
	Kluth, S. and Pfeifenschneider, P.",
	collaboration = "JADE",
	title = "{A study of event shapes and determinations of $\alpha_s$
	using data of $e^+ e^-$ annihilations at $\sqrt{s} =$ 22 GeV to
	44 GeV}",
	journal = "Eur. Phys. J.",
	volume = "C1",
	year = "1998",
	pages = "461-478",
	eprint = "hep-ex/9708034",
	archivePrefix = "arXiv",
	doi = "10.1007/s100520050096",
	SLACcitation = "%%CITATION = HEP-EX/9708034;%%"
	}'
	ToDo:
	- Trigger conditions?
	diff --git a/data/anainfo/JADE_OPAL_2000_S4300807.info b/data/anainfo/JADE_OPAL_2000_S4300807.info
	--- a/data/anainfo/JADE_OPAL_2000_S4300807.info
	+++ b/data/anainfo/JADE_OPAL_2000_S4300807.info
	@@ -1,42 +1,43 @@
	Name: JADE_OPAL_2000_S4300807
	Year: 2000
	Summary: Jet rates in $e^+e^-$ at JADE [35--44 GeV] and OPAL [91--189 GeV].
	Experiment: JADE_OPAL
	Collider: PETRA and LEP
	SpiresID: 4300807
	+InspireID: 513337
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Eur.Phys.J.C17:19-51,2000
	- arXiv:hep-ex/0001055
	RunInfo:
	$e^+ e^- \to$ jet jet (+ jets)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [35, 44, 91.2, 133, 161, 172, 183, 189]
	PtCuts: [0]
	Description:
	'Differential and integrated jet rates for Durham and JADE jet algorithms.

	The integration cut value used for the integrated rate observables is not
	well-defined in the paper: the midpoint of the differential bin has been used
	thanks to information from Stefan Kluth and Christoph Pahl. We anyway
	recommend that the differential plots be preferred over the integrated ones
	for MC generator validation and tuning, to minimise correlations.'
	BibKey: Pfeifenschneider:1999rz
	BibTeX: '@Article{Pfeifenschneider:1999rz,
	author = "Pfeifenschneider, P. and others",
	collaboration = "JADE",
	title = "{QCD analyses and determinations of alpha(s) in e+ e-
	annihilation at energies between 35-GeV and 189-GeV}",
	journal = "Eur. Phys. J.",
	volume = "C17",
	year = "2000",
	pages = "19-51",
	eprint = "hep-ex/0001055",
	archivePrefix = "arXiv",
	doi = "10.1007/s100520000432",
	SLACcitation = "%%CITATION = HEP-EX/0001055;%%"
	}'
	diff --git a/data/anainfo/L3_1992_I336180.info b/data/anainfo/L3_1992_I336180.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/L3_1992_I336180.info
	@@ -0,0 +1,31 @@
	+Name: L3_1992_I336180
	+Year: 1992
	+Summary: Measurement of inclusive eta production in hadronic decays of the Z0
	+Experiment: L3
	+Collider: LEP
	+InspireID: 336180
	+Status: VALIDATED
	+Authors:
	+ - Simone Amoroso <amoroso@cern.ch>
	+References:
	+ - Phys.Lett. B286 (1992) 403-412
	+ - doi:10.1016/0370-2693(92)91795-B
	+RunInfo: electron positron collisions at the Z0 peak, with hadronic decays.
	+Beams: [e+,e-]
	+Energies: [91.2]
	+Description: L3 measurement of the inclusive momentum distribution of the eta meson in hadronic decays of the Z0
	+ normalized to the total hadronic cross-section.
	+BibKey: Adriani:1992hd
	+BibTeX: '@article{Adriani:1992hd,
	+ author = "Adriani, O. and others",
	+ title = "{Measurement of inclusive eta production in hadronic
	+ decays of the Z0}",
	+ collaboration = "L3",
	+ journal = "Phys. Lett.",
	+ volume = "B286",
	+ year = "1992",
	+ pages = "403-412",
	+ doi = "10.1016/0370-2693(92)91795-B",
	+ reportNumber = "CERN-PPE-92-083, CERN-PPE-92-83",
	+ SLACcitation = "%%CITATION = PHLTA,B286,403;%%"
	+}'
	diff --git a/data/anainfo/L3_2004_I652683.info b/data/anainfo/L3_2004_I652683.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/L3_2004_I652683.info
	@@ -0,0 +1,36 @@
	+Name: L3_2004_I652683
	+Year: 2004
	+Summary: Jet rates and event shapes at LEP I+II
	+Experiment: L3
	+Collider: LEP I+II
	+InspireID: 652683
	+Status: VALIDATED
	+Authors:
	+ - Adil Jueid <adil.hep@gmail.com>
	+References:
	+- 'Phys.Rept. 399 (2004) 71-174'
	+- '10.1016/j.physrep.2004.07.002'
	+- 'http://arxiv.org/abs/hep-ex/0406049'
	+RunInfo: $e^+ e^- \to q \bar{q}$
	+NumEvents: 1000000
	+Beams: [e+, e-]
	+Energies: [41.4, 55.3, 65.4, 75.7, 82.3, 85.1, 91.2, 130.1, 136.1, 161.3, 172.3, 182.8, 188.6, 194.4, 200.2, 206.2]
	+NeedCrossSection: no
	+Description: Event shapes, charged particle multiplicity and scaled momentum distribution at the Z-boson peak.
	+BibKey: Achard:2004sv
	+BibTeX: '@article{Achard:2004sv,
	+ author = "Achard, P. and others",
	+ title = "{Studies of hadronic event structure in $e^{+} e^{-}$
	+ annihilation from 30-GeV to 209-GeV with the L3 detector}",
	+ collaboration = "L3",
	+ journal = "Phys. Rept.",
	+ volume = "399",
	+ year = "2004",
	+ pages = "71-174",
	+ doi = "10.1016/j.physrep.2004.07.002",
	+ eprint = "hep-ex/0406049",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-PH-EP-2004-024, CERN-EP-PH-2004-024",
	+ SLACcitation = "%%CITATION = HEP-EX/0406049;%%"
	+}'
	diff --git a/data/anainfo/LHCB_2010_S8758301.info b/data/anainfo/LHCB_2010_S8758301.info
	--- a/data/anainfo/LHCB_2010_S8758301.info
	+++ b/data/anainfo/LHCB_2010_S8758301.info
	@@ -1,42 +1,43 @@
	Name: LHCB_2010_S8758301
	Year: 2010
	Summary: LHCb differential cross section measurement of prompt $K^0_S$ production in three
	rapidity windows at $\sqrt{s} = 0.9$ TeV
	Experiment: LHCB
	Collider: LHC 900 GeV
	SpiresID: 8758301
	+InspireID: 865584
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	- Alex Grecu <Alex.Grecu@cern.ch>
	References:
	- Phys.Lett.B693:69-80,2010
	- arXiv:1008.3105[hep-ex]
	RunInfo:
	QCD events. See paper for MC discussion.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [900]
	PtCuts: [0, 1.6]
	Description:
	The paper presents the cross-section and double differential cross-section measurement
	for prompt $K^0_S$ production in pp collisions at $\sqrt{s} = 0.9\;TeV$. The data were taken
	during the LHCb run in December 2009 and cover a transversal momentum range from 0 to 1.6 GeV/c.
	The differential production cross-section is calculated for three rapidity windows
	$2.5 < y < 3.0$, $3.0 < y < 3.5$ and $3.5 < y < 4.0$ as well as the whole rapidity domain
	$2.5 < y < 4.0$.
	BibKey: Aaij:2010nx
	BibTeX: '@Article{Aaij:2010nx,
	author = "Aaij, R and others",
	collaboration = "LHCb",
	title = "{Prompt $K_s$ production in $pp$ collisions at $\sqrt{s} = 0.9\;\TeV$}",
	journal = "Phys. Lett.",
	volume = "B693",
	year = "2010",
	pages = "69-80",
	eprint = "1008.3105",
	archivePrefix = "arXiv",
	primaryClass = "Unknown",
	doi = "10.1016/j.physletb.2010.08.055",
	SLACcitation = "%%CITATION = 1008.3105;%%"
	}'
	diff --git a/data/anainfo/LHCB_2011_I919315.info b/data/anainfo/LHCB_2011_I919315.info
	--- a/data/anainfo/LHCB_2011_I919315.info
	+++ b/data/anainfo/LHCB_2011_I919315.info
	@@ -1,39 +1,39 @@
	Name: LHCB_2011_I919315
	Year: 2011
	Summary: Inclusive differential $\Phi$ production cross-section as a function of $p_\text{T}$ and $y$
	Experiment: LHCB
	Collider: LHC
	InspireID: 919315
	Status: VALIDATED
	Authors:
	- Friederike Blatt <friederike.blatt@tu-dortmund.de>
	- Michael Kaballo <michael.kaballo@tu-dortmund.de>
	- - Till Moritz Karbach <moritz.karbach@tu-dortmund.de>
	+ - Till Moritz Karbach
	References:
	- Phys.Lett.B703:267-273,2011
	- arXiv:1107.3935 [hep-ex]
	RunInfo:
	$pp$ collisions, QCD-Events, $\sqrt{s}=7$TeV
	Beams: [p+, p+]
	Energies: [7000]
	Description:
	'Measurement of the inclusive differential $\Phi$ cross-section in $pp$
	collisions at $\sqrt {s}=7$TeV in the rapidity range of
	$ 2.44 < y < 4.06$ and the $p_\text{T}$ range of
	0.6 GeV/c $< p_\text{T} <$ 5.0 GeV/c.'
	NeedCrossSection: yes
	BibKey: Aaij:2011uk
	BibTeX: '@article{Aaij:2011uk,
	author = "Aaij, R. and others",
	title = "{Measurement of the inclusive $\phi$ cross-section in $pp$
	collisions at $\sqrt{s} = 7$ TeV}",
	collaboration = "LHCb Collaboration",
	journal = "Phys.Lett.",
	volume = "B703",
	pages = "267-273",
	doi = "10.1016/j.physletb.2011.08.017",
	year = "2011",
	eprint = "1107.3935",
	archivePrefix = "arXiv",
	primaryClass = "Unknown",
	}'
	diff --git a/data/anainfo/LHCB_2014_I1262703.info b/data/anainfo/LHCB_2014_I1262703.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/LHCB_2014_I1262703.info
	@@ -0,0 +1,43 @@
	+Name: LHCB_2014_I1262703
	+Year: 2014
	+Summary: Study of forward Z + jet production in $pp$ collisions at $\sqrt{s}=7$ TeV in the LHCb fiducial phase-space
	+Experiment: LHCb
	+Collider: LHC
	+InspireID: 1262703
	+Status: VALIDATED
	+Authors:
	+ - William Barter <barter@hep.phy.cam.ac.uk>
	+ - Albert Bursche <albert.bursche@physik.uzh.ch>
	+ - Marek Sirendi <sirendi@hep.phy.cam.ac.uk>
	+References:
	+ - 'J. High Energy Phys.1401:033,2014'
	+ - 'doi:10.1007/jhep01(2014)033'
	+ - 'arXiv:hep-ex/1310.8197'
	+RunInfo:
	+ $pp$ $Z +$ jet events at 7 TeV with direct $\mu$ decays
	+NumEvents: 100000
	+NeedCrossSection: no
	+Beams: [p+, p+]
	+Energies: [7000]
	+PtCuts: [20.]
	+Description:
	+ 'A study of forward $Z +$ jet production in $pp$ collisions at $\sqrt{s}=7$ TeV is presented.
	+ Results are shown for two jet thresholds of $p_T>10$ GeV and $p_T>20$ GeV. Total
	+ cross-sections and six differential cross-sections are measured.'
	+BibKey: Aaij:2013nxa
	+BibTeX: '@article{Aaij:2013nxa,
	+ author = "Aaij, Roel and others",
	+ title = "{Study of forward Z + jet production in $pp$ collisions at
	+ $\sqrt{s} = 7$ TeV}",
	+ collaboration = "LHCb collaboration",
	+ journal = "JHEP",
	+ volume = "1401",
	+ pages = "033",
	+ doi = "10.1007/JHEP01(2014)033",
	+ year = "2014",
	+ eprint = "1310.8197",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "LHCB-PAPER-2013-058, CERN-PH-EP-2013-198",
	+ SLACcitation = "%%CITATION = ARXIV:1310.8197;%%",
	+}'
	diff --git a/data/anainfo/MC_CENTRALITY.info b/data/anainfo/MC_CENTRALITY.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/MC_CENTRALITY.info
	@@ -0,0 +1,10 @@
	+Name: MC_CENTRALITY
	+Summary: Template analysis for using CentralityHistogram
	+Status: UNVALIDATED
	+Authors:
	+ - Leif LÃ¶nnblad <leif.lonnblad@thep.lu.se>
	+NumEvents: 50000
	+RunInfo: Any!
	+Description:
	+ Template analysis for using CentralityHistogram for dynamically
	+ determining centrality intervals using summed eT in the forward region.
	diff --git a/data/anainfo/MC_DIJET.info b/data/anainfo/MC_DIJET.info
	deleted file mode 100644
	--- a/data/anainfo/MC_DIJET.info
	+++ /dev/null
	@@ -1,12 +0,0 @@
	-Name: MC_DIJET
	-Summary: Analysis of dijet events at the LHC.
	-Description:
	- Analysis of dijet events for the upcoming runs at the LHC, specifically studying
	- azimuthal angle, transverse momentum distributions (including for leading jet
	- and secondary jet), as well as charged particle multiplicities and transverse
	- momenta.
	-RunInfo: "Generic QCD events at any energy."
	-Status: UNVALIDATED
	-Author:
	- - Christophe Vaillant <c.l.j.j.vaillant@durham.ac.uk>
	-PtCuts: [0]
	diff --git a/data/anainfo/MC_MET.info b/data/anainfo/MC_MET.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/MC_MET.info
	@@ -0,0 +1,12 @@
	+Name: MC_MET
	+Summary: Monte Carlo validation observables for missing transverse energy
	+Status: VALIDATED
	+Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	+RunInfo:
	+ Any event type, with or without "real MET".
	+NumEvents: 10000
	+Description:
	+ Reports vector and scalar transverse momentum sums, based on total or
	+ $\|\eta\| < 5$ detector acceptances.
	+NeedCrossSection: no
	diff --git a/data/anainfo/Makefile.am b/data/anainfo/Makefile.am
	--- a/data/anainfo/Makefile.am
	+++ b/data/anainfo/Makefile.am
	@@ -1,376 +1,430 @@
	dist_pkgdata_DATA = \
	ALEPH_1991_S2435284.info \
	+ ALEPH_1995_I382179.info \
	ALEPH_1996_S3486095.info \
	ALEPH_1996_S3196992.info \
	ALEPH_1999_S4193598.info \
	ALEPH_2001_S4656318.info \
	ALEPH_2002_S4823664.info \
	ALEPH_2004_S5765862.info \
	ALICE_2010_S8624100.info \
	ALICE_2010_S8625980.info \
	ALICE_2010_S8706239.info \
	ALICE_2011_S8909580.info \
	ALICE_2011_S8945144.info \
	+ ALICE_2012_I1116147.info \
	ALICE_2012_I1181770.info \
	ALICE_2015_I1357424.info \
	ALICE_2014_I1300380.info \
	ARGUS_1993_S2653028.info \
	ARGUS_1993_S2669951.info \
	ARGUS_1993_S2789213.info \
	ATLAS_2010_S8591806.info \
	ATLAS_2010_S8817804.info \
	ATLAS_2010_S8894728.info \
	ATLAS_2010_S8914702.info \
	ATLAS_2010_S8918562.info \
	ATLAS_2010_S8919674.info \
	ATLAS_2010_CONF_2010_049.info \
	ATLAS_2011_S8924791.info \
	ATLAS_2011_S8971293.info \
	ATLAS_2011_S8983313.info \
	ATLAS_2011_S8994773.info \
	ATLAS_2011_S9002537.info \
	ATLAS_2011_S9019561.info \
	ATLAS_2011_S9041966.info \
	ATLAS_2011_S9120807.info \
	ATLAS_2011_S9126244.info \
	ATLAS_2011_S9128077.info \
	ATLAS_2011_S9131140.info \
	ATLAS_2011_S9108483.info \
	ATLAS_2011_S9212183.info \
	ATLAS_2011_I894867.info \
	ATLAS_2011_I921594.info \
	ATLAS_2011_I928289_W.info \
	ATLAS_2011_I928289_Z.info \
	ATLAS_2011_I930220.info \
	ATLAS_2011_S9035664.info \
	ATLAS_2011_I919017.info \
	ATLAS_2011_I925932.info \
	ATLAS_2011_I926145.info \
	+ ATLAS_2011_I929691.info \
	ATLAS_2011_I944826.info \
	ATLAS_2011_I945498.info \
	ATLAS_2011_I954993.info \
	ATLAS_2011_S9225137.info \
	ATLAS_2011_S9212353.info \
	ATLAS_2011_CONF_2011_090.info \
	ATLAS_2011_CONF_2011_098.info \
	ATLAS_2012_I943401.info \
	ATLAS_2012_I946427.info \
	ATLAS_2012_I1083318.info \
	ATLAS_2012_I1082936.info \
	ATLAS_2012_I1084540.info \
	ATLAS_2012_I1093734.info \
	ATLAS_2012_I1093738.info \
	ATLAS_2012_I1094061.info \
	ATLAS_2012_I1094564.info \
	ATLAS_2012_I1094568.info \
	ATLAS_2012_I1095236.info \
	ATLAS_2012_I1082009.info \
	ATLAS_2012_I1091481.info \
	ATLAS_2012_I1119557.info \
	ATLAS_2012_I1124167.info \
	ATLAS_2012_I1125575.info \
	ATLAS_2012_I1183818.info \
	ATLAS_2012_I1188891.info \
	ATLAS_2012_I1112263.info \
	ATLAS_2012_I1125961.info \
	ATLAS_2012_I1126136.info \
	ATLAS_2012_I1117704.info \
	ATLAS_2012_I1118269.info \
	ATLAS_2012_I1180197.info \
	ATLAS_2012_I1186556.info \
	ATLAS_2012_I1190891.info \
	ATLAS_2012_I1199269.info \
	ATLAS_2012_I1203852.info \
	ATLAS_2012_I1204447.info \
	ATLAS_2012_I1204784.info \
	ATLAS_2012_CONF_2012_001.info \
	ATLAS_2012_CONF_2012_103.info \
	ATLAS_2012_CONF_2012_104.info \
	ATLAS_2012_CONF_2012_105.info \
	ATLAS_2012_CONF_2012_109.info \
	ATLAS_2012_CONF_2012_153.info \
	ATLAS_2013_I1190187.info \
	ATLAS_2013_I1217863_W.info \
	ATLAS_2013_I1217863_W_EL.info \
	ATLAS_2013_I1217863_W_MU.info \
	ATLAS_2013_I1217863_Z.info \
	ATLAS_2013_I1217863_Z_EL.info \
	ATLAS_2013_I1217863_Z_MU.info \
	ATLAS_2013_I1217867.info \
	ATLAS_2013_I1219109.info \
	ATLAS_2013_I1219109_EL.info \
	ATLAS_2013_I1219109_MU.info \
	ATLAS_2013_I1230812.info \
	ATLAS_2013_I1230812_EL.info \
	ATLAS_2013_I1230812_MU.info \
	ATLAS_2013_I1243871.info \
	ATLAS_2013_I1263495.info \
	ATLAS_2014_I1268975.info \
	ATLAS_2014_I1279489.info \
	ATLAS_2014_I1282441.info \
	ATLAS_2014_I1298811.info \
	ATLAS_2014_I1304688.info \
	ATLAS_2014_I1307756.info \
	ATLAS_2014_I1306294.info \
	ATLAS_2014_I1306294_EL.info \
	ATLAS_2014_I1306294_MU.info \
	ATLAS_2014_I1315949.info \
	ATLAS_2014_I1325553.info \
	ATLAS_2014_I1300647.info \
	ATLAS_2014_I1288706.info \
	ATLAS_2014_I1307243.info \
	ATLAS_2014_I1312627.info \
	ATLAS_2014_I1312627_EL.info \
	ATLAS_2014_I1312627_MU.info \
	ATLAS_2014_I1306615.info \
	+ ATLAS_2015_I1393758.info \
	ATLAS_2015_I1364361.info \
	ATLAS_2015_I1345452.info \
	+ ATLAS_2015_I1351916.info \
	+ ATLAS_2015_I1351916_EL.info \
	+ ATLAS_2015_I1351916_MU.info \
	ATLAS_2013_I1216670.info \
	ATLAS_2013_I1244522.info \
	ATLAS_2014_I1282447.info \
	ATLAS_2014_I1298023.info \
	ATLAS_2014_I1319490.info \
	ATLAS_2014_I1319490_EL.info \
	ATLAS_2014_I1319490_MU.info \
	ATLAS_2014_I1326641.info \
	ATLAS_2014_I1327229.info \
	ATLAS_2015_I1387176.info \
	ATLAS_2015_CONF_2015_041.info \
	ATLAS_2015_CONF_2015_041_EL.info \
	ATLAS_2015_CONF_2015_041_MU.info \
	ATLAS_2015_I1376945.info \
	+ ATLAS_2015_I1390114.info \
	ATLAS_2015_I1394679.info \
	+ ATLAS_2015_I1397635.info \
	+ ATLAS_2015_I1397637.info \
	+ ATLAS_2015_I1408516.info \
	+ ATLAS_2015_I1408516_EL.info \
	+ ATLAS_2015_I1408516_MU.info \
	+ ATLAS_2015_I1404878.info \
	+ ATLAS_2016_I1419070.info \
	+ ATLAS_2016_I1419652.info \
	ATLAS_2016_I1424838.info \
	+ ATLAS_2016_I1426695.info \
	+ ATLAS_2016_I1444991.info \
	+ ATLAS_2016_I1452559.info \
	+ ATLAS_2016_I1457605.info \
	+ ATLAS_2016_I1458270.info \
	+ ATLAS_2016_I1467230.info \
	+ ATLAS_2016_I1467454.info \
	+ ATLAS_2016_I1467454_EL.info \
	+ ATLAS_2016_I1467454_MU.info \
	+ ATLAS_2016_I1468167.info \
	+ ATLAS_2016_I1468168.info \
	+ ATLAS_2016_I1479760.info \
	+ ATLAS_2016_CONF_2016_037.info \
	+ ATLAS_2016_CONF_2016_054.info \
	+ ATLAS_2016_CONF_2016_078.info \
	+ ATLAS_2016_CONF_2016_094.info \
	BABAR_2003_I593379.info \
	BABAR_2005_S6181155.info \
	BABAR_2007_S6895344.info \
	BABAR_2007_S7266081.info \
	+ BABAR_2013_I1116411.info \
	+ BABAR_2013_I1238276.info \
	+ BABAR_2015_I1334693.info \
	+ BELLE_2001_S4598261.info \
	BELLE_2008_I786560.info \
	- BABAR_2013_I1238276.info \
	- BELLE_2001_S4598261.info \
	+ BELLE_2011_I878990.info \
	BELLE_2013_I1216515.info \
	+ BELLE_2013_I1238273.info \
	+ BELLE_2015_I1397632.info \
	CDF_1988_S1865951.info \
	CDF_1990_S2089246.info \
	CDF_1993_S2742446.info \
	CDF_1994_S2952106.info \
	CDF_1996_S3108457.info \
	CDF_1996_S3349578.info \
	CDF_1996_S3418421.info \
	CDF_1997_S3541940.info \
	CDF_1998_S3618439.info \
	CDF_2000_S4155203.info \
	CDF_2000_S4266730.info \
	CDF_2001_S4517016.info \
	CDF_2001_S4563131.info \
	CDF_2001_S4751469.info \
	CDF_2002_S4796047.info \
	CDF_2004_S5839831.info \
	CDF_2005_S6080774.info \
	CDF_2005_S6217184.info \
	CDF_2006_S6450792.info \
	CDF_2006_S6653332.info \
	CDF_2007_S7057202.info \
	CDF_2008_S7540469.info \
	CDF_2008_S7541902.info \
	CDF_2008_S7782535.info \
	CDF_2008_S7828950.info \
	CDF_2008_S8093652.info \
	CDF_2008_S8095620.info \
	CDF_2009_S8233977.info \
	CDF_2009_NOTE_9936.info \
	- CDF_2009_S8383952.info \
	+ CDF_2009_I856131.info \
	CDF_2009_S8436959.info \
	CDF_2010_S8591881_DY.info \
	CDF_2010_S8591881_QCD.info \
	CDF_2012_NOTE10874.info \
	CDF_2012_I1124333.info \
	+ CDF_2015_1388868.info \
	CLEO_2004_S5809304.info\
	CMS_2010_S8547297.info \
	CMS_2010_S8656010.info \
	CMS_2011_S8884919.info \
	CMS_2011_S9215166.info \
	CMS_2012_I941555.info \
	CMS_2011_I954992.info \
	CMS_2011_S8941262.info \
	CMS_2011_S8950903.info \
	CMS_2011_S8957746.info \
	CMS_2011_S8968497.info \
	CMS_2011_S8973270.info \
	CMS_2011_S8978280.info \
	CMS_2011_S9086218.info \
	CMS_2011_S9088458.info \
	CMS_2011_S9120041.info \
	CMS_2012_I1087342.info \
	CMS_2012_I1090423.info \
	CMS_2012_I1102908.info \
	CMS_2012_I1107658.info \
	CMS_2012_I1184941.info \
	CMS_2012_I1193338.info \
	CMS_2013_I1122847.info \
	CMS_2013_I1208923.info \
	CMS_2013_I1209721.info \
	CMS_2013_I1218372.info \
	+ CMS_2013_I1223519.info \
	CMS_2013_I1224539_DIJET.info \
	CMS_2013_I1224539_WJET.info \
	CMS_2013_I1224539_ZJET.info \
	CMS_2013_I1256943.info \
	CMS_2013_I1258128.info \
	CMS_2013_I1261026.info \
	CMS_2013_I1265659.info \
	CMS_2013_I1272853.info \
	CMS_2013_I1273574.info \
	+ CMS_2012_I1298807.info \
	CMS_2014_I1298810.info \
	CMS_2014_I1303894.info \
	+ CMS_2014_I1305624.info \
	CMS_2015_I1310737.info \
	CMS_2015_I1327224.info \
	CMS_2015_I1346843.info \
	CMS_2015_I1356998.info \
	CMS_2015_I1370682.info \
	CMS_2015_I1384119.info \
	CMS_2015_I1385107.info \
	+ CMS_2015_I1397174.info \
	+ CMS_2016_I1459051.info \
	+ CMS_2016_I1473674.info \
	CMSTOTEM_2014_I1294140.info \
	- TOTEM_2014_I1328627.info \
	+ CMS_2010_PAS_QCD_10_024.info \
	CMS_2012_PAS_QCD_11_010.info \
	- CMS_QCD_10_024.info \
	+ CMS_2012_PAS_FSQ_12_020.info \
	+ CMS_2016_PAS_SUS_16_14.info \
	+ D0_1995_I398175.info \
	D0_1996_S3214044.info \
	D0_1996_S3324664.info \
	D0_2000_S4480767.info \
	D0_2000_I499943.info \
	D0_2001_S4674421.info \
	D0_2004_S5992206.info \
	D0_2006_S6438750.info \
	D0_2007_S7075677.info \
	D0_2008_S6879055.info \
	D0_2008_S7554427.info \
	D0_2008_S7662670.info \
	D0_2008_S7719523.info \
	D0_2008_S7837160.info \
	D0_2008_S7863608.info \
	D0_2009_S8202443.info \
	D0_2009_S8320160.info \
	D0_2009_S8349509.info \
	D0_2010_S8566488.info \
	D0_2010_S8570965.info \
	D0_2010_S8671338.info \
	D0_2010_S8821313.info \
	D0_2011_I895662.info \
	D0_2015_I1324946.info \
	D0_2000_I503361.info \
	E735_1998_S3905616.info \
	DELPHI_1995_S3137023.info \
	DELPHI_1996_S3430090.info \
	DELPHI_1999_S3960137.info \
	DELPHI_2000_S4328825.info \
	DELPHI_2002_069_CONF_603.info \
	+ DELPHI_2011_I890503.info \
	EXAMPLE.info \
	EXAMPLE_CUTS.info \
	EXAMPLE_SMEAR.info \
	H1_1994_S2919893.info \
	H1_1995_S3167097.info \
	H1_2000_S4129130.info \
	JADE_OPAL_2000_S4300807.info \
	JADE_1998_S3612880.info \
	LHCB_2010_S8758301.info \
	LHCB_2010_I867355.info \
	LHCB_2011_I917009.info \
	LHCB_2011_I919315.info \
	LHCB_2012_I1119400.info \
	LHCB_2012_I1208102.info \
	LHCB_2013_I1208105.info \
	LHCB_2013_I1218996.info \
	+ LHCB_2014_I1262703.info \
	LHCB_2014_I1281685.info \
	LHCB_2015_I1333223.info \
	LHCF_2012_I1115479.info \
	- MC_DIJET.info \
	+ MC_CENTRALITY.info \
	MC_DIPHOTON.info \
	MC_ELECTRONS.info \
	MC_GENERIC.info \
	MC_HFJETS.info \
	MC_HINC.info \
	MC_HJETS.info \
	MC_HHJETS.info \
	MC_HKTSPLITTINGS.info \
	MC_IDENTIFIED.info \
	MC_JETS.info \
	MC_JETTAGS.info \
	MC_KTSPLITTINGS.info \
	MC_LEADJETUE.info \
	+ MC_MET.info \
	MC_MUONS.info \
	MC_PDFS.info \
	MC_PHOTONINC.info \
	MC_PHOTONJETS.info \
	MC_PHOTONKTSPLITTINGS.info \
	MC_PHOTONS.info \
	MC_PRINTEVENT.info \
	MC_QCD_PARTONS.info \
	MC_SUSY.info \
	MC_TAUS.info \
	MC_TTBAR.info \
	MC_VH2BB.info \
	MC_WINC.info \
	MC_WINC_EL.info \
	MC_WINC_MU.info \
	MC_WINC_EL_BARE.info \
	MC_WINC_MU_BARE.info \
	MC_WJETS.info \
	MC_WJETS_EL.info \
	MC_WJETS_MU.info \
	MC_WJETS_EL_BARE.info \
	MC_WJETS_MU_BARE.info \
	MC_WKTSPLITTINGS.info \
	MC_WPOL.info \
	MC_WWINC.info \
	MC_WWJETS.info \
	MC_WWKTSPLITTINGS.info \
	MC_XS.info \
	MC_ZINC.info \
	MC_ZINC_EL.info \
	MC_ZINC_MU.info \
	MC_ZINC_EL_BARE.info \
	MC_ZINC_MU_BARE.info \
	MC_ZJETS.info \
	MC_ZJETS_EL.info \
	MC_ZJETS_MU.info \
	MC_ZJETS_EL_BARE.info \
	MC_ZJETS_MU_BARE.info \
	MC_ZKTSPLITTINGS.info \
	MC_ZZINC.info \
	MC_ZZJETS.info \
	MC_ZZKTSPLITTINGS.info \
	+ L3_1992_I336180.info \
	+ L3_2004_I652683.info \
	OPAL_1993_S2692198.info \
	+ OPAL_1993_I342766.info \
	OPAL_1994_S2927284.info \
	OPAL_1995_S3198391.info \
	OPAL_1996_S3257789.info \
	OPAL_1997_S3396100.info \
	OPAL_1997_S3608263.info \
	OPAL_1998_S3702294.info \
	OPAL_1998_S3780481.info \
	OPAL_1998_S3749908.info \
	OPAL_2000_S4418603.info \
	OPAL_2001_S4553896.info \
	OPAL_2002_S5361494.info \
	+ OPAL_2003_I599181.info \
	OPAL_2004_S6132243.info \
	PDG_HADRON_MULTIPLICITIES.info \
	PDG_HADRON_MULTIPLICITIES_RATIOS.info \
	PDG_TAUS.info \
	SFM_1984_S1178091.info \
	SLD_1996_S3398250.info \
	SLD_1999_S3743934.info \
	SLD_2002_S4869273.info \
	SLD_2004_S5693039.info \
	STAR_2006_S6500200.info \
	STAR_2006_S6860818.info \
	STAR_2006_S6870392.info \
	STAR_2008_S7869363.info \
	STAR_2008_S7993412.info \
	STAR_2009_UE_HELEN.info \
	TASSO_1990_S2148048.info \
	TOTEM_2012_I1115294.info \
	- TOTEM_2012_002.info \
	+ TOTEM_2012_I1220862.info \
	+ TOTEM_2014_I1328627.info \
	ZEUS_2001_S4815815.info \
	UA1_1990_S2044935.info \
	UA5_1982_S875503.info \
	UA5_1986_S1583476.info \
	UA5_1987_S1640666.info \
	UA5_1988_S1867512.info \
	UA5_1989_S1926373.info
	diff --git a/data/anainfo/OPAL_1993_I342766.info b/data/anainfo/OPAL_1993_I342766.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/OPAL_1993_I342766.info
	@@ -0,0 +1,33 @@
	+Name: OPAL_1993_I342766
	+Year: 1993
	+Summary: A Measurement of $K^{*\pm}$ (892) production in hadronic Z0 decays
	+Experiment: OPAL
	+Collider: LEP
	+InspireID: 342766
	+Status: VALIDATED
	+Authors:
	+ - Simone Amoroso <amoroso@cern.ch>
	+References:
	+ - Phys.Lett. B305 (1993) 407-414
	+ - doi:10.1016/0370-2693(93)91075-X
	+RunInfo: electron positron collisions at the Z0 resonance with hadronic decays
	+NumEvents: 1000000
	+NeedCrossSection: no
	+Beams: [e+,e-]
	+Energies: [91.2]
	+Description: 'OPAL measurement of the inclusive cross section for K^{*\pm} (892) production in hadronic decays of the Z0'
	+BibKey: Acton:1992us
	+BibTeX: '@article{Acton:1992us,
	+ author = "Acton, P. D. and others",
	+ title = "{A Measurement of K*+- (892) production in hadronic Z0
	+ decays}",
	+ collaboration = "OPAL",
	+ journal = "Phys. Lett.",
	+ volume = "B305",
	+ year = "1993",
	+ pages = "407-414",
	+ doi = "10.1016/0370-2693(93)91075-X",
	+ reportNumber = "CERN-PPE-92-213",
	+ SLACcitation = "%%CITATION = PHLTA,B305,407;%%"
	+}'
	+
	diff --git a/data/anainfo/OPAL_1993_S2692198.info b/data/anainfo/OPAL_1993_S2692198.info
	--- a/data/anainfo/OPAL_1993_S2692198.info
	+++ b/data/anainfo/OPAL_1993_S2692198.info
	@@ -1,35 +1,36 @@
	Name: OPAL_1993_S2692198
	Year: 1993
	Summary: Measurement of photon production at LEP 1
	Experiment: OPAL
	Collider: LEP Run 1
	SpiresID: 2692198
	+InspireID: 343181
	Status: UNVALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Z.Phys.C58:405-418,1993
	- doi:10.1007/BF01557697
	RunInfo:
	$e^+ e^- \to$ jet jet (+ photons)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Measurement of the production of photons in $e^+ e^-\to q \bar q$ events at LEP 1.
	BibKey: Acton:1992jk
	BibTeX: '@Article{Acton:1992jk,
	author = "Acton, P. D. and others",
	collaboration = "OPAL",
	title = "{Studies of strong and electroweak interactions using final
	state photon emission in hadronic Z0 decays}",
	journal = "Z. Phys.",
	volume = "C58",
	year = "1993",
	pages = "405-418",
	doi = "10.1007/BF01557697",
	SLACcitation = "%%CITATION = ZEPYA,C58,405;%%"
	}'
	ToDo:
	- Fix this! It looks nothing like the data, at least in the H++ benchmark tests.
	diff --git a/data/anainfo/OPAL_1994_S2927284.info b/data/anainfo/OPAL_1994_S2927284.info
	--- a/data/anainfo/OPAL_1994_S2927284.info
	+++ b/data/anainfo/OPAL_1994_S2927284.info
	@@ -1,34 +1,35 @@
	Name: OPAL_1994_S2927284
	Year: 1994
	Summary: Measurement of the production rates of charged hadrons in $e^+e^-$ annihilation at the $Z^0$
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 2927284
	+InspireID: 372772
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Z.Phys.C63:181-196,1994
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: The inclusive production rates of $\pi^\pm$, $K^\pm$ and $p\bar{p}$ in $Z^0$ decays
	measured using the OPAL detector at LEP. Only the differential cross sections are currently
	implemented.
	BibKey: Akers:1994ez
	BibTeX: '@Article{Akers:1994ez,
	author = "Akers, R. and others",
	collaboration = "OPAL",
	title = "{Measurement of the production rates of charged hadrons in
	e+ e- annihilation at the Z0}",
	journal = "Z. Phys.",
	volume = "C63",
	year = "1994",
	pages = "181-196",
	doi = "10.1007/BF01411010",
	SLACcitation = "%%CITATION = ZEPYA,C63,181;%%"
	}
	'
	diff --git a/data/anainfo/OPAL_1995_S3198391.info b/data/anainfo/OPAL_1995_S3198391.info
	--- a/data/anainfo/OPAL_1995_S3198391.info
	+++ b/data/anainfo/OPAL_1995_S3198391.info
	@@ -1,31 +1,32 @@
	Name: OPAL_1995_S3198391
	Year: 1995
	Summary: $\Delta^{++}$ Production in Hadronic $Z^0$ Decays
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 3198391
	+InspireID: 398320
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Lett.B358:162-172,1995
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: The production of $\Delta^{++}$ baryons measured using 3.5 millon $Z^0$ events
	by the OPAL experiment at LEP. Only the fragmentation function is implemented.
	BibKey: Alexander:1995gq
	BibTeX: '@Article{Alexander:1995gq,
	author = "Alexander, G. and others",
	collaboration = "OPAL",
	title = "{$\Delta^{++}$ production in hadronic $Z^0$ decays}",
	journal = "Phys. Lett.",
	volume = "B358",
	year = "1995",
	pages = "162-172",
	doi = "10.1016/0370-2693(95)00935-E",
	SLACcitation = "%%CITATION = PHLTA,B358,162;%%"
	}'
	diff --git a/data/anainfo/OPAL_1996_S3257789.info b/data/anainfo/OPAL_1996_S3257789.info
	--- a/data/anainfo/OPAL_1996_S3257789.info
	+++ b/data/anainfo/OPAL_1996_S3257789.info
	@@ -1,34 +1,35 @@
	Name: OPAL_1996_S3257789
	Year: 1995
	Summary: $J/\psi$ and $\psi^\prime$ Production in Hadronic $Z^0$ Decays
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 3257789
	+InspireID: 402487
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Z.Phys. C70 (1996) 197-210
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: The production of $J/\psi$ and $\psi^\prime$ mesons measured
	by the OPAL experiment at LEP. The fragmentation function for $J/\psi$ and the
	multiplicities of $J/\psi$ and $\psi^\prime$ are included.
	BibKey: Alexander:1995qb
	BibTeX: '@article{Alexander:1995qb,
	author = "Alexander, G. and others",
	title = "{$J/\psi$ and $\psi^\prime$ production in hadronic $Z^0$
	decays}",
	collaboration = "OPAL Collaboration",
	journal = "Z.Phys.",
	volume = "C70",
	pages = "197-210",
	doi = "10.1007/s002880050096",
	year = "1996",
	reportNumber = "CERN-PPE-95-153",
	SLACcitation = "%%CITATION = ZEPYA,C70,197;%%",
	}'
	diff --git a/data/anainfo/OPAL_1997_S3396100.info b/data/anainfo/OPAL_1997_S3396100.info
	--- a/data/anainfo/OPAL_1997_S3396100.info
	+++ b/data/anainfo/OPAL_1997_S3396100.info
	@@ -1,35 +1,36 @@
	Name: OPAL_1997_S3396100
	Year: 1997
	Summary: Strange baryon production in $Z$ hadronic decays at OPAL
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 3396100
	+InspireID: 421978
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Z. Phys. C, 73, 569--586 (1997)
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Measurement of the $\Xi^-$, $\Lambda^0$, $\Sigma^+(1385)$, $\Sigma^-(1385)$,
	$\Xi^0(1530)$ and $\Lambda^0(1520)$ scaled
	momentum distributions by OPAL at LEP 1. The paper also has the
	production cross-sections of these particles, but that is not
	implemented in Rivet.
	BibKey: Alexander:1996qj
	BibTeX: '@Article{Alexander:1996qj,
	author = "Alexander, G. and others",
	collaboration = "OPAL",
	title = "{Strange baryon production in hadronic $Z^0$ decays}",
	journal = "Z. Phys.",
	volume = "C73",
	year = "1997",
	pages = "569-586",
	doi = "10.1007/s002880050349",
	SLACcitation = "%%CITATION = ZEPYA,C73,569;%%"
	}'
	diff --git a/data/anainfo/OPAL_1997_S3608263.info b/data/anainfo/OPAL_1997_S3608263.info
	--- a/data/anainfo/OPAL_1997_S3608263.info
	+++ b/data/anainfo/OPAL_1997_S3608263.info
	@@ -1,39 +1,40 @@
	Name: OPAL_1997_S3608263
	Year: 1997
	Summary: $K^{*0}$ meson production measured by OPAL at LEP 1.
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 3608263
	+InspireID: 447146
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Lett.B412:210-224,1997
	- hep-ex/9708022
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: The $K^{*0}$ fragmentation function has been measured in hadronic $Z^0$ decays.
	In addition the helicity density matrix elements for inclusive $K^*(892)^0$ mesons
	from hadronic $Z^0$ decays have been measured over the full range of $K^{*0}$ momentum
	using data taken with the OPAL experiment at LEP. Only the fragmentation function
	measurement is currently implemented.

	BibKey: Ackerstaff:1997kj
	BibTeX: '@Article{Ackerstaff:1997kj,
	author = "Ackerstaff, K. and others",
	collaboration = "OPAL",
	title = "{Spin alignment of leading K*(892)0 mesons in hadronic Z0
	decays}",
	journal = "Phys. Lett.",
	volume = "B412",
	year = "1997",
	pages = "210-224",
	eprint = "hep-ex/9708022",
	archivePrefix = "arXiv",
	doi = "10.1016/S0370-2693(97)01077-0",
	SLACcitation = "%%CITATION = HEP-EX/9708022;%%"
	}'
	diff --git a/data/anainfo/OPAL_1998_S3702294.info b/data/anainfo/OPAL_1998_S3702294.info
	--- a/data/anainfo/OPAL_1998_S3702294.info
	+++ b/data/anainfo/OPAL_1998_S3702294.info
	@@ -1,37 +1,38 @@
	Name: OPAL_1998_S3702294
	Year: 1998
	Summary: Production of $f_0(980)$, $f_2(1270)$ and $\phi(1020)$ in hadronic $Z^0$ decay
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 3702294
	+InspireID: 467092
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Eur.Phys.J.C4:19-28,1998
	- hep-ex/9802013
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: Inclusive production of the $f_0(980)$, $f_2(1270)$ and $\phi(1020)$
	resonances studied in a sample of 4.3 million hadronic $Z^0$ decays
	from the OPAL experiment at LEP. Fragmentation functions are reported
	for the three states.
	BibKey: Ackerstaff:1998ue
	BibTeX: '@Article{Ackerstaff:1998ue,
	author = "Ackerstaff, K. and others",
	collaboration = "OPAL",
	title = "{Production of f0(980), f2(1270) and Phi(1020) in hadronic
	Z0 decay}",
	journal = "Eur. Phys. J.",
	volume = "C4",
	year = "1998",
	pages = "19-28",
	eprint = "hep-ex/9802013",
	archivePrefix = "arXiv",
	doi = "10.1007/s100520050183",
	SLACcitation = "%%CITATION = HEP-EX/9802013;%%"
	}'
	diff --git a/data/anainfo/OPAL_1998_S3749908.info b/data/anainfo/OPAL_1998_S3749908.info
	--- a/data/anainfo/OPAL_1998_S3749908.info
	+++ b/data/anainfo/OPAL_1998_S3749908.info
	@@ -1,36 +1,37 @@
	Name: OPAL_1998_S3749908
	Year: 1998
	Summary: Photon and Light Meson Production in Hadronic $Z^0$ Decays
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 3749908
	+InspireID: 470419
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Eur.Phys.J.C5:411-437,1998
	- hep-ex/9805011
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: The inclusive production rates and differential cross sections of photons
	and mesons with a final state containing photons have been measured with the OPAL
	detector at LEP. The light mesons covered by the measurements are the $\pi^0$, $\eta$,
	$\rho(770)^\pm$, $\omega(782)$, $\eta'(958)$ and $a_0(980)^\pm$.
	BibKey: Ackerstaff:1998ap
	BibTeX: '@Article{Ackerstaff:1998ap,
	author = "Ackerstaff, K. and others",
	collaboration = "OPAL",
	title = "{Photon and light meson production in hadronic Z0 decays}",
	journal = "Eur. Phys. J.",
	volume = "C5",
	year = "1998",
	pages = "411-437",
	eprint = "hep-ex/9805011",
	archivePrefix = "arXiv",
	doi = "10.1007/s100520050286",
	SLACcitation = "%%CITATION = HEP-EX/9805011;%%"
	}'
	diff --git a/data/anainfo/OPAL_1998_S3780481.info b/data/anainfo/OPAL_1998_S3780481.info
	--- a/data/anainfo/OPAL_1998_S3780481.info
	+++ b/data/anainfo/OPAL_1998_S3780481.info
	@@ -1,38 +1,39 @@
	Name: OPAL_1998_S3780481
	Year: 1998
	Summary: Measurements of flavor dependent fragmentation functions in $Z^0 -> q \bar{q}$ events
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 3780481
	+InspireID: 472637
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Eur. Phys. J, C7, 369--381 (1999)
	- hep-ex/9807004
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Measurement of scaled momentum distributions and total charged
	multiplicities in flavour tagged events at LEP 1. OPAL measured these
	observables in uds-, c-, and b-events separately. An inclusive
	measurement is also included.
	BibKey: Ackerstaff:1998hz
	BibTeX: '@Article{Ackerstaff:1998hz,
	author = "Ackerstaff, K. and others",
	collaboration = "OPAL",
	title = "{Measurements of flavour dependent fragmentation functions
	in Z0 --> q anti-q events}",
	journal = "Eur. Phys. J.",
	volume = "C7",
	year = "1999",
	pages = "369-381",
	eprint = "hep-ex/9807004",
	archivePrefix = "arXiv",
	doi = "10.1007/s100529901067",
	SLACcitation = "%%CITATION = HEP-EX/9807004;%%"
	}'
	diff --git a/data/anainfo/OPAL_2000_S4418603.info b/data/anainfo/OPAL_2000_S4418603.info
	--- a/data/anainfo/OPAL_2000_S4418603.info
	+++ b/data/anainfo/OPAL_2000_S4418603.info
	@@ -1,39 +1,40 @@
	Name: OPAL_2000_S4418603
	Year: 2000
	Summary: Multiplicities of $\pi^0$, $\eta$, $K^0$ and of charged particles in quark and gluon jets
	Experiment: OPAL
	Collider: LEP 1
	SpiresID: 4418603
	+InspireID: 529898
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Eur.Phys.J.C17:373-387,2000
	- hep-ex/0007017
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: Multiplicities of $\pi^0$, $\eta$, $K^0$ and of charged particles
	in quark and gluon jets in 3-jet events, as measured by the OPAL
	experiment at LEP. The main implemented measurement is the
	$K^0$ fragmentation function.
	BibKey: Abbiendi:2000cv
	BibTeX: '@article{Abbiendi:2000cv,
	author = "Abbiendi, G. and others",
	title = "{Multiplicities of pi0, eta, K0 and of charged particles
	in quark and gluon jets}",
	collaboration = "OPAL Collaboration",
	journal = "Eur.Phys.J.",
	volume = "C17",
	pages = "373-387",
	doi = "10.1007/s100520000505",
	year = "2000",
	eprint = "hep-ex/0007017",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-EP-2000-070",
	SLACcitation = "%%CITATION = HEP-EX/0007017;%%",
	}'
	diff --git a/data/anainfo/OPAL_2001_S4553896.info b/data/anainfo/OPAL_2001_S4553896.info
	--- a/data/anainfo/OPAL_2001_S4553896.info
	+++ b/data/anainfo/OPAL_2001_S4553896.info
	@@ -1,44 +1,45 @@
	Name: OPAL_2001_S4553896
	Year: 2001
	Summary: Four-jet angles using Durham algorithm
	Experiment: OPAL
	Collider: LEP Run 1
	SpiresID: 4553896
	+InspireID: 552446
	Status: VALIDATED
	Authors:
	- Frank Siegert <frank.siegert@cern.ch>
	References:
	- Eur.Phys.J.C20:601-615,2001
	- doi:10.1007/s100520100699
	- arXiv:hep-ex/0101044
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	Hadronisation should be turned off because the data is corrected back to the
	parton level.
	NumEvents: 10000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	'Angles between the leading (in energy) four jets defined using the Durham
	algorithm with $y_\mathrm{cut}=0.008$. The data is presented at the parton
	level and includes the Bengtsson-Zerwas, Korner-Schierholz-Willrodt and
	Nachtmann-Reiter angles as well as the angle between the two softest jets.'
	BibKey: Abbiendi:2001qn
	BibTeX: '@Article{Abbiendi:2001qn,
	author = "Abbiendi, G. and others",
	collaboration = "OPAL",
	title = "{A simultaneous measurement of the QCD colour factors and
	the strong coupling}",
	journal = "Eur. Phys. J.",
	volume = "C20",
	year = "2001",
	pages = "601-615",
	eprint = "hep-ex/0101044",
	archivePrefix = "arXiv",
	doi = "10.1007/s100520100699",
	SLACcitation = "%%CITATION = HEP-EX/0101044;%%"
	}'
	ToDo:
	- Add y23 and R4(ycut) histograms
	- Get data from HepData when available (so far just read off the plots)
	diff --git a/data/anainfo/OPAL_2002_S5361494.info b/data/anainfo/OPAL_2002_S5361494.info
	--- a/data/anainfo/OPAL_2002_S5361494.info
	+++ b/data/anainfo/OPAL_2002_S5361494.info
	@@ -1,39 +1,40 @@
	Name: OPAL_2002_S5361494
	Year: 2002
	Summary: Charged particle multiplicities in heavy and light quark initiated events above the $Z^0$ peak
	Experiment: OPAL
	Collider: LEP 2
	SpiresID: 5361494
	+InspireID: 601225
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Lett. B550 (2002) 33-46
	- hep-ex/0211007
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [130,136,161,172,183,189,192,196,200,202,206]
	PtCuts: [0]
	Description: Measurements of the mean charged multiplicities separately for $b\bar b$,
	$c\bar c$ and light quark ($uds$) initiated events in $e^+e^-$ interactions at energies
	above the $Z^0$ mass. The data is from the LEP running periods between 1995 and 2000.
	BibKey: Abbiendi:2002vn
	BibTeX: '@article{Abbiendi:2002vn,
	author = "Abbiendi, G. and others",
	title = "{Charged particle multiplicities in heavy and light quark
	initiated events above the Z0 peak}",
	collaboration = "OPAL Collaboration",
	journal = "Phys.Lett.",
	volume = "B550",
	pages = "33-46",
	doi = "10.1016/S0370-2693(02)02935-0",
	year = "2002",
	note = "18 pages, 5 figures Report-no: CERN-EP-2002-0079",
	eprint = "hep-ex/0211007",
	archivePrefix = "arXiv",
	primaryClass = "hep-ex",
	reportNumber = "CERN-EP-2002-079",
	SLACcitation = "%%CITATION = HEP-EX/0211007;%%",
	}'
	diff --git a/data/anainfo/OPAL_2003_I599181.info b/data/anainfo/OPAL_2003_I599181.info
	new file mode 100644
	--- /dev/null
	+++ b/data/anainfo/OPAL_2003_I599181.info
	@@ -0,0 +1,40 @@
	+Name: OPAL_2003_I599181
	+Year: 2003
	+Summary: Inclusive analysis of the b quark fragmentation function in Z decays
	+Experiment: OPAL
	+Collider: LEP2
	+InspireID: 599181
	+Status: VALIDATED
	+Authors:
	+ - Simone Amoroso <amoroso@cern.ch>
	+References:
	+ - Eur.Phys.J.C29:463-478,2003
	+ - doi:10.1140/epjc/s2003-01229-x
	+ - arXiv:hep-ex/0210031
	+RunInfo: Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	+
	+NumEvents: 1000000
	+NeedCrossSection: no
	+Beams: [e+,e-]
	+Energies: [91.2]
	+Description:
	+'A study of b quark fragmentation function is presented using inclusively reconstructed weakly decaying B hadrons.
	+The measurement uses about four million hadronic Z decays recorded in 1992-2000 with the OPAL detector at LEP.'
	+BibKey: Abbiendi:2002vt
	+BibTeX: '@article{Abbiendi:2002vt,
	+ author = "Abbiendi, G. and others",
	+ title = "{Inclusive analysis of the b quark fragmentation function
	+ in Z decays at LEP}",
	+ collaboration = "OPAL",
	+ journal = "Eur. Phys. J.",
	+ volume = "C29",
	+ year = "2003",
	+ pages = "463-478",
	+ doi = "10.1140/epjc/s2003-01229-x",
	+ eprint = "hep-ex/0210031",
	+ archivePrefix = "arXiv",
	+ primaryClass = "hep-ex",
	+ reportNumber = "CERN-EP-2002-051",
	+ SLACcitation = "%%CITATION = HEP-EX/0210031;%%"
	+}'
	+
	diff --git a/data/anainfo/OPAL_2004_S6132243.info b/data/anainfo/OPAL_2004_S6132243.info
	--- a/data/anainfo/OPAL_2004_S6132243.info
	+++ b/data/anainfo/OPAL_2004_S6132243.info
	@@ -1,41 +1,42 @@
	Name: OPAL_2004_S6132243
	Year: 2004
	Summary: Event shape distributions and moments in $e^+ e^-$ -> hadrons at 91--209 GeV
	Experiment: OPAL
	Collider: LEP 1 & 2
	SpiresID: 6132243
	+InspireID: 669402
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Eur.Phys.J.C40:287-316,2005
	- arXiv:hep-ex/0503051
	RunInfo:
	Hadronic $e^+ e^-$ events at 4 representative energies (91, 133, 177, 197).
	Runs need to have ISR suppressed, since the analysis was done using a cut of
	$\sqrt{s} - \sqrt{s_\text{reco}} < 1\,\text{GeV}$. Particles with a livetime
	$> 3 \cdot 10^{-10}\,\text{s}$ are considered to be stable.
	NumEvents: 200000
	Beams: [e+, e-]
	Energies: [91.2, 133, 177, 197]
	PtCuts: [0]
	Description:
	Measurement of $e^+ e^-$ event shape variable distributions and their 1st
	to 5th moments in LEP running from the Z pole to the highest LEP 2 energy
	of 209 GeV.
	BibKey: Abbiendi:2004qz
	BibTeX: '@Article{Abbiendi:2004qz,
	author = "Abbiendi, G. and others",
	collaboration = "OPAL",
	title = "{Measurement of event shape distributions and moments in $e^+
	e^- \to$ hadrons at 91 GeV - 209 GeV and a determination of
	$\alpha_s$}",
	journal = "Eur. Phys. J.",
	volume = "C40",
	year = "2005",
	pages = "287-316",
	eprint = "hep-ex/0503051",
	archivePrefix = "arXiv",
	doi = "10.1140/epjc/s2005-02120-6",
	SLACcitation = "%%CITATION = HEP-EX/0503051;%%"
	}'
	diff --git a/data/anainfo/SFM_1984_S1178091.info b/data/anainfo/SFM_1984_S1178091.info
	--- a/data/anainfo/SFM_1984_S1178091.info
	+++ b/data/anainfo/SFM_1984_S1178091.info
	@@ -1,37 +1,37 @@
	Name: SFM_1984_S1178091
	Year: 1984
	Summary: Charged multiplicity distribution in $pp$ interactions at CERN ISR energies
	Experiment: SFM
	Collider: CERN ISR
	SpiresID: 1178091
	-Status: VALIDATED
	+InspireID: 196601
	+Status: UNVALIDATED
	Authors:
	- - Holger Schulz <holger.schulz@physik.hu-berlin.de>
	+ - Holger Schulz <holger.schulz@durham.ac.uk>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Phys.Rev.D30:528,1984
	RunInfo:
	- QCD events, double-diffractive events should be turned on as well.
	-NumEvents: 1000000
	+ QCD events, double-diffractive events.
	+NumEvents: 100000
	Beams: [p+, p+]
	Energies: [30.4, 44.5, 52.2, 62.2]
	PtCuts: [0]
	Description:
	WARNING - implemented to the best of abilities, no theory curve in the
	publication to compare to.
	Charged multiplicities are measured at $\sqrt{s} = 30.4$, 44.5, 52.2
	and 62.2 GeV using a minimum-bias trigger. The data is sub-divided
	- into inelastic as well as non-single-diffractive events. However,
	- the implementation of the diffractive events will require some work.
	+ into inelastic as well as non-single-diffractive events.
	BibKey: Breakstone:1983ns
	BibTeX: '@Article{Breakstone:1983ns,
	author = "Breakstone, A. and others",
	collaboration = "Ames-Bologna-CERN-Dortmund-Heidelberg-Warsaw",
	title = "{Charged multiplicity distribution in $pp$ interactions at ISR energies}",
	journal = "Phys. Rev.",
	volume = "D30",
	year = "1984",
	pages = "528",
	doi = "10.1103/PhysRevD.30.528",
	SLACcitation = "%%CITATION = PHRVA,D30,528;%%"
	}'
	diff --git a/data/anainfo/SLD_1996_S3398250.info b/data/anainfo/SLD_1996_S3398250.info
	--- a/data/anainfo/SLD_1996_S3398250.info
	+++ b/data/anainfo/SLD_1996_S3398250.info
	@@ -1,35 +1,36 @@
	Name: SLD_1996_S3398250
	Year: 1996
	Summary: Charged particle multiplicities in heavy and light quark initiated events on the $Z^0$ peak
	Experiment: SLD
	Collider: SLC
	SpiresID: 3398250
	+InspireID: 422172
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Lett.B386:475-485,1996
	- hep-ex/9608008
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: Measurements of the mean charged multiplicities separately for $b\bar b$,
	$c\bar c$ and light quark ($uds$) initiated events in $e^+e^-$ interactions at the $Z^0$ mass.
	BibKey: Abe:1996zi
	BibTeX: '@Article{Abe:1996zi,
	author = "Abe, K. and others",
	collaboration = "SLD",
	title = "{Measurement of the charged multiplicities in b, c and
	light quark events from Z0 decays}",
	journal = "Phys. Lett.",
	volume = "B386",
	year = "1996",
	pages = "475-485",
	eprint = "hep-ex/9608008",
	archivePrefix = "arXiv",
	doi = "10.1016/0370-2693(96)01025-8",
	SLACcitation = "%%CITATION = HEP-EX/9608008;%%"
	}'
	diff --git a/data/anainfo/SLD_1999_S3743934.info b/data/anainfo/SLD_1999_S3743934.info
	--- a/data/anainfo/SLD_1999_S3743934.info
	+++ b/data/anainfo/SLD_1999_S3743934.info
	@@ -1,38 +1,39 @@
	Name: SLD_1999_S3743934
	Year: 1999
	Summary: Production of $\pi^+$, $K^+$, $K^0$, $K^{*0}$, $\Phi$, $p$ and $\Lambda^0$ in hadronic $Z^0$ decay
	Experiment: SLD
	Collider: SLC
	SpiresID: 3743934
	+InspireID: 469925
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Rev.D59:052001,1999
	- hep-ex/9805029
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Measurement of scaled momentum distributions and fragmentation functions
	in flavour tagged events at SLC. SLD measured these
	observables in uds-, c-, and b-events separately. An inclusive
	measurement is also included.
	BibKey: Abe:1998zs
	BibTeX: '@Article{Abe:1998zs,
	author = "Abe, K. and others",
	collaboration = "SLD",
	title = "{Production of pi+, K+, K0, K*0, Phi, p and Lambda0 in
	hadronic Z0 decays}",
	journal = "Phys. Rev.",
	volume = "D59",
	year = "1999",
	pages = "052001",
	eprint = "hep-ex/9805029",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.59.052001",
	SLACcitation = "%%CITATION = HEP-EX/9805029;%%"
	}'
	diff --git a/data/anainfo/SLD_2002_S4869273.info b/data/anainfo/SLD_2002_S4869273.info
	--- a/data/anainfo/SLD_2002_S4869273.info
	+++ b/data/anainfo/SLD_2002_S4869273.info
	@@ -1,38 +1,39 @@
	Name: SLD_2002_S4869273
	Year: 2002
	Summary: Measurement of the b-quark fragmentation function in $Z^0$ decays
	Experiment: SLD
	Collider: SLC
	SpiresID: 4869273
	+InspireID: 582951
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys. Rev.D65:092006,2002
	- hep-ex/0202031
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description:
	Measurement of the $b$-quark fragmentation function by SLC.
	The fragmentation function for weakly decaying $b$-quarks has been
	measured.
	BibKey: Abe:2002iq
	BibTeX: '@Article{Abe:2002iq,
	author = "Abe, Koya and others",
	collaboration = "SLD",
	title = "{Measurement of the b-quark fragmentation function in Z0
	decays}",
	journal = "Phys. Rev.",
	volume = "D65",
	year = "2002",
	pages = "092006",
	eprint = "hep-ex/0202031",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.65.092006",
	note = "[Erratum-ibid.D66:079905,2002]",
	SLACcitation = "%%CITATION = HEP-EX/0202031;%%"
	}'
	diff --git a/data/anainfo/SLD_2004_S5693039.info b/data/anainfo/SLD_2004_S5693039.info
	--- a/data/anainfo/SLD_2004_S5693039.info
	+++ b/data/anainfo/SLD_2004_S5693039.info
	@@ -1,36 +1,37 @@
	Name: SLD_2004_S5693039
	Year: 2004
	Summary: Production of $\pi^+$, $\pi^-$, $K^+$, $K^-$, $p$ and $\bar p$ in Light ($uds$), $c$ and $b$ Jets from Z Decays
	Experiment: SLD
	Collider: SLC
	SpiresID: 5693039
	+InspireID: 630327
	Status: VALIDATED
	Authors:
	- Peter Richardson <Peter.Richardson@durham.ac.uk>
	References:
	- Phys.Rev.D69:072003,2004
	- arXiv:hep-ex/0310017
	RunInfo:
	Hadronic Z decay events generated on the Z pole ($\sqrt{s} = 91.2$ GeV)
	NumEvents: 1000000
	Beams: [e+, e-]
	Energies: [91.2]
	PtCuts: [0]
	Description: Measurements of the differential production rates of stable charged particles in hadronic $Z^0$ decays, and of charged pions,
	kaons and protons identified over a wide momentum range. In addition to flavour-inclusive $Z^0$ decays, measurements are made for $Z^0$
	decays into light ($u$, $d$, $s$), $c$ and $b$ primary flavors.
	BibKey: Abe:2003iy
	BibTeX: '@Article{Abe:2003iy,
	author = "Abe, Koya and others",
	collaboration = "SLD",
	title = "{Production of $\pi^+$, $\pi^-$, $K^+$, $K^-$, $p$ and $\bar p$ in light
	$(uds)$, $c$ and $b$ jets from $Z^0$ decays}",
	journal = "Phys. Rev.",
	volume = "D69",
	year = "2004",
	pages = "072003",
	eprint = "hep-ex/0310017",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevD.69.072003",
	SLACcitation = "%%CITATION = HEP-EX/0310017;%%"
	}'
	diff --git a/data/anainfo/STAR_2006_S6500200.info b/data/anainfo/STAR_2006_S6500200.info
	--- a/data/anainfo/STAR_2006_S6500200.info
	+++ b/data/anainfo/STAR_2006_S6500200.info
	@@ -1,38 +1,39 @@
	Name: STAR_2006_S6500200
	Year: 2006
	Summary: Identified hadron spectra in pp at 200 GeV
	Experiment: STAR
	Collider: RHIC pp 200 GeV
	SpiresID: 6500200
	+InspireID: 709170
	Status: VALIDATED
	Authors:
	- Bedanga Mohanty <bedanga@rcf.bnl.gov>
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Phys. Lett. B637, 161
	- arXiv:nucl-ex/0601033
	RunInfo:
	pp at 200 GeV
	NumEvents: 2500000
	Beams: [p+, p+]
	Energies: [200]
	PtCuts: [0]
	Description:
	pT distributions of charged pions and (anti)protons in pp collisions
	at $\sqrt{s} = 200$ GeV, measured by the STAR experiment at RHIC in
	non-single-diffractive minbias events.
	BibKey: Adams:2006nd
	BibTeX: '@Article{Adams:2006nd,
	author = "Adams, John and others",
	collaboration = "STAR",
	title = "{Identified hadron spectra at large transverse momentum in
	$p\,p$ and $d\,Au$ collisions at $\sqrt{s} = 200$ GeV}",
	journal = "Phys. Lett.",
	volume = "B637",
	year = "2006",
	pages = "161-169",
	eprint = "nucl-ex/0601033",
	archivePrefix = "arXiv",
	doi = "10.1016/j.physletb.2006.04.032",
	SLACcitation = "%%CITATION = NUCL-EX/0601033;%%"
	}'
	diff --git a/data/anainfo/STAR_2006_S6860818.info b/data/anainfo/STAR_2006_S6860818.info
	--- a/data/anainfo/STAR_2006_S6860818.info
	+++ b/data/anainfo/STAR_2006_S6860818.info
	@@ -1,38 +1,39 @@
	Name: STAR_2006_S6860818
	Year: 2006
	Summary: Strange particle production in pp at 200 GeV
	Experiment: STAR
	Collider: RHIC pp 200 GeV
	SpiresID: 6860818
	+InspireID: 722757
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Phys. Rev. C75, 064901
	- nucl-ex/0607033
	RunInfo:
	pp at 200 GeV
	NumEvents: 2500000
	Beams: [p+, p+]
	Energies: [200]
	PtCuts: [0]
	Description:
	pT distributions of identified strange particles in pp collisions
	at $\sqrt{s} = 200$ GeV, measured by the STAR experiment at RHIC in
	non-single-diffractive minbias events. WARNING The $\langle pT \rangle$ vs.
	particle mass plot is not validated yet and might be wrong.
	BibKey: Abelev:2006cs
	BibTeX: '@Article{Abelev:2006cs,
	author = "Abelev, B. I. and others",
	collaboration = "STAR",
	title = "{Strange particle production in p + p collisions at
	s**(1/2) = 200-GeV}",
	journal = "Phys. Rev.",
	volume = "C75",
	year = "2007",
	pages = "064901",
	eprint = "nucl-ex/0607033",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevC.75.064901",
	SLACcitation = "%%CITATION = NUCL-EX/0607033;%%"
	}'
	diff --git a/data/anainfo/STAR_2006_S6870392.info b/data/anainfo/STAR_2006_S6870392.info
	--- a/data/anainfo/STAR_2006_S6870392.info
	+++ b/data/anainfo/STAR_2006_S6870392.info
	@@ -1,38 +1,39 @@
	Name: STAR_2006_S6870392
	Year: 2006
	Summary: Inclusive jet cross-section in pp at 200 GeV
	Experiment: STAR
	Collider: RHIC pp 200 GeV
	SpiresID: 6870392
	+InspireID: 723509
	Status: VALIDATED
	Authors:
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- Phys. Rev. Lett. 97, 252001
	- hep-ex/0608030
	RunInfo:
	pp at 200 GeV
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [200]
	PtCuts: [0]
	Description:
	Inclusive jet cross section as a function of pT in pp collisions
	at $\sqrt{s} = 200$ GeV, measured by the STAR experiment at RHIC.
	NeedCrossSection: yes
	BibKey: Abelev:2006uq
	BibTeX: '@Article{Abelev:2006uq,
	author = "Abelev, B. I. and others",
	collaboration = "STAR",
	title = "{Longitudinal double-spin asymmetry and cross section for
	inclusive jet production in polarized proton collisions at
	s**(1/2) = 200-GeV}",
	journal = "Phys. Rev. Lett.",
	volume = "97",
	year = "2006",
	pages = "252001",
	eprint = "hep-ex/0608030",
	archivePrefix = "arXiv",
	doi = "10.1103/PhysRevLett.97.252001",
	SLACcitation = "%%CITATION = HEP-EX/0608030;%%"
	}'
	diff --git a/data/anainfo/STAR_2008_S7869363.info b/data/anainfo/STAR_2008_S7869363.info
	--- a/data/anainfo/STAR_2008_S7869363.info
	+++ b/data/anainfo/STAR_2008_S7869363.info
	@@ -1,39 +1,40 @@
	Name: STAR_2008_S7869363
	Year: 2008
	-Summary: Multiplicities and pT spectra from STAR for pp at 200 GeV
	+Summary: Multiplicities and pT spectra from STAR for $pp$ at 200 GeV
	Experiment: STAR
	Collider: RHIC
	SpiresID: 7869363
	+InspireID: 793126
	Status: UNVALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	References:
	- arXiv:0808.2041
	- http://drupal.star.bnl.gov/STAR/files/starpublications/124/data.html
	RunInfo:
	QCD (pp) events at 200 GeV
	NumEvents: 1.000.000
	Beams: [p+, p+]
	Energies: [200]
	PtCuts:
	Description:
	'Charged multiplicity and identified charged particle spectra'
	BibKey: :2008ez
	BibTeX: '@Article{:2008ez,
	author = "Abelev, B. I. and others",
	collaboration = "STAR",
	title = "{Systematic measurements of identified particle spectra in
	$p p$, $d^+$ Au and Au+Au collisions from STAR}",
	journal = "Phys. Rev.",
	volume = "C79",
	year = "2009",
	pages = "034909",
	eprint = "0808.2041",
	archivePrefix = "arXiv",
	primaryClass = "nucl-ex",
	doi = "10.1103/PhysRevC.79.034909",
	SLACcitation = "%%CITATION = 0808.2041;%%"
	}'
	ToDo:
	- Understand first bin in multiplicity distribution
	- - Normalise to generator values (just scale by 1/nPassedCuts?) rather than data areas
	+ - Normalise to generator values (just scale by 1/nPassedCuts?) rather than data areas?
	diff --git a/data/anainfo/STAR_2008_S7993412.info b/data/anainfo/STAR_2008_S7993412.info
	--- a/data/anainfo/STAR_2008_S7993412.info
	+++ b/data/anainfo/STAR_2008_S7993412.info
	@@ -1,40 +1,41 @@
	Name: STAR_2008_S7993412
	Year: 2008
	-Summary: Di-hadron correlations in d-Au at 200 GeV
	+Summary: Di-hadron correlations in $d$-Au at 200 GeV
	Experiment: STAR
	Collider: RHIC d-Au 200 GeV
	SpiresID: 7993412
	+InspireID: 810030
	Status: UNVALIDATED
	Authors:
	- Christine Nattrass <christine.nattrass@yale.edu>
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- arXiv:0809.5261 [nucl-ex]
	RunInfo:
	- d-Au at 200 GeV (use pp Monte Carlo! See description)
	+ $d$-Au at 200 GeV, but use $pp$ Monte Carlo! See description.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [200]
	PtCuts: [0]
	Description:
	Correlation in $\eta$ and $\phi$ between the charged hadron with the
	highest pT (``trigger particle'') and the other charged hadrons in the
	event (``associated particles''). The data was collected in d-Au
	- collisions at 200 GeV. Nevertheless, it is very proton-proton like and
	+ collisions at 200 GeV. Nevertheless, it is very proton--proton like and
	can therefore be compared to $pp$ Monte Carlo (not for tuning, but for
	qualitative studies.)
	BibKey: Nattrass:2008tw
	BibTeX: '@Article{Nattrass:2008tw,
	author = "Nattrass, Christine",
	title = "{Energy and system dependence of high-$p_T$ triggered two-
	particle near-side correlations}",
	journal = "Eur. Phys. J.",
	volume = "C62",
	year = "2009",
	pages = "265-269",
	eprint = "0809.5261",
	archivePrefix = "arXiv",
	primaryClass = "nucl-ex",
	doi = "10.1140/epjc/s10052-009-1037-8",
	SLACcitation = "%%CITATION = 0809.5261;%%"
	}'
	diff --git a/data/anainfo/STAR_2009_UE_HELEN.info b/data/anainfo/STAR_2009_UE_HELEN.info
	--- a/data/anainfo/STAR_2009_UE_HELEN.info
	+++ b/data/anainfo/STAR_2009_UE_HELEN.info
	@@ -1,31 +1,31 @@
	Name: STAR_2009_UE_HELEN
	Year: 2009
	-Summary: UE measurement in pp at 200 GeV
	+Summary: UE measurement in $pp$ at 200 GeV
	Experiment: STAR
	-Collider: RHIC pp 200 GeV
	+Collider: RHIC
	SpiresID: None
	Status: PRELIMINARY
	Authors:
	- Helen Caines <helen.caines@yale.edu>
	- Hendrik Hoeth <hendrik.hoeth@cern.ch>
	References:
	- arXiv:0910.5203
	- arXiv:0907.3460
	- - WARNING! Mark as "STAR preliminary" and contact authors when using it!
	RunInfo:
	- pp at 200 GeV
	+ $pp$ at 200 GeV
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [200]
	PtCuts: [2, 10]
	Description:
	+ WARNING! Mark as "STAR preliminary" and contact authors when using this!
	UE analysis similar to Rick Field's leading jet analysis. SIScone with
	radius/resolution parameter R=0.7 is used. Particles with $pT > 0.2~\text{GeV}$
	and $\|\eta\| < 1$ are included in the analysis. All particles are assumed
	to have zero mass. Only jets with neutral energy $< 0.7$ are included.
	For the transMIN and transMAX $\Delta(\phi)$ is between $\pi/3$ and $2\pi/3$, and
	$\Delta(\eta) < 2.0$. For the jet region the area of the jet is used for the
	normalization, i.e. the scaling factor is $\pi R^2$ and not
	$\mathrm{d}\phi\mathrm{d}\eta$ (this is different from what Rick Field does!).
	The tracking efficiency is $\sim 0.8$, but that is an approximation,
	as below $pT \sim 0.6~\text{GeV}$ it is falling quite steeply.
	diff --git a/data/anainfo/TASSO_1990_S2148048.info b/data/anainfo/TASSO_1990_S2148048.info
	--- a/data/anainfo/TASSO_1990_S2148048.info
	+++ b/data/anainfo/TASSO_1990_S2148048.info
	@@ -1,35 +1,36 @@
	Name: TASSO_1990_S2148048
	Year: 1990
	Summary: Event shapes in $e^+ e^-$ annihilation at 14--44\;GeV
	Experiment: TASSO
	Collider: PETRA
	SpiresID: 2148048
	+InspireID: 294755
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	References:
	- Z.Phys.C47:187-198,1990
	- DESY-90-013
	RunInfo: '$e^+ e^- \to \text{jet jet}$ (+ jets). Kinematic cuts such as
	CKIN(1) in Pythia need to be set slightly below the CMS energy.'
	NumEvents: 100000
	Beams: [e-, e+]
	Energies: [14.03, 21.99, 35, 43.7]
	PtCuts:
	Description:
	'Event shapes Thrust, Sphericity, Aplanarity at four different energies'
	BibKey: Braunschweig:1990yd
	BibTeX: '@Article{Braunschweig:1990yd,
	author = "Braunschweig, W. and others",
	collaboration = "TASSO",
	title = "{Global jet properties at 14\;GeV to 44\;GeV center-of-mass energy in $e^+e^-$ annihilation}",
	journal = "Z. Phys.",
	volume = "C47",
	year = "1990",
	pages = "187-198",
	doi = "10.1007/BF01552339",
	SLACcitation = "%%CITATION = ZEPYA,C47,187;%%"
	}'
	ToDo:
	- Add the missing distributions
	- Add missing Trigger conditions, move to Trigger Projection
	diff --git a/data/anainfo/TOTEM_2012_002.info b/data/anainfo/TOTEM_2012_I1220862.info
	rename from data/anainfo/TOTEM_2012_002.info
	rename to data/anainfo/TOTEM_2012_I1220862.info
	--- a/data/anainfo/TOTEM_2012_002.info
	+++ b/data/anainfo/TOTEM_2012_I1220862.info
	@@ -1,36 +1,47 @@
	-Name: TOTEM_2012_002
	+Name: TOTEM_2012_I1220862
	Year: 2012
	-Summary: Measurement of proton-proton elastic scattering and total cross section at $\sqrt{s} = 7\;\TeV$.
	+Summary: Measurement of proton-proton elastic scattering and total cross section at $\sqrt{s} = 7\;\TeV$
	Experiment: TOTEM
	Collider: LHC
	-#InspireID:
	+InspireID: 1220862
	Status: VALIDATED
	Authors:
	- Sercan Sen <Sercan.Sen@cern.ch>
	- Peter Skands <Peter.Skands@cern.ch>
	References:
	- CERN-PH-EP-2012-239
	- http://cds.cern.ch/record/1472948
	RunInfo:
	Elastic events only.
	NumEvents: 1000000
	Beams: [p+, p+]
	Energies: [7000]
	PtCuts: [0]
	Description:
	'Measurement of the elastic differential cross-section in proton-proton interactions at a centre-of-mass energy $\sqrt{s} = 7\;\TeV$ at the LHC.
	The data, which cover the $\|t\|$ range $0.005-0.2\;\GeV^2$, were collected using Roman Pot detectors very close to the outgoing beam
	in October 2011, allowing the precise extrapolation down to the optical point, $t = 0$, and hence the derivation of the elastic as well as
	the total cross-section via the optical theorem.'
	BibKey: Antchev:1472948
	-BibTeX: '@techreport{Antchev:1472948,
	- author = "Antchev, G. and others",
	- collaboration = "TOTEM",
	- title = "Measurement of proton-proton elastic scattering and total cross-section at $\sqrt{s} = 7$ TeV",
	- institution = "CERN",
	- address = "Geneva",
	- number = "CERN-PH-EP-2012-239. TOTEM-2012-002",
	- month = "Aug",
	- year = "2012"}'
	-ToDo:
	- - Rename and add Inspire ID field when available.
	+BibTeX: '@article{Antchev:2013gaa,
	+ author = "Antchev, G. and others",
	+ title = "{Measurement of proton-proton elastic scattering and
	+ total cross-section at S**(1/2) = 7-TeV}",
	+ collaboration = "TOTEM",
	+ journal = "Europhys. Lett.",
	+ volume = "101",
	+ year = "2013",
	+ pages = "21002",
	+ doi = "10.1209/0295-5075/101/21002",
	+ SLACcitation = "%%CITATION = EULEE,101,21002;%%"
	+}'
	+# BibKey: Antchev:1472948
	+# BibTeX: '@techreport{Antchev:1472948,
	+# author = "Antchev, G. and others",
	+# collaboration = "TOTEM",
	+# title = "Measurement of proton-proton elastic scattering and total cross-section at $\sqrt{s} = 7$ TeV",
	+# institution = "CERN",
	+# address = "Geneva",
	+# number = "CERN-PH-EP-2012-239. TOTEM-2012-002",
	+# month = "Aug",
	+# year = "2012"}'
	diff --git a/data/anainfo/UA1_1990_S2044935.info b/data/anainfo/UA1_1990_S2044935.info
	--- a/data/anainfo/UA1_1990_S2044935.info
	+++ b/data/anainfo/UA1_1990_S2044935.info
	@@ -1,34 +1,35 @@
	Name: UA1_1990_S2044935
	Year: 1990
	Summary: UA1 multiplicities, transverse momenta and transverse energy distributions.
	Experiment: UA1
	Collider: SPS
	SpiresID: 2044935
	+InspireID: 280412
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Christophe Vaillant <c.l.j.j.vaillant@durham.ac.uk>
	References:
	- "Nucl.Phys.B353:261,1990"
	RunInfo: QCD min bias events at sqrtS = 63, 200, 500 and 900 GeV.
	Description:
	Particle multiplicities, transverse momenta and transverse energy
	distributions at the UA1 experiment, at energies of 200, 500 and 900 GeV
	(with one plot at 63 GeV for comparison).
	Beams: [p-, p+]
	Energies: [63, 200, 500, 900]
	PtCuts: [0]
	NeedCrossSection: yes
	BibKey: Albajar:1989an
	BibTeX: '@Article{Albajar:1989an,
	author = "Albajar, C. and others",
	collaboration = "UA1",
	title = "{A Study of the General Characteristics of $p\bar{p}$
	Collisions at $\sqrt{s}$ = 0.2 TeV to 0.9 TeV}",
	journal = "Nucl. Phys.",
	volume = "B335",
	year = "1990",
	pages = "261",
	doi = "10.1016/0550-3213(90)90493-W",
	SLACcitation = "%%CITATION = NUPHA,B335,261;%%"
	}'
	diff --git a/data/anainfo/UA5_1982_S875503.info b/data/anainfo/UA5_1982_S875503.info
	--- a/data/anainfo/UA5_1982_S875503.info
	+++ b/data/anainfo/UA5_1982_S875503.info
	@@ -1,32 +1,33 @@
	Name: UA5_1982_S875503
	SpiresID: 875503
	+InspireID: 176647
	Summary: UA5 multiplicity and pseudorapidity distributions for $pp$ and $p\bar{p}$.
	Status: VALIDATED
	Experiment: UA5
	Collider: SPS
	Year: 1982
	RunInfo: Min bias QCD events at $\sqrt{s} = 53$\;GeV. Run with both $pp$ and $p\bar{p}$ beams.
	Beams: [[p-, p+], [p+, p+]]
	Energies: [53]
	PtCuts: [0]
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Christophe Vaillant <c.l.j.j.vaillant@durham.ac.uk>
	References:
	- Phys.Lett.112B:183,1982
	Description:
	Comparisons of multiplicity and pseudorapidity distributions for $pp$ and
	$p\bar{p}$ collisions at 53 GeV, based on the UA5 53~GeV runs in 1982.
	Data confirms the lack of significant difference between the two beams.
	BibKey: Alpgard:1982zx
	BibTeX: '@Article{Alpgard:1982zx,
	author = "Alpgard, K. and others",
	collaboration = "UA5",
	title = "{Comparison of $p\bar{p}$ and $pp$ interactions at $\sqrt{s} = 53$ GeV}",
	journal = "Phys. Lett.",
	volume = "B112",
	year = "1982",
	pages = "183",
	doi = "10.1016/0370-2693(82)90325-2",
	SLACcitation = "%%CITATION = PHLTA,B112,183;%%"
	}'
	diff --git a/data/anainfo/UA5_1986_S1583476.info b/data/anainfo/UA5_1986_S1583476.info
	--- a/data/anainfo/UA5_1986_S1583476.info
	+++ b/data/anainfo/UA5_1986_S1583476.info
	@@ -1,41 +1,42 @@
	Name: UA5_1986_S1583476
	Year: 1986
	Summary: Pseudorapidity distributions in $p\bar{p}$ (NSD, NSD+SD) events at $\sqrt{s} = 200$ and 900 GeV
	Experiment: UA5
	Collider: CERN SPS
	SpiresID: 1583476
	+InspireID: 233599
	Status: VALIDATED
	Authors:
	- Andy Buckley <andy.buckley@cern.ch>
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	- Christophe Vaillant <c.l.j.j.vaillant@durham.ac.uk>
	References:
	- Eur. Phys. J. C33, 1, 1986
	RunInfo:
	'* Single- and double-diffractive, plus non-diffractive inelastic, events.
	* $p\bar{p}$ collider, $\sqrt{s} = 200$ or 900 GeV.
	* The trigger implementation for NSD events is the same as in, e.g.,
	the UA5_1989 analysis. No further cuts are needed.'
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [200, 900]
	PtCuts: [0]
	Description:
	This study comprises measurements of pseudorapidity distributions measured with the UA5
	detector at 200 and 900 GeV center of momentum energy. There are distributions for
	non-single diffractive (NSD) events and also for the combination of single- and double-diffractive
	events. The NSD distributions are further studied for certain ranges of the events charged
	multiplicity.
	BibKey: Alner:1986xu
	BibTeX: '@Article{Alner:1986xu,
	author = "Alner, G. J. and others",
	collaboration = "UA5",
	title = "{Scaling of Pseudorapidity Distributions at c.m. Energies
	Up to 0.9-TeV}",
	journal = "Z. Phys.",
	volume = "C33",
	year = "1986",
	pages = "1-6",
	doi = "10.1007/BF01410446",
	SLACcitation = "%%CITATION = ZEPYA,C33,1;%%"
	}'
	diff --git a/data/anainfo/UA5_1987_S1640666.info b/data/anainfo/UA5_1987_S1640666.info
	--- a/data/anainfo/UA5_1987_S1640666.info
	+++ b/data/anainfo/UA5_1987_S1640666.info
	@@ -1,35 +1,36 @@
	Name: UA5_1987_S1640666
	Year: 1987
	Summary: UA5 charged multiplicity measurements at 546 GeV
	Experiment: UA5
	Collider: CERN SPS
	SpiresID: 1640666
	+InspireID: 244829
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	References:
	- Phys.Rept.154:247-383,1987
	RunInfo:
	QCD and diffractive events at 546 GeV
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [546]
	PtCuts:
	Description:
	'Charged particle multiplicity measurement.'
	BibKey: Alner:1987wb
	BibTeX: '@Article{Alner:1987wb,
	author = "Alner, G. J. and others",
	collaboration = "UA5",
	title = "{UA5: A general study of proton-antiproton physics at
	$\sqrt{s}$ = 546-GeV}",
	journal = "Phys. Rept.",
	volume = "154",
	year = "1987",
	pages = "247-383",
	doi = "10.1016/0370-1573(87)90130-X",
	SLACcitation = "%%CITATION = PRPLC,154,247;%%"
	}'
	ToDo:
	- Include more distributions

	diff --git a/data/anainfo/UA5_1988_S1867512.info b/data/anainfo/UA5_1988_S1867512.info
	--- a/data/anainfo/UA5_1988_S1867512.info
	+++ b/data/anainfo/UA5_1988_S1867512.info
	@@ -1,50 +1,51 @@
	Name: UA5_1988_S1867512
	Year: 1988
	Summary: Charged particle correlations in UA5 $p\bar{p}$ NSD events at $\sqrt{s} = 200$, 546 and 900\;GeV
	Experiment: UA5
	Collider: CERN SPS
	SpiresID: 1867512
	+InspireID: 263399
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	References:
	- Z.Phys.C37:191-213,1988
	RunInfo:
	"ppbar events. Non-single diffractive events need to be switched on.
	The trigger implementation is the same as in UA5_1989_S1926373.
	Important: Only the correlation strengths with symmetric eta bins
	should be used for tuning."
	NumEvents: 100000
	Beams: [p-, p+]
	Energies: [200, 546, 900]
	PtCuts: [0]
	Description:
	"Data on two-particle pseudorapidity and multiplicity correlations
	of charged particles for non single-diffractive $p\\bar{p}$ collisions at
	c.m. energies of 200, 546 and 900~GeV. Pseudorapidity correlations are interpreted
	in terms of a cluster model, which has been motivated by this and other
	experiments, require on average about two charged particles per cluster.
	The decay width of the clusters in pseudorapidity is approximately independent
	of multiplicity and of c.m. energy. The investigations of correlations in terms
	of pseudorapidity gaps confirm the picture of cluster production. The strength
	of forward--backward multiplicity correlations increases linearly with ins and
	depends strongly on position and size of the pseudorapidity gap separating
	the forward and backward interval. All our correlation studies can be understood
	in terms of a cluster model in which clusters contain on average about two
	charged particles, i.e. are of similar magnitude to earlier estimates from the ISR."
	BibKey: Ansorge:1988fg
	BibTeX: '@Article{Ansorge:1988fg,
	author = "Ansorge, R. E. and others",
	collaboration = "UA5",
	title = "{CHARGED PARTICLE CORRELATIONS IN ANTI-P P COLLISIONS AT
	C.M. ENERGIES OF 200-GEV, 546-GEV AND 900-GEV}",
	journal = "Z. Phys.",
	volume = "C37",
	year = "1988",
	pages = "191-213",
	doi = "10.1007/BF01579906",
	SLACcitation = "%%CITATION = ZEPYA,C37,191;%%"
	}'
	ToDo:
	- Check sanity of implementation of b with assymetric eta bins
	- Get rid of vectors, use temp. histos instead
	diff --git a/data/anainfo/UA5_1989_S1926373.info b/data/anainfo/UA5_1989_S1926373.info
	--- a/data/anainfo/UA5_1989_S1926373.info
	+++ b/data/anainfo/UA5_1989_S1926373.info
	@@ -1,41 +1,42 @@
	Name: UA5_1989_S1926373
	Year: 1989
	Summary: UA5 charged multiplicity measurements
	Experiment: UA5
	Collider: CERN SPS
	SpiresID: 1926373
	+InspireID: 267179
	Status: VALIDATED
	Authors:
	- Holger Schulz <holger.schulz@physik.hu-berlin.de>
	- Christophe L. J. Vaillant <c.l.j.j.vaillant@durham.ac.uk>
	- Andy Buckley <andy.buckley@cern.ch>
	References:
	- Z. Phys. C - Particles and Fields 43, 357-374 (1989)
	- doi:10.1007/BF01506531
	RunInfo:
	Minimum bias events at $\sqrt{s} = 200$ and 900 GeV.
	Enable single and double diffractive events in addition to non-diffractive processes.
	NumEvents: 1000000
	Beams: [p-, p+]
	Energies: [200, 900]
	PtCuts: [0]
	Description:
	Multiplicity distributions of charged particles produced in non-single-diffractive
	collisions between protons and antiprotons at centre-of-mass energies of 200 and
	900 GeV. The data were recorded in the UA5 streamer chambers at the CERN collider,
	which was operated in a pulsed mode between the two energies. This analysis
	confirms the violation of KNO scaling in full phase space found by the UA5 group
	at an energy of 546 GeV, with similar measurements at 200 and 900 GeV.
	BibKey: Ansorge:1988kn
	BibTeX: '@Article{Ansorge:1988kn,
	author = "Ansorge, R. E. and others",
	collaboration = "UA5",
	title = "{Charged Particle Multiplicity Distributions at 200-GeV and
	900-GeV Center-Of-Mass Energy}",
	journal = "Z. Phys.",
	volume = "C43",
	year = "1989",
	pages = "357",
	doi = "10.1007/BF01506531",
	SLACcitation = "%%CITATION = ZEPYA,C43,357;%%"
	}'
	diff --git a/data/anainfo/ZEUS_2001_S4815815.info b/data/anainfo/ZEUS_2001_S4815815.info
	--- a/data/anainfo/ZEUS_2001_S4815815.info
	+++ b/data/anainfo/ZEUS_2001_S4815815.info
	@@ -1,50 +1,52 @@
	Name: ZEUS_2001_S4815815
	Year: 2001
	Summary: Dijet photoproduction analysis
	Experiment: ZEUS
	Collider: HERA Run I
	SpiresID: 4815815
	+InspireID: 568665
	Status: UNVALIDATED
	Authors:
	+ - Andy Buckley <andy.buckley@cern.ch>
	- Jon Butterworth <jmb@hep.ucl.ac.uk>
	References:
	- Eur.Phys.J.C23:615,2002
	- DESY 01/220
	- hep-ex/0112029
	RunInfo:
	820 GeV protons colliding with 27.5 GeV positrons;
	Direct and resolved photoproduction of dijets;
	Leading jet $pT > 14$ GeV, second jet $pT > 11$ GeV;
	Jet pseudorapidity $-1 < \|\eta\| < 2.4$
	NumEvents: 1000000
	Beams: [p+, e+]
	Energies: [[820, 27.5]]
	PtCuts: [0]
	Description:
	ZEUS photoproduction of jets from proton--positron collisions at beam
	energies of 820~GeV on 27.5~GeV. Photoproduction can either be direct,
	in which case the photon interacts directly with the parton, or
	resolved, in which case the photon acts as a source of quarks and
	gluons. A photon-proton centre of mass energy of between 134~GeV and
	227~GeV is probed, with values of $x_P$, the fractional momentum of the
	partons inside the proton, predominantly in the region between 0.01
	and 0.1. The fractional momentum of the partons from the photon,
	- $x\gamma$, is in the region 0.1 to 1. Jets are reconstructed in the
	+ $x_\gamma$, is in the region 0.1 to 1. Jets are reconstructed in the
	range $-1 < \|\eta\| < 2.4$ using the $k_\perp$ algorithm with an $R$
	- parameter of 1.0. The minimum pT of the leading jet should be greater
	- than 14~GeV, and at least one other jet must have $pT > 11$~GeV.
	+ parameter of 1.0. The minimum \pT of the leading jet should be greater
	+ than 14~GeV, and at least one other jet must have $\pT > 11$~GeV.
	BibKey: Chekanov:2001bw
	BibTeX: '@Article{Chekanov:2001bw,
	author = "Chekanov, S. and others",
	collaboration = "ZEUS",
	title = "{Dijet photoproduction at HERA and the structure of the
	photon}",
	journal = "Eur. Phys. J.",
	volume = "C23",
	year = "2002",
	pages = "615-631",
	eprint = "hep-ex/0112029",
	archivePrefix = "arXiv",
	doi = "10.1007/s100520200936",
	SLACcitation = "%%CITATION = HEP-EX/0112029;%%"
	}'
	diff --git a/data/plotinfo/ALEPH_1995_I382179.plot b/data/plotinfo/ALEPH_1995_I382179.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ALEPH_1995_I382179.plot
	@@ -0,0 +1,22 @@
	+# BEGIN PLOT /ALEPH_1995_I382179/d01-x01-y01
	+Title=$\pi^\pm$ momentum
	+XLabel= $z=p/p_{\text{beam}}$
	+YLabel=$1/\sigma \, \text{d}\sigma/\text{d}p$ [$\text{GeV}^-1$]
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ALEPH_1995_I382179/d02-x01-y01
	+Title=$K^\pm$ momentum
	+XLabel= $z=p/p_{\text{beam}}$
	+YLabel=$1/\sigma \, \text{d}\sigma/\text{d}p$ [$\text{GeV}^-1$]
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ALEPH_1995_I382179/d03-x01-y01
	+Title=$p,\bar{p}$ momentum
	+XLabel= $z=p/p_{\text{beam}}$
	+YLabel=$1/\sigma \, \text{d}\sigma/\text{d}p$ [$\text{GeV}^-1$]
	+LogX=1
	+# END PLOT
	+
	+
	diff --git a/data/plotinfo/ALICE_2012_I1116147.plot b/data/plotinfo/ALICE_2012_I1116147.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ALICE_2012_I1116147.plot
	@@ -0,0 +1,38 @@
	+# BEGIN PLOT /ALICE_2012_I1116147/d01-x01-y01
	+Title=$\pi^0$ invariant cross section at mid-rapidity at $\sqrt{s}=7$\,TeV
	+XLabel=$p_\perp$ (GeV/$c$)
	+YLabel=$E\frac{d^3\sigma}{dp^3}$ ($\mu b/$(GeV$^2c^3$))
	+YMin=1e-4
	+YMax=1e6
	+# END PLOT
	+
	+
	+
	+# BEGIN PLOT /ALICE_2012_I1116147/d02-x01-y01
	+Title=$\pi^0$ invariant cross section at mid-rapidity at $\sqrt{s}=0.9$\,TeV
	+XLabel=$p_\perp$ (GeV/$c$)
	+YLabel=$E\frac{d^3\sigma}{dp^3}$ ($\mu b/$(GeV$^2c^3$))
	+YMin=1e-2
	+YMax=1e5
	+#END PLOT
	+
	+
	+
	+# BEGIN PLOT /ALICE_2012_I1116147/d03-x01-y01
	+Title=$\eta$ invariant cross section at mid-rapidity at $\sqrt{s}=7$\,TeV
	+XLabel=$p_\perp$ (GeV/$c$)
	+YLabel=$E\frac{d^3\sigma}{dp^3}$ ($\mu b/$(GeV$^2c^3$))
	+YMin=1e-3
	+YMax=1e4
	+# END PLOT
	+
	+
	+
	+# BEGIN PLOT /ALICE_2012_I1116147/d04-x01-y01
	+Title=$\eta/\pi^0$ ratio at $\sqrt{s}=7$\,TeV
	+XLabel=$p_\perp$ (GeV/$c$)
	+YLabel=$\eta/\pi^0$
	+LogY=0
	+YMin=5e-2
	+YMax=1.1
	+# END PLOT
	\ No newline at end of file
	diff --git a/data/plotinfo/ARGUS_1993_S2669951.plot b/data/plotinfo/ARGUS_1993_S2669951.plot
	--- a/data/plotinfo/ARGUS_1993_S2669951.plot
	+++ b/data/plotinfo/ARGUS_1993_S2669951.plot
	@@ -1,33 +1,37 @@
	+# BEGIN PLOT /ARGUS_1993_S2669951/d0[234]-x01-y01
	+XLabel=$x_p$
	+YLabel=$1/(\sigma\beta)\text{d}\sigma/\text{d}x_p$
	+# END PLOT
	+
	# BEGIN PLOT /ARGUS_1993_S2669951/d02-x01-y01
	Title=$f_0$ scaled momentum, continuum
	-XLabel=$x_p$
	-YLabel=$1/(\sigma\beta)\text{d}\sigma/\text{d}x_p$
	# END PLOT
	+
	# BEGIN PLOT /ARGUS_1993_S2669951/d03-x01-y01
	Title=$f_0$ scaled momentum, $\Upsilon(1S)$
	-XLabel=$x_p$
	-YLabel=$1/(\sigma\beta)\text{d}\sigma/\text{d}x_p$
	# END PLOT
	+
	# BEGIN PLOT /ARGUS_1993_S2669951/d04-x01-y01
	Title=$f_0$ scaled momentum, $\Upsilon(2S)$
	-XLabel=$x_p$
	-YLabel=$1/(\sigma\beta)\text{d}\sigma/\text{d}x_p$
	# END PLOT
	-# BEGIN PLOT /ARGUS_1993_S2669951/d01-x01-y01
	-Title=$\eta'$ multiplicity, $x_p>0.35$
	-XLabel=
	-YLabel=$N_{\eta'}$
	+
	+
	+# BEGIN PLOT /ARGUS_1993_S2669951/d0[15]-
	+XLabel=$\sqrt{s}$
	LogY=0
	# END PLOT
	+
	# BEGIN PLOT /ARGUS_1993_S2669951/d01-x01-y02
	-Title=$\eta'$ multiplicity, $x_p>0.35$
	-XLabel=
	+Title=$\eta'$ multiplicity, $x_p > 0.35$
	YLabel=$N_{\eta'}$
	-LogY=0
	# END PLOT
	+
	+# BEGIN PLOT /ARGUS_1993_S2669951/d01-x01-y02
	+Title=$\eta'$ multiplicity
	+YLabel=$N_{\eta'}$
	+# END PLOT
	+
	# BEGIN PLOT /ARGUS_1993_S2669951/d05-x01-y01
	Title=$f_0$ multiplicity
	-XLabel=
	YLabel=$N_{f_0}$
	-LogY=0
	# END PLOT
	diff --git a/data/plotinfo/ATLAS_2011_I929691.plot b/data/plotinfo/ATLAS_2011_I929691.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2011_I929691.plot
	@@ -0,0 +1,238 @@
	+# BEGIN PLOT /ATLAS_2011_I929691/*
	+LogY=1
	+LogX=0
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d01-x01-y01
	+Title=$F(z)$ for 25 GeV $<p_\text{T~jet}<$ 40 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.0121
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d02-x01-y01
	+Title=$F(z)$ for 40 GeV $<p_\text{T~jet}<$ 60 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.0069
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d03-x01-y01
	+Title=$F(z)$ for 60 GeV $<p_\text{T~jet}<$ 80 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.0052
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d04-x01-y01
	+Title=$F(z)$ for 80 GeV $<p_\text{T~jet}<$ 110 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.004
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d05-x01-y01
	+Title=$F(z)$ for 110 GeV $<p_\text{T~jet}<$ 160 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.003
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d06-x01-y01
	+Title=$F(z)$ for 160 GeV $<p_\text{T~jet}<$ 210 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.003
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d07-x01-y01
	+Title=$F(z)$ for 210 GeV $<p_\text{T~jet}<$ 260 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.003
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d08-x01-y01
	+Title=$F(z)$ for 260 GeV $<p_\text{T~jet}<$ 310 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.003
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d09-x01-y01
	+Title=$F(z)$ for 310 GeV $<p_\text{T~jet}<$ 400 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.003
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d10-x01-y01
	+Title=$F(z)$ for 400 GeV $<p_\text{T~jet}<$ 500 GeV
	+XLabel=$z$
	+YLabel=$F(z)$
	+XMax=0.8
	+XMin=0.003
	+LogX=1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d11-x01-y01
	+Title=Density of charged particles for 25 GeV $<p_\text{T~jet}<$ 40 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d12-x01-y01
	+Title=Density of charged particles for 40 GeV $<p_\text{T~jet}<$ 60 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d13-x01-y01
	+Title=Density of charged particles for 60 GeV $<p_\text{T~jet}<$ 80 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d14-x01-y01
	+Title=Density of charged particles for 80 GeV $<p_\text{T~jet}<$ 110 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d15-x01-y01
	+Title=Density of charged particles for 110 GeV $<p_\text{T~jet}<$ 160 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d16-x01-y01
	+Title=Density of charged particles for 160 GeV $<p_\text{T~jet}<$ 210 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d17-x01-y01
	+Title=Density of charged particles for 210 GeV $<p_\text{T~jet}<$ 260 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d18-x01-y01
	+Title=Density of charged particles for 260 GeV $<p_\text{T~jet}<$ 310 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d19-x01-y01
	+Title=Density of charged particles for 310 GeV $<p_\text{T~jet}<$ 400 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d20-x01-y01
	+Title=Density of charged particles for 400 GeV $<p_\text{T~jet}<$ 500 GeV
	+XLabel=$r$
	+YLabel=$\rho_\text{ch}(r)$
	+XMax=0.6
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d21-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 25 GeV $<p_\text{T~jet}<$ 40 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d22-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 40 GeV $<p_\text{T~jet}<$ 60 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d23-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 60 GeV $<p_\text{T~jet}<$ 80 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d24-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 80 GeV $<p_\text{T~jet}<$ 110 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d25-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 110 GeV $<p_\text{T~jet}<$ 160 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d26-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 160 GeV $<p_\text{T~jet}<$ 210 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d27-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 210 GeV $<p_\text{T~jet}<$ 260 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d28-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 260 GeV $<p_\text{T~jet}<$ 310 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d29-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 310 GeV $<p_\text{T~jet}<$ 400 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2011_I929691/d30-x01-y01
	+Title=$f(p_\text{T}^\text{rel})$ for 400 GeV $<p_\text{T~jet}<$ 500 GeV
	+XLabel=$p_\text{T}^\text{rel}$ [GeV]
	+YLabel=$f(p_\text{T}^\text{rel})$
	+LogY=0
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2013_I1219109.plot b/data/plotinfo/ATLAS_2013_I1219109.plot
	--- a/data/plotinfo/ATLAS_2013_I1219109.plot
	+++ b/data/plotinfo/ATLAS_2013_I1219109.plot
	@@ -1,34 +1,33 @@
	# BEGIN PLOT /ATLAS_2013_I1219109/d..-x..-y..
	LogY=1
	LegendYPos=0.90
	LegendXPos=0.75
	XTwosidedTicks=1
	YTwosidedTicks=1
	ErrorBars=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109/d01-x..-y..
	LogY=0
	LegendXPos=0.20
	YLabel=$\sigma_\text{fiducial}$ [pb]
	XMinorTickMarks=0
	-XCustomMajorTicks=1 1 jet 2 2 jet 3 1+2 jet
	+XCustomMajorTicks=1 1~jet 2 2~jet 3 1+2~jet
	Title=electron channel, dressed level
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109/d02-x..-y..
	LeftMargin=1.5
	XLabel=b-jet $p_\text{T}$ [GeV]
	YLabel=$\text{d}\sigma / \text{d} p_\text{T}^\text{b-jet}$ [GeV/pb]
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109/d02-x01-y01
	Title=$N_\text{jet} = 1$, electron channel, dressed level
	RatioPlotYMax=1.6
	RatioPlotYMin=0.4
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109/d02-x02-y01
	Title=$N_\text{jet} = 2$, electron channel, dressed level
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2013_I1219109_EL.plot b/data/plotinfo/ATLAS_2013_I1219109_EL.plot
	--- a/data/plotinfo/ATLAS_2013_I1219109_EL.plot
	+++ b/data/plotinfo/ATLAS_2013_I1219109_EL.plot
	@@ -1,34 +1,33 @@
	# BEGIN PLOT /ATLAS_2013_I1219109_EL/d..-x..-y..
	LogY=1
	LegendYPos=0.90
	LegendXPos=0.75
	XTwosidedTicks=1
	YTwosidedTicks=1
	ErrorBars=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109_EL/d01-x..-y..
	LogY=0
	LegendXPos=0.20
	YLabel=$\sigma_\text{fiducial}$ [pb]
	XMinorTickMarks=0
	-XCustomMajorTicks=1 1 jet 2 2 jet 3 1+2 jet
	-Title=electron channel, dressed level
	+XCustomMajorTicks=1 1~jet 2 2~jet 3 1+2~jet
	+Title=Electron channel, dressed level
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109_EL/d02-x..-y..
	LeftMargin=1.5
	-XLabel=b-jet $p_\text{T}$ [GeV]
	+XLabel=$b$-jet $p_\text{T}$ [GeV]
	YLabel=$\text{d}\sigma / \text{d} p_\text{T}^\text{b-jet}$ [GeV/pb]
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109_EL/d02-x01-y01
	Title=$N_\text{jet} = 1$, electron channel, dressed level
	RatioPlotYMax=1.6
	RatioPlotYMin=0.4
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109_EL/d02-x02-y01
	Title=$N_\text{jet} = 2$, electron channel, dressed level
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2013_I1219109_MU.plot b/data/plotinfo/ATLAS_2013_I1219109_MU.plot
	--- a/data/plotinfo/ATLAS_2013_I1219109_MU.plot
	+++ b/data/plotinfo/ATLAS_2013_I1219109_MU.plot
	@@ -1,34 +1,33 @@
	# BEGIN PLOT /ATLAS_2013_I1219109_MU/d..-x..-y..
	LogY=1
	LegendYPos=0.90
	LegendXPos=0.75
	XTwosidedTicks=1
	YTwosidedTicks=1
	ErrorBars=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109_MU/d01-x..-y..
	LogY=0
	LegendXPos=0.20
	YLabel=$\sigma_\text{fiducial}$ [pb]
	XMinorTickMarks=0
	-XCustomMajorTicks=1 1 jet 2 2 jet 3 1+2 jet
	-Title=electron channel, dressed level
	+XCustomMajorTicks=1 1~jet 2 2~jet 3 1+2~jet
	+Title=Muon channel, dressed level
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109_MU/d02-x..-y..
	LeftMargin=1.5
	XLabel=b-jet $p_\text{T}$ [GeV]
	YLabel=$\text{d}\sigma / \text{d} p_\text{T}^\text{b-jet}$ [GeV/pb]
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109_MU/d02-x01-y01
	-Title=$N_\text{jet} = 1$, electron channel, dressed level
	+Title=$N_\text{jet} = 1$, muon channel, dressed level
	RatioPlotYMax=1.6
	RatioPlotYMin=0.4
	# END PLOT

	# BEGIN PLOT /ATLAS_2013_I1219109_MU/d02-x02-y01
	-Title=$N_\text{jet} = 2$, electron channel, dressed level
	+Title=$N_\text{jet} = 2$, muon channel, dressed level
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2014_I1282447.plot b/data/plotinfo/ATLAS_2014_I1282447.plot
	--- a/data/plotinfo/ATLAS_2014_I1282447.plot
	+++ b/data/plotinfo/ATLAS_2014_I1282447.plot
	@@ -1,131 +1,130 @@
	# BEGIN PLOT /ATLAS_2014_I1282447/d01-.*
	XLabel=$W$-boson charge [$e$]
	XCustomMajorTicks=-1 -1 1 1
	YLabel=$\sigma_\text{fid}^\text{OS-SS}$ [pb]
	LogY=0
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d01-x01-y01
	Title=$Wc$-jet
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d01-x01-y02
	Title=$WD$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d01-x01-y03
	Title=$WD^*$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d02-x01-y0[1-2]
	XLabel=
	XMinorTickMarks=0
	LogY=0
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d02-x01-y01
	Title=$Wc$-jet
	-YLabel=$\sigma_\text{fid}^\text{OS-SS} (W^+ \bar{c}\text{-jet}) / \sigma_\text{fid}^\text{OS-SS}(W^- c\text{-jet})$
	+YLabel=$\sigma_\text{fid}^\text{OS-SS} (W^+ \bar{c}\text{-jet}) / \sigma_\text{fid}^\text{OS-SS}(W^- c\text{-jet})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d02-x01-y02
	Title=$WD^{(*)}$
	-YLabel=$\sigma_\text{fid}^\text{OS-SS} ($W^+ D^{()-}) / \sigma_\text{fid}^\text{OS-SS}(W^- D^{()+}$
	+YLabel=$\sigma_\text{fid}^\text{OS-SS} ($W^+ D^{()-}) / \sigma_\text{fid}^\text{OS-SS}(W^- D^{()+}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d0[34]-.*
	-XLabel=Lepton $\|\eta\|$
	+XLabel=Lepton $\|\eta\|$
	YLabel=$\mathrm{d} \sigma_\text{fid}^\text{OS-SS} / \mathrm{d} \|\eta\|$ [pb]
	LogY=0
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d03-x01-y01
	-Title=$W^+ + \bar{c}$-jet
	+Title=$W^+ + \bar{c}$-jet
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d03-x01-y02
	-Title=$W^- + c$-jet
	+Title=$W^- + c$-jet
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d04-x01-y01
	-Title=$W^+ + D^-$
	+Title=$W^+ + D^-$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d04-x01-y02
	-Title=$W^- + D^+$
	+Title=$W^- + D^+$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d04-x01-y03
	-Title=$W^+ + D^{*-}$
	+Title=$W^+ + D^{*-}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d04-x01-y04
	-Title=$W^- + D^{*+}$
	+Title=$W^- + D^{*+}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d05-x01-y01
	Title=$W D$ over inclusive $W$
	XLabel=$W$-boson charge [$e$]
	XMinorTickMarks=0
	XCustomMajorTicks=-1 -1 1 1
	YLabel=$\sigma_\text{fid}^\text{OS-SS} (W D) / \sigma_\text{fid} (W)$ [\%]
	LogY=0
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d05-x01-y02
	Title=$W D^*$ over inclusive $W$
	XLabel=$W$-boson charge [$e$]
	XMinorTickMarks=0
	XCustomMajorTicks=-1 -1 1 1
	YLabel=$\sigma_\text{fid}^\text{OS-SS} (W D^*) / \sigma_\text{fid} (W)$ [\%]
	LogY=0
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d06-x01-y0[1-2]
	XLabel=$D$-meson $p_\text{T}$ [GeV]
	YLabel=$\sigma_\text{fid}^\text{OS-SS} (W D) / \sigma_\text{fid} (W)$ [\%]
	LogY=0
	LogX=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d06-x01-y01
	Title=$W^+ D^-$ over inclusive $W^+$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d06-x01-y02
	Title=$W^- D^+$ over inclusive $W^-$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d06-x01-y0[3-4]
	XLabel=$D^*$-meson $p_\text{T}$ [GeV]
	YLabel=$\sigma_\text{fid}^\text{OS-SS} (W D^*) / \sigma_\text{fid} (W)$ [\%]
	LogY=0
	LogX=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d06-x01-y03
	Title=$W^+ D^{*-}$ over inclusive $W^+$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d06-x01-y04
	Title=$W^- D^{*+}$ over inclusive $W^-$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d07-x01-y01
	Title=$W + c$-jet
	XLabel=Jet multiplicity
	XMinorTickMarks=0
	-XCustomMajorTicks=0 1 jet 1 2 jets
	+XCustomMajorTicks=0 1~jet 1 2~jets
	YLabel=$\sigma_\text{fid}^\text{OS-SS}$ [pb]
	LogY=0
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1282447/d08-x01-y01
	Title=$R^\pm_c$
	XLabel=Jet multiplicity
	XMinorTickMarks=0
	-XCustomMajorTicks=0 1 jet 1 2 jets
	-YLabel=$\sigma_\text{fid}^\text{OS-SS}(W^+ \bar{c}\text{-jet}) / \sigma_\text{fid}^\text{OS-SS}(W^- c\text{-jet})$
	+XCustomMajorTicks=0 1~jet 1 2~jets
	+YLabel=$\sigma_\text{fid}^\text{OS-SS}(W^+ \bar{c}\text{-jet}) / \sigma_\text{fid}^\text{OS-SS}(W^- c\text{-jet})$
	LogY=0
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2014_I1307243.plot b/data/plotinfo/ATLAS_2014_I1307243.plot
	--- a/data/plotinfo/ATLAS_2014_I1307243.plot
	+++ b/data/plotinfo/ATLAS_2014_I1307243.plot
	@@ -1,367 +1,367 @@
	# BEGIN PLOT /ATLAS_2014_I1307243/d01-x01-y01
	Title=Gap fraction as a function of leading dijet rapidity separation
	XLabel=$\Delta y$
	YLabel=Gap fraction
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d02-x01-y01
	Title=Gap fraction as a function of leading dijet scalar mean $p_T$
	-XLabel=$\bar{p_T}$ [GeV]
	+XLabel=$\overline{p_T}$ [GeV]
	YLabel=Gap fraction
	ShowZero=0
	LogX=1
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d03-x01-y01
	Title=$\langle N_\text{jets}$ in rapidity interval $\rangle$ as a function of $\Delta y$
	XLabel=$\Delta y$
	YLabel=$\langle N_\text{jets}$ in rapidity interval $\rangle$
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d04-x01-y01
	-Title=$\langle N_\text{jets}$ in rapidity interval $\rangle$ as a function of $\bar{p_T}$
	-XLabel=$\bar{p_T}$ [GeV]
	+Title=$\langle N_\text{jets}$ in rapidity interval $\rangle$ as a function of $\overline{p_T}$
	+XLabel=$\overline{p_T}$ [GeV]
	YLabel=$\langle N_\text{jets}$ in rapidity interval $\rangle$
	ShowZero=0
	LogX=1
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d05-x01-y01
	Title=$\langle \cos(\pi - \Delta\phi)\rangle$ for inclusive events as a function of $\Delta y$
	XLabel=$\Delta y$
	YLabel=$\langle \cos(\pi - \Delta\phi)\rangle$
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d06-x01-y01
	-Title=$\langle \cos(\pi - \Delta\phi)\rangle$ for inclusive events as a function of $\bar{p_T}$
	-XLabel=$\bar{p_T}$ [GeV]
	+Title=$\langle \cos(\pi - \Delta\phi)\rangle$ for inclusive events as a function of $\overline{p_T}$
	+XLabel=$\overline{p_T}$ [GeV]
	YLabel=$\langle \cos(\pi - \Delta\phi)\rangle$
	ShowZero=0
	LogX=1
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d07-x01-y01
	Title=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$ for inclusive events as a function of $\Delta y$
	XLabel=$\Delta y$
	YLabel=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d08-x01-y01
	-Title=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$ for inclusive events as a function of $\bar{p_T}$
	-XLabel=$\bar{p_T}$ [GeV]
	+Title=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$ for inclusive events as a function of $\overline{p_T}$
	+XLabel=$\overline{p_T}$ [GeV]
	YLabel=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$
	ShowZero=0
	LogX=1
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d09-x01-y01
	Title=$\langle \cos(\pi - \Delta\phi)\rangle$ for gap events as a function of $\Delta y$
	XLabel=$\Delta y$
	YLabel=$\langle \cos(\pi - \Delta\phi)\rangle$
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d10-x01-y01
	-Title=$\langle \cos(\pi - \Delta\phi)\rangle$ for gap events as a function of $\bar{p_T}$
	-XLabel=$\bar{p_T}$ [GeV]
	+Title=$\langle \cos(\pi - \Delta\phi)\rangle$ for gap events as a function of $\overline{p_T}$
	+XLabel=$\overline{p_T}$ [GeV]
	YLabel=$\langle \cos(\pi - \Delta\phi)\rangle$
	ShowZero=0
	LogX=1
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d11-x01-y01
	Title=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$ for gap events as a function of $\Delta y$
	XLabel=$\Delta y$
	YLabel=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d12-x01-y01
	-Title=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$ for gap events as a function of $\bar{p_T}$
	-XLabel=$\bar{p_T}$ [GeV]
	+Title=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$ for gap events as a function of $\overline{p_T}$
	+XLabel=$\overline{p_T}$ [GeV]
	YLabel=$\langle \cos(2\Delta\phi)\rangle$/$\langle \cos(\pi - \Delta\phi)\rangle$
	ShowZero=0
	LogX=1
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d13-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for inclusive events satisfying 0 $< \Delta y \leq$ 1
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d14-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for inclusive events satisfying 1 $< \Delta y \leq$ 2
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d15-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for inclusive events satisfying 2 $< \Delta y \leq$ 3
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d16-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for inclusive events satisfying 3 $< \Delta y \leq$ 4
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d17-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for inclusive events satisfying 4 $< \Delta y \leq$ 5
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d18-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for inclusive events satisfying 5 $< \Delta y \leq$ 6
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d19-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for inclusive events satisfying 6 $< \Delta y \leq$ 7
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d20-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for inclusive events satisfying 7 $< \Delta y \leq$ 8
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d21-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for gap events satisfying 0 $< \Delta y \leq$ 1
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d22-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for gap events satisfying 1 $< \Delta y \leq$ 2
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d23-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for gap events satisfying 2 $< \Delta y \leq$ 3
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d24-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for gap events satisfying 3 $< \Delta y \leq$ 4
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d25-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for gap events satisfying 4 $< \Delta y \leq$ 5
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d26-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for gap events satisfying 5 $< \Delta y \leq$ 6
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d27-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for gap events satisfying 6 $< \Delta y \leq$ 7
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d28-x01-y01
	Title=$d^2\sigma / d\Delta\phi d\Delta y$ in pb for gap events satisfying 7 $< \Delta y \leq$ 8
	XLabel=$\Delta\phi / \pi$
	YLabel=$d^2\sigma / d\Delta\phi d\Delta y$ [pb]
	ShowZero=0
	LogY=1
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d29-x01-y01
	Title=Gap fraction as a function of $Q_0$ for events satisfying 0 $< \Delta y \leq$ 1
	XLabel=$Q_0$ [GeV]
	YLabel=Gap fraction
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d30-x01-y01
	Title=Gap fraction as a function of $Q_0$ for events satisfying 1 $< \Delta y \leq$ 2
	XLabel=$Q_0$ [GeV]
	YLabel=Gap fraction
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d31-x01-y01
	Title=Gap fraction as a function of $Q_0$ for events satisfying 2 $< \Delta y \leq$ 3
	XLabel=$Q_0$ [GeV]
	YLabel=Gap fraction
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d32-x01-y01
	Title=Gap fraction as a function of $Q_0$ for events satisfying 3 $< \Delta y \leq$ 4
	XLabel=$Q_0$ [GeV]
	YLabel=Gap fraction
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d33-x01-y01
	Title=Gap fraction as a function of $Q_0$ for events satisfying 4 $< \Delta y \leq$ 5
	XLabel=$Q_0$ [GeV]
	YLabel=Gap fraction
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d34-x01-y01
	Title=Gap fraction as a function of $Q_0$ for events satisfying 5 $< \Delta y \leq$ 6
	XLabel=$Q_0$ [GeV]
	YLabel=Gap fraction
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d35-x01-y01
	Title=Gap fraction as a function of $Q_0$ for events satisfying 6 $< \Delta y \leq$ 7
	XLabel=$Q_0$ [GeV]
	YLabel=Gap fraction
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d36-x01-y01
	Title=Gap fraction as a function of $Q_0$ for events satisfying 7 $< \Delta y \leq$ 8
	XLabel=$Q_0$ [GeV]
	YLabel=Gap fraction
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d37-x01-y01
	Title=$\langle \cos(2\Delta\phi)\rangle$ for inclusive events as a function of $\Delta y$
	XLabel=$\Delta y$
	YLabel=$\langle \cos(2\Delta\phi)\rangle$
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d38-x01-y01
	-Title=$\langle \cos(2\Delta\phi)\rangle$ for inclusive events as a function of $\bar{p_T}$
	-XLabel=$\bar{p_T}$ [GeV]
	+Title=$\langle \cos(2\Delta\phi)\rangle$ for inclusive events as a function of $\overline{p_T}$
	+XLabel=$\overline{p_T}$ [GeV]
	YLabel=$\langle \cos(2\Delta\phi)\rangle$
	ShowZero=0
	LogX=1
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d39-x01-y01
	Title=$\langle \cos(2\Delta\phi)\rangle$ for gap events as a function of $\Delta y$
	XLabel=$\Delta y$
	YLabel=$\langle \cos(2\Delta\phi)\rangle$
	ShowZero=0
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1307243/d40-x01-y01
	-Title=$\langle \cos(2\Delta\phi)\rangle$ for gap events as a function of $\bar{p_T}$
	-XLabel=$\bar{p_T}$ [GeV]
	+Title=$\langle \cos(2\Delta\phi)\rangle$ for gap events as a function of $\overline{p_T}$
	+XLabel=$\overline{p_T}$ [GeV]
	YLabel=$\langle \cos(2\Delta\phi)\rangle$
	ShowZero=0
	LogX=1
	LogY=0
	-RatioPlotSameStyle=1
	+#RatioPlotSameStyle=1
	# END PLOT
	diff --git a/data/plotinfo/ATLAS_2014_I1312627.plot b/data/plotinfo/ATLAS_2014_I1312627.plot
	--- a/data/plotinfo/ATLAS_2014_I1312627.plot
	+++ b/data/plotinfo/ATLAS_2014_I1312627.plot
	@@ -1,107 +1,106 @@
	# BEGIN PLOT /ATLAS_2014_I1312627/d..
	Title=$W \rightarrow e \nu / Z \rightarrow ee$ (MC) vs $W \rightarrow \ell \nu / Z \rightarrow \ell\ell$ (data), dressed level
	LogY=0
	XTwosidedTicks=1
	YTwosidedTicks=1
	LeftMargin=1.5
	LegendYPos=0.3
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d0[1-4]
	XMinorTickMarks=0
	XLabel=$N_\text{jets}$
	YLabel=$(\sigma_{W + N_\text{jets}}) / (\sigma_{Z + N_\text{jets}})$
	YMax=18.0
	YMin=6.5
	LegendYPos=0.9
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d01
	-XCustomMajorTicks=0.5 $\geq 0$ 1.5 $\geq 1$ 2.5 $\geq 2$ 3.5 $\geq 3$ 4.5 $\geq 4$
	+XCustomMajorTicks=0.5 $\geq0$ 1.5 $\geq1$ 2.5 $\geq2$ 3.5 $\geq3$ 4.5 $\geq4$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d04
	XCustomMajorTicks=0.5 0 1.5 1 2.5 2 3.5 3 4.5 4
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d0[5-8]
	XLabel=$p^j_\text{T}$ (leading jet) [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d05
	YLabel=$(\text{d}\sigma_{W + \geq 1j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 1j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d06
	YLabel=$(\text{d}\sigma_{W + 1j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + 1j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d07
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d08
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d09
	XLabel=$p^j_\text{T}$ (2nd leading jet) [GeV]
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d10
	XLabel=$p^j_\text{T}$ (3rd leading jet) [GeV]
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d1[1-4]
	XLabel=$S_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d11
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d12
	YLabel=$(\text{d}\sigma_{W + 2j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + 2j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d13
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d14
	YLabel=$(\text{d}\sigma_{W + 3j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + 3j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d15
	XLabel=$\Delta R_{j1,j2}$
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta R_{j1,j2}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}\Delta R_{j1,j2})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d16
	XLabel=$\Delta\phi_{j1,j2}$
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta\phi_{j1,j2}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}\Delta\phi_{j1,j2})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d17
	XLabel=$m_{12}$ [GeV]
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}m_{12}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}m_{12})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d18
	XLabel=$\|y^j\|$ (leading jet)
	YLabel=$(\text{d}\sigma_{W + \geq 1j} / \text{d}y^j) / (\text{d}\sigma_{Z + \geq 1j} / \text{d}y^j)$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d19
	XLabel=$\|y^j\|$ (2nd leading jet)
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}y^j) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}y^j)$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627/d20
	XLabel=$\|y^j\|$ (3rd leading jet)
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}y^j) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}y^j)$
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2014_I1312627_EL.plot b/data/plotinfo/ATLAS_2014_I1312627_EL.plot
	--- a/data/plotinfo/ATLAS_2014_I1312627_EL.plot
	+++ b/data/plotinfo/ATLAS_2014_I1312627_EL.plot
	@@ -1,107 +1,106 @@
	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d..
	-Title=electron channel, dressed level
	+Title=Electron channel, dressed level
	LogY=0
	XTwosidedTicks=1
	YTwosidedTicks=1
	LeftMargin=1.5
	LegendYPos=0.3
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d0[1-4]
	XMinorTickMarks=0
	XLabel=$N_\text{jets}$
	YLabel=$(\sigma_{W + N_\text{jets}}) / (\sigma_{Z + N_\text{jets}})$
	YMax=18.0
	YMin=6.5
	LegendYPos=0.9
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d01
	-XCustomMajorTicks=0.5 $\geq 0$ 1.5 $\geq 1$ 2.5 $\geq 2$ 3.5 $\geq 3$ 4.5 $\geq 4$
	+XCustomMajorTicks=0.5 $\geq0$ 1.5 $\geq1$ 2.5 $\geq2$ 3.5 $\geq3$ 4.5 $\geq4$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d04
	XCustomMajorTicks=0.5 0 1.5 1 2.5 2 3.5 3 4.5 4
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d0[5-8]
	XLabel=$p^j_\text{T}$ (leading jet) [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d05
	YLabel=$(\text{d}\sigma_{W + \geq 1j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 1j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d06
	YLabel=$(\text{d}\sigma_{W + 1j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + 1j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d07
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d08
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d09
	XLabel=$p^j_\text{T}$ (2nd leading jet) [GeV]
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d10
	XLabel=$p^j_\text{T}$ (3rd leading jet) [GeV]
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d1[1-4]
	XLabel=$S_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d11
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d12
	YLabel=$(\text{d}\sigma_{W + 2j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + 2j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d13
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d14
	YLabel=$(\text{d}\sigma_{W + 3j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + 3j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d15
	XLabel=$\Delta R_{j1,j2}$
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta R_{j1,j2}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}\Delta R_{j1,j2})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d16
	XLabel=$\Delta\phi_{j1,j2}$
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta\phi_{j1,j2}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}\Delta\phi_{j1,j2})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d17
	XLabel=$m_{12}$ [GeV]
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}m_{12}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}m_{12})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d18
	XLabel=$\|y^j\|$ (leading jet)
	YLabel=$(\text{d}\sigma_{W + \geq 1j} / \text{d}y^j) / (\text{d}\sigma_{Z + \geq 1j} / \text{d}y^j)$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d19
	XLabel=$\|y^j\|$ (2nd leading jet)
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}y^j) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}y^j)$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_EL/d20
	XLabel=$\|y^j\|$ (3rd leading jet)
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}y^j) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}y^j)$
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2014_I1312627_MU.plot b/data/plotinfo/ATLAS_2014_I1312627_MU.plot
	--- a/data/plotinfo/ATLAS_2014_I1312627_MU.plot
	+++ b/data/plotinfo/ATLAS_2014_I1312627_MU.plot
	@@ -1,107 +1,106 @@
	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d..
	-Title=muon channel, dressed level
	+Title=Muon channel, dressed level
	LogY=0
	XTwosidedTicks=1
	YTwosidedTicks=1
	LeftMargin=1.5
	LegendYPos=0.3
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d0[1-4]
	XMinorTickMarks=0
	XLabel=$N_\text{jets}$
	YLabel=$(\sigma_{W + N_\text{jets}}) / (\sigma_{Z + N_\text{jets}})$
	YMax=18.0
	YMin=6.5
	LegendYPos=0.9
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d01
	-XCustomMajorTicks=0.5 $\geq 0$ 1.5 $\geq 1$ 2.5 $\geq 2$ 3.5 $\geq 3$ 4.5 $\geq 4$
	+XCustomMajorTicks=0.5 $\geq0$ 1.5 $\geq1$ 2.5 $\geq2$ 3.5 $\geq3$ 4.5 $\geq4$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d04
	XCustomMajorTicks=0.5 0 1.5 1 2.5 2 3.5 3 4.5 4
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d0[5-8]
	XLabel=$p^j_\text{T}$ (leading jet) [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d05
	YLabel=$(\text{d}\sigma_{W + \geq 1j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 1j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d06
	YLabel=$(\text{d}\sigma_{W + 1j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + 1j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d07
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d08
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d09
	XLabel=$p^j_\text{T}$ (2nd leading jet) [GeV]
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d10
	XLabel=$p^j_\text{T}$ (3rd leading jet) [GeV]
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}p^j_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d1[1-4]
	XLabel=$S_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d11
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d12
	YLabel=$(\text{d}\sigma_{W + 2j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + 2j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d13
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d14
	YLabel=$(\text{d}\sigma_{W + 3j} / \text{d}S_\text{T}) / (\text{d}\sigma_{Z + 3j} / \text{d}S_\text{T})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d15
	XLabel=$\Delta R_{j1,j2}$
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta R_{j1,j2}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}\Delta R_{j1,j2})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d16
	XLabel=$\Delta\phi_{j1,j2}$
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta\phi_{j1,j2}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}\Delta\phi_{j1,j2})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d17
	XLabel=$m_{12}$ [GeV]
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}m_{12}) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}m_{12})$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d18
	XLabel=$\|y^j\|$ (leading jet)
	YLabel=$(\text{d}\sigma_{W + \geq 1j} / \text{d}y^j) / (\text{d}\sigma_{Z + \geq 1j} / \text{d}y^j)$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d19
	XLabel=$\|y^j\|$ (2nd leading jet)
	YLabel=$(\text{d}\sigma_{W + \geq 2j} / \text{d}y^j) / (\text{d}\sigma_{Z + \geq 2j} / \text{d}y^j)$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1312627_MU/d20
	XLabel=$\|y^j\|$ (3rd leading jet)
	YLabel=$(\text{d}\sigma_{W + \geq 3j} / \text{d}y^j) / (\text{d}\sigma_{Z + \geq 3j} / \text{d}y^j)$
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2014_I1319490.plot b/data/plotinfo/ATLAS_2014_I1319490.plot
	--- a/data/plotinfo/ATLAS_2014_I1319490.plot
	+++ b/data/plotinfo/ATLAS_2014_I1319490.plot
	@@ -1,183 +1,182 @@
	# BEGIN PLOT /ATLAS_2014_I1319490/d..
	Title=$W \rightarrow e \nu$ (MC) vs $W \rightarrow \ell \nu$ (data), dressed level
	XTwosidedTicks=1
	YTwosidedTicks=1
	LeftMargin=1.5
	LegendYPos=0.3
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d0[1-4]
	XMinorTickMarks=0
	XLabel=$N_\text{jets}$
	YLabel=$\sigma_{W + N_\text{jets}}$
	LegendYPos=0.9
	LegendXPos=0.6
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d01
	-XCustomMajorTicks=0.5 $\geq~0$ 1.5 $\geq~1$ 2.5 $\geq~2$ 3.5 $\geq~3$ 4.5 $\geq~4$ 5.5 $\geq~5$ 6.5 $\geq~6$ 7.5 $\geq~7$
	+XCustomMajorTicks=0.5 $\geq0$ 1.5 $\geq1$ 2.5 $\geq2$ 3.5 $\geq3$ 4.5 $\geq4$ 5.5 $\geq5$ 6.5 $\geq6$ 7.5 $\geq7$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d04
	XCustomMajorTicks=0.5 0 1.5 1 2.5 2 3.5 3 4.5 4 5.5 5 6.5 6 7.5 7
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d0[5-8]
	XLabel=$p^j_\text{T}$ (leading jet) [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d05
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d06
	YLabel=$\text{d}\sigma_{W + 1j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d07
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d08
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d09
	XLabel=$p^j_\text{T}$ (2nd leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d10
	XLabel=$p^j_\text{T}$ (3rd leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d11
	XLabel=$p^j_\text{T}$ (4th leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d12
	XLabel=$p^j_\text{T}$ (5th leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d13
	XLabel=$\|y^j\|$ (leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d14
	XLabel=$\|y^j\|$ (subleading jet)
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d1[5-9]
	XLabel=$H_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d2[0-2]
	XLabel=$H_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d15
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d16
	YLabel=$\text{d}\sigma_{W + 1j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d17
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d18
	YLabel=$\text{d}\sigma_{W + 2j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d19
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d20
	YLabel=$\text{d}\sigma_{W + 3j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d21
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d22
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d23
	XLabel=$\Delta\phi_{j1,j2}$
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta\phi_{j1,j2}$
	LegendYPos=0.9
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d24
	XLabel=$\Delta y_{j1,j2}$
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}y_{j1,j2}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d25
	XLabel=$\Delta R_{j1,j2}$
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta R_{j1,j2}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d26
	XLabel=$m_{12}$ [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}m_{12}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d27
	XLabel=$\|y^j\|$ (3rd leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d28
	XLabel=$\|y^j\|$ (4th leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d29
	XLabel=$\|y^j\|$ (5th leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d3[0-6]
	XLabel=$S_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d30
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d31
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d32
	YLabel=$\text{d}\sigma_{W + 2j} / \text{d}S_\text{T}$
	# END PLOT
	-
	+
	# BEGIN PLOT /ATLAS_2014_I1319490/d33
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d34
	YLabel=$\text{d}\sigma_{W + 3j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d35
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490/d36
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}S_\text{T}$
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2014_I1319490_EL.plot b/data/plotinfo/ATLAS_2014_I1319490_EL.plot
	--- a/data/plotinfo/ATLAS_2014_I1319490_EL.plot
	+++ b/data/plotinfo/ATLAS_2014_I1319490_EL.plot
	@@ -1,183 +1,182 @@
	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d..
	Title=electron channel, dressed level
	XTwosidedTicks=1
	YTwosidedTicks=1
	LeftMargin=1.5
	LegendYPos=0.3
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d0[1-4]
	XMinorTickMarks=0
	XLabel=$N_\text{jets}$
	YLabel=$\sigma_{W + N_\text{jets}}$
	LegendYPos=0.9
	LegendXPos=0.6
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d01
	-XCustomMajorTicks=0.5 $\geq 0$ 1.5 $\geq 1$ 2.5 $\geq 2$ 3.5 $\geq 3$ 4.5 $\geq 4$ 5.5 $\geq 5$ 6.5 $\geq 6$ 7.5 $\geq 7$
	+XCustomMajorTicks=0.5 $\geq0$ 1.5 $\geq1$ 2.5 $\geq2$ 3.5 $\geq3$ 4.5 $\geq4$ 5.5 $\geq5$ 6.5 $\geq6$ 7.5 $\geq7$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d04
	XCustomMajorTicks=0.5 0 1.5 1 2.5 2 3.5 3 4.5 4 5.5 5 6.5 6 7.5 7
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d0[5-8]
	XLabel=$p^j_\text{T}$ (leading jet) [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d05
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d06
	YLabel=$\text{d}\sigma_{W + 1j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d07
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d08
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d09
	XLabel=$p^j_\text{T}$ (2nd leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d10
	XLabel=$p^j_\text{T}$ (3rd leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d11
	XLabel=$p^j_\text{T}$ (4th leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d12
	XLabel=$p^j_\text{T}$ (5th leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d13
	XLabel=$\|y^j\|$ (leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d14
	XLabel=$\|y^j\|$ (subleading jet)
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d1[5-9]
	XLabel=$H_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d2[0-2]
	XLabel=$H_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d15
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d16
	YLabel=$\text{d}\sigma_{W + 1j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d17
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d18
	YLabel=$\text{d}\sigma_{W + 2j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d19
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d20
	YLabel=$\text{d}\sigma_{W + 3j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d21
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d22
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d23
	XLabel=$\Delta\phi_{j1,j2}$
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta\phi_{j1,j2}$
	LegendYPos=0.9
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d24
	XLabel=$\Delta y_{j1,j2}$
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}y_{j1,j2}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d25
	XLabel=$\Delta R_{j1,j2}$
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta R_{j1,j2}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d26
	XLabel=$m_{12}$ [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}m_{12}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d27
	XLabel=$\|y^j\|$ (3rd leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d28
	XLabel=$\|y^j\|$ (4th leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d29
	XLabel=$\|y^j\|$ (5th leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d3[0-6]
	XLabel=$S_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d30
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d31
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d32
	YLabel=$\text{d}\sigma_{W + 2j} / \text{d}S_\text{T}$
	# END PLOT
	-
	+
	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d33
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d34
	YLabel=$\text{d}\sigma_{W + 3j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d35
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_EL/d36
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}S_\text{T}$
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2014_I1319490_MU.plot b/data/plotinfo/ATLAS_2014_I1319490_MU.plot
	--- a/data/plotinfo/ATLAS_2014_I1319490_MU.plot
	+++ b/data/plotinfo/ATLAS_2014_I1319490_MU.plot
	@@ -1,183 +1,182 @@
	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d..
	Title=muon channel, dressed level
	XTwosidedTicks=1
	YTwosidedTicks=1
	LeftMargin=1.5
	LegendYPos=0.3
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d0[1-4]
	XMinorTickMarks=0
	XLabel=$N_\text{jets}$
	YLabel=$\sigma_{W + N_\text{jets}}$
	LegendYPos=0.9
	LegendXPos=0.6
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d01
	-XCustomMajorTicks=0.5 $\geq 0$ 1.5 $\geq 1$ 2.5 $\geq 2$ 3.5 $\geq 3$ 4.5 $\geq 4$ 5.5 $\geq 5$ 6.5 $\geq 6$ 7.5 $\geq 7$
	+XCustomMajorTicks=0.5 $\geq0$ 1.5 $\geq1$ 2.5 $\geq2$ 3.5 $\geq3$ 4.5 $\geq4$ 5.5 $\geq5$ 6.5 $\geq6$ 7.5 $\geq7$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d04
	XCustomMajorTicks=0.5 0 1.5 1 2.5 2 3.5 3 4.5 4 5.5 5 6.5 6 7.5 7
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d0[5-8]
	XLabel=$p^j_\text{T}$ (leading jet) [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d05
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d06
	YLabel=$\text{d}\sigma_{W + 1j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d07
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d08
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d09
	XLabel=$p^j_\text{T}$ (2nd leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d10
	XLabel=$p^j_\text{T}$ (3rd leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d11
	XLabel=$p^j_\text{T}$ (4th leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d12
	XLabel=$p^j_\text{T}$ (5th leading jet) [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}p^j_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d13
	XLabel=$\|y^j\|$ (leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d14
	XLabel=$\|y^j\|$ (subleading jet)
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d1[5-9]
	XLabel=$H_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d2[0-2]
	XLabel=$H_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d15
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d16
	YLabel=$\text{d}\sigma_{W + 1j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d17
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d18
	YLabel=$\text{d}\sigma_{W + 2j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d19
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d20
	YLabel=$\text{d}\sigma_{W + 3j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d21
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d22
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}H_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d23
	XLabel=$\Delta\phi_{j1,j2}$
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta\phi_{j1,j2}$
	LegendYPos=0.9
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d24
	XLabel=$\Delta y_{j1,j2}$
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}y_{j1,j2}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d25
	XLabel=$\Delta R_{j1,j2}$
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}\Delta R_{j1,j2}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d26
	XLabel=$m_{12}$ [GeV]
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}m_{12}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d27
	XLabel=$\|y^j\|$ (3rd leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d28
	XLabel=$\|y^j\|$ (4th leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d29
	XLabel=$\|y^j\|$ (5th leading jet)
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}y^j$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d3[0-6]
	XLabel=$S_\text{T}$ [GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d30
	YLabel=$\text{d}\sigma_{W + \geq 1j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d31
	YLabel=$\text{d}\sigma_{W + \geq 2j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d32
	YLabel=$\text{d}\sigma_{W + 2j} / \text{d}S_\text{T}$
	# END PLOT
	-
	+
	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d33
	YLabel=$\text{d}\sigma_{W + \geq 3j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d34
	YLabel=$\text{d}\sigma_{W + 3j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d35
	YLabel=$\text{d}\sigma_{W + \geq 4j} / \text{d}S_\text{T}$
	# END PLOT

	# BEGIN PLOT /ATLAS_2014_I1319490_MU/d36
	YLabel=$\text{d}\sigma_{W + \geq 5j} / \text{d}S_\text{T}$
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2015_CONF_2015_041.plot b/data/plotinfo/ATLAS_2015_CONF_2015_041.plot
	--- a/data/plotinfo/ATLAS_2015_CONF_2015_041.plot
	+++ b/data/plotinfo/ATLAS_2015_CONF_2015_041.plot
	@@ -1,31 +1,30 @@
	# BEGIN PLOT /ATLAS_2015_CONF_2015_041/d..
	XTwosidedTicks=1
	YTwosidedTicks=1
	LeftMargin=1.5
	XMinorTickMarks=0
	XLabel=$N_\text{jets}$
	LegendYPos=0.9
	LegendXPos=0.6
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041/d01
	LogY=1
	YLabel=$\sigma(Z + N_\text{jets})$ [pb]
	-XCustomMajorTicks=0.5 $\geq 0$ 1.5 $\geq 1$ 2.5 $\geq 2$ 3.5 $\geq 3$ 4.5 $\geq 4$
	+XCustomMajorTicks=0.5 $\geq0$ 1.5 $\geq1$ 2.5 $\geq2$ 3.5 $\geq3$ 4.5 $\geq4$
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041/d02
	LogY=0
	YLabel=$\sigma(Z + N_\text{jets}+1) / \sigma(Z + N_\text{jets})$
	-XCustomMajorTicks=1.5 $\geq 1 /\geq 0$ 2.5 $\geq 2 /\geq 1$ 3.5 $\geq 3 /\geq 2$ 4.5 $\geq 4 /\geq 3$
	+XCustomMajorTicks=1.5 $\geq1/\geq0$ 2.5 $\geq2/\geq1$ 3.5 $\geq3/\geq2$ 4.5 $\geq4/\geq3$
	LegendYPos=0.3
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041/d..-x01
	Title=$Z \rightarrow e^+ e^-$, dressed level
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041/d..-x02
	Title=$Z \rightarrow \ell^+ \ell^-$, dressed level
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2015_CONF_2015_041_EL.plot b/data/plotinfo/ATLAS_2015_CONF_2015_041_EL.plot
	--- a/data/plotinfo/ATLAS_2015_CONF_2015_041_EL.plot
	+++ b/data/plotinfo/ATLAS_2015_CONF_2015_041_EL.plot
	@@ -1,31 +1,30 @@
	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_EL/d..
	XTwosidedTicks=1
	YTwosidedTicks=1
	LeftMargin=1.5
	XMinorTickMarks=0
	XLabel=$N_\text{jets}$
	LegendYPos=0.9
	LegendXPos=0.6
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_EL/d01
	LogY=1
	YLabel=$\sigma(Z + N_\text{jets})$ [pb]
	-XCustomMajorTicks=0.5 $\geq 0$ 1.5 $\geq 1$ 2.5 $\geq 2$ 3.5 $\geq 3$ 4.5 $\geq 4$
	+XCustomMajorTicks=0.5 $\geq0$ 1.5 $\geq1$ 2.5 $\geq2$ 3.5 $\geq3$ 4.5 $\geq4$
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_EL/d02
	LogY=0
	YLabel=$\sigma(Z + N_\text{jets}+1) / \sigma(Z + N_\text{jets})$
	-XCustomMajorTicks=1.5 $\geq 1 /\geq 0$ 2.5 $\geq 2 /\geq 1$ 3.5 $\geq 3 /\geq 2$ 4.5 $\geq 4 /\geq 3$
	+XCustomMajorTicks=1.5 $\geq1/\geq0$ 2.5 $\geq2/\geq1$ 3.5 $\geq3/\geq2$ 4.5 $\geq4/\geq3$
	LegendYPos=0.3
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_EL/d..-x01
	Title=$Z \rightarrow e^+ e^-$, dressed level
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_EL/d..-x02
	Title=$Z \rightarrow \ell^+ \ell^-$, dressed level
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2015_CONF_2015_041_MU.plot b/data/plotinfo/ATLAS_2015_CONF_2015_041_MU.plot
	--- a/data/plotinfo/ATLAS_2015_CONF_2015_041_MU.plot
	+++ b/data/plotinfo/ATLAS_2015_CONF_2015_041_MU.plot
	@@ -1,31 +1,30 @@
	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_MU/d..
	XTwosidedTicks=1
	YTwosidedTicks=1
	LeftMargin=1.5
	XMinorTickMarks=0
	XLabel=$N_\text{jets}$
	LegendYPos=0.9
	LegendXPos=0.6
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_MU/d01
	LogY=1
	YLabel=$\sigma(Z + N_\text{jets})$ [pb]
	-XCustomMajorTicks=0.5 $\geq 0$ 1.5 $\geq 1$ 2.5 $\geq 2$ 3.5 $\geq 3$ 4.5 $\geq 4$
	+XCustomMajorTicks=0.5 $\geq0$ 1.5 $\geq1$ 2.5 $\geq2$ 3.5 $\geq3$ 4.5 $\geq4$
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_MU/d02
	LogY=0
	YLabel=$\sigma(Z + N_\text{jets}+1) / \sigma(Z + N_\text{jets})$
	-XCustomMajorTicks=1.5 $\geq 1 /\geq 0$ 2.5 $\geq 2 /\geq 1$ 3.5 $\geq 3 /\geq 2$ 4.5 $\geq 4 /\geq 3$
	+XCustomMajorTicks=1.5 $\geq1/\geq0$ 2.5 $\geq2/\geq1$ 3.5 $\geq3/\geq2$ 4.5 $\geq4/\geq3$
	LegendYPos=0.3
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_MU/d..-x01
	Title=$Z \rightarrow \mu^+ \mu^-$, dressed level
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_CONF_2015_041_MU/d..-x02
	Title=$Z \rightarrow \ell^+ \ell^-$, dressed level
	# END PLOT
	-
	diff --git a/data/plotinfo/ATLAS_2015_I1351916.plot b/data/plotinfo/ATLAS_2015_I1351916.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1351916.plot
	@@ -0,0 +1,21 @@
	+# BEGIN PLOT /ATLAS_2015_I1351916/d..
	+LogY=0
	+LogX=1
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+YMax=1.2
	+YMin=-0.7
	+RatioPlotYMax=3.0
	+RatioPlotYMin=-3.0
	+XLabel=$m_{ee}$ [GeV]
	+YLabel=$A_\text{FB}$
	+LegendXPos=0.1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1351916/d01-x01
	+Title=Central--central electron channel, dressed level
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1351916/d01-x02
	+Title=Central--forward electron channel, dressed level
	+# END PLOT
	diff --git a/data/plotinfo/ATLAS_2015_I1351916_EL.plot b/data/plotinfo/ATLAS_2015_I1351916_EL.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1351916_EL.plot
	@@ -0,0 +1,21 @@
	+# BEGIN PLOT /ATLAS_2015_I1351916_EL/d..
	+LogY=0
	+LogX=1
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+YMax=1.2
	+YMin=-0.7
	+RatioPlotYMax=3.0
	+RatioPlotYMin=-3.0
	+XLabel=$m_{ee}$ [GeV]
	+YLabel=$A_\text{FB}$
	+LegendXPos=0.1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1351916_EL/d01-x01
	+Title=Central--central electron channel, dressed level
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1351916_EL/d01-x02
	+Title=Central--forward electron channel, dressed level
	+# END PLOT
	diff --git a/data/plotinfo/ATLAS_2015_I1351916_MU.plot b/data/plotinfo/ATLAS_2015_I1351916_MU.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1351916_MU.plot
	@@ -0,0 +1,17 @@
	+# BEGIN PLOT /ATLAS_2015_I1351916_MU/d..
	+LogY=0
	+LogX=1
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+YMax=1.2
	+YMin=-0.7
	+RatioPlotYMax=3.0
	+RatioPlotYMin=-3.0
	+XLabel=$m_{\mu\mu}$ [GeV]
	+YLabel=$A_\text{FB}$
	+LegendXPos=0.1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1351916_MU/d01-x01
	+Title=Central--central muon channel, dressed level
	+# END PLOT
	diff --git a/data/plotinfo/ATLAS_2015_I1364361.plot b/data/plotinfo/ATLAS_2015_I1364361.plot
	--- a/data/plotinfo/ATLAS_2015_I1364361.plot
	+++ b/data/plotinfo/ATLAS_2015_I1364361.plot
	@@ -1,21 +1,21 @@
	# BEGIN PLOT /ATLAS_2015_I1364361/d01-x01-y01
	XLabel=$p_\perp^\text{H}$~[GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp^\text{H}$~[pb/GeV]
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_I1364361/d02-x01-y01
	XLabel=$\|y^\text{H}\|$
	YLabel=$\text{d}\sigma/\text{d}\|y^\text{H}\|$~[pb]
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_I1364361/d03-x01-y01
	XLabel=$N_\text{jets}$
	YLabel=$\text{d}\sigma/\text{d}N_\text{jets}$~[pb]
	XMinorTickMarks=0
	-XCustomMajorTicks=0 0 1 1 2 2 3 $\geq 3$
	+XCustomMajorTicks=0 0 1 1 2 2 3 $\geq3$
	# END PLOT

	# BEGIN PLOT /ATLAS_2015_I1364361/d04-x01-y01
	XLabel=$p_\perp^\text{j1}$~[GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp^\text{j1}$~[pb/GeV]
	# END PLOT
	diff --git a/data/plotinfo/ATLAS_2015_I1390114.plot b/data/plotinfo/ATLAS_2015_I1390114.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1390114.plot
	@@ -0,0 +1,21 @@
	+# BEGIN PLOT /ATLAS_2015_I1390114/d..
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LegendXPos=0.95
	+LegendAlign=r
	+XLabel=
	+#RatioPlotYMax=2.1
	+#RatioPlotYMin=0.1
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1390114/d01
	+XCustomMajorTicks=1.0 $\sigma_{ttb\text{ (lepton$+$jets)}}$ 2.0 $\sigma_{ttb\text{ ($e\mu$)}}$ 3.0 $\sigma_{ttbb\text{ (cut-based)}}$ 4.0 $\sigma_{ttbb\text{ (fit-based)}}$
	+YLabel=Cross section [fb]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1390114/d02
	+LogY=0
	+XCustomMajorTicks=1.0 $R_{ttbb}$
	+YLabel=Cross section ratio [$\%$]
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2015_I1393758.plot b/data/plotinfo/ATLAS_2015_I1393758.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1393758.plot
	@@ -0,0 +1,67 @@
	+# BEGIN PLOT /ATLAS_2015_I1393758/d..
	+LogY=0
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=Dijets, more forward jet
	+XLabel=Jet $p_\text{T}$ [GeV]
	+LegendAlign=r
	+LegendYPos=0.30
	+LegendXPos=0.95
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d0[4-6]
	+Title=Dijets, more central jet
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d1[0-2]
	+Title=Dijets, more central jet
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d01-x01-y01
	+YLabel=Average Jet Charge ($\kappa = 0.3$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d02-x01-y01
	+YLabel=Average Jet Charge ($\kappa = 0.5$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d03-x01-y01
	+YLabel=Average Jet Charge ($\kappa = 0.7$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d04-x01-y01
	+YLabel=Average Jet Charge ($\kappa = 0.3$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d05-x01-y01
	+YLabel=Average Jet Charge ($\kappa = 0.5$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d06-x01-y01
	+YLabel=Average Jet Charge ($\kappa = 0.7$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d07-x01-y01
	+YLabel=Jet Charge RMS ($\kappa = 0.3$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d08-x01-y01
	+YLabel=Jet Charge RMS ($\kappa = 0.5$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d09-x01-y01
	+YLabel=Jet Charge RMS ($\kappa = 0.7$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d10-x01-y01
	+YLabel=Jet Charge RMS ($\kappa = 0.3$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d11-x01-y01
	+YLabel=Jet Charge RMS ($\kappa = 0.5$) [e]
	+# END PLOT #
	+
	+# BEGIN PLOT /ATLAS_2015_I1393758/d12-x01-y01
	+YLabel=Jet Charge RMS ($\kappa = 0.7$) [e]
	+# END PLOT #
	+
	diff --git a/data/plotinfo/ATLAS_2015_I1397635.plot b/data/plotinfo/ATLAS_2015_I1397635.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1397635.plot
	@@ -0,0 +1,9 @@
	+# BEGIN PLOT /ATLAS_2015_I1397635/d01
	+LogY=0
	+XCustomMajorTicks=1.0 $\sigma_{Wt+t\bar{t}}$
	+YLabel=Cross section [fb]
	+LegendXPos=0.95
	+LegendYPos=0.3
	+LegendAlign=r
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2015_I1397637.plot b/data/plotinfo/ATLAS_2015_I1397637.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1397637.plot
	@@ -0,0 +1,12 @@
	+# BEGIN PLOT /ATLAS_2015_I1397637/d..
	+Title=Combined $\ell$ $+$ jets decay mode
	+XLabel=Particle top-jet candidate $p_\text{T}$ [GeV]
	+YLabel= $\text{d}\sigma_{t\bar{t}} / \text{d} p_\text{T}$ [fb/GeV]
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LegendXPos=0.95
	+LegendAlign=r
	+RatioPlotYMax=2.1
	+RatioPlotYMin=0.1
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2015_I1404878.plot b/data/plotinfo/ATLAS_2015_I1404878.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1404878.plot
	@@ -0,0 +1,144 @@
	+# BEGIN PLOT /ATLAS_2015_I1404878/d.
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LeftMargin=1.9
	+LegendXPos=0.95
	+LegendAlign=r
	+YLabelSep=8.0
	+RatioPlotYMin=0.7
	+RatioPlotYMax=1.3
	+Title=Combined lepton channels
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d01
	+XLabel=$m_{t\bar{t}}$ [GeV]
	+YLabel=$\text{d}\sigma / \text{d}m_{t\bar{t}}$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d02
	+XLabel=$m_{t\bar{t}}$ [GeV]
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}m_{t\bar{t}}$ [1/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d03
	+XLabel=$p_\text{T}^{t\bar{t}}$ [GeV]
	+YLabel=$\text{d}\sigma / \text{d}p_\text{T}^{t\bar{t}}$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d04
	+XLabel=$p_\text{T}^{t\bar{t}}$ [GeV]
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}p_\text{T}^{t\bar{t}}$ [1/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d05
	+XLabel=$\|y_{t\bar{t}}\|$
	+YLabel=$\text{d}\sigma / \text{d}\|y_{t\bar{t}}\|$ [pb]
	+LegendXPos=0.05
	+LegendYPos=0.3
	+LegendAlign=l
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d06
	+XLabel=$\|y_{t\bar{t}}\|$
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}\|y_{t\bar{t}}\|$
	+LegendXPos=0.05
	+LegendYPos=0.3
	+LegendAlign=l
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d07
	+XLabel=$p_\text{T}^{t,\text{had}}$ [GeV]
	+YLabel=$\text{d}\sigma / \text{d}p_\text{T}^{t,\text{had}}$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d08
	+XLabel=$p_\text{T}^{t,\text{had}}$ [GeV]
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}p_\text{T}^{t,\text{had}}$ [1/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d09
	+XLabel=$\|y_{t,\text{had}}\|$
	+YLabel=$\text{d}\sigma / \text{d}\|y_{t,\text{had}}\|$ [pb]
	+LegendXPos=0.05
	+LegendYPos=0.3
	+LegendAlign=l
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d10
	+XLabel=$\|y_{t,\text{had}}\|$
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}\|y_{t,\text{had}}\|$
	+LegendXPos=0.05
	+LegendYPos=0.3
	+LegendAlign=l
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d11
	+XLabel=$\|p_\text{out}^{t\bar{t}}\|$ [GeV]
	+YLabel=$\text{d}\sigma / \text{d}\|p_\text{out}^{t\bar{t}}\|$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d12
	+XLabel=$\|p_\text{out}^{t\bar{t}}\|$ [GeV]
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}\|p_\text{out}^{t\bar{t}}\|$ [1/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d13
	+XLabel=$\Delta \phi_{t\bar{t}}$
	+YLabel=$\text{d}\sigma / \text{d}\Delta \phi_{t\bar{t}}$ [pb]
	+LegendXPos=0.05
	+LegendAlign=l
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d14
	+XLabel=$\Delta \phi_{t\bar{t}}$
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}\Delta \phi_{t\bar{t}}$
	+LegendXPos=0.05
	+LegendAlign=l
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d15
	+XLabel=$H_\text{T}^{t\bar{t}}$ [GeV]
	+YLabel=$\text{d}\sigma / \text{d}H_\text{T}^{t\bar{t}}$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d16
	+XLabel=$H_\text{T}^{t\bar{t}}$ [GeV]
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}H_\text{T}^{t\bar{t}}$ [1/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d17
	+XLabel=$y_\text{boost}$
	+YLabel=$\text{d}\sigma / \text{d}y_\text{boost}$ [pb]
	+LegendXPos=0.05
	+LegendYPos=0.3
	+LegendAlign=l
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d18
	+XLabel=$y_\text{boost}$
	+YLabel=$1\/sigma$ $\text{d}\sigma / \text{d}y_\text{boost}$
	+LegendXPos=0.05
	+LegendYPos=0.3
	+LegendAlign=l
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d19
	+XLabel=$\chi_{t\bar{t}}$
	+YLabel=$\text{d}\sigma / \text{d}\chi_{t\bar{t}}$ [pb]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d20
	+XLabel=$\chi_{t\bar{t}}$
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}\chi_{t\bar{t}}$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d21
	+XLabel=$R_{Wt}$
	+YLabel=$\text{d}\sigma / \text{d}R_{Wt}$ [pb]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1404878/d22
	+XLabel=$R_{Wt}$
	+YLabel=$1/\sigma$ $\text{d}\sigma / \text{d}R_{Wt}$
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2015_I1408516.plot b/data/plotinfo/ATLAS_2015_I1408516.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1408516.plot
	@@ -0,0 +1,219 @@
	+# BEGIN PLOT /ATLAS_2015_I1408516/d..
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LegendYPos=0.3
	+LegendXPos=0.05
	+LogX=1
	+YLabel=$1/\sigma$ $\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$
	+XLabel=$p_\text{T}^{\ell\ell}$ [GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d0[2-9]
	+YLabel=$1/\sigma$ $\text{d}\sigma/\text{d}\phi^\ast_\eta$
	+XLabel=$\phi^\ast_\eta$
	+XMin=0.001
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d1[0-6]
	+YLabel=$1/\sigma$ $\text{d}\sigma/\text{d}\phi^\ast_\eta$
	+XLabel=$\phi^\ast_\eta$
	+XMin=0.001
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d02
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.8$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d03
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $0.8\leq \|y_{\ell\ell}\| < 1.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d04
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $1.6\leq \|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d05
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d06
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.4\leq \|y_{\ell\ell}\| < 0.8$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d07
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.8\leq \|y_{\ell\ell}\| < 1.2$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d08
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.2\leq \|y_{\ell\ell}\| < 1.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d09
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.6\leq \|y_{\ell\ell}\| < 2.0$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d10
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $2.0\leq \|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d11
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.8$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d12
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $0.8\leq \|y_{\ell\ell}\| < 1.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d13
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $1.6\leq \|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d14
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d15
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d16
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d17
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d18
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.4 \leq \|y_{\ell\ell}\| < 0.8$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d19
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.8 \leq \|y_{\ell\ell}\| < 1.2$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d20
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.2 \leq \|y_{\ell\ell}\| < 1.6$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d21
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.6 \leq \|y_{\ell\ell}\| < 2.0$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d22
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $2.0 \leq \|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d23
	+Title=$Z\rightarrow ee$, dressed level, $12\,\text{GeV}\leq m_{\ell\ell} < 20\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d24
	+Title=$Z\rightarrow ee$, dressed level, $20\,\text{GeV}\leq m_{\ell\ell} < 30\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d25
	+Title=$Z\rightarrow ee$, dressed level, $30\,\text{GeV}\leq m_{\ell\ell} < 46\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d26
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d27
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d28
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d29
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d30
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.4 \leq \|y_{\ell\ell}\| < 0.8$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d31
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.8 \leq \|y_{\ell\ell}\| < 1.2$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d32
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.2 \leq \|y_{\ell\ell}\| < 1.6$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d33
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.6 \leq \|y_{\ell\ell}\| < 2.0$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d34
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $2.0 \leq \|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d35
	+Title=$Z\rightarrow ee$, dressed level, $12\,\text{GeV}\leq m_{\ell\ell} < 20\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+RatioPlotYMax=3.0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d36
	+Title=$Z\rightarrow ee$, dressed level, $20\,\text{GeV}\leq m_{\ell\ell} < 30\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+RatioPlotYMax=3.0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d37
	+Title=$Z\rightarrow ee$, dressed level, $30\,\text{GeV}\leq m_{\ell\ell} < 46\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+RatioPlotYMax=3.0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d38
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d39
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d40
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516/d41
	+Title=$Z\rightarrow ee$, dressed level
	+XLabel=$m_{\ell\ell}$ [GeV]
	+YLabel=$\sigma$ [pb]
	+LogX=0
	+LegendYPos=0.95
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2015_I1408516_EL.plot b/data/plotinfo/ATLAS_2015_I1408516_EL.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1408516_EL.plot
	@@ -0,0 +1,219 @@
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d..
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LegendYPos=0.3
	+LegendXPos=0.05
	+LogX=1
	+YLabel=$1/\sigma$ $\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$
	+XLabel=$p_\text{T}^{\ell\ell}$ [GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d0[2-9]
	+YLabel=$1/\sigma$ $\text{d}\sigma/\text{d}\phi^\ast_\eta$
	+XLabel=$\phi^\ast_\eta$
	+XMin=0.001
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d1[0-6]
	+YLabel=$1/\sigma$ $\text{d}\sigma/\text{d}\phi^\ast_\eta$
	+XLabel=$\phi^\ast_\eta$
	+XMin=0.001
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d02
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.8$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d03
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $0.8\leq \|y_{\ell\ell}\| < 1.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d04
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $1.6\leq \|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d05
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d06
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.4\leq \|y_{\ell\ell}\| < 0.8$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d07
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.8\leq \|y_{\ell\ell}\| < 1.2$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d08
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.2\leq \|y_{\ell\ell}\| < 1.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d09
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.6\leq \|y_{\ell\ell}\| < 2.0$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d10
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $2.0\leq \|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d11
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.8$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d12
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $0.8\leq \|y_{\ell\ell}\| < 1.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d13
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $1.6\leq \|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d14
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d15
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d16
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d17
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d18
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.4 \leq \|y_{\ell\ell}\| < 0.8$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d19
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.8 \leq \|y_{\ell\ell}\| < 1.2$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d20
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.2 \leq \|y_{\ell\ell}\| < 1.6$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d21
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.6 \leq \|y_{\ell\ell}\| < 2.0$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d22
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $2.0 \leq \|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d23
	+Title=$Z\rightarrow ee$, dressed level, $12\,\text{GeV}\leq m_{\ell\ell} < 20\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d24
	+Title=$Z\rightarrow ee$, dressed level, $20\,\text{GeV}\leq m_{\ell\ell} < 30\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d25
	+Title=$Z\rightarrow ee$, dressed level, $30\,\text{GeV}\leq m_{\ell\ell} < 46\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d26
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d27
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d28
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d29
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d30
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.4 \leq \|y_{\ell\ell}\| < 0.8$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d31
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.8 \leq \|y_{\ell\ell}\| < 1.2$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d32
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.2 \leq \|y_{\ell\ell}\| < 1.6$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d33
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.6 \leq \|y_{\ell\ell}\| < 2.0$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d34
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $2.0 \leq \|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d35
	+Title=$Z\rightarrow ee$, dressed level, $12\,\text{GeV}\leq m_{\ell\ell} < 20\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+RatioPlotYMax=3.0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d36
	+Title=$Z\rightarrow ee$, dressed level, $20\,\text{GeV}\leq m_{\ell\ell} < 30\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+RatioPlotYMax=3.0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d37
	+Title=$Z\rightarrow ee$, dressed level, $30\,\text{GeV}\leq m_{\ell\ell} < 46\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+RatioPlotYMax=3.0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d38
	+Title=$Z\rightarrow ee$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d39
	+Title=$Z\rightarrow ee$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d40
	+Title=$Z\rightarrow ee$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_EL/d41
	+Title=$Z\rightarrow ee$, dressed level
	+XLabel=$m_{\ell\ell}$ [GeV]
	+YLabel=$\sigma$ [pb]
	+LogX=0
	+LegendYPos=0.95
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2015_I1408516_MU.plot b/data/plotinfo/ATLAS_2015_I1408516_MU.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2015_I1408516_MU.plot
	@@ -0,0 +1,219 @@
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d..
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LegendYPos=0.3
	+LegendXPos=0.05
	+LogX=1
	+YLabel=$1/\sigma$ $\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$
	+XLabel=$p_\text{T}^{\ell\ell}$ [GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d0[2-9]
	+YLabel=$1/\sigma$ $\text{d}\sigma/\text{d}\phi^\ast_\eta$
	+XLabel=$\phi^\ast_\eta$
	+XMin=0.001
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d1[0-6]
	+YLabel=$1/\sigma$ $\text{d}\sigma/\text{d}\phi^\ast_\eta$
	+XLabel=$\phi^\ast_\eta$
	+XMin=0.001
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d02
	+Title=$Z\rightarrow \mu\mu$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.8$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d03
	+Title=$Z\rightarrow \mu\mu$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $0.8\leq \|y_{\ell\ell}\| < 1.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d04
	+Title=$Z\rightarrow \mu\mu$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $1.6\leq \|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d05
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d06
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.4\leq \|y_{\ell\ell}\| < 0.8$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d07
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.8\leq \|y_{\ell\ell}\| < 1.2$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d08
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.2\leq \|y_{\ell\ell}\| < 1.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d09
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.6\leq \|y_{\ell\ell}\| < 2.0$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d10
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $2.0\leq \|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d11
	+Title=$Z\rightarrow \mu\mu$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.8$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d12
	+Title=$Z\rightarrow \mu\mu$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $0.8\leq \|y_{\ell\ell}\| < 1.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d13
	+Title=$Z\rightarrow \mu\mu$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $1.6\leq \|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d14
	+Title=$Z\rightarrow \mu\mu$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d15
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d16
	+Title=$Z\rightarrow \mu\mu$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d17
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d18
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.4 \leq \|y_{\ell\ell}\| < 0.8$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d19
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.8 \leq \|y_{\ell\ell}\| < 1.2$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d20
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.2 \leq \|y_{\ell\ell}\| < 1.6$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d21
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.6 \leq \|y_{\ell\ell}\| < 2.0$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d22
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $2.0 \leq \|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d23
	+Title=$Z\rightarrow \mu\mu$, dressed level, $12\,\text{GeV}\leq m_{\ell\ell} < 20\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d24
	+Title=$Z\rightarrow \mu\mu$, dressed level, $20\,\text{GeV}\leq m_{\ell\ell} < 30\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d25
	+Title=$Z\rightarrow \mu\mu$, dressed level, $30\,\text{GeV}\leq m_{\ell\ell} < 46\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d26
	+Title=$Z\rightarrow \mu\mu$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d27
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d28
	+Title=$Z\rightarrow \mu\mu$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d29
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 0.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d30
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.4 \leq \|y_{\ell\ell}\| < 0.8$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d31
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $0.8 \leq \|y_{\ell\ell}\| < 1.2$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d32
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.2 \leq \|y_{\ell\ell}\| < 1.6$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d33
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $1.6 \leq \|y_{\ell\ell}\| < 2.0$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d34
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $2.0 \leq \|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d35
	+Title=$Z\rightarrow \mu\mu$, dressed level, $12\,\text{GeV}\leq m_{\ell\ell} < 20\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+RatioPlotYMax=3.0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d36
	+Title=$Z\rightarrow \mu\mu$, dressed level, $20\,\text{GeV}\leq m_{\ell\ell} < 30\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+RatioPlotYMax=3.0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d37
	+Title=$Z\rightarrow \mu\mu$, dressed level, $30\,\text{GeV}\leq m_{\ell\ell} < 46\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+RatioPlotYMax=3.0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d38
	+Title=$Z\rightarrow \mu\mu$, dressed level, $46\,\text{GeV}\leq m_{\ell\ell} < 66\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d39
	+Title=$Z\rightarrow \mu\mu$, dressed level, $66\,\text{GeV}\leq m_{\ell\ell} < 116\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d40
	+Title=$Z\rightarrow \mu\mu$, dressed level, $116\,\text{GeV}\leq m_{\ell\ell} < 150\,\text{GeV}$, $\|y_{\ell\ell}\| < 2.4$
	+YLabel=$\text{d}\sigma/\text{d} p_\text{T}^{\ell\ell}$ [pb GeV$^{-1}$]
	+XMin=0.9
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2015_I1408516_MU/d41
	+Title=$Z\rightarrow \mu\mu$, dressed level
	+XLabel=$m_{\ell\ell}$ [GeV]
	+YLabel=$\sigma$ [pb]
	+LogX=0
	+LegendYPos=0.95
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2016_I1419070.plot b/data/plotinfo/ATLAS_2016_I1419070.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1419070.plot
	@@ -0,0 +1,69 @@
	+# BEGIN PLOT /ATLAS_2016_I1419070/d..
	+LogY=0
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+XLabel=Jet $p_\text{T}$ [GeV]
	+YLabel=$\langle n_\text{charged}\rangle$
	+LegendAlign=r
	+LegendYPos=0.30
	+LegendXPos=0.95
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d0[7-9]
	+YLabel=$\langle n^\text{central}_\text{charged} - n^\text{forward}_\text{charged}\rangle$
	+LegendAlign=l
	+LegendXPos=0.2
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d1[0-2]
	+YLabel=$\langle n^\text{central}_\text{charged} + n^\text{forward}_\text{charged}\rangle$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d01
	+Title=Dijets, more forward jet, $p^\text{min}_\text{T} > 500$ MeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d02
	+Title=Dijets, more forward jet, $p^\text{min}_\text{T} > 2$ GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d03
	+Title=Dijets, more forward jet, $p^\text{min}_\text{T} > 5$ GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d04
	+Title=Dijets, more central jet, $p^\text{min}_\text{T} > 500$ MeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d05
	+Title=Dijets, more central jet, $p^\text{min}_\text{T} > 2$ GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d06
	+Title=Dijets, more central jet, $p^\text{min}_\text{T} > 5$ GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d07
	+Title=Dijets, $p^\text{min}_\text{T} > 500$ MeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d08
	+Title=Dijets, $p^\text{min}_\text{T} > 2$ GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d09
	+Title=Dijets, $p^\text{min}_\text{T} > 5$ GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d10
	+Title=Dijets, $p^\text{min}_\text{T} > 500$ MeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d11
	+Title=Dijets, $p^\text{min}_\text{T} > 2$ GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419070/d12
	+Title=Dijets, $p^\text{min}_\text{T} > 5$ GeV
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2016_I1419652.plot b/data/plotinfo/ATLAS_2016_I1419652.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1419652.plot
	@@ -0,0 +1,96 @@
	+# BEGIN PLOT /ATLAS_2016_I1419652/d01-x.-y.
	+LogY=1
	+FullRange=1
	+XLabel=$N_\text{ch}$
	+YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}N_\text{ch}$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d01-x01-y01
	+Title=Charged multiplicity $\ge 1$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d01-x01-y02
	+Title=Charged multiplicity $\ge 1$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 30$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d01-x02-y01
	+Title=Charged multiplicity $\ge 1$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 0.8$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d01-x02-y02
	+Title=Charged multiplicity $\ge 1$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 0.8$, $\tau > 30$ ps
	+# END PLOT
	+
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d02-x.-y.
	+LogY=1
	+LogX=1
	+XLabel=$p_\perp$ \; [GeV]
	+YLabel=$1/N_\text{ev} \, 1/2\pi{}p_\perp \, \mathrm{d}\sigma/\mathrm{d}\eta\mathrm{d}p_\perp$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d02-x01-y01
	+Title=Charged particle $p_\perp$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d02-x01-y02
	+Title=Charged particle $p_\perp$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 30$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d02-x02-y01
	+Title=Charged particle $p_\perp$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 0.8$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d02-x02-y02
	+Title=Charged particle $p_\perp$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 0.8$, $\tau > 30$ ps
	+# END PLOT
	+
	+
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d03-x.-y.
	+LogY=0
	+XLabel=$\eta$
	+YLabel=$1/N_\text{ev} \, \mathrm{d}N_\text{ch}/\mathrm{d}\eta$
	+LegendYPos=0.4
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d03-x01-y01
	+Title=Charged particle $\eta$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d03-x01-y02
	+Title=Charged particle $\eta$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 30$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d03-x02-y01
	+Title=Charged particle $\eta$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 0.8$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d03-x02-y02
	+Title=Charged particle $\eta$, $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 0.8$, $\tau > 30$ ps
	+# END PLOT
	+
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d04-x.-y.
	+LogY=0
	+FullRange=1
	+XLabel=$N_\text{ch}$
	+YLabel=$<p_T>$ \; [GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d04-x01-y01
	+Title=Average particle $p_T$, track $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d04-x01-y02
	+Title=Average particle $p_T$, track $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 30$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d04-x02-y01
	+Title=Average particle $p_T$, track $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 0.8$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1419652/d04-x02-y02
	+Title=Average particle $p_T$, track $p_\perp > 500\,\text{MeV}$, $\|\eta\| < 0.8$, $\tau > 30$ ps
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2016_I1426695.plot b/data/plotinfo/ATLAS_2016_I1426695.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1426695.plot
	@@ -0,0 +1,95 @@
	+# BEGIN PLOT /ATLAS_2016_I1426695/d01-x.*-y01
	+LogY=1
	+FullRange=1
	+LegendAlign=r
	+XLabel=$n_\text{ch}$
	+YLabel=$1/N_\text{ev} \, \mathrm{d}N_\text{ev}/\mathrm{d}n_\text{ch}$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d01-x01-y01
	+Title=Charged multiplicity $\ge 2$, track $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d01-x02-y01
	+Title=Charged multiplicity $\ge 1$, track $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$
	+# END PLOT
	+
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d02-x.*-y01
	+LogY=1
	+LogX=1
	+LegendAlign=r
	+LeftMargin=1.6
	+XLabel=$p_\text{T}$ \; [GeV]
	+YLabel=$1/N_\text{ev} \, 1/(2\pi p_\text{T}) \, \mathrm{d}^2 N_\text{ch}/\mathrm{d}\eta\mathrm{d}p_\text{T}$ [GeV$^{-2}$]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d02-x01-y01
	+Title=Charged particle $p_\text{T}$, $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 2$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d02-x02-y01
	+Title=Charged particle $p_\text{T}$, $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 1$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d02-x03-y01
	+Title=Charged particle $p_\text{T}$, $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d02-x04-y01
	+Title=Charged particle $p_\text{T}$, $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 20$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d02-x05-y01
	+Title=Charged particle $p_\text{T}$, $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 50$
	+# END PLOT
	+
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d03-x.*-y01
	+LogY=0
	+LegendAlign=r
	+LegendYPos=0.3
	+XLabel=$\eta$
	+YLabel=$1/N_\text{ev} \, \mathrm{d}N_\text{ch}/\mathrm{d}\eta$
	+LegendYPos=0.4
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d03-x01-y01
	+Title=Charged particle $\eta$, $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 2$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d03-x02-y01
	+Title=Charged particle $\eta$, $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 1$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d03-x03-y01
	+Title=Charged particle $\eta$, $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d03-x04-y01
	+Title=Charged particle $\eta$, $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 20$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d03-x05-y01
	+Title=Charged particle $\eta$, $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 50$
	+# END PLOT
	+
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d04-x.*-y01
	+LogY=0
	+FullRange=1
	+LegendAlign=r
	+LegendYPos=0.3
	+XLabel=$n_\text{ch}$
	+YLabel=$\langle p_\text{T}\rangle$ \; [GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d04-x01-y01
	+Title=average particle $p_T$, track $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 2$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1426695/d04-x02-y01
	+Title=average particle $p_T$, track $p_\text{T} > 500\,\text{MeV}$, $\|\eta\| < 2.5$, for $n_\text{ch} \ge 1$
	+# END PLOT
	+
	+
	diff --git a/data/plotinfo/ATLAS_2016_I1444991.plot b/data/plotinfo/ATLAS_2016_I1444991.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1444991.plot
	@@ -0,0 +1,65 @@
	+# BEGIN PLOT /ATLAS_2016_I1444991/*
	+LogY=1
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LeftMargin=1.5
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1444991/d02
	+Title=$p_\text{T}^\text{jet} > 25$ GeV for $\|\eta\| < 2.4$ and $p_\text{T}^\text{jet} > 30$ GeV for $2.4 < \|\eta\| < 4.5$
	+XLabel=$N_\text{jet}$
	+YLabel=$\text{d}\sigma_\text{fid} / \text{d} N_\text{jet}$ [fb]
	+LogY=0
	+LegendYPos=0.30
	+LegendXPos=0.05
	+LegendAlign=l
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1444991/d03
	+XLabel=$p_\text{T}^H$ [GeV]
	+YLabel=$\text{d}\sigma_\text{fid} / \text{d} p^H_\text{T}$ [fb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1444991/d04-x01-y01
	+XLabel=$\|y_{\ell\ell}\|$
	+YLabel=$\text{d}\sigma_\text{fid} / \text{d} \|y_{\ell\ell}\|$ [fb]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1444991/d05-x01-y01
	+XLabel=$p_\text{T}^{j_1}$ [GeV]
	+YLabel=$\text{d}\sigma_\text{fid} / \text{d} p_\text{T}^{j_1}$ [fb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1444991/d06-x01-y01
	+Title=$p_\text{T}^\text{jet} > 25$ GeV for $\|\eta\| < 2.4$ and $p_\text{T}^\text{jet} > 30$ GeV for $2.4 < \|\eta\| < 4.5$
	+XLabel=$N_\text{jet}$
	+YLabel=$1/\sigma$ $\text{d}\sigma_\text{fid} / \text{d} N_\text{jet}$ [fb]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1444991/d07-x01-y01
	+XLabel=$p_\text{T}^H$ [GeV]
	+YLabel=$1/\sigma$ $\text{d}\sigma_\text{fid} / \text{d} p^H_\text{T}$ [1/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1444991/d08-x01-y01
	+XLabel=$\|y_{\ell\ell}\|$
	+YLabel=$1/\sigma$ $\text{d}\sigma_\text{fid} / \text{d} \|y_{\ell\ell}\|$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1444991/d09-x01-y01
	+XLabel=$p_\text{T}^{j_1}$ [GeV]
	+YLabel=$1/\sigma$ $\text{d}\sigma_\text{fid} / \text{d} p_\text{T}^{j_1}$ [1/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1444991/d10-x01-y01
	+Title=Leading jet veto efficieny
	+XLabel=$p_\text{T}^\text{jet}$ threshold [GeV]
	+YLabel=$\epsilon_0$
	+LogY=0
	+LegendYPos=0.3
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2016_I1457605.plot b/data/plotinfo/ATLAS_2016_I1457605.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1457605.plot
	@@ -0,0 +1,26 @@
	+# BEGIN PLOT /ATLAS_2016_I1457605/d..
	+XLabel=$E_\text{T}^\gamma$ [GeV]
	+YLabel=$\text{d}\sigma / \text{d}E_\text{T}^\gamma$ [pb GeV${}^{-1}$]
	+LogX=1
	+YMax=1.0E04
	+YMin=1.0E-07
	+LegendYPos=0.30
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1457605/d01
	+Title=$0 \leq \|\eta^\gamma\| < 0.6$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1457605/d02
	+Title=$0.6 \leq \|\eta^\gamma\| < 1.37$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1457605/d03
	+Title=$1.56 \leq \|\eta^\gamma\| < 1.81$
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1457605/d04
	+Title=$1.81 \leq \|\eta^\gamma\| < 2.37$
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2016_I1467230.plot b/data/plotinfo/ATLAS_2016_I1467230.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1467230.plot
	@@ -0,0 +1,68 @@
	+# BEGIN PLOT /ATLAS_2016_I1467230/*
	+LogY=1
	+FullRange=1
	+XLabel=$n_\text{ch}$
	+YLabel=$1/N_\text{ev} \, \text{d} N_\text{ev}/\text{d}n_\text{ch}$
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d01-x01-y01
	+Title=Charged multiplicity $\ge 2$, $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d01-x01-y02
	+Title=Charged multiplicity $\ge 2$, $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 30$ ps
	+# END PLOT
	+
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d02-*
	+LogX=1
	+LeftMargin=1.6
	+XLabel=$p_\text{T}$ \; [GeV]
	+YLabel=$1/N_\text{ev} \, 1/(2\pi p_\text{T}) \, \text{d}^2 N_\text{ch} / \text{d}\eta\text{d}p_\text{T}$ [GeV$^{-2}$]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d02-x01-y01
	+Title=Charged particle $p_\text{T}$, $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d02-x01-y02
	+Title=Charged particle $p_\text{T}$, $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 30$ ps
	+# END PLOT
	+
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d03-*
	+LogY=0
	+XLabel=$\eta$
	+YLabel=$1/N_\text{ev} \, \text{d}N_\text{ch}/\text{d}\eta$
	+LegendYPos=0.4
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d03-x01-y01
	+Title=Charged particle $\eta$, $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d03-x01-y02
	+Title=Charged particle $\eta$, $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 30$ ps
	+# END PLOT
	+
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d04-*
	+LogY=0
	+FullRange=1
	+XLabel=$n_\text{ch}$
	+YLabel=$\langle p_\text{T}\rangle$ \; [GeV]
	+LegendYPos=0.3
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d04-x01-y01
	+Title=average particle $p_T$, track $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 300$ ps
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467230/d04-x01-y02
	+Title=average particle $p_T$, track $p_\text{T} > 100\,\text{MeV}$, $\|\eta\| < 2.5$, $\tau > 30$ ps
	+# END PLOT
	+
	+
	+
	+
	diff --git a/data/plotinfo/ATLAS_2016_I1467454.plot b/data/plotinfo/ATLAS_2016_I1467454.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1467454.plot
	@@ -0,0 +1,59 @@
	+# BEGIN PLOT /ATLAS_2016_I1467454/*
	+LogY=1
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LeftMargin=1.6
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d18
	+XLabel=$m_{\ell\ell}$ [GeV]
	+YLabel=$\frac{\text{d}\sigma}{\text{d} m_{\ell\ell}}$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d19
	+XLabel=$\|y_{\ell\ell}\|$
	+YLabel=$\frac{\text{d}^2\sigma}{\text{d} m_{\ell\ell} \text{d}y_{\ell\ell}}$ [pb/GeV]
	+Title=116 GeV $< m_{\ell\ell} <$ 150 GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d2[0-3]
	+XLabel=$\|y_{\ell\ell}\|$
	+YLabel=$\frac{\text{d}^2\sigma}{\text{d} m_{\ell\ell} \text{d}y_{\ell\ell}}$ [pb/GeV]
	+Title=150 GeV $< m_{\ell\ell} <$ 200 GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d21
	+Title=200 GeV $< m_{\ell\ell} <$ 300 GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d22
	+Title=300 GeV $< m_{\ell\ell} <$ 500 GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d23
	+Title=500 GeV $< m_{\ell\ell} <$ 1500 GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d2[4-8]
	+XLabel=$\|\Delta\eta_{\ell\ell}\|$
	+YLabel=$\frac{\text{d}^2\sigma}{\text{d} m_{\ell\ell} \text{d}\Delta\eta_{\ell\ell}}$ [pb/GeV]
	+Title=116 GeV $< m_{\ell\ell} <$ 150 GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d25
	+Title=150 GeV $< m_{\ell\ell} <$ 200 GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d26
	+Title=200 GeV $< m_{\ell\ell} <$ 300 GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d27
	+Title=300 GeV $< m_{\ell\ell} <$ 500 GeV
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1467454/d28
	+Title=500 GeV $< m_{\ell\ell} <$ 1500 GeV
	+# END PLOT
	+
	diff --git a/data/plotinfo/ATLAS_2016_I1468167.plot b/data/plotinfo/ATLAS_2016_I1468167.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1468167.plot
	@@ -0,0 +1,7 @@
	+# BEGIN PLOT /ATLAS_2016_I1468167/d01-x01-y01
	+Title=$\sigma_\text{inel}$ for $\xi > 1 \cdot 10^{-6}$ at $\sqrt{s}=13$ TeV
	+XLabel=$\sqrt{s}$ [GeV]
	+YLabel=$\sigma_\text{inel}$ [mb]
	+YMin=45
	+XCustomMajorTicks=13000 13000
	+# END PLOT
	diff --git a/data/plotinfo/ATLAS_2016_I1468168.plot b/data/plotinfo/ATLAS_2016_I1468168.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1468168.plot
	@@ -0,0 +1,11 @@
	+# BEGIN PLOT /ATLAS_2016_I1468168/d02
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LegendXPos=0.95
	+LegendYPos=0.3
	+LegendAlign=r
	+LogY=0
	+XLabel=
	+XCustomMajorTicks=0.5 $\sigma_{t\bar{t}}^\text{fid}$
	+YLabel=Cross section [pb]
	+# END PLOT
	diff --git a/data/plotinfo/ATLAS_2016_I1479760.plot b/data/plotinfo/ATLAS_2016_I1479760.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/ATLAS_2016_I1479760.plot
	@@ -0,0 +1,158 @@
	+# BEGIN PLOT /ATLAS_2016_I1479760/d..
	+LogY=0
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LeftMargin=1.8
	+TopMargin=1.3
	+YLabelSep=7.5
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d01-x01-y01
	+Title=$\Delta p_\text{T}^{12} = \left\|\vec{p}_{\text{T}}^{\,1}+\vec{p}_{\text{T}}^{\,2}\right\| / (p_\text{T}^{1}+ p_\text{T}^{2})$
	+XLabel=$\Delta p_\text{T}^{12}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta p_\text{T}^{12}}$
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d02-x01-y01
	+Title=$\Delta p_\text{T}^{34} = \left\|\vec{p}_{\text{T}}^{\,3}+\vec{p}_{\text{T}}^{\,4}\right\| / ( p_\text{T}^{3}+p_\text{T}^{4})$
	+XLabel=$\Delta p_\text{T}^{34}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta p_\text{T}^{34}}$
	+LegendAlign=r
	+LegendYPos=0.2
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d03-x01-y01
	+Title=$\Delta p_\text{T}^{13} = \left\|\vec{p}_{\text{T}}^{\,1}+\vec{p}_{\text{T}}^{\,3}\right\| / (p_\text{T}^{1}+ p_\text{T}^{3})$
	+XLabel=$\Delta p_\text{T}^{13}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta p_\text{T}^{13}}$
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d04-x01-y01
	+Title=$\Delta p_\text{T}^{23} = \left\|\vec{p}_{\text{T}}^{\,2}+\vec{p}_{\text{T}}^{\,3}\right\| / (p_\text{T}^{2}+ p_\text{T}^{3})$
	+XLabel=$\Delta p_\text{T}^{23}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta p_\text{T}^{23}}$
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d05-x01-y01
	+Title=$\Delta p_\text{T}^{14} = \left\|\vec{p}_{\text{T}}^{\,1}+\vec{p}_{\text{T}}^{\,4}\right\| / (p_\text{T}^{1}+ p_\text{T}^{4})$
	+XLabel=$\Delta p_\text{T}^{14}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta p_\text{T}^{14}}$
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d06-x01-y01
	+Title=$\Delta p_\text{T}^{24} = \left\|\vec{p}_{\text{T}}^{\,2}+\vec{p}_{\text{T}}^{\,4}\right\| / (p_\text{T}^{2}+ p_\text{T}^{4})$
	+XLabel=$\Delta p_\text{T}^{24}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta p_\text{T}^{24}}$
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d07-x01-y01
	+Title=$\Delta \phi_{12} = \left\|\phi_{1}-\phi_{2}\right\|$
	+XLabel=$\Delta\phi_{12}$ [rad]
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta\phi_{12}}$ rad
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d08-x01-y01
	+Title=$\Delta\phi_{34} = \left\| \phi_{3} - \phi_{4} \right\|$
	+XLabel=$\Delta\phi_{34}$ [rad]
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta\phi_{34}}$ rad
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d09-x01-y01
	+Title=$\Delta\phi_{13} = \left\| \phi_{1} - \phi_{3} \right\|$
	+XLabel=$\Delta\phi_{13}$ [rad]
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta\phi_{13}}$ rad
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d10-x01-y01
	+Title=$\Delta\phi_{23} = \left\| \phi_{2} - \phi_{3} \right\|$
	+XLabel=$\Delta\phi_{23}$ [rad]
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta\phi_{23}}$ rad
	+LegendXPos=0.05
	+LegendYPos=0.2
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d11-x01-y01
	+Title=$\Delta\phi_{14} = \left\| \phi_{1} - \phi_{4} \right\|$
	+XLabel=$\Delta\phi_{14}$ [rad]
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta\phi_{14}}$ rad
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d12-x01-y01
	+Title=$\Delta\phi_{24} = \left\| \phi_{2} - \phi_{4} \right\|$
	+XLabel=$\Delta\phi_{24}$ [rad]
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta\phi_{24}}$ rad
	+LegendXPos=0.05
	+LegendYPos=0.2
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d13-x01-y01
	+Title=$\Delta y_{12} = \left\| y_{1} - y_{2} \right\|$
	+XLabel=$\Delta y_{12}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta y_{12}}$
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d14-x01-y01
	+Title=$\Delta y_{34} = \left\| y_{3} - y_{4} \right\|$
	+XLabel=$\Delta y_{34}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta y_{34}}$
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d15-x01-y01
	+Title=$\Delta y_{13} = \left\| y_{1} - y_{3} \right\|$
	+XLabel=$\Delta y_{13}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta y_{13}}$
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d16-x01-y01
	+Title=$\Delta y_{23} = \left\| y_{2} - y_{3} \right\|$
	+XLabel=$\Delta y_{23}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta y_{23}}$
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d17-x01-y01
	+Title=$\Delta y_{14} = \left\| y_{1} - y_{4} \right\|$
	+XLabel=$\Delta y_{14}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta y_{14}}$
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d18-x01-y01
	+Title=$\Delta y_{24} = \left\| y_{2} - y_{4} \right\|$
	+XLabel=$\Delta y_{24}$
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\Delta y_{24}}$
	+LegendAlign=r
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d19-x01-y01
	+Title=Azimuthal angle between planes of interactions $\{ \langle 1,2 \rangle \langle 3,4 \rangle \}$
	+XLabel=$\left\|\phi_{1 + 2} - \phi_{3 + 4}\right\|$ [rad]
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\left\|\phi_{1 + 2} - \phi_{3 + 4}\right\|}$ rad
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d20-x01-y01
	+Title=Azimuthal angle between planes of interactions $\{ \langle 1,3 \rangle \langle 2,4 \rangle \}$
	+XLabel=$\left\|\phi_{1 + 3} - \phi_{2 + 4}\right\|$ [rad]
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\left\|\phi_{1 + 3} - \phi_{2 + 4}\right\|}$ rad
	+LegendXPos=0.05
	+# END PLOT
	+
	+# BEGIN PLOT /ATLAS_2016_I1479760/d21-x01-y01
	+Title=Azimuthal angle between planes of interactions $\{ \langle 1,4 \rangle \langle 2,3 \rangle \}$
	+XLabel=$\left\|\phi_{1 + 4} - \phi_{2 + 3}\right\|$ [rad]
	+YLabel=$\dfrac{1}{\sigma} \dfrac{\text{d}\sigma}{\text{d}\left\|\phi_{1 + 4} - \phi_{2 + 3}\right\|}$ rad
	+LegendXPos=0.05
	+# END PLOT
	diff --git a/data/plotinfo/BABAR_2013_I1116411.plot b/data/plotinfo/BABAR_2013_I1116411.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/BABAR_2013_I1116411.plot
	@@ -0,0 +1,9 @@
	+# BEGIN PLOT /BABAR_2013_I1116411/d01-x01-y01
	+Title=$B^+\to \omega\ell^+\nu$
	+XLabel=$q^2$~[GeV$^2$]
	+#YLabel=[Uncomment and insert y-axis label for histogram d01-x01-y01 here]
	+LogY=0
	+NormalizeToIntegral=1
	+# END PLOT
	+
	+# ... add more histograms as you need them ...
	diff --git a/data/plotinfo/BABAR_2015_I1334693.plot b/data/plotinfo/BABAR_2015_I1334693.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/BABAR_2015_I1334693.plot
	@@ -0,0 +1,9 @@
	+# BEGIN PLOT /BABAR_2015_I1334693/d01-x01-y01
	+Title=$D^0\to\pi^- e^+ \nu_e$
	+XLabel=$q^2$~[GeV$^2$]
	+#YLabel=[Uncomment and insert y-axis label for histogram d01-x01-y01 here]
	+# + any additional plot settings you might like, see make-plots documentation
	+NormalizeToIntegral=1
	+# END PLOT
	+
	+# ... add more histograms as you need them ...
	diff --git a/data/plotinfo/BELLE_2011_I878990.plot b/data/plotinfo/BELLE_2011_I878990.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/BELLE_2011_I878990.plot
	@@ -0,0 +1,9 @@
	+# BEGIN PLOT /BELLE_2011_I878990/d01-x01-y01
	+Title=$B^0\to \pi^- \ell^+\nu$
	+XLabel=$q^2$~[GeV$^2$]
	+#YLabel=[Uncomment and insert y-axis label for histogram d01-x01-y01 here]
	+LogY=0
	+#NormalizeToIntegral=1
	+# END PLOT
	+
	+# ... add more histograms as you need them ...
	diff --git a/data/plotinfo/BELLE_2013_I1238273.plot b/data/plotinfo/BELLE_2013_I1238273.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/BELLE_2013_I1238273.plot
	@@ -0,0 +1,26 @@
	+# BEGIN PLOT /BELLE_2013_I1238273/*
	+XLabel=$q^2$~[Gev$^2$]
	+YLabel=$\Delta B / \Delta q$
	+# END PLOT
	+
	+# BEGIN PLOT /BELLE_2013_I1238273/d01-x01-y01
	+Title=$\bar{B}^0 \to \pi^+ \ell^- \nu$
	+# END PLOT
	+
	+# BEGIN PLOT /BELLE_2013_I1238273/d03-x01-y01
	+Title=$\bar{B}^0 \to \rho^+ \ell^- \nu$
	+LegendXPos=0.1
	+LegendYPos=0.5
	+# END PLOT
	+
	+# BEGIN PLOT /BELLE_2013_I1238273/d02-x01-y01
	+Title=$B^- \to \pi^0 \ell^- \nu$
	+# END PLOT
	+
	+# BEGIN PLOT /BELLE_2013_I1238273/d04-x01-y01
	+Title=$B^- \to \rho^0 \ell^- \nu$
	+# END PLOT
	+
	+# BEGIN PLOT /BELLE_2013_I1238273/d05-x01-y01
	+Title=$B^- \to \omega \ell^- \nu$
	+# END PLOT
	diff --git a/data/plotinfo/BELLE_2015_I1397632.plot b/data/plotinfo/BELLE_2015_I1397632.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/BELLE_2015_I1397632.plot
	@@ -0,0 +1,33 @@
	+# BEGIN PLOT /BELLE_2015_I1397632/d01-x01-y01
	+Title=$B^0\to D^-e^+\nu$
	+XLabel=$w$
	+#YLabel=[Uncomment and insert y-axis label for histogram d01-x01-y01 here]
	+# + any additional plot settings you might like, see make-plots documentation
	+NormalizeToIntegral=1
	+# END PLOT
	+
	+# BEGIN PLOT /BELLE_2015_I1397632/d01-x01-y02
	+Title=$B^0\to D^-\mu^+\nu$
	+XLabel=$w$
	+#YLabel=[Uncomment and insert y-axis label for histogram d01-x01-y01 here]
	+# + any additional plot settings you might like, see make-plots documentation
	+NormalizeToIntegral=1
	+# END PLOT
	+
	+# BEGIN PLOT /BELLE_2015_I1397632/d01-x01-y03
	+Title=$B^+\to D^0e^+\nu$
	+XLabel=$w$
	+#YLabel=[Uncomment and insert y-axis label for histogram d01-x01-y01 here]
	+# + any additional plot settings you might like, see make-plots documentation
	+NormalizeToIntegral=1
	+# END PLOT
	+
	+# BEGIN PLOT /BELLE_2015_I1397632/d01-x01-y04
	+Title=$B^+\to D^0\mu^+\nu$
	+XLabel=$w$
	+#YLabel=[Uncomment and insert y-axis label for histogram d01-x01-y01 here]
	+# + any additional plot settings you might like, see make-plots documentation
	+NormalizeToIntegral=1
	+# END PLOT
	+
	+# ... add more histograms as you need them ...
	diff --git a/data/plotinfo/CDF_1993_S2742446.plot b/data/plotinfo/CDF_1993_S2742446.plot
	--- a/data/plotinfo/CDF_1993_S2742446.plot
	+++ b/data/plotinfo/CDF_1993_S2742446.plot
	@@ -1,6 +1,7 @@
	# BEGIN PLOT /CDF_1993_S2742446/d01-x01-y01
	Title=Angular distribution of prompt photons
	XLabel=$\|\cos\theta^*\|=\|\tanh((\eta_j-\eta_\gamma)/2.0)\|$
	YLabel=$\mathrm{d}N/\mathrm{d}\cos\theta^*$
	+YMax=7
	LogY=0
	# END PLOT
	diff --git a/data/plotinfo/CDF_1996_S3349578.plot b/data/plotinfo/CDF_1996_S3349578.plot
	--- a/data/plotinfo/CDF_1996_S3349578.plot
	+++ b/data/plotinfo/CDF_1996_S3349578.plot
	@@ -1,248 +1,248 @@
	# BEGIN PLOT /CDF_1996_S3349578/d01-x01-y01
	Title=Multijet mass in inclusive 3-jet events
	XLabel=$m_{3J}$ [GeV]
	YLabel=$1/N \mathrm{d}N/\mathrm{d}m$ [1/GeV]
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d01-x01-y02
	Title=Multijet mass in inclusive 4-jet events
	XLabel=$m_{4J}$ [GeV]
	YLabel=$1/N \mathrm{d}N/\mathrm{d}m$ [1/GeV]
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d01-x01-y03
	Title=Multijet mass in inclusive 5-jet events
	XLabel=$m_{5J}$ [GeV]
	YLabel=$1/N \mathrm{d}N/\mathrm{d}m$ [1/GeV]
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d02-x01-y01
	Title=Dalitz distribution in inclusive 3-jet events
	XLabel=$X_3$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}X_3$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d03-x01-y01
	Title=Dalitz distribution in inclusive 3-jet events
	XLabel=$X_4$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}X_4$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d04-x01-y01
	Title=Dalitz distribution in inclusive 4-jet events
	-XLabel=$X_3^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}X_3^{'}$
	+XLabel=$X_3^\prime$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}X_3^\prime$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d05-x01-y01
	Title=Dalitz distribution in inclusive 4-jet events
	-XLabel=$X_4^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}X_4^{'}$
	+XLabel=$X_4^\prime$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}X_4^\prime$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d06-x01-y01
	Title=Dalitz distribution in inclusive 5-jet events
	-XLabel=$X_3^{''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}X_3^{''}$
	+XLabel=$X_3^{\prime\prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}X_3^{\prime\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d07-x01-y01
	Title=Dalitz distribution in inclusive 5-jet events
	-XLabel=$X_4^{''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}X_4^{''}$
	+XLabel=$X_4^{\prime\prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}X_4^{\prime\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d08-x01-y01
	Title=Leading jet angle in inclusive 3-jet events
	XLabel=$\|\cos \theta_3\|$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}\cos\theta_3$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d09-x01-y01
	Title=Angular distribution in inclusive 3-jet events
	XLabel=$\Psi_3$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_3$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d10-x01-y01
	Title=Leading jet angle in inclusive 4-jet events
	-XLabel=$\|\cos \theta_{3^'}\|$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\cos\theta_{3^'}$
	+XLabel=$\|\cos \theta_{3^\prime}\|$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\cos\theta_{3^\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d11-x01-y01
	Title=Angular distribution in inclusive 4-jet events
	-XLabel=$\Psi_{3^'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{3^'}$
	+XLabel=$\Psi_{3^\prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{3^\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d12-x01-y01
	Title=Leading jet angle in inclusive 5-jet events
	-XLabel=$\|\cos \theta_{3^{''}}\|$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\cos\theta_{3^{''}}$
	+XLabel=$\|\cos \theta_{3^{\prime\prime}}\|$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\cos\theta_{3^{\prime\prime}}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d13-x01-y01
	Title=Angular distribution in inclusive 5-jet events
	-XLabel=$\Psi_{3^{''}}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{3^{''}}$
	+XLabel=$\Psi_{3^{\prime\prime}}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{3^{\prime\prime}}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d14-x01-y01
	Title=Single-jet mass fraction in inclusive 3-jet events
	XLabel=$f_3$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}f_3$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d14-x01-y02
	Title=Single-jet mass fraction in inclusive 3-jet events
	XLabel=$f_4$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}f_4$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d14-x01-y03
	Title=Single-jet mass fraction in inclusive 3-jet events
	XLabel=$f_5$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}f_5$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d15-x01-y01
	Title=Single-jet mass fraction in inclusive 4-jet events
	-XLabel=$f_3^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_3^{'}$
	+XLabel=$f_3^\prime$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_3^\prime$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d15-x01-y02
	Title=Single-jet mass fraction in inclusive 4-jet events
	-XLabel=$f_4^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_4^{'}$
	+XLabel=$f_4^\prime$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_4^\prime$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d15-x01-y03
	Title=Single-jet mass fraction in inclusive 4-jet events
	-XLabel=$f_5^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_5^{'}$
	+XLabel=$f_5^\prime$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_5^\prime$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d16-x01-y01
	Title=Single-jet mass fraction in inclusive 5-jet events
	-XLabel=$f_3^{''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_3^{''}$
	+XLabel=$f_3^{\prime\prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_3^{\prime\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d16-x01-y02
	Title=Single-jet mass fraction in inclusive 5-jet events
	-XLabel=$f_4^{''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_4^{''}$
	+XLabel=$f_4^{\prime\prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_4^{\prime\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d16-x01-y03
	Title=Single-jet mass fraction in inclusive 5-jet events
	-XLabel=$f_5^{''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_5^{''}$
	+XLabel=$f_5^{\prime\prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_5^{\prime\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d17-x01-y01
	Title=Two-body energy sharing in inclusive 4-jet events
	XLabel=$X_A$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}X_A$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d18-x01-y01
	Title=Two-body energy sharing in inclusive 5-jet events
	-XLabel=$X_A^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}X_A^{'}$
	+XLabel=$X_A^{\prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}X_A^{\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d18-x01-y02
	Title=Two-body energy sharing in inclusive 5-jet events
	XLabel=$X_C$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}X_C$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d19-x01-y01
	Title=Two-body angular distribution in inclusive 4-jet events
	-XLabel=$\Psi^{'}_{AB}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi^{'}_{AB}$
	+XLabel=$\Psi^{\prime}_{AB}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi^{\prime}_{AB}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d20-x01-y01
	Title=Two-body angular distribution in inclusive 5-jet events
	-XLabel=$\Psi^{''}_{A^{'}B^{'}}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi^{''}_{A^{'}B^{'}}$
	+XLabel=$\Psi^{\prime\prime}_{A^{\prime}B^{\prime}}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi^{\prime\prime}_{A^{\prime}B^{\prime}}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d20-x01-y02
	Title=Two-body angular distribution in inclusive 5-jet events
	-XLabel=$\Psi^{''}_{CD}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi^{''}_{CD}$
	+XLabel=$\Psi^{\prime\prime}_{CD}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi^{\prime\prime}_{CD}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d21-x01-y01
	Title=Single-body mass fraction in inclusive 4-jet events
	XLabel=$f_A$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}f_A$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d21-x01-y02
	Title=Single-body mass fraction in inclusive 4-jet events
	XLabel=$f_B$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}f_B$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d22-x01-y01
	Title=Single-body mass fraction in inclusive 5-jet events
	-XLabel=$f_A^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_A^{'}$
	+XLabel=$f_A^{\prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_A^{\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d23-x01-y01
	Title=Single-body mass fraction in inclusive 5-jet events
	-XLabel=$f_B^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_B^{'}$
	+XLabel=$f_B^{\prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_B^{\prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d24-x01-y01
	Title=Single-body mass fraction in inclusive 5-jet events
	XLabel=$f_C$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}f_C$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1996_S3349578/d25-x01-y01
	Title=Single-body mass fraction in inclusive 5-jet events
	XLabel=$f_D$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}f_D$
	LogY=0
	# END PLOT
	diff --git a/data/plotinfo/CDF_1997_S3541940.plot b/data/plotinfo/CDF_1997_S3541940.plot
	--- a/data/plotinfo/CDF_1997_S3541940.plot
	+++ b/data/plotinfo/CDF_1997_S3541940.plot
	@@ -1,138 +1,138 @@
	# BEGIN PLOT /CDF_1997_S3541940/d01-x01-y01
	Title=Multijet mass
	XLabel=$m_{6J}$ [GeV]
	YLabel=$1/N \mathrm{d}N/\mathrm{d}m$ [1/GeV]
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d02-x01-y01
	Title=Dalitz distribution
	-XLabel=$X_3^{'''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}X_3^{'''}$
	+XLabel=$X_3^{primeprimeprime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}X_3^{primeprimeprime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d03-x01-y01
	Title=Dalitz distribution
	-XLabel=$X_4^{'''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}X_4^{'''}$
	+XLabel=$X_4^{primeprimeprime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}X_4^{primeprimeprime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d04-x01-y01
	Title=Leading jet angle
	-XLabel=$\|\cos \theta_{3^{'''}}\|$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\cos\theta_{3^{'''}}$
	+XLabel=$\|\cos \theta_{3^{primeprimeprime}}\|$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\cos\theta_{3^{primeprimeprime}}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d05-x01-y01
	Title=Angular distribution
	-XLabel=$\Psi_{3^{'''}}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{3^{'''}}$
	+XLabel=$\Psi_{3^{primeprimeprime}}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{3^{primeprimeprime}}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d06-x01-y01
	Title=Single-jet mass fraction
	-XLabel=$f_3^{'''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_3^{'''}$
	+XLabel=$f_3^{primeprimeprime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_3^{primeprimeprime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d06-x01-y02
	Title=Single-jet mass fraction
	-XLabel=$f_4^{'''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_4^{'''}$
	+XLabel=$f_4^{primeprimeprime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_4^{primeprimeprime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d06-x01-y03
	Title=Single-jet mass fraction
	-XLabel=$f_5^{'''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_5^{'''}$
	+XLabel=$f_5^{primeprimeprime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_5^{primeprimeprime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d07-x01-y01
	Title=Two-body energy sharing
	-XLabel=$X_A^{''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}X_A^{''}$
	+XLabel=$X_A^{primeprime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}X_A^{primeprime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d08-x01-y01
	Title=Two-body energy sharing
	-XLabel=$X_C^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}X_C^{'}$
	+XLabel=$X_C^{prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}X_C^{prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d09-x01-y01
	Title=Two-body energy sharing
	XLabel=$X_E$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}X_E$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d10-x01-y01
	Title=Two-body angular distribution
	-XLabel=$\Psi_{A^{''}B^{''}}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{A^{''}B^{''}}$
	+XLabel=$\Psi_{A^{primeprime}B^{primeprime}}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{A^{primeprime}B^{primeprime}}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d11-x01-y01
	Title=Two-body angular distribution
	-XLabel=$\Psi_{C^{'}D^{'}}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{C^{'}D^{'}}$
	+XLabel=$\Psi_{C^{prime}D^{prime}}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{C^{prime}D^{prime}}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d12-x01-y01
	Title=Two-body angular distribution
	XLabel=$\Psi_{EF}$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}\Psi_{EF}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d13-x01-y01
	Title=Single-body mass fraction
	-XLabel=$f_A^{''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_A^{''}$
	+XLabel=$f_A^{primeprime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_A^{primeprime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d14-x01-y01
	Title=Single-body mass fraction
	-XLabel=$f_B^{''}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_B^{''}$
	+XLabel=$f_B^{primeprime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_B^{primeprime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d15-x01-y01
	Title=Single-body mass fraction
	-XLabel=$f_C^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_C^{'}$
	+XLabel=$f_C^{prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_C^{prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d16-x01-y01
	Title=Single-body mass fraction
	-XLabel=$f_D^{'}$
	-YLabel=$1/N \mathrm{d}N/\mathrm{d}f_D^{'}$
	+XLabel=$f_D^{prime}$
	+YLabel=$1/N \mathrm{d}N/\mathrm{d}f_D^{prime}$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d17-x01-y01
	Title=Single-body mass fraction
	XLabel=$f_E$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}f_E$
	LogY=0
	# END PLOT

	# BEGIN PLOT /CDF_1997_S3541940/d18-x01-y01
	Title=Single-body mass fraction
	XLabel=$f_F$
	YLabel=$1/N \mathrm{d}N/\mathrm{d}f_F$
	LogY=0
	# END PLOT
	diff --git a/data/plotinfo/CDF_2009_S8383952.plot b/data/plotinfo/CDF_2009_I856131.plot
	rename from data/plotinfo/CDF_2009_S8383952.plot
	rename to data/plotinfo/CDF_2009_I856131.plot
	--- a/data/plotinfo/CDF_2009_S8383952.plot
	+++ b/data/plotinfo/CDF_2009_I856131.plot
	@@ -1,19 +1,19 @@
	-# BEGIN PLOT /CDF_2009_S8383952/d01-x01-y01
	+# BEGIN PLOT /CDF_2009_I856131/d01-x01-y01
	Title=Total XS for $66 < M_{ee}/\mathrm{GeV} < 116$
	XLabel=$\sqrt{s}$
	YLabel=$\sigma$ [pb]
	LogY=0
	XMajorTickMarks=20
	XMinorTickMarks=0
	YMin=150
	YMax=350
	XMin=1955
	XMax=1965
	# END PLOT

	-# BEGIN PLOT /CDF_2009_S8383952/d02-x01-y01
	+# BEGIN PLOT /CDF_2009_I856131/d02-x01-y01
	Title=$e^+ e^-$ pair rapidity
	XLabel=$\|y_{e^+ e^-}\|$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}y$ [pb]
	LogY=0
	# END PLOT
	diff --git a/data/plotinfo/CDF_2015_1388868.plot b/data/plotinfo/CDF_2015_1388868.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/CDF_2015_1388868.plot
	@@ -0,0 +1,349 @@
	+# BEGIN PLOT /CDF_2015_I1388868/*
	+XLabelSep=4.4
	+YLabelSep=5.4
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d01-x01-y01
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransDIF charged-particle density $\sqrt{s}=1.96\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d01-x01-y02
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMIN charged-particle density $\sqrt{s}=1.96\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d01-x01-y03
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMAX charged-particle density $\sqrt{s}=1.96\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d01-x01-y04
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransAVE charged-particle density $\sqrt{s}=1.96\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d01-x01-y06
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransDIF charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=1.96\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d01-x01-y07
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMIN charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=1.96\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d01-x01-y08
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMAX charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=1.96\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d01-x01-y09
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransAVE charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=1.96\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d02-x01-y01
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransDIF charged-particle density $\sqrt{s}=900\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d02-x01-y02
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMIN charged-particle density $\sqrt{s}=900\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d02-x01-y03
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMAX charged-particle density $\sqrt{s}=900\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d02-x01-y04
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransAVE charged-particle density $\sqrt{s}=900\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d02-x01-y06
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransDIF charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=900\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d02-x01-y07
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMIN charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=900\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d02-x01-y08
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMAX charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=900\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d02-x01-y09
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransAVE charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=900\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d03-x01-y01
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransDIF charged-particle density $\sqrt{s}=300\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+RatioPlotYMax=2.099
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+B
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d03-x01-y02
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMIN charged-particle density $\sqrt{s}=300\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.20
	+LegendYPos=0.40
	+RatioPlotYMax=2.099
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d03-x01-y03
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMAX charged-particle density $\sqrt{s}=300\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+RatioPlotYMax=2.099
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d03-x01-y04
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransAVE charged-particle density $\sqrt{s}=300\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+RatioPlotYMax=2.099
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d03-x01-y06
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransDIF charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=300\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+RatioPlotYMax=2.099
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d03-x01-y07
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMIN charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=300\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.20
	+LegendYPos=0.40
	+RatioPlotYMax=2.099
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d03-x01-y08
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMAX charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=300\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}_\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+RatioPlotYMax=2.099
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CDF_2015_I1388868/d03-x01-y09
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransAVE charged $p^{\text{sum}}_\text{T}$ density $\sqrt{s}=300\,\text{GeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$ [GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp^{\text{sum}}\text{T}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+RatioPlotYMax=2.099
	+LogY=0
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+XLabelSep=4.4
	+YLabelSep=5.4
	+# END PLOT
	+
	+
	diff --git a/data/plotinfo/CMS_QCD_10_024.plot b/data/plotinfo/CMS_2010_PAS_QCD_10_024.plot
	rename from data/plotinfo/CMS_QCD_10_024.plot
	rename to data/plotinfo/CMS_2010_PAS_QCD_10_024.plot
	diff --git a/data/plotinfo/CMS_2012_I1193338.plot b/data/plotinfo/CMS_2012_I1193338.plot
	--- a/data/plotinfo/CMS_2012_I1193338.plot
	+++ b/data/plotinfo/CMS_2012_I1193338.plot
	@@ -1,7 +1,7 @@
	-# BEGIN PLOT /CMS_2012_I1193338/d01-x01-y01
	+# BEGIN PLOT /CMS_2012_I1193338/d01-x01-y01
	Title=$\sigma_\text{inel}$ at $\sqrt{s}=7$ TeV
	-XCustomMajorTicks=0.5 $\xi>5x10^{-6}$ 1.5 $n_\text{ch} > 1$ 2.5 $n_\text{ch} > 2$ 3.5 $n_\text{ch} > 3$
	+XCustomMajorTicks=0.5 $\xi>5x10^{-6}$ 1.5 $n_\text{ch}>1$ 2.5 $n_\text{ch}>2$ 3.5 $n_\text{ch}>3$
	YLabel=$\sigma_\text{inel}$ [mb]
	LegendYPos=0.4
	LogY=0
	# END PLOT
	diff --git a/data/plotinfo/CMS_2012_I1298807.plot b/data/plotinfo/CMS_2012_I1298807.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/CMS_2012_I1298807.plot
	@@ -0,0 +1,51 @@
	+# BEGIN PLOT /CMS_2012_I1298807/d01-x01-y01
	+Title=$\text{CMS, }\sqrt s\text{ = 8 TeV, ZZ }\to 4\mu, 4e, 2e2\mu$
	+XLabel=Leading lepton $p_{T}$ (GeV)
	+YLabel=1/$\sigma_{\text{fid}}$ d $\sigma_{\text{fid}}$/d(Ld. lep. p ) (1/GeV)
	+LogY=0
	+# + any additional plot settings you might like, see make-plots documentation
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2012_I1298807/d01-x01-y02
	+Title=$\text{CMS, }\sqrt s\text{ = 8 TeV, ZZ }\to 4\mu, 4e, 2e2\mu$
	+XLabel=$Z_{1} p_{T}$ (GeV)
	+YLabel=1/$\sigma_{\text{fid}}$ d $\sigma_{\text{fid}}$/d($Z_{1} p_{T})$ (1/GeV)
	+LogY=0
	+# + any additional plot settings you might like, see make-plots documentation
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CMS_2012_I1298807/d01-x01-y03
	+Title=$\text{CMS, }\sqrt s\text{ = 8 TeV, ZZ }\to 4\mu, 4e, 2e2\mu$
	+XLabel=$ZZ p_{T}$ (GeV)
	+YLabel=1/$\sigma_{\text{fid}}$ d $\sigma_{\text{fid}}$/d($ZZ p_{T}$ ) (1/GeV)
	+LogY=0
	+# + any additional plot settings you might like, see make-plots documentation
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2012_I1298807/d01-x01-y04
	+Title=$\text{CMS, }\sqrt s\text{ = 8 TeV, ZZ }\to 4\mu, 4e, 2e2\mu$
	+XLabel=$m_{ZZ}$ (GeV)
	+YLabel=1/$\sigma_{\text{fid}}$ d $\sigma_{\text{fid}}$/d($m_{ZZ}$ ) (1/GeV)
	+LogY=0
	+# + any additional plot settings you might like, see make-plots documentation
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CMS_2012_I1298807/d01-x01-y05
	+Title=$\text{CMS, }\sqrt s\text{ = 8 TeV, ZZ }\to 4\mu, 4e, 2e2\mu$
	+XLabel=$\Delta\phi(Z_{1},Z_{2})$
	+YLabel=1/$\sigma_{\text{fid}}$ d $\sigma_{\text{fid}}$/d($\Delta\phi(Z_{1},Z_{2})$)
	+LogY=0
	+# + any additional plot settings you might like, see make-plots documentation
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2012_I1298807/d01-x01-y06
	+Title=$\text{CMS, }\sqrt s\text{ = 8 TeV, ZZ }\to 4\mu, 4e, 2e2\mu$
	+XLabel=$\Delta R (Z_{1},Z_{2})$
	+YLabel=1/$\sigma_{\text{fid}}$ d $\sigma_{\test{fid}}$/d($\Delta R (Z_{1},Z_{2})$)
	+LogY=0
	+# + any additional plot settings you might like, see make-plots documentation
	+# END PLOT
	+
	+
	diff --git a/data/plotinfo/CMS_2012_PAS_FSQ_12_020.plot b/data/plotinfo/CMS_2012_PAS_FSQ_12_020.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/CMS_2012_PAS_FSQ_12_020.plot
	@@ -0,0 +1,78 @@
	+# BEGIN PLOT /CMS_PAS_FSQ_12_020/*
	+XLabelSep=4.4
	+YLabelSep=5.4
	+ConnectBins=0
	+RatioPlotErrorBandColor=grey!40!yellow!60
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_PAS_FSQ_12_020/d05-x01-y01
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMAX charged-particle density $\sqrt{s}=7\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$[GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LogY=0
	+LegendXPos=0.40
	+LegendYPos=0.50
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_PAS_FSQ_12_020/d06-x01-y01
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMIN charged-particle density $\sqrt{s}=7\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$[GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LogY=0
	+LegendXPos=0.40
	+LegendYPos=0.50
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_PAS_FSQ_12_020/d07-x01-y01
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransDIF charged-particle density $\sqrt{s}=7\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$[GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dN_\text{ch}\,/d\eta\, d\phi$}
	+LogY=0
	+LegendXPos=0.40
	+LegendYPos=0.50
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_PAS_FSQ_12_020/d08-x01-y01
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMAX charged $p^{\text{sum}}_{\text{T}}$ density $\sqrt{s}=7\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$[GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp_\text{T}^{\text{sum}}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_PAS_FSQ_12_020/d09-x01-y01
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransMIN charged $p^{\text{sum}}_{\text{T}}$ density $\sqrt{s}=7\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$[GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp_\text{T}^{\text{sum}}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_PAS_FSQ_12_020/d10-x01-y01
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+Title=\large{TransDIF charged $p^{\text{sum}}_{\text{T}}$ density $\sqrt{s}=7\,\text{TeV}$}
	+XLabel=\large{$p_\text{T}^{\text{max}}$[GeV]}
	+YLabel=\large{$(1/N_\text{events})\; dp_\text{T}^{\text{sum}}\,/d\eta\, d\phi$ [GeV]}
	+LegendXPos=0.40
	+LegendYPos=0.50
	+LogY=0
	+# END PLOT
	+
	+
	+
	+
	+
	+
	diff --git a/data/plotinfo/CMS_2014_I1305624.plot b/data/plotinfo/CMS_2014_I1305624.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/CMS_2014_I1305624.plot
	@@ -0,0 +1,228 @@
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x01-y01
	+Title=Transverse thrust for $110 < p_\text{T,1} < 170 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\tau_{{\perp^}})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\tau_{_{\perp^}})$
	+LogY=0
	+#XLabelSep=4.5
	+#YLabelSep=4.5
	+LegendXPos=0.20
	+LegendYPos=0.70
	+#RatioPlotMode=datamc
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x01-y02
	+Title=Transverse thrust for $170 < p_\text{T,1} < 250 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\tau_{{\perp^}})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\tau_{_{\perp^}})$
	+LogY=0
	+LegendXPos=0.20
	+LegendYPos=0.70
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x01-y03
	+Title=Transverse thrust for $250 < p_\text{T,1} < 320 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\tau_{{\perp^}})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\tau_{_{\perp^}})$
	+LogY=0
	+LegendXPos=0.20
	+LegendYPos=0.70
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x01-y04
	+Title=Transverse thrust for $320 < p_\text{T,1} < 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\tau_{{\perp^}})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\tau_{_{\perp^}})$
	+LogY=0
	+LegendXPos=0.20
	+LegendYPos=0.70
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x01-y05
	+Title=Transverse thrust for $p_\text{T,1} > 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\tau_{{\perp^}})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\tau_{_{\perp^}})$
	+LogY=0
	+LegendXPos=0.20
	+LegendYPos=0.70
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x02-y01
	+Title=Jet broadening for $110 < p_\text{T,1} < 170 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(B_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(B_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x02-y02
	+Title=Jet broadening for $170 < p_\text{T,1} < 250 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(B_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(B_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x02-y03
	+Title=Jet broadening for $250 < p_\text{T,1} < 320 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(B_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(B_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x02-y04
	+Title=Jet broadening for $320 < p_\text{T,1} < 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(B_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(B_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x02-y05
	+Title=Jet broadening for $p_\text{T,1} > 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(B_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(B_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x03-y01
	+Title=Total jet mass for $110 < p_\text{T,1} < 170 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x03-y02
	+Title=Total jet mass for $170 < p_\text{T,1} < 250 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x03-y03
	+Title=Total jet mass for $250 < p_\text{T,1} < 320 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x03-y04
	+Title=Total jet mass for $320 < p_\text{T,1} < 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x03-y05
	+Title=Total jet mass for $p_\text{T,1} > 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x04-y01
	+Title=Total transverse jet mass for $110 < p_\text{T,1} < 170 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho^\text{T}_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho^\text{T}_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x04-y02
	+Title=Total transverse jet mass for $170 < p_\text{T,1} < 250 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho^\text{T}_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho^\text{T}_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x04-y03
	+Title=Total transverse jet mass for $250 < p_\text{T,1} < 320 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho^\text{T}_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho^\text{T}_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x04-y04
	+Title=Total transverse jet mass for $320 < p_\text{T,1} < 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho^\text{T}_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho^\text{T}_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x04-y05
	+Title=Total transverse jet mass for $p_\text{T,1} > 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(\rho^\text{T}_\text{tot})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(\rho^\text{T}_\text{tot})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x05-y01
	+Title=Third-jet resolution parameter for $110 < p_\text{T,1} < 170 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(Y_{ 23})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(Y_{ 23})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x05-y02
	+Title=Third-jet resolution parameter for $170 < p_\text{T,1} < 250 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(Y_{ 23})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(Y_{ 23})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x05-y03
	+Title=Third-jet resolution parameter for $250 < p_\text{T,1} < 320 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(Y_{ 23})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(Y_{ 23})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x05-y04
	+Title=Third-jet resolution parameter for $320 < p_\text{T,1} < 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(Y_{ 23})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(Y_{ 23})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2014_I1305624/d01-x05-y05
	+Title=Third-jet resolution parameter for $p_\text{T,1} > 390 \,\, \text{and} \mid\eta\mid < 2.4$
	+XLabel=$\ln(Y_{ 23})$
	+YLabel=$1/N \,\, \text{d}N/\text{d}\,\ln(Y_{ 23})$
	+LogY=0
	+LegendXPos=0.4
	+LegendYPos=0.30
	+# END PLOT
	diff --git a/data/plotinfo/CMS_2015_I1356998.plot b/data/plotinfo/CMS_2015_I1356998.plot
	--- a/data/plotinfo/CMS_2015_I1356998.plot
	+++ b/data/plotinfo/CMS_2015_I1356998.plot
	@@ -1,41 +1,41 @@
	# BEGIN PLOT /CMS_2015_I1356998/d01-x01-y01
	-Title=Cross section for $log_{10}M_{Y} < 0.5$ (SD dominated)
	-XLabel=$log_{10}\xi_{X}$
	-YLabel=$\mathrm{d}\sigma / \mathrm{d}log_{10}\xi_{X}$ [mb]
	+Title=Cross section for $\log_{10}M_{Y} < 0.5$ (SD dominated)
	+XLabel=$\log_{10}\xi_{X}$
	+YLabel=$\mathrm{d}\sigma / \mathrm{d}\log_{10}\xi_{X}$ [mb]
	LegendXPos=0.1
	LogY=0
	YMax=2.0
	# END PLOT

	# BEGIN PLOT /CMS_2015_I1356998/d02-x01-y01
	-Title=Cross section for $0.5 < log_{10}M_{Y} < 1.1$ (DD dominated)
	-XLabel=$log_{10}\xi_{X}$
	-YLabel=$\mathrm{d}\sigma / \mathrm{d}log_{10}\xi_{X}$ [mb]
	+Title=Cross section for $0.5 < \log_{10}M_{Y} < 1.1$ (DD dominated)
	+XLabel=$\log_{10}\xi_{X}$
	+YLabel=$\mathrm{d}\sigma / \mathrm{d}\log_{10}\xi_{X}$ [mb]
	LogY=0
	YMax=2.0
	# END PLOT

	# BEGIN PLOT /CMS_2015_I1356998/d03-x01-y01
	-Title=$\sigma$ for central gaps, $\Delta\eta > 3$ $(log_{10}M_{X} > 1.1, log_{10}M_{Y} > 1.1)$
	+Title=$\sigma$ for central gaps, $\Delta\eta > 3$ $(\log_{10}M_{X} > 1.1, \log_{10}M_{Y} > 1.1)$
	XLabel=$\Delta\eta\equiv-ln\xi$
	YLabel=$\mathrm{d}\sigma / \mathrm{d}\Delta\eta$ [mb]
	LogY=0
	YMax=0.7
	# END PLOT

	# BEGIN PLOT /CMS_2015_I1356998/d04-x01-y01
	Title=Visible cross sections
	XCustomMajorTicks=0.5 $\sigma_\text{no-CASTOR}$ 1.5 $\sigma_\text{CASTOR}$ 2.5 $\sigma_\text{CG}$
	YLabel=$\sigma$ [mb]
	LegendYPos=0.9
	LogY=0
	# END PLOT

	# BEGIN PLOT /CMS_2015_I1356998/d05-x01-y01
	Title=Rapidity gap size in $\eta$ starting from $\eta = \pm 4.7$, $p_T > 200$ MeV
	XLabel=$\Delta\eta^\text{F}$
	YLabel=$\mathrm{d}\sigma / \mathrm{d}\Delta\eta^\text{F}$ [mb]
	LogY=1
	YMin=0.1
	YMax=200
	# END PLOT
	diff --git a/data/plotinfo/CMS_2015_I1397174.plot b/data/plotinfo/CMS_2015_I1397174.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/CMS_2015_I1397174.plot
	@@ -0,0 +1,520 @@
	+# BEGIN PLOT /CMS_2015_I1397174/*
	+LogY=1
	+LogX=0
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+LegendXPos=0.4
	+Title=\Large \textbf{CMS} \hspace{10em} \large $19.7\,\text{fb}^\text{$-$1}$ (8 TeV)
	+#RatioPlotYMin=0.5
	+#RatioPlotYMax=1.5
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d01-x01-y01
	+XLabel=$N_\mathrm{jets} \, p_T > 30\,\mathrm{GeV}$
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}N_\mathrm{jets}$ [pb]
	+LegendXPos=0.05
	+LegendYPos=0.50
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d02-x01-y01
	+XLabel=$N_\mathrm{jets} \, p_T > 30\,\mathrm{GeV}$
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}N_\mathrm{jets}$
	+LegendXPos=0.05
	+LegendYPos=0.50
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d03-x01-y01
	+XLabel=$N_\mathrm{jets} \, p_T > 60\,\mathrm{GeV}$
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}N_\mathrm{jets}$ [pb]
	+LegendXPos=0.05
	+LegendYPos=0.50
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d04-x01-y01
	+XLabel=$N_\mathrm{jets} \, p_T > 60\,\mathrm{GeV}$
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}N_\mathrm{jets}$
	+LegendXPos=0.05
	+LegendYPos=0.50
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d05-x01-y01
	+XLabel=$N_\mathrm{jets} \, p_T > 100\,\mathrm{GeV}$
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}N_\mathrm{jets}$ [pb]
	+LegendXPos=0.05
	+LegendYPos=0.50
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d06-x01-y01
	+XLabel=$N_\mathrm{jets} \, p_T > 100\,\mathrm{GeV}$
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}N_\mathrm{jets}$
	+LegendXPos=0.05
	+LegendYPos=0.50
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d07-x01-y01
	+XLabel=Leading add. jet $p_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}p_T$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d08-x01-y01
	+XLabel=Leading add. jet $p_T$ [GeV]
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}p_T$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d09-x01-y01
	+XLabel=Leading add. jet $\|\eta\|$
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}\|\eta\|$ [pb]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d10-x01-y01
	+XLabel=Leading add. jet $\|\eta\|$
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}\|\eta\|$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d11-x01-y01
	+XLabel=Subleading add. jet $p_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}p_T$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d12-x01-y01
	+XLabel=Subleading add. jet $p_T$ [GeV]
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}p_T$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d13-x01-y01
	+XLabel=Subleading add. jet $\|\eta\|$
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}\|\eta\|$ [pb]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d14-x01-y01
	+XLabel=Subleading add. jet $\|\eta\|$
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}\|\eta\|$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d15-x01-y01
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}m_{jj}$ [GeV$^{-1}$]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d16-x01-y01
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}m_{jj}$ [GeV$^{-1}$]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d17-x01-y01
	+XLabel=$\Delta R_{jj}$
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}\Delta R_{jj}$ [pb]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d18-x01-y01
	+XLabel=$\Delta R_{jj}$
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}\Delta R_{jj}$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d19-x01-y01
	+XLabel=$H_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}H_T$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d20-x01-y01
	+XLabel=$H_T$ [GeV]
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}H_T$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d21-x01-y01
	+XLabel=Leading add. jet $p_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}p_T$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d22-x01-y01
	+XLabel=Leading add. jet $p_T$ [GeV]
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}p_T$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d23-x01-y01
	+XLabel=Leading add. jet $\|\eta\|$
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}\|\eta\|$ [pb]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d24-x01-y01
	+XLabel=Leading add. jet $\|\eta\|$
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}\|\eta\|$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d25-x01-y01
	+XLabel=Subleading add. jet $p_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}p_T$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d26-x01-y01
	+XLabel=Subleading add. jet $p_T$ [GeV]
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}p_T$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d27-x01-y01
	+XLabel=Subleading add. jet $\|\eta\|$
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}\|\eta\|$ [pb]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d28-x01-y01
	+XLabel=Subleading add. jet $\|\eta\|$
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}\|\eta\|$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d29-x01-y01
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}m_{jj}$ [pb/GeV]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d30-x01-y01
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}m_{jj}$ [GeV$^{-1}$]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d31-x01-y01
	+XLabel=$\Delta R_{jj}$
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}\Delta R_{jj}$ [pb]
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d32-x01-y01
	+XLabel=$\Delta R_{jj}$
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}\Delta R_{jj}$
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d33-x01-y01
	+XLabel=$H_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}H_T$ [pb/GeV]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d34-x01-y01
	+XLabel=$H_T$ [GeV]
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}H_T$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d35-x01-y01
	+XLabel=Leading add. $b$-jet $p_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}p_T$ [pb/GeV]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d36-x01-y01
	+XLabel=Leading add. $b$-jet $p_T$ [GeV]
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}p_T$ [GeV$^{-1}$]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d37-x01-y01
	+XLabel=Leading add. $b$-jet $\|\eta\|$
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}\|\eta\|$ [pb]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d38-x01-y01
	+XLabel=Leading add. $b$-jet $\|\eta\|$
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}\|\eta\|$
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d39-x01-y01
	+XLabel=Subleading add. $b$-jet $p_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}p_T$ [pb/GeV]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d40-x01-y01
	+XLabel=Subleading add. $b$-jet $p_T$ [GeV]
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}p_T$ [GeV$^{-1}$]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d41-x01-y01
	+XLabel=Subleading add. $b$-jet $\|\eta\|$
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}\|\eta\|$ [pb]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d42-x01-y01
	+XLabel=Subleading add. $b$-jet $\|\eta\|$
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}\|\eta\|$
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d43-x01-y01
	+XLabel=$m_{bb}$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}m_{bb}$ [pb/GeV]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d44-x01-y01
	+XLabel=$m_{bb}$ [GeV]
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}m_{bb}$ [GeV$^{-1}$]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d45-x01-y01
	+XLabel=$\Delta R_{bb}$
	+YLabel=$\mathrm{d}\sigma^\text{vis}/\mathrm{d}\Delta R_{bb}$ [pb]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d46-x01-y01
	+XLabel=$\Delta R_{bb}$
	+YLabel=$1/\sigma^\text{vis} \, \mathrm{d}\sigma^\text{vis}/\mathrm{d}\Delta R_{bb}$
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d47-x01-y01
	+XLabel=Leading add. $b$-jet $p_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}p_T$ [pb/GeV]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d48-x01-y01
	+XLabel=Leading add. $b$-jet $p_T$ [GeV]
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}p_T$ [GeV$^{-1}$]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d49-x01-y01
	+XLabel=Leading add. $b$-jet $\|\eta\|$
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}\|\eta\|$ [pb]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d50-x01-y01
	+XLabel=Leading add. $b$-jet $\|\eta\|$
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}\|\eta\|$
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d51-x01-y01
	+XLabel=Subleading add. $b$-jet $p_T$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}p_T$ [pb/GeV]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d52-x01-y01
	+XLabel=Subleading add. $b$-jet $p_T$ [GeV]
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}p_T$ [GeV$^{-1}$]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d53-x01-y01
	+XLabel=Subleading add. $b$-jet $\|\eta\|$
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}\|\eta\|$ [pb]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d54-x01-y01
	+XLabel=Subleading add. $b$-jet $\|\eta\|$
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}\|\eta\|$
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d55-x01-y01
	+XLabel=$m_{bb}$ [GeV]
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}m_{bb}$ [pb/GeV]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=4
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d56-x01-y01
	+XLabel=$m_{bb}$ [GeV]
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}m_{bb}$ [GeV$^{-1}$]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=4
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d57-x01-y01
	+XLabel=$\Delta R_{bb}$
	+YLabel=$\mathrm{d}\sigma^\text{full}/\mathrm{d}\Delta R_{bb}$ [pb]
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d58-x01-y01
	+XLabel=$\Delta R_{bb}$
	+YLabel=$1/\sigma^\text{full} \, \mathrm{d}\sigma^\text{full}/\mathrm{d}\Delta R_{bb}$
	+#RatioPlotYMin=0
	+#RatioPlotYMax=3
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d59-x01-y01
	+XLabel=Leading add. jet $p_T$ [GeV]
	+YLabel=Gap fraction
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d60-x01-y01
	+XLabel=Leading add. jet $p_T$ [GeV]
	+YLabel=Gap fraction ($\|\eta\| < 0.8$)
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d61-x01-y01
	+XLabel=Leading add. jet $p_T$ [GeV]
	+YLabel=Gap fraction ($0.8 < \|\eta\| < 1.5$)
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d62-x01-y01
	+XLabel=Leading add. jet $p_T$ [GeV]
	+YLabel=Gap fraction ($1.5 < \|\eta\| < 2.4$)
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d63-x01-y01
	+XLabel=Subleading add. jet $p_T$ [GeV]
	+YLabel=Gap fraction
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d64-x01-y01
	+XLabel=Subleading add. jet $p_T$ [GeV]
	+YLabel=Gap fraction ($\|\eta\| < 0.8$)
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d65-x01-y01
	+XLabel=Subleading add. jet $p_T$ [GeV]
	+YLabel=Gap fraction ($0.8 < \|\eta\| < 1.5$)
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d66-x01-y01
	+XLabel=Subleading add. jet $p_T$ [GeV]
	+YLabel=Gap fraction ($1.5 < \|\eta\| < 2.4$)
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d67-x01-y01
	+XLabel=$H_T$ [GeV]
	+YLabel=Gap fraction
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d68-x01-y01
	+XLabel=$H_T$ [GeV]
	+YLabel=Gap fraction ($\|\eta\| < 0.8$)
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d69-x01-y01
	+XLabel=$H_T$ [GeV]
	+YLabel=Gap fraction ($0.8 < \|\eta\| < 1.5$)
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2015_I1397174/d70-x01-y01
	+XLabel=$H_T$ [GeV]
	+YLabel=Gap fraction ($1.5 < \|\eta\| < 2.4$)
	+LegendYPos=0.7
	+LogY=0
	+#NormalizeToIntegral=0
	+#RatioPlotYMin=0.875
	+#RatioPlotYMax=1.125
	+#YMin=0.25
	+# END PLOT
	diff --git a/data/plotinfo/CMS_2016_I1459051.plot b/data/plotinfo/CMS_2016_I1459051.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/CMS_2016_I1459051.plot
	@@ -0,0 +1,155 @@
	+# BEGIN PLOT /CMS_2016_I1459051/d01-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK7 jets, $0.0 < \|y\| < 0.5$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d02-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK7 jets, $0.5 < \|y\| < 1.0$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d03-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK7 jets, $1.0 < \|y\| < 1.5$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d04-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK7 jets, $1.5 < \|y\| < 2.0$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d05-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK7 jets, $2.0 < \|y\| < 2.5$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d06-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK7 jets, $2.5 < \|y\| < 3.0$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d07-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK7 jets, $3.2 < \|y\| < 4.7$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d08-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK4 jets, $0.0 < \|y\| < 0.5$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d09-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK4 jets, $0.5 < \|y\| < 1.0$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d10-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK4 jets, $1.0 < \|y\| < 1.5$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d11-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK4 jets, $1.5 < \|y\| < 2.0$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d12-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK4 jets, $2.0 < \|y\| < 2.5$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d13-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK4 jets, $2.5 < \|y\| < 3.0$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+# BEGIN PLOT /CMS_2016_I1459051/d14-x01-y01
	+Title=CMS, $\sqrt(s)$ = 13 TeV, Inclusive AK4 jets, $3.2 < \|y\| < 4.7$
	+XLabel=$p_{T}$ [GeV]
	+YLabel=d$^2\sigma$/d$p_{T}$d$y$ [pb/GeV]
	+FullRange=1
	+LogY=1
	+LogX=1
	+LegendYPos=0.9
	+RatioPlotYMax=2
	+RatioPlotYMin=0.1
	+# END PLOT
	+
	diff --git a/data/plotinfo/CMS_2016_I1473674.plot b/data/plotinfo/CMS_2016_I1473674.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/CMS_2016_I1473674.plot
	@@ -0,0 +1,29 @@
	+# BEGIN PLOT /CMS_2016_I1473674/*
	+LogY=0
	+LogX=0
	+XTwosidedTicks=1
	+YTwosidedTicks=1
	+#NormalizeToIntegral=1
	+LegendXPos=0.4
	+Title=\Large \textbf{CMS} \hspace{10em} \large $19.7\,\text{fb}^\text{$-$1}$ (8 TeV)
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2016_I1473674/d05-x01-y01
	+XLabel=MET [GeV]
	+YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}MET$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2016_I1473674/d06-x01-y01
	+XLabel=HT [GeV]
	+YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}HT$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2016_I1473674/d07-x01-y01
	+XLabel=ST [GeV]
	+YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}ST$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /CMS_2016_I1473674/d08-x01-y01
	+XLabel=$p_T^W$ [GeV]
	+YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}p_T^W$ [GeV$^{-1}$]
	+# END PLOT
	diff --git a/data/plotinfo/D0_1995_I398175.plot b/data/plotinfo/D0_1995_I398175.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/D0_1995_I398175.plot
	@@ -0,0 +1,32 @@
	+# BEGIN PLOT /D0_1995_I398175/d..-x..-y01
	+XLabel=$r$
	+YLabel=$\rho(r)$
	+# END PLOT
	+
	+# BEGIN PLOT /D0_1995_I398175/d01-x01-y01
	+Title=Jet shape $\rho$ for $p_\perp \in 45$--70\,GeV, $\eta \in 0.0$--0.2
	+# END PLOT
	+
	+# BEGIN PLOT /D0_1995_I398175/d02-x01-y01
	+Title=Jet shape $\rho$ for $p_\perp \in 70$--105\,GeV, $\eta \in 0.0$--0.2
	+# END PLOT
	+
	+# BEGIN PLOT /D0_1995_I398175/d03-x01-y01
	+Title=Jet shape $\rho$ for $p_\perp \in 105$--140\,GeV, $\eta \in 0.0$--0.2
	+# END PLOT
	+
	+# BEGIN PLOT /D0_1995_I398175/d04-x01-y01
	+Title=Jet shape $\rho$ for $p_\perp > 140\,GeV, $\eta \in 0.0$--0.2
	+# END PLOT
	+
	+# BEGIN PLOT /D0_1995_I398175/d05-x01-y01
	+Title= Jet shape $\rho$ for $p_\perp \in 45$--70\,GeV, $\eta \in 2.5$--3.5
	+# END PLOT
	+
	+# BEGIN PLOT /D0_1995_I398175/d06-x01-y01
	+Title= Jet shape $\rho$ for $p_\perp \in 70$--105\,GeV, $\eta \in 2.5$--3.5
	+# END PLOT
	+
	+
	+
	+
	diff --git a/data/plotinfo/DELPHI_2011_I890503.plot b/data/plotinfo/DELPHI_2011_I890503.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/DELPHI_2011_I890503.plot
	@@ -0,0 +1,13 @@
	+# BEGIN PLOT /DELPHI_2011_I890503/d01-x01-y01
	+Title=$b$ quark fragmentation function $f(x_B^\text{weak})$
	+XLabel=$x_B$
	+YLabel=$1/N \, \text{d}{N}/\text{d}x_B$
	+LegendXPos=0.10
	+# END PLOT
	+# BEGIN PLOT /DELPHI_2011_I890503/d02-x01-y01
	+Title=Mean of $b$ quark fragmentation function $f(x_B^\text{weak})$
	+XLabel=
	+YLabel=$\langle x_B \rangle$
	+ShowZero=0
	+# END PLOT
	+
	diff --git a/data/plotinfo/L3_1992_I336180.plot b/data/plotinfo/L3_1992_I336180.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/L3_1992_I336180.plot
	@@ -0,0 +1,13 @@
	+# BEGIN PLOT /L3_1992_I336180/d01-x01-y01
	+Title=The $x_p$ spectrum for inclusive $\eta$ production at the $Z^0$ resonance
	+XLabel=$x_p=p/p_{\text{beam}}$
	+YLabel=$1/\sigma_h \, \text{d}\sigma/\text{d}x_p$ [$\text{GeV}^-1$]
	+# END PLOT
	+
	+# BEGIN PLOT /L3_1992_I336180/d02-x01-y01
	+Title=The $\xi_p$ spectrum for inclusive $\eta$ production at the $Z^0$ resonance
	+XLabel=$\xi_p=ln(1/x_p)$
	+YLabel=$1/\sigma_h \, \text{d}\sigma/\text{d}\xi_p$ [$\text{GeV}^-1$]
	+# END PLOT
	+
	+
	diff --git a/data/plotinfo/L3_2004_I652683.plot b/data/plotinfo/L3_2004_I652683.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/L3_2004_I652683.plot
	@@ -0,0 +1,127 @@
	+# BEGIN PLOT /L3_2004_I652683/d47-x01-y01
	+Title=Thrust, udsc events
	+XLabel=$T$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}T$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d47-x01-y02
	+Title=Thrust, b events
	+XLabel=$T$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}T$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d48-x01-y01
	+Title=Heavy jet mass, udsc events
	+XLabel=$\rho_H$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}\rho_H$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d48-x01-y02
	+Title=Heavy jet mass, b events
	+XLabel=$\rho_H$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}\rho_H$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d49-x01-y01
	+Title=Total jet broadening, udsc events
	+XLabel=$B_T$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}B_T$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d49-x01-y02
	+Title=Total jet broadening, b events
	+XLabel=$B_T$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}B_T$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d50-x01-y01
	+Title=Wide jet broadening, udsc events
	+XLabel=$B_W$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}B_W$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d50-x01-y02
	+Title=Wide jet broadening, b events
	+XLabel=$B_W$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}B_W$
	+LogY=1
	+# END PLOT
	+
	+
	+# BEGIN PLOT /L3_2004_I652683/d51-x01-y01
	+Title=C-parameter, udsc events
	+XLabel=$C$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}C$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d51-x01-y02
	+Title=C-parameter, b events
	+XLabel=$C$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}C$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d52-x01-y01
	+Title=D-parameter, udsc events
	+XLabel=$D$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}D$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d52-x01-y02
	+Title=D-parameter, b events
	+XLabel=$D$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}D$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d59-x01-y01
	+Title=Charged multiplicity
	+XLabel=$N_ch$
	+YLabel=$P(N_ch)$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d59-x01-y02
	+Title=Charged multiplicity, udsc events
	+XLabel=$N_ch$
	+YLabel=$P(N_ch)$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d59-x01-y03
	+Title=Charged multiplicity, b events
	+XLabel=$N_ch$
	+YLabel=$P(N_ch)$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d65-x01-y01
	+Title=Log of scaled momentum distribution (charged)
	+XLabel=$\xi_p$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}\xi_p$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d65-x01-y02
	+Title=Log of scaled momentum distribution (charged), udsc events
	+XLabel=$\xi_p$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}\xi_p$
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /L3_2004_I652683/d65-x01-y03
	+Title=Log of scaled momentum distribution (charged), b events
	+XLabel=$\xi_p$
	+YLabel=$1/\sigma \mathrm{d}\sigma/\mathrm{d}\xi_p$
	+LogY=1
	+# END PLOT
	+
	diff --git a/data/plotinfo/LHCB_2014_I1262703.plot b/data/plotinfo/LHCB_2014_I1262703.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/LHCB_2014_I1262703.plot
	@@ -0,0 +1,100 @@
	+# BEGIN PLOT /LHCB_2014_I1262703/d03-x01-y01
	+Title=$1/\sigma d\sigma/dp_{T}^{jet}$, $p_{T}^{jet}>$10 GeV
	+XLabel=$p_{T}^{jet}$ [GeV]
	+YLabel=$1/\sigma d\sigma/dp_{T}^{jet}$ [1/GeV]
	+LegendXPos=0.6
	+LegendYPos=0.9
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d04-x01-y01
	+Title=1/\sigma d\sigma/d\eta^{jet}$, $p_{T}^{jet}>$20 GeV
	+XLabel=$\eta^{jet}$
	+YLabel=$1/\sigma d\sigma/d\eta^{jet}$
	+LegendXPos=0.6
	+LegendYPos=0.9
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d04-x01-y02
	+Title=1/\sigma d\sigma/d\eta^{jet}$, $p_{T}^{jet}>$10 GeV
	+XLabel=$\eta^{jet}$
	+YLabel=$1/\sigma d\sigma/d\eta^{jet}$
	+LegendXPos=0.6
	+LegendYPos=0.9
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d05-x01-y01
	+Title=1/\sigma d\sigma/dy^{Z}$, $p_{T}^{jet}>$20 GeV
	+XLabel=$y^{Z}$
	+YLabel=$1/\sigma d\sigma/dy^{Z}$
	+LegendXPos=0.6
	+LegendYPos=0.9
	+LogY=0
	+YMin=-0.1
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d05-x01-y02
	+Title=1/\sigma d\sigma/dy^{Z}$, $p_{T}^{jet}>$10 GeV
	+XLabel=$y^{Z}$
	+YLabel=$1/\sigma d\sigma/dy^{Z}$
	+LegendXPos=0.6
	+LegendYPos=0.9
	+LogY=0
	+YMin=-0.1
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d06-x01-y01
	+Title=1/\sigma d\sigma/dp_{T}^{Z}$, $p_{T}^{jet}>$20 GeV
	+XLabel=$p_{T}^{Z}$ [GeV]
	+YLabel=$1/\sigma d\sigma/dp_{T}^{Z}$ [1/GeV]
	+LegendXPos=0.6
	+LegendYPos=0.9
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d06-x01-y02
	+Title=1/\sigma d\sigma/dp_{T}^{Z}$, $p_{T}^{jet}>$10 GeV
	+XLabel=$p_{T}^{Z}$ [GeV]
	+YLabel=$1/\sigma d\sigma/dp_{T}^{Z}$ [1/GeV]
	+LegendXPos=0.6
	+LegendYPos=0.9
	+LogY=1
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d07-x01-y01
	+Title=1/\sigma d\sigma/d\Delta\phi$, $p_{T}^{jet}>$20 GeV
	+XLabel=$\Delta\phi$
	+YLabel=$1/\sigma d\sigma/d\Delta\phi $
	+LegendXPos=0.1
	+LegendYPos=0.9
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d07-x01-y02
	+Title=1/\sigma d\sigma/d\Delta\phi$, $p_{T}^{jet}>$10 GeV
	+XLabel=$\Delta\phi$
	+YLabel=$1/\sigma d\sigma/d\Delta\phi $
	+LegendXPos=0.1
	+LegendYPos=0.9
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d08-x01-y01
	+Title=1/\sigma d\sigma/d\Delta y$, $p_{T}^{jet}>$20 GeV
	+XLabel=$\Delta y$
	+YLabel=$1/\sigma d\sigma/d\Delta y$
	+LegendXPos=0.1
	+LegendYPos=0.9
	+LogY=0
	+# END PLOT
	+
	+# BEGIN PLOT /LHCB_2014_I1262703/d08-x01-y02
	+Title=1/\sigma d\sigma/d\Delta y$, $p_{T}^{jet}>$10 GeV
	+XLabel=$\Delta y$
	+YLabel=$1/\sigma d\sigma/d\Delta y$
	+LegendXPos=0.1
	+LegendYPos=0.9
	+LogY=0
	+# END PLOT
	diff --git a/data/plotinfo/MC_CENTRALITY.plot b/data/plotinfo/MC_CENTRALITY.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/MC_CENTRALITY.plot
	@@ -0,0 +1,72 @@
	+# BEGIN PLOT /MC_CENTRALITY/ETfwd
	+Title=Sum $E_T$ distribution
	+XLabel=$\sum E_T$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\sum E_T$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaAll
	+Title=Charged pseudo-rapidity distribution
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC95
	+Title=Charged pseudo-rapidity distribution centrality 95-100\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC90
	+Title=Charged pseudo-rapidity distribution centrality 90-95\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC80
	+Title=Charged pseudo-rapidity distribution centrality 80-90\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC60
	+Title=Charged pseudo-rapidity distribution centrality 60-80\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC00
	+Title=Charged pseudo-rapidity distribution centrality 0-60\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC95
	+Title=Charged pseudo-rapidity distribution centrality 95-100\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC90
	+Title=Charged pseudo-rapidity distribution centrality 90-95\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC80
	+Title=Charged pseudo-rapidity distribution centrality 80-90\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC60
	+Title=Charged pseudo-rapidity distribution centrality 60-80\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	+# BEGIN PLOT /MC_CENTRALITY/EtaC00
	+Title=Charged pseudo-rapidity distribution centrality 0-60\%
	+XLabel=$\eta$
	+YLabel=$1/\sigma \; \mathrm{d}\sigma/\mathrm{d}\eta$
	+# END PLOT
	+
	diff --git a/data/plotinfo/MC_DIJET.plot b/data/plotinfo/MC_DIJET.plot
	deleted file mode 100644
	--- a/data/plotinfo/MC_DIJET.plot
	+++ /dev/null
	@@ -1,83 +0,0 @@
	-# BEGIN PLOT /MC_DIJET/d01-x01-y01
	-Title=Jetcounts
	-XLabel=Number of jets
	-YLabel=
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d02-x01-y01
	-Title=Pt distributions of dijet events
	-XLabel=$P_{t}$
	-YLabel=$\\frac{d \\sigma}{d P_{t}}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d03-x01-y01
	-Title=$\\log{P_{t}}$ distributions of dijet events
	-XLabel=$\\log{P_{t}}$
	-YLabel=$\\frac{d \\sigma}{d P_{t}}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d04-x01-y01
	-Title=Pt distributions of leading jets in dijet events
	-XLabel=$P_{t}$
	-YLabel=$\\frac{d \\sigma}{d P_{t}}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d05-x01-y01
	-Title=Pt distributions of 2nd leading jets in dijet events
	-XLabel=$P_{t}$
	-YLabel=$\\frac{d \\sigma}{d P_{t}}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d06-x01-y01
	-Title=Phi distributions of dijet events
	-XLabel=$\\phi$
	-YLabel=$\\frac{d \\sigma}{d \\phi}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d07-x01-y01
	-Title=Pseudorapidity distributions of dijet events
	-XLabel=$\\eta$
	-YLabel=$\\frac{d \\sigma}{d P_{t}}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d08-x01-y01
	-Title=$\\Delta \\phi$ distributions of dijet events
	-XLabel=$\\phi$
	-YLabel=$\\frac{d \\sigma}{d \\phi}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d09-x01-y01
	-Title=$\\Delta \\eta$ distributions of dijet events
	-XLabel=$\\eta$
	-YLabel=$\\frac{d \\sigma}{d \\eta}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d10-x01-y01
	-Title=Multiplicity of charged particles
	-XLabel=$n_{ch}$
	-YLabel=$\\frac{d \\sigma}{d n_{ch}}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d11-x01-y01
	-Title=Mean $p_{T}$ of charged particles
	-XLabel=$p_{T}^{\\mathrm{mean}}$
	-YLabel=$\\frac{d \\sigma}{d p}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d12-x01-y01
	-Title=$p_{T}$ of charged particles
	-XLabel=$p_{T}$
	-YLabel=$\\frac{d \\sigma}{d p}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d13-x01-y01
	-Title=$\\log{p_{T}}$ of charged particles
	-XLabel=$p_{T}$
	-YLabel=$\\frac{d \\sigma}{d p}$
	-# END PLOT
	-
	-# BEGIN PLOT /MC_DIJET/d14-x01-y01
	-Title=RMS $p_{T}$ of charged particles
	-XLabel=$p_{T}^{\\mathrm{RMS}}$
	-YLabel=$\\frac{d \\sigma}{d p}$
	-# END PLOT
	\ No newline at end of file
	diff --git a/data/plotinfo/MC_HHJETS.plot b/data/plotinfo/MC_HHJETS.plot
	--- a/data/plotinfo/MC_HHJETS.plot
	+++ b/data/plotinfo/MC_HHJETS.plot
	@@ -1,522 +1,529 @@
	# BEGIN PLOT /MC_HHJETS/H_jet1_dR
	Title=Separation between Higgs boson and leading jet
	XLabel=$\Delta{R}(H, \text{1st jet}})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta{R}(H, \text{1st jet})$ [pb]
	RatioPlotYMin=0.1
	RatioPlotYMax=1.8
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/HH_dR
	Title=Separation between Higgs bosons
	XLabel=$\Delta{R}(H, H)$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta{R}(H, H)$ [pb]
	#Rebin=2
	RatioPlotYMin=0.1
	RatioPlotYMax=2.0
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/HH_dPhi
	Title=Separation between Higgs bosons in $\phi$
	XLabel=$\Delta\phi(H, H)$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta\phi(H, H)$ [pb]
	#Rebin=2
	RatioPlotYMin=0.1
	RatioPlotYMax=2.0
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/HH_deta
	Title=Separation between Higgs bosons in $\eta$
	XLabel=$\Delta\eta(H, H)$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta\eta(H, H)$ [pb]
	#Rebin=2
	RatioPlotYMin=0.1
	RatioPlotYMax=2.0
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/HH_pT$
	Title=Di-Higgs $p_\perp$
	XLabel=$p_\perp^{HH}$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}p_\perp^{HH}$ [pb/\GeV]
	LogX=0
	#Rebin=4
	#XMax=900
	RatioPlotYMin=0.1
	RatioPlotYMax=1.8
	# END PLOT


	# BEGIN PLOT /MC_HHJETS/H_jet1_deta
	Title=Separation in $\eta$ between Higgs boson and leading jet
	XLabel=$\Delta{\eta}(H, \text{1st jet})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta{\eta}(H, \text{1st jet})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/HH_mass
	Title=di-Higgs mass
	XLabel=$m_{HH}$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}m_{HH}$ [pb/\GeV]
	#Rebin=2
	#XMax=2E+03
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/H_pT$
	Title=Higgs boson $p_\perp$ (any Higgs)
	XLabel=$p_\perp^H$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}p_\perp^H$ [pb/\GeV]
	LogX=0
	#Rebin=4
	#XMax=900
	LegendXPos=0.15
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/H_pT1$
	Title=Higgs boson $p_\perp$ (hardest Higgs)
	XLabel=$p_\perp^H$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}p_\perp^H$ [pb/\GeV]
	LogX=0
	#Rebin=4
	#XMax=900
	LegendXPos=0.15
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/H_pT2$
	Title=Higgs boson $p_\perp$ (second hardest Higgs)
	XLabel=$p_\perp^H$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}p_\perp^H$ [pb/\GeV]
	LogX=0
	#Rebin=4
	#XMax=900
	LegendXPos=0.15
	LegendYPos=0.5
	# END PLOT


	# BEGIN PLOT /MC_HHJETS/H_eta
	Title=Higgs boson pseudorapidity
	XLabel=$\eta_H$
	YLabel=$\mathrm{d}\sigma/\mathrm{d} \eta_H$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/H_eta1
	Title=Higgs boson pseudorapidity (hardest)
	XLabel=$\eta_H$
	YLabel=$\mathrm{d}\sigma/\mathrm{d} \eta_H$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/H_eta2
	Title=Higgs boson pseudorapidity (second hardest)
	XLabel=$\eta_H$
	YLabel=$\mathrm{d}\sigma/\mathrm{d} \eta_H$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/H_phi
	Title=Higgs boson azimuthal angle
	XLabel=$\phi_H$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\phi_H$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/lepton_pT
	Title=Lepton $p_\perp$
	XLabel=$p_\perp^\ell$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}p_\perp^\ell$ [pb/\GeV]
	LogX=1
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/lepton_eta
	Title=Lepton $\eta$
	XLabel=$\eta_\ell$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\eta_\ell$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1}, \text{jet 2})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta{R}(\text{jet 1}, \text{jet 2})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1}, \text{jet 3})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta{R}(\text{jet 1}, \text{jet 3})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2}, \text{jet 3})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta{R}(\text{jet 2}, \text{jet 3})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1}, \text{jet 2})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta\eta(\text{jet 1}, \text{jet 2})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1}, \text{jet 3})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta\eta(\text{jet 1}, \text{jet 3})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2}, \text{jet 3})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta\eta(\text{jet 2}, \text{jet 3})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1}, \text{jet 2})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta\phi(\text{jet 1}, \text{jet 2})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1}, \text{jet 3})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta\phi(\text{jet 1}, \text{jet 3})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2}, \text{jet 3})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\Delta\phi(\text{jet 2}, \text{jet 3})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}y(\text{jet 1})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}y(\text{jet 2})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}y(\text{jet 3})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}y(\text{jet 4})$ [pb]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}m(\text{jet 1})$ [pb/\GeV]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}m(\text{jet 2})$ [pb/\GeV]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}m(\text{jet 3})$ [pb/\GeV]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}m(\text{jet 4})$ [pb/\GeV]
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/log10_R_0
	Title=$\log_{10}$(Integrated $0$ jet rate in $k_\perp$ [\GeV])
	XLabel=$\log_{10}(d_{\text{cut}}/\GeV)$
	YLabel=$R_{0}$
	#Rebin=2
	LegendYPos=0.8
	LegendXPos=0.75
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/log10_R_1
	Title=$\log_{10}$(Integrated $1$ jet rate in $k_\perp$ [\GeV])
	XLabel=$\log_{10}(d_{\text{cut}}/\GeV)$
	YLabel=$R_{1}$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/log10_R_2
	Title=$\log_{10}$(Integrated $2$ jet rate in $k_\perp$ [\GeV])
	XLabel=$\log_{10}(d_{\text{cut}}/\GeV)$
	YLabel=$R_{2}$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/log10_R_3
	Title=$\log_{10}$(Integrated $3$ jet rate in $k_\perp$ [\GeV])
	XLabel=$\log_{10}(d_{\text{cut}}/\GeV)$
	YLabel=$R_{3}$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/log10_R_4
	Title=$\log_{10}$(Integrated $4$ jet rate in $k_\perp$ [\GeV])
	XLabel=$\log_{10}(d_{\text{cut}}/\GeV)$
	YLabel=$R_{\geq4}$
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/log10_d_01
	Title=$\log_{10}$($k_\perp$ jet resolution $0 \to 1$ [\GeV])
	XLabel=$\log_{10}(d_{01}/\GeV)$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\log_{10}(d_{01}/\GeV)$ [pb]
	LegendXPos=0.15
	LegendYPos=0.5
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/log10_d_12
	Title=$\log_{10}$($k_\perp$ jet resolution $1 \to 2$ [\GeV])
	XLabel=$\log_{10}(d_{12}/\GeV)$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\log_{10}(d_{12}/\GeV)$ [pb]
	LegendXPos=0.15
	LegendYPos=0.5
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/log10_d_23
	Title=$\log_{10}$($k_\perp$ jet resolution $2 \to 3$ [\GeV])
	XLabel=$\log_{10}(d_{23}/\GeV)$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\log_{10}(d_{23}/\GeV)$ [pb]
	LegendXPos=0.15
	LegendYPos=0.5
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/log10_d_34
	Title=$\log_{10}$($k_\perp$ jet resolution $3 \to 4$ [\GeV])
	XLabel=$\log_{10}(d_{34}/\GeV)$
	YLabel=$\mathrm{d}\sigma/\mathrm{d}\log_{10}(d_{34}/\GeV)$ [pb]
	LegendXPos=0.15
	LegendYPos=0.5
	#Rebin=2
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}p_\perp(\text{jet 1})$ [pb/\GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	#XMin=20
	#XMax=1500.0
	RatioPlotYMin=0.1
	RatioPlotYMax=1.6
	#Rebin=8
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}p_\perp(\text{jet 2})$ [pb/\GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	#XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}p_\perp(\text{jet 3})$ [pb/\GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	#XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}p_\perp(\text{jet 4})$ [pb/\GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	#XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_HHJETS/jet_HT
	Title=Scalar sum of jet transverse momenta ($H_T$)
	XLabel=$H_T$ [\GeV]
	YLabel=$\mathrm{d}\sigma/\mathrm{d}H_T$ [pb/\GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_HHJETS/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_HJETS.plot b/data/plotinfo/MC_HJETS.plot
	--- a/data/plotinfo/MC_HJETS.plot
	+++ b/data/plotinfo/MC_HJETS.plot
	@@ -1,276 +1,283 @@
	# BEGIN PLOT /MC_HJETS/H_jet1_dR
	Title=Separation between Higgs boson and leading jet
	XLabel=$\Delta R(\text{h, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{h, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/H_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{h, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{h, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_HJETS/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_HJETS/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_JETS.plot b/data/plotinfo/MC_JETS.plot
	--- a/data/plotinfo/MC_JETS.plot
	+++ b/data/plotinfo/MC_JETS.plot
	@@ -1,272 +1,279 @@
	# BEGIN PLOT /MC_JETS/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_dphi_
	Title=Azimuthal separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\|\eta(\text{jet 1}\|$
	YLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\|\eta(\text{jet 2}\|$
	YLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\|\eta(\text{jet 3}\|$
	YLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\|\eta(\text{jet 4}\|$
	YLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.3
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.3
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.3
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.3
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$\|y(\text{jet 1}\|$
	YLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$\|y(\text{jet 2}\|$
	YLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$\|y(\text{jet 3}\|$
	YLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$\|y(\text{jet 4}\|$
	YLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	#LegendXPos=0.05
	#LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	#LegendXPos=0.05
	#LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	#LegendXPos=0.05
	#LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	#LegendXPos=0.05
	#LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_JETS/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_JETS/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_MET.plot b/data/plotinfo/MC_MET.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/MC_MET.plot
	@@ -0,0 +1,11 @@
	+# BEGIN PLOT /MC_MET/met_(.*)
	+Title=Vector missing $E_T$ in \1 acceptance
	+XLabel=Vector missing $E_T$ [GeV]
	+YLabel=$1/\sigma \, \mathrm{d}\sigma / \mathrm{d}\sum E_T$ [GeV$^{-1}$]
	+# END PLOT
	+
	+# BEGIN PLOT /MC_MET/set_(.*)
	+Title=Scalar $\sum E_T$ in \1 acceptance
	+XLabel=Scalar $\sum E_T$ [GeV]
	+YLabel=$1/\sigma \, \mathrm{d}\sigma / \mathrm{d}\sum E_T$ [GeV$^{-1}$]
	+# END PLOT
	diff --git a/data/plotinfo/MC_PHOTONJETS.plot b/data/plotinfo/MC_PHOTONJETS.plot
	--- a/data/plotinfo/MC_PHOTONJETS.plot
	+++ b/data/plotinfo/MC_PHOTONJETS.plot
	@@ -1,282 +1,289 @@
	# BEGIN PLOT /MC_PHOTONJETS/photon_jet1_dR
	Title=
	XLabel=$\Delta R(\gamma\text{, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\gamma\text{, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/photon_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\gamma\text{, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\gamma\text{, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/photon_jet1_dphi
	Title=
	XLabel=$\Delta{\phi}(\gamma\text{, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\phi}(\gamma\text{, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_PHOTONJETS/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_PHOTONJETS/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_TTBAR.plot b/data/plotinfo/MC_TTBAR.plot
	--- a/data/plotinfo/MC_TTBAR.plot
	+++ b/data/plotinfo/MC_TTBAR.plot
	@@ -1,89 +1,96 @@
	# BEGIN PLOT /MC_TTBAR/jet.?_[1234]_pT
	XLabel=$p_\perp$ [GeV]
	YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}p_\perp$ [GeV$^{-1}$]
	LogX=1
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/jet_1_pT
	Title=Transverse momentum distribution for jet 1
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/jet_2_pT
	Title=Transverse momentum distribution for jet 2
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/jet_3_pT
	Title=Transverse momentum distribution for jet 3
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/jet_4_pT
	Title=Transverse momentum distribution for jet 4
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/jet_HT
	Title=$H_T$ distribution for all jets
	XLabel=$H_T$ [GeV]
	YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}H_T$ [GeV$^{-1}$]
	LogX=1
	# END PLOT

	+# BEGIN PLOT /MC_TTBAR/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	+
	# BEGIN PLOT /MC_TTBAR/jetb_1_pT
	Title=Transverse momentum distribution for $b$-jet 1
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/jetb_2_pT
	Title=Transverse momentum distribution for $b$-jet 2
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/jetl_1_pT
	Title=Transverse momentum distribution for light jet 1
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/jetl_2_pT
	Title=Transverse momentum distribution for light jet 2
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/W_mass
	Title=Mass distribution for $W$ bosons
	XLabel=$m_{jj}$ [GeV]
	YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}m_{jj}$ [GeV$^{-1}$]
	LogY=0
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/t_mass
	Title=Mass distribution for reconstructed top
	XLabel=$m_{q\bar{q}b}$ [GeV]
	YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}m_{q\bar{q}b}$ [GeV$^{-1}$]
	LogY=0
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/t_mass_W_cut
	Title=Mass distribution for reconstructed top after $m_W$ cut
	XLabel=$m_{q\bar{q}b}$ [GeV]
	YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}m_{q\bar{q}b}$ [GeV$^{-1}$]
	LogY=0
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/.*_mass
	XLabel=$m$ [GeV]
	YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}m$ [GeV$^{-1}$]
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/.*_dR
	XLabel=$\Delta R$
	YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}\Delta R$
	LogY=0
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/.*_deta
	XLabel=$\Delta \eta$
	YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}\Delta \eta$
	LogY=0
	# END PLOT

	# BEGIN PLOT /MC_TTBAR/.*_dphi
	XLabel=$\Delta \phi$
	YLabel=$1/\sigma \, \mathrm{d}\sigma/\mathrm{d}\Delta \phi$
	LogY=0
	# END PLOT

	diff --git a/data/plotinfo/MC_WJETS.plot b/data/plotinfo/MC_WJETS.plot
	--- a/data/plotinfo/MC_WJETS.plot
	+++ b/data/plotinfo/MC_WJETS.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_WJETS/W_jet1_dR
	Title=Separation between W boson and leading jet
	XLabel=$\Delta R(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{W, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS/W_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{W, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_WJETS/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_WJETS_EL.plot b/data/plotinfo/MC_WJETS_EL.plot
	--- a/data/plotinfo/MC_WJETS_EL.plot
	+++ b/data/plotinfo/MC_WJETS_EL.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_WJETS_EL/W_jet1_dR
	Title=Separation between W boson and leading jet
	XLabel=$\Delta R(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{W, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/W_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{W, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_WJETS_EL/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_WJETS_EL_BARE.plot b/data/plotinfo/MC_WJETS_EL_BARE.plot
	--- a/data/plotinfo/MC_WJETS_EL_BARE.plot
	+++ b/data/plotinfo/MC_WJETS_EL_BARE.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_WJETS_EL_BARE/W_jet1_dR
	Title=Separation between W boson and leading jet
	XLabel=$\Delta R(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{W, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/W_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{W, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_EL_BARE/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_WJETS_EL_BARE/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_WJETS_MU.plot b/data/plotinfo/MC_WJETS_MU.plot
	--- a/data/plotinfo/MC_WJETS_MU.plot
	+++ b/data/plotinfo/MC_WJETS_MU.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_WJETS_MU/W_jet1_dR
	Title=Separation between W boson and leading jet
	XLabel=$\Delta R(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{W, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/W_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{W, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_WJETS_MU/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_WJETS_MU_BARE.plot b/data/plotinfo/MC_WJETS_MU_BARE.plot
	--- a/data/plotinfo/MC_WJETS_MU_BARE.plot
	+++ b/data/plotinfo/MC_WJETS_MU_BARE.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_WJETS_MU_BARE/W_jet1_dR
	Title=Separation between W boson and leading jet
	XLabel=$\Delta R(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{W, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/W_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{W, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{W, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WJETS_MU_BARE/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_WJETS_MU_BARE/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_WWJETS.plot b/data/plotinfo/MC_WWJETS.plot
	--- a/data/plotinfo/MC_WWJETS.plot
	+++ b/data/plotinfo/MC_WWJETS.plot
	@@ -1,307 +1,314 @@
	# BEGIN PLOT /MC_WWJETS/WW_jet1_dR
	Title=Separation between W boson pair and leading jet
	XLabel=$\Delta R(\text{WW, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{WW, 1st jet})$ [pb]
	LegendXPos=0.25
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/WW_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{WW, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{WW, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/We_jet1_dR
	Title=Separation between $e^+$ and leading jet
	XLabel=$\Delta R(e^+,\text{1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(e^+,\text{1st jet})$ [pb]
	LegendXPos=0.25
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_dphi_12
	Title=Azimuthal decorrelation of leading and second leading jet
	XLabel=$\Delta{\phi}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\phi}(\text{jet 1, jet 2})$ [pb]
	LegendXPos=0.10
	LogY=0
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_m_12
	Title=Invariant mass of leading and second leading jet
	XLabel=$m_{12}$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}m_{12}$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/HT
	Title=HT
	XLabel=$H_T$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}H_T$ [pb/GeV]
	LogX=1
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_WWJETS/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_WWJETS/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_ZJETS.plot b/data/plotinfo/MC_ZJETS.plot
	--- a/data/plotinfo/MC_ZJETS.plot
	+++ b/data/plotinfo/MC_ZJETS.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_ZJETS/Z_jet1_dR
	Title=Separation between Z boson and leading jet
	XLabel=$\Delta R(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{Z, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/Z_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{Z, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_ZJETS/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_ZJETS_EL.plot b/data/plotinfo/MC_ZJETS_EL.plot
	--- a/data/plotinfo/MC_ZJETS_EL.plot
	+++ b/data/plotinfo/MC_ZJETS_EL.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_ZJETS_EL/Z_jet1_dR
	Title=Separation between Z boson and leading jet
	XLabel=$\Delta R(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{Z, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/Z_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{Z, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_ZJETS_EL/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_ZJETS_EL_BARE.plot b/data/plotinfo/MC_ZJETS_EL_BARE.plot
	--- a/data/plotinfo/MC_ZJETS_EL_BARE.plot
	+++ b/data/plotinfo/MC_ZJETS_EL_BARE.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_ZJETS_EL_BARE/Z_jet1_dR
	Title=Separation between Z boson and leading jet
	XLabel=$\Delta R(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{Z, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/Z_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{Z, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_EL_BARE/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_ZJETS_EL_BARE/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_ZJETS_MU.plot b/data/plotinfo/MC_ZJETS_MU.plot
	--- a/data/plotinfo/MC_ZJETS_MU.plot
	+++ b/data/plotinfo/MC_ZJETS_MU.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_ZJETS_MU/Z_jet1_dR
	Title=Separation between Z boson and leading jet
	XLabel=$\Delta R(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{Z, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/Z_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{Z, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_ZJETS_MU/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_ZJETS_MU_BARE.plot b/data/plotinfo/MC_ZJETS_MU_BARE.plot
	--- a/data/plotinfo/MC_ZJETS_MU_BARE.plot
	+++ b/data/plotinfo/MC_ZJETS_MU_BARE.plot
	@@ -1,278 +1,285 @@
	# BEGIN PLOT /MC_ZJETS_MU_BARE/Z_jet1_dR
	Title=Separation between Z boson and leading jet
	XLabel=$\Delta R(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{Z, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/Z_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{Z, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{Z, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZJETS_MU_BARE/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_ZJETS_MU_BARE/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/MC_ZZJETS.plot b/data/plotinfo/MC_ZZJETS.plot
	--- a/data/plotinfo/MC_ZZJETS.plot
	+++ b/data/plotinfo/MC_ZZJETS.plot
	@@ -1,304 +1,311 @@
	# BEGIN PLOT /MC_ZZJETS/ZZ_jet1_dR
	Title=Separation between Z boson pair and leading jet
	XLabel=$\Delta R(\text{ZZ, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(\text{ZZ, 1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/ZZ_jet1_deta
	Title=
	XLabel=$\Delta{\eta}(\text{ZZ, 1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{\eta}(\text{ZZ, 1st jet})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/Ze_jet1_dR
	Title=Separation between $e^+$ and leading jet
	XLabel=$\Delta R(e^+,\text{1st jet})$
	YLabel=$\text{d}\sigma/\text{d}\Delta R(e^+,\text{1st jet})$ [pb]
	LegendXPos=0.35
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/HT
	Title=HT
	XLabel=$H_T$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}H_T$ [pb/GeV]
	LogX=1
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_dR_
	Title=$\Delta R$ separation between jets
	LegendXPos=0.10
	LegendYPos=0.5
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_dR_12
	XLabel=$\Delta{R}(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_dR_13
	XLabel=$\Delta{R}(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_dR_23
	XLabel=$\Delta{R}(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta{R}(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_deta_
	Title=Pseudorapidity separation between jets
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_deta_12
	XLabel=$\Delta\eta(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_deta_13
	XLabel=$\Delta\eta(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_deta_23
	XLabel=$\Delta\eta(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\eta(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_dphi_
	Title=Pseudorapidity separation between jets
	LegendXPos=0.1
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_dphi_12
	XLabel=$\Delta\phi(\text{jet 1, jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_dphi_13
	XLabel=$\Delta\phi(\text{jet 1, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 1, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jets_dphi_23
	XLabel=$\Delta\phi(\text{jet 2, jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\Delta\phi(\text{jet 2, jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_eta_1
	Title=Pseudorapidity of leading jet
	XLabel=$\eta(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 1})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_eta_2
	Title=Pseudorapidity of second jet
	XLabel=$\eta(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 2})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_eta_3
	Title=Pseudorapidity of third jet
	XLabel=$\eta(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 3})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_eta_4
	Title=Pseudorapidity of fourth jet
	XLabel=$\eta(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}\eta(\text{jet 4})$ [pb]
	LegendYPos=0.5
	LegendXPos=0.30
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_eta_pmratio_1
	Title=Pseudorapidity $+/-$ ratio of first jet
	XLabel=$\eta(\text{jet 1})_+/\eta(\text{jet 1})_-$
	YLabel=$\|\eta(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_eta_pmratio_2
	Title=Pseudorapidity $+/-$ ratio of second jet
	XLabel=$\eta(\text{jet 2})_+/\eta(\text{jet 2})_-$
	YLabel=$\|\eta(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_eta_pmratio_3
	Title=Pseudorapidity $+/-$ ratio of third jet
	XLabel=$\eta(\text{jet 3})_+/\eta(\text{jet 3})_-$
	YLabel=$\|\eta(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_eta_pmratio_4
	Title=Pseudorapidity $+/-$ ratio of fourth jet
	XLabel=$\eta(\text{jet 4})_+/\eta(\text{jet 4})_-$
	YLabel=$\|\eta(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_y_1
	Title=Rapidity of first jet
	XLabel=$y(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 1})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_y_2
	Title=Rapidity of second jet
	XLabel=$y(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 2})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_y_3
	Title=Rapidity of third jet
	XLabel=$y(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 3})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_y_4
	Title=Rapidity of fourth jet
	XLabel=$y(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}y(\text{jet 4})$ [pb]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_y_pmratio_1
	Title=Rapidity $+/-$ ratio of first jet
	XLabel=$y(\text{jet 1})_+/y(\text{jet 1})_-$
	YLabel=$\|y(\text{jet 1}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_y_pmratio_2
	Title=Rapidity $+/-$ ratio of second jet
	XLabel=$y(\text{jet 2})_+/y(\text{jet 2})_-$
	YLabel=$\|y(\text{jet 2}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_y_pmratio_3
	Title=Rapidity $+/-$ ratio of third jet
	XLabel=$y(\text{jet 3})_+/y(\text{jet 3})_-$
	YLabel=$\|y(\text{jet 3}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_y_pmratio_4
	Title=Rapidity $+/-$ ratio of fourth jet
	XLabel=$y(\text{jet 4})_+/y(\text{jet 4})_-$
	YLabel=$\|y(\text{jet 4}\|$
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_mass_1
	Title=Mass of first jet
	XLabel=$m(\text{jet 1})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 1})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_mass_2
	Title=Mass of second jet
	XLabel=$m(\text{jet 2})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 2})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_mass_3
	Title=Mass of third jet
	XLabel=$m(\text{jet 3})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 3})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_mass_4
	Title=Mass of fourth jet
	XLabel=$m(\text{jet 4})$
	YLabel=$\text{d}\sigma/\text{d}m(\text{jet 4})$ [pb/GeV]
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_multi_exclusive
	Title=Exclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_multi_inclusive
	Title=Inclusive jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})$ [pb]
	XMajorTickMarks=10
	XMinorTickMarks=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_multi_ratio
	Title=Ratio of jet multiplicity
	XLabel=$N_{\text{jet}}$
	YLabel=$\sigma(\geq N_{\text{jet}})/\sigma(\geq N_{\text{jet}}-1)$
	XMajorTickMarks=10
	XMinorTickMarks=0
	LogY=0
	ErrorBands=1
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/log10_R_0
	Title=$\log_{10}$(Integrated $0$ jet rate in $k_\perp$ [GeV])
	XLabel=$\log_{10}(d_{\text{cut}}/\text{GeV})$
	YLabel=$R_{0}$
	Rebin=2
	LegendYPos=0.8
	LegendXPos=0.75
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_pT_1
	Title=Transverse momentum of leading jet
	XLabel=$p_\perp(\text{jet 1})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 1})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_pT_2
	Title=Transverse momentum of second jet
	XLabel=$p_\perp(\text{jet 2})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 2})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_pT_3
	Title=Transverse momentum of third jet
	XLabel=$p_\perp(\text{jet 3})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 3})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_pT_4
	Title=Transverse momentum of fourth jet
	XLabel=$p_\perp(\text{jet 4})$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}p_\perp(\text{jet 4})$ [pb/GeV]
	LogX=1
	LegendXPos=0.05
	LegendYPos=0.5
	XMin=20.0
	# END PLOT

	# BEGIN PLOT /MC_ZZJETS/jet_HT
	Title=Scalar sum of jet transverse momenta (HT)
	XLabel=$HT$ [GeV]
	YLabel=$\text{d}\sigma/\text{d}HT$ [pb/GeV]
	LogX=1
	# END PLOT
	+
	+# BEGIN PLOT /MC_ZZJETS/jets_mjj
	+Title=Dijet invariant mass spectrum
	+XLabel=$m_{jj}$ [GeV]
	+YLabel=$\text{d}\sigma/\text{d}m_{jj}$ [pb/GeV]
	+LegendAlign=r
	+# END PLOT
	diff --git a/data/plotinfo/Makefile.am b/data/plotinfo/Makefile.am
	--- a/data/plotinfo/Makefile.am
	+++ b/data/plotinfo/Makefile.am
	@@ -1,370 +1,414 @@
	dist_pkgdata_DATA = \
	ALEPH_1991_S2435284.plot \
	+ ALEPH_1995_I382179.plot \
	ALEPH_1996_S3486095.plot \
	ALEPH_1996_S3196992.plot \
	ALEPH_1999_S4193598.plot \
	ALEPH_2001_S4656318.plot \
	ALEPH_2002_S4823664.plot \
	ALEPH_2004_S5765862.plot \
	ALICE_2010_S8624100.plot \
	ALICE_2010_S8625980.plot \
	ALICE_2010_S8706239.plot \
	ALICE_2011_S8909580.plot \
	ALICE_2011_S8945144.plot \
	+ ALICE_2012_I1116147.plot \
	ALICE_2012_I1181770.plot \
	ALICE_2014_I1300380.plot \
	ALICE_2015_I1357424.plot \
	ARGUS_1993_S2653028.plot \
	ARGUS_1993_S2669951.plot \
	ARGUS_1993_S2789213.plot \
	ATLAS_2010_S8591806.plot \
	ATLAS_2010_S8817804.plot \
	ATLAS_2010_S8894728.plot \
	ATLAS_2010_S8914702.plot \
	ATLAS_2010_S8918562.plot \
	ATLAS_2010_S8919674.plot \
	ATLAS_2010_CONF_2010_049.plot \
	ATLAS_2011_S8924791.plot \
	ATLAS_2011_S8971293.plot \
	ATLAS_2011_S8994773.plot \
	ATLAS_2011_S9002537.plot \
	ATLAS_2011_S9035664.plot \
	ATLAS_2011_S9120807.plot \
	ATLAS_2011_S9126244.plot \
	ATLAS_2011_S9128077.plot \
	ATLAS_2011_S9131140.plot \
	ATLAS_2011_I894867.plot \
	ATLAS_2011_I919017.plot \
	ATLAS_2011_I921594.plot \
	ATLAS_2011_I928289_W.plot \
	ATLAS_2011_I928289_Z.plot \
	ATLAS_2011_I925932.plot \
	ATLAS_2011_I926145.plot \
	+ ATLAS_2011_I929691.plot \
	ATLAS_2011_I930220.plot \
	ATLAS_2011_I944826.plot \
	ATLAS_2011_I945498.plot \
	ATLAS_2011_I954993.plot \
	ATLAS_2011_S9225137.plot \
	ATLAS_2011_S9212183.plot \
	ATLAS_2011_S8983313.plot \
	ATLAS_2011_S9212353.plot \
	ATLAS_2011_CONF_2011_090.plot \
	ATLAS_2011_CONF_2011_098.plot \
	ATLAS_2012_I1082936.plot \
	ATLAS_2012_I1083318.plot \
	ATLAS_2012_I1084540.plot \
	ATLAS_2012_I1091481.plot \
	ATLAS_2012_I1093734.plot \
	ATLAS_2012_I1093738.plot \
	ATLAS_2012_I1094061.plot \
	ATLAS_2012_I1094564.plot \
	ATLAS_2012_I1094568.plot \
	ATLAS_2012_I1095236.plot \
	ATLAS_2012_I943401.plot \
	ATLAS_2012_I946427.plot \
	ATLAS_2012_I1119557.plot \
	ATLAS_2012_I1124167.plot \
	ATLAS_2012_I1125575.plot \
	ATLAS_2012_I1112263.plot \
	ATLAS_2012_I1125961.plot \
	ATLAS_2012_I1126136.plot \
	ATLAS_2012_I1117704.plot \
	ATLAS_2012_I1118269.plot \
	ATLAS_2012_I1180197.plot \
	ATLAS_2012_I1082009.plot \
	ATLAS_2012_I1183818.plot \
	ATLAS_2012_I1188891.plot \
	ATLAS_2012_I1186556.plot \
	ATLAS_2012_I1190891.plot \
	ATLAS_2012_I1199269.plot \
	ATLAS_2012_I1203852.plot \
	ATLAS_2012_I1204447.plot \
	ATLAS_2012_I1204784.plot \
	ATLAS_2012_CONF_2012_001.plot \
	ATLAS_2012_CONF_2012_103.plot \
	ATLAS_2012_CONF_2012_104.plot \
	ATLAS_2012_CONF_2012_105.plot \
	ATLAS_2012_CONF_2012_109.plot \
	ATLAS_2012_CONF_2012_153.plot \
	ATLAS_2013_I1190187.plot \
	ATLAS_2013_I1219109.plot \
	ATLAS_2013_I1219109_EL.plot \
	ATLAS_2013_I1219109_MU.plot \
	ATLAS_2013_I1217863_W.plot \
	ATLAS_2013_I1217863_W_EL.plot \
	ATLAS_2013_I1217863_W_MU.plot \
	ATLAS_2013_I1217863_Z.plot \
	ATLAS_2013_I1217863_Z_EL.plot \
	ATLAS_2013_I1217863_Z_MU.plot \
	ATLAS_2013_I1217867.plot \
	ATLAS_2013_I1216670.plot \
	ATLAS_2013_I1230812.plot \
	ATLAS_2013_I1230812_EL.plot \
	ATLAS_2013_I1230812_MU.plot \
	ATLAS_2013_I1243871.plot \
	ATLAS_2013_I1244522.plot \
	ATLAS_2013_I1263495.plot \
	ATLAS_2014_I1268975.plot \
	ATLAS_2014_I1279489.plot \
	ATLAS_2014_I1282441.plot \
	ATLAS_2014_I1298811.plot \
	ATLAS_2014_I1304688.plot \
	ATLAS_2014_I1307756.plot \
	ATLAS_2014_I1306294.plot \
	ATLAS_2014_I1306294_EL.plot \
	ATLAS_2014_I1306294_MU.plot \
	ATLAS_2014_I1315949.plot \
	ATLAS_2014_I1325553.plot \
	ATLAS_2014_I1300647.plot \
	ATLAS_2014_I1288706.plot \
	ATLAS_2014_I1307243.plot \
	ATLAS_2014_I1312627.plot \
	ATLAS_2014_I1312627_EL.plot \
	ATLAS_2014_I1312627_MU.plot \
	ATLAS_2014_I1306615.plot \
	ATLAS_2014_I1282447.plot \
	ATLAS_2014_I1298023.plot \
	ATLAS_2014_I1319490.plot \
	ATLAS_2014_I1319490_EL.plot \
	ATLAS_2014_I1319490_MU.plot \
	ATLAS_2014_I1326641.plot \
	ATLAS_2014_I1327229.plot \
	+ ATLAS_2015_I1393758.plot \
	ATLAS_2015_I1387176.plot \
	ATLAS_2015_I1364361.plot \
	+ ATLAS_2015_I1351916.plot \
	+ ATLAS_2015_I1351916_EL.plot \
	+ ATLAS_2015_I1351916_MU.plot \
	ATLAS_2015_I1345452.plot \
	ATLAS_2015_I1376945.plot \
	+ ATLAS_2015_I1390114.plot \
	ATLAS_2015_I1394679.plot \
	+ ATLAS_2015_I1397637.plot \
	+ ATLAS_2015_I1397635.plot \
	ATLAS_2015_CONF_2015_041.plot \
	ATLAS_2015_CONF_2015_041_EL.plot \
	ATLAS_2015_CONF_2015_041_MU.plot \
	+ ATLAS_2015_I1408516.plot \
	+ ATLAS_2015_I1408516_EL.plot \
	+ ATLAS_2015_I1408516_MU.plot \
	+ ATLAS_2015_I1404878.plot \
	+ ATLAS_2016_I1419070.plot \
	+ ATLAS_2016_I1419652.plot \
	ATLAS_2016_I1424838.plot \
	+ ATLAS_2016_I1426695.plot \
	+ ATLAS_2016_I1444991.plot \
	+ ATLAS_2016_I1457605.plot \
	+ ATLAS_2016_I1468168.plot \
	+ ATLAS_2016_I1467230.plot \
	+ ATLAS_2016_I1467454.plot \
	+ ATLAS_2016_I1468167.plot \
	+ ATLAS_2016_I1479760.plot \
	BABAR_2003_I593379.plot \
	BABAR_2005_S6181155.plot \
	BABAR_2007_S6895344.plot \
	BABAR_2007_S7266081.plot \
	+ BABAR_2013_I1116411.plot \
	BABAR_2013_I1238276.plot \
	+ BABAR_2015_I1334693.plot \
	BELLE_2001_S4598261.plot \
	BELLE_2008_I786560.plot \
	+ BELLE_2011_I878990.plot \
	BELLE_2013_I1216515.plot \
	+ BELLE_2013_I1238273.plot \
	+ BELLE_2015_I1397632.plot \
	CDF_1988_S1865951.plot \
	CDF_1990_S2089246.plot \
	CDF_1993_S2742446.plot \
	CDF_1994_S2952106.plot \
	CDF_1996_S3108457.plot \
	CDF_1996_S3349578.plot \
	CDF_1996_S3418421.plot \
	CDF_1997_S3541940.plot \
	CDF_1998_S3618439.plot \
	CDF_2000_S4155203.plot \
	CDF_2000_S4266730.plot \
	CDF_2001_S4517016.plot \
	CDF_2001_S4563131.plot \
	CDF_2001_S4751469.plot \
	CDF_2002_S4796047.plot \
	CDF_2004_S5839831.plot \
	CDF_2005_S6080774.plot \
	CDF_2005_S6217184.plot \
	CDF_2006_S6450792.plot \
	CDF_2006_S6653332.plot \
	CDF_2007_S7057202.plot \
	CDF_2008_S7540469.plot \
	CDF_2008_S7541902.plot \
	CDF_2008_S7782535.plot \
	CDF_2008_S7828950.plot \
	CDF_2008_S8093652.plot \
	CDF_2008_S8095620.plot \
	CDF_2009_S8233977.plot \
	CDF_2009_NOTE_9936.plot \
	- CDF_2009_S8383952.plot \
	+ CDF_2009_I856131.plot \
	CDF_2009_S8436959.plot \
	CDF_2010_S8591881_DY.plot \
	CDF_2010_S8591881_QCD.plot \
	CDF_2012_NOTE10874.plot \
	CDF_2012_I1124333.plot \
	+ CDF_2015_1388868.plot \
	CLEO_2004_S5809304.plot \
	CMS_2010_S8547297.plot \
	CMS_2010_S8656010.plot \
	CMS_2011_S8884919.plot \
	CMS_2011_S8941262.plot \
	CMS_2011_S8950903.plot \
	CMS_2011_S8957746.plot \
	CMS_2011_S8968497.plot \
	CMS_2011_S8973270.plot \
	CMS_2011_S8978280.plot \
	CMS_2011_S9086218.plot \
	CMS_2011_S9088458.plot \
	CMS_2011_S9120041.plot \
	CMS_2011_S9215166.plot \
	CMS_2012_I941555.plot \
	CMS_2011_I954992.plot \
	CMS_2012_I1087342.plot \
	CMS_2012_I1090423.plot \
	CMS_2012_I1102908.plot \
	CMS_2012_I1107658.plot \
	CMS_2012_I1184941.plot \
	CMS_2012_I1193338.plot \
	CMS_2013_I1122847.plot \
	CMS_2013_I1208923.plot \
	CMS_2013_I1209721.plot \
	CMS_2013_I1218372.plot \
	CMS_2013_I1224539_DIJET.plot \
	CMS_2013_I1224539_WJET.plot \
	CMS_2013_I1224539_ZJET.plot \
	CMS_2013_I1256943.plot \
	CMS_2013_I1258128.plot \
	CMS_2013_I1261026.plot \
	CMS_2013_I1265659.plot \
	CMS_2013_I1272853.plot \
	CMS_2013_I1273574.plot \
	+ CMS_2012_I1298807.plot \
	CMS_2014_I1298810.plot \
	CMS_2014_I1303894.plot \
	+ CMS_2014_I1305624.plot \
	CMS_2015_I1310737.plot \
	CMS_2015_I1327224.plot \
	CMS_2015_I1346843.plot \
	CMS_2015_I1356998.plot \
	CMS_2015_I1370682.plot \
	CMS_2015_I1384119.plot \
	CMS_2015_I1385107.plot \
	+ CMS_2015_I1397174.plot \
	+ CMS_2016_I1459051.plot \
	+ CMS_2016_I1473674.plot \
	+ CMS_2010_PAS_QCD_10_024.plot \
	CMS_2012_PAS_QCD_11_010.plot \
	- CMS_QCD_10_024.plot \
	+ CMS_2012_PAS_FSQ_12_020.plot \
	CMSTOTEM_2014_I1294140.plot \
	- TOTEM_2014_I1328627.plot \
	+ D0_1995_I398175.plot \
	D0_1996_S3214044.plot \
	D0_1996_S3324664.plot \
	D0_2000_S4480767.plot \
	D0_2000_I499943.plot \
	D0_2001_S4674421.plot \
	D0_2004_S5992206.plot \
	D0_2006_S6438750.plot \
	D0_2007_S7075677.plot \
	D0_2008_S6879055.plot \
	D0_2008_S7554427.plot \
	D0_2008_S7662670.plot \
	D0_2008_S7719523.plot \
	D0_2008_S7837160.plot \
	D0_2008_S7863608.plot \
	D0_2009_S8202443.plot \
	D0_2009_S8320160.plot \
	D0_2009_S8349509.plot \
	D0_2010_S8566488.plot \
	D0_2010_S8570965.plot \
	D0_2010_S8671338.plot \
	D0_2010_S8821313.plot \
	D0_2011_I895662.plot \
	D0_2015_I1324946.plot \
	D0_2000_I503361.plot \
	E735_1998_S3905616.plot \
	DELPHI_1995_S3137023.plot \
	DELPHI_1996_S3430090.plot \
	DELPHI_1999_S3960137.plot \
	DELPHI_2000_S4328825.plot \
	DELPHI_2002_069_CONF_603.plot \
	+ DELPHI_2011_I890503.plot \
	EXAMPLE.plot \
	H1_1994_S2919893.plot \
	H1_1995_S3167097.plot \
	H1_2000_S4129130.plot \
	JADE_OPAL_2000_S4300807.plot \
	JADE_1998_S3612880.plot \
	+ L3_1992_I336180.plot \
	+ L3_2004_I652683.plot \
	LHCB_2010_S8758301.plot \
	LHCB_2010_I867355.plot \
	LHCB_2011_I917009.plot \
	LHCB_2011_I919315.plot \
	LHCB_2012_I1119400.plot \
	LHCB_2012_I1208102.plot \
	LHCB_2013_I1208105.plot \
	LHCB_2013_I1218996.plot \
	+ LHCB_2014_I1262703.plot \
	LHCB_2014_I1281685.plot \
	LHCB_2015_I1333223.plot \
	LHCF_2012_I1115479.plot \
	- MC_DIJET.plot \
	+ MC_CENTRALITY.plot \
	MC_DIPHOTON.plot \
	MC_ELECTRONS.plot \
	MC_GENERIC.plot \
	MC_HFJETS.plot \
	MC_HINC.plot \
	MC_HJETS.plot \
	MC_HHJETS.plot \
	MC_HKTSPLITTINGS.plot \
	MC_IDENTIFIED.plot \
	MC_JETS.plot \
	MC_JETTAGS.plot \
	MC_KTSPLITTINGS.plot \
	MC_LEADJETUE.plot \
	+ MC_MET.plot \
	MC_MUONS.plot \
	MC_PDFS.plot \
	MC_PHOTONINC.plot \
	MC_PHOTONJETS.plot \
	MC_PHOTONKTSPLITTINGS.plot \
	MC_PHOTONS.plot \
	MC_QCD_PARTONS.plot \
	MC_SUSY.plot \
	MC_TAUS.plot \
	MC_TTBAR.plot \
	MC_VH2BB.plot \
	MC_WINC.plot \
	MC_WINC_EL.plot \
	MC_WINC_MU.plot \
	MC_WINC_EL_BARE.plot \
	MC_WINC_MU_BARE.plot \
	MC_WJETS.plot \
	MC_WJETS_EL.plot \
	MC_WJETS_MU.plot \
	MC_WJETS_EL_BARE.plot \
	MC_WJETS_MU_BARE.plot \
	MC_WKTSPLITTINGS.plot \
	MC_WPOL.plot \
	MC_WWINC.plot \
	MC_WWJETS.plot \
	MC_WWKTSPLITTINGS.plot \
	MC_XS.plot \
	MC_ZINC.plot \
	MC_ZINC_EL.plot \
	MC_ZINC_MU.plot \
	MC_ZINC_EL_BARE.plot \
	MC_ZINC_MU_BARE.plot \
	MC_ZJETS.plot \
	MC_ZJETS_EL.plot \
	MC_ZJETS_MU.plot \
	MC_ZJETS_EL_BARE.plot \
	MC_ZJETS_MU_BARE.plot \
	MC_ZKTSPLITTINGS.plot \
	MC_ZZINC.plot \
	MC_ZZJETS.plot \
	MC_ZZKTSPLITTINGS.plot \
	OPAL_1993_S2692198.plot \
	+ OPAL_1993_I342766.plot \
	OPAL_1994_S2927284.plot \
	OPAL_1995_S3198391.plot \
	OPAL_1996_S3257789.plot \
	OPAL_1997_S3396100.plot \
	OPAL_1997_S3608263.plot \
	OPAL_1998_S3702294.plot \
	OPAL_1998_S3749908.plot \
	OPAL_1998_S3780481.plot \
	OPAL_2000_S4418603.plot \
	OPAL_2001_S4553896.plot \
	OPAL_2002_S5361494.plot \
	+ OPAL_2003_I599181.plot \
	OPAL_2004_S6132243.plot \
	PDG_HADRON_MULTIPLICITIES.plot \
	PDG_HADRON_MULTIPLICITIES_RATIOS.plot \
	PDG_TAUS.plot \
	SFM_1984_S1178091.plot \
	SLD_1996_S3398250.plot \
	SLD_1999_S3743934.plot \
	SLD_2002_S4869273.plot \
	SLD_2004_S5693039.plot \
	STAR_2006_S6500200.plot \
	STAR_2006_S6860818.plot \
	STAR_2006_S6870392.plot \
	STAR_2008_S7869363.plot \
	STAR_2008_S7993412.plot \
	STAR_2009_UE_HELEN.plot \
	TASSO_1990_S2148048.plot \
	TOTEM_2012_I1115294.plot \
	- TOTEM_2012_002.plot \
	+ TOTEM_2012_I1220862.plot \
	+ TOTEM_2014_I1328627.plot \
	ZEUS_2001_S4815815.plot \
	UA1_1990_S2044935.plot \
	UA5_1982_S875503.plot \
	UA5_1986_S1583476.plot \
	UA5_1987_S1640666.plot \
	UA5_1988_S1867512.plot \
	UA5_1989_S1926373.plot
	diff --git a/data/plotinfo/OPAL_1993_I342766.plot b/data/plotinfo/OPAL_1993_I342766.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/OPAL_1993_I342766.plot
	@@ -0,0 +1,11 @@
	+# BEGIN PLOT /OPAL_1993_I342766/d01-x01-y01
	+Title=$K^{*\pm}$ (892) cross section as function of $x_E$
	+XLabel=$x_E$
	+YLabel=$1/\sigma \, \text{d}\sigma/\text{d}x_E$ [$\text{GeV}^-1$]
	+# END PLOT
	+
	+# BEGIN PLOT /OPAL_1993_I342766/d02-x01-y01
	+Title=Mean $K^{*\pm}$ (892) multiplicity
	+XLabel=$E$
	+YLabel= $<N_{K^{*\pm}}>$
	+# END PLOT
	diff --git a/data/plotinfo/OPAL_2003_I599181.plot b/data/plotinfo/OPAL_2003_I599181.plot
	new file mode 100644
	--- /dev/null
	+++ b/data/plotinfo/OPAL_2003_I599181.plot
	@@ -0,0 +1,16 @@
	+# BEGIN PLOT /OPAL_2003_I599181/d01-x01-y01
	+Title=$b$-quark fragmentation function $f(x_B^{weak})$
	+XLabel=$x_{B}$
	+YLabel=$1/N \, \text{d}{N}/\text{d}x_B$
	+# END PLOT
	+
	+# BEGIN PLOT /OPAL_2003_I599181/d02-x01-y01
	+Title=Mean of the $b$-quark fragmentation function $f(x_B^{weak})$
	+XLabel=
	+YLabel=$\langle x_B \rangle$
	+ShowZero=0
	+YMin=0.6
	+YMax=0.8
	+RatioPlotYMin=0.8
	+RatioPlotYMax=1.2
	+# END PLOT
	diff --git a/data/plotinfo/STAR_2006_S6860818.plot b/data/plotinfo/STAR_2006_S6860818.plot
	--- a/data/plotinfo/STAR_2006_S6860818.plot
	+++ b/data/plotinfo/STAR_2006_S6860818.plot
	@@ -1,112 +1,111 @@
	# BEGIN PLOT /STAR_2006_S6860818/d01-x01-y01
	Title=$K^0_\text{s}$ transverse momentum
	XLabel=$p_\perp$ [GeV]
	YLabel=$1/(2\pi) \, d^2N/(p_\perp dy dp_\perp)$ [GeV$^{-2}$]
	FullRange=1
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d01-x02-y01
	Title=$K^-$ transverse momentum
	XLabel=$p_\perp$ [GeV]
	YLabel=$1/(2\pi) \, d^2N/(p_\perp dy dp_\perp)$ [GeV$^{-2}$]
	FullRange=1
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d01-x03-y01
	Title=$K^+$ transverse momentum
	XLabel=$p_\perp$ [GeV]
	YLabel=$1/(2\pi) \, d^2N/(p_\perp dy dp_\perp)$ [GeV$^{-2}$]
	FullRange=1
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d01-x04-y01
	Title=$\Lambda$ transverse momentum
	XLabel=$p_\perp$ [GeV]
	YLabel=$1/(2\pi) \, d^2N/(p_\perp dy dp_\perp)$ [GeV$^{-2}$]
	FullRange=1
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d01-x05-y01
	Title=$\bar \Lambda$ transverse momentum
	XLabel=$p_\perp$ [GeV]
	YLabel=$1/(2\pi) \, d^2N/(p_\perp dy dp_\perp)$ [GeV$^{-2}$]
	FullRange=1
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d01-x06-y01
	Title=$\Xi^-$ transverse momentum
	XLabel=$p_\perp$ [GeV]
	YLabel=$1/(2\pi) \, d^2N/(p_\perp dy dp_\perp)$ [GeV$^{-2}$]
	FullRange=1
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d01-x07-y01
	Title=$\Xi^+$ transverse momentum
	XLabel=$p_\perp$ [GeV]
	YLabel=$1/(2\pi) \, d^2N/(p_\perp dy dp_\perp)$ [GeV$^{-2}$]
	FullRange=1
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d01-x08-y01
	Title=$\Omega$ transverse momentum
	XLabel=$p_\perp$ [GeV]
	YLabel=$1/(2\pi) \, d^2N/(p_\perp dy dp_\perp)$ [GeV$^{-2}$]
	FullRange=1
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d02-x01-y01
	Title=Anti-baryon over baryon ratio vs strangeness
	XLabel=strangeness
	YLabel=anti-baryon/baryon ratio
	-XCustomMajorTicks=0 0 ($\bar p / p$) 1 1 ($\bar \Lambda / \Lambda$) 2 2 ($\bar \Xi / \Xi$) 3 3 ($\bar \Omega / \Omega$)
	+XCustomMajorTicks=0 0~($\bar{p}/p$) 1 1~($\bar{\Lambda}/\Lambda$) 2 2~($\bar{\Xi}/\Xi$) 3 3~($\bar{\Omega}/\Omega$)
	LogY=0
	ShowZero=0
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d02-x02-y01
	Title=Ratio of $\bar \Lambda / \Lambda$ as function of $p_\perp$
	XLabel=$p_\perp$ [GeV]
	YLabel=$\bar \Lambda / \Lambda$
	LogY=0
	YMin=0
	YMax=2
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d02-x03-y01
	Title=Ratio of $\Xi^+ / \Xi^-$ as function of $p_\perp$
	XLabel=$p_\perp$ [GeV]
	YLabel=$\Xi^+ / \Xi^-$
	LogY=0
	YMin=0
	YMax=2
	# END PLOT

	# BEGIN PLOT /STAR_2006_S6860818/d03-x01-y01
	Title=Mean $p_\perp$ vs particle mass
	XLabel=mass [GeV]
	YLabel=$\langle p_\perp \rangle$ [GeV]
	LogY=0
	XMin=0
	XMax=1.8
	# END PLOT
	# BEGIN HISTOGRAM /STAR_2006_S6860818/d03-x01-y01
	ErrorBars=1
	PolyMarker=o
	# END HISTOGRAM
	# BEGIN SPECIAL /STAR_2006_S6860818/d03-x01-y01
	\rput[B]\physicscoor(0.145, 0.14){\small $\pi^-$}
	\rput[B]\physicscoor(0.480, 0.14){\small $K^-$}
	\rput[B]\physicscoor(0.510, 0.25){\small $K^0$}
	\rput[B]\physicscoor(0.775, 0.14){\small $\rho^0$}
	\rput[B]\physicscoor(0.896, 0.14){\small $K^{*0}$}
	\rput[B]\physicscoor(0.938, 0.25){\small $\bar p$}
	\rput[B]\physicscoor(1.019, 0.14){\small $\phi$}
	\rput[B]\physicscoor(1.105, 0.14){\small $\Lambda$}
	\rput[B]\physicscoor(1.125, 0.25){\small $\bar \Lambda$}
	\rput[B]\physicscoor(1.312, 0.14){\small $\Xi^-$}
	\rput[B]\physicscoor(1.332, 0.25){\small $\bar \Xi^+$}
	\rput[B]\physicscoor(1.384, 0.14){\small $\Sigma$}
	\rput[B]\physicscoor(1.520, 0.14){\small $\Lambda$}
	\rput[B]\physicscoor(1.672, 0.14){\small $(\Omega + \bar\Omega)$}
	# END SPECIAL
	-
	diff --git a/data/plotinfo/TOTEM_2012_002.plot b/data/plotinfo/TOTEM_2012_I1220862.plot
	rename from data/plotinfo/TOTEM_2012_002.plot
	rename to data/plotinfo/TOTEM_2012_I1220862.plot
	--- a/data/plotinfo/TOTEM_2012_002.plot
	+++ b/data/plotinfo/TOTEM_2012_I1220862.plot
	@@ -1,17 +1,17 @@
	-# BEGIN PLOT /TOTEM_2012_002/d01-x01-y01
	+# BEGIN PLOT /TOTEM_2012_I1220862/d01-x01-y01
	Title=Differential elastic cross-section vs. $\|t\|$ (low $t$)
	XLabel=$\|t\|$ [$\text{GeV}^2$]
	YLabel=$\mathrm{d}\sigma_\text{el} / \mathrm{d}t$ [mb/$\text{GeV}^2$]
	# END PLOT

	-# BEGIN PLOT /TOTEM_2012_002/d02-x01-y01
	+# BEGIN PLOT /TOTEM_2012_I1220862/d02-x01-y01
	Title=Differential elastic cross-section vs. $\|t\|$ (high $t$)
	XLabel=$\|t\|$ [$\text{GeV}^2$]
	YLabel=$\mathrm{d}\sigma_\text{el} / \mathrm{d}t$ [mb/$\text{GeV}^2$]
	# END PLOT

	-# BEGIN PLOT /TOTEM_2012_002/d03-x01-y01
	+# BEGIN PLOT /TOTEM_2012_I1220862/d03-x01-y01
	Title=Total elastic cross-section
	XLabel=$\sqrt{s}$ [GeV]
	YLabel=$\sigma_\text{elastic}$ [mb]
	# END PLOT
	diff --git a/data/refdata/ALEPH_1995_I382179.yoda b/data/refdata/ALEPH_1995_I382179.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ALEPH_1995_I382179.yoda
	@@ -0,0 +1,115 @@
	+# BEGIN YODA_SCATTER2D /REF/ALEPH_1995_I382179/d01-x01-y01
	+Path=/REF/ALEPH_1995_I382179/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.00526 2.599999999999998E-4 2.3999999999999976E-4 482.9 6.041522986797286 6.041522986797286
	+0.00574 2.4000000000000063E-4 2.599999999999998E-4 462.6 4.8836461788299115 4.8836461788299115
	+0.00622 2.199999999999997E-4 2.7999999999999987E-4 496.5 4.6690470119715 4.6690470119715
	+0.00673 2.3000000000000017E-4 2.700000000000003E-4 511.2 4.47213595499958 4.47213595499958
	+0.00722 2.199999999999997E-4 2.7999999999999987E-4 507.7 4.257933771208753 4.257933771208753
	+0.00773 2.3000000000000017E-4 2.700000000000003E-4 538.5 4.455333881989093 4.455333881989093
	+0.00822 2.199999999999997E-4 2.8000000000000073E-4 484.2 3.9458839313897713 3.9458839313897713
	+0.00871 2.1000000000000012E-4 2.899999999999986E-4 499.7 3.96232255123179 3.96232255123179
	+0.00922 2.2000000000000144E-4 2.79999999999999E-4 494.6 3.8470768123342687 3.8470768123342687
	+0.00972 2.199999999999997E-4 2.8000000000000073E-4 473.9 3.6345563690772495 3.6345563690772495
	+0.0105 5.000000000000004E-4 4.999999999999987E-4 460.9 2.5495097567963922 2.5495097567963922
	+0.0115 5.000000000000004E-4 5.000000000000004E-4 425.6 2.3537204591879637 2.3537204591879637
	+0.0125 5.000000000000004E-4 4.999999999999987E-4 420.7 2.33452350598575 2.33452350598575
	+0.0135 5.000000000000004E-4 5.000000000000004E-4 380.5 2.23606797749979 2.23606797749979
	+0.0147 6.999999999999992E-4 0.0013000000000000008 360.8 1.6155494421403511 1.6155494421403511
	+0.0167 6.999999999999992E-4 0.001299999999999999 324.0 2.280350850198276 2.280350850198276
	+0.047 0.0020000000000000018 0.0030000000000000027 103.96 2.1772000367444417 2.1772000367444417
	+0.052 0.001999999999999995 0.0030000000000000027 89.95 1.1494781424629177 1.1494781424629177
	+0.057 0.0020000000000000018 0.0029999999999999957 78.96 1.0295630140987 1.0295630140987
	+0.0619 0.001899999999999999 0.0031000000000000055 69.36 0.8005623023850174 0.8005623023850174
	+0.0669 0.001899999999999999 0.0031000000000000055 61.35 0.6847627326307997 0.6847627326307997
	+0.0719 0.001899999999999999 0.0030999999999999917 55.27 0.5852349955359812 0.5852349955359812
	+0.0769 0.001899999999999999 0.0031000000000000055 49.91 0.5325410782277739 0.5325410782277739
	+0.0819 0.001899999999999999 0.0031000000000000055 44.33 0.4780167361086848 0.4780167361086848
	+0.087 0.001999999999999988 0.0030000000000000027 40.24 0.4341658669218482 0.4341658669218482
	+0.0942 0.004200000000000009 0.0058 35.38 0.34985711369071804 0.34985711369071804
	+0.104 0.00399999999999999 0.006000000000000005 29.51 0.3023243291566195 0.3023243291566195
	+0.114 0.0040000000000000036 0.0059999999999999915 24.91 0.2720294101747089 0.2720294101747089
	+0.124 0.0040000000000000036 0.006000000000000005 21.06 0.2280350850198276 0.2280350850198276
	+0.134 0.0040000000000000036 0.006000000000000005 18.16 0.20615528128088303 0.20615528128088303
	+0.144 0.003999999999999976 0.006000000000000005 15.46 0.19209372712298547 0.19209372712298547
	+0.154 0.0040000000000000036 0.006000000000000005 13.64 0.17691806012954134 0.17691806012954134
	+0.169 0.009000000000000008 0.010999999999999982 11.0 0.130384048104053 0.130384048104053
	+0.189 0.009000000000000008 0.01100000000000001 8.484 0.11485643212288983 0.11485643212288983
	+0.222 0.021999999999999992 0.027999999999999997 5.621 0.0791580697086532 0.0791580697086532
	+0.272 0.02200000000000002 0.02799999999999997 3.181 0.05371219600798314 0.05371219600798314
	+0.342 0.04200000000000004 0.057999999999999996 1.563 0.030870698080866264 0.030870698080866264
	+0.476 0.07599999999999996 0.124 0.4495 0.01122541758688736 0.01122541758688736
	+0.674 0.07400000000000007 0.126 0.0767 0.0029698484809834993 0.0029698484809834993
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/ALEPH_1995_I382179/d02-x01-y01
	+Path=/REF/ALEPH_1995_I382179/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.00574 2.4000000000000063E-4 2.599999999999998E-4 12.4 1.120044641967453 1.120044641967453
	+0.00622 2.199999999999997E-4 2.7999999999999987E-4 13.27 0.9100549433962765 0.9100549433962765
	+0.00673 2.3000000000000017E-4 2.700000000000003E-4 15.33 0.9000555538409838 0.9000555538409838
	+0.00722 2.199999999999997E-4 2.7999999999999987E-4 17.43 0.9202173656261873 0.9202173656261873
	+0.00773 2.3000000000000017E-4 2.700000000000003E-4 18.33 0.8802272433866154 0.8802272433866154
	+0.00822 2.199999999999997E-4 2.8000000000000073E-4 19.62 0.9002221947941519 0.9002221947941519
	+0.00871 2.1000000000000012E-4 2.899999999999986E-4 20.02 0.8614522621712708 0.8614522621712708
	+0.00922 2.2000000000000144E-4 2.79999999999999E-4 21.66 0.8881441324469806 0.8881441324469806
	+0.0135 5.000000000000004E-4 5.000000000000004E-4 25.84 0.8280096617793781 0.8280096617793781
	+0.0147 6.999999999999992E-4 0.0013000000000000008 27.46 0.8266196223173026 0.8266196223173026
	+0.0167 6.999999999999992E-4 0.001299999999999999 27.63 2.2629405648403584 2.2629405648403584
	+0.0719 0.001899999999999999 0.0030999999999999917 10.6 1.3146862743635837 1.3146862743635837
	+0.0769 0.001899999999999999 0.0031000000000000055 9.53 1.0139033484509261 1.0139033484509261
	+0.0819 0.001899999999999999 0.0031000000000000055 9.15 0.861278120005379 0.861278120005379
	+0.087 0.001999999999999988 0.0030000000000000027 8.41 0.7404052944165108 0.7404052944165108
	+0.0942 0.004200000000000009 0.0058 7.96 0.5772347875864725 0.5772347875864725
	+0.104 0.00399999999999999 0.006000000000000005 7.26 0.48764741360946434 0.48764741360946434
	+0.114 0.0040000000000000036 0.0059999999999999915 6.34 0.38600518131237566 0.38600518131237566
	+0.124 0.0040000000000000036 0.006000000000000005 5.63 0.3383784863137726 0.3383784863137726
	+0.134 0.0040000000000000036 0.006000000000000005 4.94 0.2973213749463701 0.2973213749463701
	+0.144 0.003999999999999976 0.006000000000000005 4.39 0.2563201123595259 0.2563201123595259
	+0.154 0.0040000000000000036 0.006000000000000005 4.22 0.23769728648009425 0.23769728648009425
	+0.169 0.009000000000000008 0.010999999999999982 3.63 0.18973665961010275 0.18973665961010275
	+0.189 0.009000000000000008 0.01100000000000001 3.1 0.15811388300841897 0.15811388300841897
	+0.222 0.021999999999999992 0.027999999999999997 2.245 0.11279184367674819 0.11279184367674819
	+0.272 0.02200000000000002 0.02799999999999997 1.538 0.08000624975587844 0.08000624975587844
	+0.342 0.04200000000000004 0.057999999999999996 0.841 0.0449221548904324 0.0449221548904324
	+0.476 0.07599999999999996 0.124 0.2936 0.015532224567009067 0.015532224567009067
	+0.674 0.07400000000000007 0.126 0.0596 0.0038013155617496425 0.0038013155617496425
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/ALEPH_1995_I382179/d03-x01-y01
	+Path=/REF/ALEPH_1995_I382179/d03-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0105 5.000000000000004E-4 4.999999999999987E-4 8.32 0.35 0.35
	+0.0115 5.000000000000004E-4 5.000000000000004E-4 8.95 0.36 0.36
	+0.0125 5.000000000000004E-4 4.999999999999987E-4 9.8 0.3601388621073821 0.3601388621073821
	+0.0135 5.000000000000004E-4 5.000000000000004E-4 10.3 0.38013155617496425 0.38013155617496425
	+0.0147 6.999999999999992E-4 0.0013000000000000008 10.7 0.2601922366251538 0.2601922366251538
	+0.0167 6.999999999999992E-4 0.001299999999999999 11.58 0.27294688127912364 0.27294688127912364
	+0.0247 6.999999999999992E-4 0.001299999999999999 12.37 0.2920616373302047 0.2920616373302047
	+0.0268 8.000000000000021E-4 0.0011999999999999997 12.46 0.4753945729601885 0.4753945729601885
	+0.0719 0.001899999999999999 0.0030999999999999917 5.315 0.9022372193608508 0.9022372193608508
	+0.0769 0.001899999999999999 0.0031000000000000055 5.008 0.6646878966853541 0.6646878966853541
	+0.0819 0.001899999999999999 0.0031000000000000055 4.445 0.5724028301816825 0.5724028301816825
	+0.087 0.001999999999999988 0.0030000000000000027 4.555 0.49838940598692505 0.49838940598692505
	+0.0942 0.004200000000000009 0.0058 3.742 0.3667274192094177 0.3667274192094177
	+0.104 0.00399999999999999 0.006000000000000005 3.355 0.30384206423732707 0.30384206423732707
	+0.114 0.0040000000000000036 0.0059999999999999915 2.905 0.24444426767670377 0.24444426767670377
	+0.124 0.0040000000000000036 0.006000000000000005 2.653 0.21727632176562633 0.21727632176562633
	+0.134 0.0040000000000000036 0.006000000000000005 2.371 0.1905465822312224 0.1905465822312224
	+0.144 0.003999999999999976 0.006000000000000005 2.137 0.17418381095842403 0.17418381095842403
	+0.154 0.0040000000000000036 0.006000000000000005 1.878 0.1582308440222702 0.1582308440222702
	+0.169 0.009000000000000008 0.010999999999999982 1.696 0.12491997438360287 0.12491997438360287
	+0.189 0.009000000000000008 0.01100000000000001 1.299 0.10534229919647663 0.10534229919647663
	+0.222 0.021999999999999992 0.027999999999999997 0.966 0.07569015788066503 0.07569015788066503
	+0.272 0.02200000000000002 0.02799999999999997 0.614 0.056612719418872644 0.056612719418872644
	+0.342 0.04200000000000004 0.057999999999999996 0.305 0.03228002478313795 0.03228002478313795
	+0.476 0.07599999999999996 0.124 0.0784 0.011513470371699404 0.011513470371699404
	+0.674 0.07400000000000007 0.126 0.0054 0.0024596747752497687 0.0024596747752497687
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/ALICE_2012_I1116147.yoda b/data/refdata/ALICE_2012_I1116147.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ALICE_2012_I1116147.yoda
	@@ -0,0 +1,126 @@
	+# BEGIN YODA_SCATTER2D /REF/ALICE_2012_I1116147/d01-x01-y01
	+Path=/REF/ALICE_2012_I1116147/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.35 0.04999999999999999 0.050000000000000044 88580.0 23448.660942578364 23448.660942578364
	+0.449 0.04899999999999999 0.05099999999999999 67370.0 10971.313731727847 10971.313731727847
	+0.549 0.049000000000000044 0.050999999999999934 38660.0 5669.586316478479 5669.586316478479
	+0.694 0.09399999999999997 0.1060000000000001 20560.0 1974.526272299257 1974.526272299257
	+0.894 0.09399999999999997 0.10599999999999998 8903.0 802.9701115234614 802.9701115234614
	+1.095 0.09499999999999997 0.10499999999999998 4165.0 310.4528949776439 310.4528949776439
	+1.295 0.09499999999999997 0.10499999999999998 2152.0 138.81282361511128 138.81282361511128
	+1.495 0.0950000000000002 0.10499999999999998 1187.0 60.530983801686226 60.530983801686226
	+1.696 0.09599999999999986 0.10400000000000009 677.7 31.76476034853718 31.76476034853718
	+1.896 0.09599999999999986 0.10400000000000009 393.8 18.36355085488643 18.36355085488643
	+2.096 0.09600000000000009 0.10400000000000009 241.2 11.002272492535349 11.002272492535349
	+2.296 0.09599999999999964 0.10400000000000009 150.2 6.7468511173731995 6.7468511173731995
	+2.497 0.09699999999999998 0.1030000000000002 99.72 4.615733961137709 4.615733961137709
	+2.697 0.09699999999999998 0.10299999999999976 67.19 3.1531730050855122 3.1531730050855122
	+2.897 0.09699999999999998 0.1030000000000002 44.36 2.1676023620581337 2.1676023620581337
	+3.097 0.09699999999999998 0.1030000000000002 32.46 1.53687995627505 1.53687995627505
	+3.297 0.09699999999999998 0.10299999999999976 21.98 1.0568822072492279 1.0568822072492279
	+3.497 0.09699999999999998 0.1030000000000002 15.97 0.8228000972289684 0.8228000972289684
	+3.697 0.09699999999999998 0.10299999999999976 11.69 0.5818075283115542 0.5818075283115542
	+3.898 0.09800000000000031 0.10199999999999987 8.544 0.4482064256567503 0.4482064256567503
	+4.236 0.23599999999999977 0.26400000000000023 5.376 0.253298243183801 0.253298243183801
	+4.737 0.2370000000000001 0.2629999999999999 2.68 0.1341640786499874 0.1341640786499874
	+5.238 0.23800000000000043 0.26199999999999957 1.475 0.07940403012442127 0.07940403012442127
	+5.739 0.23899999999999988 0.2610000000000001 0.9079 0.05289357238833468 0.05289357238833468
	+6.461 0.4610000000000003 0.5389999999999997 0.42 0.024935316320431947 0.024935316320431947
	+7.465 0.46499999999999986 0.5350000000000001 0.2057 0.01422005625867915 0.01422005625867915
	+8.883 0.8829999999999991 1.1170000000000009 0.06003 0.004400693127224392 0.004400693127224392
	+10.902 0.9019999999999992 1.0980000000000008 0.01891 0.0017425555945220228 0.0017425555945220228
	+12.916 0.9160000000000004 1.0839999999999996 0.006357 8.910454533860772E-4 8.910454533860772E-4
	+14.927 0.9269999999999996 1.0730000000000004 0.002958 9.746902071940601E-4 9.746902071940601E-4
	+16.935 0.9349999999999987 1.0650000000000013 9.478E-4 3.746797165580224E-4 3.746797165580224E-4
	+18.941 0.940999999999999 1.059000000000001 3.942E-4 1.910556201738122E-4 1.910556201738122E-4
	+22.197 2.196999999999999 2.803000000000001 2.052E-4 7.44452819190041E-5 7.44452819190041E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/ALICE_2012_I1116147/d02-x01-y01
	+Path=/REF/ALICE_2012_I1116147/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.495 0.09499999999999997 0.10499999999999998 27760.0 7468.831568592239 7468.831568592239
	+0.694 0.09399999999999997 0.1060000000000001 8458.0 1232.0551935688595 1232.0551935688595
	+0.894 0.09399999999999997 0.10599999999999998 3404.0 395.82824558133797 395.82824558133797
	+1.095 0.09499999999999997 0.10499999999999998 1474.0 155.03870484495155 155.03870484495155
	+1.295 0.09499999999999997 0.10499999999999998 801.4 84.76803642883324 84.76803642883324
	+1.495 0.0950000000000002 0.10499999999999998 380.0 40.98499725509323 40.98499725509323
	+1.783 0.18299999999999983 0.21700000000000008 143.4 14.5 14.5
	+2.228 0.2280000000000002 0.2719999999999998 41.24 4.951464429842953 4.951464429842953
	+2.73 0.22999999999999998 0.27 18.55 2.6664770765937593 2.6664770765937593
	+3.233 0.2330000000000001 0.2669999999999999 5.385 0.8742413854308202 0.8742413854308202
	+3.735 0.23499999999999988 0.2650000000000001 2.531 0.47773737555271933 0.47773737555271933
	+4.447 0.44700000000000006 0.5529999999999999 0.7415 0.15614957572788982 0.15614957572788982
	+5.818 0.8179999999999996 1.1820000000000004 0.09131 0.026135173617177293 0.026135173617177293
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/ALICE_2012_I1116147/d03-x01-y01
	+Path=/REF/ALICE_2012_I1116147/d03-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.548 0.14800000000000002 0.1519999999999999 4216.0 1363.117016253557 1363.117016253557
	+0.839 0.139 0.16100000000000003 1797.0 317.2002522067093 317.2002522067093
	+1.179 0.17900000000000005 0.22099999999999986 741.4 98.7656822990658 98.7656822990658
	+1.581 0.18100000000000005 0.21900000000000008 261.2 29.47032405658275 29.47032405658275
	+1.983 0.18300000000000005 0.21700000000000008 107.6 13.124404748406688 13.124404748406688
	+2.385 0.1849999999999996 0.2150000000000003 45.85 4.964483860382669 4.964483860382669
	+2.786 0.18599999999999994 0.21399999999999997 21.99 2.7572631357924475 2.7572631357924475
	+3.231 0.23099999999999987 0.26900000000000013 9.723 1.1775623125762815 1.1775623125762815
	+3.733 0.2330000000000001 0.2669999999999999 5.203 0.612474489264655 0.612474489264655
	+4.792 0.7919999999999998 1.2080000000000002 1.134 0.12625371281669304 0.12625371281669304
	+6.846 0.8460000000000001 1.154 0.1672 0.02846085030353099 0.02846085030353099
	+8.877 0.8770000000000007 1.1229999999999993 0.03576 0.016479881674332498 0.016479881674332498
	+11.98 1.9800000000000004 3.0199999999999996 0.004347 0.0025059852353914616 0.0025059852353914616
	+# END YODA_SCATTER2D
	+
	+#------------------------------------------------------------
	+# HERE IS THE YODA SCATTER2D PLOT THAT HAS NO x-ERRORS
	+#------------------------------------------------------------
	+# BEGIN YODA_SCATTER2D /REF/ALICE_2012_I1116147/d04-x01-y01
	+#Path=/REF/ALICE_2012_I1116147/d04-x01-y01
	+#Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+#0.55 0.0 0.0 0.1067 0.03347013594235912 0.03347013594235912
	+#0.85 0.0 0.0 0.1655 0.02529268669002959 0.02529268669002959
	+#1.2 0.0 0.0 0.2501 0.02603113520382851 0.02603113520382851
	+#1.6 0.0 0.0 0.2866 0.026801865606707307 0.026801865606707307
	+#2.0 0.0 0.0 0.3514 0.030696090956341654 0.030696090956341654
	+#2.4 0.0 0.0 0.3547 0.02972574641619618 0.02972574641619618
	+#2.8 0.0 0.0 0.3757 0.035979021665409415 0.035979021665409415
	+#3.25 0.0 0.0 0.3987 0.03927250946909301 0.03927250946909301
	+#3.75 0.0 0.0 0.4655 0.04585193561890272 0.04585193561890272
	+#5.0 0.0 0.0 0.4686 0.04081041533726409 0.04081041533726409
	+#7.0 0.0 0.0 0.5014 0.08140718641495971 0.08140718641495971
	+#9.0 0.0 0.0 0.7082 0.18510386273657284 0.18510386273657284
	+#12.5 0.0 0.0 0.5205 0.27690873947927325 0.27690873947927325
	+# END YODA_SCATTER2D
	+
	+
	+#------------------------------------------------------------
	+# THIS IS TAKEN FROM THE AIDA FILE FROM HEPDATA,
	+# THEN CONVERTED TO YODA WITH AIDA2YODA.
	+# IT HAS THE RIGHT "x-ERRORS" AND THUS THE RIGHT BINNING
	+#------------------------------------------------------------
	+BEGIN YODA_SCATTER2D /REF/ALICE_2012_I1116147/d04-x01-y01
	+Path=/REF/ALICE_2012_I1116147/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.500000e-01 1.500000e-01 1.500000e-01 1.067000e-01 3.347014e-02 3.347014e-02
	+8.500000e-01 1.500000e-01 1.750000e-01 1.655000e-01 2.529269e-02 2.529269e-02
	+1.200000e+00 1.750000e-01 2.000000e-01 2.501000e-01 2.603114e-02 2.603114e-02
	+1.600000e+00 2.000000e-01 2.000000e-01 2.866000e-01 2.680187e-02 2.680187e-02
	+2.000000e+00 2.000000e-01 2.000000e-01 3.514000e-01 3.069609e-02 3.069609e-02
	+2.400000e+00 2.000000e-01 2.000000e-01 3.547000e-01 2.972575e-02 2.972575e-02
	+2.800000e+00 2.000000e-01 2.250000e-01 3.757000e-01 3.597902e-02 3.597902e-02
	+3.250000e+00 2.250000e-01 2.500000e-01 3.987000e-01 3.927251e-02 3.927251e-02
	+3.750000e+00 2.500000e-01 6.250000e-01 4.655000e-01 4.585194e-02 4.585194e-02
	+5.000000e+00 6.250000e-01 1.000000e+00 4.686000e-01 4.081042e-02 4.081042e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 5.014000e-01 8.140719e-02 8.140719e-02
	+9.000000e+00 1.000000e+00 1.750000e+00 7.082000e-01 1.851039e-01 1.851039e-01
	+1.250000e+01 1.750000e+00 1.750000e+00 5.205000e-01 2.769087e-01 2.769087e-01
	+END YODA_SCATTER2D
	diff --git a/data/refdata/ATLAS_2010_S8918562.yoda b/data/refdata/ATLAS_2010_S8918562.yoda
	--- a/data/refdata/ATLAS_2010_S8918562.yoda
	+++ b/data/refdata/ATLAS_2010_S8918562.yoda
	@@ -1,1812 +1,1810 @@
	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d01-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d01-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.450000e+00 5.000000e-02 5.000000e-02 1.150000e+00 7.831347e-02 7.831347e-02
	-2.350000e+00 5.000000e-02 5.000000e-02 1.184000e+00 8.130191e-02 8.130191e-02
	-2.250000e+00 5.000000e-02 5.000000e-02 1.213000e+00 4.751842e-02 4.751842e-02
	-2.150000e+00 5.000000e-02 5.000000e-02 1.206000e+00 4.652956e-02 4.652956e-02
	-2.050000e+00 5.000000e-02 5.000000e-02 1.235000e+00 4.850773e-02 4.850773e-02
	-1.950000e+00 5.000000e-02 5.000000e-02 1.238000e+00 4.850773e-02 4.850773e-02
	-1.850000e+00 5.000000e-02 5.000000e-02 1.258000e+00 3.765634e-02 3.765634e-02
	-1.750000e+00 5.000000e-02 5.000000e-02 1.302000e+00 3.863936e-02 3.863936e-02
	-1.650000e+00 5.000000e-02 5.000000e-02 1.326000e+00 3.863936e-02 3.863936e-02
	-1.550000e+00 5.000000e-02 5.000000e-02 1.330000e+00 3.962323e-02 3.962323e-02
	-1.450000e+00 5.000000e-02 5.000000e-02 1.325000e+00 3.863936e-02 3.863936e-02
	-1.350000e+00 5.000000e-02 5.000000e-02 1.324000e+00 3.863936e-02 3.863936e-02
	-1.250000e+00 5.000000e-02 5.000000e-02 1.351000e+00 2.789265e-02 2.789265e-02
	-1.150000e+00 5.000000e-02 5.000000e-02 1.346000e+00 2.789265e-02 2.789265e-02
	-1.050000e+00 5.000000e-02 5.000000e-02 1.357000e+00 2.789265e-02 2.789265e-02
	-9.500000e-01 5.000000e-02 5.000000e-02 1.349000e+00 2.789265e-02 2.789265e-02
	-8.500000e-01 5.000000e-02 5.000000e-02 1.354000e+00 2.789265e-02 2.789265e-02
	-7.500000e-01 5.000000e-02 5.000000e-02 1.348000e+00 2.789265e-02 2.789265e-02
	-6.500000e-01 5.000000e-02 5.000000e-02 1.360000e+00 2.789265e-02 2.789265e-02
	-5.500000e-01 5.000000e-02 5.000000e-02 1.345000e+00 2.789265e-02 2.789265e-02
	-4.500000e-01 5.000000e-02 5.000000e-02 1.346000e+00 2.789265e-02 2.789265e-02
	-3.500000e-01 5.000000e-02 5.000000e-02 1.348000e+00 2.789265e-02 2.789265e-02
	-2.500000e-01 5.000000e-02 5.000000e-02 1.352000e+00 2.789265e-02 2.789265e-02
	-1.500000e-01 5.000000e-02 5.000000e-02 1.342000e+00 2.789265e-02 2.789265e-02
	-5.000000e-02 5.000000e-02 5.000000e-02 1.353000e+00 2.789265e-02 2.789265e-02
	5.000000e-02 5.000000e-02 5.000000e-02 1.341000e+00 2.789265e-02 2.789265e-02
	1.500000e-01 5.000000e-02 5.000000e-02 1.338000e+00 2.789265e-02 2.789265e-02
	2.500000e-01 5.000000e-02 5.000000e-02 1.329000e+00 2.692582e-02 2.692582e-02
	3.500000e-01 5.000000e-02 5.000000e-02 1.340000e+00 2.789265e-02 2.789265e-02
	4.500000e-01 5.000000e-02 5.000000e-02 1.346000e+00 2.789265e-02 2.789265e-02
	5.500000e-01 5.000000e-02 5.000000e-02 1.337000e+00 2.692582e-02 2.692582e-02
	6.500000e-01 5.000000e-02 5.000000e-02 1.345000e+00 2.789265e-02 2.789265e-02
	7.500000e-01 5.000000e-02 5.000000e-02 1.356000e+00 2.789265e-02 2.789265e-02
	8.500000e-01 5.000000e-02 5.000000e-02 1.346000e+00 2.789265e-02 2.789265e-02
	9.500000e-01 5.000000e-02 5.000000e-02 1.352000e+00 2.789265e-02 2.789265e-02
	1.050000e+00 5.000000e-02 5.000000e-02 1.360000e+00 2.789265e-02 2.789265e-02
	1.150000e+00 5.000000e-02 5.000000e-02 1.364000e+00 2.789265e-02 2.789265e-02
	1.250000e+00 5.000000e-02 5.000000e-02 1.354000e+00 2.789265e-02 2.789265e-02
	1.350000e+00 5.000000e-02 5.000000e-02 1.332000e+00 3.962323e-02 3.962323e-02
	1.450000e+00 5.000000e-02 5.000000e-02 1.315000e+00 3.863936e-02 3.863936e-02
	1.550000e+00 5.000000e-02 5.000000e-02 1.322000e+00 3.863936e-02 3.863936e-02
	1.650000e+00 5.000000e-02 5.000000e-02 1.325000e+00 3.863936e-02 3.863936e-02
	1.750000e+00 5.000000e-02 5.000000e-02 1.306000e+00 3.863936e-02 3.863936e-02
	1.850000e+00 5.000000e-02 5.000000e-02 1.279000e+00 3.765634e-02 3.765634e-02
	1.950000e+00 5.000000e-02 5.000000e-02 1.233000e+00 4.751842e-02 4.751842e-02
	2.050000e+00 5.000000e-02 5.000000e-02 1.235000e+00 4.850773e-02 4.850773e-02
	2.150000e+00 5.000000e-02 5.000000e-02 1.241000e+00 4.850773e-02 4.850773e-02
	2.250000e+00 5.000000e-02 5.000000e-02 1.224000e+00 4.751842e-02 4.751842e-02
	2.350000e+00 5.000000e-02 5.000000e-02 1.178000e+00 8.030567e-02 8.030567e-02
	2.450000e+00 5.000000e-02 5.000000e-02 1.144000e+00 7.831347e-02 7.831347e-02
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d02-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d02-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.400000e+00 1.000000e-01 1.000000e-01 1.661000e+00 1.211487e-01 1.211487e-01
	-2.200000e+00 1.000000e-01 1.000000e-01 1.700000e+00 8.198780e-02 8.198780e-02
	-2.000000e+00 1.000000e-01 1.000000e-01 1.692000e+00 8.508819e-02 8.508819e-02
	-1.800000e+00 1.000000e-01 1.000000e-01 1.685000e+00 8.508819e-02 8.508819e-02
	-1.600000e+00 1.000000e-01 1.000000e-01 1.757000e+00 8.198780e-02 8.198780e-02
	-1.400000e+00 1.000000e-01 1.000000e-01 1.777000e+00 8.198780e-02 8.198780e-02
	-1.200000e+00 1.000000e-01 1.000000e-01 1.793000e+00 8.112336e-02 8.112336e-02
	-1.000000e+00 1.000000e-01 1.000000e-01 1.808000e+00 7.975588e-02 7.975588e-02
	-8.000000e-01 1.000000e-01 1.000000e-01 1.745000e+00 7.803204e-02 7.803204e-02
	-6.000000e-01 1.000000e-01 1.000000e-01 1.720000e+00 7.803204e-02 7.803204e-02
	-4.000000e-01 1.000000e-01 1.000000e-01 1.712000e+00 7.889233e-02 7.889233e-02
	-2.000000e-01 1.000000e-01 1.000000e-01 1.776000e+00 8.335466e-02 8.335466e-02
	0.000000e+00 1.000000e-01 1.000000e-01 1.708000e+00 8.335466e-02 8.335466e-02
	2.000000e-01 1.000000e-01 1.000000e-01 1.710000e+00 8.421995e-02 8.421995e-02
	4.000000e-01 1.000000e-01 1.000000e-01 1.794000e+00 8.558621e-02 8.558621e-02
	6.000000e-01 1.000000e-01 1.000000e-01 1.776000e+00 8.249242e-02 8.249242e-02
	8.000000e-01 1.000000e-01 1.000000e-01 1.749000e+00 8.112336e-02 8.112336e-02
	1.000000e+00 1.000000e-01 1.000000e-01 1.747000e+00 8.112336e-02 8.112336e-02
	1.200000e+00 1.000000e-01 1.000000e-01 1.822000e+00 8.285530e-02 8.285530e-02
	1.400000e+00 1.000000e-01 1.000000e-01 1.793000e+00 8.198780e-02 8.198780e-02
	1.600000e+00 1.000000e-01 1.000000e-01 1.759000e+00 8.112336e-02 8.112336e-02
	1.800000e+00 1.000000e-01 1.000000e-01 1.710000e+00 8.198780e-02 8.198780e-02
	2.000000e+00 1.000000e-01 1.000000e-01 1.697000e+00 8.508819e-02 8.508819e-02
	2.200000e+00 1.000000e-01 1.000000e-01 1.645000e+00 7.752419e-02 7.752419e-02
	2.400000e+00 1.000000e-01 1.000000e-01 1.574000e+00 1.069766e-01 1.069766e-01
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d03-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d03-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.450000e+00 5.000000e-02 5.000000e-02 2.196000e+00 1.510132e-01 1.510132e-01
	-2.350000e+00 5.000000e-02 5.000000e-02 2.265000e+00 1.560128e-01 1.560128e-01
	-2.250000e+00 5.000000e-02 5.000000e-02 2.295000e+00 9.102198e-02 9.102198e-02
	-2.150000e+00 5.000000e-02 5.000000e-02 2.286000e+00 9.002222e-02 9.002222e-02
	-2.050000e+00 5.000000e-02 5.000000e-02 2.334000e+00 9.202174e-02 9.202174e-02
	-1.950000e+00 5.000000e-02 5.000000e-02 2.312000e+00 9.102198e-02 9.102198e-02
	-1.850000e+00 5.000000e-02 5.000000e-02 2.355000e+00 7.102816e-02 7.102816e-02
	-1.750000e+00 5.000000e-02 5.000000e-02 2.413000e+00 7.202777e-02 7.202777e-02
	-1.650000e+00 5.000000e-02 5.000000e-02 2.431000e+00 7.302739e-02 7.302739e-02
	-1.550000e+00 5.000000e-02 5.000000e-02 2.417000e+00 7.202777e-02 7.202777e-02
	-1.450000e+00 5.000000e-02 5.000000e-02 2.408000e+00 7.202777e-02 7.202777e-02
	-1.350000e+00 5.000000e-02 5.000000e-02 2.445000e+00 7.202777e-02 7.202777e-02
	-1.250000e+00 5.000000e-02 5.000000e-02 2.471000e+00 5.103920e-02 5.103920e-02
	-1.150000e+00 5.000000e-02 5.000000e-02 2.469000e+00 5.203845e-02 5.203845e-02
	-1.050000e+00 5.000000e-02 5.000000e-02 2.451000e+00 5.103920e-02 5.103920e-02
	-9.500000e-01 5.000000e-02 5.000000e-02 2.446000e+00 5.003998e-02 5.003998e-02
	-8.500000e-01 5.000000e-02 5.000000e-02 2.451000e+00 5.103920e-02 5.103920e-02
	-7.500000e-01 5.000000e-02 5.000000e-02 2.451000e+00 5.103920e-02 5.103920e-02
	-6.500000e-01 5.000000e-02 5.000000e-02 2.448000e+00 5.103920e-02 5.103920e-02
	-5.500000e-01 5.000000e-02 5.000000e-02 2.442000e+00 5.003998e-02 5.003998e-02
	-4.500000e-01 5.000000e-02 5.000000e-02 2.438000e+00 5.103920e-02 5.103920e-02
	-3.500000e-01 5.000000e-02 5.000000e-02 2.433000e+00 5.103920e-02 5.103920e-02
	-2.500000e-01 5.000000e-02 5.000000e-02 2.428000e+00 5.103920e-02 5.103920e-02
	-1.500000e-01 5.000000e-02 5.000000e-02 2.425000e+00 5.003998e-02 5.003998e-02
	-5.000000e-02 5.000000e-02 5.000000e-02 2.422000e+00 5.003998e-02 5.003998e-02
	5.000000e-02 5.000000e-02 5.000000e-02 2.420000e+00 5.003998e-02 5.003998e-02
	1.500000e-01 5.000000e-02 5.000000e-02 2.426000e+00 5.103920e-02 5.103920e-02
	2.500000e-01 5.000000e-02 5.000000e-02 2.429000e+00 5.003998e-02 5.003998e-02
	3.500000e-01 5.000000e-02 5.000000e-02 2.430000e+00 5.003998e-02 5.003998e-02
	4.500000e-01 5.000000e-02 5.000000e-02 2.438000e+00 5.103920e-02 5.103920e-02
	5.500000e-01 5.000000e-02 5.000000e-02 2.444000e+00 5.103920e-02 5.103920e-02
	6.500000e-01 5.000000e-02 5.000000e-02 2.447000e+00 5.103920e-02 5.103920e-02
	7.500000e-01 5.000000e-02 5.000000e-02 2.451000e+00 5.103920e-02 5.103920e-02
	8.500000e-01 5.000000e-02 5.000000e-02 2.451000e+00 5.103920e-02 5.103920e-02
	9.500000e-01 5.000000e-02 5.000000e-02 2.447000e+00 5.103920e-02 5.103920e-02
	1.050000e+00 5.000000e-02 5.000000e-02 2.458000e+00 5.203845e-02 5.203845e-02
	1.150000e+00 5.000000e-02 5.000000e-02 2.474000e+00 5.103920e-02 5.103920e-02
	1.250000e+00 5.000000e-02 5.000000e-02 2.459000e+00 5.203845e-02 5.203845e-02
	1.350000e+00 5.000000e-02 5.000000e-02 2.432000e+00 7.302739e-02 7.302739e-02
	1.450000e+00 5.000000e-02 5.000000e-02 2.393000e+00 7.202777e-02 7.202777e-02
	1.550000e+00 5.000000e-02 5.000000e-02 2.424000e+00 7.302739e-02 7.302739e-02
	1.650000e+00 5.000000e-02 5.000000e-02 2.434000e+00 7.302739e-02 7.302739e-02
	1.750000e+00 5.000000e-02 5.000000e-02 2.401000e+00 7.102816e-02 7.102816e-02
	1.850000e+00 5.000000e-02 5.000000e-02 2.351000e+00 7.002857e-02 7.002857e-02
	1.950000e+00 5.000000e-02 5.000000e-02 2.316000e+00 9.102198e-02 9.102198e-02
	2.050000e+00 5.000000e-02 5.000000e-02 2.344000e+00 9.202174e-02 9.202174e-02
	2.150000e+00 5.000000e-02 5.000000e-02 2.295000e+00 9.102198e-02 9.102198e-02
	2.250000e+00 5.000000e-02 5.000000e-02 2.285000e+00 8.902247e-02 8.902247e-02
	2.350000e+00 5.000000e-02 5.000000e-02 2.251000e+00 1.550129e-01 1.550129e-01
	2.450000e+00 5.000000e-02 5.000000e-02 2.180000e+00 1.510132e-01 1.510132e-01
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d04-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d04-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.450000e+00 5.000000e-02 5.000000e-02 3.516000e+00 3.474665e-01 3.474665e-01
	-2.350000e+00 5.000000e-02 5.000000e-02 3.558000e+00 3.483231e-01 3.483231e-01
	-2.250000e+00 5.000000e-02 5.000000e-02 3.596000e+00 2.184491e-01 2.184491e-01
	-2.150000e+00 5.000000e-02 5.000000e-02 3.585000e+00 2.174511e-01 2.174511e-01
	-2.050000e+00 5.000000e-02 5.000000e-02 3.620000e+00 2.024846e-01 2.024846e-01
	-1.950000e+00 5.000000e-02 5.000000e-02 3.593000e+00 1.994919e-01 1.994919e-01
	-1.850000e+00 5.000000e-02 5.000000e-02 3.628000e+00 1.606113e-01 1.606113e-01
	-1.750000e+00 5.000000e-02 5.000000e-02 3.740000e+00 1.655929e-01 1.655929e-01
	-1.650000e+00 5.000000e-02 5.000000e-02 3.781000e+00 1.665893e-01 1.665893e-01
	-1.550000e+00 5.000000e-02 5.000000e-02 3.707000e+00 1.626930e-01 1.626930e-01
	-1.450000e+00 5.000000e-02 5.000000e-02 3.694000e+00 1.616075e-01 1.616075e-01
	-1.350000e+00 5.000000e-02 5.000000e-02 3.669000e+00 1.606113e-01 1.606113e-01
	-1.250000e+00 5.000000e-02 5.000000e-02 3.685000e+00 1.138640e-01 1.138640e-01
	-1.150000e+00 5.000000e-02 5.000000e-02 3.711000e+00 1.158490e-01 1.158490e-01
	-1.050000e+00 5.000000e-02 5.000000e-02 3.701000e+00 1.147388e-01 1.147388e-01
	-9.500000e-01 5.000000e-02 5.000000e-02 3.656000e+00 1.127519e-01 1.127519e-01
	-8.500000e-01 5.000000e-02 5.000000e-02 3.650000e+00 1.127519e-01 1.127519e-01
	-7.500000e-01 5.000000e-02 5.000000e-02 3.604000e+00 1.097725e-01 1.097725e-01
	-6.500000e-01 5.000000e-02 5.000000e-02 3.610000e+00 1.107655e-01 1.107655e-01
	-5.500000e-01 5.000000e-02 5.000000e-02 3.558000e+00 1.087796e-01 1.087796e-01
	-4.500000e-01 5.000000e-02 5.000000e-02 3.531000e+00 1.079120e-01 1.079120e-01
	-3.500000e-01 5.000000e-02 5.000000e-02 3.536000e+00 1.100273e-01 1.100273e-01
	-2.500000e-01 5.000000e-02 5.000000e-02 3.508000e+00 1.070561e-01 1.070561e-01
	-1.500000e-01 5.000000e-02 5.000000e-02 3.497000e+00 1.080463e-01 1.080463e-01
	-5.000000e-02 5.000000e-02 5.000000e-02 3.476000e+00 1.059292e-01 1.059292e-01
	5.000000e-02 5.000000e-02 5.000000e-02 3.486000e+00 1.070561e-01 1.070561e-01
	1.500000e-01 5.000000e-02 5.000000e-02 3.474000e+00 1.060660e-01 1.060660e-01
	2.500000e-01 5.000000e-02 5.000000e-02 3.496000e+00 1.080463e-01 1.080463e-01
	3.500000e-01 5.000000e-02 5.000000e-02 3.522000e+00 1.079120e-01 1.079120e-01
	4.500000e-01 5.000000e-02 5.000000e-02 3.521000e+00 1.069205e-01 1.069205e-01
	5.500000e-01 5.000000e-02 5.000000e-02 3.557000e+00 1.098954e-01 1.098954e-01
	6.500000e-01 5.000000e-02 5.000000e-02 3.584000e+00 1.107655e-01 1.107655e-01
	7.500000e-01 5.000000e-02 5.000000e-02 3.603000e+00 1.097725e-01 1.097725e-01
	8.500000e-01 5.000000e-02 5.000000e-02 3.625000e+00 1.097725e-01 1.097725e-01
	9.500000e-01 5.000000e-02 5.000000e-02 3.639000e+00 1.117587e-01 1.117587e-01
	1.050000e+00 5.000000e-02 5.000000e-02 3.671000e+00 1.117587e-01 1.117587e-01
	1.150000e+00 5.000000e-02 5.000000e-02 3.702000e+00 1.138640e-01 1.138640e-01
	1.250000e+00 5.000000e-02 5.000000e-02 3.711000e+00 1.148564e-01 1.148564e-01
	1.350000e+00 5.000000e-02 5.000000e-02 3.725000e+00 1.645965e-01 1.645965e-01
	1.450000e+00 5.000000e-02 5.000000e-02 3.711000e+00 1.636887e-01 1.636887e-01
	1.550000e+00 5.000000e-02 5.000000e-02 3.714000e+00 1.646845e-01 1.646845e-01
	1.650000e+00 5.000000e-02 5.000000e-02 3.744000e+00 1.645965e-01 1.645965e-01
	1.750000e+00 5.000000e-02 5.000000e-02 3.702000e+00 1.626038e-01 1.626038e-01
	1.850000e+00 5.000000e-02 5.000000e-02 3.656000e+00 1.606113e-01 1.606113e-01
	1.950000e+00 5.000000e-02 5.000000e-02 3.606000e+00 2.014870e-01 2.014870e-01
	2.050000e+00 5.000000e-02 5.000000e-02 3.650000e+00 2.034822e-01 2.034822e-01
	2.150000e+00 5.000000e-02 5.000000e-02 3.639000e+00 2.194470e-01 2.194470e-01
	2.250000e+00 5.000000e-02 5.000000e-02 3.617000e+00 2.184491e-01 2.184491e-01
	2.350000e+00 5.000000e-02 5.000000e-02 3.523000e+00 3.443269e-01 3.443269e-01
	2.450000e+00 5.000000e-02 5.000000e-02 3.408000e+00 3.344324e-01 3.344324e-01
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d05-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d05-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.450000e+00 5.000000e-02 5.000000e-02 5.786000e+00 5.580143e-01 5.580143e-01
	-2.350000e+00 5.000000e-02 5.000000e-02 5.971000e+00 5.730140e-01 5.730140e-01
	-2.250000e+00 5.000000e-02 5.000000e-02 5.999000e+00 3.570126e-01 3.570126e-01
	-2.150000e+00 5.000000e-02 5.000000e-02 5.938000e+00 3.500129e-01 3.500129e-01
	-2.050000e+00 5.000000e-02 5.000000e-02 6.048000e+00 3.330135e-01 3.330135e-01
	-1.950000e+00 5.000000e-02 5.000000e-02 5.950000e+00 3.250138e-01 3.250138e-01
	-1.850000e+00 5.000000e-02 5.000000e-02 6.001000e+00 2.600173e-01 2.600173e-01
	-1.750000e+00 5.000000e-02 5.000000e-02 6.138000e+00 2.660169e-01 2.660169e-01
	-1.650000e+00 5.000000e-02 5.000000e-02 6.132000e+00 2.660169e-01 2.660169e-01
	-1.550000e+00 5.000000e-02 5.000000e-02 6.011000e+00 2.600308e-01 2.600308e-01
	-1.450000e+00 5.000000e-02 5.000000e-02 5.923000e+00 2.530178e-01 2.530178e-01
	-1.350000e+00 5.000000e-02 5.000000e-02 5.963000e+00 2.550176e-01 2.550176e-01
	-1.250000e+00 5.000000e-02 5.000000e-02 5.996000e+00 1.830246e-01 1.830246e-01
	-1.150000e+00 5.000000e-02 5.000000e-02 5.982000e+00 1.810249e-01 1.810249e-01
	-1.050000e+00 5.000000e-02 5.000000e-02 5.932000e+00 1.800250e-01 1.800250e-01
	-9.500000e-01 5.000000e-02 5.000000e-02 5.876000e+00 1.770254e-01 1.770254e-01
	-8.500000e-01 5.000000e-02 5.000000e-02 5.842000e+00 1.760256e-01 1.760256e-01
	-7.500000e-01 5.000000e-02 5.000000e-02 5.814000e+00 1.740259e-01 1.740259e-01
	-6.500000e-01 5.000000e-02 5.000000e-02 5.781000e+00 1.750257e-01 1.750257e-01
	-5.500000e-01 5.000000e-02 5.000000e-02 5.737000e+00 1.710263e-01 1.710263e-01
	-4.500000e-01 5.000000e-02 5.000000e-02 5.701000e+00 1.710263e-01 1.710263e-01
	-3.500000e-01 5.000000e-02 5.000000e-02 5.673000e+00 1.710263e-01 1.710263e-01
	-2.500000e-01 5.000000e-02 5.000000e-02 5.650000e+00 1.700471e-01 1.700471e-01
	-1.500000e-01 5.000000e-02 5.000000e-02 5.636000e+00 1.700471e-01 1.700471e-01
	-5.000000e-02 5.000000e-02 5.000000e-02 5.628000e+00 1.700471e-01 1.700471e-01
	5.000000e-02 5.000000e-02 5.000000e-02 5.628000e+00 1.690473e-01 1.690473e-01
	1.500000e-01 5.000000e-02 5.000000e-02 5.626000e+00 1.680268e-01 1.680268e-01
	2.500000e-01 5.000000e-02 5.000000e-02 5.641000e+00 1.680268e-01 1.680268e-01
	3.500000e-01 5.000000e-02 5.000000e-02 5.669000e+00 1.700265e-01 1.700265e-01
	4.500000e-01 5.000000e-02 5.000000e-02 5.706000e+00 1.700265e-01 1.700265e-01
	5.500000e-01 5.000000e-02 5.000000e-02 5.735000e+00 1.710263e-01 1.710263e-01
	6.500000e-01 5.000000e-02 5.000000e-02 5.780000e+00 1.720262e-01 1.720262e-01
	7.500000e-01 5.000000e-02 5.000000e-02 5.827000e+00 1.750257e-01 1.750257e-01
	8.500000e-01 5.000000e-02 5.000000e-02 5.856000e+00 1.760256e-01 1.760256e-01
	9.500000e-01 5.000000e-02 5.000000e-02 5.883000e+00 1.770254e-01 1.770254e-01
	1.050000e+00 5.000000e-02 5.000000e-02 5.943000e+00 1.800250e-01 1.800250e-01
	1.150000e+00 5.000000e-02 5.000000e-02 6.012000e+00 1.840245e-01 1.840245e-01
	1.250000e+00 5.000000e-02 5.000000e-02 6.027000e+00 1.850243e-01 1.850243e-01
	1.350000e+00 5.000000e-02 5.000000e-02 6.008000e+00 2.580174e-01 2.580174e-01
	1.450000e+00 5.000000e-02 5.000000e-02 5.954000e+00 2.560176e-01 2.560176e-01
	1.550000e+00 5.000000e-02 5.000000e-02 6.031000e+00 2.600308e-01 2.600308e-01
	1.650000e+00 5.000000e-02 5.000000e-02 6.115000e+00 2.650170e-01 2.650170e-01
	1.750000e+00 5.000000e-02 5.000000e-02 6.091000e+00 2.660169e-01 2.660169e-01
	1.850000e+00 5.000000e-02 5.000000e-02 5.985000e+00 2.600173e-01 2.600173e-01
	1.950000e+00 5.000000e-02 5.000000e-02 5.936000e+00 3.250138e-01 3.250138e-01
	2.050000e+00 5.000000e-02 5.000000e-02 6.018000e+00 3.300136e-01 3.300136e-01
	2.150000e+00 5.000000e-02 5.000000e-02 5.908000e+00 3.490129e-01 3.490129e-01
	2.250000e+00 5.000000e-02 5.000000e-02 5.930000e+00 3.500129e-01 3.500129e-01
	2.350000e+00 5.000000e-02 5.000000e-02 5.901000e+00 5.650142e-01 5.650142e-01
	2.450000e+00 5.000000e-02 5.000000e-02 5.742000e+00 5.540144e-01 5.540144e-01
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d06-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d06-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.450000e+00 5.000000e-02 5.000000e-02 1.900000e+00 1.226907e-01 1.226907e-01
	-2.350000e+00 5.000000e-02 5.000000e-02 1.962000e+00 1.256742e-01 1.256742e-01
	-2.250000e+00 5.000000e-02 5.000000e-02 2.031000e+00 6.628725e-02 6.628725e-02
	-2.150000e+00 5.000000e-02 5.000000e-02 2.034000e+00 6.824954e-02 6.824954e-02
	-2.050000e+00 5.000000e-02 5.000000e-02 2.095000e+00 6.923150e-02 6.923150e-02
	-1.950000e+00 5.000000e-02 5.000000e-02 2.116000e+00 6.923150e-02 6.923150e-02
	-1.850000e+00 5.000000e-02 5.000000e-02 2.149000e+00 4.876474e-02 4.876474e-02
	-1.750000e+00 5.000000e-02 5.000000e-02 2.230000e+00 4.972927e-02 4.972927e-02
	-1.650000e+00 5.000000e-02 5.000000e-02 2.284000e+00 5.069517e-02 5.069517e-02
	-1.550000e+00 5.000000e-02 5.000000e-02 2.301000e+00 5.166237e-02 5.166237e-02
	-1.450000e+00 5.000000e-02 5.000000e-02 2.302000e+00 5.166237e-02 5.166237e-02
	-1.350000e+00 5.000000e-02 5.000000e-02 2.291000e+00 5.166237e-02 5.166237e-02
	-1.250000e+00 5.000000e-02 5.000000e-02 2.353000e+00 3.087070e-02 3.087070e-02
	-1.150000e+00 5.000000e-02 5.000000e-02 2.354000e+00 3.087070e-02 3.087070e-02
	-1.050000e+00 5.000000e-02 5.000000e-02 2.378000e+00 3.087070e-02 3.087070e-02
	-9.500000e-01 5.000000e-02 5.000000e-02 2.368000e+00 2.996665e-02 2.996665e-02
	-8.500000e-01 5.000000e-02 5.000000e-02 2.387000e+00 2.996665e-02 2.996665e-02
	-7.500000e-01 5.000000e-02 5.000000e-02 2.378000e+00 3.087070e-02 3.087070e-02
	-6.500000e-01 5.000000e-02 5.000000e-02 2.402000e+00 3.087070e-02 3.087070e-02
	-5.500000e-01 5.000000e-02 5.000000e-02 2.376000e+00 2.996665e-02 2.996665e-02
	-4.500000e-01 5.000000e-02 5.000000e-02 2.381000e+00 2.996665e-02 2.996665e-02
	-3.500000e-01 5.000000e-02 5.000000e-02 2.383000e+00 2.996665e-02 2.996665e-02
	-2.500000e-01 5.000000e-02 5.000000e-02 2.401000e+00 2.996665e-02 2.996665e-02
	-1.500000e-01 5.000000e-02 5.000000e-02 2.377000e+00 2.996665e-02 2.996665e-02
	-5.000000e-02 5.000000e-02 5.000000e-02 2.392000e+00 3.087070e-02 3.087070e-02
	5.000000e-02 5.000000e-02 5.000000e-02 2.378000e+00 2.996665e-02 2.996665e-02
	1.500000e-01 5.000000e-02 5.000000e-02 2.371000e+00 2.996665e-02 2.996665e-02
	2.500000e-01 5.000000e-02 5.000000e-02 2.353000e+00 2.906888e-02 2.906888e-02
	3.500000e-01 5.000000e-02 5.000000e-02 2.365000e+00 2.906888e-02 2.906888e-02
	4.500000e-01 5.000000e-02 5.000000e-02 2.380000e+00 2.996665e-02 2.996665e-02
	5.500000e-01 5.000000e-02 5.000000e-02 2.366000e+00 2.996665e-02 2.996665e-02
	6.500000e-01 5.000000e-02 5.000000e-02 2.371000e+00 3.087070e-02 3.087070e-02
	7.500000e-01 5.000000e-02 5.000000e-02 2.390000e+00 2.996665e-02 2.996665e-02
	8.500000e-01 5.000000e-02 5.000000e-02 2.378000e+00 2.996665e-02 2.996665e-02
	9.500000e-01 5.000000e-02 5.000000e-02 2.378000e+00 3.087070e-02 3.087070e-02
	1.050000e+00 5.000000e-02 5.000000e-02 2.374000e+00 3.087070e-02 3.087070e-02
	1.150000e+00 5.000000e-02 5.000000e-02 2.387000e+00 3.087070e-02 3.087070e-02
	1.250000e+00 5.000000e-02 5.000000e-02 2.353000e+00 3.087070e-02 3.087070e-02
	1.350000e+00 5.000000e-02 5.000000e-02 2.313000e+00 4.972927e-02 4.972927e-02
	1.450000e+00 5.000000e-02 5.000000e-02 2.273000e+00 5.166237e-02 5.166237e-02
	1.550000e+00 5.000000e-02 5.000000e-02 2.279000e+00 5.069517e-02 5.069517e-02
	1.650000e+00 5.000000e-02 5.000000e-02 2.275000e+00 5.263079e-02 5.263079e-02
	1.750000e+00 5.000000e-02 5.000000e-02 2.246000e+00 5.096077e-02 5.096077e-02
	1.850000e+00 5.000000e-02 5.000000e-02 2.184000e+00 5.069517e-02 5.069517e-02
	1.950000e+00 5.000000e-02 5.000000e-02 2.087000e+00 6.824954e-02 6.824954e-02
	2.050000e+00 5.000000e-02 5.000000e-02 2.088000e+00 6.923150e-02 6.923150e-02
	2.150000e+00 5.000000e-02 5.000000e-02 2.093000e+00 7.021396e-02 7.021396e-02
	2.250000e+00 5.000000e-02 5.000000e-02 2.052000e+00 6.824954e-02 6.824954e-02
	2.350000e+00 5.000000e-02 5.000000e-02 1.957000e+00 1.276636e-01 1.276636e-01
	2.450000e+00 5.000000e-02 5.000000e-02 1.884000e+00 1.216963e-01 1.216963e-01
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d07-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d07-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.450000e+00 5.000000e-02 5.000000e-02 3.219000e+00 2.060218e-01 2.060218e-01
	-2.350000e+00 5.000000e-02 5.000000e-02 3.328000e+00 2.130211e-01 2.130211e-01
	-2.250000e+00 5.000000e-02 5.000000e-02 3.380000e+00 1.150391e-01 1.150391e-01
	-2.150000e+00 5.000000e-02 5.000000e-02 3.373000e+00 1.140395e-01 1.140395e-01
	-2.050000e+00 5.000000e-02 5.000000e-02 3.451000e+00 1.170385e-01 1.170385e-01
	-1.950000e+00 5.000000e-02 5.000000e-02 3.426000e+00 1.150391e-01 1.150391e-01
	-1.850000e+00 5.000000e-02 5.000000e-02 3.495000e+00 8.505292e-02 8.505292e-02
	-1.750000e+00 5.000000e-02 5.000000e-02 3.587000e+00 8.605231e-02 8.605231e-02
	-1.650000e+00 5.000000e-02 5.000000e-02 3.619000e+00 8.705171e-02 8.705171e-02
	-1.550000e+00 5.000000e-02 5.000000e-02 3.601000e+00 8.605231e-02 8.605231e-02
	-1.450000e+00 5.000000e-02 5.000000e-02 3.592000e+00 8.605231e-02 8.605231e-02
	-1.350000e+00 5.000000e-02 5.000000e-02 3.653000e+00 8.605231e-02 8.605231e-02
	-1.250000e+00 5.000000e-02 5.000000e-02 3.695000e+00 5.408327e-02 5.408327e-02
	-1.150000e+00 5.000000e-02 5.000000e-02 3.698000e+00 5.408327e-02 5.408327e-02
	-1.050000e+00 5.000000e-02 5.000000e-02 3.673000e+00 5.308484e-02 5.308484e-02
	-9.500000e-01 5.000000e-02 5.000000e-02 3.669000e+00 5.208647e-02 5.208647e-02
	-8.500000e-01 5.000000e-02 5.000000e-02 3.678000e+00 5.308484e-02 5.308484e-02
	-7.500000e-01 5.000000e-02 5.000000e-02 3.681000e+00 5.308484e-02 5.308484e-02
	-6.500000e-01 5.000000e-02 5.000000e-02 3.678000e+00 5.308484e-02 5.308484e-02
	-5.500000e-01 5.000000e-02 5.000000e-02 3.672000e+00 5.208647e-02 5.208647e-02
	-4.500000e-01 5.000000e-02 5.000000e-02 3.666000e+00 5.308484e-02 5.308484e-02
	-3.500000e-01 5.000000e-02 5.000000e-02 3.661000e+00 5.308484e-02 5.308484e-02
	-2.500000e-01 5.000000e-02 5.000000e-02 3.653000e+00 5.308484e-02 5.308484e-02
	-1.500000e-01 5.000000e-02 5.000000e-02 3.649000e+00 5.208647e-02 5.208647e-02
	-5.000000e-02 5.000000e-02 5.000000e-02 3.646000e+00 5.208647e-02 5.208647e-02
	5.000000e-02 5.000000e-02 5.000000e-02 3.641000e+00 5.208647e-02 5.208647e-02
	1.500000e-01 5.000000e-02 5.000000e-02 3.651000e+00 5.308484e-02 5.308484e-02
	2.500000e-01 5.000000e-02 5.000000e-02 3.656000e+00 5.208647e-02 5.208647e-02
	3.500000e-01 5.000000e-02 5.000000e-02 3.655000e+00 5.208647e-02 5.208647e-02
	4.500000e-01 5.000000e-02 5.000000e-02 3.667000e+00 5.308484e-02 5.308484e-02
	5.500000e-01 5.000000e-02 5.000000e-02 3.674000e+00 5.308484e-02 5.308484e-02
	6.500000e-01 5.000000e-02 5.000000e-02 3.677000e+00 5.308484e-02 5.308484e-02
	7.500000e-01 5.000000e-02 5.000000e-02 3.682000e+00 5.308484e-02 5.308484e-02
	8.500000e-01 5.000000e-02 5.000000e-02 3.678000e+00 5.308484e-02 5.308484e-02
	9.500000e-01 5.000000e-02 5.000000e-02 3.670000e+00 5.408327e-02 5.408327e-02
	1.050000e+00 5.000000e-02 5.000000e-02 3.683000e+00 5.408327e-02 5.408327e-02
	1.150000e+00 5.000000e-02 5.000000e-02 3.703000e+00 5.408327e-02 5.408327e-02
	1.250000e+00 5.000000e-02 5.000000e-02 3.677000e+00 5.408327e-02 5.408327e-02
	1.350000e+00 5.000000e-02 5.000000e-02 3.633000e+00 8.705171e-02 8.705171e-02
	1.450000e+00 5.000000e-02 5.000000e-02 3.571000e+00 8.505292e-02 8.505292e-02
	1.550000e+00 5.000000e-02 5.000000e-02 3.613000e+00 8.805112e-02 8.805112e-02
	1.650000e+00 5.000000e-02 5.000000e-02 3.621000e+00 8.705171e-02 8.705171e-02
	1.750000e+00 5.000000e-02 5.000000e-02 3.566000e+00 8.505292e-02 8.505292e-02
	1.850000e+00 5.000000e-02 5.000000e-02 3.488000e+00 8.305420e-02 8.305420e-02
	1.950000e+00 5.000000e-02 5.000000e-02 3.431000e+00 1.160388e-01 1.160388e-01
	2.050000e+00 5.000000e-02 5.000000e-02 3.467000e+00 1.170385e-01 1.170385e-01
	2.150000e+00 5.000000e-02 5.000000e-02 3.387000e+00 1.150391e-01 1.150391e-01
	2.250000e+00 5.000000e-02 5.000000e-02 3.365000e+00 1.130398e-01 1.130398e-01
	2.350000e+00 5.000000e-02 5.000000e-02 3.309000e+00 2.130211e-01 2.130211e-01
	2.450000e+00 5.000000e-02 5.000000e-02 3.195000e+00 2.060218e-01 2.060218e-01
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d08-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d08-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	5.480000e-01 4.800000e-02 5.200000e-02 9.638000e-01 2.740456e-02 2.740456e-02
	6.480000e-01 4.800000e-02 5.200000e-02 5.930000e-01 1.680476e-02 1.680476e-02
	7.480000e-01 4.800000e-02 5.200000e-02 3.764000e-01 1.070420e-02 1.070420e-02
	8.480000e-01 4.800000e-02 5.200000e-02 2.463000e-01 7.002857e-03 7.002857e-03
	9.480000e-01 4.800000e-02 5.200000e-02 1.636000e-01 4.604346e-03 4.604346e-03
	1.048000e+00 4.800000e-02 5.200000e-02 1.110000e-01 3.101612e-03 3.101612e-03
	1.148000e+00 4.800000e-02 5.200000e-02 7.654000e-02 2.151883e-03 2.151883e-03
	1.248000e+00 4.800000e-02 5.200000e-02 5.384000e-02 1.511622e-03 1.511622e-03
	1.348000e+00 4.800000e-02 5.200000e-02 3.822000e-02 1.071681e-03 1.071681e-03
	1.448000e+00 4.800000e-02 5.200000e-02 2.765000e-02 7.716217e-04 7.716217e-04
	1.548000e+00 4.800000e-02 5.200000e-02 2.031000e-02 5.614268e-04 5.614268e-04
	1.648000e+00 4.800000e-02 5.200000e-02 1.487000e-02 4.210701e-04 4.210701e-04
	1.748000e+00 4.800000e-02 5.200000e-02 1.107000e-02 3.114482e-04 3.114482e-04
	1.848000e+00 4.800000e-02 5.200000e-02 8.390000e-03 2.389247e-04 2.389247e-04
	1.948000e+00 4.800000e-02 5.200000e-02 6.342000e-03 1.778145e-04 1.778145e-04
	2.049000e+00 4.900000e-02 5.100000e-02 4.861000e-03 1.377135e-04 1.377135e-04
	2.148000e+00 4.800000e-02 5.200000e-02 3.735000e-03 1.076708e-04 1.076708e-04
	2.248000e+00 4.800000e-02 5.200000e-02 2.895000e-03 8.161495e-05 8.161495e-05
	2.348000e+00 4.800000e-02 5.200000e-02 2.232000e-03 6.562012e-05 6.562012e-05
	2.448000e+00 4.800000e-02 5.200000e-02 1.806000e-03 5.346027e-05 5.346027e-05
	2.616000e+00 1.160000e-01 1.340000e-01 1.185000e-03 3.337664e-05 3.337664e-05
	2.867000e+00 1.170000e-01 1.330000e-01 7.024000e-04 2.012461e-05 2.012461e-05
	3.116000e+00 1.160000e-01 1.340000e-01 4.301000e-04 1.306139e-05 1.306139e-05
	3.365000e+00 1.150000e-01 1.350000e-01 2.584000e-04 7.736924e-06 7.736924e-06
	3.721000e+00 2.210000e-01 2.790000e-01 1.330000e-04 3.905125e-06 3.905125e-06
	4.384000e+00 3.840000e-01 6.160000e-01 4.029000e-05 1.314686e-06 1.314686e-06
	5.404000e+00 4.040000e-01 5.960000e-01 9.232000e-06 5.546675e-07 5.546675e-07
	6.692000e+00 6.920000e-01 1.308000e+00 1.914000e-06 9.123596e-08 9.123596e-08
	8.777000e+00 7.770000e-01 1.223000e+00 3.004000e-07 1.588364e-08 1.588364e-08
	1.170000e+01 1.700000e+00 3.300000e+00 4.985000e-08 1.164270e-08 6.155104e-09
	1.604000e+01 1.040000e+00 3.960000e+00 5.203000e-09 1.371745e-09 9.030670e-10
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d09-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d09-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	5.480000e-01 4.800000e-02 5.200000e-02 1.093000e+00 1.086646e-01 1.086646e-01
	6.480000e-01 4.800000e-02 5.200000e-02 6.895000e-01 6.793386e-02 6.793386e-02
	7.480000e-01 4.800000e-02 5.200000e-02 4.322000e-01 4.275196e-02 4.275196e-02
	8.480000e-01 4.800000e-02 5.200000e-02 2.988000e-01 2.969057e-02 2.969057e-02
	9.480000e-01 4.800000e-02 5.200000e-02 2.002000e-01 2.004445e-02 2.004445e-02
	1.049000e+00 4.900000e-02 5.100000e-02 1.477000e-01 1.492548e-02 1.492548e-02
	1.147000e+00 4.700000e-02 5.300000e-02 9.648000e-02 9.856698e-03 9.856698e-03
	1.248000e+00 4.800000e-02 5.200000e-02 7.164000e-02 7.398865e-03 7.398865e-03
	1.348000e+00 4.800000e-02 5.200000e-02 5.297000e-02 5.558282e-03 5.558282e-03
	1.449000e+00 4.900000e-02 5.100000e-02 3.747000e-02 4.016217e-03 4.016217e-03
	1.615000e+00 1.150000e-01 1.350000e-01 2.449000e-02 2.490984e-03 2.490984e-03
	1.865000e+00 1.150000e-01 1.350000e-01 1.280000e-02 1.347145e-03 1.347145e-03
	2.114000e+00 1.140000e-01 1.360000e-01 6.779000e-03 7.512317e-04 7.512317e-04
	2.369000e+00 1.190000e-01 1.310000e-01 4.089000e-03 4.776275e-04 4.776275e-04
	2.616000e+00 1.160000e-01 1.340000e-01 2.218000e-03 2.841918e-04 2.841918e-04
	2.863000e+00 1.130000e-01 1.370000e-01 1.399000e-03 1.975171e-04 1.975171e-04
	3.221000e+00 2.210000e-01 2.790000e-01 6.531000e-04 8.723359e-05 8.723359e-05
	3.741000e+00 2.410000e-01 2.590000e-01 2.486000e-04 4.309907e-05 4.309907e-05
	4.249000e+00 2.490000e-01 2.510000e-01 1.290000e-04 2.764869e-05 2.764869e-05
	4.712000e+00 2.120000e-01 2.880000e-01 7.519000e-05 2.034347e-05 2.034347e-05
	5.821000e+00 8.210000e-01 1.179000e+00 2.471000e-05 5.289159e-06 5.289159e-06
	7.911000e+00 9.110000e-01 2.089000e+00 1.442000e-06 9.234815e-07 9.234815e-07
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d10-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d10-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	5.480000e-01 4.800000e-02 5.200000e-02 1.483000e+00 4.400000e-02 4.400000e-02
	6.480000e-01 4.800000e-02 5.200000e-02 9.568000e-01 2.800071e-02 2.800071e-02
	7.480000e-01 4.800000e-02 5.200000e-02 6.378000e-01 1.880027e-02 1.880027e-02
	8.480000e-01 4.800000e-02 5.200000e-02 4.364000e-01 1.280039e-02 1.280039e-02
	9.480000e-01 4.800000e-02 5.200000e-02 3.054000e-01 8.900562e-03 8.900562e-03
	1.048000e+00 4.800000e-02 5.200000e-02 2.178000e-01 6.400781e-03 6.400781e-03
	1.148000e+00 4.800000e-02 5.200000e-02 1.582000e-01 4.600000e-03 4.600000e-03
	1.248000e+00 4.800000e-02 5.200000e-02 1.163000e-01 3.400000e-03 3.400000e-03
	1.348000e+00 4.800000e-02 5.200000e-02 8.688000e-02 2.530178e-03 2.530178e-03
	1.448000e+00 4.800000e-02 5.200000e-02 6.547000e-02 1.910105e-03 1.910105e-03
	1.548000e+00 4.800000e-02 5.200000e-02 4.996000e-02 1.460137e-03 1.460137e-03
	1.648000e+00 4.800000e-02 5.200000e-02 3.840000e-02 1.120045e-03 1.120045e-03
	1.749000e+00 4.900000e-02 5.100000e-02 2.984000e-02 8.700575e-04 8.700575e-04
	1.849000e+00 4.900000e-02 5.100000e-02 2.341000e-02 6.800735e-04 6.800735e-04
	1.949000e+00 4.900000e-02 5.100000e-02 1.843000e-02 5.400926e-04 5.400926e-04
	2.049000e+00 4.900000e-02 5.100000e-02 1.463000e-02 4.301163e-04 4.301163e-04
	2.149000e+00 4.900000e-02 5.100000e-02 1.170000e-02 3.401470e-04 3.401470e-04
	2.249000e+00 4.900000e-02 5.100000e-02 9.385000e-03 2.730458e-04 2.730458e-04
	2.349000e+00 4.900000e-02 5.100000e-02 7.598000e-03 2.220563e-04 2.220563e-04
	2.449000e+00 4.900000e-02 5.100000e-02 6.195000e-03 1.820440e-04 1.820440e-04
	2.617000e+00 1.170000e-01 1.330000e-01 4.381000e-03 1.270354e-04 1.270354e-04
	2.867000e+00 1.170000e-01 1.330000e-01 2.729000e-03 7.902531e-05 7.902531e-05
	3.118000e+00 1.180000e-01 1.320000e-01 1.746000e-03 5.100980e-05 5.100980e-05
	3.368000e+00 1.180000e-01 1.320000e-01 1.140000e-03 3.301515e-05 3.301515e-05
	3.725000e+00 2.250000e-01 2.750000e-01 6.419000e-04 1.850676e-05 1.850676e-05
	4.227000e+00 2.270000e-01 2.730000e-01 3.103000e-04 9.004999e-06 9.004999e-06
	4.729000e+00 2.290000e-01 2.710000e-01 1.612000e-04 4.804165e-06 4.804165e-06
	5.427000e+00 4.270000e-01 5.730000e-01 6.973000e-05 2.072921e-06 2.072921e-06
	6.436000e+00 4.360000e-01 5.640000e-01 2.506000e-05 7.117584e-07 7.117584e-07
	7.442000e+00 4.420000e-01 5.580000e-01 1.059000e-05 3.114482e-07 3.114482e-07
	8.456000e+00 4.560000e-01 5.440000e-01 4.933000e-06 3.234471e-07 3.234471e-07
	9.454000e+00 4.540000e-01 5.460000e-01 2.530000e-06 1.603777e-07 1.603777e-07
	1.168000e+01 1.680000e+00 3.320000e+00 6.136000e-07 9.063178e-08 6.724284e-08
	1.692000e+01 1.920000e+00 3.080000e+00 6.851000e-08 9.923114e-09 7.237990e-09
	2.337000e+01 3.370000e+00 6.630000e+00 9.516000e-09 2.273662e-09 1.261612e-09
	3.611000e+01 6.110000e+00 1.389000e+01 6.630000e-10 2.122716e-10 7.716994e-11
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d11-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d11-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.260000e-01 2.600000e-02 2.400000e-02 7.778000e+00 8.580210e-01 8.580210e-01
	1.750000e-01 2.500000e-02 2.500000e-02 6.615000e+00 3.990313e-01 3.990313e-01
	2.250000e-01 2.500000e-02 2.500000e-02 5.158000e+00 2.480181e-01 2.480181e-01
	2.750000e-01 2.500000e-02 2.500000e-02 3.940000e+00 1.540130e-01 1.540130e-01
	3.250000e-01 2.500000e-02 2.500000e-02 2.981000e+00 1.090183e-01 1.090183e-01
	3.750000e-01 2.500000e-02 2.500000e-02 2.271000e+00 8.000625e-02 8.000625e-02
	4.250000e-01 2.500000e-02 2.500000e-02 1.734000e+00 5.500909e-02 5.500909e-02
	4.750000e-01 2.500000e-02 2.500000e-02 1.327000e+00 4.001250e-02 4.001250e-02
	5.480000e-01 4.800000e-02 5.200000e-02 9.134000e-01 2.750455e-02 2.750455e-02
	6.480000e-01 4.800000e-02 5.200000e-02 5.625000e-01 1.690473e-02 1.690473e-02
	7.480000e-01 4.800000e-02 5.200000e-02 3.564000e-01 1.070420e-02 1.070420e-02
	8.480000e-01 4.800000e-02 5.200000e-02 2.334000e-01 7.002857e-03 7.002857e-03
	9.480000e-01 4.800000e-02 5.200000e-02 1.549000e-01 4.601087e-03 4.601087e-03
	1.048000e+00 4.800000e-02 5.200000e-02 1.050000e-01 3.101612e-03 3.101612e-03
	1.148000e+00 4.800000e-02 5.200000e-02 7.250000e-02 2.151883e-03 2.151883e-03
	1.248000e+00 4.800000e-02 5.200000e-02 5.101000e-02 1.511622e-03 1.511622e-03
	1.348000e+00 4.800000e-02 5.200000e-02 3.620000e-02 1.071681e-03 1.071681e-03
	1.448000e+00 4.800000e-02 5.200000e-02 2.620000e-02 7.710383e-04 7.710383e-04
	1.548000e+00 4.800000e-02 5.200000e-02 1.925000e-02 5.614268e-04 5.614268e-04
	1.648000e+00 4.800000e-02 5.200000e-02 1.409000e-02 4.210701e-04 4.210701e-04
	1.748000e+00 4.800000e-02 5.200000e-02 1.049000e-02 3.106445e-04 3.106445e-04
	1.848000e+00 4.800000e-02 5.200000e-02 7.954000e-03 2.378424e-04 2.378424e-04
	1.948000e+00 4.800000e-02 5.200000e-02 6.018000e-03 1.787177e-04 1.787177e-04
	2.049000e+00 4.900000e-02 5.100000e-02 4.608000e-03 1.377135e-04 1.377135e-04
	2.148000e+00 4.800000e-02 5.200000e-02 3.545000e-03 1.076708e-04 1.076708e-04
	2.248000e+00 4.800000e-02 5.200000e-02 2.745000e-03 8.260751e-05 8.260751e-05
	2.348000e+00 4.800000e-02 5.200000e-02 2.118000e-03 6.648308e-05 6.648308e-05
	2.448000e+00 4.800000e-02 5.200000e-02 1.714000e-03 5.346027e-05 5.346027e-05
	2.616000e+00 1.160000e-01 1.340000e-01 1.124000e-03 3.337664e-05 3.337664e-05
	2.867000e+00 1.170000e-01 1.330000e-01 6.666000e-04 2.058276e-05 2.058276e-05
	3.116000e+00 1.160000e-01 1.340000e-01 4.086000e-04 1.245351e-05 1.245351e-05
	3.365000e+00 1.150000e-01 1.350000e-01 2.455000e-04 9.963935e-06 9.963935e-06
	3.721000e+00 2.210000e-01 2.790000e-01 1.259000e-04 5.953990e-06 5.953990e-06
	4.384000e+00 3.840000e-01 6.160000e-01 3.829000e-05 2.853769e-06 2.853769e-06
	5.404000e+00 4.040000e-01 5.960000e-01 8.766000e-06 4.297872e-07 4.297872e-07
	6.693000e+00 6.930000e-01 1.307000e+00 1.814000e-06 8.407735e-08 8.407735e-08
	8.776000e+00 7.760000e-01 1.224000e+00 2.869000e-07 2.492429e-08 2.492429e-08
	1.170000e+01 1.700000e+00 3.300000e+00 4.744000e-08 1.115233e-08 5.928718e-09
	1.604000e+01 1.040000e+00 3.960000e+00 4.959000e-09 1.329701e-09 8.895684e-10
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d12-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d12-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.260000e-01 2.600000e-02 2.400000e-02 1.217000e+01 1.350037e+00 1.350037e+00
	1.750000e-01 2.500000e-02 2.500000e-02 1.008000e+01 6.000000e-01 6.000000e-01
	2.250000e-01 2.500000e-02 2.500000e-02 7.657000e+00 3.720013e-01 3.720013e-01
	2.750000e-01 2.500000e-02 2.500000e-02 5.779000e+00 2.290022e-01 2.290022e-01
	3.250000e-01 2.500000e-02 2.500000e-02 4.382000e+00 1.620031e-01 1.620031e-01
	3.750000e-01 2.500000e-02 2.500000e-02 3.354000e+00 1.190042e-01 1.190042e-01
	4.250000e-01 2.500000e-02 2.500000e-02 2.594000e+00 8.300000e-02 8.300000e-02
	4.750000e-01 2.500000e-02 2.500000e-02 2.025000e+00 6.100000e-02 6.100000e-02
	5.480000e-01 4.800000e-02 5.200000e-02 1.431000e+00 4.300000e-02 4.300000e-02
	6.480000e-01 4.800000e-02 5.200000e-02 9.245000e-01 2.820018e-02 2.820018e-02
	7.480000e-01 4.800000e-02 5.200000e-02 6.159000e-01 1.870027e-02 1.870027e-02
	8.480000e-01 4.800000e-02 5.200000e-02 4.217000e-01 1.280039e-02 1.280039e-02
	9.480000e-01 4.800000e-02 5.200000e-02 2.950000e-01 8.900562e-03 8.900562e-03
	1.048000e+00 4.800000e-02 5.200000e-02 2.105000e-01 6.400000e-03 6.400000e-03
	1.148000e+00 4.800000e-02 5.200000e-02 1.530000e-01 4.600000e-03 4.600000e-03
	1.248000e+00 4.800000e-02 5.200000e-02 1.125000e-01 3.400000e-03 3.400000e-03
	1.348000e+00 4.800000e-02 5.200000e-02 8.408000e-02 2.530079e-03 2.530079e-03
	1.448000e+00 4.800000e-02 5.200000e-02 6.345000e-02 1.900105e-03 1.900105e-03
	1.548000e+00 4.800000e-02 5.200000e-02 4.841000e-02 1.450138e-03 1.450138e-03
	1.648000e+00 4.800000e-02 5.200000e-02 3.722000e-02 1.120045e-03 1.120045e-03
	1.749000e+00 4.900000e-02 5.100000e-02 2.892000e-02 8.700575e-04 8.700575e-04
	1.849000e+00 4.900000e-02 5.100000e-02 2.270000e-02 6.800735e-04 6.800735e-04
	1.949000e+00 4.900000e-02 5.100000e-02 1.788000e-02 5.400926e-04 5.400926e-04
	2.049000e+00 4.900000e-02 5.100000e-02 1.420000e-02 4.301163e-04 4.301163e-04
	2.149000e+00 4.900000e-02 5.100000e-02 1.134000e-02 3.401470e-04 3.401470e-04
	2.249000e+00 4.900000e-02 5.100000e-02 9.112000e-03 2.730458e-04 2.730458e-04
	2.349000e+00 4.900000e-02 5.100000e-02 7.383000e-03 2.220360e-04 2.220360e-04
	2.449000e+00 4.900000e-02 5.100000e-02 6.012000e-03 1.820440e-04 1.820440e-04
	2.617000e+00 1.170000e-01 1.330000e-01 4.258000e-03 1.270157e-04 1.270157e-04
	2.867000e+00 1.170000e-01 1.330000e-01 2.653000e-03 7.902531e-05 7.902531e-05
	3.118000e+00 1.180000e-01 1.320000e-01 1.697000e-03 5.100980e-05 5.100980e-05
	3.368000e+00 1.180000e-01 1.320000e-01 1.108000e-03 3.301515e-05 3.301515e-05
	3.725000e+00 2.250000e-01 2.750000e-01 6.244000e-04 1.870668e-05 1.870668e-05
	4.227000e+00 2.270000e-01 2.730000e-01 3.017000e-04 1.030437e-05 1.030437e-05
	4.729000e+00 2.290000e-01 2.710000e-01 1.567000e-04 6.103278e-06 6.103278e-06
	5.427000e+00 4.270000e-01 5.730000e-01 6.770000e-05 2.141892e-06 2.141892e-06
	6.436000e+00 4.360000e-01 5.640000e-01 2.438000e-05 8.814193e-07 8.814193e-07
	7.442000e+00 4.420000e-01 5.580000e-01 1.026000e-05 3.805260e-07 3.805260e-07
	8.456000e+00 4.560000e-01 5.440000e-01 4.777000e-06 2.714148e-07 2.714148e-07
	9.454000e+00 4.540000e-01 5.460000e-01 2.461000e-06 1.073778e-07 1.073778e-07
	1.168000e+01 1.680000e+00 3.320000e+00 5.960000e-07 8.772514e-08 6.463412e-08
	1.692000e+01 1.920000e+00 3.080000e+00 6.661000e-08 9.691894e-09 7.076298e-09
	2.337000e+01 3.370000e+00 6.630000e+00 9.215000e-09 2.125562e-09 1.074066e-09
	3.611000e+01 6.110000e+00 1.389000e+01 6.453000e-10 2.081448e-10 7.800801e-11
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d13-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d13-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	5.480000e-01 4.800000e-02 5.200000e-02 1.573000e+00 3.501428e-02 3.501428e-02
	6.480000e-01 4.800000e-02 5.200000e-02 9.893000e-01 2.171129e-02 2.171129e-02
	7.480000e-01 4.800000e-02 5.200000e-02 6.398000e-01 1.360919e-02 1.360919e-02
	8.480000e-01 4.800000e-02 5.200000e-02 4.289000e-01 8.908984e-03 8.908984e-03
	9.480000e-01 4.800000e-02 5.200000e-02 2.902000e-01 5.807753e-03 5.807753e-03
	1.048000e+00 4.800000e-02 5.200000e-02 2.003000e-01 3.905125e-03 3.905125e-03
	1.148000e+00 4.800000e-02 5.200000e-02 1.400000e-01 2.707397e-03 2.707397e-03
	1.248000e+00 4.800000e-02 5.200000e-02 1.002000e-01 1.902630e-03 1.902630e-03
	1.348000e+00 4.800000e-02 5.200000e-02 7.198000e-02 1.305527e-03 1.305527e-03
	1.448000e+00 4.800000e-02 5.200000e-02 5.272000e-02 9.453042e-04 9.453042e-04
	1.548000e+00 4.800000e-02 5.200000e-02 3.908000e-02 6.846897e-04 6.846897e-04
	1.648000e+00 4.800000e-02 5.200000e-02 2.886000e-02 5.035871e-04 5.035871e-04
	1.748000e+00 4.800000e-02 5.200000e-02 2.172000e-02 3.634556e-04 3.634556e-04
	1.848000e+00 4.800000e-02 5.200000e-02 1.659000e-02 2.828427e-04 2.828427e-04
	1.949000e+00 4.900000e-02 5.100000e-02 1.267000e-02 2.137756e-04 2.137756e-04
	2.049000e+00 4.900000e-02 5.100000e-02 9.734000e-03 1.619938e-04 1.619938e-04
	2.148000e+00 4.800000e-02 5.200000e-02 7.529000e-03 1.237619e-04 1.237619e-04
	2.248000e+00 4.800000e-02 5.200000e-02 5.835000e-03 9.556673e-05 9.556673e-05
	2.348000e+00 4.800000e-02 5.200000e-02 4.529000e-03 7.930952e-05 7.930952e-05
	2.448000e+00 4.800000e-02 5.200000e-02 3.697000e-03 6.306346e-05 6.306346e-05
	2.616000e+00 1.160000e-01 1.340000e-01 2.441000e-03 3.956008e-05 3.956008e-05
	2.867000e+00 1.170000e-01 1.330000e-01 1.447000e-03 2.340940e-05 2.340940e-05
	3.116000e+00 1.160000e-01 1.340000e-01 8.957000e-04 1.585970e-05 1.585970e-05
	3.365000e+00 1.150000e-01 1.350000e-01 5.416000e-04 8.635392e-06 8.635392e-06
	3.723000e+00 2.230000e-01 2.770000e-01 2.790000e-04 4.609772e-06 4.609772e-06
	4.386000e+00 3.860000e-01 6.140000e-01 8.651000e-05 1.675470e-06 1.675470e-06
	5.404000e+00 4.040000e-01 5.960000e-01 1.961000e-05 8.653901e-07 8.653901e-07
	6.694000e+00 6.940000e-01 1.306000e+00 4.194000e-06 1.337946e-07 1.337946e-07
	8.784000e+00 7.840000e-01 1.216000e+00 6.755000e-07 2.810000e-08 2.810000e-08
	1.169000e+01 1.690000e+00 3.310000e+00 1.055000e-07 2.289629e-08 1.132299e-08
	1.632000e+01 1.320000e+00 3.680000e+00 9.252000e-09 2.398673e-09 1.622074e-09
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d14-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d14-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	5.480000e-01 4.800000e-02 5.200000e-02 2.128000e+00 5.200000e-02 5.200000e-02
	6.480000e-01 4.800000e-02 5.200000e-02 1.391000e+00 3.300000e-02 3.300000e-02
	7.480000e-01 4.800000e-02 5.200000e-02 9.390000e-01 2.230090e-02 2.230090e-02
	8.480000e-01 4.800000e-02 5.200000e-02 6.502000e-01 1.510033e-02 1.510033e-02
	9.480000e-01 4.800000e-02 5.200000e-02 4.597000e-01 1.060047e-02 1.060047e-02
	1.048000e+00 4.800000e-02 5.200000e-02 3.309000e-01 7.500667e-03 7.500667e-03
	1.148000e+00 4.800000e-02 5.200000e-02 2.422000e-01 5.400926e-03 5.400926e-03
	1.248000e+00 4.800000e-02 5.200000e-02 1.792000e-01 4.001250e-03 4.001250e-03
	1.348000e+00 4.800000e-02 5.200000e-02 1.346000e-01 3.000000e-03 3.000000e-03
	1.448000e+00 4.800000e-02 5.200000e-02 1.020000e-01 2.200000e-03 2.200000e-03
	1.548000e+00 4.800000e-02 5.200000e-02 7.812000e-02 1.690266e-03 1.690266e-03
	1.649000e+00 4.900000e-02 5.100000e-02 6.025000e-02 1.300154e-03 1.300154e-03
	1.749000e+00 4.900000e-02 5.100000e-02 4.700000e-02 1.010198e-03 1.010198e-03
	1.849000e+00 4.900000e-02 5.100000e-02 3.694000e-02 7.902531e-04 7.902531e-04
	1.949000e+00 4.900000e-02 5.100000e-02 2.915000e-02 6.200806e-04 6.200806e-04
	2.049000e+00 4.900000e-02 5.100000e-02 2.319000e-02 4.901020e-04 4.901020e-04
	2.149000e+00 4.900000e-02 5.100000e-02 1.857000e-02 3.901282e-04 3.901282e-04
	2.249000e+00 4.900000e-02 5.100000e-02 1.493000e-02 3.101612e-04 3.101612e-04
	2.349000e+00 4.900000e-02 5.100000e-02 1.211000e-02 2.501999e-04 2.501999e-04
	2.449000e+00 4.900000e-02 5.100000e-02 9.884000e-03 2.080865e-04 2.080865e-04
	2.617000e+00 1.170000e-01 1.330000e-01 7.001000e-03 1.440555e-04 1.440555e-04
	2.867000e+00 1.170000e-01 1.330000e-01 4.375000e-03 9.004999e-05 9.004999e-05
	3.118000e+00 1.180000e-01 1.320000e-01 2.804000e-03 5.703508e-05 5.703508e-05
	3.368000e+00 1.180000e-01 1.320000e-01 1.833000e-03 3.805260e-05 3.805260e-05
	3.725000e+00 2.250000e-01 2.750000e-01 1.035000e-03 2.102380e-05 2.102380e-05
	4.227000e+00 2.270000e-01 2.730000e-01 5.015000e-04 1.021225e-05 1.021225e-05
	4.729000e+00 2.290000e-01 2.710000e-01 2.612000e-04 5.408327e-06 5.408327e-06
	5.427000e+00 4.270000e-01 5.730000e-01 1.131000e-04 2.308679e-06 2.308679e-06
	6.436000e+00 4.360000e-01 5.640000e-01 4.077000e-05 7.851751e-07 7.851751e-07
	7.442000e+00 4.420000e-01 5.580000e-01 1.722000e-05 3.535534e-07 3.535534e-07
	8.456000e+00 4.560000e-01 5.440000e-01 8.044000e-06 4.518683e-07 4.518683e-07
	9.455000e+00 4.550000e-01 5.450000e-01 4.128000e-06 2.167487e-07 2.167487e-07
	1.168000e+01 1.680000e+00 3.320000e+00 1.003000e-06 1.390575e-07 1.000800e-07
	1.692000e+01 1.920000e+00 3.080000e+00 1.123000e-07 1.522104e-08 1.082959e-08
	2.336000e+01 3.360000e+00 6.640000e+00 1.554000e-08 3.556206e-09 1.901631e-09
	3.614000e+01 6.140000e+00 1.386000e+01 1.080000e-09 3.351612e-10 1.144902e-10
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d15-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d15-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.000000e+00 5.000000e-01 5.000000e-01 1.320000e-01 3.157531e-03 3.157531e-03
	2.000000e+00 5.000000e-01 5.000000e-01 1.278000e-01 2.473863e-03 2.473863e-03
	3.000000e+00 5.000000e-01 5.000000e-01 1.161000e-01 1.431782e-03 1.523155e-03
	4.000000e+00 5.000000e-01 5.000000e-01 9.957000e-02 9.102198e-04 9.102198e-04
	5.000000e+00 5.000000e-01 5.000000e-01 8.282000e-02 5.643580e-04 5.643580e-04
	6.000000e+00 5.000000e-01 5.000000e-01 6.837000e-02 4.410215e-04 4.404543e-04
	7.000000e+00 5.000000e-01 5.000000e-01 5.713000e-02 4.237924e-04 4.176123e-04
	8.000000e+00 5.000000e-01 5.000000e-01 4.810000e-02 4.356604e-04 4.304649e-04
	9.000000e+00 5.000000e-01 5.000000e-01 4.088000e-02 4.738143e-04 4.669047e-04
	1.000000e+01 5.000000e-01 5.000000e-01 3.492000e-02 5.060632e-04 5.060632e-04
	1.100000e+01 5.000000e-01 5.000000e-01 2.996000e-02 5.269725e-04 5.269725e-04
	1.200000e+01 5.000000e-01 5.000000e-01 2.568000e-02 5.507268e-04 5.507268e-04
	1.300000e+01 5.000000e-01 5.000000e-01 2.190000e-02 5.769749e-04 5.679789e-04
	1.400000e+01 5.000000e-01 5.000000e-01 1.851000e-02 5.685948e-04 5.685948e-04
	1.500000e+01 5.000000e-01 5.000000e-01 1.572000e-02 5.423099e-04 5.423099e-04
	1.600000e+01 5.000000e-01 5.000000e-01 1.326000e-02 4.884670e-04 4.884670e-04
	1.700000e+01 5.000000e-01 5.000000e-01 1.108000e-02 4.386342e-04 4.386342e-04
	1.800000e+01 5.000000e-01 5.000000e-01 9.436000e-03 3.937766e-04 3.946860e-04
	1.900000e+01 5.000000e-01 5.000000e-01 8.011000e-03 3.692831e-04 3.692831e-04
	2.000000e+01 5.000000e-01 5.000000e-01 6.754000e-03 3.512449e-04 3.521647e-04
	2.100000e+01 5.000000e-01 5.000000e-01 5.682000e-03 3.340808e-04 3.350060e-04
	2.200000e+01 5.000000e-01 5.000000e-01 4.789000e-03 3.141974e-04 3.141974e-04
	2.300000e+01 5.000000e-01 5.000000e-01 3.970000e-03 2.872716e-04 2.872716e-04
	2.400000e+01 5.000000e-01 5.000000e-01 3.272000e-03 2.575597e-04 2.584879e-04
	2.500000e+01 5.000000e-01 5.000000e-01 2.695000e-03 2.282323e-04 2.291572e-04
	2.600000e+01 5.000000e-01 5.000000e-01 2.186000e-03 1.993239e-04 1.993239e-04
	2.700000e+01 5.000000e-01 5.000000e-01 1.774000e-03 1.723079e-04 1.723079e-04
	2.800000e+01 5.000000e-01 5.000000e-01 1.444000e-03 1.484992e-04 1.494021e-04
	2.900000e+01 5.000000e-01 5.000000e-01 1.195000e-03 1.296919e-04 1.305871e-04
	3.000000e+01 5.000000e-01 5.000000e-01 9.797000e-04 1.118882e-04 1.124179e-04
	3.100000e+01 5.000000e-01 5.000000e-01 7.843000e-04 9.513464e-05 9.556908e-05
	3.286000e+01 1.360000e+00 1.640000e+00 5.280000e-04 6.401008e-05 6.438517e-05
	3.655000e+01 2.050000e+00 2.950000e+00 2.220000e-04 3.174161e-05 3.192883e-05
	4.269000e+01 3.190000e+00 6.810000e+00 4.490000e-05 7.372069e-06 7.494865e-06
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d16-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d16-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.000000e+00 5.000000e-01 5.000000e-01 1.165000e-01 1.484891e-02 1.484891e-02
	2.000000e+00 5.000000e-01 5.000000e-01 1.072000e-01 6.539113e-03 6.539113e-03
	3.000000e+00 5.000000e-01 5.000000e-01 9.541000e-02 4.242641e-03 4.242641e-03
	4.000000e+00 5.000000e-01 5.000000e-01 8.434000e-02 4.128656e-03 4.128656e-03
	5.000000e+00 5.000000e-01 5.000000e-01 7.219000e-02 3.506294e-03 3.506294e-03
	6.000000e+00 5.000000e-01 5.000000e-01 6.204000e-02 2.767255e-03 2.767255e-03
	7.000000e+00 5.000000e-01 5.000000e-01 5.307000e-02 2.135814e-03 2.135814e-03
	8.000000e+00 5.000000e-01 5.000000e-01 4.556000e-02 1.736663e-03 1.736663e-03
	9.000000e+00 5.000000e-01 5.000000e-01 4.006000e-02 1.509868e-03 1.509868e-03
	1.000000e+01 5.000000e-01 5.000000e-01 3.472000e-02 1.338693e-03 1.338693e-03
	1.100000e+01 5.000000e-01 5.000000e-01 3.089000e-02 1.239879e-03 1.239879e-03
	1.200000e+01 5.000000e-01 5.000000e-01 2.743000e-02 1.155206e-03 1.155206e-03
	1.300000e+01 5.000000e-01 5.000000e-01 2.499000e-02 1.106345e-03 1.106345e-03
	1.400000e+01 5.000000e-01 5.000000e-01 2.237000e-02 1.029417e-03 1.029417e-03
	1.500000e+01 5.000000e-01 5.000000e-01 1.975000e-02 9.590099e-04 9.590099e-04
	1.600000e+01 5.000000e-01 5.000000e-01 1.831000e-02 9.464143e-04 9.464143e-04
	1.700000e+01 5.000000e-01 5.000000e-01 1.648000e-02 9.060353e-04 9.060353e-04
	1.800000e+01 5.000000e-01 5.000000e-01 1.481000e-02 8.741853e-04 8.741853e-04
	1.900000e+01 5.000000e-01 5.000000e-01 1.332000e-02 8.405355e-04 8.405355e-04
	2.000000e+01 5.000000e-01 5.000000e-01 1.179000e-02 8.070936e-04 8.070936e-04
	2.100000e+01 5.000000e-01 5.000000e-01 1.050000e-02 7.600658e-04 7.600658e-04
	2.200000e+01 5.000000e-01 5.000000e-01 9.117000e-03 7.139090e-04 7.139090e-04
	2.300000e+01 5.000000e-01 5.000000e-01 8.343000e-03 6.985564e-04 6.985564e-04
	2.400000e+01 5.000000e-01 5.000000e-01 7.289000e-03 6.443268e-04 6.443268e-04
	2.500000e+01 5.000000e-01 5.000000e-01 6.565000e-03 6.163668e-04 6.163668e-04
	2.600000e+01 5.000000e-01 5.000000e-01 5.727000e-03 5.702359e-04 5.702359e-04
	2.700000e+01 5.000000e-01 5.000000e-01 4.990000e-03 5.191310e-04 5.191310e-04
	2.800000e+01 5.000000e-01 5.000000e-01 4.359000e-03 4.795498e-04 4.795498e-04
	2.900000e+01 5.000000e-01 5.000000e-01 3.840000e-03 4.450944e-04 4.450944e-04
	3.000000e+01 5.000000e-01 5.000000e-01 3.507000e-03 4.194532e-04 4.194532e-04
	-6.359000e+01 4.090000e+00 5.910000e+00 4.846000e-05 5.227577e-05 5.227577e-05
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d17-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d17-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.000000e+00 5.000000e-01 5.000000e-01 8.928000e-02 2.081946e-03 2.081946e-03
	2.000000e+00 5.000000e-01 5.000000e-01 8.833000e-02 1.642468e-03 1.642468e-03
	3.000000e+00 5.000000e-01 5.000000e-01 8.111000e-02 1.113643e-03 1.123610e-03
	4.000000e+00 5.000000e-01 5.000000e-01 7.097000e-02 6.946222e-04 6.946222e-04
	5.000000e+00 5.000000e-01 5.000000e-01 6.035000e-02 4.570558e-04 4.472136e-04
	6.000000e+00 5.000000e-01 5.000000e-01 5.190000e-02 3.275668e-04 3.178050e-04
	7.000000e+00 5.000000e-01 5.000000e-01 4.516000e-02 2.500000e-04 2.404163e-04
	8.000000e+00 5.000000e-01 5.000000e-01 3.998000e-02 1.897367e-04 1.897367e-04
	9.000000e+00 5.000000e-01 5.000000e-01 3.595000e-02 1.615549e-04 1.523155e-04
	1.000000e+01 5.000000e-01 5.000000e-01 3.268000e-02 1.252996e-04 1.252996e-04
	1.100000e+01 5.000000e-01 5.000000e-01 2.968000e-02 9.433981e-05 8.602325e-05
	1.200000e+01 5.000000e-01 5.000000e-01 2.746000e-02 7.810250e-05 6.403124e-05
	1.300000e+01 5.000000e-01 5.000000e-01 2.530000e-02 6.403124e-05 5.099020e-05
	1.400000e+01 5.000000e-01 5.000000e-01 2.345000e-02 6.403124e-05 5.099020e-05
	1.500000e+01 5.000000e-01 5.000000e-01 2.173000e-02 7.071068e-05 6.403124e-05
	1.600000e+01 5.000000e-01 5.000000e-01 2.018000e-02 8.602325e-05 7.810250e-05
	1.700000e+01 5.000000e-01 5.000000e-01 1.877000e-02 9.848858e-05 8.944272e-05
	1.800000e+01 5.000000e-01 5.000000e-01 1.745000e-02 1.170470e-04 1.077033e-04
	1.900000e+01 5.000000e-01 5.000000e-01 1.625000e-02 1.264911e-04 1.264911e-04
	2.000000e+01 5.000000e-01 5.000000e-01 1.512000e-02 1.456022e-04 1.360147e-04
	2.100000e+01 5.000000e-01 5.000000e-01 1.410000e-02 1.552417e-04 1.552417e-04
	2.200000e+01 5.000000e-01 5.000000e-01 1.311000e-02 1.649242e-04 1.649242e-04
	2.300000e+01 5.000000e-01 5.000000e-01 1.227000e-02 1.746425e-04 1.746425e-04
	2.400000e+01 5.000000e-01 5.000000e-01 1.133000e-02 1.824829e-04 1.824829e-04
	2.500000e+01 5.000000e-01 5.000000e-01 1.058000e-02 1.923538e-04 1.824829e-04
	2.600000e+01 5.000000e-01 5.000000e-01 9.784000e-03 1.934994e-04 1.934994e-04
	2.700000e+01 5.000000e-01 5.000000e-01 9.120000e-03 1.992712e-04 1.992712e-04
	2.800000e+01 5.000000e-01 5.000000e-01 8.522000e-03 2.040711e-04 2.040711e-04
	2.900000e+01 5.000000e-01 5.000000e-01 7.930000e-03 2.069034e-04 2.069034e-04
	3.000000e+01 5.000000e-01 5.000000e-01 7.331000e-03 2.067704e-04 2.067704e-04
	3.100000e+01 5.000000e-01 5.000000e-01 6.788000e-03 2.046583e-04 2.046583e-04
	3.295000e+01 1.450000e+00 1.550000e+00 5.844000e-03 1.984943e-04 1.984943e-04
	3.685000e+01 2.350000e+00 2.650000e+00 4.310000e-03 1.842200e-04 1.842200e-04
	4.380000e+01 4.300000e+00 5.700000e+00 2.355000e-03 1.410886e-04 1.410886e-04
	5.375000e+01 4.250000e+00 5.750000e+00 9.680000e-04 8.265815e-05 8.345759e-05
	6.370000e+01 4.200000e+00 5.800000e+00 3.751000e-04 4.234265e-05 4.284215e-05
	7.356000e+01 4.060000e+00 5.940000e+00 1.327000e-04 1.873846e-05 1.903786e-05
	8.609000e+01 6.590000e+00 1.341000e+01 2.884000e-05 5.183946e-06 5.293657e-06
	1.049000e+02 5.400000e+00 1.560000e+01 2.247000e-06 6.050058e-07 6.257036e-07
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d18-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d18-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	2.000000e+00 5.000000e-01 5.000000e-01 2.922000e-02 1.098362e-03 1.049238e-03
	3.000000e+00 5.000000e-01 5.000000e-01 3.186000e-02 1.179025e-03 1.140044e-03
	4.000000e+00 5.000000e-01 5.000000e-01 3.518000e-02 1.256344e-03 1.256344e-03
	5.000000e+00 5.000000e-01 5.000000e-01 3.822000e-02 1.309695e-03 1.309695e-03
	6.000000e+00 5.000000e-01 5.000000e-01 4.104000e-02 1.292826e-03 1.292826e-03
	7.000000e+00 5.000000e-01 5.000000e-01 4.331000e-02 1.247237e-03 1.208801e-03
	8.000000e+00 5.000000e-01 5.000000e-01 4.480000e-02 1.192518e-03 1.078378e-03
	9.000000e+00 5.000000e-01 5.000000e-01 4.534000e-02 1.125789e-03 9.192388e-04
	1.000000e+01 5.000000e-01 5.000000e-01 4.501000e-02 1.050048e-03 7.559100e-04
	1.100000e+01 5.000000e-01 5.000000e-01 4.354000e-02 9.527329e-04 5.964059e-04
	1.200000e+01 5.000000e-01 5.000000e-01 4.169000e-02 8.508819e-04 4.808326e-04
	1.300000e+01 5.000000e-01 5.000000e-01 3.913000e-02 7.424958e-04 3.721559e-04
	1.400000e+01 5.000000e-01 5.000000e-01 3.651000e-02 6.400781e-04 3.201562e-04
	1.500000e+01 5.000000e-01 5.000000e-01 3.374000e-02 5.491812e-04 3.006659e-04
	1.600000e+01 5.000000e-01 5.000000e-01 3.101000e-02 4.701064e-04 2.983287e-04
	1.700000e+01 5.000000e-01 5.000000e-01 2.886000e-02 4.252058e-04 3.046309e-04
	1.800000e+01 5.000000e-01 5.000000e-01 2.658000e-02 3.889730e-04 3.041381e-04
	1.900000e+01 5.000000e-01 5.000000e-01 2.476000e-02 3.748333e-04 3.001666e-04
	2.000000e+01 5.000000e-01 5.000000e-01 2.322000e-02 3.535534e-04 2.968164e-04
	2.100000e+01 5.000000e-01 5.000000e-01 2.168000e-02 3.394113e-04 2.884441e-04
	2.200000e+01 5.000000e-01 5.000000e-01 2.040000e-02 3.252691e-04 2.860070e-04
	2.300000e+01 5.000000e-01 5.000000e-01 1.921000e-02 3.182766e-04 2.920616e-04
	2.400000e+01 5.000000e-01 5.000000e-01 1.813000e-02 3.111270e-04 2.973214e-04
	2.500000e+01 5.000000e-01 5.000000e-01 1.712000e-02 3.114482e-04 3.041381e-04
	2.600000e+01 5.000000e-01 5.000000e-01 1.606000e-02 3.189044e-04 3.189044e-04
	2.700000e+01 5.000000e-01 5.000000e-01 1.513000e-02 3.280244e-04 3.280244e-04
	2.800000e+01 5.000000e-01 5.000000e-01 1.414000e-02 3.360060e-04 3.440930e-04
	2.900000e+01 5.000000e-01 5.000000e-01 1.323000e-02 3.383785e-04 3.551056e-04
	3.000000e+01 5.000000e-01 5.000000e-01 1.253000e-02 3.413210e-04 3.584690e-04
	3.148000e+01 9.800000e-01 1.020000e+00 1.120000e-02 3.138471e-04 3.417601e-04
	3.348000e+01 9.800000e-01 1.020000e+00 9.669000e-03 3.171939e-04 3.567072e-04
	3.548000e+01 9.800000e-01 1.020000e+00 8.359000e-03 3.134661e-04 3.704875e-04
	3.748000e+01 9.800000e-01 1.020000e+00 7.163000e-03 3.004330e-04 3.788931e-04
	3.948000e+01 9.800000e-01 1.020000e+00 6.163000e-03 2.830283e-04 3.829687e-04
	4.148000e+01 9.800000e-01 1.020000e+00 5.272000e-03 2.646828e-04 3.764904e-04
	4.348000e+01 9.800000e-01 1.020000e+00 4.524000e-03 2.504556e-04 3.663987e-04
	4.548000e+01 9.800000e-01 1.020000e+00 3.868000e-03 2.381449e-04 3.514541e-04
	4.748000e+01 9.800000e-01 1.020000e+00 3.257000e-03 2.258584e-04 3.316338e-04
	4.948000e+01 9.800000e-01 1.020000e+00 2.751000e-03 2.129249e-04 3.139825e-04
	5.148000e+01 9.800000e-01 1.020000e+00 2.297000e-03 1.952050e-04 2.875065e-04
	5.348000e+01 9.800000e-01 1.020000e+00 1.896000e-03 1.746139e-04 2.610306e-04
	5.547000e+01 9.700000e-01 1.030000e+00 1.573000e-03 1.530751e-04 2.316139e-04
	5.747000e+01 9.700000e-01 1.030000e+00 1.293000e-03 1.328157e-04 2.014274e-04
	5.947000e+01 9.700000e-01 1.030000e+00 1.081000e-03 1.173243e-04 1.781011e-04
	6.147000e+01 9.700000e-01 1.030000e+00 8.552000e-04 9.733160e-05 1.470837e-04
	6.349000e+01 9.900000e-01 1.010000e+00 7.071000e-04 8.660035e-05 1.301221e-04
	6.678000e+01 2.280000e+00 2.720000e+00 4.995000e-04 6.616472e-05 1.013359e-04
	7.172000e+01 2.220000e+00 2.780000e+00 2.781000e-04 4.290105e-05 6.566232e-05
	7.671000e+01 2.210000e+00 2.790000e+00 1.502000e-04 2.553840e-05 3.905125e-05
	8.366000e+01 4.160000e+00 5.840000e+00 6.588000e-05 1.180037e-05 1.755477e-05
	9.287000e+01 3.370000e+00 6.630000e+00 1.733000e-05 5.575410e-06 6.783104e-06
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d19-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d19-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	2.000000e+00 5.000000e-01 5.000000e-01 2.045000e-02 6.906519e-04 6.606815e-04
	3.000000e+00 5.000000e-01 5.000000e-01 2.242000e-02 7.510659e-04 7.510659e-04
	4.000000e+00 5.000000e-01 5.000000e-01 2.494000e-02 8.414868e-04 8.414868e-04
	5.000000e+00 5.000000e-01 5.000000e-01 2.701000e-02 8.814193e-04 8.814193e-04
	6.000000e+00 5.000000e-01 5.000000e-01 2.876000e-02 8.814193e-04 8.814193e-04
	7.000000e+00 5.000000e-01 5.000000e-01 3.002000e-02 8.514693e-04 8.414868e-04
	8.000000e+00 5.000000e-01 5.000000e-01 3.108000e-02 8.315047e-04 7.716217e-04
	9.000000e+00 5.000000e-01 5.000000e-01 3.166000e-02 8.321658e-04 6.826419e-04
	1.000000e+01 5.000000e-01 5.000000e-01 3.178000e-02 8.221922e-04 5.731492e-04
	1.100000e+01 5.000000e-01 5.000000e-01 3.132000e-02 7.823043e-04 4.638965e-04
	1.200000e+01 5.000000e-01 5.000000e-01 3.020000e-02 7.117584e-04 3.535534e-04
	1.300000e+01 5.000000e-01 5.000000e-01 2.884000e-02 6.419502e-04 2.549510e-04
	1.400000e+01 5.000000e-01 5.000000e-01 2.718000e-02 5.522681e-04 1.868154e-04
	1.500000e+01 5.000000e-01 5.000000e-01 2.545000e-02 4.825971e-04 1.300000e-04
	1.600000e+01 5.000000e-01 5.000000e-01 2.379000e-02 4.229657e-04 1.029563e-04
	1.700000e+01 5.000000e-01 5.000000e-01 2.233000e-02 3.733631e-04 8.602325e-05
	1.800000e+01 5.000000e-01 5.000000e-01 2.095000e-02 3.337664e-04 7.810250e-05
	1.900000e+01 5.000000e-01 5.000000e-01 1.979000e-02 2.927456e-04 6.403124e-05
	2.000000e+01 5.000000e-01 5.000000e-01 1.880000e-02 2.729469e-04 6.403124e-05
	2.100000e+01 5.000000e-01 5.000000e-01 1.791000e-02 2.433105e-04 6.403124e-05
	2.200000e+01 5.000000e-01 5.000000e-01 1.714000e-02 2.236068e-04 6.403124e-05
	2.300000e+01 5.000000e-01 5.000000e-01 1.645000e-02 2.137756e-04 5.656854e-05
	2.400000e+01 5.000000e-01 5.000000e-01 1.588000e-02 1.941649e-04 5.656854e-05
	2.500000e+01 5.000000e-01 5.000000e-01 1.530000e-02 1.843909e-04 5.000000e-05
	2.600000e+01 5.000000e-01 5.000000e-01 1.473000e-02 1.746425e-04 5.000000e-05
	2.700000e+01 5.000000e-01 5.000000e-01 1.421000e-02 1.649242e-04 4.472136e-05
	2.800000e+01 5.000000e-01 5.000000e-01 1.371000e-02 1.552417e-04 4.123106e-05
	2.900000e+01 5.000000e-01 5.000000e-01 1.337000e-02 1.456022e-04 4.123106e-05
	3.000000e+01 5.000000e-01 5.000000e-01 1.291000e-02 1.456022e-04 4.000000e-05
	3.100000e+01 5.000000e-01 5.000000e-01 1.243000e-02 1.334166e-04 3.000000e-05
	3.200000e+01 5.000000e-01 5.000000e-01 1.211000e-02 1.334166e-04 3.162278e-05
	3.300000e+01 5.000000e-01 5.000000e-01 1.170000e-02 1.236932e-04 3.605551e-05
	3.400000e+01 5.000000e-01 5.000000e-01 1.130000e-02 1.236932e-04 3.605551e-05
	3.500000e+01 5.000000e-01 5.000000e-01 1.098000e-02 1.140175e-04 4.242641e-05
	3.600000e+01 5.000000e-01 5.000000e-01 1.063000e-02 1.140175e-04 5.000000e-05
	3.700000e+01 5.000000e-01 5.000000e-01 1.032000e-02 1.044031e-04 5.000000e-05
	3.800000e+01 5.000000e-01 5.000000e-01 9.980000e-03 9.708244e-05 5.883026e-05
	3.900000e+01 5.000000e-01 5.000000e-01 9.667000e-03 9.141663e-05 6.400781e-05
	4.000000e+01 5.000000e-01 5.000000e-01 9.336000e-03 8.637708e-05 6.887670e-05
	4.100000e+01 5.000000e-01 5.000000e-01 9.050000e-03 8.450444e-05 7.432362e-05
	4.200000e+01 5.000000e-01 5.000000e-01 8.759000e-03 8.415462e-05 7.854935e-05
	4.300000e+01 5.000000e-01 5.000000e-01 8.516000e-03 8.603488e-05 8.228001e-05
	4.400000e+01 5.000000e-01 5.000000e-01 8.268000e-03 8.759566e-05 8.664872e-05
	4.500000e+01 5.000000e-01 5.000000e-01 7.999000e-03 9.139475e-05 9.139475e-05
	4.600000e+01 5.000000e-01 5.000000e-01 7.723000e-03 9.492102e-05 9.492102e-05
	4.700000e+01 5.000000e-01 5.000000e-01 7.459000e-03 9.876234e-05 9.972462e-05
	4.800000e+01 5.000000e-01 5.000000e-01 7.259000e-03 1.035809e-04 1.045466e-04
	4.900000e+01 5.000000e-01 5.000000e-01 7.023000e-03 1.072007e-04 1.091421e-04
	5.000000e+01 5.000000e-01 5.000000e-01 6.813000e-03 1.120580e-04 1.159526e-04
	5.100000e+01 5.000000e-01 5.000000e-01 6.614000e-03 1.157325e-04 1.215977e-04
	5.200000e+01 5.000000e-01 5.000000e-01 6.349000e-03 1.176860e-04 1.264951e-04
	5.300000e+01 5.000000e-01 5.000000e-01 6.143000e-03 1.204159e-04 1.321968e-04
	5.400000e+01 5.000000e-01 5.000000e-01 5.939000e-03 1.223765e-04 1.371167e-04
	5.500000e+01 5.000000e-01 5.000000e-01 5.723000e-03 1.243382e-04 1.430280e-04
	5.600000e+01 5.000000e-01 5.000000e-01 5.557000e-03 1.270984e-04 1.487884e-04
	5.700000e+01 5.000000e-01 5.000000e-01 5.345000e-03 1.280820e-04 1.537303e-04
	5.800000e+01 5.000000e-01 5.000000e-01 5.162000e-03 1.298769e-04 1.595243e-04
	5.900000e+01 5.000000e-01 5.000000e-01 4.968000e-03 1.318484e-04 1.644780e-04
	6.000000e+01 5.000000e-01 5.000000e-01 4.841000e-03 1.348073e-04 1.704259e-04
	6.149000e+01 9.900000e-01 1.010000e+00 4.545000e-03 1.348369e-04 1.756417e-04
	6.349000e+01 9.900000e-01 1.010000e+00 4.206000e-03 1.367187e-04 1.815406e-04
	6.549000e+01 9.900000e-01 1.010000e+00 3.899000e-03 1.367187e-04 1.875233e-04
	6.749000e+01 9.900000e-01 1.010000e+00 3.603000e-03 1.356245e-04 1.924396e-04
	6.949000e+01 9.900000e-01 1.010000e+00 3.331000e-03 1.346291e-04 1.964306e-04
	7.149000e+01 9.900000e-01 1.010000e+00 3.079000e-03 1.325443e-04 1.993615e-04
	7.349000e+01 9.900000e-01 1.010000e+00 2.839000e-03 1.315485e-04 2.013579e-04
	7.549000e+01 9.900000e-01 1.010000e+00 2.619000e-03 1.294681e-04 2.013008e-04
	7.749000e+01 9.900000e-01 1.010000e+00 2.411000e-03 1.264792e-04 2.003023e-04
	7.949000e+01 9.900000e-01 1.010000e+00 2.202000e-03 1.224091e-04 1.962549e-04
	8.149000e+01 9.900000e-01 1.010000e+00 2.015000e-03 1.184230e-04 1.912616e-04
	8.349000e+01 9.900000e-01 1.010000e+00 1.844000e-03 1.143547e-04 1.862176e-04
	8.549000e+01 9.900000e-01 1.010000e+00 1.690000e-03 1.103676e-04 1.812236e-04
	8.749000e+01 9.900000e-01 1.010000e+00 1.535000e-03 1.053850e-04 1.752313e-04
	8.949000e+01 9.900000e-01 1.010000e+00 1.402000e-03 1.003195e-04 1.691892e-04
	9.149000e+01 9.900000e-01 1.010000e+00 1.276000e-03 9.633276e-05 1.641950e-04
	9.349000e+01 9.900000e-01 1.010000e+00 1.168000e-03 9.234717e-05 1.592011e-04
	9.549000e+01 9.900000e-01 1.010000e+00 1.061000e-03 8.728115e-05 1.521611e-04
	9.749000e+01 9.900000e-01 1.010000e+00 9.567000e-04 8.238113e-05 1.451594e-04
	9.949000e+01 9.900000e-01 1.010000e+00 8.598000e-04 7.687529e-05 1.364549e-04
	1.015000e+02 1.000000e+00 1.000000e+00 7.682000e-04 7.116193e-05 1.274461e-04
	1.062000e+02 3.700000e+00 4.300000e+00 6.062000e-04 6.085992e-05 1.095333e-04
	1.150000e+02 4.500000e+00 5.500000e+00 3.733000e-04 4.374128e-05 7.882290e-05
	1.250000e+02 4.500000e+00 5.500000e+00 2.123000e-04 2.953320e-05 5.361828e-05
	1.409000e+02 1.040000e+01 1.960000e+01 6.877000e-05 1.166947e-05 2.141516e-05
	1.719000e+02 1.140000e+01 2.860000e+01 6.832000e-06 1.675972e-06 2.976796e-06
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d20-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d20-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	6.000000e+00 5.000000e-01 5.000000e-01 1.548000e-01 2.973214e-03 2.973214e-03
	7.000000e+00 5.000000e-01 5.000000e-01 1.294000e-01 2.193171e-03 2.193171e-03
	8.000000e+00 5.000000e-01 5.000000e-01 1.089000e-01 1.612452e-03 1.612452e-03
	9.000000e+00 5.000000e-01 5.000000e-01 9.256000e-02 1.207394e-03 1.199708e-03
	1.000000e+01 5.000000e-01 5.000000e-01 7.907000e-02 8.860023e-04 8.741853e-04
	1.100000e+01 5.000000e-01 5.000000e-01 6.783000e-02 6.989278e-04 6.926038e-04
	1.200000e+01 5.000000e-01 5.000000e-01 5.813000e-02 6.198387e-04 6.140033e-04
	1.300000e+01 5.000000e-01 5.000000e-01 4.959000e-02 6.352952e-04 6.306346e-04
	1.400000e+01 5.000000e-01 5.000000e-01 4.190000e-02 6.747592e-04 6.747592e-04
	1.500000e+01 5.000000e-01 5.000000e-01 3.559000e-02 6.931089e-04 6.931089e-04
	1.600000e+01 5.000000e-01 5.000000e-01 3.002000e-02 6.585590e-04 6.585590e-04
	1.700000e+01 5.000000e-01 5.000000e-01 2.508000e-02 6.020797e-04 6.020797e-04
	1.800000e+01 5.000000e-01 5.000000e-01 2.136000e-02 5.672742e-04 5.748913e-04
	1.900000e+01 5.000000e-01 5.000000e-01 1.814000e-02 5.560576e-04 5.560576e-04
	2.000000e+01 5.000000e-01 5.000000e-01 1.529000e-02 5.547071e-04 5.547071e-04
	2.100000e+01 5.000000e-01 5.000000e-01 1.287000e-02 5.522681e-04 5.522681e-04
	2.200000e+01 5.000000e-01 5.000000e-01 1.084000e-02 5.371220e-04 5.371220e-04
	2.300000e+01 5.000000e-01 5.000000e-01 8.988000e-03 5.055937e-04 5.064741e-04
	2.400000e+01 5.000000e-01 5.000000e-01 7.409000e-03 4.643533e-04 4.661202e-04
	2.500000e+01 5.000000e-01 5.000000e-01 6.101000e-03 4.205294e-04 4.214119e-04
	2.600000e+01 5.000000e-01 5.000000e-01 4.948000e-03 3.714297e-04 3.731863e-04
	2.700000e+01 5.000000e-01 5.000000e-01 4.017000e-03 3.264613e-04 3.282027e-04
	2.800000e+01 5.000000e-01 5.000000e-01 3.270000e-03 2.855538e-04 2.872786e-04
	2.900000e+01 5.000000e-01 5.000000e-01 2.705000e-03 2.522875e-04 2.539941e-04
	3.000000e+01 5.000000e-01 5.000000e-01 2.218000e-03 2.191278e-04 2.208099e-04
	3.100000e+01 5.000000e-01 5.000000e-01 1.776000e-03 1.891692e-04 1.899947e-04
	3.286000e+01 1.360000e+00 1.640000e+00 1.196000e-03 1.258014e-04 1.267162e-04
	3.655000e+01 2.050000e+00 2.950000e+00 5.027000e-04 6.359285e-05 6.405154e-05
	4.269000e+01 3.190000e+00 6.810000e+00 1.017000e-04 1.514761e-05 1.548709e-05
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d21-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d21-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	6.000000e+00 5.000000e-01 5.000000e-01 8.509000e-02 1.345362e-03 1.345362e-03
	7.000000e+00 5.000000e-01 5.000000e-01 7.404000e-02 1.105486e-03 1.105486e-03
	8.000000e+00 5.000000e-01 5.000000e-01 6.554000e-02 9.353609e-04 9.353609e-04
	9.000000e+00 5.000000e-01 5.000000e-01 5.894000e-02 8.161495e-04 8.062258e-04
	1.000000e+01 5.000000e-01 5.000000e-01 5.358000e-02 7.057620e-04 7.057620e-04
	1.100000e+01 5.000000e-01 5.000000e-01 4.867000e-02 6.067125e-04 6.067125e-04
	1.200000e+01 5.000000e-01 5.000000e-01 4.502000e-02 5.178803e-04 5.178803e-04
	1.300000e+01 5.000000e-01 5.000000e-01 4.147000e-02 4.373786e-04 4.373786e-04
	1.400000e+01 5.000000e-01 5.000000e-01 3.845000e-02 3.687818e-04 3.590265e-04
	1.500000e+01 5.000000e-01 5.000000e-01 3.562000e-02 3.008322e-04 3.008322e-04
	1.600000e+01 5.000000e-01 5.000000e-01 3.309000e-02 2.404163e-04 2.308679e-04
	1.700000e+01 5.000000e-01 5.000000e-01 3.078000e-02 1.838478e-04 1.746425e-04
	1.800000e+01 5.000000e-01 5.000000e-01 2.861000e-02 1.389244e-04 1.303840e-04
	1.900000e+01 5.000000e-01 5.000000e-01 2.664000e-02 9.899495e-05 9.219544e-05
	2.000000e+01 5.000000e-01 5.000000e-01 2.479000e-02 7.211103e-05 6.324555e-05
	2.100000e+01 5.000000e-01 5.000000e-01 2.312000e-02 6.708204e-05 6.082763e-05
	2.200000e+01 5.000000e-01 5.000000e-01 2.150000e-02 7.810250e-05 7.810250e-05
	2.300000e+01 5.000000e-01 5.000000e-01 2.012000e-02 1.000000e-04 1.000000e-04
	2.400000e+01 5.000000e-01 5.000000e-01 1.857000e-02 1.252996e-04 1.252996e-04
	2.500000e+01 5.000000e-01 5.000000e-01 1.734000e-02 1.392839e-04 1.392839e-04
	2.600000e+01 5.000000e-01 5.000000e-01 1.604000e-02 1.676305e-04 1.676305e-04
	2.700000e+01 5.000000e-01 5.000000e-01 1.495000e-02 1.868154e-04 1.868154e-04
	2.800000e+01 5.000000e-01 5.000000e-01 1.397000e-02 2.061553e-04 2.061553e-04
	2.900000e+01 5.000000e-01 5.000000e-01 1.300000e-02 2.158703e-04 2.158703e-04
	3.000000e+01 5.000000e-01 5.000000e-01 1.202000e-02 2.236068e-04 2.236068e-04
	3.100000e+01 5.000000e-01 5.000000e-01 1.113000e-02 2.236068e-04 2.236068e-04
	3.295000e+01 1.450000e+00 1.550000e+00 9.581000e-03 2.321422e-04 2.321422e-04
	3.685000e+01 2.350000e+00 2.650000e+00 7.066000e-03 2.324844e-04 2.334823e-04
	4.380000e+01 4.300000e+00 5.700000e+00 3.861000e-03 1.931657e-04 1.941649e-04
	5.375000e+01 4.250000e+00 5.750000e+00 1.587000e-03 1.201041e-04 1.221024e-04
	6.370000e+01 4.200000e+00 5.800000e+00 6.150000e-04 6.338083e-05 6.427970e-05
	7.356000e+01 4.060000e+00 5.940000e+00 2.176000e-04 2.856326e-05 2.916196e-05
	8.609000e+01 6.590000e+00 1.341000e+01 4.728000e-05 8.043929e-06 8.233377e-06
	1.049000e+02 5.400000e+00 1.560000e+01 3.685000e-06 9.582009e-07 9.936503e-07
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d22-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d22-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.000000e+00 5.000000e-01 5.000000e-01 7.616000e-01 2.367298e-02 2.367298e-02
	2.000000e+00 5.000000e-01 5.000000e-01 7.757000e-01 1.618178e-02 1.618178e-02
	3.000000e+00 5.000000e-01 5.000000e-01 7.924000e-01 1.632483e-02 1.632483e-02
	4.000000e+00 5.000000e-01 5.000000e-01 8.089000e-01 1.669281e-02 1.669281e-02
	5.000000e+00 5.000000e-01 5.000000e-01 8.251000e-01 1.702939e-02 1.702939e-02
	6.000000e+00 5.000000e-01 5.000000e-01 8.408000e-01 1.774176e-02 1.774176e-02
	7.000000e+00 5.000000e-01 5.000000e-01 8.578000e-01 2.016928e-02 2.016928e-02
	8.000000e+00 5.000000e-01 5.000000e-01 8.715000e-01 2.118962e-02 2.118962e-02
	9.000000e+00 5.000000e-01 5.000000e-01 8.813000e-01 2.092463e-02 2.092463e-02
	1.000000e+01 5.000000e-01 5.000000e-01 8.892000e-01 2.026055e-02 2.026055e-02
	1.100000e+01 5.000000e-01 5.000000e-01 8.961000e-01 1.963084e-02 1.963084e-02
	1.200000e+01 5.000000e-01 5.000000e-01 9.026000e-01 1.925954e-02 1.925954e-02
	1.300000e+01 5.000000e-01 5.000000e-01 9.090000e-01 1.913766e-02 1.913766e-02
	1.400000e+01 5.000000e-01 5.000000e-01 9.152000e-01 1.917603e-02 1.917603e-02
	1.500000e+01 5.000000e-01 5.000000e-01 9.213000e-01 1.930026e-02 1.930026e-02
	1.600000e+01 5.000000e-01 5.000000e-01 9.270000e-01 1.945379e-02 1.945379e-02
	1.700000e+01 5.000000e-01 5.000000e-01 9.327000e-01 1.976487e-02 1.976487e-02
	1.800000e+01 5.000000e-01 5.000000e-01 9.381000e-01 1.998650e-02 1.998650e-02
	1.900000e+01 5.000000e-01 5.000000e-01 9.435000e-01 2.018019e-02 2.018019e-02
	2.000000e+01 5.000000e-01 5.000000e-01 9.489000e-01 2.044749e-02 2.044749e-02
	2.100000e+01 5.000000e-01 5.000000e-01 9.539000e-01 2.072390e-02 2.072390e-02
	2.200000e+01 5.000000e-01 5.000000e-01 9.586000e-01 2.100905e-02 2.100905e-02
	2.300000e+01 5.000000e-01 5.000000e-01 9.628000e-01 2.138598e-02 2.138598e-02
	2.400000e+01 5.000000e-01 5.000000e-01 9.666000e-01 2.177935e-02 2.177935e-02
	2.500000e+01 5.000000e-01 5.000000e-01 9.703000e-01 2.228273e-02 2.228273e-02
	2.600000e+01 5.000000e-01 5.000000e-01 9.740000e-01 2.286154e-02 2.286154e-02
	2.700000e+01 5.000000e-01 5.000000e-01 9.779000e-01 2.346913e-02 2.346913e-02
	2.800000e+01 5.000000e-01 5.000000e-01 9.816000e-01 2.413462e-02 2.413462e-02
	2.900000e+01 5.000000e-01 5.000000e-01 9.856000e-01 2.486001e-02 2.486001e-02
	3.000000e+01 5.000000e-01 5.000000e-01 9.892000e-01 2.572353e-02 2.572353e-02
	3.100000e+01 5.000000e-01 5.000000e-01 9.932000e-01 2.684045e-02 2.684045e-02
	3.286000e+01 1.360000e+00 1.640000e+00 1.001000e+00 2.332381e-02 2.332381e-02
	3.655000e+01 2.050000e+00 2.950000e+00 1.014000e+00 2.441311e-02 2.441311e-02
	4.269000e+01 3.190000e+00 6.810000e+00 1.032000e+00 2.969848e-02 2.969848e-02
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d23-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d23-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.000000e+00 5.000000e-01 5.000000e-01 7.711000e-01 2.324220e-02 2.324220e-02
	2.000000e+00 5.000000e-01 5.000000e-01 7.872000e-01 1.583161e-02 1.583161e-02
	3.000000e+00 5.000000e-01 5.000000e-01 8.053000e-01 1.622498e-02 1.622498e-02
	4.000000e+00 5.000000e-01 5.000000e-01 8.248000e-01 1.661927e-02 1.661927e-02
	5.000000e+00 5.000000e-01 5.000000e-01 8.440000e-01 1.701881e-02 1.701881e-02
	6.000000e+00 5.000000e-01 5.000000e-01 8.621000e-01 1.741838e-02 1.741838e-02
	7.000000e+00 5.000000e-01 5.000000e-01 8.783000e-01 1.781797e-02 1.781797e-02
	8.000000e+00 5.000000e-01 5.000000e-01 8.930000e-01 1.812236e-02 1.812236e-02
	9.000000e+00 5.000000e-01 5.000000e-01 9.060000e-01 1.832212e-02 1.832212e-02
	1.000000e+01 5.000000e-01 5.000000e-01 9.176000e-01 1.852188e-02 1.852188e-02
	1.100000e+01 5.000000e-01 5.000000e-01 9.281000e-01 1.882153e-02 1.882153e-02
	1.200000e+01 5.000000e-01 5.000000e-01 9.377000e-01 1.892142e-02 1.892142e-02
	1.300000e+01 5.000000e-01 5.000000e-01 9.465000e-01 1.912119e-02 1.912119e-02
	1.400000e+01 5.000000e-01 5.000000e-01 9.546000e-01 1.932097e-02 1.932097e-02
	1.500000e+01 5.000000e-01 5.000000e-01 9.621000e-01 1.942087e-02 1.942087e-02
	1.600000e+01 5.000000e-01 5.000000e-01 9.693000e-01 1.962065e-02 1.962065e-02
	1.700000e+01 5.000000e-01 5.000000e-01 9.758000e-01 1.972055e-02 1.972055e-02
	1.800000e+01 5.000000e-01 5.000000e-01 9.821000e-01 1.982044e-02 1.982044e-02
	1.900000e+01 5.000000e-01 5.000000e-01 9.882000e-01 2.002498e-02 2.002498e-02
	2.000000e+01 5.000000e-01 5.000000e-01 9.939000e-01 2.012486e-02 2.012486e-02
	2.100000e+01 5.000000e-01 5.000000e-01 9.994000e-01 2.022474e-02 2.022474e-02
	2.200000e+01 5.000000e-01 5.000000e-01 1.005000e+00 2.002498e-02 2.002498e-02
	2.300000e+01 5.000000e-01 5.000000e-01 1.010000e+00 2.002498e-02 2.002498e-02
	2.400000e+01 5.000000e-01 5.000000e-01 1.014000e+00 2.002498e-02 2.002498e-02
	2.500000e+01 5.000000e-01 5.000000e-01 1.019000e+00 2.102380e-02 2.102380e-02
	2.600000e+01 5.000000e-01 5.000000e-01 1.023000e+00 2.102380e-02 2.102380e-02
	2.700000e+01 5.000000e-01 5.000000e-01 1.028000e+00 2.102380e-02 2.102380e-02
	2.800000e+01 5.000000e-01 5.000000e-01 1.032000e+00 2.102380e-02 2.102380e-02
	2.900000e+01 5.000000e-01 5.000000e-01 1.036000e+00 2.102380e-02 2.102380e-02
	3.000000e+01 5.000000e-01 5.000000e-01 1.040000e+00 2.102380e-02 2.102380e-02
	3.100000e+01 5.000000e-01 5.000000e-01 1.044000e+00 2.102380e-02 2.102380e-02
	3.295000e+01 1.450000e+00 1.550000e+00 1.051000e+00 2.102380e-02 2.102380e-02
	3.685000e+01 2.350000e+00 2.650000e+00 1.064000e+00 2.102380e-02 2.102380e-02
	4.380000e+01 4.300000e+00 5.700000e+00 1.086000e+00 2.202272e-02 2.202272e-02
	5.375000e+01 4.250000e+00 5.750000e+00 1.111000e+00 2.202272e-02 2.202272e-02
	6.370000e+01 4.200000e+00 5.800000e+00 1.136000e+00 2.302173e-02 2.302173e-02
	7.356000e+01 4.060000e+00 5.940000e+00 1.159000e+00 2.408319e-02 2.408319e-02
	8.609000e+01 6.590000e+00 1.341000e+01 1.183000e+00 2.418677e-02 2.418677e-02
	1.049000e+02 5.400000e+00 1.560000e+01 1.226000e+00 2.692582e-02 2.692582e-02
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d24-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d24-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	2.000000e+00 5.000000e-01 5.000000e-01 4.390000e-01 1.207394e-02 1.207394e-02
	3.000000e+00 5.000000e-01 5.000000e-01 4.375000e-01 1.051903e-02 1.051903e-02
	4.000000e+00 5.000000e-01 5.000000e-01 4.361000e-01 1.003195e-02 1.003195e-02
	5.000000e+00 5.000000e-01 5.000000e-01 4.350000e-01 9.868131e-03 9.868131e-03
	6.000000e+00 5.000000e-01 5.000000e-01 4.346000e-01 9.741663e-03 9.741663e-03
	7.000000e+00 5.000000e-01 5.000000e-01 4.349000e-01 9.752948e-03 9.752948e-03
	8.000000e+00 5.000000e-01 5.000000e-01 4.360000e-01 9.798469e-03 9.798469e-03
	9.000000e+00 5.000000e-01 5.000000e-01 4.376000e-01 9.848858e-03 9.848858e-03
	1.000000e+01 5.000000e-01 5.000000e-01 4.398000e-01 9.924717e-03 9.924717e-03
	1.100000e+01 5.000000e-01 5.000000e-01 4.423000e-01 1.012028e-02 1.012028e-02
	1.200000e+01 5.000000e-01 5.000000e-01 4.451000e-01 1.021812e-02 1.021812e-02
	1.300000e+01 5.000000e-01 5.000000e-01 4.482000e-01 1.031601e-02 1.031601e-02
	1.400000e+01 5.000000e-01 5.000000e-01 4.514000e-01 1.051190e-02 1.051190e-02
	1.500000e+01 5.000000e-01 5.000000e-01 4.549000e-01 1.060990e-02 1.060990e-02
	1.600000e+01 5.000000e-01 5.000000e-01 4.585000e-01 1.082589e-02 1.082589e-02
	1.700000e+01 5.000000e-01 5.000000e-01 4.622000e-01 1.096586e-02 1.096586e-02
	1.800000e+01 5.000000e-01 5.000000e-01 4.661000e-01 1.127918e-02 1.127918e-02
	1.900000e+01 5.000000e-01 5.000000e-01 4.700000e-01 1.160560e-02 1.160560e-02
	2.000000e+01 5.000000e-01 5.000000e-01 4.739000e-01 1.210785e-02 1.210785e-02
	2.100000e+01 5.000000e-01 5.000000e-01 4.777000e-01 1.256742e-02 1.256742e-02
	2.200000e+01 5.000000e-01 5.000000e-01 4.811000e-01 1.284134e-02 1.284134e-02
	2.300000e+01 5.000000e-01 5.000000e-01 4.844000e-01 1.298653e-02 1.298653e-02
	2.400000e+01 5.000000e-01 5.000000e-01 4.870000e-01 1.303610e-02 1.303610e-02
	2.500000e+01 5.000000e-01 5.000000e-01 4.895000e-01 1.293754e-02 1.293754e-02
	2.600000e+01 5.000000e-01 5.000000e-01 4.918000e-01 1.279414e-02 1.279414e-02
	2.700000e+01 5.000000e-01 5.000000e-01 4.939000e-01 1.256742e-02 1.256742e-02
	2.800000e+01 5.000000e-01 5.000000e-01 4.959000e-01 1.244829e-02 1.244829e-02
	2.900000e+01 5.000000e-01 5.000000e-01 4.978000e-01 1.234909e-02 1.234909e-02
	3.000000e+01 5.000000e-01 5.000000e-01 4.998000e-01 1.220901e-02 1.220901e-02
	3.148000e+01 9.800000e-01 1.020000e+00 5.027000e-01 1.198541e-02 1.198541e-02
	3.348000e+01 9.800000e-01 1.020000e+00 5.064000e-01 1.202206e-02 1.202206e-02
	3.548000e+01 9.800000e-01 1.020000e+00 5.099000e-01 1.212023e-02 1.212023e-02
	3.748000e+01 9.800000e-01 1.020000e+00 5.134000e-01 1.223765e-02 1.223765e-02
	3.948000e+01 9.800000e-01 1.020000e+00 5.169000e-01 1.235557e-02 1.235557e-02
	4.148000e+01 9.800000e-01 1.020000e+00 5.202000e-01 1.257179e-02 1.257179e-02
	4.348000e+01 9.800000e-01 1.020000e+00 5.235000e-01 1.261467e-02 1.261467e-02
	4.548000e+01 9.800000e-01 1.020000e+00 5.267000e-01 1.273460e-02 1.273460e-02
	4.748000e+01 9.800000e-01 1.020000e+00 5.297000e-01 1.278163e-02 1.278163e-02
	4.948000e+01 9.800000e-01 1.020000e+00 5.327000e-01 1.283160e-02 1.283160e-02
	5.148000e+01 9.800000e-01 1.020000e+00 5.353000e-01 1.291201e-02 1.291201e-02
	5.348000e+01 9.800000e-01 1.020000e+00 5.379000e-01 1.309427e-02 1.309427e-02
	5.547000e+01 9.700000e-01 1.030000e+00 5.405000e-01 1.328157e-02 1.328157e-02
	5.747000e+01 9.700000e-01 1.030000e+00 5.428000e-01 1.350741e-02 1.350741e-02
	5.947000e+01 9.700000e-01 1.030000e+00 5.453000e-01 1.370584e-02 1.370584e-02
	6.147000e+01 9.700000e-01 1.030000e+00 5.473000e-01 1.407693e-02 1.407693e-02
	6.349000e+01 9.900000e-01 1.010000e+00 5.497000e-01 1.441804e-02 1.441804e-02
	6.678000e+01 2.280000e+00 2.720000e+00 5.547000e-01 1.407302e-02 1.407302e-02
	7.172000e+01 2.220000e+00 2.780000e+00 5.626000e-01 1.470782e-02 1.470782e-02
	7.671000e+01 2.210000e+00 2.790000e+00 5.683000e-01 1.525942e-02 1.525942e-02
	8.366000e+01 4.160000e+00 5.840000e+00 5.733000e-01 1.525942e-02 1.525942e-02
	9.287000e+01 3.370000e+00 6.630000e+00 5.802000e-01 1.997523e-02 1.997523e-02
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d25-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d25-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	2.000000e+00 5.000000e-01 5.000000e-01 4.465000e-01 3.361547e-03 3.361547e-03
	3.000000e+00 5.000000e-01 5.000000e-01 4.437000e-01 3.231099e-03 3.231099e-03
	4.000000e+00 5.000000e-01 5.000000e-01 4.415000e-01 3.228002e-03 3.228002e-03
	5.000000e+00 5.000000e-01 5.000000e-01 4.404000e-01 3.395585e-03 3.395585e-03
	6.000000e+00 5.000000e-01 5.000000e-01 4.404000e-01 3.569314e-03 3.569314e-03
	7.000000e+00 5.000000e-01 5.000000e-01 4.413000e-01 3.748333e-03 3.748333e-03
	8.000000e+00 5.000000e-01 5.000000e-01 4.429000e-01 3.931921e-03 3.931921e-03
	9.000000e+00 5.000000e-01 5.000000e-01 4.452000e-01 4.229657e-03 4.229657e-03
	1.000000e+01 5.000000e-01 5.000000e-01 4.480000e-01 4.428318e-03 4.428318e-03
	1.100000e+01 5.000000e-01 5.000000e-01 4.513000e-01 4.627094e-03 4.627094e-03
	1.200000e+01 5.000000e-01 5.000000e-01 4.550000e-01 4.925444e-03 4.925444e-03
	1.300000e+01 5.000000e-01 5.000000e-01 4.592000e-01 5.124451e-03 5.124451e-03
	1.400000e+01 5.000000e-01 5.000000e-01 4.635000e-01 5.423099e-03 5.423099e-03
	1.500000e+01 5.000000e-01 5.000000e-01 4.682000e-01 5.622277e-03 5.622277e-03
	1.600000e+01 5.000000e-01 5.000000e-01 4.729000e-01 5.921149e-03 5.921149e-03
	1.700000e+01 5.000000e-01 5.000000e-01 4.777000e-01 6.120457e-03 6.120457e-03
	1.800000e+01 5.000000e-01 5.000000e-01 4.825000e-01 6.220129e-03 6.220129e-03
	1.900000e+01 5.000000e-01 5.000000e-01 4.872000e-01 6.419502e-03 6.419502e-03
	2.000000e+01 5.000000e-01 5.000000e-01 4.918000e-01 6.519202e-03 6.519202e-03
	2.100000e+01 5.000000e-01 5.000000e-01 4.962000e-01 6.618912e-03 6.618912e-03
	2.200000e+01 5.000000e-01 5.000000e-01 5.005000e-01 6.618912e-03 6.618912e-03
	2.300000e+01 5.000000e-01 5.000000e-01 5.044000e-01 6.718631e-03 6.718631e-03
	2.400000e+01 5.000000e-01 5.000000e-01 5.082000e-01 6.718631e-03 6.718631e-03
	2.500000e+01 5.000000e-01 5.000000e-01 5.119000e-01 6.718631e-03 6.718631e-03
	2.600000e+01 5.000000e-01 5.000000e-01 5.153000e-01 6.818358e-03 6.818358e-03
	2.700000e+01 5.000000e-01 5.000000e-01 5.187000e-01 6.818358e-03 6.818358e-03
	2.800000e+01 5.000000e-01 5.000000e-01 5.218000e-01 6.818358e-03 6.818358e-03
	2.900000e+01 5.000000e-01 5.000000e-01 5.250000e-01 6.918092e-03 6.918092e-03
	3.000000e+01 5.000000e-01 5.000000e-01 5.280000e-01 6.918092e-03 6.918092e-03
	3.100000e+01 5.000000e-01 5.000000e-01 5.309000e-01 7.017834e-03 7.017834e-03
	3.200000e+01 5.000000e-01 5.000000e-01 5.338000e-01 7.017834e-03 7.017834e-03
	3.300000e+01 5.000000e-01 5.000000e-01 5.365000e-01 7.017834e-03 7.017834e-03
	3.400000e+01 5.000000e-01 5.000000e-01 5.392000e-01 7.117584e-03 7.117584e-03
	3.500000e+01 5.000000e-01 5.000000e-01 5.418000e-01 7.125307e-03 7.125307e-03
	3.600000e+01 5.000000e-01 5.000000e-01 5.445000e-01 7.224957e-03 7.224957e-03
	3.700000e+01 5.000000e-01 5.000000e-01 5.469000e-01 7.224957e-03 7.224957e-03
	3.800000e+01 5.000000e-01 5.000000e-01 5.494000e-01 7.324616e-03 7.324616e-03
	3.900000e+01 5.000000e-01 5.000000e-01 5.517000e-01 7.324616e-03 7.324616e-03
	4.000000e+01 5.000000e-01 5.000000e-01 5.541000e-01 7.424284e-03 7.424284e-03
	4.100000e+01 5.000000e-01 5.000000e-01 5.564000e-01 7.523962e-03 7.523962e-03
	4.200000e+01 5.000000e-01 5.000000e-01 5.587000e-01 7.523962e-03 7.523962e-03
	4.300000e+01 5.000000e-01 5.000000e-01 5.610000e-01 7.623647e-03 7.623647e-03
	4.400000e+01 5.000000e-01 5.000000e-01 5.632000e-01 7.623647e-03 7.623647e-03
	4.500000e+01 5.000000e-01 5.000000e-01 5.653000e-01 7.623647e-03 7.623647e-03
	4.600000e+01 5.000000e-01 5.000000e-01 5.675000e-01 7.723341e-03 7.723341e-03
	4.700000e+01 5.000000e-01 5.000000e-01 5.696000e-01 7.723341e-03 7.723341e-03
	4.800000e+01 5.000000e-01 5.000000e-01 5.716000e-01 7.723341e-03 7.723341e-03
	4.900000e+01 5.000000e-01 5.000000e-01 5.736000e-01 7.723341e-03 7.723341e-03
	5.000000e+01 5.000000e-01 5.000000e-01 5.755000e-01 7.723341e-03 7.723341e-03
	5.100000e+01 5.000000e-01 5.000000e-01 5.775000e-01 7.723341e-03 7.723341e-03
	5.200000e+01 5.000000e-01 5.000000e-01 5.794000e-01 7.823043e-03 7.823043e-03
	5.300000e+01 5.000000e-01 5.000000e-01 5.812000e-01 7.831347e-03 7.831347e-03
	5.400000e+01 5.000000e-01 5.000000e-01 5.830000e-01 7.831347e-03 7.831347e-03
	5.500000e+01 5.000000e-01 5.000000e-01 5.848000e-01 7.831347e-03 7.831347e-03
	5.600000e+01 5.000000e-01 5.000000e-01 5.865000e-01 7.930952e-03 7.930952e-03
	5.700000e+01 5.000000e-01 5.000000e-01 5.883000e-01 7.930952e-03 7.930952e-03
	5.800000e+01 5.000000e-01 5.000000e-01 5.900000e-01 8.030567e-03 8.030567e-03
	5.900000e+01 5.000000e-01 5.000000e-01 5.917000e-01 8.030567e-03 8.030567e-03
	6.000000e+01 5.000000e-01 5.000000e-01 5.933000e-01 8.030567e-03 8.030567e-03
	6.149000e+01 9.900000e-01 1.010000e+00 5.958000e-01 8.115417e-03 8.115417e-03
	6.349000e+01 9.900000e-01 1.010000e+00 5.990000e-01 8.215230e-03 8.215230e-03
	6.549000e+01 9.900000e-01 1.010000e+00 6.022000e-01 8.315047e-03 8.315047e-03
	6.749000e+01 9.900000e-01 1.010000e+00 6.053000e-01 8.321658e-03 8.321658e-03
	6.949000e+01 9.900000e-01 1.010000e+00 6.083000e-01 8.421401e-03 8.421401e-03
	7.149000e+01 9.900000e-01 1.010000e+00 6.112000e-01 8.421401e-03 8.421401e-03
	7.349000e+01 9.900000e-01 1.010000e+00 6.141000e-01 8.421401e-03 8.421401e-03
	7.549000e+01 9.900000e-01 1.010000e+00 6.168000e-01 8.521150e-03 8.521150e-03
	7.749000e+01 9.900000e-01 1.010000e+00 6.195000e-01 8.521150e-03 8.521150e-03
	7.949000e+01 9.900000e-01 1.010000e+00 6.222000e-01 8.528775e-03 8.528775e-03
	8.149000e+01 9.900000e-01 1.010000e+00 6.247000e-01 8.528775e-03 8.528775e-03
	8.349000e+01 9.900000e-01 1.010000e+00 6.272000e-01 8.628441e-03 8.628441e-03
	8.549000e+01 9.900000e-01 1.010000e+00 6.296000e-01 8.628441e-03 8.628441e-03
	8.749000e+01 9.900000e-01 1.010000e+00 6.320000e-01 8.637129e-03 8.637129e-03
	8.949000e+01 9.900000e-01 1.010000e+00 6.343000e-01 8.736704e-03 8.736704e-03
	9.149000e+01 9.900000e-01 1.010000e+00 6.367000e-01 8.836289e-03 8.836289e-03
	9.349000e+01 9.900000e-01 1.010000e+00 6.391000e-01 8.845903e-03 8.845903e-03
	9.549000e+01 9.900000e-01 1.010000e+00 6.413000e-01 8.945390e-03 8.945390e-03
	9.749000e+01 9.900000e-01 1.010000e+00 6.437000e-01 8.945390e-03 8.945390e-03
	9.949000e+01 9.900000e-01 1.010000e+00 6.459000e-01 9.055385e-03 9.055385e-03
	1.015000e+02 1.000000e+00 1.000000e+00 6.482000e-01 9.154780e-03 9.154780e-03
	1.062000e+02 3.700000e+00 4.300000e+00 6.533000e-01 9.219544e-03 9.219544e-03
	1.150000e+02 4.500000e+00 5.500000e+00 6.627000e-01 9.525755e-03 9.525755e-03
	1.250000e+02 4.500000e+00 5.500000e+00 6.731000e-01 9.751410e-03 9.751410e-03
	1.409000e+02 1.040000e+01 1.960000e+01 6.880000e-01 9.234717e-03 9.234717e-03
	1.719000e+02 1.140000e+01 2.860000e+01 7.134000e-01 2.357668e-02 2.357668e-02
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d26-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d26-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.450000e+00 5.000000e-02 5.000000e-02 6.073000e+00 5.105693e-01 5.105693e-01
	-2.350000e+00 5.000000e-02 5.000000e-02 6.217000e+00 5.241040e-01 5.241040e-01
	-2.250000e+00 5.000000e-02 5.000000e-02 6.295000e+00 2.836988e-01 2.836988e-01
	-2.150000e+00 5.000000e-02 5.000000e-02 6.342000e+00 2.855801e-01 2.855801e-01
	-2.050000e+00 5.000000e-02 5.000000e-02 6.443000e+00 2.607317e-01 2.607317e-01
	-1.950000e+00 5.000000e-02 5.000000e-02 6.429000e+00 2.537794e-01 2.537794e-01
	-1.850000e+00 5.000000e-02 5.000000e-02 6.540000e+00 1.816645e-01 1.816645e-01
	-1.750000e+00 5.000000e-02 5.000000e-02 6.772000e+00 1.885656e-01 1.885656e-01
	-1.650000e+00 5.000000e-02 5.000000e-02 6.906000e+00 1.946484e-01 1.946484e-01
	-1.550000e+00 5.000000e-02 5.000000e-02 6.750000e+00 1.869358e-01 1.869358e-01
	-1.450000e+00 5.000000e-02 5.000000e-02 6.811000e+00 1.838070e-01 1.838070e-01
	-1.350000e+00 5.000000e-02 5.000000e-02 6.760000e+00 1.826499e-01 1.826499e-01
	-1.250000e+00 5.000000e-02 5.000000e-02 6.822000e+00 9.392018e-02 9.392018e-02
	-1.150000e+00 5.000000e-02 5.000000e-02 6.901000e+00 9.803061e-02 9.803061e-02
	-1.050000e+00 5.000000e-02 5.000000e-02 6.914000e+00 9.771898e-02 9.771898e-02
	-9.500000e-01 5.000000e-02 5.000000e-02 6.814000e+00 9.581753e-02 9.581753e-02
	-8.500000e-01 5.000000e-02 5.000000e-02 6.851000e+00 9.392018e-02 9.392018e-02
	-7.500000e-01 5.000000e-02 5.000000e-02 6.808000e+00 9.202717e-02 9.202717e-02
	-6.500000e-01 5.000000e-02 5.000000e-02 6.818000e+00 9.047652e-02 9.047652e-02
	-5.500000e-01 5.000000e-02 5.000000e-02 6.703000e+00 8.860023e-02 8.860023e-02
	-4.500000e-01 5.000000e-02 5.000000e-02 6.682000e+00 8.802272e-02 8.802272e-02
	-3.500000e-01 5.000000e-02 5.000000e-02 6.686000e+00 9.304837e-02 9.304837e-02
	-2.500000e-01 5.000000e-02 5.000000e-02 6.649000e+00 8.969392e-02 8.969392e-02
	-1.500000e-01 5.000000e-02 5.000000e-02 6.612000e+00 8.784646e-02 8.784646e-02
	-5.000000e-02 5.000000e-02 5.000000e-02 6.598000e+00 8.469357e-02 8.469357e-02
	5.000000e-02 5.000000e-02 5.000000e-02 6.597000e+00 8.653901e-02 8.653901e-02
	1.500000e-01 5.000000e-02 5.000000e-02 6.578000e+00 8.469357e-02 8.469357e-02
	2.500000e-01 5.000000e-02 5.000000e-02 6.633000e+00 8.969392e-02 8.969392e-02
	3.500000e-01 5.000000e-02 5.000000e-02 6.675000e+00 8.839118e-02 8.839118e-02
	4.500000e-01 5.000000e-02 5.000000e-02 6.645000e+00 8.766413e-02 8.766413e-02
	5.500000e-01 5.000000e-02 5.000000e-02 6.701000e+00 9.141663e-02 9.141663e-02
	6.500000e-01 5.000000e-02 5.000000e-02 6.740000e+00 9.235800e-02 9.235800e-02
	7.500000e-01 5.000000e-02 5.000000e-02 6.762000e+00 8.792042e-02 8.792042e-02
	8.500000e-01 5.000000e-02 5.000000e-02 6.829000e+00 9.013878e-02 9.013878e-02
	9.500000e-01 5.000000e-02 5.000000e-02 6.854000e+00 9.392018e-02 9.392018e-02
	1.050000e+00 5.000000e-02 5.000000e-02 6.852000e+00 9.297311e-02 9.297311e-02
	1.150000e+00 5.000000e-02 5.000000e-02 6.884000e+00 9.424436e-02 9.424436e-02
	1.250000e+00 5.000000e-02 5.000000e-02 6.869000e+00 9.613532e-02 9.613532e-02
	1.350000e+00 5.000000e-02 5.000000e-02 6.900000e+00 1.847918e-01 1.847918e-01
	1.450000e+00 5.000000e-02 5.000000e-02 6.795000e+00 1.869358e-01 1.869358e-01
	1.550000e+00 5.000000e-02 5.000000e-02 6.796000e+00 1.882817e-01 1.882817e-01
	1.650000e+00 5.000000e-02 5.000000e-02 6.780000e+00 1.877472e-01 1.877472e-01
	1.750000e+00 5.000000e-02 5.000000e-02 6.714000e+00 1.846212e-01 1.846212e-01
	1.850000e+00 5.000000e-02 5.000000e-02 6.591000e+00 1.826499e-01 1.826499e-01
	1.950000e+00 5.000000e-02 5.000000e-02 6.464000e+00 2.568774e-01 2.568774e-01
	2.050000e+00 5.000000e-02 5.000000e-02 6.476000e+00 2.597383e-01 2.597383e-01
	2.150000e+00 5.000000e-02 5.000000e-02 6.433000e+00 2.885637e-01 2.885637e-01
	2.250000e+00 5.000000e-02 5.000000e-02 6.358000e+00 2.856869e-01 2.856869e-01
	2.350000e+00 5.000000e-02 5.000000e-02 6.140000e+00 5.120010e-01 5.120010e-01
	2.450000e+00 5.000000e-02 5.000000e-02 5.917000e+00 4.963074e-01 4.963074e-01
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d27-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d27-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.450000e+00 5.000000e-02 5.000000e-02 9.000000e+00 7.630321e-01 7.630321e-01
	-2.350000e+00 5.000000e-02 5.000000e-02 9.310000e+00 7.870229e-01 7.870229e-01
	-2.250000e+00 5.000000e-02 5.000000e-02 9.377000e+00 4.460404e-01 4.460404e-01
	-2.150000e+00 5.000000e-02 5.000000e-02 9.305000e+00 4.400409e-01 4.400409e-01
	-2.050000e+00 5.000000e-02 5.000000e-02 9.496000e+00 4.090440e-01 4.090440e-01
	-1.950000e+00 5.000000e-02 5.000000e-02 9.373000e+00 4.000450e-01 4.000450e-01
	-1.850000e+00 5.000000e-02 5.000000e-02 9.476000e+00 2.960608e-01 2.960608e-01
	-1.750000e+00 5.000000e-02 5.000000e-02 9.713000e+00 3.040592e-01 3.040592e-01
	-1.650000e+00 5.000000e-02 5.000000e-02 9.724000e+00 3.050590e-01 3.050590e-01
	-1.550000e+00 5.000000e-02 5.000000e-02 9.552000e+00 2.950610e-01 2.950610e-01
	-1.450000e+00 5.000000e-02 5.000000e-02 9.432000e+00 2.870627e-01 2.870627e-01
	-1.350000e+00 5.000000e-02 5.000000e-02 9.508000e+00 2.890623e-01 2.890623e-01
	-1.250000e+00 5.000000e-02 5.000000e-02 9.581000e+00 1.731040e-01 1.731040e-01
	-1.150000e+00 5.000000e-02 5.000000e-02 9.573000e+00 1.701058e-01 1.701058e-01
	-1.050000e+00 5.000000e-02 5.000000e-02 9.504000e+00 1.690739e-01 1.690739e-01
	-9.500000e-01 5.000000e-02 5.000000e-02 9.426000e+00 1.650757e-01 1.650757e-01
	-8.500000e-01 5.000000e-02 5.000000e-02 9.384000e+00 1.650757e-01 1.650757e-01
	-7.500000e-01 5.000000e-02 5.000000e-02 9.344000e+00 1.630767e-01 1.630767e-01
	-6.500000e-01 5.000000e-02 5.000000e-02 9.299000e+00 1.630767e-01 1.630767e-01
	-5.500000e-01 5.000000e-02 5.000000e-02 9.236000e+00 1.581139e-01 1.581139e-01
	-4.500000e-01 5.000000e-02 5.000000e-02 9.178000e+00 1.581139e-01 1.581139e-01
	-3.500000e-01 5.000000e-02 5.000000e-02 9.137000e+00 1.561153e-01 1.561153e-01
	-2.500000e-01 5.000000e-02 5.000000e-02 9.111000e+00 1.581139e-01 1.581139e-01
	-1.500000e-01 5.000000e-02 5.000000e-02 9.088000e+00 1.581139e-01 1.581139e-01
	-5.000000e-02 5.000000e-02 5.000000e-02 9.074000e+00 1.571146e-01 1.571146e-01
	5.000000e-02 5.000000e-02 5.000000e-02 9.075000e+00 1.561153e-01 1.561153e-01
	1.500000e-01 5.000000e-02 5.000000e-02 9.071000e+00 1.551161e-01 1.551161e-01
	2.500000e-01 5.000000e-02 5.000000e-02 9.095000e+00 1.561153e-01 1.561153e-01
	3.500000e-01 5.000000e-02 5.000000e-02 9.138000e+00 1.581139e-01 1.581139e-01
	4.500000e-01 5.000000e-02 5.000000e-02 9.187000e+00 1.561153e-01 1.561153e-01
	5.500000e-01 5.000000e-02 5.000000e-02 9.229000e+00 1.580791e-01 1.580791e-01
	6.500000e-01 5.000000e-02 5.000000e-02 9.295000e+00 1.600781e-01 1.600781e-01
	7.500000e-01 5.000000e-02 5.000000e-02 9.367000e+00 1.630767e-01 1.630767e-01
	8.500000e-01 5.000000e-02 5.000000e-02 9.398000e+00 1.630767e-01 1.630767e-01
	9.500000e-01 5.000000e-02 5.000000e-02 9.434000e+00 1.660753e-01 1.660753e-01
	1.050000e+00 5.000000e-02 5.000000e-02 9.522000e+00 1.700735e-01 1.700735e-01
	1.150000e+00 5.000000e-02 5.000000e-02 9.616000e+00 1.741034e-01 1.741034e-01
	1.250000e+00 5.000000e-02 5.000000e-02 9.628000e+00 1.751028e-01 1.751028e-01
	1.350000e+00 5.000000e-02 5.000000e-02 9.575000e+00 2.930614e-01 2.930614e-01
	1.450000e+00 5.000000e-02 5.000000e-02 9.478000e+00 2.910618e-01 2.910618e-01
	1.550000e+00 5.000000e-02 5.000000e-02 9.584000e+00 2.950610e-01 2.950610e-01
	1.650000e+00 5.000000e-02 5.000000e-02 9.691000e+00 3.020596e-01 3.020596e-01
	1.750000e+00 5.000000e-02 5.000000e-02 9.634000e+00 3.030594e-01 3.030594e-01
	1.850000e+00 5.000000e-02 5.000000e-02 9.449000e+00 2.960608e-01 2.960608e-01
	1.950000e+00 5.000000e-02 5.000000e-02 9.348000e+00 4.000450e-01 4.000450e-01
	2.050000e+00 5.000000e-02 5.000000e-02 9.450000e+00 4.060443e-01 4.060443e-01
	2.150000e+00 5.000000e-02 5.000000e-02 9.259000e+00 4.360413e-01 4.360413e-01
	2.250000e+00 5.000000e-02 5.000000e-02 9.265000e+00 4.380411e-01 4.380411e-01
	2.350000e+00 5.000000e-02 5.000000e-02 9.198000e+00 7.750232e-01 7.750232e-01
	2.450000e+00 5.000000e-02 5.000000e-02 8.936000e+00 7.580323e-01 7.580323e-01
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d28-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d28-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.300000e+00 1.000000e-01 1.000000e-01 1.899000e-01 1.012373e-02 1.012373e-02
	-2.100000e+00 1.000000e-01 1.000000e-01 2.004000e-01 8.595929e-03 8.595929e-03
	-1.900000e+00 1.000000e-01 1.000000e-01 2.136000e-01 8.600581e-03 8.600581e-03
	-1.700000e+00 1.000000e-01 1.000000e-01 2.328000e-01 8.633076e-03 8.633076e-03
	-1.500000e+00 1.000000e-01 1.000000e-01 2.233000e-01 8.286133e-03 8.286133e-03
	-1.300000e+00 1.000000e-01 1.000000e-01 2.425000e-01 8.374366e-03 8.374366e-03
	-1.100000e+00 1.000000e-01 1.000000e-01 2.528000e-01 8.215230e-03 8.215230e-03
	-9.000000e-01 1.000000e-01 1.000000e-01 2.654000e-01 8.315047e-03 8.315047e-03
	-7.000000e-01 1.000000e-01 1.000000e-01 2.652000e-01 8.309633e-03 8.309633e-03
	-5.000000e-01 1.000000e-01 1.000000e-01 2.753000e-01 8.514693e-03 8.514693e-03
	-3.000000e-01 1.000000e-01 1.000000e-01 2.811000e-01 8.514693e-03 8.514693e-03
	-1.000000e-01 1.000000e-01 1.000000e-01 2.720000e-01 8.414868e-03 8.414868e-03
	1.000000e-01 1.000000e-01 1.000000e-01 2.906000e-01 8.714356e-03 8.714356e-03
	3.000000e-01 1.000000e-01 1.000000e-01 2.827000e-01 8.614523e-03 8.614523e-03
	5.000000e-01 1.000000e-01 1.000000e-01 2.690000e-01 8.309633e-03 8.309633e-03
	7.000000e-01 1.000000e-01 1.000000e-01 2.738000e-01 8.414868e-03 8.414868e-03
	9.000000e-01 1.000000e-01 1.000000e-01 2.724000e-01 8.414868e-03 8.414868e-03
	1.100000e+00 1.000000e-01 1.000000e-01 2.625000e-01 8.414868e-03 8.414868e-03
	1.300000e+00 1.000000e-01 1.000000e-01 2.353000e-01 8.158431e-03 8.158431e-03
	1.500000e+00 1.000000e-01 1.000000e-01 2.231000e-01 8.286133e-03 8.286133e-03
	1.700000e+00 1.000000e-01 1.000000e-01 2.382000e-01 8.633076e-03 8.633076e-03
	1.900000e+00 1.000000e-01 1.000000e-01 2.058000e-01 8.377350e-03 8.377350e-03
	2.100000e+00 1.000000e-01 1.000000e-01 2.013000e-01 8.683317e-03 8.683317e-03
	2.300000e+00 1.000000e-01 1.000000e-01 1.872000e-01 9.915644e-03 9.915644e-03
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d29-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d29-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	-2.450000e+00 5.000000e-02 5.000000e-02 2.892000e-01 1.606113e-02 1.606113e-02
	-2.350000e+00 5.000000e-02 5.000000e-02 2.925000e-01 1.626038e-02 1.626038e-02
	-2.250000e+00 5.000000e-02 5.000000e-02 2.928000e-01 7.629548e-03 7.629548e-03
	-2.150000e+00 5.000000e-02 5.000000e-02 2.966000e-01 7.727872e-03 7.727872e-03
	-2.050000e+00 5.000000e-02 5.000000e-02 3.035000e-01 7.924645e-03 7.924645e-03
	-1.950000e+00 5.000000e-02 5.000000e-02 3.059000e-01 7.924645e-03 7.924645e-03
	-1.850000e+00 5.000000e-02 5.000000e-02 3.149000e-01 5.288667e-03 5.288667e-03
	-1.750000e+00 5.000000e-02 5.000000e-02 3.192000e-01 5.288667e-03 5.288667e-03
	-1.650000e+00 5.000000e-02 5.000000e-02 3.280000e-01 5.508176e-03 5.508176e-03
	-1.550000e+00 5.000000e-02 5.000000e-02 3.286000e-01 5.481788e-03 5.481788e-03
	-1.450000e+00 5.000000e-02 5.000000e-02 3.299000e-01 5.481788e-03 5.481788e-03
	-1.350000e+00 5.000000e-02 5.000000e-02 3.371000e-01 5.604463e-03 5.604463e-03
	-1.250000e+00 5.000000e-02 5.000000e-02 3.430000e-01 2.830194e-03 2.830194e-03
	-1.150000e+00 5.000000e-02 5.000000e-02 3.426000e-01 2.830194e-03 2.830194e-03
	-1.050000e+00 5.000000e-02 5.000000e-02 3.471000e-01 2.778489e-03 2.778489e-03
	-9.500000e-01 5.000000e-02 5.000000e-02 3.496000e-01 2.778489e-03 2.778489e-03
	-8.500000e-01 5.000000e-02 5.000000e-02 3.487000e-01 2.778489e-03 2.778489e-03
	-7.500000e-01 5.000000e-02 5.000000e-02 3.523000e-01 2.778489e-03 2.778489e-03
	-6.500000e-01 5.000000e-02 5.000000e-02 3.554000e-01 2.778489e-03 2.778489e-03
	-5.500000e-01 5.000000e-02 5.000000e-02 3.586000e-01 2.830194e-03 2.830194e-03
	-4.500000e-01 5.000000e-02 5.000000e-02 3.598000e-01 2.830194e-03 2.830194e-03
	-3.500000e-01 5.000000e-02 5.000000e-02 3.594000e-01 2.830194e-03 2.830194e-03
	-2.500000e-01 5.000000e-02 5.000000e-02 3.602000e-01 2.915476e-03 2.915476e-03
	-1.500000e-01 5.000000e-02 5.000000e-02 3.582000e-01 2.830194e-03 2.830194e-03
	-5.000000e-02 5.000000e-02 5.000000e-02 3.643000e-01 2.830194e-03 2.830194e-03
	5.000000e-02 5.000000e-02 5.000000e-02 3.629000e-01 2.915476e-03 2.915476e-03
	1.500000e-01 5.000000e-02 5.000000e-02 3.620000e-01 2.915476e-03 2.915476e-03
	2.500000e-01 5.000000e-02 5.000000e-02 3.618000e-01 2.830194e-03 2.830194e-03
	3.500000e-01 5.000000e-02 5.000000e-02 3.592000e-01 2.778489e-03 2.778489e-03
	4.500000e-01 5.000000e-02 5.000000e-02 3.605000e-01 2.830194e-03 2.830194e-03
	5.500000e-01 5.000000e-02 5.000000e-02 3.595000e-01 2.830194e-03 2.830194e-03
	6.500000e-01 5.000000e-02 5.000000e-02 3.561000e-01 2.778489e-03 2.778489e-03
	7.500000e-01 5.000000e-02 5.000000e-02 3.534000e-01 2.778489e-03 2.778489e-03
	8.500000e-01 5.000000e-02 5.000000e-02 3.521000e-01 2.778489e-03 2.778489e-03
	9.500000e-01 5.000000e-02 5.000000e-02 3.510000e-01 2.778489e-03 2.778489e-03
	1.050000e+00 5.000000e-02 5.000000e-02 3.455000e-01 2.692582e-03 2.692582e-03
	1.150000e+00 5.000000e-02 5.000000e-02 3.508000e-01 2.915476e-03 2.915476e-03
	1.250000e+00 5.000000e-02 5.000000e-02 3.388000e-01 2.692582e-03 2.692582e-03
	1.350000e+00 5.000000e-02 5.000000e-02 3.302000e-01 5.481788e-03 5.481788e-03
	1.450000e+00 5.000000e-02 5.000000e-02 3.240000e-01 5.385165e-03 5.385165e-03
	1.550000e+00 5.000000e-02 5.000000e-02 3.276000e-01 5.385165e-03 5.385165e-03
	1.650000e+00 5.000000e-02 5.000000e-02 3.265000e-01 5.385165e-03 5.385165e-03
	1.750000e+00 5.000000e-02 5.000000e-02 3.209000e-01 5.412024e-03 5.412024e-03
	1.850000e+00 5.000000e-02 5.000000e-02 3.144000e-01 5.288667e-03 5.288667e-03
	1.950000e+00 5.000000e-02 5.000000e-02 3.047000e-01 7.924645e-03 7.924645e-03
	2.050000e+00 5.000000e-02 5.000000e-02 3.030000e-01 7.826238e-03 7.826238e-03
	2.150000e+00 5.000000e-02 5.000000e-02 2.953000e-01 7.629548e-03 7.629548e-03
	2.250000e+00 5.000000e-02 5.000000e-02 2.901000e-01 7.531268e-03 7.531268e-03
	2.350000e+00 5.000000e-02 5.000000e-02 2.881000e-01 1.596152e-02 1.596152e-02
	2.450000e+00 5.000000e-02 5.000000e-02 2.839000e-01 1.576230e-02 1.576230e-02
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d30-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d30-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.260000e-01 2.600000e-02 2.400000e-02 1.461000e+01 1.350037e+00 1.350037e+00
	1.750000e-01 2.500000e-02 2.500000e-02 1.199000e+01 5.200961e-01 5.200961e-01
	2.250000e-01 2.500000e-02 2.500000e-02 9.199000e+00 2.900621e-01 2.900621e-01
	2.750000e-01 2.500000e-02 2.500000e-02 6.937000e+00 1.600781e-01 1.600781e-01
	3.250000e-01 2.500000e-02 2.500000e-02 5.213000e+00 1.060754e-01 1.060754e-01
	3.750000e-01 2.500000e-02 2.500000e-02 3.968000e+00 7.605919e-02 7.605919e-02
	4.250000e-01 2.500000e-02 2.500000e-02 3.054000e+00 4.709565e-02 4.709565e-02
	4.750000e-01 2.500000e-02 2.500000e-02 2.346000e+00 3.106445e-02 3.106445e-02
	5.480000e-01 4.800000e-02 5.200000e-02 1.644000e+00 2.202272e-02 2.202272e-02
	6.480000e-01 4.800000e-02 5.200000e-02 1.037000e+00 1.303840e-02 1.303840e-02
	7.480000e-01 4.800000e-02 5.200000e-02 6.740000e-01 7.922752e-03 7.922752e-03
	8.480000e-01 4.800000e-02 5.200000e-02 4.544000e-01 5.024938e-03 5.024938e-03
	9.480000e-01 4.800000e-02 5.200000e-02 3.088000e-01 3.125700e-03 3.125700e-03
	1.048000e+00 4.800000e-02 5.200000e-02 2.141000e-01 2.022375e-03 2.022375e-03
	1.148000e+00 4.800000e-02 5.200000e-02 1.508000e-01 1.414214e-03 1.414214e-03
	1.248000e+00 4.800000e-02 5.200000e-02 1.083000e-01 9.219544e-04 9.219544e-04
	1.348000e+00 4.800000e-02 5.200000e-02 7.824000e-02 6.161169e-04 6.161169e-04
	1.448000e+00 4.800000e-02 5.200000e-02 5.741000e-02 4.148494e-04 4.148494e-04
	1.548000e+00 4.800000e-02 5.200000e-02 4.270000e-02 3.036445e-04 3.036445e-04
	1.648000e+00 4.800000e-02 5.200000e-02 3.158000e-02 2.213594e-04 2.213594e-04
	1.748000e+00 4.800000e-02 5.200000e-02 2.384000e-02 1.615549e-04 1.615549e-04
	1.848000e+00 4.800000e-02 5.200000e-02 1.827000e-02 1.208305e-04 1.208305e-04
	1.949000e+00 4.900000e-02 5.100000e-02 1.395000e-02 8.944272e-05 8.944272e-05
	2.049000e+00 4.900000e-02 5.100000e-02 1.070000e-02 6.403124e-05 6.403124e-05
	2.149000e+00 4.900000e-02 5.100000e-02 8.368000e-03 4.534314e-05 4.534314e-05
	2.248000e+00 4.800000e-02 5.200000e-02 6.484000e-03 3.023243e-05 3.023243e-05
	2.348000e+00 4.800000e-02 5.200000e-02 5.024000e-03 3.111270e-05 3.111270e-05
	2.449000e+00 4.900000e-02 5.100000e-02 4.113000e-03 2.831960e-05 2.831960e-05
	2.616000e+00 1.160000e-01 1.340000e-01 2.712000e-03 1.200000e-05 1.200000e-05
	2.867000e+00 1.170000e-01 1.330000e-01 1.618000e-03 9.000000e-06 9.000000e-06
	3.116000e+00 1.160000e-01 1.340000e-01 1.001000e-03 7.000000e-06 7.000000e-06
	3.365000e+00 1.150000e-01 1.350000e-01 6.049000e-04 6.060528e-06 6.060528e-06
	3.723000e+00 2.230000e-01 2.770000e-01 3.134000e-04 4.830114e-06 4.830114e-06
	4.387000e+00 3.870000e-01 6.130000e-01 9.767000e-05 3.242746e-06 3.242746e-06
	5.400000e+00 4.000000e-01 6.000000e-01 2.247000e-05 3.900000e-07 3.900000e-07
	6.696000e+00 6.960000e-01 1.304000e+00 4.779000e-06 1.060000e-07 1.060000e-07
	8.772000e+00 7.720000e-01 1.228000e+00 7.669000e-07 4.156008e-08 4.156008e-08
	1.170000e+01 1.700000e+00 3.300000e+00 1.230000e-07 2.514458e-08 1.223806e-08
	1.607000e+01 1.070000e+00 3.930000e+00 1.418000e-08 3.471167e-09 2.296127e-09
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d31-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d31-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.260000e-01 2.600000e-02 2.400000e-02 1.943000e+01 1.920026e+00 1.920026e+00
	1.750000e-01 2.500000e-02 2.500000e-02 1.578000e+01 7.500667e-01 7.500667e-01
	2.250000e-01 2.500000e-02 2.500000e-02 1.184000e+01 4.400000e-01 4.400000e-01
	2.750000e-01 2.500000e-02 2.500000e-02 8.875000e+00 2.490020e-01 2.490020e-01
	3.250000e-01 2.500000e-02 2.500000e-02 6.719000e+00 1.720029e-01 1.720029e-01
	3.750000e-01 2.500000e-02 2.500000e-02 5.153000e+00 1.240040e-01 1.240040e-01
	4.250000e-01 2.500000e-02 2.500000e-02 4.004000e+00 8.200610e-02 8.200610e-02
	4.750000e-01 2.500000e-02 2.500000e-02 3.144000e+00 5.800862e-02 5.800862e-02
	5.480000e-01 4.800000e-02 5.200000e-02 2.246000e+00 4.100000e-02 4.100000e-02
	6.480000e-01 4.800000e-02 5.200000e-02 1.475000e+00 2.700000e-02 2.700000e-02
	7.480000e-01 4.800000e-02 5.200000e-02 9.988000e-01 1.750114e-02 1.750114e-02
	8.480000e-01 4.800000e-02 5.200000e-02 6.949000e-01 1.180042e-02 1.180042e-02
	9.480000e-01 4.800000e-02 5.200000e-02 4.928000e-01 8.100617e-03 8.100617e-03
	1.048000e+00 4.800000e-02 5.200000e-02 3.559000e-01 5.700877e-03 5.700877e-03
	1.148000e+00 4.800000e-02 5.200000e-02 2.615000e-01 4.101219e-03 4.101219e-03
	1.248000e+00 4.800000e-02 5.200000e-02 1.941000e-01 3.001666e-03 3.001666e-03
	1.348000e+00 4.800000e-02 5.200000e-02 1.461000e-01 2.200000e-03 2.200000e-03
	1.448000e+00 4.800000e-02 5.200000e-02 1.110000e-01 1.700000e-03 1.700000e-03
	1.548000e+00 4.800000e-02 5.200000e-02 8.519000e-02 1.250360e-03 1.250360e-03
	1.649000e+00 4.900000e-02 5.100000e-02 6.585000e-02 9.602083e-04 9.602083e-04
	1.749000e+00 4.900000e-02 5.100000e-02 5.143000e-02 7.402702e-04 7.402702e-04
	1.849000e+00 4.900000e-02 5.100000e-02 4.047000e-02 5.703508e-04 5.703508e-04
	1.949000e+00 4.900000e-02 5.100000e-02 3.199000e-02 4.501111e-04 4.501111e-04
	2.049000e+00 4.900000e-02 5.100000e-02 2.548000e-02 3.501428e-04 3.501428e-04
	2.149000e+00 4.900000e-02 5.100000e-02 2.041000e-02 2.801785e-04 2.801785e-04
	2.249000e+00 4.900000e-02 5.100000e-02 1.644000e-02 2.202272e-04 2.202272e-04
	2.349000e+00 4.900000e-02 5.100000e-02 1.335000e-02 1.802776e-04 1.802776e-04
	2.449000e+00 4.900000e-02 5.100000e-02 1.090000e-02 1.503330e-04 1.503330e-04
	2.617000e+00 1.170000e-01 1.330000e-01 7.735000e-03 1.020784e-04 1.020784e-04
	2.867000e+00 1.170000e-01 1.330000e-01 4.842000e-03 6.307139e-05 6.307139e-05
	3.118000e+00 1.180000e-01 1.320000e-01 3.105000e-03 4.004997e-05 4.004997e-05
	3.368000e+00 1.180000e-01 1.320000e-01 2.034000e-03 2.607681e-05 2.607681e-05
	3.725000e+00 2.250000e-01 2.750000e-01 1.149000e-03 1.503330e-05 1.503330e-05
	4.227000e+00 2.270000e-01 2.730000e-01 5.576000e-04 8.714356e-06 8.714356e-06
	4.729000e+00 2.290000e-01 2.710000e-01 2.906000e-04 5.508176e-06 5.508176e-06
	5.427000e+00 4.270000e-01 5.730000e-01 1.259000e-04 1.711724e-06 1.711724e-06
	6.436000e+00 4.360000e-01 5.640000e-01 4.555000e-05 7.951101e-07 7.951101e-07
	7.443000e+00 4.430000e-01 5.570000e-01 1.922000e-05 3.634556e-07 3.634556e-07
	8.456000e+00 4.560000e-01 5.440000e-01 8.950000e-06 3.411510e-07 3.411510e-07
	9.455000e+00 4.550000e-01 5.450000e-01 4.631000e-06 1.083421e-07 1.083421e-07
	1.169000e+01 1.690000e+00 3.310000e+00 1.124000e-06 1.440555e-07 1.000800e-07
	1.692000e+01 1.920000e+00 3.080000e+00 1.270000e-07 1.602529e-08 1.103676e-08
	2.335000e+01 3.350000e+00 6.650000e+00 1.752000e-08 3.687818e-09 1.687157e-09
	3.609000e+01 6.090000e+00 1.391000e+01 1.223000e-09 3.702769e-10 1.230325e-10
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d32-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d32-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	2.616000e+00 1.160000e-01 1.340000e-01 2.011000e-02 1.878829e-04 1.878829e-04
	2.867000e+00 1.170000e-01 1.330000e-01 1.132000e-02 1.081665e-04 1.081665e-04
	3.116000e+00 1.160000e-01 1.340000e-01 6.988000e-03 7.161006e-05 7.161006e-05
	3.365000e+00 1.150000e-01 1.350000e-01 4.197000e-03 4.675468e-05 4.675468e-05
	3.721000e+00 2.210000e-01 2.790000e-01 2.160000e-03 2.202272e-05 2.202272e-05
	4.384000e+00 3.840000e-01 6.160000e-01 6.545000e-04 8.323461e-06 8.323461e-06
	5.404000e+00 4.040000e-01 5.960000e-01 1.501000e-04 2.400000e-06 2.400000e-06
	6.692000e+00 6.920000e-01 1.308000e+00 3.120000e-05 6.500000e-07 6.500000e-07
	8.777000e+00 7.770000e-01 1.223000e+00 4.954000e-06 2.030000e-07 2.030000e-07
	1.170000e+01 1.700000e+00 3.300000e+00 8.069000e-07 1.729819e-07 8.406694e-08
	1.604000e+01 1.040000e+00 3.960000e+00 8.392000e-08 2.053084e-08 1.295967e-08
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d33-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d33-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	2.617000e+00 1.170000e-01 1.330000e-01 2.369000e-02 3.501428e-04 3.501428e-04
	2.867000e+00 1.170000e-01 1.330000e-01 1.411000e-02 2.102380e-04 2.102380e-04
	3.118000e+00 1.180000e-01 1.320000e-01 9.098000e-03 1.362351e-04 1.362351e-04
	3.368000e+00 1.180000e-01 1.320000e-01 5.930000e-03 8.920202e-05 8.920202e-05
	3.725000e+00 2.250000e-01 2.750000e-01 3.340000e-03 4.909175e-05 4.909175e-05
	4.227000e+00 2.270000e-01 2.730000e-01 1.615000e-03 2.408319e-05 2.408319e-05
	4.729000e+00 2.290000e-01 2.710000e-01 8.385000e-04 1.294681e-05 1.294681e-05
	5.427000e+00 4.270000e-01 5.730000e-01 3.627000e-04 5.522681e-06 5.522681e-06
	6.436000e+00 4.360000e-01 5.640000e-01 1.304000e-04 1.923538e-06 1.923538e-06
	7.442000e+00 4.420000e-01 5.580000e-01 5.514000e-05 8.336066e-07 8.336066e-07
	8.456000e+00 4.560000e-01 5.440000e-01 2.564000e-05 4.002499e-07 4.002499e-07
	9.454000e+00 4.540000e-01 5.460000e-01 1.319000e-05 2.184033e-07 2.184033e-07
	1.168000e+01 1.680000e+00 3.320000e+00 3.182000e-06 4.251694e-07 3.032375e-07
	1.692000e+01 1.920000e+00 3.080000e+00 3.554000e-07 4.647849e-08 3.261196e-08
	2.337000e+01 3.370000e+00 6.630000e+00 4.943000e-08 1.041094e-08 4.508570e-09
	3.611000e+01 6.110000e+00 1.389000e+01 3.582000e-09 1.092858e-09 3.554406e-10
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d34-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d34-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	2.000000e+01 5.000000e-01 5.000000e-01 6.827000e-02 2.645600e-03 1.753767e-03
	2.100000e+01 5.000000e-01 5.000000e-01 6.373000e-02 2.435775e-03 1.605522e-03
	2.200000e+01 5.000000e-01 5.000000e-01 5.996000e-02 2.238973e-03 1.480608e-03
	2.300000e+01 5.000000e-01 5.000000e-01 5.647000e-02 2.014671e-03 1.339589e-03
	2.400000e+01 5.000000e-01 5.000000e-01 5.328000e-02 1.792038e-03 1.201083e-03
	2.500000e+01 5.000000e-01 5.000000e-01 5.034000e-02 1.562626e-03 1.058017e-03
	2.600000e+01 5.000000e-01 5.000000e-01 4.721000e-02 1.337236e-03 9.284934e-04
	2.700000e+01 5.000000e-01 5.000000e-01 4.446000e-02 1.135341e-03 8.203658e-04
	2.800000e+01 5.000000e-01 5.000000e-01 4.155000e-02 9.660745e-04 7.262231e-04
	2.900000e+01 5.000000e-01 5.000000e-01 3.888000e-02 8.354639e-04 6.603787e-04
	3.000000e+01 5.000000e-01 5.000000e-01 3.683000e-02 7.291776e-04 5.993330e-04
	3.148000e+01 9.800000e-01 1.020000e+00 3.292000e-02 4.750789e-04 3.827532e-04
	3.348000e+01 9.800000e-01 1.020000e+00 2.842000e-02 3.640055e-04 3.423449e-04
	3.548000e+01 9.800000e-01 1.020000e+00 2.457000e-02 3.361547e-04 3.443835e-04
	3.748000e+01 9.800000e-01 1.020000e+00 2.106000e-02 3.522783e-04 4.244997e-04
	3.948000e+01 9.800000e-01 1.020000e+00 1.812000e-02 3.679674e-04 5.162364e-04
	4.148000e+01 9.800000e-01 1.020000e+00 1.550000e-02 3.679674e-04 5.860034e-04
	4.348000e+01 9.800000e-01 1.020000e+00 1.330000e-02 3.780212e-04 6.239391e-04
	4.548000e+01 9.800000e-01 1.020000e+00 1.137000e-02 3.911521e-04 6.356886e-04
	4.748000e+01 9.800000e-01 1.020000e+00 9.575000e-03 3.989098e-04 6.394576e-04
	4.948000e+01 9.800000e-01 1.020000e+00 8.088000e-03 4.011508e-04 6.376402e-04
	5.148000e+01 9.800000e-01 1.020000e+00 6.752000e-03 3.838033e-04 6.056278e-04
	5.348000e+01 9.800000e-01 1.020000e+00 5.575000e-03 3.557106e-04 5.678952e-04
	5.547000e+01 9.700000e-01 1.030000e+00 4.623000e-03 3.216971e-04 5.159738e-04
	5.747000e+01 9.700000e-01 1.030000e+00 3.800000e-03 2.840158e-04 4.559057e-04
	5.947000e+01 9.700000e-01 1.030000e+00 3.179000e-03 2.558202e-04 4.096096e-04
	6.147000e+01 9.700000e-01 1.030000e+00 2.514000e-03 2.173684e-04 3.429052e-04
	6.349000e+01 9.900000e-01 1.010000e+00 2.079000e-03 1.981338e-04 3.087167e-04
	6.678000e+01 2.280000e+00 2.720000e+00 1.468000e-03 1.527383e-04 2.437724e-04
	7.172000e+01 2.220000e+00 2.780000e+00 8.174000e-04 1.029027e-04 1.630245e-04
	7.671000e+01 2.210000e+00 2.790000e+00 4.417000e-04 6.294966e-05 9.862682e-05
	8.366000e+01 4.160000e+00 5.840000e+00 1.937000e-04 2.943892e-05 4.456007e-05
	9.287000e+01 3.370000e+00 6.630000e+00 5.094000e-05 1.526774e-05 1.836634e-05
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d35-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d35-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	2.000000e+01 5.000000e-01 5.000000e-01 3.602000e-02 1.122854e-03 6.846897e-04
	2.100000e+01 5.000000e-01 5.000000e-01 3.431000e-02 1.053043e-03 6.549046e-04
	2.200000e+01 5.000000e-01 5.000000e-01 3.284000e-02 9.932271e-04 6.251400e-04
	2.300000e+01 5.000000e-01 5.000000e-01 3.150000e-02 9.433981e-04 5.953990e-04
	2.400000e+01 5.000000e-01 5.000000e-01 3.042000e-02 8.935883e-04 5.755867e-04
	2.500000e+01 5.000000e-01 5.000000e-01 2.931000e-02 8.528775e-04 5.445181e-04
	2.600000e+01 5.000000e-01 5.000000e-01 2.822000e-02 8.030567e-04 5.147815e-04
	2.700000e+01 5.000000e-01 5.000000e-01 2.721000e-02 7.632169e-04 4.850773e-04
	2.800000e+01 5.000000e-01 5.000000e-01 2.627000e-02 7.333485e-04 4.554119e-04
	2.900000e+01 5.000000e-01 5.000000e-01 2.560000e-02 7.034913e-04 4.356604e-04
	3.000000e+01 5.000000e-01 5.000000e-01 2.473000e-02 6.736468e-04 4.159327e-04
	3.100000e+01 5.000000e-01 5.000000e-01 2.381000e-02 6.438167e-04 3.863936e-04
	3.200000e+01 5.000000e-01 5.000000e-01 2.320000e-02 6.140033e-04 3.667424e-04
	3.300000e+01 5.000000e-01 5.000000e-01 2.241000e-02 5.830952e-04 3.354102e-04
	3.400000e+01 5.000000e-01 5.000000e-01 2.165000e-02 5.532630e-04 3.157531e-04
	3.500000e+01 5.000000e-01 5.000000e-01 2.103000e-02 5.234501e-04 2.961419e-04
	3.600000e+01 5.000000e-01 5.000000e-01 2.036000e-02 4.936598e-04 2.668333e-04
	3.700000e+01 5.000000e-01 5.000000e-01 1.976000e-02 4.539824e-04 2.473863e-04
	3.800000e+01 5.000000e-01 5.000000e-01 1.912000e-02 4.242641e-04 2.280351e-04
	3.900000e+01 5.000000e-01 5.000000e-01 1.852000e-02 3.847077e-04 1.992486e-04
	4.000000e+01 5.000000e-01 5.000000e-01 1.788000e-02 3.452535e-04 1.802776e-04
	4.100000e+01 5.000000e-01 5.000000e-01 1.734000e-02 3.157531e-04 1.615549e-04
	4.200000e+01 5.000000e-01 5.000000e-01 1.678000e-02 2.863564e-04 1.431782e-04
	4.300000e+01 5.000000e-01 5.000000e-01 1.631000e-02 2.570992e-04 1.341641e-04
	4.400000e+01 5.000000e-01 5.000000e-01 1.584000e-02 2.256103e-04 1.118034e-04
	4.500000e+01 5.000000e-01 5.000000e-01 1.532000e-02 2.061553e-04 9.433981e-05
	4.600000e+01 5.000000e-01 5.000000e-01 1.479000e-02 1.868154e-04 8.602325e-05
	4.700000e+01 5.000000e-01 5.000000e-01 1.429000e-02 1.581139e-04 7.071068e-05
	4.800000e+01 5.000000e-01 5.000000e-01 1.390000e-02 1.392839e-04 5.830952e-05
	4.900000e+01 5.000000e-01 5.000000e-01 1.345000e-02 1.208305e-04 5.385165e-05
	5.000000e+01 5.000000e-01 5.000000e-01 1.305000e-02 1.029563e-04 5.000000e-05
	5.100000e+01 5.000000e-01 5.000000e-01 1.267000e-02 8.602325e-05 5.099020e-05
	5.200000e+01 5.000000e-01 5.000000e-01 1.216000e-02 7.071068e-05 5.385165e-05
	5.300000e+01 5.000000e-01 5.000000e-01 1.177000e-02 6.403124e-05 5.830952e-05
	5.400000e+01 5.000000e-01 5.000000e-01 1.138000e-02 7.071068e-05 7.071068e-05
	5.500000e+01 5.000000e-01 5.000000e-01 1.096000e-02 7.810250e-05 7.810250e-05
	5.600000e+01 5.000000e-01 5.000000e-01 1.065000e-02 8.062258e-05 8.062258e-05
	5.700000e+01 5.000000e-01 5.000000e-01 1.024000e-02 8.944272e-05 9.848858e-05
	5.800000e+01 5.000000e-01 5.000000e-01 9.889000e-03 9.525755e-05 1.153170e-04
	5.900000e+01 5.000000e-01 5.000000e-01 9.517000e-03 1.029563e-04 1.309198e-04
	6.000000e+01 5.000000e-01 5.000000e-01 9.274000e-03 1.117900e-04 1.468400e-04
	6.149000e+01 9.900000e-01 1.010000e+00 8.707000e-03 1.183596e-04 1.653874e-04
	6.349000e+01 9.900000e-01 1.010000e+00 8.058000e-03 1.317953e-04 1.919088e-04
	6.549000e+01 9.900000e-01 1.010000e+00 7.469000e-03 1.423938e-04 2.145810e-04
	6.749000e+01 9.900000e-01 1.010000e+00 6.901000e-03 1.491107e-04 2.343374e-04
	6.949000e+01 9.900000e-01 1.010000e+00 6.381000e-03 1.548709e-04 2.531403e-04
	7.149000e+01 9.900000e-01 1.010000e+00 5.898000e-03 1.596653e-04 2.689851e-04
	7.349000e+01 9.900000e-01 1.010000e+00 5.438000e-03 1.634870e-04 2.818599e-04
	7.549000e+01 9.900000e-01 1.010000e+00 5.017000e-03 1.664602e-04 2.908333e-04
	7.749000e+01 9.900000e-01 1.010000e+00 4.618000e-03 1.683152e-04 2.947490e-04
	7.949000e+01 9.900000e-01 1.010000e+00 4.219000e-03 1.672005e-04 2.946795e-04
	8.149000e+01 9.900000e-01 1.010000e+00 3.861000e-03 1.650969e-04 2.916196e-04
	8.349000e+01 9.900000e-01 1.010000e+00 3.532000e-03 1.620031e-04 2.885620e-04
	8.549000e+01 9.900000e-01 1.010000e+00 3.237000e-03 1.589119e-04 2.845083e-04
	8.749000e+01 9.900000e-01 1.010000e+00 2.941000e-03 1.539415e-04 2.785193e-04
	8.949000e+01 9.900000e-01 1.010000e+00 2.686000e-03 1.498566e-04 2.734685e-04
	9.149000e+01 9.900000e-01 1.010000e+00 2.443000e-03 1.447791e-04 2.664226e-04
	9.349000e+01 9.900000e-01 1.010000e+00 2.237000e-03 1.406983e-04 2.613752e-04
	9.549000e+01 9.900000e-01 1.010000e+00 2.033000e-03 1.347294e-04 2.533871e-04
	9.749000e+01 9.900000e-01 1.010000e+00 1.833000e-03 1.276636e-04 2.423489e-04
	9.949000e+01 9.900000e-01 1.010000e+00 1.647000e-03 1.205985e-04 2.293142e-04
	1.015000e+02 1.000000e+00 1.000000e+00 1.472000e-03 1.126410e-04 2.153346e-04
	1.062000e+02 3.700000e+00 4.300000e+00 1.161000e-03 9.812747e-05 1.870668e-04
	1.150000e+02 4.500000e+00 5.500000e+00 7.152000e-04 7.208994e-05 1.369473e-04
	1.250000e+02 4.500000e+00 5.500000e+00 4.067000e-04 4.997299e-05 9.453856e-05
	1.409000e+02 1.040000e+01 1.960000e+01 1.317000e-04 2.022004e-05 3.831057e-05
	1.719000e+02 1.140000e+01 2.860000e+01 1.309000e-05 3.000433e-06 5.425763e-06
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d36-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d36-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.000000e+00 5.000000e-01 5.000000e-01 8.504000e-01 6.135145e-03 6.135145e-03
	2.000000e+00 5.000000e-01 5.000000e-01 1.182000e-01 2.594224e-03 2.594224e-03
	3.000000e+00 5.000000e-01 5.000000e-01 2.323000e-02 1.212642e-03 1.212642e-03
	4.000000e+00 5.000000e-01 5.000000e-01 5.575000e-03 5.266422e-04 5.266422e-04
	5.630000e+00 1.130000e+00 2.870000e+00 6.542000e-04 8.939871e-05 8.939871e-05
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d37-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d37-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.000000e+00 5.000000e-01 5.000000e-01 6.448000e-01 3.832754e-03 3.832754e-03
	2.000000e+00 5.000000e-01 5.000000e-01 2.041000e-01 7.615773e-04 7.615773e-04
	3.000000e+00 5.000000e-01 5.000000e-01 8.139000e-02 1.041393e-03 1.041393e-03
	4.000000e+00 5.000000e-01 5.000000e-01 3.574000e-02 7.727872e-04 7.727872e-04
	5.000000e+00 5.000000e-01 5.000000e-01 1.651000e-02 5.080354e-04 5.080354e-04
	6.000000e+00 5.000000e-01 5.000000e-01 8.257000e-03 3.198828e-04 3.198828e-04
	7.000000e+00 5.000000e-01 5.000000e-01 4.192000e-03 2.025290e-04 2.025290e-04
	8.000000e+00 5.000000e-01 5.000000e-01 2.207000e-03 1.228007e-04 1.228007e-04
	9.000000e+00 5.000000e-01 5.000000e-01 1.202000e-03 7.621680e-05 7.621680e-05
	1.000000e+01 5.000000e-01 5.000000e-01 6.572000e-04 4.837706e-05 4.837706e-05
	1.138000e+01 8.800000e-01 1.120000e+00 2.964000e-04 2.471943e-05 2.471943e-05
	1.338000e+01 8.800000e-01 1.120000e+00 1.108000e-04 1.041009e-05 1.041009e-05
	1.540000e+01 9.000000e-01 1.100000e+00 4.925000e-05 5.293997e-06 5.293997e-06
	1.789000e+01 1.390000e+00 2.610000e+00 1.296000e-05 1.782807e-06 1.782807e-06
	2.251000e+01 2.010000e+00 2.990000e+00 2.907000e-06 6.802955e-07 6.802955e-07
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d38-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d38-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.000000e+00 5.000000e-01 5.000000e-01 3.138000e+00 7.294518e-02 7.294518e-02
	2.000000e+00 5.000000e-01 5.000000e-01 3.317000e+00 1.258014e-01 1.258014e-01
	3.000000e+00 5.000000e-01 5.000000e-01 3.443000e+00 1.971903e-01 1.971903e-01
	4.000000e+00 5.000000e-01 5.000000e-01 3.552000e+00 3.255764e-01 3.255764e-01
	5.630000e+00 1.130000e+00 2.870000e+00 3.816000e+00 4.640970e-01 4.640970e-01
	END YODA_SCATTER2D

	BEGIN YODA_SCATTER2D /REF/ATLAS_2010_S8918562/d39-x01-y01
	IsRef=1
	Path=/REF/ATLAS_2010_S8918562/d39-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.000000e+00 5.000000e-01 5.000000e-01 3.267000e+00 6.512296e-02 6.512296e-02
	2.000000e+00 5.000000e-01 5.000000e-01 3.374000e+00 6.826419e-02 6.826419e-02
	3.000000e+00 5.000000e-01 5.000000e-01 3.466000e+00 7.045566e-02 7.045566e-02
	4.000000e+00 5.000000e-01 5.000000e-01 3.558000e+00 7.283543e-02 7.283543e-02
	5.000000e+00 5.000000e-01 5.000000e-01 3.653000e+00 7.746612e-02 7.746612e-02
	6.000000e+00 5.000000e-01 5.000000e-01 3.754000e+00 8.246211e-02 8.246211e-02
	7.000000e+00 5.000000e-01 5.000000e-01 3.861000e+00 8.918520e-02 8.918520e-02
	8.000000e+00 5.000000e-01 5.000000e-01 3.972000e+00 9.786215e-02 9.786215e-02
	9.000000e+00 5.000000e-01 5.000000e-01 4.093000e+00 1.100227e-01 1.100227e-01
	1.000000e+01 5.000000e-01 5.000000e-01 4.209000e+00 1.238225e-01 1.238225e-01
	1.138000e+01 8.800000e-01 1.120000e+00 4.375000e+00 1.395887e-01 1.395887e-01
	1.338000e+01 8.800000e-01 1.120000e+00 4.678000e+00 1.863894e-01 1.863894e-01
	1.540000e+01 9.000000e-01 1.100000e+00 5.002000e+00 2.422499e-01 2.422499e-01
	1.789000e+01 1.390000e+00 2.610000e+00 5.363000e+00 3.503327e-01 3.503327e-01
	2.251000e+01 2.010000e+00 2.990000e+00 6.080000e+00 6.067364e-01 6.067364e-01
	END YODA_SCATTER2D
	-
	diff --git a/data/refdata/ATLAS_2011_I929691.yoda b/data/refdata/ATLAS_2011_I929691.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2011_I929691.yoda
	@@ -0,0 +1,619 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d01-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.405000e-02 1.950000e-03 1.950000e-03 4.304000e+01 2.020742e+00 2.020742e+00
	+1.860000e-02 2.600000e-03 2.600000e-03 1.007000e+02 3.178050e+00 3.178050e+00
	+2.460000e-02 3.400000e-03 3.400000e-03 1.132000e+02 3.436568e+00 3.436568e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 9.569000e+01 3.317891e+00 3.317891e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 7.317000e+01 2.618416e+00 2.618416e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.370000e+01 2.206581e+00 2.206581e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.680000e+01 1.631104e+00 1.631104e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 2.358000e+01 1.176138e+00 1.176138e+00
	+1.314500e-01 1.825000e-02 1.825000e-02 1.397000e+01 8.438009e-01 8.438009e-01
	+1.738500e-01 2.415000e-02 2.415000e-02 7.916000e+00 5.265453e-01 5.265453e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 3.977000e+00 3.416958e-01 3.416958e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.734000e+00 1.997248e-01 1.997248e-01
	+4.018500e-01 5.575000e-02 5.575000e-02 6.573000e-01 9.450608e-02 9.450608e-02
	+5.313000e-01 7.370000e-02 7.370000e-02 2.055000e-01 4.754293e-02 4.754293e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 5.147000e-02 2.436682e-02 2.436682e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d02-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+8.050000e-03 1.150000e-03 1.150000e-03 3.209000e+01 2.107724e+00 2.107724e+00
	+1.065000e-02 1.450000e-03 1.450000e-03 1.252000e+02 6.082763e+00 6.082763e+00
	+1.405000e-02 1.950000e-03 1.950000e-03 1.819000e+02 7.539231e+00 7.539231e+00
	+1.860000e-02 2.600000e-03 2.600000e-03 1.644000e+02 6.356886e+00 6.356886e+00
	+2.460000e-02 3.400000e-03 3.400000e-03 1.335000e+02 5.124451e+00 5.124451e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 1.012000e+02 3.956008e+00 3.956008e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 7.575000e+01 2.993226e+00 2.993226e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.291000e+01 2.206015e+00 2.206015e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.577000e+01 1.579652e+00 1.579652e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 2.257000e+01 1.079120e+00 1.079120e+00
	+1.314500e-01 1.825000e-02 1.825000e-02 1.328000e+01 6.926038e-01 6.926038e-01
	+1.738500e-01 2.415000e-02 2.415000e-02 7.312000e+00 4.415699e-01 4.415699e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 3.811000e+00 2.581550e-01 2.581550e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.666000e+00 1.508410e-01 1.508410e-01
	+4.018500e-01 5.575000e-02 5.575000e-02 6.541000e-01 7.918188e-02 7.918188e-02
	+5.313000e-01 7.370000e-02 7.370000e-02 2.253000e-01 4.623127e-02 4.623127e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 6.794000e-02 3.910165e-02 3.910165e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d03-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.050000e-03 8.500000e-04 8.500000e-04 8.191000e+01 7.030512e+00 7.030512e+00
	+8.050000e-03 1.150000e-03 1.150000e-03 2.413000e+02 1.274402e+01 1.274402e+01
	+1.065000e-02 1.450000e-03 1.450000e-03 2.635000e+02 1.202414e+01 1.202414e+01
	+1.405000e-02 1.950000e-03 1.950000e-03 2.262000e+02 1.061037e+01 1.061037e+01
	+1.860000e-02 2.600000e-03 2.600000e-03 1.907000e+02 8.769265e+00 8.769265e+00
	+2.460000e-02 3.400000e-03 3.400000e-03 1.427000e+02 6.161980e+00 6.161980e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 1.071000e+02 5.093133e+00 5.093133e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 8.187000e+01 3.628361e+00 3.628361e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.370000e+01 2.304821e+00 2.304821e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.399000e+01 1.711198e+00 1.711198e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 2.303000e+01 1.323820e+00 1.323820e+00
	+1.314500e-01 1.825000e-02 1.825000e-02 1.328000e+01 8.139410e-01 8.139410e-01
	+1.738500e-01 2.415000e-02 2.415000e-02 7.043000e+00 4.432212e-01 4.432212e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 3.829000e+00 3.334382e-01 3.334382e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.600000e+00 1.618394e-01 1.618394e-01
	+4.018500e-01 5.575000e-02 5.575000e-02 6.431000e-01 1.263450e-01 1.263450e-01
	+5.313000e-01 7.370000e-02 7.370000e-02 2.448000e-01 6.046263e-02 6.046263e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 3.722000e-02 2.154877e-02 2.154877e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d04-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.600000e-03 6.000000e-04 6.000000e-04 1.028000e+02 1.460137e+01 1.460137e+01
	+6.050000e-03 8.500000e-04 8.500000e-04 2.926000e+02 2.479234e+01 2.479234e+01
	+8.050000e-03 1.150000e-03 1.150000e-03 3.196000e+02 2.438237e+01 2.438237e+01
	+1.065000e-02 1.450000e-03 1.450000e-03 2.833000e+02 1.889153e+01 1.889153e+01
	+1.405000e-02 1.950000e-03 1.950000e-03 2.411000e+02 1.332216e+01 1.332216e+01
	+1.860000e-02 2.600000e-03 2.600000e-03 1.934000e+02 1.170470e+01 1.170470e+01
	+2.460000e-02 3.400000e-03 3.400000e-03 1.571000e+02 9.763708e+00 9.763708e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 1.153000e+02 7.357309e+00 7.357309e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 8.260000e+01 5.217394e+00 5.217394e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.368000e+01 4.025916e+00 4.025916e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.439000e+01 2.252110e+00 2.252110e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 2.177000e+01 1.900789e+00 1.900789e+00
	+1.314500e-01 1.825000e-02 1.825000e-02 1.208000e+01 1.033538e+00 1.033538e+00
	+1.738500e-01 2.415000e-02 2.415000e-02 6.905000e+00 6.200556e-01 6.200556e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 4.126000e+00 4.463272e-01 4.463272e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.358000e+00 1.995420e-01 1.995420e-01
	+4.018500e-01 5.575000e-02 5.575000e-02 6.220000e-01 2.079259e-01 2.079259e-01
	+5.313000e-01 7.370000e-02 7.370000e-02 2.026000e-01 9.305622e-02 9.305622e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 2.063000e-02 1.336075e-02 1.336075e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d05-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.500000e-03 5.000000e-04 5.000000e-04 2.354000e+02 8.732125e+00 8.732125e+00
	+4.600000e-03 6.000000e-04 6.000000e-04 5.092000e+02 1.645843e+01 1.645843e+01
	+6.050000e-03 8.500000e-04 8.500000e-04 5.273000e+02 1.793683e+01 1.793683e+01
	+8.050000e-03 1.150000e-03 1.150000e-03 4.335000e+02 1.418238e+01 1.418238e+01
	+1.065000e-02 1.450000e-03 1.450000e-03 3.508000e+02 1.101681e+01 1.101681e+01
	+1.405000e-02 1.950000e-03 1.950000e-03 2.772000e+02 8.415462e+00 8.415462e+00
	+1.860000e-02 2.600000e-03 2.600000e-03 2.149000e+02 6.894926e+00 6.894926e+00
	+2.460000e-02 3.400000e-03 3.400000e-03 1.607000e+02 5.162364e+00 5.162364e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 1.166000e+02 3.889730e+00 3.889730e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 7.998000e+01 2.631368e+00 2.631368e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.248000e+01 1.794269e+00 1.794269e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.409000e+01 1.296919e+00 1.296919e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 2.112000e+01 8.100617e-01 8.100617e-01
	+1.314500e-01 1.825000e-02 1.825000e-02 1.263000e+01 5.412024e-01 5.412024e-01
	+1.738500e-01 2.415000e-02 2.415000e-02 6.728000e+00 2.986135e-01 2.986135e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 3.257000e+00 1.748885e-01 1.748885e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.432000e+00 9.976472e-02 9.976472e-02
	+4.018500e-01 5.575000e-02 5.575000e-02 5.189000e-01 5.507032e-02 5.507032e-02
	+5.313000e-01 7.370000e-02 7.370000e-02 1.989000e-01 2.903188e-02 2.903188e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 6.337000e-02 1.976788e-02 1.976788e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d06-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.500000e-03 5.000000e-04 5.000000e-04 7.801000e+02 2.959899e+01 2.959899e+01
	+4.600000e-03 6.000000e-04 6.000000e-04 7.278000e+02 2.921660e+01 2.921660e+01
	+6.050000e-03 8.500000e-04 8.500000e-04 6.065000e+02 2.317952e+01 2.317952e+01
	+8.050000e-03 1.150000e-03 1.150000e-03 4.859000e+02 1.816618e+01 1.816618e+01
	+1.065000e-02 1.450000e-03 1.450000e-03 3.902000e+02 1.475263e+01 1.475263e+01
	+1.405000e-02 1.950000e-03 1.950000e-03 3.004000e+02 1.140175e+01 1.140175e+01
	+1.860000e-02 2.600000e-03 2.600000e-03 2.253000e+02 8.634813e+00 8.634813e+00
	+2.460000e-02 3.400000e-03 3.400000e-03 1.656000e+02 6.403124e+00 6.403124e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 1.197000e+02 4.707441e+00 4.707441e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 8.348000e+01 3.253014e+00 3.253014e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.343000e+01 2.127769e+00 2.127769e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.423000e+01 1.411559e+00 1.411559e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 2.060000e+01 9.176056e-01 9.176056e-01
	+1.314500e-01 1.825000e-02 1.825000e-02 1.185000e+01 5.664804e-01 5.664804e-01
	+1.738500e-01 2.415000e-02 2.415000e-02 6.592000e+00 3.236495e-01 3.236495e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 3.112000e+00 1.684340e-01 1.684340e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.402000e+00 9.493682e-02 9.493682e-02
	+4.018500e-01 5.575000e-02 5.575000e-02 5.375000e-01 4.603586e-02 4.603586e-02
	+5.313000e-01 7.370000e-02 7.370000e-02 2.011000e-01 2.548490e-02 2.548490e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 5.159000e-02 1.534719e-02 1.534719e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d07-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.500000e-03 5.000000e-04 5.000000e-04 9.845000e+02 3.360268e+01 3.360268e+01
	+4.600000e-03 6.000000e-04 6.000000e-04 8.136000e+02 3.010548e+01 3.010548e+01
	+6.050000e-03 8.500000e-04 8.500000e-04 6.818000e+02 2.298043e+01 2.298043e+01
	+8.050000e-03 1.150000e-03 1.150000e-03 5.419000e+02 1.814635e+01 1.814635e+01
	+1.065000e-02 1.450000e-03 1.450000e-03 4.150000e+02 1.414814e+01 1.414814e+01
	+1.405000e-02 1.950000e-03 1.950000e-03 3.189000e+02 1.100636e+01 1.100636e+01
	+1.860000e-02 2.600000e-03 2.600000e-03 2.364000e+02 7.981228e+00 7.981228e+00
	+2.460000e-02 3.400000e-03 3.400000e-03 1.681000e+02 5.772348e+00 5.772348e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 1.211000e+02 4.684015e+00 4.684015e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 8.364000e+01 3.089547e+00 3.089547e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.341000e+01 2.017573e+00 2.017573e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.392000e+01 1.311030e+00 1.311030e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 2.012000e+01 8.860023e-01 8.860023e-01
	+1.314500e-01 1.825000e-02 1.825000e-02 1.162000e+01 5.126402e-01 5.126402e-01
	+1.738500e-01 2.415000e-02 2.415000e-02 6.470000e+00 2.935864e-01 2.935864e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 3.054000e+00 1.733263e-01 1.733263e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.412000e+00 8.969392e-02 8.969392e-02
	+4.018500e-01 5.575000e-02 5.575000e-02 5.705000e-01 6.463412e-02 6.463412e-02
	+5.313000e-01 7.370000e-02 7.370000e-02 1.782000e-01 1.947434e-02 1.947434e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 4.339000e-02 1.113677e-02 1.113677e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d08-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.500000e-03 5.000000e-04 5.000000e-04 1.098500e+03 3.567464e+01 3.567464e+01
	+4.600000e-03 6.000000e-04 6.000000e-04 8.695000e+02 2.968451e+01 2.968451e+01
	+6.050000e-03 8.500000e-04 8.500000e-04 7.096000e+02 2.298369e+01 2.298369e+01
	+8.050000e-03 1.150000e-03 1.150000e-03 5.587000e+02 1.814635e+01 1.814635e+01
	+1.065000e-02 1.450000e-03 1.450000e-03 4.285000e+02 1.401606e+01 1.401606e+01
	+1.405000e-02 1.950000e-03 1.950000e-03 3.239000e+02 1.077868e+01 1.077868e+01
	+1.860000e-02 2.600000e-03 2.600000e-03 2.389000e+02 7.851751e+00 7.851751e+00
	+2.460000e-02 3.400000e-03 3.400000e-03 1.716000e+02 5.755867e+00 5.755867e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 1.202000e+02 4.130375e+00 4.130375e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 8.144000e+01 2.782104e+00 2.782104e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.326000e+01 1.910628e+00 1.910628e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.344000e+01 1.244588e+00 1.244588e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 2.019000e+01 1.224949e+00 1.224949e+00
	+1.314500e-01 1.825000e-02 1.825000e-02 1.138000e+01 5.246904e-01 5.246904e-01
	+1.738500e-01 2.415000e-02 2.415000e-02 6.128000e+00 2.753779e-01 2.753779e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 3.075000e+00 2.186733e-01 2.186733e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.418000e+00 1.675052e-01 1.675052e-01
	+4.018500e-01 5.575000e-02 5.575000e-02 5.518000e-01 4.964071e-02 4.964071e-02
	+5.313000e-01 7.370000e-02 7.370000e-02 1.893000e-01 2.046778e-02 2.046778e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 5.641000e-02 1.494045e-02 1.494045e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d09-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.500000e-03 5.000000e-04 5.000000e-04 1.172000e+03 3.788681e+01 3.788681e+01
	+4.600000e-03 6.000000e-04 6.000000e-04 9.072000e+02 3.098596e+01 3.098596e+01
	+6.050000e-03 8.500000e-04 8.500000e-04 7.296000e+02 2.361779e+01 2.361779e+01
	+8.050000e-03 1.150000e-03 1.150000e-03 5.652000e+02 1.871069e+01 1.871069e+01
	+1.065000e-02 1.450000e-03 1.450000e-03 4.352000e+02 1.432655e+01 1.432655e+01
	+1.405000e-02 1.950000e-03 1.950000e-03 3.297000e+02 1.079120e+01 1.079120e+01
	+1.860000e-02 2.600000e-03 2.600000e-03 2.419000e+02 8.448077e+00 8.448077e+00
	+2.460000e-02 3.400000e-03 3.400000e-03 1.720000e+02 5.656854e+00 5.656854e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 1.196000e+02 3.945884e+00 3.945884e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 8.088000e+01 2.766839e+00 2.766839e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.260000e+01 1.851486e+00 1.851486e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.255000e+01 1.228088e+00 1.228088e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 1.972000e+01 8.174350e-01 8.174350e-01
	+1.314500e-01 1.825000e-02 1.825000e-02 1.121000e+01 4.903060e-01 4.903060e-01
	+1.738500e-01 2.415000e-02 2.415000e-02 6.053000e+00 2.814267e-01 2.814267e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 3.066000e+00 1.653874e-01 1.653874e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.417000e+00 9.178235e-02 9.178235e-02
	+4.018500e-01 5.575000e-02 5.575000e-02 5.857000e-01 5.409510e-02 5.409510e-02
	+5.313000e-01 7.370000e-02 7.370000e-02 2.107000e-01 2.151953e-02 2.151953e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 5.553000e-02 1.250496e-02 1.250496e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d10-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.500000e-03 5.000000e-04 5.000000e-04 1.243200e+03 3.752386e+01 3.752386e+01
	+4.600000e-03 6.000000e-04 6.000000e-04 9.537000e+02 2.988394e+01 2.988394e+01
	+6.050000e-03 8.500000e-04 8.500000e-04 7.693000e+02 2.272004e+01 2.272004e+01
	+8.050000e-03 1.150000e-03 1.150000e-03 5.916000e+02 2.139252e+01 2.139252e+01
	+1.065000e-02 1.450000e-03 1.450000e-03 4.430000e+02 1.338096e+01 1.338096e+01
	+1.405000e-02 1.950000e-03 1.950000e-03 3.353000e+02 1.002846e+01 1.002846e+01
	+1.860000e-02 2.600000e-03 2.600000e-03 2.442000e+02 7.665507e+00 7.665507e+00
	+2.460000e-02 3.400000e-03 3.400000e-03 1.740000e+02 5.375872e+00 5.375872e+00
	+3.255000e-02 4.550000e-03 4.550000e-03 1.191000e+02 3.700000e+00 3.700000e+00
	+4.305000e-02 5.950000e-03 5.950000e-03 8.005000e+01 2.656501e+00 2.656501e+00
	+5.690000e-02 7.900000e-03 7.900000e-03 5.216000e+01 1.711286e+00 1.711286e+00
	+7.520000e-02 1.040000e-02 1.040000e-02 3.204000e+01 1.141622e+00 1.141622e+00
	+9.940000e-02 1.380000e-02 1.380000e-02 1.931000e+01 7.912016e-01 7.912016e-01
	+1.314500e-01 1.825000e-02 1.825000e-02 1.107000e+01 4.272002e-01 4.272002e-01
	+1.738500e-01 2.415000e-02 2.415000e-02 6.044000e+00 2.561816e-01 2.561816e-01
	+2.299000e-01 3.190000e-02 3.190000e-02 3.123000e+00 1.623392e-01 1.623392e-01
	+3.039500e-01 4.215000e-02 4.215000e-02 1.473000e+00 9.638465e-02 9.638465e-02
	+4.018500e-01 5.575000e-02 5.575000e-02 6.179000e-01 6.379216e-02 6.379216e-02
	+5.313000e-01 7.370000e-02 7.370000e-02 2.268000e-01 2.802231e-02 2.802231e-02
	+7.025000e-01 9.750000e-02 9.750000e-02 5.536000e-02 1.063328e-02 1.063328e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d11-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d11-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 4.777000e+01 3.308716e+00 3.308716e+00
	+9.000000e-02 3.000000e-02 3.000000e-02 2.959000e+01 1.772823e+00 1.772823e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 1.779000e+01 8.814193e-01 8.814193e-01
	+2.100000e-01 3.000000e-02 3.000000e-02 1.136000e+01 4.909175e-01 4.909175e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 7.727000e+00 3.422309e-01 3.422309e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 5.623000e+00 2.310498e-01 2.310498e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 4.230000e+00 1.739339e-01 1.739339e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 3.304000e+00 1.338432e-01 1.338432e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 2.584000e+00 8.287340e-02 8.287340e-02
	+5.700000e-01 3.000000e-02 3.000000e-02 1.178000e+00 3.962323e-02 3.962323e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d12-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d12-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 8.430000e+01 5.604543e+00 5.604543e+00
	+9.000000e-02 3.000000e-02 3.000000e-02 4.239000e+01 2.414063e+00 2.414063e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 2.218000e+01 1.039423e+00 1.039423e+00
	+2.100000e-01 3.000000e-02 3.000000e-02 1.304000e+01 5.295281e-01 5.295281e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 8.485000e+00 3.490172e-01 3.490172e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 5.920000e+00 2.408423e-01 2.408423e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 4.261000e+00 1.572800e-01 1.572800e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 3.250000e+00 1.110000e-01 1.110000e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 2.588000e+00 9.392018e-02 9.392018e-02
	+5.700000e-01 3.000000e-02 3.000000e-02 1.470000e+00 6.184658e-02 6.184658e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d13-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d13-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 1.251000e+02 7.564390e+00 7.564390e+00
	+9.000000e-02 3.000000e-02 3.000000e-02 5.452000e+01 2.653338e+00 2.653338e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 2.588000e+01 1.106797e+00 1.106797e+00
	+2.100000e-01 3.000000e-02 3.000000e-02 1.492000e+01 5.981639e-01 5.981639e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 9.514000e+00 3.687818e-01 3.687818e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 6.189000e+00 2.468299e-01 2.468299e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 4.445000e+00 1.875447e-01 1.875447e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 3.358000e+00 1.503330e-01 1.503330e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 2.742000e+00 1.429475e-01 1.429475e-01
	+5.700000e-01 3.000000e-02 3.000000e-02 1.666000e+00 1.067755e-01 1.067755e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d14-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d14-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 1.655000e+02 9.479451e+00 9.479451e+00
	+9.000000e-02 3.000000e-02 3.000000e-02 5.860000e+01 2.430823e+00 2.430823e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 2.725000e+01 1.202539e+00 1.202539e+00
	+2.100000e-01 3.000000e-02 3.000000e-02 1.682000e+01 8.523497e-01 8.523497e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 1.058000e+01 6.216912e-01 6.216912e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 6.065000e+00 3.856488e-01 3.856488e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 4.713000e+00 3.140143e-01 3.140143e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 3.389000e+00 2.236180e-01 2.236180e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 2.530000e+00 1.892749e-01 1.892749e-01
	+5.700000e-01 3.000000e-02 3.000000e-02 1.551000e+00 1.560801e-01 1.560801e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d15-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d15-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 2.199000e+02 7.156815e+00 7.156815e+00
	+9.000000e-02 3.000000e-02 3.000000e-02 7.111000e+01 1.904127e+00 1.904127e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 3.099000e+01 7.783315e-01 7.783315e-01
	+2.100000e-01 3.000000e-02 3.000000e-02 1.707000e+01 4.308132e-01 4.308132e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 1.060000e+01 2.773085e-01 2.773085e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 7.209000e+00 1.953586e-01 1.953586e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 5.187000e+00 1.456606e-01 1.456606e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 3.942000e+00 1.123610e-01 1.123610e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 3.040000e+00 9.170605e-02 9.170605e-02
	+5.700000e-01 3.000000e-02 3.000000e-02 2.070000e+00 9.042677e-02 9.042677e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d16-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d16-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 2.850000e+02 8.434453e+00 8.434453e+00
	+9.000000e-02 3.000000e-02 3.000000e-02 7.993000e+01 2.006614e+00 2.006614e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 3.445000e+01 9.774457e-01 9.774457e-01
	+2.100000e-01 3.000000e-02 3.000000e-02 1.901000e+01 4.838388e-01 4.838388e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 1.150000e+01 2.846050e-01 2.846050e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 7.683000e+00 1.913766e-01 1.913766e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 5.479000e+00 1.369708e-01 1.369708e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 4.082000e+00 1.068925e-01 1.068925e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 3.148000e+00 9.230926e-02 9.230926e-02
	+5.700000e-01 3.000000e-02 3.000000e-02 2.197000e+00 8.134494e-02 8.134494e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d17-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d17-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 3.345000e+02 1.329662e+01 1.329662e+01
	+9.000000e-02 3.000000e-02 3.000000e-02 8.887000e+01 3.327897e+00 3.327897e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 3.798000e+01 1.479595e+00 1.479595e+00
	+2.100000e-01 3.000000e-02 3.000000e-02 2.040000e+01 7.690254e-01 7.690254e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 1.213000e+01 4.657252e-01 4.657252e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 8.094000e+00 3.070016e-01 3.070016e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 5.604000e+00 2.127205e-01 2.127205e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 4.195000e+00 1.619197e-01 1.619197e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 3.284000e+00 1.354179e-01 1.354179e-01
	+5.700000e-01 3.000000e-02 3.000000e-02 2.356000e+00 1.230163e-01 1.230163e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d18-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d18-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 3.800000e+02 1.492146e+01 1.492146e+01
	+9.000000e-02 3.000000e-02 3.000000e-02 9.253000e+01 3.407110e+00 3.407110e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 3.891000e+01 1.494824e+00 1.494824e+00
	+2.100000e-01 3.000000e-02 3.000000e-02 2.099000e+01 7.741447e-01 7.741447e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 1.271000e+01 4.738143e-01 4.738143e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 8.367000e+00 3.146824e-01 3.146824e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 5.912000e+00 2.219031e-01 2.219031e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 4.351000e+00 1.619413e-01 1.619413e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 3.386000e+00 1.308625e-01 1.308625e-01
	+5.700000e-01 3.000000e-02 3.000000e-02 2.416000e+00 1.269212e-01 1.269212e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d19-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d19-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 4.252000e+02 1.714205e+01 1.714205e+01
	+9.000000e-02 3.000000e-02 3.000000e-02 9.675000e+01 3.571792e+00 3.571792e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 3.976000e+01 1.475737e+00 1.475737e+00
	+2.100000e-01 3.000000e-02 3.000000e-02 2.129000e+01 7.951101e-01 7.951101e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 1.290000e+01 4.738143e-01 4.738143e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 8.627000e+00 3.258497e-01 3.258497e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 6.129000e+00 2.267179e-01 2.267179e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 4.443000e+00 1.630859e-01 1.630859e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 3.407000e+00 1.298769e-01 1.298769e-01
	+5.700000e-01 3.000000e-02 3.000000e-02 2.423000e+00 1.132828e-01 1.132828e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d20-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d20-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 4.807000e+02 1.514629e+01 1.514629e+01
	+9.000000e-02 3.000000e-02 3.000000e-02 1.012000e+02 3.059412e+00 3.059412e+00
	+1.500000e-01 3.000000e-02 3.000000e-02 4.168000e+01 1.229715e+00 1.229715e+00
	+2.100000e-01 3.000000e-02 3.000000e-02 2.223000e+01 6.580274e-01 6.580274e-01
	+2.700000e-01 3.000000e-02 3.000000e-02 1.365000e+01 4.052160e-01 4.052160e-01
	+3.300000e-01 3.000000e-02 3.000000e-02 8.903000e+00 2.767400e-01 2.767400e-01
	+3.900000e-01 3.000000e-02 3.000000e-02 6.374000e+00 1.998499e-01 1.998499e-01
	+4.500000e-01 3.000000e-02 3.000000e-02 4.614000e+00 1.449966e-01 1.449966e-01
	+5.100000e-01 3.000000e-02 3.000000e-02 3.523000e+00 1.173882e-01 1.173882e-01
	+5.700000e-01 3.000000e-02 3.000000e-02 2.531000e+00 1.128938e-01 1.128938e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d21-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d21-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 2.129000e+00 9.472592e-02 9.472592e-02
	+9.000000e-02 3.000000e-02 3.000000e-02 6.019000e+00 2.558847e-01 2.558847e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.017000e+01 4.119466e-01 4.119466e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 1.287000e+01 5.124451e-01 5.124451e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 1.207000e+01 4.517743e-01 4.517743e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 8.783000e+00 3.381612e-01 3.381612e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 5.503000e+00 2.179197e-01 2.179197e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 2.880000e+00 1.255747e-01 1.255747e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 1.225000e+00 5.842089e-02 5.842089e-02
	+1.445800e+00 2.127000e-01 2.127000e-01 4.136000e-01 2.797320e-02 2.797320e-02
	+1.944550e+00 2.860500e-01 2.860500e-01 9.954000e-02 1.668764e-02 1.668764e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 1.755000e-02 4.048827e-03 4.048827e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d22-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d22-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 2.576000e+00 1.034650e-01 1.034650e-01
	+9.000000e-02 3.000000e-02 3.000000e-02 7.248000e+00 2.626176e-01 2.626176e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.193000e+01 3.860052e-01 3.860052e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 1.462000e+01 4.560702e-01 4.560702e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 1.380000e+01 4.301163e-01 4.301163e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 1.000000e+01 3.036445e-01 3.036445e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 6.388000e+00 2.061892e-01 2.061892e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 3.584000e+00 1.205529e-01 1.205529e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 1.670000e+00 6.356099e-02 6.356099e-02
	+1.445800e+00 2.127000e-01 2.127000e-01 6.821000e-01 3.046309e-02 3.046309e-02
	+1.944550e+00 2.860500e-01 2.860500e-01 2.325000e-01 1.683449e-02 1.683449e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 6.582000e-02 8.445425e-03 8.445425e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d23-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d23-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 3.047000e+00 1.680774e-01 1.680774e-01
	+9.000000e-02 3.000000e-02 3.000000e-02 8.804000e+00 3.749827e-01 3.749827e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.328000e+01 4.701064e-01 4.701064e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 1.618000e+01 5.403702e-01 5.403702e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 1.529000e+01 4.940648e-01 4.940648e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 1.127000e+01 3.661967e-01 3.661967e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 7.218000e+00 2.570992e-01 2.570992e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 4.333000e+00 1.589025e-01 1.589025e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 2.224000e+00 9.265528e-02 9.265528e-02
	+1.445800e+00 2.127000e-01 2.127000e-01 1.020000e+00 4.957822e-02 4.957822e-02
	+1.944550e+00 2.860500e-01 2.860500e-01 4.032000e-01 2.736512e-02 2.736512e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 1.361000e-01 1.994242e-02 1.994242e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d24-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d24-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 3.167000e+00 3.333482e-01 3.333482e-01
	+9.000000e-02 3.000000e-02 3.000000e-02 9.188000e+00 6.606981e-01 6.606981e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.353000e+01 7.582216e-01 7.582216e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 1.728000e+01 8.839118e-01 8.839118e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 1.511000e+01 7.574299e-01 7.574299e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 1.207000e+01 6.585590e-01 6.585590e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 7.960000e+00 4.419683e-01 4.419683e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 4.815000e+00 2.566807e-01 2.566807e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 2.565000e+00 1.547966e-01 1.547966e-01
	+1.445800e+00 2.127000e-01 2.127000e-01 1.246000e+00 9.319335e-02 9.319335e-02
	+1.944550e+00 2.860500e-01 2.860500e-01 6.009000e-01 5.791459e-02 5.791459e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 2.550000e-01 5.053197e-02 5.053197e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d25-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d25-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 3.775000e+00 1.560833e-01 1.560833e-01
	+9.000000e-02 3.000000e-02 3.000000e-02 1.048000e+01 4.178516e-01 4.178516e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.589000e+01 5.966574e-01 5.966574e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 1.858000e+01 6.888396e-01 6.888396e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 1.733000e+01 6.596969e-01 6.596969e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 1.342000e+01 5.166237e-01 5.166237e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 9.006000e+00 3.473327e-01 3.473327e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 5.536000e+00 2.175891e-01 2.175891e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 3.142000e+00 1.259603e-01 1.259603e-01
	+1.445800e+00 2.127000e-01 2.127000e-01 1.614000e+00 7.116881e-02 7.116881e-02
	+1.944550e+00 2.860500e-01 2.860500e-01 7.834000e-01 4.758203e-02 4.758203e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 3.631000e-01 7.884802e-02 7.884802e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d26-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d26-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 4.221000e+00 2.001799e-01 2.001799e-01
	+9.000000e-02 3.000000e-02 3.000000e-02 1.130000e+01 5.239275e-01 5.239275e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.725000e+01 7.863841e-01 7.863841e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 1.995000e+01 9.093404e-01 9.093404e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 1.866000e+01 8.500000e-01 8.500000e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 1.457000e+01 6.661081e-01 6.661081e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 9.954000e+00 4.603531e-01 4.603531e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 6.256000e+00 2.954353e-01 2.954353e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 3.670000e+00 1.742642e-01 1.742642e-01
	+1.445800e+00 2.127000e-01 2.127000e-01 1.987000e+00 9.982485e-02 9.982485e-02
	+1.944550e+00 2.860500e-01 2.860500e-01 1.039000e+00 9.503683e-02 9.503683e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 5.205000e-01 1.181674e-01 1.181674e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d27-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d27-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 4.428000e+00 1.796274e-01 1.796274e-01
	+9.000000e-02 3.000000e-02 3.000000e-02 1.211000e+01 4.535416e-01 4.535416e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.851000e+01 6.844706e-01 6.844706e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 2.098000e+01 7.727872e-01 7.727872e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 1.960000e+01 7.218033e-01 7.218033e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 1.539000e+01 5.688585e-01 5.688585e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 1.062000e+01 4.044750e-01 4.044750e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 6.887000e+00 2.643936e-01 2.643936e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 4.047000e+00 1.639573e-01 1.639573e-01
	+1.445800e+00 2.127000e-01 2.127000e-01 2.297000e+00 9.362158e-02 9.362158e-02
	+1.944550e+00 2.860500e-01 2.860500e-01 1.262000e+00 7.009280e-02 7.009280e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 6.720000e-01 1.364770e-01 1.364770e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d28-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d28-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 4.576000e+00 1.686891e-01 1.686891e-01
	+9.000000e-02 3.000000e-02 3.000000e-02 1.270000e+01 4.627094e-01 4.627094e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.891000e+01 6.926038e-01 6.926038e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 2.170000e+01 8.022468e-01 8.022468e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 1.998000e+01 7.224957e-01 7.224957e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 1.582000e+01 5.821512e-01 5.821512e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 1.113000e+01 4.509989e-01 4.509989e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 7.245000e+00 2.760453e-01 2.760453e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 4.383000e+00 1.697557e-01 1.697557e-01
	+1.445800e+00 2.127000e-01 2.127000e-01 2.512000e+00 9.751410e-02 9.751410e-02
	+1.944550e+00 2.860500e-01 2.860500e-01 1.399000e+00 7.355270e-02 7.355270e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 7.769000e-01 1.609611e-01 1.609611e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d29-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d29-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 4.719000e+00 1.747484e-01 1.747484e-01
	+9.000000e-02 3.000000e-02 3.000000e-02 1.272000e+01 4.539824e-01 4.539824e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.925000e+01 6.935416e-01 6.935416e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 2.199000e+01 8.022468e-01 8.022468e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 2.045000e+01 7.416873e-01 7.416873e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 1.628000e+01 6.020797e-01 6.020797e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 1.154000e+01 4.418144e-01 4.418144e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 7.590000e+00 2.794065e-01 2.794065e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 4.658000e+00 1.708479e-01 1.708479e-01
	+1.445800e+00 2.127000e-01 2.127000e-01 2.719000e+00 1.006032e-01 1.006032e-01
	+1.944550e+00 2.860500e-01 2.860500e-01 1.520000e+00 7.632169e-02 7.632169e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 8.805000e-01 1.860967e-01 1.860967e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2011_I929691/d30-x01-y01
	+Path=/REF/ATLAS_2011_I929691/d30-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-02 3.000000e-02 3.000000e-02 4.911000e+00 1.859946e-01 1.859946e-01
	+9.000000e-02 3.000000e-02 3.000000e-02 1.321000e+01 4.876474e-01 4.876474e-01
	+1.642000e-01 4.420000e-02 4.420000e-02 1.968000e+01 7.200694e-01 7.200694e-01
	+2.443000e-01 3.590000e-02 3.590000e-02 2.232000e+01 8.354639e-01 8.354639e-01
	+3.285500e-01 4.835000e-02 4.835000e-02 2.076000e+01 8.318654e-01 8.318654e-01
	+4.419000e-01 6.500000e-02 6.500000e-02 1.674000e+01 6.198387e-01 6.198387e-01
	+5.943000e-01 8.740000e-02 8.740000e-02 1.193000e+01 4.472136e-01 4.472136e-01
	+7.993000e-01 1.176000e-01 1.176000e-01 7.980000e+00 2.935864e-01 2.935864e-01
	+1.075000e+00 1.581000e-01 1.581000e-01 5.017000e+00 1.859247e-01 1.859247e-01
	+1.445800e+00 2.127000e-01 2.127000e-01 2.992000e+00 1.132652e-01 1.132652e-01
	+1.944550e+00 2.860500e-01 2.860500e-01 1.777000e+00 9.317188e-02 9.317188e-02
	+2.615300e+00 3.847000e-01 3.847000e-01 1.035000e+00 2.283703e-01 2.283703e-01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2015_I1351916.yoda b/data/refdata/ATLAS_2015_I1351916.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1351916.yoda
	@@ -0,0 +1,52 @@
	+# BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1351916/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1351916/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.800000e+01 2.000000e+00 2.000000e+00 -1.000000e-01 3.969887e-02 4.313931e-02
	+7.300000e+01 3.000000e+00 3.000000e+00 -5.000000e-02 3.361547e-02 3.361547e-02
	+7.800000e+01 2.000000e+00 2.000000e+00 -4.000000e-02 2.701851e-02 2.624881e-02
	+8.300000e+01 3.000000e+00 3.000000e+00 -2.000000e-02 1.425798e-02 1.425798e-02
	+8.700000e+01 1.000000e+00 1.000000e+00 -9.000000e-03 8.823265e-03 8.987213e-03
	+8.850000e+01 5.000000e-01 5.000000e-01 -3.000000e-03 4.967897e-03 5.099020e-03
	+8.950000e+01 5.000000e-01 5.000000e-01 6.000000e-03 4.622770e-03 4.701064e-03
	+9.050000e+01 5.000000e-01 5.000000e-01 1.500000e-02 5.423099e-03 5.423099e-03
	+9.150000e+01 5.000000e-01 5.000000e-01 2.100000e-02 5.200000e-03 5.292447e-03
	+9.250000e+01 5.000000e-01 5.000000e-01 3.000000e-02 7.854935e-03 7.854935e-03
	+9.350000e+01 5.000000e-01 5.000000e-01 4.000000e-02 1.077033e-02 1.077033e-02
	+9.450000e+01 5.000000e-01 5.000000e-01 6.000000e-02 1.382353e-02 1.382353e-02
	+9.750000e+01 2.500000e+00 2.500000e+00 8.000000e-02 1.471768e-02 1.471768e-02
	+1.025000e+02 2.500000e+00 2.500000e+00 9.000000e-02 2.163331e-02 2.080865e-02
	+1.075000e+02 2.500000e+00 2.500000e+00 8.000000e-02 3.712142e-02 3.190611e-02
	+1.130000e+02 3.000000e+00 3.000000e+00 1.700000e-01 3.360060e-02 3.201562e-02
	+1.205000e+02 4.500000e+00 4.500000e+00 1.200000e-01 3.635932e-02 3.383785e-02
	+1.875000e+02 6.250000e+01 6.250000e+01 2.000000e-01 5.282509e-02 2.115396e-02
	+3.750000e+02 1.250000e+02 1.250000e+02 2.000000e-01 1.524106e-01 9.972462e-02
	+7.500000e+02 2.500000e+02 2.500000e+02 7.000000e-01 1.500833e-01 1.767060e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1351916/d01-x02-y01
	+Path=/REF/ATLAS_2015_I1351916/d01-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.800000e+01 2.000000e+00 2.000000e+00 -2.400000e-01 8.486460e-02 7.406079e-02
	+7.300000e+01 3.000000e+00 3.000000e+00 -1.900000e-01 4.313931e-02 3.310589e-02
	+7.800000e+01 2.000000e+00 2.000000e+00 -1.500000e-01 4.924429e-02 3.920459e-02
	+8.300000e+01 3.000000e+00 3.000000e+00 -1.000000e-01 4.808326e-02 3.130495e-02
	+8.700000e+01 1.000000e+00 1.000000e+00 -4.000000e-02 3.204076e-02 2.065454e-02
	+8.850000e+01 5.000000e-01 5.000000e-01 -1.000000e-02 2.666102e-02 2.471457e-02
	+8.950000e+01 5.000000e-01 5.000000e-01 3.000000e-02 1.659397e-02 1.001798e-02
	+9.050000e+01 5.000000e-01 5.000000e-01 5.000000e-02 1.631686e-02 1.241934e-02
	+9.150000e+01 5.000000e-01 5.000000e-01 8.000000e-02 1.724558e-02 1.002846e-02
	+9.250000e+01 5.000000e-01 5.000000e-01 1.200000e-01 1.739799e-02 8.363014e-03
	+9.350000e+01 5.000000e-01 5.000000e-01 1.500000e-01 2.061553e-02 1.208305e-02
	+9.450000e+01 5.000000e-01 5.000000e-01 1.800000e-01 3.069609e-02 1.820027e-02
	+9.750000e+01 2.500000e+00 2.500000e+00 2.500000e-01 4.011683e-02 2.392405e-02
	+1.025000e+02 2.500000e+00 2.500000e+00 3.500000e-01 5.661272e-02 3.106445e-02
	+1.075000e+02 2.500000e+00 2.500000e+00 4.500000e-01 3.111270e-02 3.111270e-02
	+1.130000e+02 3.000000e+00 3.000000e+00 5.000000e-01 4.382921e-02 2.915476e-02
	+1.205000e+02 4.500000e+00 4.500000e+00 5.200000e-01 8.570298e-02 7.169379e-02
	+1.875000e+02 6.250000e+01 6.250000e+01 3.900000e-01 8.154140e-02 8.154140e-02
	+# END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2015_I1351916_EL.yoda b/data/refdata/ATLAS_2015_I1351916_EL.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1351916_EL.yoda
	@@ -0,0 +1,53 @@
	+# BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1351916_EL/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1351916_EL/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.800000e+01 2.000000e+00 2.000000e+00 -1.000000e-01 3.969887e-02 4.313931e-02
	+7.300000e+01 3.000000e+00 3.000000e+00 -5.000000e-02 3.361547e-02 3.361547e-02
	+7.800000e+01 2.000000e+00 2.000000e+00 -4.000000e-02 2.701851e-02 2.624881e-02
	+8.300000e+01 3.000000e+00 3.000000e+00 -2.000000e-02 1.425798e-02 1.425798e-02
	+8.700000e+01 1.000000e+00 1.000000e+00 -9.000000e-03 8.823265e-03 8.987213e-03
	+8.850000e+01 5.000000e-01 5.000000e-01 -3.000000e-03 4.967897e-03 5.099020e-03
	+8.950000e+01 5.000000e-01 5.000000e-01 6.000000e-03 4.622770e-03 4.701064e-03
	+9.050000e+01 5.000000e-01 5.000000e-01 1.500000e-02 5.423099e-03 5.423099e-03
	+9.150000e+01 5.000000e-01 5.000000e-01 2.100000e-02 5.200000e-03 5.292447e-03
	+9.250000e+01 5.000000e-01 5.000000e-01 3.000000e-02 7.854935e-03 7.854935e-03
	+9.350000e+01 5.000000e-01 5.000000e-01 4.000000e-02 1.077033e-02 1.077033e-02
	+9.450000e+01 5.000000e-01 5.000000e-01 6.000000e-02 1.382353e-02 1.382353e-02
	+9.750000e+01 2.500000e+00 2.500000e+00 8.000000e-02 1.471768e-02 1.471768e-02
	+1.025000e+02 2.500000e+00 2.500000e+00 9.000000e-02 2.163331e-02 2.080865e-02
	+1.075000e+02 2.500000e+00 2.500000e+00 8.000000e-02 3.712142e-02 3.190611e-02
	+1.130000e+02 3.000000e+00 3.000000e+00 1.700000e-01 3.360060e-02 3.201562e-02
	+1.205000e+02 4.500000e+00 4.500000e+00 1.200000e-01 3.635932e-02 3.383785e-02
	+1.875000e+02 6.250000e+01 6.250000e+01 2.000000e-01 5.282509e-02 2.115396e-02
	+3.750000e+02 1.250000e+02 1.250000e+02 2.000000e-01 1.524106e-01 9.972462e-02
	+7.500000e+02 2.500000e+02 2.500000e+02 7.000000e-01 1.500833e-01 1.767060e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1351916_EL/d01-x02-y01
	+Path=/REF/ATLAS_2015_I1351916_EL/d01-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.800000e+01 2.000000e+00 2.000000e+00 -2.400000e-01 8.486460e-02 7.406079e-02
	+7.300000e+01 3.000000e+00 3.000000e+00 -1.900000e-01 4.313931e-02 3.310589e-02
	+7.800000e+01 2.000000e+00 2.000000e+00 -1.500000e-01 4.924429e-02 3.920459e-02
	+8.300000e+01 3.000000e+00 3.000000e+00 -1.000000e-01 4.808326e-02 3.130495e-02
	+8.700000e+01 1.000000e+00 1.000000e+00 -4.000000e-02 3.204076e-02 2.065454e-02
	+8.850000e+01 5.000000e-01 5.000000e-01 -1.000000e-02 2.666102e-02 2.471457e-02
	+8.950000e+01 5.000000e-01 5.000000e-01 3.000000e-02 1.659397e-02 1.001798e-02
	+9.050000e+01 5.000000e-01 5.000000e-01 5.000000e-02 1.631686e-02 1.241934e-02
	+9.150000e+01 5.000000e-01 5.000000e-01 8.000000e-02 1.724558e-02 1.002846e-02
	+9.250000e+01 5.000000e-01 5.000000e-01 1.200000e-01 1.739799e-02 8.363014e-03
	+9.350000e+01 5.000000e-01 5.000000e-01 1.500000e-01 2.061553e-02 1.208305e-02
	+9.450000e+01 5.000000e-01 5.000000e-01 1.800000e-01 3.069609e-02 1.820027e-02
	+9.750000e+01 2.500000e+00 2.500000e+00 2.500000e-01 4.011683e-02 2.392405e-02
	+1.025000e+02 2.500000e+00 2.500000e+00 3.500000e-01 5.661272e-02 3.106445e-02
	+1.075000e+02 2.500000e+00 2.500000e+00 4.500000e-01 3.111270e-02 3.111270e-02
	+1.130000e+02 3.000000e+00 3.000000e+00 5.000000e-01 4.382921e-02 2.915476e-02
	+1.205000e+02 4.500000e+00 4.500000e+00 5.200000e-01 8.570298e-02 7.169379e-02
	+1.875000e+02 6.250000e+01 6.250000e+01 3.900000e-01 8.154140e-02 8.154140e-02
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/ATLAS_2015_I1351916_MU.yoda b/data/refdata/ATLAS_2015_I1351916_MU.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1351916_MU.yoda
	@@ -0,0 +1,27 @@
	+# BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1351916_MU/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1351916_MU/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.800000e+01 2.000000e+00 2.000000e+00 -3.200000e-02 2.898707e-02 2.898707e-02
	+7.300000e+01 3.000000e+00 3.000000e+00 -6.500000e-02 2.594224e-02 2.594224e-02
	+7.800000e+01 2.000000e+00 2.000000e+00 -6.000000e-02 2.401270e-02 2.401270e-02
	+8.300000e+01 3.000000e+00 3.000000e+00 -2.900000e-02 1.500000e-02 1.500000e-02
	+8.700000e+01 1.000000e+00 1.000000e+00 -1.000000e-02 1.389244e-02 1.389244e-02
	+8.850000e+01 5.000000e-01 5.000000e-01 -5.000000e-03 1.634778e-02 1.634778e-02
	+8.950000e+01 5.000000e-01 5.000000e-01 9.000000e-03 1.137585e-02 1.234544e-02
	+9.050000e+01 5.000000e-01 5.000000e-01 1.010000e-02 5.909315e-03 5.909315e-03
	+9.150000e+01 5.000000e-01 5.000000e-01 1.640000e-02 2.801785e-03 2.801785e-03
	+9.250000e+01 5.000000e-01 5.000000e-01 2.160000e-02 9.411164e-03 9.411164e-03
	+9.350000e+01 5.000000e-01 5.000000e-01 3.100000e-02 1.431782e-02 1.431782e-02
	+9.450000e+01 5.000000e-01 5.000000e-01 3.900000e-02 1.456022e-02 1.456022e-02
	+9.750000e+01 2.500000e+00 2.500000e+00 5.100000e-02 1.166190e-02 1.166190e-02
	+1.025000e+02 2.500000e+00 2.500000e+00 9.100000e-02 1.400143e-02 1.400143e-02
	+1.075000e+02 2.500000e+00 2.500000e+00 7.300000e-02 2.401270e-02 2.401270e-02
	+1.130000e+02 3.000000e+00 3.000000e+00 1.270000e-01 3.114482e-02 3.114482e-02
	+1.205000e+02 4.500000e+00 4.500000e+00 1.300000e-01 2.299761e-02 2.299761e-02
	+1.875000e+02 6.250000e+01 6.250000e+01 1.600000e-01 8.989438e-03 8.989438e-03
	+3.750000e+02 1.250000e+02 1.250000e+02 1.790000e-01 3.101612e-02 3.101612e-02
	+7.500000e+02 2.500000e+02 2.500000e+02 3.500000e-01 1.198165e-01 1.198165e-01
	+# END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2015_I1390114.yoda b/data/refdata/ATLAS_2015_I1390114.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1390114.yoda
	@@ -0,0 +1,19 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1390114/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1390114/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 9.300000e+02 2.024846e+02 2.500000e+02
	+2.000000e+00 5.000000e-01 5.000000e-01 4.800000e+01 1.414214e+01 1.802776e+01
	+3.000000e+00 5.000000e-01 5.000000e-01 1.820000e+01 6.688797e+00 6.688797e+00
	+4.000000e+00 5.000000e-01 5.000000e-01 1.240000e+01 4.883646e+00 4.883646e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1390114/d02-x01-y01
	+Path=/REF/ATLAS_2015_I1390114/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 1.200000e+00 4.327817e-01 4.327817e-01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2015_I1393758.yoda b/data/refdata/ATLAS_2015_I1393758.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1393758.yoda
	@@ -0,0 +1,204 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 1.900000e-02 1.081665e-02 1.081665e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 3.100000e-02 2.828427e-03 2.828427e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 6.700000e-02 3.162278e-03 1.414214e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 8.800000e-02 2.236068e-03 1.414214e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 1.030000e-01 2.000000e-03 2.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 1.100000e-01 2.236068e-03 3.162278e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 1.270000e-01 4.123106e-03 3.162278e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 1.380000e-01 5.000000e-03 4.242641e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 1.500000e-01 8.485281e-03 7.211103e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 1.600000e-01 1.345362e-02 1.166190e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d02-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 1.400000e-02 7.211103e-03 6.403124e-03
	+1.500000e+02 5.000000e+01 5.000000e+01 2.400000e-02 2.236068e-03 2.236068e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 4.900000e-02 3.162278e-03 1.414214e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 6.500000e-02 1.000000e-03 1.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 7.600000e-02 1.000000e-03 2.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 8.200000e-02 1.414214e-03 2.236068e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 9.200000e-02 2.236068e-03 2.236068e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 1.000000e-01 2.828427e-03 2.828427e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 1.080000e-01 5.830952e-03 5.830952e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 1.150000e-01 8.944272e-03 8.944272e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d03-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 1.000000e-02 4.242641e-03 4.242641e-03
	+1.500000e+02 5.000000e+01 5.000000e+01 1.900000e-02 1.414214e-03 1.414214e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 3.700000e-02 2.236068e-03 1.414214e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 4.900000e-02 1.000000e-03 1.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 5.700000e-02 1.000000e-03 1.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 6.100000e-02 1.000000e-03 1.000000e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 6.900000e-02 1.414214e-03 2.236068e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 7.400000e-02 2.236068e-03 2.828427e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 8.100000e-02 4.472136e-03 4.472136e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 8.800000e-02 7.615773e-03 8.062258e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d04-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 5.000000e-03 8.944272e-03 8.944272e-03
	+1.500000e+02 5.000000e+01 5.000000e+01 1.100000e-02 3.162278e-03 3.605551e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 2.900000e-02 1.414214e-03 1.414214e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 4.200000e-02 1.414214e-03 2.236068e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 5.400000e-02 1.000000e-03 1.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 6.500000e-02 2.236068e-03 1.414214e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 8.000000e-02 2.236068e-03 2.236068e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 1.010000e-01 4.242641e-03 4.242641e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 1.100000e-01 7.211103e-03 6.324555e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 1.430000e-01 1.345362e-02 1.166190e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d05-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 4.000000e-03 6.708204e-03 6.708204e-03
	+1.500000e+02 5.000000e+01 5.000000e+01 1.000000e-02 2.236068e-03 2.236068e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 2.300000e-02 1.414214e-03 1.414214e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 3.200000e-02 1.000000e-03 1.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 4.000000e-02 1.000000e-03 1.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 4.800000e-02 1.000000e-03 1.000000e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 5.900000e-02 1.414214e-03 2.236068e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 7.500000e-02 2.828427e-03 2.828427e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 8.300000e-02 5.385165e-03 5.385165e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 1.090000e-01 1.000000e-02 1.000000e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d06-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 4.000000e-03 4.472136e-03 4.472136e-03
	+1.500000e+02 5.000000e+01 5.000000e+01 9.000000e-03 2.236068e-03 2.236068e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 1.800000e-02 1.000000e-03 1.000000e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 2.400000e-02 1.000000e-03 1.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 3.000000e-02 1.000000e-03 1.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 3.600000e-02 1.000000e-03 1.000000e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 4.400000e-02 1.000000e-03 1.000000e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 5.600000e-02 2.236068e-03 2.828427e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 6.300000e-02 4.123106e-03 4.472136e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 8.600000e-02 9.219544e-03 9.219544e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d07-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 6.110000e-01 1.941649e-02 1.941649e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 5.660000e-01 6.082763e-03 5.099020e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 5.340000e-01 5.099020e-03 3.162278e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 5.190000e-01 5.000000e-03 4.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 5.100000e-01 4.000000e-03 3.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 5.050000e-01 4.000000e-03 4.000000e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 5.000000e-01 4.123106e-03 3.162278e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 4.940000e-01 3.162278e-03 3.162278e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 4.860000e-01 6.324555e-03 6.324555e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 4.760000e-01 9.848858e-03 1.077033e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d08-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 4.100000e-01 1.264911e-02 1.360147e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 3.870000e-01 6.082763e-03 6.082763e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 3.750000e-01 5.099020e-03 4.123106e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 3.720000e-01 4.000000e-03 4.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 3.700000e-01 4.000000e-03 4.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 3.690000e-01 3.000000e-03 5.000000e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 3.680000e-01 3.162278e-03 4.123106e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 3.670000e-01 4.123106e-03 4.123106e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 3.620000e-01 3.605551e-03 4.472136e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 3.550000e-01 7.211103e-03 8.944272e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d09-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 3.100000e-01 1.236932e-02 1.236932e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 2.990000e-01 6.082763e-03 6.082763e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 2.940000e-01 4.000000e-03 4.000000e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 2.930000e-01 4.000000e-03 5.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 2.940000e-01 4.000000e-03 5.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 2.930000e-01 3.000000e-03 5.000000e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 2.930000e-01 3.000000e-03 4.000000e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 2.940000e-01 4.123106e-03 5.099020e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 2.910000e-01 3.605551e-03 4.472136e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 2.850000e-01 4.242641e-03 6.708204e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d10-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 6.070000e-01 2.256103e-02 2.256103e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 5.650000e-01 6.324555e-03 4.472136e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 5.320000e-01 6.082763e-03 3.162278e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 5.180000e-01 6.000000e-03 3.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 5.130000e-01 5.000000e-03 3.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 5.080000e-01 5.000000e-03 3.000000e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 5.020000e-01 4.123106e-03 3.162278e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 4.980000e-01 4.123106e-03 3.162278e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 4.920000e-01 4.472136e-03 4.472136e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 4.890000e-01 5.000000e-03 5.656854e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d11-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d11-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 4.060000e-01 1.360147e-02 1.360147e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 3.820000e-01 5.099020e-03 4.123106e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 3.670000e-01 4.000000e-03 4.000000e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 3.630000e-01 4.000000e-03 3.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 3.640000e-01 4.000000e-03 3.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 3.650000e-01 3.000000e-03 3.000000e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 3.650000e-01 3.000000e-03 4.000000e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 3.660000e-01 3.162278e-03 4.123106e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 3.670000e-01 3.605551e-03 3.605551e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 3.630000e-01 5.000000e-03 6.403124e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1393758/d12-x01-y01
	+Path=/REF/ATLAS_2015_I1393758/d12-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 3.080000e-01 1.140175e-02 1.236932e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 2.930000e-01 4.123106e-03 4.123106e-03
	+2.500000e+02 5.000000e+01 5.000000e+01 2.840000e-01 3.000000e-03 3.000000e-03
	+3.500000e+02 5.000000e+01 5.000000e+01 2.820000e-01 3.000000e-03 3.000000e-03
	+4.500000e+02 5.000000e+01 5.000000e+01 2.840000e-01 3.000000e-03 4.000000e-03
	+5.500000e+02 5.000000e+01 5.000000e+01 2.860000e-01 3.000000e-03 4.000000e-03
	+7.000000e+02 1.000000e+02 1.000000e+02 2.870000e-01 3.000000e-03 4.000000e-03
	+9.000000e+02 1.000000e+02 1.000000e+02 2.900000e-01 3.162278e-03 5.099020e-03
	+1.100000e+03 1.000000e+02 1.000000e+02 2.920000e-01 4.242641e-03 5.000000e-03
	+1.350000e+03 1.500000e+02 1.500000e+02 2.890000e-01 3.605551e-03 6.708204e-03
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2015_I1397635.yoda b/data/refdata/ATLAS_2015_I1397635.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1397635.yoda
	@@ -0,0 +1,8 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1397635/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1397635/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+ 1.0 0.5 0.5 849. 72. 66.
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2015_I1397637.yoda b/data/refdata/ATLAS_2015_I1397637.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1397637.yoda
	@@ -0,0 +1,15 @@
	+# BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1397637/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1397637/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+325.0 25.0 25.0 4.97 0.7574808288663152 0.7574808288663152
	+375.0 25.0 25.0 3.09 0.41600398135114036 0.41600398135114036
	+425.0 25.0 25.0 1.73 0.23634611399386282 0.23634611399386282
	+475.0 25.0 25.0 1.08 0.15849160987257338 0.15849160987257338
	+525.0 25.0 25.0 0.56 0.08551880261088787 0.08551880261088787
	+600.0 50.0 50.0 0.27 0.04613762022471467 0.04613762022471467
	+700.0 50.0 50.0 0.097 0.020930658111965806 0.020930658111965806
	+975.0 225.0 225.0 0.012 0.0033962332075403775 0.0033962332075403775
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/ATLAS_2015_I1404878.yoda b/data/refdata/ATLAS_2015_I1404878.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1404878.yoda
	@@ -0,0 +1,416 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.850000e+02 6.000000e+01 6.000000e+01 1.685320e-02 6.501372e-03 6.507267e-03
	+3.825000e+02 3.750000e+01 3.750000e+01 9.637670e-02 2.365511e-02 2.347302e-02
	+4.600000e+02 4.000000e+01 4.000000e+01 9.005970e-02 1.788788e-02 1.788878e-02
	+5.450000e+02 4.500000e+01 4.500000e+01 5.923150e-02 1.150839e-02 1.149714e-02
	+6.375000e+02 4.750000e+01 4.750000e+01 3.497560e-02 6.820419e-03 6.831600e-03
	+7.375000e+02 5.250000e+01 5.250000e+01 1.939140e-02 3.760553e-03 3.760166e-03
	+8.500000e+02 6.000000e+01 6.000000e+01 9.903030e-03 1.899636e-03 1.888677e-03
	+9.750000e+02 6.500000e+01 6.500000e+01 4.931670e-03 9.384592e-04 9.413018e-04
	+1.107500e+03 6.750000e+01 6.750000e+01 2.402930e-03 5.240543e-04 5.176296e-04
	+1.247500e+03 7.250000e+01 7.250000e+01 1.091860e-03 2.186828e-04 2.223231e-04
	+2.160000e+03 8.400000e+02 8.400000e+02 1.051660e-04 2.368830e-05 2.456504e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d02-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.850000e+02 6.000000e+01 6.000000e+01 5.687140e-04 1.397078e-04 1.413546e-04
	+3.825000e+02 3.750000e+01 3.750000e+01 3.252250e-03 2.013098e-04 1.971309e-04
	+4.600000e+02 4.000000e+01 4.000000e+01 3.039080e-03 1.159507e-04 1.163715e-04
	+5.450000e+02 4.500000e+01 4.500000e+01 1.998770e-03 9.990586e-05 1.015903e-04
	+6.375000e+02 4.750000e+01 4.750000e+01 1.180260e-03 5.856806e-05 5.928929e-05
	+7.375000e+02 5.250000e+01 5.250000e+01 6.543650e-04 3.309464e-05 3.276263e-05
	+8.500000e+02 6.000000e+01 6.000000e+01 3.341790e-04 2.104030e-05 2.080009e-05
	+9.750000e+02 6.500000e+01 6.500000e+01 1.664200e-04 1.258563e-05 1.276477e-05
	+1.107500e+03 6.750000e+01 6.750000e+01 8.108710e-05 4.688635e-06 4.899380e-06
	+1.247500e+03 7.250000e+01 7.250000e+01 3.684480e-05 3.221817e-06 3.406622e-06
	+2.160000e+03 8.400000e+02 8.400000e+02 3.548860e-06 4.779154e-07 5.212764e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d03-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.750000e+01 1.750000e+01 1.750000e+01 3.873990e-01 8.530850e-02 8.507997e-02
	+5.500000e+01 2.000000e+01 2.000000e+01 2.185730e-01 4.652990e-02 4.668723e-02
	+1.000000e+02 2.500000e+01 2.500000e+01 7.960280e-02 1.609056e-02 1.622339e-02
	+1.475000e+02 2.250000e+01 2.250000e+01 3.520890e-02 7.313912e-03 7.317778e-03
	+1.975000e+02 2.750000e+01 2.750000e+01 1.654870e-02 3.336376e-03 3.386647e-03
	+5.125000e+02 2.875000e+02 2.875000e+02 1.473650e-03 2.833055e-04 2.860936e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d04-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.750000e+01 1.750000e+01 1.750000e+01 1.307720e-02 6.255344e-04 6.006189e-04
	+5.500000e+01 2.000000e+01 2.000000e+01 7.378250e-03 2.841189e-04 3.005457e-04
	+1.000000e+02 2.500000e+01 2.500000e+01 2.687110e-03 1.662744e-04 1.645417e-04
	+1.475000e+02 2.250000e+01 2.250000e+01 1.188530e-03 5.559169e-05 5.758622e-05
	+1.975000e+02 2.750000e+01 2.750000e+01 5.586260e-04 3.126989e-05 3.275473e-05
	+5.125000e+02 2.875000e+02 2.875000e+02 4.974510e-05 1.975786e-06 2.052951e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d05-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e-02 5.000000e-02 5.000000e-02 3.337060e+01 6.982955e+00 6.874264e+00
	+1.500000e-01 5.000000e-02 5.000000e-02 3.342630e+01 6.943166e+00 6.905089e+00
	+2.500000e-01 5.000000e-02 5.000000e-02 3.151310e+01 6.694874e+00 6.713137e+00
	+3.500000e-01 5.000000e-02 5.000000e-02 2.982330e+01 6.429117e+00 6.425839e+00
	+4.500000e-01 5.000000e-02 5.000000e-02 2.831300e+01 5.877913e+00 5.928263e+00
	+5.500000e-01 5.000000e-02 5.000000e-02 2.592050e+01 5.464787e+00 5.489905e+00
	+6.500000e-01 5.000000e-02 5.000000e-02 2.265530e+01 4.904218e+00 4.798533e+00
	+7.500000e-01 5.000000e-02 5.000000e-02 1.996850e+01 4.169297e+00 4.194824e+00
	+8.500000e-01 5.000000e-02 5.000000e-02 1.710840e+01 3.527369e+00 3.533177e+00
	+9.500000e-01 5.000000e-02 5.000000e-02 1.384830e+01 2.962134e+00 2.910852e+00
	+1.050000e+00 5.000000e-02 5.000000e-02 1.094210e+01 2.256070e+00 2.240899e+00
	+1.150000e+00 5.000000e-02 5.000000e-02 8.672580e+00 1.755364e+00 1.748362e+00
	+1.250000e+00 5.000000e-02 5.000000e-02 6.757060e+00 1.316904e+00 1.309172e+00
	+1.350000e+00 5.000000e-02 5.000000e-02 4.903970e+00 1.007116e+00 9.850854e-01
	+1.450000e+00 5.000000e-02 5.000000e-02 3.394650e+00 7.138572e-01 7.003251e-01
	+1.550000e+00 5.000000e-02 5.000000e-02 2.349770e+00 5.052729e-01 5.015623e-01
	+1.700000e+00 1.000000e-01 1.000000e-01 1.072210e+00 2.011577e-01 2.107634e-01
	+2.150000e+00 3.500000e-01 3.500000e-01 9.208080e-02 2.181340e-02 2.204236e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d06-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e-02 5.000000e-02 5.000000e-02 1.128310e+00 1.831141e-02 1.125853e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 1.130200e+00 1.274611e-02 1.237938e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 1.065510e+00 1.160831e-02 1.259765e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 1.008370e+00 1.395988e-02 1.423576e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 9.573070e-01 1.091122e-02 1.323886e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 8.764130e-01 1.001281e-02 1.196976e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 7.660130e-01 1.342294e-02 1.055176e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 6.751670e-01 8.344813e-03 9.355983e-03
	+8.500000e-01 5.000000e-02 5.000000e-02 5.784640e-01 7.612641e-03 7.905063e-03
	+9.500000e-01 5.000000e-02 5.000000e-02 4.682330e-01 7.829053e-03 6.536710e-03
	+1.050000e+00 5.000000e-02 5.000000e-02 3.699690e-01 7.417509e-03 7.207224e-03
	+1.150000e+00 5.000000e-02 5.000000e-02 2.932340e-01 7.431289e-03 7.572282e-03
	+1.250000e+00 5.000000e-02 5.000000e-02 2.284670e-01 7.546780e-03 7.589902e-03
	+1.350000e+00 5.000000e-02 5.000000e-02 1.658110e-01 6.459908e-03 5.985199e-03
	+1.450000e+00 5.000000e-02 5.000000e-02 1.147780e-01 4.675176e-03 4.263343e-03
	+1.550000e+00 5.000000e-02 5.000000e-02 7.944940e-02 3.620771e-03 3.651219e-03
	+1.700000e+00 1.000000e-01 1.000000e-01 3.625310e-02 2.367818e-03 2.685853e-03
	+2.150000e+00 3.500000e-01 3.500000e-01 3.113400e-03 3.213059e-04 3.266022e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d07-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.250000e+01 1.250000e+01 1.250000e+01 4.226720e-02 9.230233e-03 9.311114e-03
	+3.750000e+01 1.250000e+01 1.250000e+01 1.192880e-01 2.610726e-02 2.591064e-02
	+6.250000e+01 1.250000e+01 1.250000e+01 1.774390e-01 4.047870e-02 4.018257e-02
	+9.000000e+01 1.500000e+01 1.500000e+01 1.953350e-01 4.120088e-02 4.099198e-02
	+1.200000e+02 1.500000e+01 1.500000e+01 1.736560e-01 3.551662e-02 3.553918e-02
	+1.500000e+02 1.500000e+01 1.500000e+01 1.192390e-01 2.435572e-02 2.439265e-02
	+1.800000e+02 1.500000e+01 1.500000e+01 7.619360e-02 1.512422e-02 1.484122e-02
	+2.125000e+02 1.750000e+01 1.750000e+01 4.796640e-02 9.769471e-03 9.766120e-03
	+2.475000e+02 1.750000e+01 1.750000e+01 2.892490e-02 6.095694e-03 6.202977e-03
	+2.825000e+02 1.750000e+01 1.750000e+01 1.713080e-02 3.536383e-03 3.517132e-03
	+3.250000e+02 2.500000e+01 2.500000e+01 9.450500e-03 1.941335e-03 1.907953e-03
	+3.750000e+02 2.500000e+01 2.500000e+01 4.936720e-03 1.021523e-03 1.043637e-03
	+4.250000e+02 2.500000e+01 2.500000e+01 2.378980e-03 5.449892e-04 5.436028e-04
	+4.750000e+02 2.500000e+01 2.500000e+01 9.900470e-04 2.318067e-04 2.327330e-04
	+7.500000e+02 2.500000e+02 2.500000e+02 1.166030e-04 2.966275e-05 2.911553e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d08-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.250000e+01 1.250000e+01 1.250000e+01 1.425800e-03 5.642463e-05 5.825361e-05
	+3.750000e+01 1.250000e+01 1.250000e+01 4.023940e-03 9.366997e-05 9.554445e-05
	+6.250000e+01 1.250000e+01 1.250000e+01 5.985570e-03 2.017407e-04 2.014496e-04
	+9.000000e+01 1.500000e+01 1.500000e+01 6.589250e-03 7.532184e-05 7.162563e-05
	+1.200000e+02 1.500000e+01 1.500000e+01 5.857980e-03 7.904480e-05 8.289073e-05
	+1.500000e+02 1.500000e+01 1.500000e+01 4.022310e-03 7.800432e-05 8.014760e-05
	+1.800000e+02 1.500000e+01 1.500000e+01 2.570250e-03 9.608688e-05 9.126712e-05
	+2.125000e+02 1.750000e+01 1.750000e+01 1.618060e-03 3.449124e-05 3.430755e-05
	+2.475000e+02 1.750000e+01 1.750000e+01 9.757290e-04 2.751999e-05 3.128105e-05
	+2.825000e+02 1.750000e+01 1.750000e+01 5.778750e-04 2.963352e-05 2.808960e-05
	+3.250000e+02 2.500000e+01 2.500000e+01 3.187950e-04 1.970941e-05 1.900510e-05
	+3.750000e+02 2.500000e+01 2.500000e+01 1.665310e-04 8.494388e-06 8.816497e-06
	+4.250000e+02 2.500000e+01 2.500000e+01 8.025050e-05 6.539848e-06 6.347251e-06
	+4.750000e+02 2.500000e+01 2.500000e+01 3.339740e-05 5.067386e-06 5.097579e-06
	+7.500000e+02 2.500000e+02 2.500000e+02 3.933370e-06 4.484170e-07 4.281579e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d09-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e-02 5.000000e-02 5.000000e-02 2.488830e+01 5.264737e+00 5.244849e+00
	+1.500000e-01 5.000000e-02 5.000000e-02 2.436980e+01 5.049694e+00 5.030224e+00
	+2.500000e-01 5.000000e-02 5.000000e-02 2.433290e+01 5.211291e+00 5.185530e+00
	+3.500000e-01 5.000000e-02 5.000000e-02 2.384070e+01 4.915410e+00 4.849227e+00
	+4.500000e-01 5.000000e-02 5.000000e-02 2.270670e+01 4.827157e+00 4.814459e+00
	+5.500000e-01 5.000000e-02 5.000000e-02 2.162690e+01 4.626821e+00 4.612352e+00
	+6.500000e-01 5.000000e-02 5.000000e-02 2.080160e+01 4.080438e+00 4.112624e+00
	+7.500000e-01 5.000000e-02 5.000000e-02 1.965030e+01 4.188557e+00 4.194639e+00
	+8.500000e-01 5.000000e-02 5.000000e-02 1.760150e+01 3.859756e+00 3.850092e+00
	+9.500000e-01 5.000000e-02 5.000000e-02 1.634290e+01 3.289986e+00 3.272212e+00
	+1.050000e+00 5.000000e-02 5.000000e-02 1.444420e+01 2.955342e+00 2.914421e+00
	+1.150000e+00 5.000000e-02 5.000000e-02 1.271440e+01 2.791937e+00 2.765683e+00
	+1.250000e+00 5.000000e-02 5.000000e-02 1.162280e+01 2.418043e+00 2.437281e+00
	+1.350000e+00 5.000000e-02 5.000000e-02 9.898210e+00 1.997269e+00 1.986521e+00
	+1.450000e+00 5.000000e-02 5.000000e-02 8.276860e+00 1.742947e+00 1.791985e+00
	+1.600000e+00 1.000000e-01 1.000000e-01 5.999230e+00 1.234600e+00 1.222396e+00
	+1.800000e+00 1.000000e-01 1.000000e-01 3.459200e+00 7.516454e-01 7.292973e-01
	+2.200000e+00 3.000000e-01 3.000000e-01 6.812840e-01 1.508826e-01 1.480814e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d10-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e-02 5.000000e-02 5.000000e-02 8.404740e-01 1.128325e-02 1.090940e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 8.229620e-01 1.022033e-02 1.057546e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 8.217160e-01 1.109336e-02 1.116717e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 8.050970e-01 1.811990e-02 1.597319e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 7.668000e-01 1.340416e-02 1.362622e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 7.303350e-01 1.449998e-02 1.501072e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 7.024670e-01 1.370285e-02 1.455186e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 6.635860e-01 1.007848e-02 1.144900e-02
	+8.500000e-01 5.000000e-02 5.000000e-02 5.943990e-01 1.663269e-02 1.705853e-02
	+9.500000e-01 5.000000e-02 5.000000e-02 5.518980e-01 1.162303e-02 1.156293e-02
	+1.050000e+00 5.000000e-02 5.000000e-02 4.877760e-01 1.048771e-02 1.002592e-02
	+1.150000e+00 5.000000e-02 5.000000e-02 4.293630e-01 9.906361e-03 9.327717e-03
	+1.250000e+00 5.000000e-02 5.000000e-02 3.924990e-01 6.493567e-03 7.101205e-03
	+1.350000e+00 5.000000e-02 5.000000e-02 3.342610e-01 1.011860e-02 1.025845e-02
	+1.450000e+00 5.000000e-02 5.000000e-02 2.795080e-01 6.695356e-03 8.527763e-03
	+1.600000e+00 1.000000e-01 1.000000e-01 2.025930e-01 4.224103e-03 4.022685e-03
	+1.800000e+00 1.000000e-01 1.000000e-01 1.168170e-01 3.674908e-03 3.181375e-03
	+2.200000e+00 3.000000e-01 3.000000e-01 2.300680e-02 8.700794e-04 8.084201e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d11-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d11-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+01 2.000000e+01 2.000000e+01 5.476850e-01 1.146269e-01 1.139698e-01
	+6.000000e+01 2.000000e+01 2.000000e+01 1.280040e-01 2.788834e-02 2.807384e-02
	+1.000000e+02 2.000000e+01 2.000000e+01 3.914690e-02 7.942762e-03 8.011116e-03
	+1.450000e+02 2.500000e+01 2.500000e+01 1.349900e-02 2.701401e-03 2.761283e-03
	+2.000000e+02 3.000000e+01 3.000000e+01 4.213450e-03 8.971544e-04 8.993552e-04
	+4.150000e+02 1.850000e+02 1.850000e+02 3.103370e-04 6.058207e-05 6.145308e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d12-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d12-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+01 2.000000e+01 2.000000e+01 1.848040e-02 2.415988e-04 2.220607e-04
	+6.000000e+01 2.000000e+01 2.000000e+01 4.319200e-03 1.713025e-04 1.846616e-04
	+1.000000e+02 2.000000e+01 2.000000e+01 1.320920e-03 6.148051e-05 6.083527e-05
	+1.450000e+02 2.500000e+01 2.500000e+01 4.554940e-04 1.816511e-05 1.950696e-05
	+2.000000e+02 3.000000e+01 3.000000e+01 1.421730e-04 6.612686e-06 7.033805e-06
	+4.150000e+02 1.850000e+02 1.850000e+02 1.047160e-05 7.561010e-07 1.027394e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d13-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d13-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.000000e-01 7.000000e-01 7.000000e-01 1.248700e+00 2.745513e-01 2.724327e-01
	+1.800000e+00 4.000000e-01 4.000000e-01 3.030070e+00 6.584401e-01 6.749928e-01
	+2.450000e+00 2.500000e-01 2.500000e-01 9.609390e+00 2.113714e+00 2.131095e+00
	+2.925000e+00 2.250000e-01 2.250000e-01 4.596160e+01 9.443037e+00 9.380537e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d14-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d14-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.000000e-01 7.000000e-01 7.000000e-01 4.210080e-02 1.741187e-03 1.741187e-03
	+1.800000e+00 4.000000e-01 4.000000e-01 1.021610e-01 3.881417e-03 4.221202e-03
	+2.450000e+00 2.500000e-01 2.500000e-01 3.239880e-01 8.020834e-03 9.148451e-03
	+2.925000e+00 2.250000e-01 2.250000e-01 1.549630e+00 1.961643e-02 1.787725e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d15-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d15-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.500000e+01 4.500000e+01 4.500000e+01 2.490670e-02 5.733871e-03 5.647813e-03
	+1.150000e+02 2.500000e+01 2.500000e+01 7.721150e-02 1.808773e-02 1.808850e-02
	+1.675000e+02 2.750000e+01 2.750000e+01 1.023840e-01 2.291388e-02 2.270511e-02
	+2.250000e+02 3.000000e+01 3.000000e+01 1.004190e-01 2.115150e-02 2.105716e-02
	+2.875000e+02 3.250000e+01 3.250000e+01 7.213200e-02 1.452496e-02 1.466624e-02
	+3.525000e+02 3.250000e+01 3.250000e+01 4.325280e-02 8.630400e-03 8.529303e-03
	+4.200000e+02 3.500000e+01 3.500000e+01 2.568990e-02 5.102307e-03 5.054350e-03
	+4.925000e+02 3.750000e+01 3.750000e+01 1.518860e-02 2.887329e-03 2.913679e-03
	+5.700000e+02 4.000000e+01 4.000000e+01 8.127450e-03 1.707734e-03 1.718414e-03
	+6.525000e+02 4.250000e+01 4.250000e+01 4.543040e-03 9.454707e-04 9.198461e-04
	+7.375000e+02 4.250000e+01 4.250000e+01 2.324570e-03 4.695520e-04 4.706246e-04
	+8.225000e+02 4.250000e+01 4.250000e+01 1.218550e-03 2.719632e-04 2.772658e-04
	+9.075000e+02 4.250000e+01 4.250000e+01 6.155750e-04 1.409511e-04 1.410146e-04
	+9.955000e+02 4.550000e+01 4.550000e+01 3.307130e-04 8.350808e-05 8.241889e-05
	+1.270500e+03 2.295000e+02 2.295000e+02 7.707950e-05 1.953344e-05 1.807178e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d16-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d16-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.500000e+01 4.500000e+01 4.500000e+01 8.399900e-04 3.849690e-05 3.754711e-05
	+1.150000e+02 2.500000e+01 2.500000e+01 2.603990e-03 1.110379e-04 1.136739e-04
	+1.675000e+02 2.750000e+01 2.750000e+01 3.452960e-03 8.576299e-05 8.539572e-05
	+2.250000e+02 3.000000e+01 3.000000e+01 3.386660e-03 5.570692e-05 5.435864e-05
	+2.875000e+02 3.250000e+01 3.250000e+01 2.432680e-03 5.131802e-05 5.743920e-05
	+3.525000e+02 3.250000e+01 3.250000e+01 1.458720e-03 5.741687e-05 5.469619e-05
	+4.200000e+02 3.500000e+01 3.500000e+01 8.664040e-04 3.995540e-05 3.993861e-05
	+4.925000e+02 3.750000e+01 3.750000e+01 5.122420e-04 2.284890e-05 2.289251e-05
	+5.700000e+02 4.000000e+01 4.000000e+01 2.741020e-04 2.176729e-05 2.157094e-05
	+6.525000e+02 4.250000e+01 4.250000e+01 1.532160e-04 7.590711e-06 6.863771e-06
	+7.375000e+02 4.250000e+01 4.250000e+01 7.839730e-05 5.790860e-06 5.628911e-06
	+8.225000e+02 4.250000e+01 4.250000e+01 4.109620e-05 5.317010e-06 5.452537e-06
	+9.075000e+02 4.250000e+01 4.250000e+01 2.076050e-05 3.738540e-06 3.749538e-06
	+9.955000e+02 4.550000e+01 4.550000e+01 1.115340e-05 1.574300e-06 1.561501e-06
	+1.270500e+03 2.295000e+02 2.295000e+02 2.599540e-06 4.142760e-07 3.801987e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d17-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d17-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e-02 5.000000e-02 5.000000e-02 3.368580e+01 6.957464e+00 6.903950e+00
	+1.500000e-01 5.000000e-02 5.000000e-02 3.311430e+01 6.874900e+00 6.836186e+00
	+2.500000e-01 5.000000e-02 5.000000e-02 3.145440e+01 6.746644e+00 6.734072e+00
	+3.500000e-01 5.000000e-02 5.000000e-02 3.012680e+01 6.504550e+00 6.493412e+00
	+4.500000e-01 5.000000e-02 5.000000e-02 2.829980e+01 5.822610e+00 5.866715e+00
	+5.500000e-01 5.000000e-02 5.000000e-02 2.552530e+01 5.357160e+00 5.346961e+00
	+6.500000e-01 5.000000e-02 5.000000e-02 2.264700e+01 4.920719e+00 4.868689e+00
	+7.500000e-01 5.000000e-02 5.000000e-02 1.995730e+01 4.244309e+00 4.260454e+00
	+8.500000e-01 5.000000e-02 5.000000e-02 1.705750e+01 3.424366e+00 3.431859e+00
	+9.500000e-01 5.000000e-02 5.000000e-02 1.364350e+01 2.887453e+00 2.837209e+00
	+1.050000e+00 5.000000e-02 5.000000e-02 1.111390e+01 2.398777e+00 2.396115e+00
	+1.150000e+00 5.000000e-02 5.000000e-02 8.725570e+00 1.738623e+00 1.678638e+00
	+1.250000e+00 5.000000e-02 5.000000e-02 6.761050e+00 1.377403e+00 1.378144e+00
	+1.350000e+00 5.000000e-02 5.000000e-02 4.966550e+00 1.024540e+00 1.006075e+00
	+1.450000e+00 5.000000e-02 5.000000e-02 3.559080e+00 7.006089e-01 6.885703e-01
	+1.750000e+00 2.500000e-01 2.500000e-01 1.013350e+00 2.121696e-01 2.142018e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d18-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d18-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e-02 5.000000e-02 5.000000e-02 1.139170e+00 1.537147e-02 1.248998e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 1.119850e+00 1.645236e-02 1.627245e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 1.063710e+00 1.353093e-02 1.376055e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 1.018810e+00 1.648528e-02 1.713548e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 9.570280e-01 9.705496e-03 1.266210e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 8.632050e-01 9.222916e-03 9.751581e-03
	+6.500000e-01 5.000000e-02 5.000000e-02 7.658650e-01 1.369866e-02 1.212833e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 6.749060e-01 9.308429e-03 1.046101e-02
	+8.500000e-01 5.000000e-02 5.000000e-02 5.768430e-01 9.304034e-03 9.923980e-03
	+9.500000e-01 5.000000e-02 5.000000e-02 4.613890e-01 7.795542e-03 6.840583e-03
	+1.050000e+00 5.000000e-02 5.000000e-02 3.758450e-01 7.485806e-03 8.166074e-03
	+1.150000e+00 5.000000e-02 5.000000e-02 2.950770e-01 1.015654e-02 8.876458e-03
	+1.250000e+00 5.000000e-02 5.000000e-02 2.286420e-01 5.906779e-03 6.114690e-03
	+1.350000e+00 5.000000e-02 5.000000e-02 1.679570e-01 5.136399e-03 4.713779e-03
	+1.450000e+00 5.000000e-02 5.000000e-02 1.203590e-01 5.705172e-03 5.383483e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 3.426910e-02 1.361555e-03 1.515810e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d19-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d19-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.200000e+00 2.000000e-01 2.000000e-01 2.058280e+01 4.296699e+00 4.258017e+00
	+1.650000e+00 2.500000e-01 2.500000e-01 1.315660e+01 2.772704e+00 2.774808e+00
	+2.200000e+00 3.000000e-01 3.000000e-01 7.843360e+00 1.627125e+00 1.635590e+00
	+2.850000e+00 3.500000e-01 3.500000e-01 4.752390e+00 9.775894e-01 9.687109e-01
	+3.700000e+00 5.000000e-01 5.000000e-01 2.541410e+00 5.506720e-01 5.499359e-01
	+4.850000e+00 6.500000e-01 6.500000e-01 1.391200e+00 2.947572e-01 2.939656e-01
	+6.350000e+00 8.500000e-01 8.500000e-01 6.553130e-01 1.400795e-01 1.400664e-01
	+8.250000e+00 1.050000e+00 1.050000e+00 3.099090e-01 6.218028e-02 6.022957e-02
	+1.065000e+01 1.350000e+00 1.350000e+00 1.313330e-01 2.481022e-02 2.451056e-02
	+1.600000e+01 4.000000e+00 4.000000e+00 3.386430e-02 7.220122e-03 7.065365e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d20-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d20-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.200000e+00 2.000000e-01 2.000000e-01 6.957300e-01 5.330495e-03 4.554009e-03
	+1.650000e+00 2.500000e-01 2.500000e-01 4.447130e-01 3.581077e-03 4.481235e-03
	+2.200000e+00 3.000000e-01 3.000000e-01 2.651180e-01 3.512621e-03 3.975625e-03
	+2.850000e+00 3.500000e-01 3.500000e-01 1.606380e-01 1.934554e-03 1.839680e-03
	+3.700000e+00 5.000000e-01 5.000000e-01 8.590360e-02 1.575835e-03 1.605366e-03
	+4.850000e+00 6.500000e-01 6.500000e-01 4.702480e-02 9.386230e-04 9.806397e-04
	+6.350000e+00 8.500000e-01 8.500000e-01 2.215060e-02 4.663442e-04 4.704563e-04
	+8.250000e+00 1.050000e+00 1.050000e+00 1.047540e-02 3.971214e-04 3.666349e-04
	+1.065000e+01 1.350000e+00 1.350000e+00 4.439250e-03 2.372445e-04 2.537520e-04
	+1.600000e+01 4.000000e+00 4.000000e+00 1.144670e-03 6.261051e-05 5.735732e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d21-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d21-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e-02 5.000000e-02 5.000000e-02 4.545000e+00 9.590486e-01 9.473139e-01
	+1.500000e-01 5.000000e-02 5.000000e-02 1.129190e+01 2.252359e+00 2.246728e+00
	+2.500000e-01 5.000000e-02 5.000000e-02 1.568280e+01 3.222034e+00 3.179453e+00
	+3.500000e-01 5.000000e-02 5.000000e-02 1.923750e+01 3.988519e+00 4.044999e+00
	+5.000000e-01 1.000000e-01 1.000000e-01 2.448450e+01 5.203111e+00 5.170809e+00
	+7.000000e-01 1.000000e-01 1.000000e-01 2.958400e+01 6.193492e+00 6.168950e+00
	+9.000000e-01 1.000000e-01 1.000000e-01 2.501900e+01 5.374474e+00 5.313469e+00
	+1.150000e+00 1.500000e-01 1.500000e-01 1.284680e+01 2.764528e+00 2.762089e+00
	+1.500000e+00 2.000000e-01 2.000000e-01 5.592720e+00 1.156967e+00 1.156130e+00
	+2.000000e+00 3.000000e-01 3.000000e-01 2.165250e+00 4.677832e-01 4.699867e-01
	+2.700000e+00 4.000000e-01 4.000000e-01 8.176000e-01 1.628053e-01 1.646140e-01
	+4.050000e+00 9.500000e-01 9.500000e-01 2.359770e-01 4.807232e-02 4.735341e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1404878/d22-x01-y01
	+Path=/REF/ATLAS_2015_I1404878/d22-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e-02 5.000000e-02 5.000000e-02 1.546660e-01 6.063357e-03 5.489088e-03
	+1.500000e-01 5.000000e-02 5.000000e-02 3.842600e-01 1.309050e-02 1.294716e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 5.336860e-01 1.548138e-02 1.567599e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 6.546510e-01 1.197065e-02 1.378591e-02
	+5.000000e-01 1.000000e-01 1.000000e-01 8.332030e-01 1.093995e-02 1.103315e-02
	+7.000000e-01 1.000000e-01 1.000000e-01 1.006740e+00 2.461985e-02 2.478505e-02
	+9.000000e-01 1.000000e-01 1.000000e-01 8.513930e-01 1.644369e-02 1.550493e-02
	+1.150000e+00 1.500000e-01 1.500000e-01 4.371760e-01 9.756397e-03 9.728294e-03
	+1.500000e+00 2.000000e-01 2.000000e-01 1.903200e-01 3.594808e-03 3.754131e-03
	+2.000000e+00 3.000000e-01 3.000000e-01 7.368330e-02 1.854271e-03 2.141529e-03
	+2.700000e+00 4.000000e-01 4.000000e-01 2.782280e-02 7.046176e-04 8.361779e-04
	+4.050000e+00 9.500000e-01 9.500000e-01 8.030270e-03 2.460159e-04 2.356653e-04
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2015_I1408516.yoda b/data/refdata/ATLAS_2015_I1408516.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1408516.yoda
	@@ -0,0 +1,1293 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.600000e+01 4.000000e+00 4.000000e+00 1.420000e+00 9.221585e-02 9.221585e-02
	+2.500000e+01 5.000000e+00 5.000000e+00 1.040000e+00 5.568129e-02 5.568129e-02
	+3.800000e+01 8.000000e+00 8.000000e+00 1.010000e+00 4.843000e-02 4.843000e-02
	+5.600000e+01 1.000000e+01 1.000000e+01 1.516000e+01 7.168099e-01 7.168099e-01
	+9.100000e+01 2.500000e+01 2.500000e+01 5.376400e+02 4.628703e+00 4.628703e+00
	+1.330000e+02 1.700000e+01 1.700000e+01 5.720000e+00 8.399251e-02 8.399251e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d02-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.778000e+00 4.360104e-01 4.360104e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 6.662000e+00 2.248363e-01 2.248363e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.781000e+00 1.959463e-01 1.959463e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.561000e+00 1.773898e-01 1.773898e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.540000e+00 1.742637e-01 1.742637e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.327000e+00 1.710632e-01 1.710632e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.102000e+00 1.477138e-01 1.477138e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 5.682000e+00 1.405649e-01 1.405649e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 5.868000e+00 1.471687e-01 1.471687e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.263000e+00 1.211634e-01 1.211634e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.032000e+00 1.170413e-01 1.170413e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 4.796000e+00 1.159006e-01 1.159006e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.443000e+00 1.045758e-01 1.045758e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.113000e+00 9.196948e-02 9.196948e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.766000e+00 8.404173e-02 8.404173e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.400000e+00 8.628233e-02 8.628233e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.231000e+00 7.318055e-02 7.318055e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.833000e+00 6.416604e-02 6.416604e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.555000e+00 5.701716e-02 5.701716e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.206000e+00 4.726197e-02 4.726197e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.830000e+00 3.920644e-02 3.920644e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.545000e+00 3.363703e-02 3.363703e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.235000e+00 2.979398e-02 2.979398e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 1.008000e+00 2.147773e-02 2.147773e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.670000e-01 1.634268e-02 1.634268e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.450000e-01 1.180274e-02 1.180274e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 3.370000e-01 7.329266e-03 7.329266e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 2.010000e-01 5.642339e-03 5.642339e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.050000e-01 3.236317e-03 3.236317e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 6.470000e-02 2.550526e-03 2.550526e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 3.420000e-02 1.901409e-03 1.901409e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.840000e-02 1.102926e-03 1.102926e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 9.070000e-03 7.019735e-04 7.019735e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 4.540000e-03 4.235117e-04 4.235117e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 2.520000e-03 2.008584e-04 2.008584e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 5.250000e-04 5.269128e-05 5.269128e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d03-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 7.182000e+00 4.344368e-01 4.344368e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 7.048000e+00 2.657760e-01 2.657760e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.842000e+00 2.254748e-01 2.254748e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.408000e+00 1.996789e-01 1.996789e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.302000e+00 2.038188e-01 2.038188e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.328000e+00 1.971860e-01 1.971860e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.279000e+00 1.705763e-01 1.705763e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 6.047000e+00 1.644962e-01 1.644962e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 5.803000e+00 1.758223e-01 1.758223e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.295000e+00 1.393903e-01 1.393903e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.149000e+00 1.416677e-01 1.416677e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 4.906000e+00 1.364891e-01 1.364891e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.396000e+00 1.168046e-01 1.168046e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.289000e+00 1.142839e-01 1.142839e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 3.884000e+00 1.008345e-01 1.008345e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.645000e+00 9.141613e-02 9.141613e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.172000e+00 8.142840e-02 8.142840e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.869000e+00 7.365009e-02 7.365009e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.520000e+00 6.633873e-02 6.633873e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.092000e+00 5.246709e-02 5.246709e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.806000e+00 4.688649e-02 4.688649e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.462000e+00 3.753100e-02 3.753100e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.216000e+00 3.109728e-02 3.109728e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 9.890000e-01 2.446651e-02 2.446651e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.380000e-01 1.812237e-02 1.812237e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.540000e-01 1.385000e-02 1.385000e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 3.250000e-01 8.437491e-03 8.437491e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.970000e-01 6.551546e-03 6.551546e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.020000e-01 3.984533e-03 3.984533e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 6.050000e-02 2.899585e-03 2.899585e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 3.520000e-02 2.110826e-03 2.110826e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.740000e-02 1.250139e-03 1.250139e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 9.500000e-03 7.753420e-04 7.753420e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 5.670000e-03 7.519968e-04 7.519968e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 2.080000e-03 1.977094e-04 1.977094e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 6.030000e-04 5.804482e-05 5.804482e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d04-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.724000e+00 3.837985e-01 3.837985e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 6.620000e+00 3.000255e-01 3.000255e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.546000e+00 2.749320e-01 2.749320e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.493000e+00 2.714664e-01 2.714664e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.632000e+00 2.906753e-01 2.906753e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.727000e+00 2.692481e-01 2.692481e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.531000e+00 2.425280e-01 2.425280e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 6.023000e+00 2.295071e-01 2.295071e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 6.204000e+00 2.292963e-01 2.292963e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.461000e+00 2.064374e-01 2.064374e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.384000e+00 2.108714e-01 2.108714e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.016000e+00 1.956240e-01 1.956240e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.760000e+00 1.705648e-01 1.705648e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.364000e+00 1.703638e-01 1.703638e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 3.733000e+00 1.448192e-01 1.448192e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.600000e+00 1.216033e-01 1.216033e-01
	+9.650000e-02 5.500000e-03 5.500000e-03 3.201000e+00 1.126279e-01 1.126279e-01
	+1.080000e-01 6.000000e-03 6.000000e-03 2.927000e+00 1.065846e-01 1.065846e-01
	+1.210000e-01 7.000000e-03 7.000000e-03 2.599000e+00 9.520999e-02 9.520999e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.987000e+00 7.649305e-02 7.649305e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.840000e+00 6.631662e-02 6.631662e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.544000e+00 5.588342e-02 5.588342e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.302000e+00 4.871638e-02 4.871638e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 1.000000e+00 3.432200e-02 3.432200e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.280000e-01 2.646958e-02 2.646958e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.380000e-01 1.763130e-02 1.763130e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 3.470000e-01 1.110942e-02 1.110942e-02
	+6.095000e-01 8.550000e-02 8.550000e-02 1.910000e-01 9.116124e-03 9.116124e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.030000e-01 5.190015e-03 5.190015e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 5.430000e-02 4.072138e-03 4.072138e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 2.850000e-02 2.309204e-03 2.309204e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.520000e-02 1.297086e-03 1.297086e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 6.280000e-03 6.860451e-04 6.860451e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 2.740000e-03 3.974889e-04 3.974889e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 1.150000e-03 1.592034e-04 1.592034e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 2.130000e-04 3.964147e-05 3.964147e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d05-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.252000e+00 4.239799e-02 4.239799e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.264000e+00 3.930382e-02 3.930382e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.001000e+00 3.818801e-02 3.818801e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.810000e+00 3.737766e-02 3.737766e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.627000e+00 3.660126e-02 3.660126e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.112000e+00 3.441630e-02 3.441630e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.778000e+00 3.299926e-02 3.299926e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.344000e+00 3.115795e-02 3.115795e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.884000e+00 2.920634e-02 2.920634e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.367000e+00 2.701289e-02 2.701289e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.865000e+00 2.488309e-02 2.488309e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.438000e+00 2.307148e-02 2.307148e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.954000e+00 2.101804e-02 2.101804e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.522000e+00 1.918522e-02 1.918522e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.021000e+00 1.705966e-02 1.705966e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.572000e+00 1.515471e-02 1.515471e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.145000e+00 1.334310e-02 1.334310e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.764000e+00 1.172666e-02 1.172666e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.394000e+00 1.015688e-02 1.015688e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.023000e+00 8.582862e-03 8.582862e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.697000e+00 7.199761e-03 7.199761e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.396000e+00 5.922726e-03 5.922726e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.111000e+00 4.713574e-03 4.713574e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.510000e-01 3.610487e-03 3.610487e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.180000e-01 2.832032e-03 2.832032e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.110000e-01 2.095697e-03 2.095697e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.410000e-01 1.228864e-03 1.228864e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.260000e-01 7.767162e-04 7.767162e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.350000e-02 4.999995e-04 4.999995e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.350000e-02 3.333208e-04 3.333208e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.780000e-02 1.949892e-04 1.949892e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 8.830000e-03 1.147900e-04 1.147900e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.510000e-03 7.915018e-05 7.915018e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 2.390000e-03 4.857054e-05 4.857054e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 1.030000e-03 2.125896e-05 2.125896e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 3.060000e-04 6.944245e-06 6.944245e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d06-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.405000e+00 4.309912e-02 4.309912e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.230000e+00 3.915957e-02 3.915957e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.055000e+00 3.841711e-02 3.841711e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.813000e+00 3.739039e-02 3.739039e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.530000e+00 3.618973e-02 3.618973e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.163000e+00 4.241619e-02 4.241619e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.849000e+00 3.330049e-02 3.330049e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.382000e+00 3.131917e-02 3.131917e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.874000e+00 2.916391e-02 2.916391e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.410000e+00 2.719533e-02 2.719533e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.850000e+00 2.481945e-02 2.481945e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.427000e+00 2.819952e-02 2.819952e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.933000e+00 2.092895e-02 2.092895e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.503000e+00 1.910461e-02 1.910461e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.020000e+00 1.705542e-02 1.705542e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.585000e+00 1.520987e-02 1.520987e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.146000e+00 1.334735e-02 1.334735e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.786000e+00 1.182000e-02 1.182000e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.380000e+00 1.009748e-02 1.009748e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.034000e+00 8.629531e-03 8.629531e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.694000e+00 7.187033e-03 7.187033e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.396000e+00 5.922726e-03 5.922726e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.115000e+00 4.730544e-03 4.730544e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.530000e-01 3.908937e-03 3.908937e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.160000e-01 2.822867e-03 2.822867e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.100000e-01 2.090598e-03 2.090598e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.400000e-01 1.419859e-03 1.419859e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.240000e-01 8.680000e-04 8.680000e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.290000e-02 4.952751e-04 4.952751e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.300000e-02 3.283459e-04 3.283459e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.750000e-02 2.025771e-04 2.025771e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 8.500000e-03 1.211064e-04 1.211064e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.400000e-03 7.721969e-05 7.721969e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 2.290000e-03 4.868607e-05 4.868607e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 9.940000e-04 2.222652e-05 2.222652e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 3.090000e-04 7.113714e-06 7.113714e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d07-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.387000e+00 4.301664e-02 4.301664e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.268000e+00 3.932079e-02 3.932079e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.252000e+00 3.925291e-02 3.925291e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.913000e+00 4.881851e-02 4.881851e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.699000e+00 4.764639e-02 4.764639e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.264000e+00 4.294100e-02 4.294100e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.876000e+00 3.341504e-02 3.341504e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.364000e+00 3.374609e-02 3.374609e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.923000e+00 3.791883e-02 3.791883e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.430000e+00 2.728018e-02 2.728018e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.921000e+00 3.076642e-02 3.076642e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.410000e+00 2.811118e-02 2.811118e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 5.012000e+00 2.604312e-02 2.604312e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.492000e+00 2.334112e-02 2.334112e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.019000e+00 2.088334e-02 2.088334e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.589000e+00 1.864899e-02 1.864899e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.141000e+00 1.632111e-02 1.632111e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.755000e+00 1.431540e-02 1.431540e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.394000e+00 1.243959e-02 1.243959e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.029000e+00 1.054299e-02 1.054299e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.695000e+00 8.807478e-03 8.807478e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.378000e+00 7.160298e-03 7.160298e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.106000e+00 5.746945e-03 5.746945e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.450000e-01 4.390749e-03 4.390749e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.140000e-01 3.363017e-03 3.363017e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.090000e-01 2.419677e-03 2.419677e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.380000e-01 1.408027e-03 1.408027e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.220000e-01 8.965132e-04 8.965132e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.240000e-02 5.107660e-04 5.107660e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.210000e-02 3.486953e-04 3.486953e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.650000e-02 1.993703e-04 1.993703e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 8.010000e-03 1.209483e-04 1.209483e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.120000e-03 7.381587e-05 7.381587e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 2.100000e-03 4.653289e-05 4.653289e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 9.420000e-04 2.168647e-05 2.168647e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.820000e-04 6.849756e-06 6.849756e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d08-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.382000e+00 5.138733e-02 5.138733e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.317000e+00 5.352209e-02 5.352209e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.095000e+00 5.224680e-02 5.224680e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.874000e+00 4.860490e-02 4.860490e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.552000e+00 4.912750e-02 4.912750e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.242000e+00 4.734669e-02 4.734669e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.803000e+00 4.482482e-02 4.482482e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.312000e+00 4.004947e-02 4.004947e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.920000e+00 3.975237e-02 3.975237e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.397000e+00 3.503781e-02 3.503781e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.877000e+00 3.218965e-02 3.218965e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.366000e+00 2.939079e-02 2.939079e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.985000e+00 2.590282e-02 2.590282e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.526000e+00 2.351779e-02 2.351779e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.049000e+00 2.217729e-02 2.217729e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.593000e+00 1.967967e-02 1.967967e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.196000e+00 1.750521e-02 1.750521e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.756000e+00 1.509523e-02 1.509523e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.403000e+00 1.316177e-02 1.316177e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.065000e+00 1.131047e-02 1.131047e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.715000e+00 9.393442e-03 9.393442e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.404000e+00 7.690025e-03 7.690025e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.117000e+00 6.885650e-03 6.885650e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.510000e-01 5.245916e-03 5.245916e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.210000e-01 3.828101e-03 3.828101e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.150000e-01 2.558232e-03 2.558232e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.380000e-01 1.408027e-03 1.408027e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.240000e-01 1.066688e-03 1.066688e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 6.150000e-02 6.025745e-04 6.025745e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.130000e-02 3.983840e-04 3.983840e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.630000e-02 2.322393e-04 2.322393e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 7.520000e-03 1.295973e-04 1.295973e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 3.560000e-03 7.643644e-05 7.643644e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 1.680000e-03 4.435327e-05 4.435327e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 7.690000e-04 1.957554e-05 1.957554e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.150000e-04 6.238706e-06 6.238706e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d09-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.378000e+00 6.891394e-02 6.891394e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.264000e+00 6.145042e-02 6.145042e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.014000e+00 5.979211e-02 5.979211e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.875000e+00 6.700478e-02 6.700478e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.592000e+00 6.486818e-02 6.486818e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.207000e+00 6.196149e-02 6.196149e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.721000e+00 5.121532e-02 5.121532e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.439000e+00 4.934474e-02 4.934474e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.755000e+00 5.099913e-02 5.099913e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.394000e+00 4.241300e-02 4.241300e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.878000e+00 4.437793e-02 4.437793e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.309000e+00 4.008207e-02 4.008207e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.899000e+00 3.698664e-02 3.698664e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.508000e+00 2.990269e-02 2.990269e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.011000e+00 3.001558e-02 3.001558e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.574000e+00 2.968787e-02 2.968787e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.159000e+00 2.384993e-02 2.384993e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.806000e+00 2.061980e-02 2.061980e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.407000e+00 1.768777e-02 1.768777e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.072000e+00 1.522603e-02 1.522603e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.730000e+00 1.306121e-02 1.306121e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.417000e+00 1.069812e-02 1.069812e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.137000e+00 9.780844e-03 9.780844e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.710000e-01 7.492625e-03 7.492625e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.430000e-01 5.341159e-03 5.341159e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.280000e-01 3.681795e-03 3.681795e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.440000e-01 2.222946e-03 2.222946e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.250000e-01 1.346291e-03 1.346291e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 6.210000e-02 7.976889e-04 7.976889e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.050000e-02 5.011661e-04 5.011661e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.480000e-02 2.792458e-04 2.792458e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 6.430000e-03 1.544539e-04 1.544539e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 2.740000e-03 8.621209e-05 8.621209e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 1.310000e-03 5.054971e-05 5.054971e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 5.100000e-04 2.140178e-05 2.140178e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 1.410000e-04 6.327743e-06 6.327743e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d10-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.324000e+00 1.042455e-01 1.042455e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 9.101000e+00 1.017523e-01 1.017523e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 9.083000e+00 1.015510e-01 1.015510e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 8.825000e+00 9.866650e-02 9.866650e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.401000e+00 9.392604e-02 9.392604e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.047000e+00 1.001843e-01 1.001843e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 7.986000e+00 9.244463e-02 9.244463e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.168000e+00 8.297560e-02 8.297560e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.833000e+00 7.909769e-02 7.909769e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.468000e+00 7.231444e-02 7.231444e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.717000e+00 6.262660e-02 6.262660e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.413000e+00 6.427581e-02 6.427581e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.935000e+00 5.406022e-02 5.406022e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.502000e+00 4.931694e-02 4.931694e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.994000e+00 4.536312e-02 4.536312e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.517000e+00 3.947823e-02 3.947823e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.161000e+00 3.699856e-02 3.699856e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.793000e+00 3.543920e-02 3.543920e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.404000e+00 3.021781e-02 3.021781e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.036000e+00 2.383077e-02 2.383077e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.743000e+00 2.062345e-02 2.062345e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.447000e+00 1.712113e-02 1.712113e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.175000e+00 1.287148e-02 1.287148e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 8.940000e-01 1.034880e-02 1.034880e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 6.560000e-01 8.087711e-03 8.087711e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.380000e-01 5.908943e-03 5.908943e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.550000e-01 3.542573e-03 3.542573e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.310000e-01 2.003915e-03 2.003915e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 6.120000e-02 1.216326e-03 1.216326e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.920000e-02 7.586383e-04 7.586383e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.320000e-02 4.151185e-04 4.151185e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 4.920000e-03 2.155836e-04 2.155836e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 1.910000e-03 1.172746e-04 1.172746e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 5.830000e-04 5.450037e-05 5.450037e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 1.390000e-04 1.754761e-05 1.754761e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.470000e-05 5.084362e-06 5.084362e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d11-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d11-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.148900e+01 4.668268e-01 4.668268e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.137500e+01 3.500470e-01 3.500470e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.105100e+01 3.267061e-01 3.267061e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.080400e+01 3.280575e-01 3.280575e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 1.003800e+01 3.006377e-01 3.006377e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.378000e+00 2.896573e-01 2.896573e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 9.075000e+00 2.589160e-01 2.589160e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 8.348000e+00 2.381742e-01 2.381742e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 6.798000e+00 2.245399e-01 2.245399e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.684000e+00 2.020736e-01 2.020736e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 6.001000e+00 1.853522e-01 1.853522e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.433000e+00 1.820663e-01 1.820663e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 5.175000e+00 1.612575e-01 1.612575e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.099000e+00 1.353912e-01 1.353912e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 4.003000e+00 1.274061e-01 1.274061e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.423000e+00 1.147088e-01 1.147088e-01
	+9.650000e-02 5.500000e-03 5.500000e-03 2.992000e+00 1.002655e-01 1.002655e-01
	+1.080000e-01 6.000000e-03 6.000000e-03 2.495000e+00 1.179267e-01 1.179267e-01
	+1.210000e-01 7.000000e-03 7.000000e-03 2.134000e+00 7.450686e-02 7.450686e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.857000e+00 6.774869e-02 6.774869e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.507000e+00 5.293840e-02 5.293840e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.212000e+00 4.960324e-02 4.960324e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.790000e-01 3.720200e-02 3.720200e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.050000e-01 2.851549e-02 2.851549e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.260000e-01 2.496700e-02 2.496700e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.540000e-01 1.683641e-02 1.683641e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 1.990000e-01 1.120425e-02 1.120425e-02
	+6.095000e-01 8.550000e-02 8.550000e-02 1.030000e-01 7.310098e-03 7.310098e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 5.400000e-02 4.195004e-03 4.195004e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.580000e-02 3.192222e-03 3.192222e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 1.800000e-02 1.652082e-03 1.652082e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 8.040000e-03 1.036661e-03 1.036661e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 2.850000e-03 7.139577e-04 7.139577e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 1.360000e-03 3.894447e-04 3.894447e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 8.500000e-04 1.899517e-04 1.899517e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 2.850000e-04 6.775152e-05 6.775152e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d12-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d12-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.097200e+01 4.375064e-01 4.375064e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.198900e+01 3.941811e-01 3.941811e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.062800e+01 3.698483e-01 3.698483e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.071800e+01 3.594926e-01 3.594926e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 9.871000e+00 3.456260e-01 3.456260e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.754000e+00 3.504660e-01 3.504660e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 8.577000e+00 2.857570e-01 2.857570e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 7.516000e+00 3.044676e-01 3.044676e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.643000e+00 2.705449e-01 2.705449e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.365000e+00 2.268299e-01 2.268299e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 6.080000e+00 2.185420e-01 2.185420e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.577000e+00 2.057452e-01 2.057452e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.794000e+00 1.822351e-01 1.822351e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.645000e+00 1.787571e-01 1.787571e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 4.082000e+00 1.486431e-01 1.486431e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.474000e+00 1.294735e-01 1.294735e-01
	+9.650000e-02 5.500000e-03 5.500000e-03 3.205000e+00 1.210710e-01 1.210710e-01
	+1.080000e-01 6.000000e-03 6.000000e-03 2.435000e+00 1.017469e-01 1.017469e-01
	+1.210000e-01 7.000000e-03 7.000000e-03 2.051000e+00 8.528314e-02 8.528314e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.828000e+00 8.088771e-02 8.088771e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.608000e+00 6.791778e-02 6.791778e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.211000e+00 5.259143e-02 5.259143e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.400000e-01 4.274675e-02 4.274675e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.740000e-01 3.470076e-02 3.470076e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.470000e-01 2.742102e-02 2.742102e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.550000e-01 1.845317e-02 1.845317e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 2.120000e-01 1.117182e-02 1.117182e-02
	+6.095000e-01 8.550000e-02 8.550000e-02 1.010000e-01 7.258661e-03 7.258661e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 5.040000e-02 4.329416e-03 4.329416e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.540000e-02 2.901165e-03 2.901165e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 1.140000e-02 3.444611e-03 3.444611e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 5.230000e-03 9.077478e-04 9.077478e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 2.360000e-03 5.490235e-04 5.490235e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 1.470000e-03 3.806392e-04 3.806392e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 6.540000e-04 1.789906e-04 1.789906e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 2.280000e-04 5.534533e-05 5.534533e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d13-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d13-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.189200e+01 6.601935e-01 6.601935e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.164800e+01 7.139568e-01 7.139568e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.145500e+01 6.088416e-01 6.088416e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.117100e+01 6.074600e-01 6.074600e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 9.714000e+00 5.861496e-01 5.861496e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.337000e+00 6.076228e-01 6.076228e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 9.075000e+00 5.342702e-01 5.342702e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 7.757000e+00 4.665821e-01 4.665821e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.263000e+00 4.515928e-01 4.515928e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.336000e+00 3.816881e-01 3.816881e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 6.574000e+00 3.934527e-01 3.934527e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.317000e+00 3.433070e-01 3.433070e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.755000e+00 3.090750e-01 3.090750e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.983000e+00 2.991876e-01 2.991876e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 3.911000e+00 2.533410e-01 2.533410e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.070000e+00 2.120301e-01 2.120301e-01
	+9.650000e-02 5.500000e-03 5.500000e-03 3.005000e+00 2.394402e-01 2.394402e-01
	+1.080000e-01 6.000000e-03 6.000000e-03 2.530000e+00 1.755390e-01 1.755390e-01
	+1.210000e-01 7.000000e-03 7.000000e-03 2.350000e+00 1.581499e-01 1.581499e-01
	+1.365000e-01 8.500000e-03 8.500000e-03 1.975000e+00 1.230379e-01 1.230379e-01
	+1.550000e-01 1.000000e-02 1.000000e-02 1.409000e+00 9.608099e-02 9.608099e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.252000e+00 9.614349e-02 9.614349e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.700000e-01 8.799777e-02 8.799777e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 8.560000e-01 5.917555e-02 5.917555e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.380000e-01 3.772911e-02 3.772911e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.560000e-01 2.752504e-02 2.752504e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 1.940000e-01 1.631908e-02 1.631908e-02
	+6.095000e-01 8.550000e-02 8.550000e-02 7.870000e-02 1.118676e-02 1.118676e-02
	+8.065000e-01 1.115000e-01 1.115000e-01 4.650000e-02 5.862874e-03 5.862874e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.280000e-02 3.976623e-03 3.976623e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 9.700000e-03 2.050374e-03 2.050374e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 4.960000e-03 1.201355e-03 1.201355e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 1.550000e-03 5.501015e-04 5.501015e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 6.780000e-04 3.120752e-04 3.120752e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 9.360000e-05 1.454449e-04 1.454449e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 5.400000e-05 4.329776e-05 4.329776e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d14-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d14-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.941000e+00 3.873302e-01 3.873302e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 6.819000e+00 1.969263e-01 1.969263e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.793000e+00 1.563866e-01 1.563866e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.507000e+00 1.309508e-01 1.309508e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.498000e+00 1.376902e-01 1.376902e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.428000e+00 1.234778e-01 1.234778e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.261000e+00 1.077183e-01 1.077183e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 5.900000e+00 1.038802e-01 1.038802e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 5.934000e+00 1.069767e-01 1.069767e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.324000e+00 8.748225e-02 8.748225e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.159000e+00 8.648060e-02 8.648060e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 4.874000e+00 8.399700e-02 8.399700e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.499000e+00 7.365180e-02 7.365180e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.231000e+00 6.926446e-02 6.926446e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.805000e+00 6.229053e-02 6.229053e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.526000e+00 5.761531e-02 5.761531e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.202000e+00 5.241900e-02 5.241900e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.856000e+00 4.913648e-02 4.913648e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.549000e+00 3.957112e-02 3.957112e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.122000e+00 3.218172e-02 3.218172e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.817000e+00 2.980102e-02 2.980102e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.512000e+00 2.479864e-02 2.479864e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.240000e+00 2.136977e-02 2.136977e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 9.990000e-01 1.638482e-02 1.638482e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.480000e-01 1.168413e-02 1.168413e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.450000e-01 9.328897e-03 9.328897e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 3.330000e-01 5.777334e-03 5.777334e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.970000e-01 4.548098e-03 4.548098e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.030000e-01 2.595518e-03 2.595518e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 6.110000e-02 1.909803e-03 1.909803e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 3.330000e-02 1.351012e-03 1.351012e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.740000e-02 7.754233e-04 7.754233e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 8.630000e-03 4.749637e-04 4.749637e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 4.570000e-03 3.650283e-04 3.650283e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 2.070000e-03 1.226726e-04 1.226726e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 4.860000e-04 3.479231e-05 3.479231e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d15-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d15-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.362000e+00 2.808600e-02 2.808600e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.267000e+00 2.269942e-02 2.269942e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.094000e+00 2.227566e-02 2.227566e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.855000e+00 2.169023e-02 2.169023e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.601000e+00 2.106806e-02 2.106806e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.188000e+00 2.005642e-02 2.005642e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.825000e+00 1.916726e-02 1.916726e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.356000e+00 1.801845e-02 1.801845e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.883000e+00 1.685984e-02 1.685984e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.403000e+00 1.568408e-02 1.568408e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.871000e+00 1.438095e-02 1.438095e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.404000e+00 1.323704e-02 1.323704e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.960000e+00 1.214947e-02 1.214947e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.509000e+00 1.104475e-02 1.104475e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.022000e+00 9.851848e-03 9.851848e-03
	+8.600000e-02 5.000000e-03 5.000000e-03 3.580000e+00 8.769173e-03 8.769173e-03
	+9.650000e-02 5.500000e-03 5.500000e-03 3.155000e+00 7.728140e-03 7.728140e-03
	+1.080000e-01 6.000000e-03 6.000000e-03 2.771000e+00 6.787536e-03 6.787536e-03
	+1.210000e-01 7.000000e-03 7.000000e-03 2.394000e+00 5.864078e-03 5.864078e-03
	+1.365000e-01 8.500000e-03 8.500000e-03 2.039000e+00 4.994510e-03 4.994510e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.704000e+00 4.173931e-03 4.173931e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.398000e+00 3.424387e-03 3.424387e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.117000e+00 2.736080e-03 2.736080e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.540000e-01 2.091864e-03 2.091864e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.210000e-01 2.323569e-03 2.323569e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.140000e-01 1.549046e-03 1.549046e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.410000e-01 9.017394e-04 9.017394e-04
	+6.095000e-01 8.550000e-02 8.550000e-02 1.240000e-01 5.405035e-04 5.405035e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.250000e-02 2.724312e-04 2.724312e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.220000e-02 1.932000e-04 1.932000e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.660000e-02 1.075803e-04 1.075803e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 7.910000e-03 6.377246e-05 6.377246e-05
	+2.234500e+00 2.875000e-01 2.875000e-01 3.920000e-03 3.780311e-05 3.780311e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 1.980000e-03 2.342768e-05 2.342768e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 8.600000e-04 1.081003e-05 1.081003e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.550000e-04 3.411667e-06 3.411667e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d16-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d16-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.137800e+01 3.549134e-01 3.549134e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.162300e+01 2.492856e-01 2.492856e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.095000e+01 2.351065e-01 2.351065e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.081900e+01 2.284833e-01 2.284833e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 9.950000e+00 2.161693e-01 2.161693e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.516000e+00 2.067404e-01 2.067404e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 8.890000e+00 1.826241e-01 1.826241e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 7.962000e+00 1.776793e-01 1.776793e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.172000e+00 1.606912e-01 1.606912e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.523000e+00 1.417158e-01 1.417158e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 6.099000e+00 1.381393e-01 1.381393e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.466000e+00 1.288864e-01 1.288864e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.992000e+00 1.130663e-01 1.130663e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.404000e+00 1.024344e-01 1.024344e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 4.017000e+00 9.098305e-02 9.098305e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.397000e+00 8.010008e-02 8.010008e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.067000e+00 7.980096e-02 7.980096e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.480000e+00 7.599491e-02 7.599491e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.131000e+00 5.280410e-02 5.280410e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.859000e+00 4.621401e-02 4.621401e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.530000e+00 3.791191e-02 3.791191e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.219000e+00 3.273191e-02 3.273191e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.660000e-01 2.801400e-02 2.801400e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.510000e-01 2.109495e-02 2.109495e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.360000e-01 1.821612e-02 1.821612e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.560000e-01 1.191936e-02 1.191936e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 2.040000e-01 7.503762e-03 7.503762e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 9.880000e-02 5.125235e-03 5.125235e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 5.150000e-02 2.929621e-03 2.929621e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.520000e-02 1.887310e-03 1.887310e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 1.440000e-02 1.568278e-03 1.568278e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 6.510000e-03 6.113510e-04 6.113510e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 2.500000e-03 4.135668e-04 4.135668e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 1.320000e-03 2.367662e-04 2.367662e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 6.680000e-04 1.110428e-04 1.110428e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 2.290000e-04 3.869558e-05 3.869558e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d17-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d17-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.622000e-02 2.528565e-04 2.528565e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.438000e-02 2.772847e-04 2.772847e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.513000e-02 2.968841e-04 2.968841e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.896000e-02 2.636577e-04 2.636577e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.127000e-02 2.476200e-04 2.476200e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.293000e-02 1.544554e-04 1.544554e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.532000e-02 1.363524e-04 1.363524e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.920000e-02 1.033952e-04 1.033952e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.377000e-02 6.310207e-05 6.310207e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.812000e-03 5.003158e-05 5.003158e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.865000e-03 3.696916e-05 3.696916e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.627000e-03 3.400137e-05 3.400137e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 3.029000e-03 2.675140e-05 2.675140e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.926000e-03 1.964142e-05 1.964142e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.275000e-03 1.582233e-05 1.582233e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.504000e-04 1.134575e-05 1.134575e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.956000e-04 5.800849e-06 5.800849e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.896000e-04 2.235351e-06 2.235351e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.379000e-05 9.347705e-07 9.347705e-07
	+5.500000e+02 3.500000e+02 3.500000e+02 2.288000e-06 5.395024e-08 5.395024e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d18-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d18-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.601000e-02 3.575784e-04 3.575784e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.469000e-02 4.092625e-04 4.092625e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.582000e-02 3.206615e-04 3.206615e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.875000e-02 3.270249e-04 3.270249e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.085000e-02 2.740301e-04 2.740301e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.303000e-02 1.778720e-04 1.778720e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.548000e-02 1.372140e-04 1.372140e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.933000e-02 1.040952e-04 1.040952e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.380000e-02 7.431527e-05 7.431527e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.832000e-03 6.060852e-05 6.060852e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.765000e-03 3.643064e-05 3.643064e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.625000e-03 3.398667e-05 3.398667e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 2.993000e-03 2.643346e-05 2.643346e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.915000e-03 2.257752e-05 2.257752e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.282000e-03 1.719983e-05 1.719983e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.543000e-04 1.315178e-05 1.315178e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.796000e-04 6.610830e-06 6.610830e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.855000e-04 2.556941e-06 2.556941e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.087000e-05 1.041283e-06 1.041283e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.117000e-06 5.700197e-08 5.700197e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d19-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d19-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.640000e-02 3.178981e-04 3.178981e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.532000e-02 4.139770e-04 4.139770e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.598000e-02 3.014615e-04 3.014615e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.889000e-02 2.933400e-04 2.933400e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.126000e-02 3.169241e-04 3.169241e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.288000e-02 1.972800e-04 1.972800e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.552000e-02 1.711934e-04 1.711934e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.917000e-02 1.032336e-04 1.032336e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.360000e-02 7.323824e-05 7.323824e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.826000e-03 6.057153e-05 6.057153e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.841000e-03 4.589082e-05 4.589082e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.559000e-03 3.675583e-05 3.675583e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 2.962000e-03 3.092419e-05 3.092419e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.903000e-03 2.392034e-05 2.392034e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.238000e-03 1.921893e-05 1.921893e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.166000e-04 1.416748e-05 1.416748e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.798000e-04 7.051591e-06 7.051591e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.807000e-04 2.536245e-06 2.536245e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.136000e-05 1.186849e-06 1.186849e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.031000e-06 5.704905e-08 5.704905e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d20-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d20-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.584000e-02 3.329251e-04 3.329251e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.405000e-02 4.953764e-04 4.953764e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.436000e-02 3.646580e-04 3.646580e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.804000e-02 4.019315e-04 4.019315e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.096000e-02 3.009933e-04 3.009933e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.316000e-02 1.785721e-04 1.785721e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.573000e-02 1.819386e-04 1.819386e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.956000e-02 1.312125e-04 1.312125e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.390000e-02 9.828784e-05 9.828784e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 1.000000e-02 9.000000e-05 9.000000e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.933000e-03 6.239700e-05 6.239700e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.611000e-03 4.814025e-05 4.814025e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 2.995000e-03 3.764657e-05 3.764657e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.940000e-03 2.864376e-05 2.864376e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.290000e-03 2.162434e-05 2.162434e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.719000e-04 1.547469e-05 1.547469e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.966000e-04 7.788867e-06 7.788867e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.933000e-04 3.240298e-06 3.240298e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.229000e-05 1.420518e-06 1.420518e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.078000e-06 9.100596e-08 9.100596e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d21-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d21-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.536000e-02 4.493803e-04 4.493803e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.324000e-02 6.628327e-04 6.628327e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.345000e-02 4.471948e-04 4.471948e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.640000e-02 5.208387e-04 5.208387e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 3.960000e-02 4.134361e-04 4.134361e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.241000e-02 2.711615e-04 2.711615e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.554000e-02 2.476195e-04 2.476195e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.920000e-02 1.728000e-04 1.728000e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.431000e-02 1.197260e-04 1.197260e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 1.042000e-02 1.183484e-04 1.183484e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 7.322000e-03 8.087413e-05 8.087413e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.924000e-03 6.606239e-05 6.606239e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 3.207000e-03 5.327869e-05 5.327869e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 2.042000e-03 3.985825e-05 3.985825e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.333000e-03 3.065900e-05 3.065900e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 9.113000e-04 2.342945e-05 2.342945e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 5.245000e-04 1.014335e-05 1.014335e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 2.042000e-04 3.890533e-06 3.890533e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.886000e-05 1.791124e-06 1.791124e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.048000e-06 9.925936e-08 9.925936e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d22-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d22-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.582000e-02 6.995267e-04 6.995267e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.224000e-02 9.256952e-04 9.256952e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.276000e-02 7.253301e-04 7.253301e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.545000e-02 6.215194e-04 6.215194e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 3.928000e-02 5.637741e-04 5.637741e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.116000e-02 3.765077e-04 3.765077e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.418000e-02 3.594615e-04 3.594615e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.935000e-02 2.385628e-04 2.385628e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.407000e-02 1.989798e-04 1.989798e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 1.040000e-02 1.647670e-04 1.647670e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 7.412000e-03 1.133818e-04 1.133818e-04
	+4.100000e+01 4.000000e+00 4.000000e+00 5.299000e-03 7.983749e-05 7.983749e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 3.549000e-03 6.752433e-05 6.752433e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 2.400000e-03 5.290898e-05 5.290898e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.534000e-03 4.245607e-05 4.245607e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 9.811000e-04 3.046154e-05 3.046154e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 5.455000e-04 1.434986e-05 1.434986e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 2.015000e-04 5.334996e-06 5.334996e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.896000e-05 2.783012e-06 2.783012e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 1.803000e-06 1.224050e-07 1.224050e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d23-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d23-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.720000e-02 8.963628e-04 8.963628e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.137000e-02 6.894930e-04 6.894930e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.526000e-02 7.232017e-04 7.232017e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.014000e-02 4.031846e-04 4.031846e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 6.223000e-03 2.106649e-04 2.106649e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.116000e-03 7.667398e-05 7.667398e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 5.489000e-04 3.381420e-05 3.381420e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 1.888000e-05 2.088097e-06 2.088097e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d24-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d24-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.771000e-02 9.165268e-04 9.165268e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.081000e-02 7.354502e-04 7.354502e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.441000e-02 5.869312e-04 5.869312e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.048000e-02 5.363262e-04 5.363262e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 6.007000e-03 2.850636e-04 2.850636e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.236000e-03 1.143862e-04 1.143862e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.916000e-04 4.379838e-05 4.379838e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.228000e-05 2.066162e-06 2.066162e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d25-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d25-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.853000e-02 8.114767e-04 8.114767e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.153000e-02 7.036062e-04 7.036062e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.517000e-02 5.808347e-04 5.808347e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 9.428000e-03 4.730940e-04 4.730940e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.793000e-03 2.575769e-04 2.575769e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.114000e-03 9.947038e-05 9.947038e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 5.464000e-04 3.754289e-05 3.754289e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.155000e-05 2.373437e-06 2.373437e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d26-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d26-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.886000e-02 1.851466e-03 1.851466e-03
	+3.000000e+00 1.000000e+00 1.000000e+00 7.415000e-02 1.271408e-03 1.271408e-03
	+5.000000e+00 1.000000e+00 1.000000e+00 6.674000e-02 1.046776e-03 1.046776e-03
	+7.000000e+00 1.000000e+00 1.000000e+00 5.417000e-02 8.161533e-04 8.161533e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.119000e-02 7.310500e-04 7.310500e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.160000e-02 5.766459e-04 5.766459e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.289000e-02 4.685466e-04 4.685466e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.705000e-02 3.248461e-04 3.248461e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.254000e-02 2.218552e-04 2.218552e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 7.907000e-03 1.766290e-04 1.766290e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 4.606000e-03 1.168872e-04 1.168872e-04
	+4.100000e+01 4.000000e+00 4.000000e+00 2.797000e-03 8.580000e-05 8.580000e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 1.915000e-03 6.264129e-05 6.264129e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.213000e-03 5.018948e-05 5.018948e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 8.436000e-04 4.249099e-05 4.249099e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 6.112000e-04 3.547067e-05 3.547067e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 3.534000e-04 1.829848e-05 1.829848e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 1.279000e-04 7.283565e-06 7.283565e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 3.507000e-05 2.559870e-06 2.559870e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 1.279000e-06 1.263170e-07 1.263170e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d27-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d27-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.608000e-02 2.487873e-04 2.487873e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.441000e-02 2.980158e-04 2.980158e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.505000e-02 2.059782e-04 2.059782e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.831000e-02 2.213842e-04 2.213842e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.084000e-02 1.871524e-04 1.871524e-04
	+1.100000e+01 1.000000e+00 1.000000e+00 3.429000e-02 1.028700e-04 1.028700e-04
	+1.300000e+01 1.000000e+00 1.000000e+00 2.881000e-02 1.077971e-04 1.077971e-04
	+1.500000e+01 1.000000e+00 1.000000e+00 2.431000e-02 1.059648e-04 1.059648e-04
	+1.700000e+01 1.000000e+00 1.000000e+00 2.076000e-02 7.767681e-05 7.767681e-05
	+1.900000e+01 1.000000e+00 1.000000e+00 1.782000e-02 8.358321e-05 8.358321e-05
	+2.125000e+01 1.250000e+00 1.250000e+00 1.510000e-02 6.581937e-05 6.581937e-05
	+2.375000e+01 1.250000e+00 1.250000e+00 1.259000e-02 6.779922e-05 6.779922e-05
	+2.625000e+01 1.250000e+00 1.250000e+00 1.072000e-02 6.432000e-05 6.432000e-05
	+2.875000e+01 1.250000e+00 1.250000e+00 9.172000e-03 6.152765e-05 6.152765e-05
	+3.150000e+01 1.500000e+00 1.500000e+00 7.677000e-03 4.606200e-05 4.606200e-05
	+3.450000e+01 1.500000e+00 1.500000e+00 6.558000e-03 4.399240e-05 4.399240e-05
	+3.750000e+01 1.500000e+00 1.500000e+00 5.537000e-03 4.143511e-05 4.143511e-05
	+4.050000e+01 1.500000e+00 1.500000e+00 4.745000e-03 3.825541e-05 3.825541e-05
	+4.350000e+01 1.500000e+00 1.500000e+00 4.085000e-03 3.721612e-05 3.721612e-05
	+4.650000e+01 1.500000e+00 1.500000e+00 3.557000e-03 3.448639e-05 3.448639e-05
	+4.950000e+01 1.500000e+00 1.500000e+00 3.060000e-03 2.966780e-05 2.966780e-05
	+5.250000e+01 1.500000e+00 1.500000e+00 2.706000e-03 3.120711e-05 3.120711e-05
	+5.550000e+01 1.500000e+00 1.500000e+00 2.358000e-03 2.849182e-05 2.849182e-05
	+5.900000e+01 2.000000e+00 2.000000e+00 2.011000e-03 2.099546e-05 2.099546e-05
	+6.300000e+01 2.000000e+00 2.000000e+00 1.702000e-03 2.139381e-05 2.139381e-05
	+6.750000e+01 2.500000e+00 2.500000e+00 1.440000e-03 1.733990e-05 1.733990e-05
	+7.250000e+01 2.500000e+00 2.500000e+00 1.138000e-03 1.617402e-05 1.617402e-05
	+7.750000e+01 2.500000e+00 2.500000e+00 9.443000e-04 1.338776e-05 1.338776e-05
	+8.250000e+01 2.500000e+00 2.500000e+00 7.761000e-04 1.227122e-05 1.227122e-05
	+9.000000e+01 5.000000e+00 5.000000e+00 5.740000e-04 6.443134e-06 6.443134e-06
	+1.000000e+02 5.000000e+00 5.000000e+00 4.122000e-04 5.181274e-06 5.181274e-06
	+1.150000e+02 1.000000e+01 1.000000e+01 2.591000e-04 2.908390e-06 2.908390e-06
	+1.375000e+02 1.250000e+01 1.250000e+01 1.337000e-04 1.576300e-06 1.576300e-06
	+1.625000e+02 1.250000e+01 1.250000e+01 6.769000e-05 9.948358e-07 9.948358e-07
	+1.875000e+02 1.250000e+01 1.250000e+01 3.840000e-05 7.316183e-07 7.316183e-07
	+2.250000e+02 2.500000e+01 2.500000e+01 1.753000e-05 3.588302e-07 3.588302e-07
	+2.750000e+02 2.500000e+01 2.500000e+01 6.578000e-06 2.052926e-07 2.052926e-07
	+3.250000e+02 2.500000e+01 2.500000e+01 2.813000e-06 1.263347e-07 1.263347e-07
	+3.750000e+02 2.500000e+01 2.500000e+01 1.194000e-06 6.726789e-08 6.726789e-08
	+4.350000e+02 3.500000e+01 3.500000e+01 5.587000e-07 4.441929e-08 4.441929e-08
	+5.100000e+02 4.000000e+01 4.000000e+01 1.882000e-07 2.024616e-08 2.024616e-08
	+6.000000e+02 5.000000e+01 5.000000e+01 6.450000e-08 1.033631e-08 1.033631e-08
	+7.750000e+02 1.250000e+02 1.250000e+02 1.500000e-08 3.016045e-09 3.016045e-09
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d28-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d28-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.181000e-02 1.195578e-03 1.195578e-03
	+3.000000e+00 1.000000e+00 1.000000e+00 4.492000e-02 1.243238e-03 1.243238e-03
	+5.000000e+00 1.000000e+00 1.000000e+00 4.604000e-02 1.162909e-03 1.162909e-03
	+7.000000e+00 1.000000e+00 1.000000e+00 4.296000e-02 1.061903e-03 1.061903e-03
	+9.000000e+00 1.000000e+00 1.000000e+00 3.850000e-02 1.045188e-03 1.045188e-03
	+1.150000e+01 1.500000e+00 1.500000e+00 3.035000e-02 7.346957e-04 7.346957e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.439000e-02 6.728281e-04 6.728281e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.889000e-02 4.915031e-04 4.915031e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.479000e-02 3.655853e-04 3.655853e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 1.076000e-02 3.144425e-04 3.144425e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 7.884000e-03 2.403004e-04 2.403004e-04
	+4.100000e+01 4.000000e+00 4.000000e+00 5.685000e-03 1.703604e-04 1.703604e-04
	+5.000000e+01 5.000000e+00 5.000000e+00 4.160000e-03 1.329249e-04 1.329249e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.592000e-03 1.180428e-04 1.180428e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.870000e-03 1.001629e-04 1.001629e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.267000e-03 8.518161e-05 8.518161e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 8.973000e-04 4.598170e-05 4.598170e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 3.827000e-04 1.802350e-05 1.802350e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 1.226000e-04 8.056229e-06 8.056229e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 4.541000e-06 3.651201e-07 3.651201e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d29-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d29-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.107000e+00 9.495431e-02 9.495431e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 6.445000e+00 1.909722e-01 1.909722e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 6.534000e+00 1.936094e-01 1.936094e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 5.804000e+00 1.709965e-01 1.709965e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 4.891000e+00 1.455021e-01 1.455021e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.903000e+00 1.145250e-01 1.145250e-01
	+1.450000e+01 1.500000e+00 1.500000e+00 3.002000e+00 8.930635e-02 8.930635e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.276000e+00 6.770861e-02 6.770861e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.633000e+00 4.858003e-02 4.858003e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.163000e+00 3.496745e-02 3.496745e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 8.137000e-01 2.474772e-02 2.474772e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 5.484000e-01 1.700924e-02 1.700924e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 3.590000e-01 1.143177e-02 1.143177e-02
	+6.000000e+01 5.000000e+00 5.000000e+00 2.282000e-01 7.433157e-03 7.433157e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.512000e-01 4.989600e-03 4.989600e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 1.008000e-01 3.321815e-03 3.321815e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 5.874000e-02 1.887922e-03 1.887922e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.247000e-02 7.193910e-04 7.193910e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 6.375000e-03 2.171247e-04 2.171247e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 2.712000e-04 1.031273e-05 1.031273e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d30-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d30-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.055000e+00 1.006297e-01 1.006297e-01
	+3.000000e+00 1.000000e+00 1.000000e+00 6.424000e+00 1.977924e-01 1.977924e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 6.556000e+00 1.971166e-01 1.971166e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 5.725000e+00 1.721312e-01 1.721312e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 4.798000e+00 1.434594e-01 1.434594e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.880000e+00 1.154259e-01 1.154259e-01
	+1.450000e+01 1.500000e+00 1.500000e+00 2.993000e+00 8.903861e-02 8.903861e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.270000e+00 6.753012e-02 6.753012e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.621000e+00 4.822305e-02 4.822305e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.155000e+00 3.489935e-02 3.489935e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 7.945000e-01 2.416377e-02 2.416377e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 5.433000e-01 1.706861e-02 1.706861e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 3.516000e-01 1.119613e-02 1.119613e-02
	+6.000000e+01 5.000000e+00 5.000000e+00 2.250000e-01 7.373686e-03 7.373686e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.506000e-01 5.084841e-03 5.084841e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 1.003000e-01 3.439573e-03 3.439573e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 5.633000e-02 1.873343e-03 1.873343e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.179000e-02 7.150972e-04 7.150972e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.974000e-03 2.154785e-04 2.154785e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 2.487000e-04 9.929330e-06 9.929330e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d31-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d31-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.990000e+00 9.707144e-02 9.707144e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 6.267000e+00 1.929585e-01 1.929585e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 6.341000e+00 1.928540e-01 1.928540e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 5.539000e+00 1.665389e-01 1.665389e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 4.674000e+00 1.432259e-01 1.432259e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.725000e+00 1.119981e-01 1.119981e-01
	+1.450000e+01 1.500000e+00 1.500000e+00 2.890000e+00 8.732392e-02 8.732392e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.172000e+00 6.530464e-02 6.530464e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.541000e+00 4.633262e-02 4.633262e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.113000e+00 3.410578e-02 3.410578e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 7.749000e-01 2.397185e-02 2.397185e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 5.164000e-01 1.644391e-02 1.644391e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 3.355000e-01 1.092824e-02 1.092824e-02
	+6.000000e+01 5.000000e+00 5.000000e+00 2.155000e-01 7.192666e-03 7.192666e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.403000e-01 4.817421e-03 4.817421e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 9.251000e-02 3.244451e-03 3.244451e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 5.435000e-02 1.806678e-03 1.806678e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.047000e-02 6.720897e-04 6.720897e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.818000e-03 2.159724e-04 2.159724e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 2.301000e-04 9.264204e-06 9.264204e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d32-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d32-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.459000e+00 7.670346e-02 7.670346e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 5.143000e+00 1.546325e-01 1.546325e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 5.173000e+00 1.510835e-01 1.510835e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 4.571000e+00 1.353664e-01 1.353664e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 3.898000e+00 1.154361e-01 1.154361e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.156000e+00 9.217465e-02 9.217465e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 2.448000e+00 7.270189e-02 7.270189e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 1.861000e+00 5.579897e-02 5.579897e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.323000e+00 3.966794e-02 3.966794e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 9.516000e-01 2.933028e-02 2.933028e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 6.598000e-01 2.033640e-02 2.033640e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 4.387000e-01 1.385903e-02 1.385903e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 2.850000e-01 9.309515e-03 9.309515e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.846000e-01 6.139164e-03 6.139164e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.227000e-01 4.209522e-03 4.209522e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 8.297000e-02 2.877756e-03 2.877756e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 4.726000e-02 1.585853e-03 1.585853e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 1.839000e-02 6.146223e-04 6.146223e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 4.976000e-03 1.986664e-04 1.986664e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 1.978000e-04 1.028180e-05 1.028180e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d33-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d33-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.573000e+00 5.362061e-02 5.362061e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 3.302000e+00 1.037375e-01 1.037375e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 3.315000e+00 9.845048e-02 9.845048e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 2.878000e+00 8.772000e-02 8.772000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 2.456000e+00 7.437261e-02 7.437261e-02
	+1.150000e+01 1.500000e+00 1.500000e+00 2.010000e+00 5.955844e-02 5.955844e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 1.584000e+00 4.767814e-02 4.767814e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 1.191000e+00 3.559078e-02 3.559078e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 8.876000e-01 2.677552e-02 2.677552e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 6.461000e-01 2.015376e-02 2.015376e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 4.542000e-01 1.431271e-02 1.431271e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 3.054000e-01 9.943104e-03 9.943104e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 1.989000e-01 6.780127e-03 6.780127e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.267000e-01 4.515215e-03 4.515215e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 8.266000e-02 3.125816e-03 3.125816e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 5.653000e-02 2.210460e-03 2.210460e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 3.254000e-02 1.154138e-03 1.154138e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 1.266000e-02 4.467025e-04 4.467025e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 3.651000e-03 1.526886e-04 1.526886e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 1.271000e-04 7.114195e-06 7.114195e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d34-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d34-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 5.365000e-01 2.122398e-02 2.122398e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 1.085000e+00 3.631105e-02 3.631105e-02
	+5.000000e+00 1.000000e+00 1.000000e+00 1.096000e+00 3.455443e-02 3.455443e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 9.443000e-01 3.002518e-02 3.002518e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 8.161000e-01 2.606414e-02 2.606414e-02
	+1.150000e+01 1.500000e+00 1.500000e+00 6.474000e-01 1.999617e-02 1.999617e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 5.024000e-01 1.631060e-02 1.631060e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 4.021000e-01 1.272187e-02 1.272187e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 2.924000e-01 9.662482e-03 9.662482e-03
	+2.750000e+01 2.500000e+00 2.500000e+00 2.160000e-01 7.340823e-03 7.340823e-03
	+3.350000e+01 3.500000e+00 3.500000e+00 1.540000e-01 5.294555e-03 5.294555e-03
	+4.100000e+01 4.000000e+00 4.000000e+00 1.101000e-01 3.780456e-03 3.780456e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 7.374000e-02 2.675045e-03 2.675045e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 4.985000e-02 1.877830e-03 1.877830e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 3.186000e-02 1.327840e-03 1.327840e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 2.038000e-02 8.941689e-04 8.941689e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 1.133000e-02 4.599478e-04 4.599478e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 4.185000e-03 1.689621e-04 1.689621e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 1.225000e-03 6.904698e-05 6.904698e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 3.746000e-05 2.798741e-06 2.798741e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d35-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d35-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 3.802000e-02 3.742605e-03 3.742605e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.987000e-02 3.220562e-03 3.220562e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 2.133000e-02 3.104010e-03 3.104010e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 1.417000e-02 1.798920e-03 1.798920e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 8.699000e-03 1.034157e-03 1.034157e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.958000e-03 2.934539e-04 2.934539e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 7.673000e-04 8.181735e-05 8.181735e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.640000e-05 3.725488e-06 3.725488e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d36-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d36-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.833000e-02 2.470240e-03 2.470240e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.128000e-02 1.763289e-03 1.763289e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.473000e-02 1.147995e-03 1.147995e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 1.071000e-02 7.892042e-04 7.892042e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 6.141000e-03 3.895544e-04 3.895544e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.286000e-03 1.245608e-04 1.245608e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 6.048000e-04 4.456683e-05 4.456683e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.278000e-05 2.029083e-06 2.029083e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d37-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d37-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.880000e-02 2.123402e-03 2.123402e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.173000e-02 1.444677e-03 1.444677e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.531000e-02 1.008370e-03 1.008370e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 9.516000e-03 6.827689e-04 6.827689e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.847000e-03 3.461602e-04 3.461602e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.133000e-03 1.245752e-04 1.245752e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.515000e-04 4.174677e-05 4.174677e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.175000e-05 2.707591e-06 2.707591e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d38-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d38-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 6.376000e-01 5.090029e-02 5.090029e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 1.216000e+00 7.099816e-02 7.099816e-02
	+5.000000e+00 1.000000e+00 1.000000e+00 1.095000e+00 6.206825e-02 6.206825e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 8.887000e-01 4.979100e-02 4.979100e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 6.757000e-01 3.765171e-02 3.765171e-02
	+1.150000e+01 1.500000e+00 1.500000e+00 5.185000e-01 2.775792e-02 2.775792e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 3.756000e-01 2.035877e-02 2.035877e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.796000e-01 1.492917e-02 1.492917e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 2.057000e-01 1.057906e-02 1.057906e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.297000e-01 6.908275e-03 6.908275e-03
	+3.350000e+01 3.500000e+00 3.500000e+00 7.556000e-02 4.071836e-03 4.071836e-03
	+4.100000e+01 4.000000e+00 4.000000e+00 4.588000e-02 2.541686e-03 2.541686e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 3.141000e-02 1.643557e-03 1.643557e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.989000e-02 1.050222e-03 1.050222e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.384000e-02 8.012870e-04 8.012870e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.003000e-02 6.463711e-04 6.463711e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.797000e-03 3.242695e-04 3.242695e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.099000e-03 1.254844e-04 1.254844e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.754000e-04 4.343031e-05 4.343031e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.098000e-05 2.087589e-06 2.087589e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d39-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d39-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.375000e+01 4.211183e-01 4.211183e-01
	+3.000000e+00 1.000000e+00 1.000000e+00 2.868000e+01 8.459385e-01 8.459385e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 2.902000e+01 8.475629e-01 8.475629e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 2.547000e+01 7.438810e-01 7.438810e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 2.153000e+01 6.288087e-01 6.288087e-01
	+1.100000e+01 1.000000e+00 1.000000e+00 1.808000e+01 5.280474e-01 5.280474e-01
	+1.300000e+01 1.000000e+00 1.000000e+00 1.519000e+01 4.436416e-01 4.436416e-01
	+1.500000e+01 1.000000e+00 1.000000e+00 1.282000e+01 3.755188e-01 3.755188e-01
	+1.700000e+01 1.000000e+00 1.000000e+00 1.094000e+01 3.210102e-01 3.210102e-01
	+1.900000e+01 1.000000e+00 1.000000e+00 9.396000e+00 2.757050e-01 2.757050e-01
	+2.125000e+01 1.250000e+00 1.250000e+00 7.960000e+00 2.358633e-01 2.358633e-01
	+2.375000e+01 1.250000e+00 1.250000e+00 6.637000e+00 1.987779e-01 1.987779e-01
	+2.625000e+01 1.250000e+00 1.250000e+00 5.654000e+00 1.682006e-01 1.682006e-01
	+2.875000e+01 1.250000e+00 1.250000e+00 4.836000e+00 1.470812e-01 1.470812e-01
	+3.150000e+01 1.500000e+00 1.500000e+00 4.048000e+00 1.231151e-01 1.231151e-01
	+3.450000e+01 1.500000e+00 1.500000e+00 3.457000e+00 1.064397e-01 1.064397e-01
	+3.750000e+01 1.500000e+00 1.500000e+00 2.919000e+00 9.128586e-02 9.128586e-02
	+4.050000e+01 1.500000e+00 1.500000e+00 2.502000e+00 7.860422e-02 7.860422e-02
	+4.350000e+01 1.500000e+00 1.500000e+00 2.154000e+00 6.882696e-02 6.882696e-02
	+4.650000e+01 1.500000e+00 1.500000e+00 1.875000e+00 6.023392e-02 6.023392e-02
	+4.950000e+01 1.500000e+00 1.500000e+00 1.613000e+00 5.181723e-02 5.181723e-02
	+5.250000e+01 1.500000e+00 1.500000e+00 1.427000e+00 4.667839e-02 4.667839e-02
	+5.550000e+01 1.500000e+00 1.500000e+00 1.243000e+00 4.090584e-02 4.090584e-02
	+5.900000e+01 2.000000e+00 2.000000e+00 1.060000e+00 3.467351e-02 3.467351e-02
	+6.300000e+01 2.000000e+00 2.000000e+00 8.972000e-01 2.994552e-02 2.994552e-02
	+6.750000e+01 2.500000e+00 2.500000e+00 7.591000e-01 2.518794e-02 2.518794e-02
	+7.250000e+01 2.500000e+00 2.500000e+00 6.000000e-01 2.032043e-02 2.032043e-02
	+7.750000e+01 2.500000e+00 2.500000e+00 4.979000e-01 1.672974e-02 1.672974e-02
	+8.250000e+01 2.500000e+00 2.500000e+00 4.092000e-01 1.391882e-02 1.391882e-02
	+9.000000e+01 5.000000e+00 5.000000e+00 3.027000e-01 9.859846e-03 9.859846e-03
	+1.000000e+02 5.000000e+00 5.000000e+00 2.173000e-01 7.024540e-03 7.024540e-03
	+1.150000e+02 1.000000e+01 1.000000e+01 1.366000e-01 4.330457e-03 4.330457e-03
	+1.375000e+02 1.250000e+01 1.250000e+01 7.046000e-02 2.248105e-03 2.248105e-03
	+1.625000e+02 1.250000e+01 1.250000e+01 3.569000e-02 1.186391e-03 1.186391e-03
	+1.875000e+02 1.250000e+01 1.250000e+01 2.024000e-02 7.109975e-04 7.109975e-04
	+2.250000e+02 2.500000e+01 2.500000e+01 9.242000e-03 3.334813e-04 3.334813e-04
	+2.750000e+02 2.500000e+01 2.500000e+01 3.468000e-03 1.472573e-04 1.472573e-04
	+3.250000e+02 2.500000e+01 2.500000e+01 1.483000e-03 7.962757e-05 7.962757e-05
	+3.750000e+02 2.500000e+01 2.500000e+01 6.297000e-04 4.007386e-05 4.007386e-05
	+4.350000e+02 3.500000e+01 3.500000e+01 2.945000e-04 2.482375e-05 2.482375e-05
	+5.100000e+02 4.000000e+01 4.000000e+01 9.920000e-05 1.105090e-05 1.105090e-05
	+6.000000e+02 5.000000e+01 5.000000e+01 3.401000e-05 5.540813e-06 5.540813e-06
	+7.750000e+02 1.250000e+02 1.250000e+02 7.920000e-06 1.607838e-06 1.607838e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d40-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d40-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.199000e-01 8.093916e-03 8.093916e-03
	+3.000000e+00 1.000000e+00 1.000000e+00 2.471000e-01 1.048939e-02 1.048939e-02
	+5.000000e+00 1.000000e+00 1.000000e+00 2.532000e-01 9.747378e-03 9.747378e-03
	+7.000000e+00 1.000000e+00 1.000000e+00 2.363000e-01 9.001138e-03 9.001138e-03
	+9.000000e+00 1.000000e+00 1.000000e+00 2.118000e-01 8.477293e-03 8.477293e-03
	+1.150000e+01 1.500000e+00 1.500000e+00 1.669000e-01 6.275973e-03 6.275973e-03
	+1.450000e+01 1.500000e+00 1.500000e+00 1.341000e-01 5.352253e-03 5.352253e-03
	+1.800000e+01 2.000000e+00 2.000000e+00 1.039000e-01 4.120785e-03 4.120785e-03
	+2.250000e+01 2.500000e+00 2.500000e+00 8.132000e-02 3.066530e-03 3.066530e-03
	+2.750000e+01 2.500000e+00 2.500000e+00 5.917000e-02 2.480910e-03 2.480910e-03
	+3.350000e+01 3.500000e+00 3.500000e+00 4.336000e-02 1.894490e-03 1.894490e-03
	+4.100000e+01 4.000000e+00 4.000000e+00 3.127000e-02 1.366252e-03 1.366252e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 2.288000e-02 1.015522e-03 1.015522e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.425000e-02 7.611421e-04 7.611421e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.029000e-02 6.508781e-04 6.508781e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 6.970000e-03 5.160154e-04 5.160154e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 4.935000e-03 2.956885e-04 2.956885e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.105000e-03 1.172203e-04 1.172203e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 6.743000e-04 4.887163e-05 4.887163e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.498000e-05 2.114613e-06 2.114613e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516/d41-x01-y01
	+Path=/REF/ATLAS_2015_I1408516/d41-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.600000e+01 4.000000e+00 4.000000e+00 1.420000e+00 9.939047e-02 9.939047e-02
	+2.500000e+01 5.000000e+00 5.000000e+00 1.040000e+00 6.103746e-02 6.103746e-02
	+3.800000e+01 8.000000e+00 8.000000e+00 1.030000e+00 5.294491e-02 5.294491e-02
	+5.600000e+01 1.000000e+01 1.000000e+01 1.645000e+01 8.898644e-01 8.898644e-01
	+9.100000e+01 2.500000e+01 2.500000e+01 5.276200e+02 1.544053e+01 1.544053e+01
	+1.330000e+02 1.700000e+01 1.700000e+01 5.500000e+00 1.734045e-01 1.734045e-01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2015_I1408516_EL.yoda b/data/refdata/ATLAS_2015_I1408516_EL.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1408516_EL.yoda
	@@ -0,0 +1,1293 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d01-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.600000e+01 4.000000e+00 4.000000e+00 1.420000e+00 9.221585e-02 9.221585e-02
	+2.500000e+01 5.000000e+00 5.000000e+00 1.040000e+00 5.568129e-02 5.568129e-02
	+3.800000e+01 8.000000e+00 8.000000e+00 1.010000e+00 4.843000e-02 4.843000e-02
	+5.600000e+01 1.000000e+01 1.000000e+01 1.516000e+01 7.168099e-01 7.168099e-01
	+9.100000e+01 2.500000e+01 2.500000e+01 5.376400e+02 4.628703e+00 4.628703e+00
	+1.330000e+02 1.700000e+01 1.700000e+01 5.720000e+00 8.399251e-02 8.399251e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d02-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.778000e+00 4.360104e-01 4.360104e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 6.662000e+00 2.248363e-01 2.248363e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.781000e+00 1.959463e-01 1.959463e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.561000e+00 1.773898e-01 1.773898e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.540000e+00 1.742637e-01 1.742637e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.327000e+00 1.710632e-01 1.710632e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.102000e+00 1.477138e-01 1.477138e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 5.682000e+00 1.405649e-01 1.405649e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 5.868000e+00 1.471687e-01 1.471687e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.263000e+00 1.211634e-01 1.211634e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.032000e+00 1.170413e-01 1.170413e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 4.796000e+00 1.159006e-01 1.159006e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.443000e+00 1.045758e-01 1.045758e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.113000e+00 9.196948e-02 9.196948e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.766000e+00 8.404173e-02 8.404173e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.400000e+00 8.628233e-02 8.628233e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.231000e+00 7.318055e-02 7.318055e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.833000e+00 6.416604e-02 6.416604e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.555000e+00 5.701716e-02 5.701716e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.206000e+00 4.726197e-02 4.726197e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.830000e+00 3.920644e-02 3.920644e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.545000e+00 3.363703e-02 3.363703e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.235000e+00 2.979398e-02 2.979398e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 1.008000e+00 2.147773e-02 2.147773e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.670000e-01 1.634268e-02 1.634268e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.450000e-01 1.180274e-02 1.180274e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 3.370000e-01 7.329266e-03 7.329266e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 2.010000e-01 5.642339e-03 5.642339e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.050000e-01 3.236317e-03 3.236317e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 6.470000e-02 2.550526e-03 2.550526e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 3.420000e-02 1.901409e-03 1.901409e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.840000e-02 1.102926e-03 1.102926e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 9.070000e-03 7.019735e-04 7.019735e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 4.540000e-03 4.235117e-04 4.235117e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 2.520000e-03 2.008584e-04 2.008584e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 5.250000e-04 5.269128e-05 5.269128e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d03-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 7.182000e+00 4.344368e-01 4.344368e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 7.048000e+00 2.657760e-01 2.657760e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.842000e+00 2.254748e-01 2.254748e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.408000e+00 1.996789e-01 1.996789e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.302000e+00 2.038188e-01 2.038188e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.328000e+00 1.971860e-01 1.971860e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.279000e+00 1.705763e-01 1.705763e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 6.047000e+00 1.644962e-01 1.644962e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 5.803000e+00 1.758223e-01 1.758223e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.295000e+00 1.393903e-01 1.393903e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.149000e+00 1.416677e-01 1.416677e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 4.906000e+00 1.364891e-01 1.364891e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.396000e+00 1.168046e-01 1.168046e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.289000e+00 1.142839e-01 1.142839e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 3.884000e+00 1.008345e-01 1.008345e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.645000e+00 9.141613e-02 9.141613e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.172000e+00 8.142840e-02 8.142840e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.869000e+00 7.365009e-02 7.365009e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.520000e+00 6.633873e-02 6.633873e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.092000e+00 5.246709e-02 5.246709e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.806000e+00 4.688649e-02 4.688649e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.462000e+00 3.753100e-02 3.753100e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.216000e+00 3.109728e-02 3.109728e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 9.890000e-01 2.446651e-02 2.446651e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.380000e-01 1.812237e-02 1.812237e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.540000e-01 1.385000e-02 1.385000e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 3.250000e-01 8.437491e-03 8.437491e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.970000e-01 6.551546e-03 6.551546e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.020000e-01 3.984533e-03 3.984533e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 6.050000e-02 2.899585e-03 2.899585e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 3.520000e-02 2.110826e-03 2.110826e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.740000e-02 1.250139e-03 1.250139e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 9.500000e-03 7.753420e-04 7.753420e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 5.670000e-03 7.519968e-04 7.519968e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 2.080000e-03 1.977094e-04 1.977094e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 6.030000e-04 5.804482e-05 5.804482e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d04-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.724000e+00 3.837985e-01 3.837985e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 6.620000e+00 3.000255e-01 3.000255e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.546000e+00 2.749320e-01 2.749320e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.493000e+00 2.714664e-01 2.714664e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.632000e+00 2.906753e-01 2.906753e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.727000e+00 2.692481e-01 2.692481e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.531000e+00 2.425280e-01 2.425280e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 6.023000e+00 2.295071e-01 2.295071e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 6.204000e+00 2.292963e-01 2.292963e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.461000e+00 2.064374e-01 2.064374e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.384000e+00 2.108714e-01 2.108714e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.016000e+00 1.956240e-01 1.956240e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.760000e+00 1.705648e-01 1.705648e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.364000e+00 1.703638e-01 1.703638e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 3.733000e+00 1.448192e-01 1.448192e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.600000e+00 1.216033e-01 1.216033e-01
	+9.650000e-02 5.500000e-03 5.500000e-03 3.201000e+00 1.126279e-01 1.126279e-01
	+1.080000e-01 6.000000e-03 6.000000e-03 2.927000e+00 1.065846e-01 1.065846e-01
	+1.210000e-01 7.000000e-03 7.000000e-03 2.599000e+00 9.520999e-02 9.520999e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.987000e+00 7.649305e-02 7.649305e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.840000e+00 6.631662e-02 6.631662e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.544000e+00 5.588342e-02 5.588342e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.302000e+00 4.871638e-02 4.871638e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 1.000000e+00 3.432200e-02 3.432200e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.280000e-01 2.646958e-02 2.646958e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.380000e-01 1.763130e-02 1.763130e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 3.470000e-01 1.110942e-02 1.110942e-02
	+6.095000e-01 8.550000e-02 8.550000e-02 1.910000e-01 9.116124e-03 9.116124e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.030000e-01 5.190015e-03 5.190015e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 5.430000e-02 4.072138e-03 4.072138e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 2.850000e-02 2.309204e-03 2.309204e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.520000e-02 1.297086e-03 1.297086e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 6.280000e-03 6.860451e-04 6.860451e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 2.740000e-03 3.974889e-04 3.974889e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 1.150000e-03 1.592034e-04 1.592034e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 2.130000e-04 3.964147e-05 3.964147e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d05-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.252000e+00 4.239799e-02 4.239799e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.264000e+00 3.930382e-02 3.930382e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.001000e+00 3.818801e-02 3.818801e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.810000e+00 3.737766e-02 3.737766e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.627000e+00 3.660126e-02 3.660126e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.112000e+00 3.441630e-02 3.441630e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.778000e+00 3.299926e-02 3.299926e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.344000e+00 3.115795e-02 3.115795e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.884000e+00 2.920634e-02 2.920634e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.367000e+00 2.701289e-02 2.701289e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.865000e+00 2.488309e-02 2.488309e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.438000e+00 2.307148e-02 2.307148e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.954000e+00 2.101804e-02 2.101804e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.522000e+00 1.918522e-02 1.918522e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.021000e+00 1.705966e-02 1.705966e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.572000e+00 1.515471e-02 1.515471e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.145000e+00 1.334310e-02 1.334310e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.764000e+00 1.172666e-02 1.172666e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.394000e+00 1.015688e-02 1.015688e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.023000e+00 8.582862e-03 8.582862e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.697000e+00 7.199761e-03 7.199761e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.396000e+00 5.922726e-03 5.922726e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.111000e+00 4.713574e-03 4.713574e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.510000e-01 3.610487e-03 3.610487e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.180000e-01 2.832032e-03 2.832032e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.110000e-01 2.095697e-03 2.095697e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.410000e-01 1.228864e-03 1.228864e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.260000e-01 7.767162e-04 7.767162e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.350000e-02 4.999995e-04 4.999995e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.350000e-02 3.333208e-04 3.333208e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.780000e-02 1.949892e-04 1.949892e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 8.830000e-03 1.147900e-04 1.147900e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.510000e-03 7.915018e-05 7.915018e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 2.390000e-03 4.857054e-05 4.857054e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 1.030000e-03 2.125896e-05 2.125896e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 3.060000e-04 6.944245e-06 6.944245e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d06-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.405000e+00 4.309912e-02 4.309912e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.230000e+00 3.915957e-02 3.915957e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.055000e+00 3.841711e-02 3.841711e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.813000e+00 3.739039e-02 3.739039e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.530000e+00 3.618973e-02 3.618973e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.163000e+00 4.241619e-02 4.241619e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.849000e+00 3.330049e-02 3.330049e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.382000e+00 3.131917e-02 3.131917e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.874000e+00 2.916391e-02 2.916391e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.410000e+00 2.719533e-02 2.719533e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.850000e+00 2.481945e-02 2.481945e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.427000e+00 2.819952e-02 2.819952e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.933000e+00 2.092895e-02 2.092895e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.503000e+00 1.910461e-02 1.910461e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.020000e+00 1.705542e-02 1.705542e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.585000e+00 1.520987e-02 1.520987e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.146000e+00 1.334735e-02 1.334735e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.786000e+00 1.182000e-02 1.182000e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.380000e+00 1.009748e-02 1.009748e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.034000e+00 8.629531e-03 8.629531e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.694000e+00 7.187033e-03 7.187033e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.396000e+00 5.922726e-03 5.922726e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.115000e+00 4.730544e-03 4.730544e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.530000e-01 3.908937e-03 3.908937e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.160000e-01 2.822867e-03 2.822867e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.100000e-01 2.090598e-03 2.090598e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.400000e-01 1.419859e-03 1.419859e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.240000e-01 8.680000e-04 8.680000e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.290000e-02 4.952751e-04 4.952751e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.300000e-02 3.283459e-04 3.283459e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.750000e-02 2.025771e-04 2.025771e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 8.500000e-03 1.211064e-04 1.211064e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.400000e-03 7.721969e-05 7.721969e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 2.290000e-03 4.868607e-05 4.868607e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 9.940000e-04 2.222652e-05 2.222652e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 3.090000e-04 7.113714e-06 7.113714e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d07-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.387000e+00 4.301664e-02 4.301664e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.268000e+00 3.932079e-02 3.932079e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.252000e+00 3.925291e-02 3.925291e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.913000e+00 4.881851e-02 4.881851e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.699000e+00 4.764639e-02 4.764639e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.264000e+00 4.294100e-02 4.294100e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.876000e+00 3.341504e-02 3.341504e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.364000e+00 3.374609e-02 3.374609e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.923000e+00 3.791883e-02 3.791883e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.430000e+00 2.728018e-02 2.728018e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.921000e+00 3.076642e-02 3.076642e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.410000e+00 2.811118e-02 2.811118e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 5.012000e+00 2.604312e-02 2.604312e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.492000e+00 2.334112e-02 2.334112e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.019000e+00 2.088334e-02 2.088334e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.589000e+00 1.864899e-02 1.864899e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.141000e+00 1.632111e-02 1.632111e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.755000e+00 1.431540e-02 1.431540e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.394000e+00 1.243959e-02 1.243959e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.029000e+00 1.054299e-02 1.054299e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.695000e+00 8.807478e-03 8.807478e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.378000e+00 7.160298e-03 7.160298e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.106000e+00 5.746945e-03 5.746945e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.450000e-01 4.390749e-03 4.390749e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.140000e-01 3.363017e-03 3.363017e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.090000e-01 2.419677e-03 2.419677e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.380000e-01 1.408027e-03 1.408027e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.220000e-01 8.965132e-04 8.965132e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.240000e-02 5.107660e-04 5.107660e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.210000e-02 3.486953e-04 3.486953e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.650000e-02 1.993703e-04 1.993703e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 8.010000e-03 1.209483e-04 1.209483e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.120000e-03 7.381587e-05 7.381587e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 2.100000e-03 4.653289e-05 4.653289e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 9.420000e-04 2.168647e-05 2.168647e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.820000e-04 6.849756e-06 6.849756e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d08-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.382000e+00 5.138733e-02 5.138733e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.317000e+00 5.352209e-02 5.352209e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.095000e+00 5.224680e-02 5.224680e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.874000e+00 4.860490e-02 4.860490e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.552000e+00 4.912750e-02 4.912750e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.242000e+00 4.734669e-02 4.734669e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.803000e+00 4.482482e-02 4.482482e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.312000e+00 4.004947e-02 4.004947e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.920000e+00 3.975237e-02 3.975237e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.397000e+00 3.503781e-02 3.503781e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.877000e+00 3.218965e-02 3.218965e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.366000e+00 2.939079e-02 2.939079e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.985000e+00 2.590282e-02 2.590282e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.526000e+00 2.351779e-02 2.351779e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.049000e+00 2.217729e-02 2.217729e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.593000e+00 1.967967e-02 1.967967e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.196000e+00 1.750521e-02 1.750521e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.756000e+00 1.509523e-02 1.509523e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.403000e+00 1.316177e-02 1.316177e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.065000e+00 1.131047e-02 1.131047e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.715000e+00 9.393442e-03 9.393442e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.404000e+00 7.690025e-03 7.690025e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.117000e+00 6.885650e-03 6.885650e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.510000e-01 5.245916e-03 5.245916e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.210000e-01 3.828101e-03 3.828101e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.150000e-01 2.558232e-03 2.558232e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.380000e-01 1.408027e-03 1.408027e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.240000e-01 1.066688e-03 1.066688e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 6.150000e-02 6.025745e-04 6.025745e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.130000e-02 3.983840e-04 3.983840e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.630000e-02 2.322393e-04 2.322393e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 7.520000e-03 1.295973e-04 1.295973e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 3.560000e-03 7.643644e-05 7.643644e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 1.680000e-03 4.435327e-05 4.435327e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 7.690000e-04 1.957554e-05 1.957554e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.150000e-04 6.238706e-06 6.238706e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d09-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.378000e+00 6.891394e-02 6.891394e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.264000e+00 6.145042e-02 6.145042e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.014000e+00 5.979211e-02 5.979211e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.875000e+00 6.700478e-02 6.700478e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.592000e+00 6.486818e-02 6.486818e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.207000e+00 6.196149e-02 6.196149e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.721000e+00 5.121532e-02 5.121532e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.439000e+00 4.934474e-02 4.934474e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.755000e+00 5.099913e-02 5.099913e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.394000e+00 4.241300e-02 4.241300e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.878000e+00 4.437793e-02 4.437793e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.309000e+00 4.008207e-02 4.008207e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.899000e+00 3.698664e-02 3.698664e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.508000e+00 2.990269e-02 2.990269e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.011000e+00 3.001558e-02 3.001558e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.574000e+00 2.968787e-02 2.968787e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.159000e+00 2.384993e-02 2.384993e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.806000e+00 2.061980e-02 2.061980e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.407000e+00 1.768777e-02 1.768777e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.072000e+00 1.522603e-02 1.522603e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.730000e+00 1.306121e-02 1.306121e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.417000e+00 1.069812e-02 1.069812e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.137000e+00 9.780844e-03 9.780844e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.710000e-01 7.492625e-03 7.492625e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.430000e-01 5.341159e-03 5.341159e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.280000e-01 3.681795e-03 3.681795e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.440000e-01 2.222946e-03 2.222946e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.250000e-01 1.346291e-03 1.346291e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 6.210000e-02 7.976889e-04 7.976889e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.050000e-02 5.011661e-04 5.011661e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.480000e-02 2.792458e-04 2.792458e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 6.430000e-03 1.544539e-04 1.544539e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 2.740000e-03 8.621209e-05 8.621209e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 1.310000e-03 5.054971e-05 5.054971e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 5.100000e-04 2.140178e-05 2.140178e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 1.410000e-04 6.327743e-06 6.327743e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d10-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.324000e+00 1.042455e-01 1.042455e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 9.101000e+00 1.017523e-01 1.017523e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 9.083000e+00 1.015510e-01 1.015510e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 8.825000e+00 9.866650e-02 9.866650e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.401000e+00 9.392604e-02 9.392604e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.047000e+00 1.001843e-01 1.001843e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 7.986000e+00 9.244463e-02 9.244463e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.168000e+00 8.297560e-02 8.297560e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.833000e+00 7.909769e-02 7.909769e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.468000e+00 7.231444e-02 7.231444e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.717000e+00 6.262660e-02 6.262660e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.413000e+00 6.427581e-02 6.427581e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.935000e+00 5.406022e-02 5.406022e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.502000e+00 4.931694e-02 4.931694e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.994000e+00 4.536312e-02 4.536312e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.517000e+00 3.947823e-02 3.947823e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.161000e+00 3.699856e-02 3.699856e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.793000e+00 3.543920e-02 3.543920e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.404000e+00 3.021781e-02 3.021781e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.036000e+00 2.383077e-02 2.383077e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.743000e+00 2.062345e-02 2.062345e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.447000e+00 1.712113e-02 1.712113e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.175000e+00 1.287148e-02 1.287148e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 8.940000e-01 1.034880e-02 1.034880e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 6.560000e-01 8.087711e-03 8.087711e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.380000e-01 5.908943e-03 5.908943e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.550000e-01 3.542573e-03 3.542573e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.310000e-01 2.003915e-03 2.003915e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 6.120000e-02 1.216326e-03 1.216326e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.920000e-02 7.586383e-04 7.586383e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.320000e-02 4.151185e-04 4.151185e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 4.920000e-03 2.155836e-04 2.155836e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 1.910000e-03 1.172746e-04 1.172746e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 5.830000e-04 5.450037e-05 5.450037e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 1.390000e-04 1.754761e-05 1.754761e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.470000e-05 5.084362e-06 5.084362e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d11-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d11-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.148900e+01 4.668268e-01 4.668268e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.137500e+01 3.500470e-01 3.500470e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.105100e+01 3.267061e-01 3.267061e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.080400e+01 3.280575e-01 3.280575e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 1.003800e+01 3.006377e-01 3.006377e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.378000e+00 2.896573e-01 2.896573e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 9.075000e+00 2.589160e-01 2.589160e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 8.348000e+00 2.381742e-01 2.381742e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 6.798000e+00 2.245399e-01 2.245399e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.684000e+00 2.020736e-01 2.020736e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 6.001000e+00 1.853522e-01 1.853522e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.433000e+00 1.820663e-01 1.820663e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 5.175000e+00 1.612575e-01 1.612575e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.099000e+00 1.353912e-01 1.353912e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 4.003000e+00 1.274061e-01 1.274061e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.423000e+00 1.147088e-01 1.147088e-01
	+9.650000e-02 5.500000e-03 5.500000e-03 2.992000e+00 1.002655e-01 1.002655e-01
	+1.080000e-01 6.000000e-03 6.000000e-03 2.495000e+00 1.179267e-01 1.179267e-01
	+1.210000e-01 7.000000e-03 7.000000e-03 2.134000e+00 7.450686e-02 7.450686e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.857000e+00 6.774869e-02 6.774869e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.507000e+00 5.293840e-02 5.293840e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.212000e+00 4.960324e-02 4.960324e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.790000e-01 3.720200e-02 3.720200e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.050000e-01 2.851549e-02 2.851549e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.260000e-01 2.496700e-02 2.496700e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.540000e-01 1.683641e-02 1.683641e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 1.990000e-01 1.120425e-02 1.120425e-02
	+6.095000e-01 8.550000e-02 8.550000e-02 1.030000e-01 7.310098e-03 7.310098e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 5.400000e-02 4.195004e-03 4.195004e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.580000e-02 3.192222e-03 3.192222e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 1.800000e-02 1.652082e-03 1.652082e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 8.040000e-03 1.036661e-03 1.036661e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 2.850000e-03 7.139577e-04 7.139577e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 1.360000e-03 3.894447e-04 3.894447e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 8.500000e-04 1.899517e-04 1.899517e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 2.850000e-04 6.775152e-05 6.775152e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d12-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d12-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.097200e+01 4.375064e-01 4.375064e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.198900e+01 3.941811e-01 3.941811e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.062800e+01 3.698483e-01 3.698483e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.071800e+01 3.594926e-01 3.594926e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 9.871000e+00 3.456260e-01 3.456260e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.754000e+00 3.504660e-01 3.504660e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 8.577000e+00 2.857570e-01 2.857570e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 7.516000e+00 3.044676e-01 3.044676e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.643000e+00 2.705449e-01 2.705449e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.365000e+00 2.268299e-01 2.268299e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 6.080000e+00 2.185420e-01 2.185420e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.577000e+00 2.057452e-01 2.057452e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.794000e+00 1.822351e-01 1.822351e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.645000e+00 1.787571e-01 1.787571e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 4.082000e+00 1.486431e-01 1.486431e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.474000e+00 1.294735e-01 1.294735e-01
	+9.650000e-02 5.500000e-03 5.500000e-03 3.205000e+00 1.210710e-01 1.210710e-01
	+1.080000e-01 6.000000e-03 6.000000e-03 2.435000e+00 1.017469e-01 1.017469e-01
	+1.210000e-01 7.000000e-03 7.000000e-03 2.051000e+00 8.528314e-02 8.528314e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.828000e+00 8.088771e-02 8.088771e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.608000e+00 6.791778e-02 6.791778e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.211000e+00 5.259143e-02 5.259143e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.400000e-01 4.274675e-02 4.274675e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.740000e-01 3.470076e-02 3.470076e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.470000e-01 2.742102e-02 2.742102e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.550000e-01 1.845317e-02 1.845317e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 2.120000e-01 1.117182e-02 1.117182e-02
	+6.095000e-01 8.550000e-02 8.550000e-02 1.010000e-01 7.258661e-03 7.258661e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 5.040000e-02 4.329416e-03 4.329416e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.540000e-02 2.901165e-03 2.901165e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 1.140000e-02 3.444611e-03 3.444611e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 5.230000e-03 9.077478e-04 9.077478e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 2.360000e-03 5.490235e-04 5.490235e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 1.470000e-03 3.806392e-04 3.806392e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 6.540000e-04 1.789906e-04 1.789906e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 2.280000e-04 5.534533e-05 5.534533e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d13-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d13-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.189200e+01 6.601935e-01 6.601935e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.164800e+01 7.139568e-01 7.139568e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.145500e+01 6.088416e-01 6.088416e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.117100e+01 6.074600e-01 6.074600e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 9.714000e+00 5.861496e-01 5.861496e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.337000e+00 6.076228e-01 6.076228e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 9.075000e+00 5.342702e-01 5.342702e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 7.757000e+00 4.665821e-01 4.665821e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.263000e+00 4.515928e-01 4.515928e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.336000e+00 3.816881e-01 3.816881e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 6.574000e+00 3.934527e-01 3.934527e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.317000e+00 3.433070e-01 3.433070e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.755000e+00 3.090750e-01 3.090750e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.983000e+00 2.991876e-01 2.991876e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 3.911000e+00 2.533410e-01 2.533410e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.070000e+00 2.120301e-01 2.120301e-01
	+9.650000e-02 5.500000e-03 5.500000e-03 3.005000e+00 2.394402e-01 2.394402e-01
	+1.080000e-01 6.000000e-03 6.000000e-03 2.530000e+00 1.755390e-01 1.755390e-01
	+1.210000e-01 7.000000e-03 7.000000e-03 2.350000e+00 1.581499e-01 1.581499e-01
	+1.365000e-01 8.500000e-03 8.500000e-03 1.975000e+00 1.230379e-01 1.230379e-01
	+1.550000e-01 1.000000e-02 1.000000e-02 1.409000e+00 9.608099e-02 9.608099e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.252000e+00 9.614349e-02 9.614349e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.700000e-01 8.799777e-02 8.799777e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 8.560000e-01 5.917555e-02 5.917555e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.380000e-01 3.772911e-02 3.772911e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.560000e-01 2.752504e-02 2.752504e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 1.940000e-01 1.631908e-02 1.631908e-02
	+6.095000e-01 8.550000e-02 8.550000e-02 7.870000e-02 1.118676e-02 1.118676e-02
	+8.065000e-01 1.115000e-01 1.115000e-01 4.650000e-02 5.862874e-03 5.862874e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.280000e-02 3.976623e-03 3.976623e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 9.700000e-03 2.050374e-03 2.050374e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 4.960000e-03 1.201355e-03 1.201355e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 1.550000e-03 5.501015e-04 5.501015e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 6.780000e-04 3.120752e-04 3.120752e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 9.360000e-05 1.454449e-04 1.454449e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 5.400000e-05 4.329776e-05 4.329776e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d14-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d14-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.941000e+00 3.873302e-01 3.873302e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 6.819000e+00 1.969263e-01 1.969263e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.793000e+00 1.563866e-01 1.563866e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.507000e+00 1.309508e-01 1.309508e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.498000e+00 1.376902e-01 1.376902e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.428000e+00 1.234778e-01 1.234778e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.261000e+00 1.077183e-01 1.077183e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 5.900000e+00 1.038802e-01 1.038802e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 5.934000e+00 1.069767e-01 1.069767e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.324000e+00 8.748225e-02 8.748225e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.159000e+00 8.648060e-02 8.648060e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 4.874000e+00 8.399700e-02 8.399700e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.499000e+00 7.365180e-02 7.365180e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.231000e+00 6.926446e-02 6.926446e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.805000e+00 6.229053e-02 6.229053e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.526000e+00 5.761531e-02 5.761531e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.202000e+00 5.241900e-02 5.241900e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.856000e+00 4.913648e-02 4.913648e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.549000e+00 3.957112e-02 3.957112e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.122000e+00 3.218172e-02 3.218172e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.817000e+00 2.980102e-02 2.980102e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.512000e+00 2.479864e-02 2.479864e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.240000e+00 2.136977e-02 2.136977e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 9.990000e-01 1.638482e-02 1.638482e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.480000e-01 1.168413e-02 1.168413e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.450000e-01 9.328897e-03 9.328897e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 3.330000e-01 5.777334e-03 5.777334e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.970000e-01 4.548098e-03 4.548098e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.030000e-01 2.595518e-03 2.595518e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 6.110000e-02 1.909803e-03 1.909803e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 3.330000e-02 1.351012e-03 1.351012e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.740000e-02 7.754233e-04 7.754233e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 8.630000e-03 4.749637e-04 4.749637e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 4.570000e-03 3.650283e-04 3.650283e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 2.070000e-03 1.226726e-04 1.226726e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 4.860000e-04 3.479231e-05 3.479231e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d15-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d15-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.362000e+00 2.808600e-02 2.808600e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.267000e+00 2.269942e-02 2.269942e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.094000e+00 2.227566e-02 2.227566e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.855000e+00 2.169023e-02 2.169023e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.601000e+00 2.106806e-02 2.106806e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.188000e+00 2.005642e-02 2.005642e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.825000e+00 1.916726e-02 1.916726e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.356000e+00 1.801845e-02 1.801845e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.883000e+00 1.685984e-02 1.685984e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.403000e+00 1.568408e-02 1.568408e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.871000e+00 1.438095e-02 1.438095e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.404000e+00 1.323704e-02 1.323704e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.960000e+00 1.214947e-02 1.214947e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.509000e+00 1.104475e-02 1.104475e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.022000e+00 9.851848e-03 9.851848e-03
	+8.600000e-02 5.000000e-03 5.000000e-03 3.580000e+00 8.769173e-03 8.769173e-03
	+9.650000e-02 5.500000e-03 5.500000e-03 3.155000e+00 7.728140e-03 7.728140e-03
	+1.080000e-01 6.000000e-03 6.000000e-03 2.771000e+00 6.787536e-03 6.787536e-03
	+1.210000e-01 7.000000e-03 7.000000e-03 2.394000e+00 5.864078e-03 5.864078e-03
	+1.365000e-01 8.500000e-03 8.500000e-03 2.039000e+00 4.994510e-03 4.994510e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.704000e+00 4.173931e-03 4.173931e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.398000e+00 3.424387e-03 3.424387e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.117000e+00 2.736080e-03 2.736080e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.540000e-01 2.091864e-03 2.091864e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.210000e-01 2.323569e-03 2.323569e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.140000e-01 1.549046e-03 1.549046e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.410000e-01 9.017394e-04 9.017394e-04
	+6.095000e-01 8.550000e-02 8.550000e-02 1.240000e-01 5.405035e-04 5.405035e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.250000e-02 2.724312e-04 2.724312e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.220000e-02 1.932000e-04 1.932000e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.660000e-02 1.075803e-04 1.075803e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 7.910000e-03 6.377246e-05 6.377246e-05
	+2.234500e+00 2.875000e-01 2.875000e-01 3.920000e-03 3.780311e-05 3.780311e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 1.980000e-03 2.342768e-05 2.342768e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 8.600000e-04 1.081003e-05 1.081003e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.550000e-04 3.411667e-06 3.411667e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d16-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d16-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.137800e+01 3.549134e-01 3.549134e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.162300e+01 2.492856e-01 2.492856e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.095000e+01 2.351065e-01 2.351065e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.081900e+01 2.284833e-01 2.284833e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 9.950000e+00 2.161693e-01 2.161693e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.516000e+00 2.067404e-01 2.067404e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 8.890000e+00 1.826241e-01 1.826241e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 7.962000e+00 1.776793e-01 1.776793e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.172000e+00 1.606912e-01 1.606912e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.523000e+00 1.417158e-01 1.417158e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 6.099000e+00 1.381393e-01 1.381393e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.466000e+00 1.288864e-01 1.288864e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.992000e+00 1.130663e-01 1.130663e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.404000e+00 1.024344e-01 1.024344e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 4.017000e+00 9.098305e-02 9.098305e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.397000e+00 8.010008e-02 8.010008e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.067000e+00 7.980096e-02 7.980096e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.480000e+00 7.599491e-02 7.599491e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.131000e+00 5.280410e-02 5.280410e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.859000e+00 4.621401e-02 4.621401e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.530000e+00 3.791191e-02 3.791191e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.219000e+00 3.273191e-02 3.273191e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.660000e-01 2.801400e-02 2.801400e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.510000e-01 2.109495e-02 2.109495e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.360000e-01 1.821612e-02 1.821612e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.560000e-01 1.191936e-02 1.191936e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 2.040000e-01 7.503762e-03 7.503762e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 9.880000e-02 5.125235e-03 5.125235e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 5.150000e-02 2.929621e-03 2.929621e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.520000e-02 1.887310e-03 1.887310e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 1.440000e-02 1.568278e-03 1.568278e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 6.510000e-03 6.113510e-04 6.113510e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 2.500000e-03 4.135668e-04 4.135668e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 1.320000e-03 2.367662e-04 2.367662e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 6.680000e-04 1.110428e-04 1.110428e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 2.290000e-04 3.869558e-05 3.869558e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d17-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d17-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.622000e-02 2.528565e-04 2.528565e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.438000e-02 2.772847e-04 2.772847e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.513000e-02 2.968841e-04 2.968841e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.896000e-02 2.636577e-04 2.636577e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.127000e-02 2.476200e-04 2.476200e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.293000e-02 1.544554e-04 1.544554e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.532000e-02 1.363524e-04 1.363524e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.920000e-02 1.033952e-04 1.033952e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.377000e-02 6.310207e-05 6.310207e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.812000e-03 5.003158e-05 5.003158e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.865000e-03 3.696916e-05 3.696916e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.627000e-03 3.400137e-05 3.400137e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 3.029000e-03 2.675140e-05 2.675140e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.926000e-03 1.964142e-05 1.964142e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.275000e-03 1.582233e-05 1.582233e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.504000e-04 1.134575e-05 1.134575e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.956000e-04 5.800849e-06 5.800849e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.896000e-04 2.235351e-06 2.235351e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.379000e-05 9.347705e-07 9.347705e-07
	+5.500000e+02 3.500000e+02 3.500000e+02 2.288000e-06 5.395024e-08 5.395024e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d18-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d18-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.601000e-02 3.575784e-04 3.575784e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.469000e-02 4.092625e-04 4.092625e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.582000e-02 3.206615e-04 3.206615e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.875000e-02 3.270249e-04 3.270249e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.085000e-02 2.740301e-04 2.740301e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.303000e-02 1.778720e-04 1.778720e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.548000e-02 1.372140e-04 1.372140e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.933000e-02 1.040952e-04 1.040952e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.380000e-02 7.431527e-05 7.431527e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.832000e-03 6.060852e-05 6.060852e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.765000e-03 3.643064e-05 3.643064e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.625000e-03 3.398667e-05 3.398667e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 2.993000e-03 2.643346e-05 2.643346e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.915000e-03 2.257752e-05 2.257752e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.282000e-03 1.719983e-05 1.719983e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.543000e-04 1.315178e-05 1.315178e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.796000e-04 6.610830e-06 6.610830e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.855000e-04 2.556941e-06 2.556941e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.087000e-05 1.041283e-06 1.041283e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.117000e-06 5.700197e-08 5.700197e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d19-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d19-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.640000e-02 3.178981e-04 3.178981e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.532000e-02 4.139770e-04 4.139770e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.598000e-02 3.014615e-04 3.014615e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.889000e-02 2.933400e-04 2.933400e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.126000e-02 3.169241e-04 3.169241e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.288000e-02 1.972800e-04 1.972800e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.552000e-02 1.711934e-04 1.711934e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.917000e-02 1.032336e-04 1.032336e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.360000e-02 7.323824e-05 7.323824e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.826000e-03 6.057153e-05 6.057153e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.841000e-03 4.589082e-05 4.589082e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.559000e-03 3.675583e-05 3.675583e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 2.962000e-03 3.092419e-05 3.092419e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.903000e-03 2.392034e-05 2.392034e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.238000e-03 1.921893e-05 1.921893e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.166000e-04 1.416748e-05 1.416748e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.798000e-04 7.051591e-06 7.051591e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.807000e-04 2.536245e-06 2.536245e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.136000e-05 1.186849e-06 1.186849e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.031000e-06 5.704905e-08 5.704905e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d20-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d20-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.584000e-02 3.329251e-04 3.329251e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.405000e-02 4.953764e-04 4.953764e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.436000e-02 3.646580e-04 3.646580e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.804000e-02 4.019315e-04 4.019315e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.096000e-02 3.009933e-04 3.009933e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.316000e-02 1.785721e-04 1.785721e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.573000e-02 1.819386e-04 1.819386e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.956000e-02 1.312125e-04 1.312125e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.390000e-02 9.828784e-05 9.828784e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 1.000000e-02 9.000000e-05 9.000000e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.933000e-03 6.239700e-05 6.239700e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.611000e-03 4.814025e-05 4.814025e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 2.995000e-03 3.764657e-05 3.764657e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.940000e-03 2.864376e-05 2.864376e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.290000e-03 2.162434e-05 2.162434e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.719000e-04 1.547469e-05 1.547469e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.966000e-04 7.788867e-06 7.788867e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.933000e-04 3.240298e-06 3.240298e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.229000e-05 1.420518e-06 1.420518e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.078000e-06 9.100596e-08 9.100596e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d21-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d21-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.536000e-02 4.493803e-04 4.493803e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.324000e-02 6.628327e-04 6.628327e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.345000e-02 4.471948e-04 4.471948e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.640000e-02 5.208387e-04 5.208387e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 3.960000e-02 4.134361e-04 4.134361e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.241000e-02 2.711615e-04 2.711615e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.554000e-02 2.476195e-04 2.476195e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.920000e-02 1.728000e-04 1.728000e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.431000e-02 1.197260e-04 1.197260e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 1.042000e-02 1.183484e-04 1.183484e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 7.322000e-03 8.087413e-05 8.087413e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.924000e-03 6.606239e-05 6.606239e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 3.207000e-03 5.327869e-05 5.327869e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 2.042000e-03 3.985825e-05 3.985825e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.333000e-03 3.065900e-05 3.065900e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 9.113000e-04 2.342945e-05 2.342945e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 5.245000e-04 1.014335e-05 1.014335e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 2.042000e-04 3.890533e-06 3.890533e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.886000e-05 1.791124e-06 1.791124e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.048000e-06 9.925936e-08 9.925936e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d22-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d22-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.582000e-02 6.995267e-04 6.995267e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.224000e-02 9.256952e-04 9.256952e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.276000e-02 7.253301e-04 7.253301e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.545000e-02 6.215194e-04 6.215194e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 3.928000e-02 5.637741e-04 5.637741e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.116000e-02 3.765077e-04 3.765077e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.418000e-02 3.594615e-04 3.594615e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.935000e-02 2.385628e-04 2.385628e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.407000e-02 1.989798e-04 1.989798e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 1.040000e-02 1.647670e-04 1.647670e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 7.412000e-03 1.133818e-04 1.133818e-04
	+4.100000e+01 4.000000e+00 4.000000e+00 5.299000e-03 7.983749e-05 7.983749e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 3.549000e-03 6.752433e-05 6.752433e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 2.400000e-03 5.290898e-05 5.290898e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.534000e-03 4.245607e-05 4.245607e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 9.811000e-04 3.046154e-05 3.046154e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 5.455000e-04 1.434986e-05 1.434986e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 2.015000e-04 5.334996e-06 5.334996e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.896000e-05 2.783012e-06 2.783012e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 1.803000e-06 1.224050e-07 1.224050e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d23-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d23-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.720000e-02 8.963628e-04 8.963628e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.137000e-02 6.894930e-04 6.894930e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.526000e-02 7.232017e-04 7.232017e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.014000e-02 4.031846e-04 4.031846e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 6.223000e-03 2.106649e-04 2.106649e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.116000e-03 7.667398e-05 7.667398e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 5.489000e-04 3.381420e-05 3.381420e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 1.888000e-05 2.088097e-06 2.088097e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d24-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d24-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.771000e-02 9.165268e-04 9.165268e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.081000e-02 7.354502e-04 7.354502e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.441000e-02 5.869312e-04 5.869312e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.048000e-02 5.363262e-04 5.363262e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 6.007000e-03 2.850636e-04 2.850636e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.236000e-03 1.143862e-04 1.143862e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.916000e-04 4.379838e-05 4.379838e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.228000e-05 2.066162e-06 2.066162e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d25-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d25-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.853000e-02 8.114767e-04 8.114767e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.153000e-02 7.036062e-04 7.036062e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.517000e-02 5.808347e-04 5.808347e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 9.428000e-03 4.730940e-04 4.730940e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.793000e-03 2.575769e-04 2.575769e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.114000e-03 9.947038e-05 9.947038e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 5.464000e-04 3.754289e-05 3.754289e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.155000e-05 2.373437e-06 2.373437e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d26-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d26-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.886000e-02 1.851466e-03 1.851466e-03
	+3.000000e+00 1.000000e+00 1.000000e+00 7.415000e-02 1.271408e-03 1.271408e-03
	+5.000000e+00 1.000000e+00 1.000000e+00 6.674000e-02 1.046776e-03 1.046776e-03
	+7.000000e+00 1.000000e+00 1.000000e+00 5.417000e-02 8.161533e-04 8.161533e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.119000e-02 7.310500e-04 7.310500e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.160000e-02 5.766459e-04 5.766459e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.289000e-02 4.685466e-04 4.685466e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.705000e-02 3.248461e-04 3.248461e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.254000e-02 2.218552e-04 2.218552e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 7.907000e-03 1.766290e-04 1.766290e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 4.606000e-03 1.168872e-04 1.168872e-04
	+4.100000e+01 4.000000e+00 4.000000e+00 2.797000e-03 8.580000e-05 8.580000e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 1.915000e-03 6.264129e-05 6.264129e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.213000e-03 5.018948e-05 5.018948e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 8.436000e-04 4.249099e-05 4.249099e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 6.112000e-04 3.547067e-05 3.547067e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 3.534000e-04 1.829848e-05 1.829848e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 1.279000e-04 7.283565e-06 7.283565e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 3.507000e-05 2.559870e-06 2.559870e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 1.279000e-06 1.263170e-07 1.263170e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d27-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d27-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.608000e-02 2.487873e-04 2.487873e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.441000e-02 2.980158e-04 2.980158e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.505000e-02 2.059782e-04 2.059782e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.831000e-02 2.213842e-04 2.213842e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.084000e-02 1.871524e-04 1.871524e-04
	+1.100000e+01 1.000000e+00 1.000000e+00 3.429000e-02 1.028700e-04 1.028700e-04
	+1.300000e+01 1.000000e+00 1.000000e+00 2.881000e-02 1.077971e-04 1.077971e-04
	+1.500000e+01 1.000000e+00 1.000000e+00 2.431000e-02 1.059648e-04 1.059648e-04
	+1.700000e+01 1.000000e+00 1.000000e+00 2.076000e-02 7.767681e-05 7.767681e-05
	+1.900000e+01 1.000000e+00 1.000000e+00 1.782000e-02 8.358321e-05 8.358321e-05
	+2.125000e+01 1.250000e+00 1.250000e+00 1.510000e-02 6.581937e-05 6.581937e-05
	+2.375000e+01 1.250000e+00 1.250000e+00 1.259000e-02 6.779922e-05 6.779922e-05
	+2.625000e+01 1.250000e+00 1.250000e+00 1.072000e-02 6.432000e-05 6.432000e-05
	+2.875000e+01 1.250000e+00 1.250000e+00 9.172000e-03 6.152765e-05 6.152765e-05
	+3.150000e+01 1.500000e+00 1.500000e+00 7.677000e-03 4.606200e-05 4.606200e-05
	+3.450000e+01 1.500000e+00 1.500000e+00 6.558000e-03 4.399240e-05 4.399240e-05
	+3.750000e+01 1.500000e+00 1.500000e+00 5.537000e-03 4.143511e-05 4.143511e-05
	+4.050000e+01 1.500000e+00 1.500000e+00 4.745000e-03 3.825541e-05 3.825541e-05
	+4.350000e+01 1.500000e+00 1.500000e+00 4.085000e-03 3.721612e-05 3.721612e-05
	+4.650000e+01 1.500000e+00 1.500000e+00 3.557000e-03 3.448639e-05 3.448639e-05
	+4.950000e+01 1.500000e+00 1.500000e+00 3.060000e-03 2.966780e-05 2.966780e-05
	+5.250000e+01 1.500000e+00 1.500000e+00 2.706000e-03 3.120711e-05 3.120711e-05
	+5.550000e+01 1.500000e+00 1.500000e+00 2.358000e-03 2.849182e-05 2.849182e-05
	+5.900000e+01 2.000000e+00 2.000000e+00 2.011000e-03 2.099546e-05 2.099546e-05
	+6.300000e+01 2.000000e+00 2.000000e+00 1.702000e-03 2.139381e-05 2.139381e-05
	+6.750000e+01 2.500000e+00 2.500000e+00 1.440000e-03 1.733990e-05 1.733990e-05
	+7.250000e+01 2.500000e+00 2.500000e+00 1.138000e-03 1.617402e-05 1.617402e-05
	+7.750000e+01 2.500000e+00 2.500000e+00 9.443000e-04 1.338776e-05 1.338776e-05
	+8.250000e+01 2.500000e+00 2.500000e+00 7.761000e-04 1.227122e-05 1.227122e-05
	+9.000000e+01 5.000000e+00 5.000000e+00 5.740000e-04 6.443134e-06 6.443134e-06
	+1.000000e+02 5.000000e+00 5.000000e+00 4.122000e-04 5.181274e-06 5.181274e-06
	+1.150000e+02 1.000000e+01 1.000000e+01 2.591000e-04 2.908390e-06 2.908390e-06
	+1.375000e+02 1.250000e+01 1.250000e+01 1.337000e-04 1.576300e-06 1.576300e-06
	+1.625000e+02 1.250000e+01 1.250000e+01 6.769000e-05 9.948358e-07 9.948358e-07
	+1.875000e+02 1.250000e+01 1.250000e+01 3.840000e-05 7.316183e-07 7.316183e-07
	+2.250000e+02 2.500000e+01 2.500000e+01 1.753000e-05 3.588302e-07 3.588302e-07
	+2.750000e+02 2.500000e+01 2.500000e+01 6.578000e-06 2.052926e-07 2.052926e-07
	+3.250000e+02 2.500000e+01 2.500000e+01 2.813000e-06 1.263347e-07 1.263347e-07
	+3.750000e+02 2.500000e+01 2.500000e+01 1.194000e-06 6.726789e-08 6.726789e-08
	+4.350000e+02 3.500000e+01 3.500000e+01 5.587000e-07 4.441929e-08 4.441929e-08
	+5.100000e+02 4.000000e+01 4.000000e+01 1.882000e-07 2.024616e-08 2.024616e-08
	+6.000000e+02 5.000000e+01 5.000000e+01 6.450000e-08 1.033631e-08 1.033631e-08
	+7.750000e+02 1.250000e+02 1.250000e+02 1.500000e-08 3.016045e-09 3.016045e-09
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d28-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d28-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.181000e-02 1.195578e-03 1.195578e-03
	+3.000000e+00 1.000000e+00 1.000000e+00 4.492000e-02 1.243238e-03 1.243238e-03
	+5.000000e+00 1.000000e+00 1.000000e+00 4.604000e-02 1.162909e-03 1.162909e-03
	+7.000000e+00 1.000000e+00 1.000000e+00 4.296000e-02 1.061903e-03 1.061903e-03
	+9.000000e+00 1.000000e+00 1.000000e+00 3.850000e-02 1.045188e-03 1.045188e-03
	+1.150000e+01 1.500000e+00 1.500000e+00 3.035000e-02 7.346957e-04 7.346957e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.439000e-02 6.728281e-04 6.728281e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.889000e-02 4.915031e-04 4.915031e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.479000e-02 3.655853e-04 3.655853e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 1.076000e-02 3.144425e-04 3.144425e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 7.884000e-03 2.403004e-04 2.403004e-04
	+4.100000e+01 4.000000e+00 4.000000e+00 5.685000e-03 1.703604e-04 1.703604e-04
	+5.000000e+01 5.000000e+00 5.000000e+00 4.160000e-03 1.329249e-04 1.329249e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.592000e-03 1.180428e-04 1.180428e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.870000e-03 1.001629e-04 1.001629e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.267000e-03 8.518161e-05 8.518161e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 8.973000e-04 4.598170e-05 4.598170e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 3.827000e-04 1.802350e-05 1.802350e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 1.226000e-04 8.056229e-06 8.056229e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 4.541000e-06 3.651201e-07 3.651201e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d29-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d29-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.107000e+00 9.495431e-02 9.495431e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 6.445000e+00 1.909722e-01 1.909722e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 6.534000e+00 1.936094e-01 1.936094e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 5.804000e+00 1.709965e-01 1.709965e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 4.891000e+00 1.455021e-01 1.455021e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.903000e+00 1.145250e-01 1.145250e-01
	+1.450000e+01 1.500000e+00 1.500000e+00 3.002000e+00 8.930635e-02 8.930635e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.276000e+00 6.770861e-02 6.770861e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.633000e+00 4.858003e-02 4.858003e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.163000e+00 3.496745e-02 3.496745e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 8.137000e-01 2.474772e-02 2.474772e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 5.484000e-01 1.700924e-02 1.700924e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 3.590000e-01 1.143177e-02 1.143177e-02
	+6.000000e+01 5.000000e+00 5.000000e+00 2.282000e-01 7.433157e-03 7.433157e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.512000e-01 4.989600e-03 4.989600e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 1.008000e-01 3.321815e-03 3.321815e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 5.874000e-02 1.887922e-03 1.887922e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.247000e-02 7.193910e-04 7.193910e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 6.375000e-03 2.171247e-04 2.171247e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 2.712000e-04 1.031273e-05 1.031273e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d30-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d30-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.055000e+00 1.006297e-01 1.006297e-01
	+3.000000e+00 1.000000e+00 1.000000e+00 6.424000e+00 1.977924e-01 1.977924e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 6.556000e+00 1.971166e-01 1.971166e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 5.725000e+00 1.721312e-01 1.721312e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 4.798000e+00 1.434594e-01 1.434594e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.880000e+00 1.154259e-01 1.154259e-01
	+1.450000e+01 1.500000e+00 1.500000e+00 2.993000e+00 8.903861e-02 8.903861e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.270000e+00 6.753012e-02 6.753012e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.621000e+00 4.822305e-02 4.822305e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.155000e+00 3.489935e-02 3.489935e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 7.945000e-01 2.416377e-02 2.416377e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 5.433000e-01 1.706861e-02 1.706861e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 3.516000e-01 1.119613e-02 1.119613e-02
	+6.000000e+01 5.000000e+00 5.000000e+00 2.250000e-01 7.373686e-03 7.373686e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.506000e-01 5.084841e-03 5.084841e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 1.003000e-01 3.439573e-03 3.439573e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 5.633000e-02 1.873343e-03 1.873343e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.179000e-02 7.150972e-04 7.150972e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.974000e-03 2.154785e-04 2.154785e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 2.487000e-04 9.929330e-06 9.929330e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d31-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d31-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.990000e+00 9.707144e-02 9.707144e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 6.267000e+00 1.929585e-01 1.929585e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 6.341000e+00 1.928540e-01 1.928540e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 5.539000e+00 1.665389e-01 1.665389e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 4.674000e+00 1.432259e-01 1.432259e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.725000e+00 1.119981e-01 1.119981e-01
	+1.450000e+01 1.500000e+00 1.500000e+00 2.890000e+00 8.732392e-02 8.732392e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.172000e+00 6.530464e-02 6.530464e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.541000e+00 4.633262e-02 4.633262e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.113000e+00 3.410578e-02 3.410578e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 7.749000e-01 2.397185e-02 2.397185e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 5.164000e-01 1.644391e-02 1.644391e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 3.355000e-01 1.092824e-02 1.092824e-02
	+6.000000e+01 5.000000e+00 5.000000e+00 2.155000e-01 7.192666e-03 7.192666e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.403000e-01 4.817421e-03 4.817421e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 9.251000e-02 3.244451e-03 3.244451e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 5.435000e-02 1.806678e-03 1.806678e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.047000e-02 6.720897e-04 6.720897e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.818000e-03 2.159724e-04 2.159724e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 2.301000e-04 9.264204e-06 9.264204e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d32-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d32-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.459000e+00 7.670346e-02 7.670346e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 5.143000e+00 1.546325e-01 1.546325e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 5.173000e+00 1.510835e-01 1.510835e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 4.571000e+00 1.353664e-01 1.353664e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 3.898000e+00 1.154361e-01 1.154361e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.156000e+00 9.217465e-02 9.217465e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 2.448000e+00 7.270189e-02 7.270189e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 1.861000e+00 5.579897e-02 5.579897e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.323000e+00 3.966794e-02 3.966794e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 9.516000e-01 2.933028e-02 2.933028e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 6.598000e-01 2.033640e-02 2.033640e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 4.387000e-01 1.385903e-02 1.385903e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 2.850000e-01 9.309515e-03 9.309515e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.846000e-01 6.139164e-03 6.139164e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.227000e-01 4.209522e-03 4.209522e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 8.297000e-02 2.877756e-03 2.877756e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 4.726000e-02 1.585853e-03 1.585853e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 1.839000e-02 6.146223e-04 6.146223e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 4.976000e-03 1.986664e-04 1.986664e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 1.978000e-04 1.028180e-05 1.028180e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d33-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d33-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.573000e+00 5.362061e-02 5.362061e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 3.302000e+00 1.037375e-01 1.037375e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 3.315000e+00 9.845048e-02 9.845048e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 2.878000e+00 8.772000e-02 8.772000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 2.456000e+00 7.437261e-02 7.437261e-02
	+1.150000e+01 1.500000e+00 1.500000e+00 2.010000e+00 5.955844e-02 5.955844e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 1.584000e+00 4.767814e-02 4.767814e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 1.191000e+00 3.559078e-02 3.559078e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 8.876000e-01 2.677552e-02 2.677552e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 6.461000e-01 2.015376e-02 2.015376e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 4.542000e-01 1.431271e-02 1.431271e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 3.054000e-01 9.943104e-03 9.943104e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 1.989000e-01 6.780127e-03 6.780127e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.267000e-01 4.515215e-03 4.515215e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 8.266000e-02 3.125816e-03 3.125816e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 5.653000e-02 2.210460e-03 2.210460e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 3.254000e-02 1.154138e-03 1.154138e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 1.266000e-02 4.467025e-04 4.467025e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 3.651000e-03 1.526886e-04 1.526886e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 1.271000e-04 7.114195e-06 7.114195e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d34-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d34-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 5.365000e-01 2.122398e-02 2.122398e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 1.085000e+00 3.631105e-02 3.631105e-02
	+5.000000e+00 1.000000e+00 1.000000e+00 1.096000e+00 3.455443e-02 3.455443e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 9.443000e-01 3.002518e-02 3.002518e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 8.161000e-01 2.606414e-02 2.606414e-02
	+1.150000e+01 1.500000e+00 1.500000e+00 6.474000e-01 1.999617e-02 1.999617e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 5.024000e-01 1.631060e-02 1.631060e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 4.021000e-01 1.272187e-02 1.272187e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 2.924000e-01 9.662482e-03 9.662482e-03
	+2.750000e+01 2.500000e+00 2.500000e+00 2.160000e-01 7.340823e-03 7.340823e-03
	+3.350000e+01 3.500000e+00 3.500000e+00 1.540000e-01 5.294555e-03 5.294555e-03
	+4.100000e+01 4.000000e+00 4.000000e+00 1.101000e-01 3.780456e-03 3.780456e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 7.374000e-02 2.675045e-03 2.675045e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 4.985000e-02 1.877830e-03 1.877830e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 3.186000e-02 1.327840e-03 1.327840e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 2.038000e-02 8.941689e-04 8.941689e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 1.133000e-02 4.599478e-04 4.599478e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 4.185000e-03 1.689621e-04 1.689621e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 1.225000e-03 6.904698e-05 6.904698e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 3.746000e-05 2.798741e-06 2.798741e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d35-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d35-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 3.802000e-02 3.742605e-03 3.742605e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.987000e-02 3.220562e-03 3.220562e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 2.133000e-02 3.104010e-03 3.104010e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 1.417000e-02 1.798920e-03 1.798920e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 8.699000e-03 1.034157e-03 1.034157e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.958000e-03 2.934539e-04 2.934539e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 7.673000e-04 8.181735e-05 8.181735e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.640000e-05 3.725488e-06 3.725488e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d36-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d36-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.833000e-02 2.470240e-03 2.470240e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.128000e-02 1.763289e-03 1.763289e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.473000e-02 1.147995e-03 1.147995e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 1.071000e-02 7.892042e-04 7.892042e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 6.141000e-03 3.895544e-04 3.895544e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.286000e-03 1.245608e-04 1.245608e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 6.048000e-04 4.456683e-05 4.456683e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.278000e-05 2.029083e-06 2.029083e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d37-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d37-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.880000e-02 2.123402e-03 2.123402e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.173000e-02 1.444677e-03 1.444677e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.531000e-02 1.008370e-03 1.008370e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 9.516000e-03 6.827689e-04 6.827689e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.847000e-03 3.461602e-04 3.461602e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.133000e-03 1.245752e-04 1.245752e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.515000e-04 4.174677e-05 4.174677e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.175000e-05 2.707591e-06 2.707591e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d38-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d38-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 6.376000e-01 5.090029e-02 5.090029e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 1.216000e+00 7.099816e-02 7.099816e-02
	+5.000000e+00 1.000000e+00 1.000000e+00 1.095000e+00 6.206825e-02 6.206825e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 8.887000e-01 4.979100e-02 4.979100e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 6.757000e-01 3.765171e-02 3.765171e-02
	+1.150000e+01 1.500000e+00 1.500000e+00 5.185000e-01 2.775792e-02 2.775792e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 3.756000e-01 2.035877e-02 2.035877e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.796000e-01 1.492917e-02 1.492917e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 2.057000e-01 1.057906e-02 1.057906e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.297000e-01 6.908275e-03 6.908275e-03
	+3.350000e+01 3.500000e+00 3.500000e+00 7.556000e-02 4.071836e-03 4.071836e-03
	+4.100000e+01 4.000000e+00 4.000000e+00 4.588000e-02 2.541686e-03 2.541686e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 3.141000e-02 1.643557e-03 1.643557e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.989000e-02 1.050222e-03 1.050222e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.384000e-02 8.012870e-04 8.012870e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.003000e-02 6.463711e-04 6.463711e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.797000e-03 3.242695e-04 3.242695e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.099000e-03 1.254844e-04 1.254844e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.754000e-04 4.343031e-05 4.343031e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.098000e-05 2.087589e-06 2.087589e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d39-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d39-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.375000e+01 4.211183e-01 4.211183e-01
	+3.000000e+00 1.000000e+00 1.000000e+00 2.868000e+01 8.459385e-01 8.459385e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 2.902000e+01 8.475629e-01 8.475629e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 2.547000e+01 7.438810e-01 7.438810e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 2.153000e+01 6.288087e-01 6.288087e-01
	+1.100000e+01 1.000000e+00 1.000000e+00 1.808000e+01 5.280474e-01 5.280474e-01
	+1.300000e+01 1.000000e+00 1.000000e+00 1.519000e+01 4.436416e-01 4.436416e-01
	+1.500000e+01 1.000000e+00 1.000000e+00 1.282000e+01 3.755188e-01 3.755188e-01
	+1.700000e+01 1.000000e+00 1.000000e+00 1.094000e+01 3.210102e-01 3.210102e-01
	+1.900000e+01 1.000000e+00 1.000000e+00 9.396000e+00 2.757050e-01 2.757050e-01
	+2.125000e+01 1.250000e+00 1.250000e+00 7.960000e+00 2.358633e-01 2.358633e-01
	+2.375000e+01 1.250000e+00 1.250000e+00 6.637000e+00 1.987779e-01 1.987779e-01
	+2.625000e+01 1.250000e+00 1.250000e+00 5.654000e+00 1.682006e-01 1.682006e-01
	+2.875000e+01 1.250000e+00 1.250000e+00 4.836000e+00 1.470812e-01 1.470812e-01
	+3.150000e+01 1.500000e+00 1.500000e+00 4.048000e+00 1.231151e-01 1.231151e-01
	+3.450000e+01 1.500000e+00 1.500000e+00 3.457000e+00 1.064397e-01 1.064397e-01
	+3.750000e+01 1.500000e+00 1.500000e+00 2.919000e+00 9.128586e-02 9.128586e-02
	+4.050000e+01 1.500000e+00 1.500000e+00 2.502000e+00 7.860422e-02 7.860422e-02
	+4.350000e+01 1.500000e+00 1.500000e+00 2.154000e+00 6.882696e-02 6.882696e-02
	+4.650000e+01 1.500000e+00 1.500000e+00 1.875000e+00 6.023392e-02 6.023392e-02
	+4.950000e+01 1.500000e+00 1.500000e+00 1.613000e+00 5.181723e-02 5.181723e-02
	+5.250000e+01 1.500000e+00 1.500000e+00 1.427000e+00 4.667839e-02 4.667839e-02
	+5.550000e+01 1.500000e+00 1.500000e+00 1.243000e+00 4.090584e-02 4.090584e-02
	+5.900000e+01 2.000000e+00 2.000000e+00 1.060000e+00 3.467351e-02 3.467351e-02
	+6.300000e+01 2.000000e+00 2.000000e+00 8.972000e-01 2.994552e-02 2.994552e-02
	+6.750000e+01 2.500000e+00 2.500000e+00 7.591000e-01 2.518794e-02 2.518794e-02
	+7.250000e+01 2.500000e+00 2.500000e+00 6.000000e-01 2.032043e-02 2.032043e-02
	+7.750000e+01 2.500000e+00 2.500000e+00 4.979000e-01 1.672974e-02 1.672974e-02
	+8.250000e+01 2.500000e+00 2.500000e+00 4.092000e-01 1.391882e-02 1.391882e-02
	+9.000000e+01 5.000000e+00 5.000000e+00 3.027000e-01 9.859846e-03 9.859846e-03
	+1.000000e+02 5.000000e+00 5.000000e+00 2.173000e-01 7.024540e-03 7.024540e-03
	+1.150000e+02 1.000000e+01 1.000000e+01 1.366000e-01 4.330457e-03 4.330457e-03
	+1.375000e+02 1.250000e+01 1.250000e+01 7.046000e-02 2.248105e-03 2.248105e-03
	+1.625000e+02 1.250000e+01 1.250000e+01 3.569000e-02 1.186391e-03 1.186391e-03
	+1.875000e+02 1.250000e+01 1.250000e+01 2.024000e-02 7.109975e-04 7.109975e-04
	+2.250000e+02 2.500000e+01 2.500000e+01 9.242000e-03 3.334813e-04 3.334813e-04
	+2.750000e+02 2.500000e+01 2.500000e+01 3.468000e-03 1.472573e-04 1.472573e-04
	+3.250000e+02 2.500000e+01 2.500000e+01 1.483000e-03 7.962757e-05 7.962757e-05
	+3.750000e+02 2.500000e+01 2.500000e+01 6.297000e-04 4.007386e-05 4.007386e-05
	+4.350000e+02 3.500000e+01 3.500000e+01 2.945000e-04 2.482375e-05 2.482375e-05
	+5.100000e+02 4.000000e+01 4.000000e+01 9.920000e-05 1.105090e-05 1.105090e-05
	+6.000000e+02 5.000000e+01 5.000000e+01 3.401000e-05 5.540813e-06 5.540813e-06
	+7.750000e+02 1.250000e+02 1.250000e+02 7.920000e-06 1.607838e-06 1.607838e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d40-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d40-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.199000e-01 8.093916e-03 8.093916e-03
	+3.000000e+00 1.000000e+00 1.000000e+00 2.471000e-01 1.048939e-02 1.048939e-02
	+5.000000e+00 1.000000e+00 1.000000e+00 2.532000e-01 9.747378e-03 9.747378e-03
	+7.000000e+00 1.000000e+00 1.000000e+00 2.363000e-01 9.001138e-03 9.001138e-03
	+9.000000e+00 1.000000e+00 1.000000e+00 2.118000e-01 8.477293e-03 8.477293e-03
	+1.150000e+01 1.500000e+00 1.500000e+00 1.669000e-01 6.275973e-03 6.275973e-03
	+1.450000e+01 1.500000e+00 1.500000e+00 1.341000e-01 5.352253e-03 5.352253e-03
	+1.800000e+01 2.000000e+00 2.000000e+00 1.039000e-01 4.120785e-03 4.120785e-03
	+2.250000e+01 2.500000e+00 2.500000e+00 8.132000e-02 3.066530e-03 3.066530e-03
	+2.750000e+01 2.500000e+00 2.500000e+00 5.917000e-02 2.480910e-03 2.480910e-03
	+3.350000e+01 3.500000e+00 3.500000e+00 4.336000e-02 1.894490e-03 1.894490e-03
	+4.100000e+01 4.000000e+00 4.000000e+00 3.127000e-02 1.366252e-03 1.366252e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 2.288000e-02 1.015522e-03 1.015522e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.425000e-02 7.611421e-04 7.611421e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.029000e-02 6.508781e-04 6.508781e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 6.970000e-03 5.160154e-04 5.160154e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 4.935000e-03 2.956885e-04 2.956885e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.105000e-03 1.172203e-04 1.172203e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 6.743000e-04 4.887163e-05 4.887163e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.498000e-05 2.114613e-06 2.114613e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_EL/d41-x01-y01
	+Path=/REF/ATLAS_2015_I1408516_EL/d41-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.600000e+01 4.000000e+00 4.000000e+00 1.420000e+00 9.939047e-02 9.939047e-02
	+2.500000e+01 5.000000e+00 5.000000e+00 1.040000e+00 6.103746e-02 6.103746e-02
	+3.800000e+01 8.000000e+00 8.000000e+00 1.030000e+00 5.294491e-02 5.294491e-02
	+5.600000e+01 1.000000e+01 1.000000e+01 1.645000e+01 8.898644e-01 8.898644e-01
	+9.100000e+01 2.500000e+01 2.500000e+01 5.276200e+02 1.544053e+01 1.544053e+01
	+1.330000e+02 1.700000e+01 1.700000e+01 5.500000e+00 1.734045e-01 1.734045e-01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2015_I1408516_MU.yoda b/data/refdata/ATLAS_2015_I1408516_MU.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2015_I1408516_MU.yoda
	@@ -0,0 +1,1293 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d01-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d01-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.600000e+01 4.000000e+00 4.000000e+00 5.110000e+00 0.000000e+00 0.000000e+00
	+2.500000e+01 5.000000e+00 5.000000e+00 4.380000e+00 0.000000e+00 0.000000e+00
	+3.800000e+01 8.000000e+00 8.000000e+00 3.590000e+00 0.000000e+00 0.000000e+00
	+5.600000e+01 1.000000e+01 1.000000e+01 1.590000e+00 0.000000e+00 0.000000e+00
	+9.100000e+01 2.500000e+01 2.500000e+01 1.600000e-01 0.000000e+00 0.000000e+00
	+1.330000e+02 1.700000e+01 1.700000e+01 7.400000e-01 0.000000e+00 0.000000e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d02-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d02-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.687000e+00 3.640579e-01 3.640579e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 7.046000e+00 2.023809e-01 2.023809e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.704000e+00 1.774978e-01 1.774978e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.660000e+00 1.666331e-01 1.666331e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.484000e+00 1.513705e-01 1.513705e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.415000e+00 1.575271e-01 1.575271e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.075000e+00 1.366537e-01 1.366537e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 5.904000e+00 1.356636e-01 1.356636e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 5.482000e+00 1.307661e-01 1.307661e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.449000e+00 1.204956e-01 1.204956e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.210000e+00 1.171961e-01 1.171961e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 4.897000e+00 1.125245e-01 1.125245e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.443000e+00 9.425026e-02 9.425026e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.082000e+00 8.572200e-02 8.572200e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.787000e+00 7.555041e-02 7.555041e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.521000e+00 7.024373e-02 7.024373e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.130000e+00 6.244330e-02 6.244330e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.822000e+00 5.629872e-02 5.629872e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.487000e+00 5.108954e-02 5.108954e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.170000e+00 4.134405e-02 4.134405e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.850000e+00 3.577730e-02 3.577730e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.538000e+00 2.930284e-02 2.930284e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.292000e+00 2.498609e-02 2.498609e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 1.001000e+00 1.935842e-02 1.935842e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.710000e-01 1.450628e-02 1.450628e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.310000e-01 9.805544e-03 9.805544e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 3.350000e-01 6.808004e-03 6.808004e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.930000e-01 5.281998e-03 5.281998e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.120000e-01 3.585750e-03 3.585750e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 6.090000e-02 2.661546e-03 2.661546e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 3.280000e-02 1.819439e-03 1.819439e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.670000e-02 9.463170e-04 9.463170e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 9.750000e-03 5.796127e-04 5.796127e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 4.410000e-03 3.476356e-04 3.476356e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 2.190000e-03 1.604689e-04 1.604689e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 5.770000e-04 4.665144e-05 4.665144e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d03-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d03-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.704000e+00 3.440661e-01 3.440661e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 6.884000e+00 1.929977e-01 1.929977e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.851000e+00 1.669734e-01 1.669734e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 6.757000e+00 1.548223e-01 1.548223e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.630000e+00 1.603583e-01 1.603583e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.334000e+00 1.478687e-01 1.478687e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.141000e+00 1.283748e-01 1.283748e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 5.944000e+00 1.294100e-01 1.294100e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 5.664000e+00 1.233140e-01 1.233140e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.413000e+00 1.111973e-01 1.111973e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.189000e+00 1.128533e-01 1.128533e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.139000e+00 1.074285e-01 1.074285e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.569000e+00 9.551287e-02 9.551287e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.198000e+00 8.258438e-02 8.258438e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.110000e+00 7.732919e-02 7.732919e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.486000e+00 6.558870e-02 6.558870e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.165000e+00 6.030135e-02 6.030135e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.802000e+00 5.338527e-02 5.338527e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.550000e+00 4.632305e-02 4.632305e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.154000e+00 3.901060e-02 3.901060e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.889000e+00 3.421125e-02 3.421125e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.496000e+00 2.717619e-02 2.717619e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.268000e+00 2.296446e-02 2.296446e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 9.910000e-01 1.794777e-02 1.794777e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.560000e-01 1.278512e-02 1.278512e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.240000e-01 1.054530e-02 1.054530e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 3.290000e-01 7.574149e-03 7.574149e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.860000e-01 5.332721e-03 5.332721e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 9.980000e-02 3.379965e-03 3.379965e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 5.880000e-02 2.598534e-03 2.598534e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 3.100000e-02 1.367518e-03 1.367518e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.750000e-02 8.304667e-04 8.304667e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 9.230000e-03 4.980780e-04 4.980780e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 4.940000e-03 3.278687e-04 3.278687e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 2.040000e-03 1.509738e-04 1.509738e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 5.290000e-04 4.328759e-05 4.328759e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d04-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d04-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.783000e+00 2.894522e-01 2.894522e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 6.752000e+00 2.026725e-01 2.026725e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.942000e+00 2.046419e-01 2.046419e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 7.206000e+00 2.072273e-01 2.072273e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 6.958000e+00 1.975386e-01 1.975386e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 6.504000e+00 1.950116e-01 1.950116e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 6.378000e+00 1.717329e-01 1.717329e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 5.980000e+00 1.663687e-01 1.663687e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 5.509000e+00 1.589993e-01 1.589993e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 5.625000e+00 1.443993e-01 1.443993e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.170000e+00 1.406392e-01 1.406392e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 4.891000e+00 1.305082e-01 1.305082e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.878000e+00 1.220475e-01 1.220475e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.203000e+00 1.013089e-01 1.013089e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 3.856000e+00 9.366191e-02 9.366191e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.505000e+00 8.448432e-02 8.448432e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.283000e+00 8.272899e-02 8.272899e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.901000e+00 6.950302e-02 6.950302e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.528000e+00 6.140491e-02 6.140491e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.241000e+00 5.115178e-02 5.115178e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.860000e+00 4.483333e-02 4.483333e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.610000e+00 3.765473e-02 3.765473e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.233000e+00 2.994947e-02 2.994947e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 9.850000e-01 2.414757e-02 2.414757e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.470000e-01 1.670343e-02 1.670343e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.340000e-01 1.291574e-02 1.291574e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 3.270000e-01 8.063054e-03 8.063054e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.820000e-01 5.784050e-03 5.784050e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.020000e-01 3.757423e-03 3.757423e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 5.390000e-02 2.170103e-03 2.170103e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 2.950000e-02 1.458386e-03 1.458386e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.520000e-02 1.003315e-03 1.003315e-03
	+2.234500e+00 2.875000e-01 2.875000e-01 6.340000e-03 5.052149e-04 5.052149e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 2.940000e-03 2.872938e-04 2.872938e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 1.060000e-03 1.150332e-04 1.150332e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 3.210000e-04 3.590181e-05 3.590181e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d05-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d05-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.359000e+00 3.970687e-02 3.970687e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.270000e+00 3.932928e-02 3.932928e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.074000e+00 3.849772e-02 3.849772e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.875000e+00 3.765344e-02 3.765344e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.474000e+00 3.595214e-02 3.595214e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.164000e+00 3.463692e-02 3.463692e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.822000e+00 3.225093e-02 3.225093e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.395000e+00 3.049037e-02 3.049037e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.863000e+00 2.829687e-02 2.829687e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.392000e+00 2.635489e-02 2.635489e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.872000e+00 2.421088e-02 2.421088e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.434000e+00 2.240496e-02 2.240496e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.966000e+00 2.106895e-02 2.106895e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.514000e+00 1.915128e-02 1.915128e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.983000e+00 1.689844e-02 1.689844e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.576000e+00 1.517168e-02 1.517168e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.165000e+00 1.342796e-02 1.342796e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.773000e+00 1.176484e-02 1.176484e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.378000e+00 1.008900e-02 1.008900e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.038000e+00 8.646502e-03 8.646502e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.698000e+00 7.204004e-03 7.204004e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.391000e+00 5.901513e-03 5.901513e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.106000e+00 4.692361e-03 4.692361e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.570000e-01 3.635943e-03 3.635943e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.160000e-01 2.613467e-03 2.613467e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.120000e-01 1.888021e-03 1.888021e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.390000e-01 1.095236e-03 1.095236e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.240000e-01 6.791760e-04 6.791760e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.310000e-02 4.417000e-04 4.417000e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.290000e-02 3.015335e-04 3.015335e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.730000e-02 1.895120e-04 1.895120e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 8.780000e-03 1.141400e-04 1.141400e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.450000e-03 6.850688e-05 6.850688e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 2.280000e-03 4.265489e-05 4.265489e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 1.020000e-03 1.883551e-05 1.883551e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 3.010000e-04 6.183334e-06 6.183334e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d06-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d06-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.383000e+00 3.980870e-02 3.980870e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.289000e+00 3.940989e-02 3.940989e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.102000e+00 3.752851e-02 3.752851e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.890000e+00 3.665441e-02 3.665441e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.590000e+00 3.541748e-02 3.541748e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.207000e+00 3.383833e-02 3.383833e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.809000e+00 3.313078e-02 3.313078e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.388000e+00 3.134463e-02 3.134463e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.907000e+00 2.930392e-02 2.930392e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.417000e+00 2.722503e-02 2.722503e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.906000e+00 2.505704e-02 2.505704e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.475000e+00 2.322846e-02 2.322846e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.977000e+00 2.111562e-02 2.111562e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.492000e+00 1.905794e-02 1.905794e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.035000e+00 1.711906e-02 1.711906e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.587000e+00 1.521835e-02 1.521835e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.144000e+00 1.333886e-02 1.333886e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.752000e+00 1.167575e-02 1.167575e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.369000e+00 1.005082e-02 1.005082e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.034000e+00 8.629531e-03 8.629531e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.695000e+00 7.191276e-03 7.191276e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.381000e+00 5.859087e-03 5.859087e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.110000e+00 4.709331e-03 4.709331e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.480000e-01 3.597759e-03 3.597759e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.120000e-01 2.596496e-03 2.596496e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.100000e-01 1.878856e-03 1.878856e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.360000e-01 1.081488e-03 1.081488e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.240000e-01 6.791760e-04 6.791760e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.230000e-02 4.225392e-04 4.225392e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.320000e-02 2.913288e-04 2.913288e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.740000e-02 1.849645e-04 1.849645e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 8.620000e-03 1.103899e-04 1.103899e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.390000e-03 6.941199e-05 6.941199e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 2.240000e-03 4.279514e-05 4.279514e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 1.010000e-03 1.886836e-05 1.886836e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.970000e-04 5.954831e-06 5.954831e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d07-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d07-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.388000e+00 3.982991e-02 3.982991e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.371000e+00 3.863762e-02 3.863762e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.155000e+00 3.774703e-02 3.774703e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.900000e+00 3.669564e-02 3.669564e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.613000e+00 3.551231e-02 3.551231e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.348000e+00 3.441969e-02 3.441969e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.868000e+00 3.338110e-02 3.338110e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.437000e+00 3.155252e-02 3.155252e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.906000e+00 2.847417e-02 2.847417e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.483000e+00 2.750504e-02 2.750504e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.884000e+00 2.496370e-02 2.496370e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.470000e+00 2.320724e-02 2.320724e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 5.016000e+00 2.128109e-02 2.128109e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.506000e+00 1.911734e-02 1.911734e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.037000e+00 1.712754e-02 1.712754e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.564000e+00 1.512077e-02 1.512077e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.149000e+00 1.336008e-02 1.336008e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.745000e+00 1.164605e-02 1.164605e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.388000e+00 1.013143e-02 1.013143e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.025000e+00 8.591347e-03 8.591347e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.679000e+00 7.123394e-03 7.123394e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.394000e+00 5.914241e-03 5.914241e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.110000e+00 4.709331e-03 4.709331e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.430000e-01 3.576546e-03 3.576546e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.090000e-01 2.583768e-03 2.583768e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.080000e-01 1.869691e-03 1.869691e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.360000e-01 1.081488e-03 1.081488e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.210000e-01 6.627443e-04 6.627443e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.170000e-02 3.950728e-04 3.950728e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.230000e-02 2.740746e-04 2.740746e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.670000e-02 1.735515e-04 1.735515e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 8.380000e-03 1.066600e-04 1.066600e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.070000e-03 6.822563e-05 6.822563e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 2.080000e-03 4.086552e-05 4.086552e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 9.090000e-04 1.802022e-05 1.802022e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.750000e-04 5.775000e-06 5.775000e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d08-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d08-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.352000e+00 3.967718e-02 3.967718e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.281000e+00 3.937595e-02 3.937595e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.093000e+00 3.749140e-02 3.749140e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.905000e+00 3.671626e-02 3.671626e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.629000e+00 3.557828e-02 3.557828e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.264000e+00 3.407334e-02 3.407334e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.792000e+00 3.212724e-02 3.212724e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.363000e+00 3.035843e-02 3.035843e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.914000e+00 2.850715e-02 2.850715e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.404000e+00 2.640437e-02 2.640437e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.908000e+00 2.435931e-02 2.435931e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.415000e+00 2.232662e-02 2.232662e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.979000e+00 2.112411e-02 2.112411e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.521000e+00 1.918098e-02 1.918098e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.071000e+00 1.727179e-02 1.727179e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.587000e+00 1.521835e-02 1.521835e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.158000e+00 1.339826e-02 1.339826e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.784000e+00 1.181151e-02 1.181151e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.418000e+00 1.025871e-02 1.025871e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.045000e+00 8.676200e-03 8.676200e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.711000e+00 7.259158e-03 7.259158e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.404000e+00 5.956668e-03 5.956668e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.124000e+00 4.768728e-03 4.768728e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.560000e-01 3.631700e-03 3.631700e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.230000e-01 2.643165e-03 2.643165e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.090000e-01 1.735240e-03 1.735240e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.370000e-01 1.005506e-03 1.005506e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.220000e-01 7.008366e-04 7.008366e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.100000e-02 4.482566e-04 4.482566e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.110000e-02 2.933968e-04 2.933968e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.580000e-02 1.828982e-04 1.828982e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 7.410000e-03 1.013302e-04 1.013302e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 3.570000e-03 6.396181e-05 6.396181e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 1.760000e-03 3.907834e-05 3.907834e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 7.960000e-04 1.806411e-05 1.806411e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 2.130000e-04 5.290810e-06 5.290810e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d09-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d09-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.325000e+00 4.845412e-02 4.845412e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.274000e+00 4.728831e-02 4.728831e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.130000e+00 4.655405e-02 4.655405e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.855000e+00 4.515182e-02 4.515182e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.493000e+00 4.330597e-02 4.330597e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.143000e+00 4.231227e-02 4.231227e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.769000e+00 3.961428e-02 3.961428e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.345000e+00 3.745230e-02 3.745230e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.824000e+00 3.545854e-02 3.545854e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.375000e+00 3.250625e-02 3.250625e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.903000e+00 3.067289e-02 3.067289e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.370000e+00 2.738173e-02 2.738173e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.907000e+00 2.549752e-02 2.549752e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.507000e+00 2.341906e-02 2.341906e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.005000e+00 2.081059e-02 2.081059e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.575000e+00 1.857624e-02 1.857624e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.155000e+00 1.639386e-02 1.639386e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.776000e+00 1.442452e-02 1.442452e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.416000e+00 1.255390e-02 1.255390e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.061000e+00 1.070927e-02 1.070927e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.730000e+00 8.989344e-03 8.989344e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.422000e+00 7.388929e-03 7.388929e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.139000e+00 5.918418e-03 5.918418e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.760000e-01 4.551830e-03 4.551830e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.350000e-01 3.299557e-03 3.299557e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.270000e-01 2.218757e-03 2.218757e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.460000e-01 1.278253e-03 1.278253e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.270000e-01 8.131968e-04 8.131968e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.150000e-02 5.218448e-04 5.218448e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.010000e-02 3.418703e-04 3.418703e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.500000e-02 2.023611e-04 2.023611e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 6.410000e-03 1.197487e-04 1.197487e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 2.990000e-03 7.081946e-05 7.081946e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 1.280000e-03 3.949376e-05 3.949376e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 5.240000e-04 1.694717e-05 1.694717e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 1.280000e-04 4.965674e-06 4.965674e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d10-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d10-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.347000e+00 7.593539e-02 7.593539e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.288000e+00 8.613337e-02 8.613337e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 8.959000e+00 8.308235e-02 8.308235e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.993000e+00 8.339765e-02 8.339765e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.456000e+00 7.841772e-02 7.841772e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.241000e+00 7.642389e-02 7.642389e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.743000e+00 6.385041e-02 6.385041e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.270000e+00 6.583265e-02 6.583265e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.783000e+00 6.290295e-02 6.290295e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.408000e+00 5.166295e-02 5.166295e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.870000e+00 5.411873e-02 5.411873e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.330000e+00 4.942839e-02 4.942839e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.915000e+00 4.531406e-02 4.531406e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.435000e+00 4.112850e-02 4.112850e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.982000e+00 3.627775e-02 3.627775e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.569000e+00 3.251514e-02 3.251514e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.144000e+00 2.592609e-02 2.592609e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.779000e+00 2.531789e-02 2.531789e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.438000e+00 2.221124e-02 2.221124e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.074000e+00 1.722794e-02 1.722794e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.737000e+00 1.582482e-02 1.582482e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.455000e+00 1.325568e-02 1.325568e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.147000e+00 1.044967e-02 1.044967e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 8.890000e-01 7.384589e-03 7.384589e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.460000e-01 5.990758e-03 5.990758e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.370000e-01 3.981259e-03 3.981259e-03
	+4.575000e-01 6.650000e-02 6.650000e-02 2.530000e-01 2.346225e-03 2.346225e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.340000e-01 1.521947e-03 1.521947e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 6.090000e-02 8.804211e-04 8.804211e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 2.900000e-02 5.929064e-04 5.929064e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.290000e-02 3.186065e-04 3.186065e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 4.860000e-03 1.729231e-04 1.729231e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 1.540000e-03 8.499349e-05 8.499349e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 5.360000e-04 4.503357e-05 4.503357e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 1.830000e-04 1.737440e-05 1.737440e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 3.110000e-05 4.149258e-06 4.149258e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d11-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d11-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.113500e+01 4.354056e-01 4.354056e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.136100e+01 2.731370e-01 2.731370e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.098000e+01 2.532551e-01 2.532551e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.100600e+01 2.383504e-01 2.383504e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 1.003900e+01 2.295838e-01 2.295838e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.293000e+00 2.129294e-01 2.129294e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 8.773000e+00 1.782884e-01 1.782884e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 8.532000e+00 1.847725e-01 1.847725e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.781000e+00 1.750293e-01 1.750293e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.826000e+00 1.595007e-01 1.595007e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.965000e+00 1.416609e-01 1.416609e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.439000e+00 1.379191e-01 1.379191e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.949000e+00 1.137194e-01 1.137194e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.528000e+00 1.057072e-01 1.057072e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 3.744000e+00 8.740456e-02 8.740456e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.302000e+00 7.799992e-02 7.799992e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 2.958000e+00 7.184957e-02 7.184957e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.697000e+00 6.444645e-02 6.444645e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.246000e+00 5.515291e-02 5.515291e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.785000e+00 4.476757e-02 4.476757e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.582000e+00 4.027115e-02 4.027115e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.211000e+00 3.143939e-02 3.143939e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.330000e-01 2.907309e-02 2.907309e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.400000e-01 2.369156e-02 2.369156e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.240000e-01 1.577231e-02 1.577231e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.410000e-01 1.183226e-02 1.183226e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 1.970000e-01 8.292741e-03 8.292741e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 9.200000e-02 5.442016e-03 5.442016e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 5.290000e-02 3.464849e-03 3.464849e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.620000e-02 1.854286e-03 1.854286e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 1.370000e-02 1.118460e-03 1.118460e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 5.460000e-03 7.120853e-04 7.120853e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 3.200000e-03 3.625192e-04 3.625192e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 2.620000e-03 3.208511e-04 3.208511e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 5.320000e-04 1.064917e-04 1.064917e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 2.180000e-04 3.801522e-05 3.801522e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d12-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d12-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.220600e+01 3.256967e-01 3.256967e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.184300e+01 2.564768e-01 2.564768e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.080500e+01 2.352415e-01 2.352415e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.123700e+01 2.484877e-01 2.484877e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 9.860000e+00 2.241931e-01 2.241931e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.737000e+00 2.241626e-01 2.241626e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 8.611000e+00 1.826669e-01 1.826669e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 8.268000e+00 1.859841e-01 1.859841e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.404000e+00 1.731650e-01 1.731650e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.583000e+00 1.467581e-01 1.467581e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.931000e+00 1.375685e-01 1.375685e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.657000e+00 1.312131e-01 1.312131e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 4.918000e+00 1.150223e-01 1.150223e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.370000e+00 1.032282e-01 1.032282e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 3.773000e+00 8.912590e-02 8.912590e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.238000e+00 8.023448e-02 8.023448e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.125000e+00 7.308760e-02 7.308760e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.533000e+00 6.438007e-02 6.438007e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.075000e+00 5.434757e-02 5.434757e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.902000e+00 4.662810e-02 4.662810e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.584000e+00 3.975808e-02 3.975808e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.177000e+00 3.201786e-02 3.201786e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.720000e-01 2.656602e-02 2.656602e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.890000e-01 2.121515e-02 2.121515e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.450000e-01 1.603819e-02 1.603819e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.300000e-01 1.141724e-02 1.141724e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 1.880000e-01 6.504365e-03 6.504365e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 9.640000e-02 4.136223e-03 4.136223e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 4.770000e-02 2.594284e-03 2.594284e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.510000e-02 1.655268e-03 1.655268e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 1.110000e-02 9.214337e-04 9.214337e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 5.970000e-03 5.503420e-04 5.503420e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 4.070000e-03 4.437233e-04 4.437233e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 1.280000e-03 2.201935e-04 2.201935e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 5.110000e-04 9.277993e-05 9.277993e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 1.710000e-04 3.101659e-05 3.101659e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d13-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d13-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.129100e+01 3.835618e-01 3.835618e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.120700e+01 3.603708e-01 3.603708e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.116400e+01 3.567243e-01 3.567243e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.090200e+01 3.530969e-01 3.530969e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 1.020000e+01 3.524539e-01 3.524539e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 1.008400e+01 3.427077e-01 3.427077e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 9.019000e+00 2.843489e-01 2.843489e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 8.239000e+00 2.783026e-01 2.783026e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.356000e+00 2.550316e-01 2.550316e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.463000e+00 2.255578e-01 2.255578e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.675000e+00 2.076616e-01 2.076616e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.445000e+00 1.958687e-01 1.958687e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 5.424000e+00 1.935996e-01 1.935996e-01
	+6.800000e-02 4.000000e-03 4.000000e-03 4.460000e+00 1.661612e-01 1.661612e-01
	+7.650000e-02 4.500000e-03 4.500000e-03 4.103000e+00 1.454686e-01 1.454686e-01
	+8.600000e-02 5.000000e-03 5.000000e-03 3.426000e+00 1.276386e-01 1.276386e-01
	+9.650000e-02 5.500000e-03 5.500000e-03 2.874000e+00 1.124171e-01 1.124171e-01
	+1.080000e-01 6.000000e-03 6.000000e-03 2.590000e+00 1.003437e-01 1.003437e-01
	+1.210000e-01 7.000000e-03 7.000000e-03 2.157000e+00 8.431635e-02 8.431635e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.814000e+00 7.183074e-02 7.183074e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.634000e+00 6.296733e-02 6.296733e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.343000e+00 5.083925e-02 5.083925e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.630000e-01 3.963538e-02 3.963538e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.880000e-01 3.093339e-02 3.093339e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.430000e-01 2.276718e-02 2.276718e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.420000e-01 1.481693e-02 1.481693e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 1.990000e-01 9.149673e-03 9.149673e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 8.780000e-02 5.245269e-03 5.245269e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 4.480000e-02 3.306713e-03 3.306713e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.380000e-02 2.367711e-03 2.367711e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 9.600000e-03 1.327059e-03 1.327059e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 2.720000e-03 6.319304e-04 6.319304e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 9.880000e-04 2.653217e-04 2.653217e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 1.010000e-04 1.274532e-04 1.274532e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 5.350000e-05 3.848283e-05 3.848283e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 4.160000e-05 1.729560e-05 1.729560e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d14-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d14-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 6.724000e+00 2.963141e-01 2.963141e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 6.909000e+00 1.204625e-01 1.204625e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 6.827000e+00 9.385573e-02 9.385573e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 6.814000e+00 8.858200e-02 8.858200e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 6.627000e+00 8.615100e-02 8.615100e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 6.440000e+00 8.853536e-02 8.853536e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 6.145000e+00 7.821308e-02 7.821308e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 5.959000e+00 7.584569e-02 7.584569e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 5.539000e+00 7.200700e-02 7.200700e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 5.475000e+00 6.615468e-02 6.615468e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.208000e+00 6.710039e-02 6.710039e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 4.977000e+00 6.412416e-02 6.412416e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.600000e+00 6.154381e-02 6.154381e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.148000e+00 5.549646e-02 5.549646e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.945000e+00 5.494749e-02 5.494749e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.509000e+00 4.836823e-02 4.836823e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.184000e+00 4.388841e-02 4.388841e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.824000e+00 4.282808e-02 4.282808e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.524000e+00 3.786000e-02 3.786000e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 2.180000e+00 3.151589e-02 3.151589e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.868000e+00 2.700536e-02 2.700536e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.539000e+00 2.447929e-02 2.447929e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 1.269000e+00 1.924534e-02 1.924534e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 9.910000e-01 1.576282e-02 1.576282e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 7.620000e-01 1.214428e-02 1.214428e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 5.290000e-01 1.055352e-02 1.055352e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 3.300000e-01 7.739186e-03 7.739186e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 1.870000e-01 5.827083e-03 5.827083e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 1.040000e-01 3.520673e-03 3.520673e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 5.860000e-02 2.324877e-03 2.324877e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 3.150000e-02 1.357793e-03 1.357793e-03
	+1.721500e+00 2.255000e-01 2.255000e-01 1.670000e-02 6.775345e-04 6.775345e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 8.750000e-03 3.857946e-04 3.857946e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 4.300000e-03 2.218150e-04 2.218150e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 1.870000e-03 1.074233e-04 1.074233e-04
	+7.500000e+00 2.500000e+00 2.500000e+00 4.970000e-04 3.077791e-05 3.077791e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d15-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d15-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 9.359000e+00 2.092736e-02 2.092736e-02
	+6.000000e-03 2.000000e-03 2.000000e-03 9.294000e+00 2.078202e-02 2.078202e-02
	+1.000000e-02 2.000000e-03 2.000000e-03 9.098000e+00 2.034375e-02 2.034375e-02
	+1.400000e-02 2.000000e-03 2.000000e-03 8.888000e+00 1.777600e-02 1.777600e-02
	+1.800000e-02 2.000000e-03 2.000000e-03 8.556000e+00 1.711200e-02 1.711200e-02
	+2.200000e-02 2.000000e-03 2.000000e-03 8.229000e+00 1.645800e-02 1.645800e-02
	+2.650000e-02 2.500000e-03 2.500000e-03 7.811000e+00 1.562200e-02 1.562200e-02
	+3.150000e-02 2.500000e-03 2.500000e-03 7.384000e+00 1.476800e-02 1.476800e-02
	+3.650000e-02 2.500000e-03 2.500000e-03 6.881000e+00 1.376200e-02 1.376200e-02
	+4.200000e-02 3.000000e-03 3.000000e-03 6.417000e+00 1.434885e-02 1.434885e-02
	+4.800000e-02 3.000000e-03 3.000000e-03 5.891000e+00 1.317268e-02 1.317268e-02
	+5.400000e-02 3.000000e-03 3.000000e-03 5.434000e+00 1.086800e-02 1.086800e-02
	+6.050000e-02 3.500000e-03 3.500000e-03 4.972000e+00 1.111773e-02 1.111773e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.505000e+00 1.007349e-02 1.007349e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 4.025000e+00 9.000174e-03 9.000174e-03
	+8.600000e-02 5.000000e-03 5.000000e-03 3.577000e+00 7.998415e-03 7.998415e-03
	+9.650000e-02 5.500000e-03 5.500000e-03 3.153000e+00 7.050322e-03 7.050322e-03
	+1.080000e-01 6.000000e-03 6.000000e-03 2.765000e+00 6.182728e-03 6.182728e-03
	+1.210000e-01 7.000000e-03 7.000000e-03 2.394000e+00 5.353147e-03 5.353147e-03
	+1.365000e-01 8.500000e-03 8.500000e-03 2.040000e+00 4.561579e-03 4.561579e-03
	+1.550000e-01 1.000000e-02 1.000000e-02 1.702000e+00 3.805788e-03 3.805788e-03
	+1.770000e-01 1.200000e-02 1.200000e-02 1.399000e+00 3.128259e-03 3.128259e-03
	+2.040000e-01 1.500000e-02 1.500000e-02 1.117000e+00 2.497688e-03 2.497688e-03
	+2.385000e-01 1.950000e-02 1.950000e-02 8.560000e-01 1.914074e-03 1.914074e-03
	+2.850000e-01 2.700000e-02 2.700000e-02 6.190000e-01 1.384126e-03 1.384126e-03
	+3.515000e-01 3.950000e-02 3.950000e-02 4.130000e-01 9.234961e-04 9.234961e-04
	+4.575000e-01 6.650000e-02 6.650000e-02 2.390000e-01 6.759941e-04 6.759941e-04
	+6.095000e-01 8.550000e-02 8.550000e-02 1.240000e-01 3.720000e-04 3.720000e-04
	+8.065000e-01 1.115000e-01 1.115000e-01 6.200000e-02 2.319828e-04 2.319828e-04
	+1.035500e+00 1.175000e-01 1.175000e-01 3.200000e-02 1.466424e-04 1.466424e-04
	+1.324500e+00 1.715000e-01 1.715000e-01 1.650000e-02 9.037422e-05 9.037422e-05
	+1.721500e+00 2.255000e-01 2.255000e-01 7.980000e-03 5.412299e-05 5.412299e-05
	+2.234500e+00 2.875000e-01 2.875000e-01 3.910000e-03 3.078737e-05 3.078737e-05
	+2.899500e+00 3.775000e-01 3.775000e-01 1.950000e-03 1.890595e-05 1.890595e-05
	+4.138500e+00 8.615000e-01 8.615000e-01 8.630000e-04 8.367095e-06 8.367095e-06
	+7.500000e+00 2.500000e+00 2.500000e+00 2.470000e-04 2.625646e-06 2.625646e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d16-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d16-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-03 2.000000e-03 2.000000e-03 1.160100e+01 3.097706e-01 3.097706e-01
	+6.000000e-03 2.000000e-03 2.000000e-03 1.144900e+01 2.009291e-01 2.009291e-01
	+1.000000e-02 2.000000e-03 2.000000e-03 1.088000e+01 1.823820e-01 1.823820e-01
	+1.400000e-02 2.000000e-03 2.000000e-03 1.101800e+01 1.936788e-01 1.936788e-01
	+1.800000e-02 2.000000e-03 2.000000e-03 9.989000e+00 1.795243e-01 1.795243e-01
	+2.200000e-02 2.000000e-03 2.000000e-03 9.619000e+00 1.796977e-01 1.796977e-01
	+2.650000e-02 2.500000e-03 2.500000e-03 8.783000e+00 1.472299e-01 1.472299e-01
	+3.150000e-02 2.500000e-03 2.500000e-03 8.344000e+00 1.494950e-01 1.494950e-01
	+3.650000e-02 2.500000e-03 2.500000e-03 7.526000e+00 1.420003e-01 1.420003e-01
	+4.200000e-02 3.000000e-03 3.000000e-03 6.672000e+00 1.149832e-01 1.149832e-01
	+4.800000e-02 3.000000e-03 3.000000e-03 5.971000e+00 1.140758e-01 1.140758e-01
	+5.400000e-02 3.000000e-03 3.000000e-03 5.480000e+00 1.098737e-01 1.098737e-01
	+6.050000e-02 3.500000e-03 3.500000e-03 5.028000e+00 9.749654e-02 9.749654e-02
	+6.800000e-02 4.000000e-03 4.000000e-03 4.426000e+00 8.994695e-02 8.994695e-02
	+7.650000e-02 4.500000e-03 4.500000e-03 3.834000e+00 7.434402e-02 7.434402e-02
	+8.600000e-02 5.000000e-03 5.000000e-03 3.311000e+00 6.728747e-02 6.728747e-02
	+9.650000e-02 5.500000e-03 5.500000e-03 3.031000e+00 6.226474e-02 6.226474e-02
	+1.080000e-01 6.000000e-03 6.000000e-03 2.620000e+00 5.324469e-02 5.324469e-02
	+1.210000e-01 7.000000e-03 7.000000e-03 2.169000e+00 4.742130e-02 4.742130e-02
	+1.365000e-01 8.500000e-03 8.500000e-03 1.828000e+00 3.979838e-02 3.979838e-02
	+1.550000e-01 1.000000e-02 1.000000e-02 1.577000e+00 3.433372e-02 3.433372e-02
	+1.770000e-01 1.200000e-02 1.200000e-02 1.224000e+00 2.836407e-02 2.836407e-02
	+2.040000e-01 1.500000e-02 1.500000e-02 9.480000e-01 2.589272e-02 2.589272e-02
	+2.385000e-01 1.950000e-02 1.950000e-02 7.680000e-01 2.158613e-02 2.158613e-02
	+2.850000e-01 2.700000e-02 2.700000e-02 5.390000e-01 1.565885e-02 1.565885e-02
	+3.515000e-01 3.950000e-02 3.950000e-02 3.370000e-01 1.144808e-02 1.144808e-02
	+4.575000e-01 6.650000e-02 6.650000e-02 1.930000e-01 7.407279e-03 7.407279e-03
	+6.095000e-01 8.550000e-02 8.550000e-02 9.400000e-02 4.321956e-03 4.321956e-03
	+8.065000e-01 1.115000e-01 1.115000e-01 4.960000e-02 2.899798e-03 2.899798e-03
	+1.035500e+00 1.175000e-01 1.175000e-01 2.590000e-02 1.611013e-03 1.611013e-03
	+1.324500e+00 1.715000e-01 1.715000e-01 1.230000e-02 9.185556e-04 9.185556e-04
	+1.721500e+00 2.255000e-01 2.255000e-01 5.320000e-03 5.523328e-04 5.523328e-04
	+2.234500e+00 2.875000e-01 2.875000e-01 3.180000e-03 3.496699e-04 3.496699e-04
	+2.899500e+00 3.775000e-01 3.775000e-01 1.740000e-03 2.358005e-04 2.358005e-04
	+4.138500e+00 8.615000e-01 8.615000e-01 4.760000e-04 9.163216e-05 9.163216e-05
	+7.500000e+00 2.500000e+00 2.500000e+00 1.790000e-04 3.051412e-05 3.051412e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d17-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d17-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.638000e-02 2.651157e-04 2.651157e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.472000e-02 2.790183e-04 2.790183e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.534000e-02 3.411387e-04 3.411387e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.879000e-02 2.288454e-04 2.288454e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.111000e-02 2.466600e-04 2.466600e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.287000e-02 1.432770e-04 1.432770e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.551000e-02 1.111955e-04 1.111955e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.920000e-02 8.369086e-05 8.369086e-05
	+2.250000e+01 2.500000e+00 2.500000e+00 1.380000e-02 6.015281e-05 6.015281e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.772000e-03 5.262383e-05 5.262383e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.845000e-03 3.490279e-05 3.490279e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.580000e-03 2.335351e-05 2.335351e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 3.018000e-03 2.024536e-05 2.024536e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.917000e-03 1.497225e-05 1.497225e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.282000e-03 1.269115e-05 1.269115e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.486000e-04 1.046224e-05 1.046224e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.833000e-04 4.784426e-06 4.784426e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.852000e-04 1.986049e-06 1.986049e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.377000e-05 9.767806e-07 9.767806e-07
	+5.500000e+02 3.500000e+02 3.500000e+02 2.277000e-06 5.325455e-08 5.325455e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d18-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d18-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.672000e-02 2.685327e-04 2.685327e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.485000e-02 2.390856e-04 2.390856e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.569000e-02 2.839644e-04 2.839644e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.936000e-02 2.035165e-04 2.035165e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.112000e-02 2.214380e-04 2.214380e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.290000e-02 1.231005e-04 1.231005e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.533000e-02 9.477618e-05 9.477618e-05
	+1.800000e+01 2.000000e+00 2.000000e+00 1.916000e-02 7.169016e-05 7.169016e-05
	+2.250000e+01 2.500000e+00 2.500000e+00 1.368000e-02 5.118587e-05 5.118587e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.759000e-03 4.472136e-05 4.472136e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.791000e-03 3.462744e-05 3.462744e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.555000e-03 2.452943e-05 2.452943e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 2.955000e-03 1.982274e-05 1.982274e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.912000e-03 1.541504e-05 1.541504e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.260000e-03 1.247336e-05 1.247336e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.501000e-04 1.048074e-05 1.048074e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.833000e-04 4.784426e-06 4.784426e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.850000e-04 1.859227e-06 1.859227e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.453000e-05 9.905866e-07 9.905866e-07
	+5.500000e+02 3.500000e+02 3.500000e+02 2.138000e-06 5.045861e-08 5.045861e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d19-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d19-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.662000e-02 2.791929e-04 2.791929e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.491000e-02 2.575507e-04 2.575507e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.645000e-02 2.878397e-04 2.878397e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.913000e-02 2.505148e-04 2.505148e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.132000e-02 2.479200e-04 2.479200e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.284000e-02 1.431462e-04 1.431462e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.556000e-02 1.303309e-04 1.303309e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.916000e-02 7.169016e-05 7.169016e-05
	+2.250000e+01 2.500000e+00 2.500000e+00 1.373000e-02 5.137296e-05 5.137296e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.698000e-03 4.444182e-05 4.444182e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.757000e-03 3.096446e-05 3.096446e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.527000e-03 2.678209e-05 2.678209e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 2.909000e-03 1.793228e-05 1.793228e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.893000e-03 1.416591e-05 1.416591e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.242000e-03 1.229517e-05 1.229517e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.348000e-04 9.912701e-06 9.912701e-06
	+9.500000e+01 1.000000e+01 1.000000e+01 4.786000e-04 4.737898e-06 4.737898e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.829000e-04 1.961384e-06 1.961384e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.152000e-05 1.005630e-06 1.005630e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.067000e-06 5.138481e-08 5.138481e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d20-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d20-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.573000e-02 2.698585e-04 2.698585e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.405000e-02 3.331866e-04 3.331866e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.498000e-02 2.960764e-04 2.960764e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.831000e-02 2.601573e-04 2.601573e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.104000e-02 2.462400e-04 2.462400e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.313000e-02 1.518207e-04 1.518207e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.580000e-02 1.389373e-04 1.389373e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.947000e-02 9.538313e-05 9.538313e-05
	+2.250000e+01 2.500000e+00 2.500000e+00 1.390000e-02 7.485379e-05 7.485379e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 9.973000e-03 6.147770e-05 6.147770e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 6.928000e-03 3.532601e-05 3.532601e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.594000e-03 2.831932e-05 2.831932e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 2.949000e-03 1.817886e-05 1.817886e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.921000e-03 1.750114e-05 1.750114e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.263000e-03 1.354417e-05 1.354417e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.689000e-04 1.142860e-05 1.142860e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 4.877000e-04 5.230000e-06 5.230000e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 1.909000e-04 2.047174e-06 2.047174e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.410000e-05 1.030743e-06 1.030743e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.095000e-06 5.062796e-08 5.062796e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d21-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d21-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.541000e-02 3.493297e-04 3.493297e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.254000e-02 3.931734e-04 3.931734e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.366000e-02 2.889679e-04 2.889679e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.674000e-02 3.305017e-04 3.305017e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 3.950000e-02 2.649741e-04 2.649741e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.216000e-02 1.731869e-04 1.731869e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.531000e-02 1.697846e-04 1.697846e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.968000e-02 1.213157e-04 1.213157e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.419000e-02 9.518941e-05 9.518941e-05
	+2.750000e+01 2.500000e+00 2.500000e+00 1.029000e-02 7.700331e-05 7.700331e-05
	+3.350000e+01 3.500000e+00 3.500000e+00 7.452000e-03 4.998954e-05 4.998954e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 4.998000e-03 3.740161e-05 3.740161e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 3.221000e-03 2.675564e-05 2.675564e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 2.022000e-03 2.331884e-05 2.331884e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.330000e-03 1.749342e-05 1.749342e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 8.952000e-04 1.555692e-05 1.555692e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 5.206000e-04 7.100037e-06 7.100037e-06
	+1.275000e+02 2.250000e+01 2.250000e+01 2.030000e-04 2.615472e-06 2.615472e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.976000e-05 1.283102e-06 1.283102e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 2.036000e-06 6.337817e-08 6.337817e-08
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d22-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d22-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.563000e-02 5.988871e-04 5.988871e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.296000e-02 7.085565e-04 7.085565e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.274000e-02 5.990113e-04 5.990113e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.556000e-02 6.112515e-04 6.112515e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 3.872000e-02 4.397747e-04 4.397747e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.175000e-02 3.389972e-04 3.389972e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.473000e-02 2.988137e-04 2.988137e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.909000e-02 1.956143e-04 1.956143e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.417000e-02 1.519563e-04 1.519563e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 1.020000e-02 1.345472e-04 1.345472e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 7.424000e-03 8.593901e-05 8.593901e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 5.215000e-03 6.492623e-05 6.492623e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 3.478000e-03 4.574595e-05 4.574595e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 2.325000e-03 3.820365e-05 3.820365e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 1.519000e-03 3.510172e-05 3.510172e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 1.037000e-03 2.949531e-05 2.949531e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 5.498000e-04 1.322952e-05 1.322952e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 1.975000e-04 4.698674e-06 4.698674e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 5.514000e-05 2.270804e-06 2.270804e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 1.745000e-06 1.042482e-07 1.042482e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d23-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d23-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.815000e-02 4.241225e-04 4.241225e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.156000e-02 3.771460e-04 3.771460e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.532000e-02 3.147132e-04 3.147132e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.042000e-02 2.754903e-04 2.754903e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.974000e-03 1.460884e-04 1.460884e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.023000e-03 5.796522e-05 5.796522e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 4.940000e-04 2.719245e-05 2.719245e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 1.460000e-05 1.182330e-06 1.182330e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d24-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d24-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.766000e-02 5.621176e-04 5.621176e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.114000e-02 4.684311e-04 4.684311e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.480000e-02 4.442466e-04 4.442466e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.010000e-02 3.792547e-04 3.792547e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 6.240000e-03 2.097605e-04 2.097605e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.201000e-03 7.843717e-05 7.843717e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 5.107000e-04 3.372941e-05 3.372941e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 1.947000e-05 1.587253e-06 1.587253e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d25-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d25-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.977000e-02 5.968866e-04 5.968866e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.119000e-02 5.032346e-04 5.032346e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.405000e-02 4.366816e-04 4.366816e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 9.895000e-03 3.733970e-04 3.733970e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.799000e-03 2.098084e-04 2.098084e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.042000e-03 8.160339e-05 8.160339e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 5.911000e-04 4.213842e-05 4.213842e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 1.923000e-05 2.155219e-06 2.155219e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d26-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d26-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.927000e-02 1.775855e-03 1.775855e-03
	+3.000000e+00 1.000000e+00 1.000000e+00 7.302000e-02 8.065323e-04 8.065323e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 6.764000e-02 6.996736e-04 6.996736e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 5.484000e-02 6.418857e-04 6.418857e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.163000e-02 5.282255e-04 5.282255e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.166000e-02 3.928903e-04 3.928903e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.283000e-02 2.985410e-04 2.985410e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.738000e-02 2.272730e-04 2.272730e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.254000e-02 1.777852e-04 1.777852e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 7.862000e-03 1.338850e-04 1.338850e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 4.428000e-03 8.911178e-05 8.911178e-05
	+4.100000e+01 4.000000e+00 4.000000e+00 2.784000e-03 7.227684e-05 7.227684e-05
	+5.000000e+01 5.000000e+00 5.000000e+00 1.819000e-03 4.785042e-05 4.785042e-05
	+6.000000e+01 5.000000e+00 5.000000e+00 1.236000e-03 3.887019e-05 3.887019e-05
	+7.000000e+01 5.000000e+00 5.000000e+00 7.838000e-04 2.899001e-05 2.899001e-05
	+8.000000e+01 5.000000e+00 5.000000e+00 5.533000e-04 2.443307e-05 2.443307e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 3.396000e-04 1.322697e-05 1.322697e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 1.229000e-04 4.763069e-06 4.763069e-06
	+1.750000e+02 2.500000e+01 2.500000e+01 3.488000e-05 2.063823e-06 2.063823e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 1.315000e-06 1.034513e-07 1.034513e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d27-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d27-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.626000e-02 2.435252e-04 2.435252e-04
	+3.000000e+00 1.000000e+00 1.000000e+00 5.428000e-02 1.800264e-04 1.800264e-04
	+5.000000e+00 1.000000e+00 1.000000e+00 5.525000e-02 2.344059e-04 2.344059e-04
	+7.000000e+00 1.000000e+00 1.000000e+00 4.851000e-02 1.455300e-04 1.455300e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 4.085000e-02 1.225500e-04 1.225500e-04
	+1.100000e+01 1.000000e+00 1.000000e+00 3.420000e-02 1.026000e-04 1.026000e-04
	+1.300000e+01 1.000000e+00 1.000000e+00 2.878000e-02 8.634000e-05 8.634000e-05
	+1.500000e+01 1.000000e+00 1.000000e+00 2.443000e-02 7.329000e-05 7.329000e-05
	+1.700000e+01 1.000000e+00 1.000000e+00 2.077000e-02 6.231000e-05 6.231000e-05
	+1.900000e+01 1.000000e+00 1.000000e+00 1.781000e-02 6.663892e-05 6.663892e-05
	+2.125000e+01 1.250000e+00 1.250000e+00 1.503000e-02 6.551425e-05 6.551425e-05
	+2.375000e+01 1.250000e+00 1.250000e+00 1.266000e-02 4.736938e-05 4.736938e-05
	+2.625000e+01 1.250000e+00 1.250000e+00 1.068000e-02 4.655304e-05 4.655304e-05
	+2.875000e+01 1.250000e+00 1.250000e+00 9.064000e-03 3.950906e-05 3.950906e-05
	+3.150000e+01 1.500000e+00 1.500000e+00 7.709000e-03 3.360275e-05 3.360275e-05
	+3.450000e+01 1.500000e+00 1.500000e+00 6.541000e-03 3.068001e-05 3.068001e-05
	+3.750000e+01 1.500000e+00 1.500000e+00 5.487000e-03 2.954840e-05 2.954840e-05
	+4.050000e+01 1.500000e+00 1.500000e+00 4.728000e-03 2.546106e-05 2.546106e-05
	+4.350000e+01 1.500000e+00 1.500000e+00 4.086000e-03 2.200378e-05 2.200378e-05
	+4.650000e+01 1.500000e+00 1.500000e+00 3.541000e-03 2.375375e-05 2.375375e-05
	+4.950000e+01 1.500000e+00 1.500000e+00 3.027000e-03 2.030573e-05 2.030573e-05
	+5.250000e+01 1.500000e+00 1.500000e+00 2.660000e-03 1.954693e-05 1.954693e-05
	+5.550000e+01 1.500000e+00 1.500000e+00 2.322000e-03 1.737626e-05 1.737626e-05
	+5.900000e+01 2.000000e+00 2.000000e+00 2.036000e-03 1.439669e-05 1.439669e-05
	+6.300000e+01 2.000000e+00 2.000000e+00 1.683000e-03 1.259442e-05 1.259442e-05
	+6.750000e+01 2.500000e+00 2.500000e+00 1.417000e-03 1.060386e-05 1.060386e-05
	+7.250000e+01 2.500000e+00 2.500000e+00 1.144000e-03 1.042234e-05 1.042234e-05
	+7.750000e+01 2.500000e+00 2.500000e+00 9.545000e-04 9.254221e-06 9.254221e-06
	+8.250000e+01 2.500000e+00 2.500000e+00 7.721000e-04 8.769370e-06 8.769370e-06
	+9.000000e+01 5.000000e+00 5.000000e+00 5.771000e-04 4.652729e-06 4.652729e-06
	+1.000000e+02 5.000000e+00 5.000000e+00 4.044000e-04 3.571564e-06 3.571564e-06
	+1.150000e+02 1.000000e+01 1.000000e+01 2.562000e-04 1.917225e-06 1.917225e-06
	+1.375000e+02 1.250000e+01 1.250000e+01 1.337000e-04 1.110596e-06 1.110596e-06
	+1.625000e+02 1.250000e+01 1.250000e+01 7.115000e-05 8.448594e-07 8.448594e-07
	+1.875000e+02 1.250000e+01 1.250000e+01 3.744000e-05 6.883260e-07 6.883260e-07
	+2.250000e+02 2.500000e+01 2.500000e+01 1.762000e-05 3.031459e-07 3.031459e-07
	+2.750000e+02 2.500000e+01 2.500000e+01 6.756000e-06 2.018903e-07 2.018903e-07
	+3.250000e+02 2.500000e+01 2.500000e+01 2.735000e-06 1.528911e-07 1.528911e-07
	+3.750000e+02 2.500000e+01 2.500000e+01 1.228000e-06 1.072024e-07 1.072024e-07
	+4.350000e+02 3.500000e+01 3.500000e+01 5.711000e-07 5.721556e-08 5.721556e-08
	+5.100000e+02 4.000000e+01 4.000000e+01 2.118000e-07 3.659546e-08 3.659546e-08
	+6.000000e+02 5.000000e+01 5.000000e+01 8.540000e-08 2.230821e-08 2.230821e-08
	+7.750000e+02 1.250000e+02 1.250000e+02 7.000000e-09 3.739219e-09 3.739219e-09
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d28-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d28-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.023000e-02 1.183930e-03 1.183930e-03
	+3.000000e+00 1.000000e+00 1.000000e+00 4.488000e-02 1.000532e-03 1.000532e-03
	+5.000000e+00 1.000000e+00 1.000000e+00 4.882000e-02 1.044794e-03 1.044794e-03
	+7.000000e+00 1.000000e+00 1.000000e+00 4.326000e-02 9.826783e-04 9.826783e-04
	+9.000000e+00 1.000000e+00 1.000000e+00 3.804000e-02 9.926910e-04 9.926910e-04
	+1.150000e+01 1.500000e+00 1.500000e+00 3.081000e-02 6.557538e-04 6.557538e-04
	+1.450000e+01 1.500000e+00 1.500000e+00 2.552000e-02 5.757574e-04 5.757574e-04
	+1.800000e+01 2.000000e+00 2.000000e+00 1.956000e-02 4.320945e-04 4.320945e-04
	+2.250000e+01 2.500000e+00 2.500000e+00 1.463000e-02 3.185176e-04 3.185176e-04
	+2.750000e+01 2.500000e+00 2.500000e+00 1.084000e-02 2.710000e-04 2.710000e-04
	+3.350000e+01 3.500000e+00 3.500000e+00 7.948000e-03 1.808934e-04 1.808934e-04
	+4.100000e+01 4.000000e+00 4.000000e+00 5.628000e-03 1.520602e-04 1.520602e-04
	+5.000000e+01 5.000000e+00 5.000000e+00 3.573000e-03 1.265266e-04 1.265266e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 2.604000e-03 1.131767e-04 1.131767e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.691000e-03 1.022041e-04 1.022041e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.325000e-03 8.498612e-05 8.498612e-05
	+9.500000e+01 1.000000e+01 1.000000e+01 8.311000e-04 4.258931e-05 4.258931e-05
	+1.275000e+02 2.250000e+01 2.250000e+01 3.714000e-04 1.691808e-05 1.691808e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 1.139000e-04 7.849189e-06 7.849189e-06
	+5.500000e+02 3.500000e+02 3.500000e+02 4.718000e-06 3.350444e-07 3.350444e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d29-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d29-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.109000e+00 9.572489e-02 9.572489e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 6.448000e+00 1.888725e-01 1.888725e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 6.521000e+00 1.932242e-01 1.932242e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 5.750000e+00 1.703786e-01 1.703786e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 4.844000e+00 1.441039e-01 1.441039e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.873000e+00 1.145649e-01 1.145649e-01
	+1.450000e+01 1.500000e+00 1.500000e+00 3.006000e+00 8.907098e-02 8.907098e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.262000e+00 6.691086e-02 6.691086e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.626000e+00 4.809773e-02 4.809773e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.151000e+00 3.460665e-02 3.460665e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 8.065000e-01 2.420844e-02 2.420844e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 5.396000e-01 1.619699e-02 1.619699e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 3.557000e-01 1.074779e-02 1.074779e-02
	+6.000000e+01 5.000000e+00 5.000000e+00 2.259000e-01 6.962706e-03 6.962706e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.510000e-01 4.722222e-03 4.722222e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 9.999000e-02 3.194990e-03 3.194990e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 5.695000e-02 1.761772e-03 1.761772e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.183000e-02 6.812919e-04 6.812919e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 6.336000e-03 2.182014e-04 2.182014e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 2.683000e-04 1.001733e-05 1.001733e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d30-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d30-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.118000e+00 9.483027e-02 9.483027e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 6.399000e+00 1.874372e-01 1.874372e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 6.497000e+00 1.921839e-01 1.921839e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 5.758000e+00 1.689559e-01 1.689559e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 4.797000e+00 1.427057e-01 1.427057e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.838000e+00 1.135296e-01 1.135296e-01
	+1.450000e+01 1.500000e+00 1.500000e+00 2.956000e+00 8.743966e-02 8.743966e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.235000e+00 6.611219e-02 6.611219e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.596000e+00 4.721032e-02 4.721032e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.139000e+00 3.382657e-02 3.382657e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 7.923000e-01 2.353011e-02 2.353011e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 5.314000e-01 1.580859e-02 1.580859e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 3.448000e-01 1.041844e-02 1.041844e-02
	+6.000000e+01 5.000000e+00 5.000000e+00 2.231000e-01 6.781653e-03 6.781653e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.470000e-01 4.547506e-03 4.547506e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 9.917000e-02 3.168788e-03 3.168788e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 5.638000e-02 1.744139e-03 1.744139e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.158000e-02 6.717587e-04 6.717587e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 6.361000e-03 2.211763e-04 2.211763e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 2.494000e-04 9.480481e-06 9.480481e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d31-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d31-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 3.005000e+00 9.296093e-02 9.296093e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 6.200000e+00 1.819254e-01 1.819254e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 6.374000e+00 1.867049e-01 1.867049e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 5.547000e+00 1.610542e-01 1.610542e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 4.665000e+00 1.374395e-01 1.374395e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.708000e+00 1.076598e-01 1.076598e-01
	+1.450000e+01 1.500000e+00 1.500000e+00 2.886000e+00 8.487981e-02 8.487981e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.163000e+00 6.335781e-02 6.335781e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.551000e+00 4.543133e-02 4.543133e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 1.095000e+00 3.220492e-02 3.220492e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 7.629000e-01 2.243756e-02 2.243756e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 5.111000e-01 1.525614e-02 1.525614e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 3.285000e-01 9.822095e-03 9.822095e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.137000e-01 6.495918e-03 6.495918e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.402000e-01 4.337145e-03 4.337145e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 9.426000e-02 2.980763e-03 2.980763e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 5.404000e-02 1.671750e-03 1.671750e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 2.065000e-02 6.444653e-04 6.444653e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.817000e-03 2.065649e-04 2.065649e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 2.333000e-04 9.101691e-06 9.101691e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d32-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d32-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 2.437000e+00 7.636797e-02 7.636797e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 5.120000e+00 1.517111e-01 1.517111e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 5.209000e+00 1.528467e-01 1.528467e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 4.576000e+00 1.336474e-01 1.336474e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 3.887000e+00 1.135244e-01 1.135244e-01
	+1.150000e+01 1.500000e+00 1.500000e+00 3.138000e+00 9.078533e-02 9.078533e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 2.444000e+00 7.137986e-02 7.137986e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 1.844000e+00 5.344420e-02 5.344420e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 1.317000e+00 3.846452e-02 3.846452e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 9.448000e-01 2.773917e-02 2.773917e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 6.564000e-01 1.913718e-02 1.913718e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 4.352000e-01 1.277740e-02 1.277740e-02
	+5.000000e+01 5.000000e+00 5.000000e+00 2.794000e-01 8.274204e-03 8.274204e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.820000e-01 5.585947e-03 5.585947e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 1.197000e-01 3.735714e-03 3.735714e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 8.232000e-02 2.630378e-03 2.630378e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 4.620000e-02 1.427722e-03 1.427722e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 1.809000e-02 5.540386e-04 5.540386e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.125000e-03 1.759749e-04 1.759749e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 1.985000e-04 7.437793e-06 7.437793e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d33-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d33-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.573000e+00 5.036057e-02 5.036057e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 3.252000e+00 9.674358e-02 9.674358e-02
	+5.000000e+00 1.000000e+00 1.000000e+00 3.321000e+00 9.699367e-02 9.699367e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 2.893000e+00 8.547824e-02 8.547824e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 2.445000e+00 7.124144e-02 7.124144e-02
	+1.150000e+01 1.500000e+00 1.500000e+00 1.991000e+00 5.770466e-02 5.770466e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 1.566000e+00 4.562949e-02 4.562949e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 1.218000e+00 3.548960e-02 3.548960e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 8.781000e-01 2.558573e-02 2.558573e-02
	+2.750000e+01 2.500000e+00 2.500000e+00 6.368000e-01 1.886906e-02 1.886906e-02
	+3.350000e+01 3.500000e+00 3.500000e+00 4.612000e-01 1.343826e-02 1.343826e-02
	+4.100000e+01 4.000000e+00 4.000000e+00 3.094000e-01 9.141710e-03 9.141710e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 1.994000e-01 5.935291e-03 5.935291e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 1.252000e-01 3.883219e-03 3.883219e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 8.231000e-02 2.605472e-03 2.605472e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 5.541000e-02 1.859334e-03 1.859334e-03
	+9.500000e+01 1.000000e+01 1.000000e+01 3.222000e-02 1.029529e-03 1.029529e-03
	+1.275000e+02 2.250000e+01 2.250000e+01 1.257000e-02 4.002711e-04 4.002711e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 3.699000e-03 1.334719e-04 1.334719e-04
	+5.500000e+02 3.500000e+02 3.500000e+02 1.260000e-04 5.387145e-06 5.387145e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d34-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d34-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 5.292000e-01 1.989961e-02 1.989961e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 1.093000e+00 3.521428e-02 3.521428e-02
	+5.000000e+00 1.000000e+00 1.000000e+00 1.089000e+00 3.391671e-02 3.391671e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 9.406000e-01 2.986312e-02 2.986312e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 7.992000e-01 2.456809e-02 2.456809e-02
	+1.150000e+01 1.500000e+00 1.500000e+00 6.553000e-01 1.998396e-02 1.998396e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 5.106000e-01 1.583683e-02 1.583683e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 3.941000e-01 1.200550e-02 1.200550e-02
	+2.250000e+01 2.500000e+00 2.500000e+00 2.924000e-01 8.955272e-03 8.955272e-03
	+2.750000e+01 2.500000e+00 2.500000e+00 2.105000e-01 6.623228e-03 6.623228e-03
	+3.350000e+01 3.500000e+00 3.500000e+00 1.532000e-01 4.739306e-03 4.739306e-03
	+4.100000e+01 4.000000e+00 4.000000e+00 1.077000e-01 3.368101e-03 3.368101e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 7.180000e-02 2.272785e-03 2.272785e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 4.800000e-02 1.610684e-03 1.610684e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 3.136000e-02 1.164128e-03 1.164128e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 2.140000e-02 8.802661e-04 8.802661e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 1.135000e-02 4.321951e-04 4.321951e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 4.076000e-03 1.528364e-04 1.528364e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 1.138000e-03 5.785921e-05 5.785921e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 3.602000e-05 2.376501e-06 2.376501e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d35-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d35-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 4.086000e-02 1.715147e-03 1.715147e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 3.130000e-02 1.387476e-03 1.387476e-03
	+7.000000e+01 5.000000e+00 5.000000e+00 2.225000e-02 1.042193e-03 1.042193e-03
	+8.000000e+01 5.000000e+00 5.000000e+00 1.513000e-02 7.640275e-04 7.640275e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 8.673000e-03 4.458799e-04 4.458799e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.937000e-03 1.658300e-04 1.658300e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 7.172000e-04 5.362239e-05 5.362239e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.120000e-05 2.075977e-06 2.075977e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d36-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d36-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.860000e-02 1.280309e-03 1.280309e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.186000e-02 9.361594e-04 9.361594e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.530000e-02 7.281578e-04 7.281578e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 1.045000e-02 5.485006e-04 5.485006e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 6.453000e-03 3.212272e-04 3.212272e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.276000e-03 1.076719e-04 1.076719e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.281000e-04 3.829362e-05 3.829362e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.013000e-05 1.719672e-06 1.719672e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d37-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d37-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e+01 5.000000e+00 5.000000e+00 2.947000e-02 1.391346e-03 1.391346e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.098000e-02 9.368457e-04 9.368457e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.391000e-02 6.685488e-04 6.685488e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 9.795000e-03 5.120640e-04 5.120640e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.740000e-03 2.868277e-04 2.868277e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 2.021000e-03 1.048975e-04 1.048975e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 5.851000e-04 4.794251e-05 4.794251e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 1.903000e-05 2.278679e-06 2.278679e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d38-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d38-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 6.376000e-01 3.994553e-02 3.994553e-02
	+3.000000e+00 1.000000e+00 1.000000e+00 1.185000e+00 4.046389e-02 4.046389e-02
	+5.000000e+00 1.000000e+00 1.000000e+00 1.098000e+00 3.692612e-02 3.692612e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 8.903000e-01 3.013899e-02 3.013899e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 6.759000e-01 2.382008e-02 2.382008e-02
	+1.150000e+01 1.500000e+00 1.500000e+00 5.140000e-01 1.793853e-02 1.793853e-02
	+1.450000e+01 1.500000e+00 1.500000e+00 3.706000e-01 1.306069e-02 1.306069e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 2.822000e-01 9.767545e-03 9.767545e-03
	+2.250000e+01 2.500000e+00 2.500000e+00 2.036000e-01 7.126000e-03 7.126000e-03
	+2.750000e+01 2.500000e+00 2.500000e+00 1.276000e-01 4.653465e-03 4.653465e-03
	+3.350000e+01 3.500000e+00 3.500000e+00 7.188000e-02 2.876996e-03 2.876996e-03
	+4.100000e+01 4.000000e+00 4.000000e+00 4.520000e-02 2.007715e-03 2.007715e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 2.953000e-02 1.297305e-03 1.297305e-03
	+6.000000e+01 5.000000e+00 5.000000e+00 2.006000e-02 9.264593e-04 9.264593e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 1.273000e-02 6.303600e-04 6.303600e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 8.983000e-03 4.949625e-04 4.949625e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 5.513000e-03 2.684440e-04 2.684440e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 1.995000e-03 9.763278e-05 9.763278e-05
	+1.750000e+02 2.500000e+01 2.500000e+01 5.663000e-04 3.686609e-05 3.686609e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.135000e-05 1.781542e-06 1.781542e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d39-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d39-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.378000e+01 4.156903e-01 4.156903e-01
	+3.000000e+00 1.000000e+00 1.000000e+00 2.849000e+01 8.232575e-01 8.232575e-01
	+5.000000e+00 1.000000e+00 1.000000e+00 2.900000e+01 8.454880e-01 8.454880e-01
	+7.000000e+00 1.000000e+00 1.000000e+00 2.546000e+01 7.370219e-01 7.370219e-01
	+9.000000e+00 1.000000e+00 1.000000e+00 2.144000e+01 6.261802e-01 6.261802e-01
	+1.100000e+01 1.000000e+00 1.000000e+00 1.795000e+01 5.242506e-01 5.242506e-01
	+1.300000e+01 1.000000e+00 1.000000e+00 1.510000e+01 4.410131e-01 4.410131e-01
	+1.500000e+01 1.000000e+00 1.000000e+00 1.282000e+01 3.744230e-01 3.744230e-01
	+1.700000e+01 1.000000e+00 1.000000e+00 1.090000e+01 3.183472e-01 3.183472e-01
	+1.900000e+01 1.000000e+00 1.000000e+00 9.349000e+00 2.738475e-01 2.738475e-01
	+2.125000e+01 1.250000e+00 1.250000e+00 7.890000e+00 2.311110e-01 2.311110e-01
	+2.375000e+01 1.250000e+00 1.250000e+00 6.643000e+00 1.945843e-01 1.945843e-01
	+2.625000e+01 1.250000e+00 1.250000e+00 5.608000e+00 1.642675e-01 1.642675e-01
	+2.875000e+01 1.250000e+00 1.250000e+00 4.757000e+00 1.393403e-01 1.393403e-01
	+3.150000e+01 1.500000e+00 1.500000e+00 4.046000e+00 1.185140e-01 1.185140e-01
	+3.450000e+01 1.500000e+00 1.500000e+00 3.433000e+00 1.007338e-01 1.007338e-01
	+3.750000e+01 1.500000e+00 1.500000e+00 2.880000e+00 8.485010e-02 8.485010e-02
	+4.050000e+01 1.500000e+00 1.500000e+00 2.481000e+00 7.309482e-02 7.309482e-02
	+4.350000e+01 1.500000e+00 1.500000e+00 2.144000e+00 6.378175e-02 6.378175e-02
	+4.650000e+01 1.500000e+00 1.500000e+00 1.858000e+00 5.555389e-02 5.555389e-02
	+4.950000e+01 1.500000e+00 1.500000e+00 1.589000e+00 4.801305e-02 4.801305e-02
	+5.250000e+01 1.500000e+00 1.500000e+00 1.396000e+00 4.243473e-02 4.243473e-02
	+5.550000e+01 1.500000e+00 1.500000e+00 1.219000e+00 3.705439e-02 3.705439e-02
	+5.900000e+01 2.000000e+00 2.000000e+00 1.069000e+00 3.238911e-02 3.238911e-02
	+6.300000e+01 2.000000e+00 2.000000e+00 8.831000e-01 2.684392e-02 2.684392e-02
	+6.750000e+01 2.500000e+00 2.500000e+00 7.439000e-01 2.237891e-02 2.237891e-02
	+7.250000e+01 2.500000e+00 2.500000e+00 6.006000e-01 1.843363e-02 1.843363e-02
	+7.750000e+01 2.500000e+00 2.500000e+00 5.010000e-01 1.537670e-02 1.537670e-02
	+8.250000e+01 2.500000e+00 2.500000e+00 4.052000e-01 1.271708e-02 1.271708e-02
	+9.000000e+01 5.000000e+00 5.000000e+00 3.029000e-01 9.112207e-03 9.112207e-03
	+1.000000e+02 5.000000e+00 5.000000e+00 2.122000e-01 6.429345e-03 6.429345e-03
	+1.150000e+02 1.000000e+01 1.000000e+01 1.345000e-01 4.046193e-03 4.046193e-03
	+1.375000e+02 1.250000e+01 1.250000e+01 7.018000e-02 2.126350e-03 2.126350e-03
	+1.625000e+02 1.250000e+01 1.250000e+01 3.734000e-02 1.180794e-03 1.180794e-03
	+1.875000e+02 1.250000e+01 1.250000e+01 1.965000e-02 6.812630e-04 6.812630e-04
	+2.250000e+02 2.500000e+01 2.500000e+01 9.249000e-03 3.118710e-04 3.118710e-04
	+2.750000e+02 2.500000e+01 2.500000e+01 3.546000e-03 1.491851e-04 1.491851e-04
	+3.250000e+02 2.500000e+01 2.500000e+01 1.435000e-03 9.117616e-05 9.117616e-05
	+3.750000e+02 2.500000e+01 2.500000e+01 6.443000e-04 5.940851e-05 5.940851e-05
	+4.350000e+02 3.500000e+01 3.500000e+01 2.998000e-04 3.132013e-05 3.132013e-05
	+5.100000e+02 4.000000e+01 4.000000e+01 1.112000e-04 1.952154e-05 1.952154e-05
	+6.000000e+02 5.000000e+01 5.000000e+01 4.483000e-05 1.180596e-05 1.180596e-05
	+7.750000e+02 1.250000e+02 1.250000e+02 3.660000e-06 1.959522e-06 1.959522e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d40-x01-y04
	+Path=/REF/ATLAS_2015_I1408516_MU/d40-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.067000e-01 7.599707e-03 7.599707e-03
	+3.000000e+00 1.000000e+00 1.000000e+00 2.368000e-01 9.051213e-03 9.051213e-03
	+5.000000e+00 1.000000e+00 1.000000e+00 2.575000e-01 9.158461e-03 9.158461e-03
	+7.000000e+00 1.000000e+00 1.000000e+00 2.282000e-01 8.415600e-03 8.415600e-03
	+9.000000e+00 1.000000e+00 1.000000e+00 2.007000e-01 7.767894e-03 7.767894e-03
	+1.150000e+01 1.500000e+00 1.500000e+00 1.625000e-01 5.816047e-03 5.816047e-03
	+1.450000e+01 1.500000e+00 1.500000e+00 1.346000e-01 4.929007e-03 4.929007e-03
	+1.800000e+01 2.000000e+00 2.000000e+00 1.032000e-01 3.743757e-03 3.743757e-03
	+2.250000e+01 2.500000e+00 2.500000e+00 7.720000e-02 2.818593e-03 2.818593e-03
	+2.750000e+01 2.500000e+00 2.500000e+00 5.720000e-02 2.244690e-03 2.244690e-03
	+3.350000e+01 3.500000e+00 3.500000e+00 4.193000e-02 1.589473e-03 1.589473e-03
	+4.100000e+01 4.000000e+00 4.000000e+00 2.969000e-02 1.226308e-03 1.226308e-03
	+5.000000e+01 5.000000e+00 5.000000e+00 1.885000e-02 9.067614e-04 9.067614e-04
	+6.000000e+01 5.000000e+00 5.000000e+00 1.374000e-02 7.447536e-04 7.447536e-04
	+7.000000e+01 5.000000e+00 5.000000e+00 8.921000e-03 6.106814e-04 6.106814e-04
	+8.000000e+01 5.000000e+00 5.000000e+00 6.990000e-03 5.026972e-04 5.026972e-04
	+9.500000e+01 1.000000e+01 1.000000e+01 4.384000e-03 2.641337e-04 2.641337e-04
	+1.275000e+02 2.250000e+01 2.250000e+01 1.959000e-03 1.082425e-04 1.082425e-04
	+1.750000e+02 2.500000e+01 2.500000e+01 6.007000e-04 4.532798e-05 4.532798e-05
	+5.500000e+02 3.500000e+02 3.500000e+02 2.489000e-05 1.921211e-06 1.921211e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2015_I1408516_MU/d41-x01-y02
	+Path=/REF/ATLAS_2015_I1408516_MU/d41-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.600000e+01 4.000000e+00 4.000000e+00 1.450000e+00 5.581766e-02 5.581766e-02
	+2.500000e+01 5.000000e+00 5.000000e+00 1.030000e+00 4.157999e-02 4.157999e-02
	+3.800000e+01 8.000000e+00 8.000000e+00 9.900000e-01 3.747971e-02 3.747971e-02
	+5.600000e+01 1.000000e+01 1.000000e+01 1.625000e+01 5.500139e-01 5.500139e-01
	+9.100000e+01 2.500000e+01 2.500000e+01 5.242500e+02 1.522475e+01 1.522475e+01
	+1.330000e+02 1.700000e+01 1.700000e+01 5.270000e+00 1.640740e-01 1.640740e-01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1419070.yoda b/data/refdata/ATLAS_2016_I1419070.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1419070.yoda
	@@ -0,0 +1,216 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d01-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 7.874000e+00 5.273708e-01 5.333554e-01
	+1.500000e+02 5.000000e+01 5.000000e+01 9.870000e+00 3.505153e-01 3.595024e-01
	+2.500000e+02 5.000000e+01 5.000000e+01 1.218600e+01 1.165204e-01 1.454166e-01
	+3.500000e+02 5.000000e+01 5.000000e+01 1.353900e+01 1.501632e-01 1.901289e-01
	+4.500000e+02 5.000000e+01 5.000000e+01 1.458600e+01 1.270984e-01 2.470506e-01
	+5.500000e+02 5.000000e+01 5.000000e+01 1.541400e+01 1.252557e-01 2.391339e-01
	+7.000000e+02 1.000000e+02 1.000000e+02 1.627500e+01 1.236851e-01 2.403518e-01
	+9.000000e+02 1.000000e+02 1.000000e+02 1.741300e+01 1.113598e-01 2.518134e-01
	+1.100000e+03 1.000000e+02 1.000000e+02 1.825300e+01 1.387083e-01 2.653846e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.871500e+01 2.410850e-01 7.361807e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 2.077800e+01 8.278871e-01 1.087399e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d02-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 4.930000e+00 3.189044e-01 3.199015e-01
	+1.500000e+02 5.000000e+01 5.000000e+01 6.885000e+00 2.623223e-01 2.663175e-01
	+2.500000e+02 5.000000e+01 5.000000e+01 9.161000e+00 9.924717e-02 1.152128e-01
	+3.500000e+02 5.000000e+01 5.000000e+01 1.055400e+01 1.201499e-01 1.511192e-01
	+4.500000e+02 5.000000e+01 5.000000e+01 1.161200e+01 1.110720e-01 1.990402e-01
	+5.500000e+02 5.000000e+01 5.000000e+01 1.246100e+01 1.062309e-01 1.961250e-01
	+7.000000e+02 1.000000e+02 1.000000e+02 1.335500e+01 1.074663e-01 1.992511e-01
	+9.000000e+02 1.000000e+02 1.000000e+02 1.453400e+01 9.861541e-02 2.124265e-01
	+1.100000e+03 1.000000e+02 1.000000e+02 1.540000e+01 1.230691e-01 2.253220e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.605300e+01 2.096592e-01 6.283447e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 1.796400e+01 6.843223e-01 9.196314e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d03-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 2.430000e+00 1.836981e-01 1.817058e-01
	+1.500000e+02 5.000000e+01 5.000000e+01 4.036000e+00 1.362351e-01 1.392300e-01
	+2.500000e+02 5.000000e+01 5.000000e+01 6.045000e+00 6.618912e-02 7.816009e-02
	+3.500000e+02 5.000000e+01 5.000000e+01 7.368000e+00 8.709191e-02 1.060754e-01
	+4.500000e+02 5.000000e+01 5.000000e+01 8.377000e+00 8.505292e-02 1.460308e-01
	+5.500000e+02 5.000000e+01 5.000000e+01 9.194000e+00 8.315047e-02 1.500833e-01
	+7.000000e+02 1.000000e+02 1.000000e+02 1.006500e+01 8.637129e-02 1.522104e-01
	+9.000000e+02 1.000000e+02 1.000000e+02 1.122700e+01 7.854935e-02 1.675291e-01
	+1.100000e+03 1.000000e+02 1.000000e+02 1.208500e+01 9.617692e-02 1.780842e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.277400e+01 1.794241e-01 5.047772e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 1.485600e+01 5.849991e-01 7.837244e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d04-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 7.913000e+00 4.824210e-01 4.814239e-01
	+1.500000e+02 5.000000e+01 5.000000e+01 1.023300e+01 3.744823e-01 3.814735e-01
	+2.500000e+02 5.000000e+01 5.000000e+01 1.289900e+01 1.116468e-01 1.285613e-01
	+3.500000e+02 5.000000e+01 5.000000e+01 1.456500e+01 1.452205e-01 1.691892e-01
	+4.500000e+02 5.000000e+01 5.000000e+01 1.569900e+01 9.812747e-02 2.350532e-01
	+5.500000e+02 5.000000e+01 5.000000e+01 1.653400e+01 8.348653e-02 2.241807e-01
	+7.000000e+02 1.000000e+02 1.000000e+02 1.728000e+01 7.864477e-02 2.265657e-01
	+9.000000e+02 1.000000e+02 1.000000e+02 1.816800e+01 7.242237e-02 2.347871e-01
	+1.100000e+03 1.000000e+02 1.000000e+02 1.888400e+01 1.252996e-01 2.593935e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.904800e+01 2.296541e-01 7.428923e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 2.031700e+01 6.777382e-01 9.574393e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d05-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 4.955000e+00 2.948983e-01 2.899138e-01
	+1.500000e+02 5.000000e+01 5.000000e+01 7.057000e+00 2.672695e-01 2.712656e-01
	+2.500000e+02 5.000000e+01 5.000000e+01 9.639000e+00 9.625487e-02 1.042353e-01
	+3.500000e+02 5.000000e+01 5.000000e+01 1.127200e+01 1.071681e-01 1.251439e-01
	+4.500000e+02 5.000000e+01 5.000000e+01 1.242800e+01 8.309633e-02 1.890423e-01
	+5.500000e+02 5.000000e+01 5.000000e+01 1.330400e+01 7.034913e-02 1.791368e-01
	+7.000000e+02 1.000000e+02 1.000000e+02 1.412100e+01 6.844706e-02 1.855290e-01
	+9.000000e+02 1.000000e+02 1.000000e+02 1.512400e+01 6.519202e-02 1.951640e-01
	+1.100000e+03 1.000000e+02 1.000000e+02 1.593200e+01 1.156936e-01 2.241830e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.617900e+01 2.140023e-01 6.448108e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 1.745100e+01 5.929123e-01 8.414999e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d06-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 2.407000e+00 1.636001e-01 1.586190e-01
	+1.500000e+02 5.000000e+01 5.000000e+01 4.074000e+00 1.412268e-01 1.452205e-01
	+2.500000e+02 5.000000e+01 5.000000e+01 6.265000e+00 6.220129e-02 6.818358e-02
	+3.500000e+02 5.000000e+01 5.000000e+01 7.758000e+00 7.211103e-02 8.409518e-02
	+4.500000e+02 5.000000e+01 5.000000e+01 8.856000e+00 5.807753e-02 1.330338e-01
	+5.500000e+02 5.000000e+01 5.000000e+01 9.726000e+00 5.522681e-02 1.310954e-01
	+7.000000e+02 1.000000e+02 1.000000e+02 1.056400e+01 4.981967e-02 1.382932e-01
	+9.000000e+02 1.000000e+02 1.000000e+02 1.162100e+01 5.283938e-02 1.512514e-01
	+1.100000e+03 1.000000e+02 1.000000e+02 1.244900e+01 8.681590e-02 1.757555e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.284400e+01 1.593047e-01 5.059743e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 1.392900e+01 4.892627e-01 6.894295e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d07-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 3.900000e-02 8.605231e-02 7.924645e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 3.630000e-01 6.407808e-02 6.685058e-02
	+2.500000e+02 5.000000e+01 5.000000e+01 7.130000e-01 5.824088e-02 5.728001e-02
	+3.500000e+02 5.000000e+01 5.000000e+01 1.026000e+00 6.987131e-02 6.198387e-02
	+4.500000e+02 5.000000e+01 5.000000e+01 1.113000e+00 6.228965e-02 6.228965e-02
	+5.500000e+02 5.000000e+01 5.000000e+01 1.120000e+00 7.990620e-02 7.990620e-02
	+7.000000e+02 1.000000e+02 1.000000e+02 1.005000e+00 8.343261e-02 8.537564e-02
	+9.000000e+02 1.000000e+02 1.000000e+02 7.550000e-01 1.145469e-01 9.859513e-02
	+1.100000e+03 1.000000e+02 1.000000e+02 6.320000e-01 1.574960e-01 1.638566e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 3.330000e-01 3.127075e-01 3.102805e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 -4.610000e-01 1.118122e+00 1.122320e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d08-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 2.500000e-02 4.780167e-02 4.101219e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 1.720000e-01 4.531004e-02 5.092151e-02
	+2.500000e+02 5.000000e+01 5.000000e+01 4.780000e-01 4.535416e-02 4.827007e-02
	+3.500000e+02 5.000000e+01 5.000000e+01 7.180000e-01 5.656854e-02 4.866210e-02
	+4.500000e+02 5.000000e+01 5.000000e+01 8.170000e-01 5.423099e-02 5.721888e-02
	+5.500000e+02 5.000000e+01 5.000000e+01 8.430000e-01 6.972087e-02 6.576473e-02
	+7.000000e+02 1.000000e+02 1.000000e+02 7.660000e-01 7.375636e-02 7.473286e-02
	+9.000000e+02 1.000000e+02 1.000000e+02 5.900000e-01 9.541488e-02 8.324062e-02
	+1.100000e+03 1.000000e+02 1.000000e+02 5.320000e-01 1.392049e-01 1.450138e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.260000e-01 2.849860e-01 2.826606e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 -5.140000e-01 9.187192e-01 9.209587e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d09-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 -2.300000e-02 2.973214e-02 3.182766e-02
	+1.500000e+02 5.000000e+01 5.000000e+01 3.800000e-02 3.257299e-02 3.736308e-02
	+2.500000e+02 5.000000e+01 5.000000e+01 2.200000e-01 3.395585e-02 3.395585e-02
	+3.500000e+02 5.000000e+01 5.000000e+01 3.900000e-01 4.229657e-02 3.931921e-02
	+4.500000e+02 5.000000e+01 5.000000e+01 4.790000e-01 4.310452e-02 4.709565e-02
	+5.500000e+02 5.000000e+01 5.000000e+01 5.320000e-01 5.742822e-02 5.147815e-02
	+7.000000e+02 1.000000e+02 1.000000e+02 4.990000e-01 5.629387e-02 5.922837e-02
	+9.000000e+02 1.000000e+02 1.000000e+02 3.940000e-01 7.443118e-02 6.360031e-02
	+1.100000e+03 1.000000e+02 1.000000e+02 3.640000e-01 1.100727e-01 1.146124e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 6.900000e-02 2.347765e-01 2.338547e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 -9.270000e-01 7.629843e-01 7.686722e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d10-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 7.893000e+00 5.028956e-01 5.058903e-01
	+1.500000e+02 5.000000e+01 5.000000e+01 1.005100e+01 3.613115e-01 3.693048e-01
	+2.500000e+02 5.000000e+01 5.000000e+01 1.254200e+01 1.123610e-01 1.352997e-01
	+3.500000e+02 5.000000e+01 5.000000e+01 1.404900e+01 1.480844e-01 1.800694e-01
	+4.500000e+02 5.000000e+01 5.000000e+01 1.514200e+01 1.150695e-01 2.410332e-01
	+5.500000e+02 5.000000e+01 5.000000e+01 1.597500e+01 1.051713e-01 2.300782e-01
	+7.000000e+02 1.000000e+02 1.000000e+02 1.677900e+01 1.014938e-01 2.322154e-01
	+9.000000e+02 1.000000e+02 1.000000e+02 1.779300e+01 8.523497e-02 2.381596e-01
	+1.100000e+03 1.000000e+02 1.000000e+02 1.857400e+01 1.033925e-01 2.501460e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.888000e+01 1.644384e-01 7.201007e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 2.054000e+01 4.737816e-01 8.362135e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d11-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d11-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 4.942000e+00 3.065893e-01 3.035951e-01
	+1.500000e+02 5.000000e+01 5.000000e+01 6.971000e+00 2.631539e-01 2.681511e-01
	+2.500000e+02 5.000000e+01 5.000000e+01 9.400000e+00 9.613012e-02 1.091146e-01
	+3.500000e+02 5.000000e+01 5.000000e+01 1.091100e+01 1.140702e-01 1.380580e-01
	+4.500000e+02 5.000000e+01 5.000000e+01 1.201900e+01 9.804591e-02 1.940232e-01
	+5.500000e+02 5.000000e+01 5.000000e+01 1.288300e+01 8.914034e-02 1.860672e-01
	+7.000000e+02 1.000000e+02 1.000000e+02 1.373900e+01 8.736704e-02 1.901683e-01
	+9.000000e+02 1.000000e+02 1.000000e+02 1.483100e+01 7.689603e-02 1.998324e-01
	+1.100000e+03 1.000000e+02 1.000000e+02 1.567000e+01 9.055385e-02 2.115585e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.611500e+01 1.445579e-01 6.161956e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 1.769900e+01 4.436496e-01 7.499287e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419070/d12-x01-y01
	+Path=/REF/ATLAS_2016_I1419070/d12-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e+01 2.500000e+01 2.500000e+01 2.418000e+00 1.733494e-01 1.703555e-01
	+1.500000e+02 5.000000e+01 5.000000e+01 4.055000e+00 1.381304e-01 1.411276e-01
	+2.500000e+02 5.000000e+01 5.000000e+01 6.155000e+00 6.307139e-02 7.206247e-02
	+3.500000e+02 5.000000e+01 5.000000e+01 7.562000e+00 7.905694e-02 9.504736e-02
	+4.500000e+02 5.000000e+01 5.000000e+01 8.616000e+00 7.202777e-02 1.390144e-01
	+5.500000e+02 5.000000e+01 5.000000e+01 9.460000e+00 6.911584e-02 1.390575e-01
	+7.000000e+02 1.000000e+02 1.000000e+02 1.031500e+01 6.726812e-02 1.441249e-01
	+9.000000e+02 1.000000e+02 1.000000e+02 1.142500e+01 6.135145e-02 1.562850e-01
	+1.100000e+03 1.000000e+02 1.000000e+02 1.227000e+01 7.433034e-02 1.691892e-01
	+1.350000e+03 1.500000e+02 1.500000e+02 1.280900e+01 1.112340e-01 4.889714e-01
	+1.650000e+03 1.500000e+02 1.500000e+02 1.437800e+01 3.635629e-01 6.186057e-01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1419652.yoda b/data/refdata/ATLAS_2016_I1419652.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1419652.yoda
	@@ -0,0 +1,904 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d01-x01-y01
	+Path=/REF/ATLAS_2016_I1419652/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 8.067000e-02 3.400027e-03 3.401026e-03
	+2.000000e+00 5.000000e-01 5.000000e-01 8.245000e-02 1.888022e-03 1.889022e-03
	+3.000000e+00 5.000000e-01 5.000000e-01 7.496000e-02 9.752560e-04 9.760549e-04
	+4.000000e+00 5.000000e-01 5.000000e-01 6.445000e-02 3.923413e-04 3.930370e-04
	+5.000000e+00 5.000000e-01 5.000000e-01 5.476000e-02 2.464073e-04 2.451227e-04
	+6.000000e+00 5.000000e-01 5.000000e-01 4.714000e-02 1.688208e-04 1.577589e-04
	+7.000000e+00 5.000000e-01 5.000000e-01 4.117000e-02 1.192081e-04 1.111927e-04
	+8.000000e+00 5.000000e-01 5.000000e-01 3.655000e-02 9.127394e-05 8.427662e-05
	+9.000000e+00 5.000000e-01 5.000000e-01 3.298000e-02 7.410317e-05 7.530887e-05
	+1.000000e+01 5.000000e-01 5.000000e-01 3.013000e-02 5.911554e-05 7.428201e-05
	+1.100000e+01 5.000000e-01 5.000000e-01 2.778000e-02 4.913538e-05 6.861869e-05
	+1.200000e+01 5.000000e-01 5.000000e-01 2.583000e-02 4.421650e-05 5.389847e-05
	+1.300000e+01 5.000000e-01 5.000000e-01 2.404000e-02 3.948652e-05 3.698231e-05
	+1.400000e+01 5.000000e-01 5.000000e-01 2.235000e-02 3.232366e-05 2.476274e-05
	+1.500000e+01 5.000000e-01 5.000000e-01 2.089000e-02 2.366967e-05 1.932285e-05
	+1.600000e+01 5.000000e-01 5.000000e-01 1.957000e-02 1.778095e-05 1.799906e-05
	+1.700000e+01 5.000000e-01 5.000000e-01 1.838000e-02 1.751014e-05 1.944865e-05
	+1.800000e+01 5.000000e-01 5.000000e-01 1.727000e-02 1.964510e-05 2.392373e-05
	+1.900000e+01 5.000000e-01 5.000000e-01 1.626000e-02 2.421904e-05 2.760568e-05
	+2.000000e+01 5.000000e-01 5.000000e-01 1.540000e-02 3.134114e-05 3.018710e-05
	+2.100000e+01 5.000000e-01 5.000000e-01 1.454000e-02 4.031064e-05 3.247422e-05
	+2.200000e+01 5.000000e-01 5.000000e-01 1.373000e-02 4.957660e-05 3.501481e-05
	+2.300000e+01 5.000000e-01 5.000000e-01 1.298000e-02 5.778055e-05 3.875542e-05
	+2.400000e+01 5.000000e-01 5.000000e-01 1.220000e-02 6.248102e-05 4.398013e-05
	+2.500000e+01 5.000000e-01 5.000000e-01 1.154000e-02 6.553834e-05 5.098190e-05
	+2.600000e+01 5.000000e-01 5.000000e-01 1.092000e-02 6.788200e-05 5.809186e-05
	+2.700000e+01 5.000000e-01 5.000000e-01 1.028000e-02 7.007261e-05 6.375624e-05
	+2.800000e+01 5.000000e-01 5.000000e-01 9.739000e-03 7.378801e-05 6.832766e-05
	+2.900000e+01 5.000000e-01 5.000000e-01 9.188000e-03 7.739139e-05 7.110950e-05
	+3.000000e+01 5.000000e-01 5.000000e-01 8.704000e-03 8.080073e-05 7.342951e-05
	+3.100000e+01 5.000000e-01 5.000000e-01 8.184000e-03 8.313128e-05 7.487915e-05
	+3.200000e+01 5.000000e-01 5.000000e-01 7.716000e-03 8.537997e-05 7.664389e-05
	+3.300000e+01 5.000000e-01 5.000000e-01 7.297000e-03 8.755951e-05 7.866833e-05
	+3.400000e+01 5.000000e-01 5.000000e-01 6.906000e-03 8.863485e-05 8.121113e-05
	+3.500000e+01 5.000000e-01 5.000000e-01 6.509000e-03 8.893725e-05 8.389940e-05
	+3.600000e+01 5.000000e-01 5.000000e-01 6.115000e-03 8.772310e-05 8.641830e-05
	+3.700000e+01 5.000000e-01 5.000000e-01 5.774000e-03 8.617637e-05 8.940455e-05
	+3.800000e+01 5.000000e-01 5.000000e-01 5.429000e-03 8.405995e-05 9.126540e-05
	+3.900000e+01 5.000000e-01 5.000000e-01 5.124000e-03 8.251507e-05 9.255297e-05
	+4.000000e+01 5.000000e-01 5.000000e-01 4.823000e-03 8.144761e-05 9.251431e-05
	+4.100000e+01 5.000000e-01 5.000000e-01 4.547000e-03 8.134906e-05 9.124090e-05
	+4.200000e+01 5.000000e-01 5.000000e-01 4.273000e-03 8.179996e-05 8.899052e-05
	+4.300000e+01 5.000000e-01 5.000000e-01 3.996000e-03 8.178942e-05 8.588892e-05
	+4.400000e+01 5.000000e-01 5.000000e-01 3.809000e-03 8.382445e-05 8.390426e-05
	+4.500000e+01 5.000000e-01 5.000000e-01 3.554000e-03 8.330047e-05 8.130516e-05
	+4.600000e+01 5.000000e-01 5.000000e-01 3.345000e-03 8.296794e-05 7.989480e-05
	+4.700000e+01 5.000000e-01 5.000000e-01 3.140000e-03 8.163712e-05 7.888297e-05
	+4.800000e+01 5.000000e-01 5.000000e-01 2.940000e-03 7.953902e-05 7.789238e-05
	+4.900000e+01 5.000000e-01 5.000000e-01 2.734000e-03 7.647199e-05 7.649195e-05
	+5.000000e+01 5.000000e-01 5.000000e-01 2.575000e-03 7.457592e-05 7.582352e-05
	+5.100000e+01 5.000000e-01 5.000000e-01 2.373000e-03 7.092748e-05 7.339285e-05
	+5.200000e+01 5.000000e-01 5.000000e-01 2.250000e-03 6.970425e-05 7.263881e-05
	+5.300000e+01 5.000000e-01 5.000000e-01 2.099000e-03 6.705810e-05 7.049185e-05
	+5.400000e+01 5.000000e-01 5.000000e-01 1.955000e-03 6.422301e-05 6.790632e-05
	+5.500000e+01 5.000000e-01 5.000000e-01 1.823000e-03 6.163811e-05 6.563091e-05
	+5.600000e+01 5.000000e-01 5.000000e-01 1.717000e-03 5.962442e-05 6.358727e-05
	+5.700000e+01 5.000000e-01 5.000000e-01 1.611000e-03 5.735166e-05 6.160394e-05
	+5.800000e+01 5.000000e-01 5.000000e-01 1.481000e-03 5.431614e-05 5.847857e-05
	+5.900000e+01 5.000000e-01 5.000000e-01 1.398000e-03 5.273298e-05 5.684552e-05
	+6.000000e+01 5.000000e-01 5.000000e-01 1.305000e-03 5.074954e-05 5.462247e-05
	+6.148000e+01 9.800000e-01 1.020000e+00 1.174000e-03 4.794663e-05 5.135353e-05
	+6.348000e+01 9.800000e-01 1.020000e+00 1.011000e-03 4.422275e-05 4.680039e-05
	+6.548000e+01 9.800000e-01 1.020000e+00 8.774000e-04 4.084990e-05 4.312779e-05
	+6.748000e+01 9.800000e-01 1.020000e+00 7.577000e-04 3.731698e-05 3.945498e-05
	+6.948000e+01 9.800000e-01 1.020000e+00 6.470000e-04 3.375420e-05 3.581223e-05
	+7.148000e+01 9.800000e-01 1.020000e+00 5.519000e-04 3.035171e-05 3.254956e-05
	+7.348000e+01 9.800000e-01 1.020000e+00 4.818000e-04 2.808020e-05 3.007819e-05
	+7.548000e+01 9.800000e-01 1.020000e+00 4.112000e-04 2.526804e-05 2.707616e-05
	+7.748000e+01 9.800000e-01 1.020000e+00 3.486000e-04 2.246607e-05 2.414426e-05
	+7.947000e+01 9.700000e-01 1.030000e+00 2.965000e-04 1.996480e-05 2.135319e-05
	+8.148000e+01 9.800000e-01 1.020000e+00 2.516000e-04 1.752360e-05 1.877203e-05
	+8.347000e+01 9.700000e-01 1.030000e+00 2.116000e-04 1.522230e-05 1.617099e-05
	+8.547000e+01 9.700000e-01 1.030000e+00 1.790000e-04 1.331137e-05 1.389047e-05
	+8.747000e+01 9.700000e-01 1.030000e+00 1.516000e-04 1.166049e-05 1.188011e-05
	+8.947000e+01 9.700000e-01 1.030000e+00 1.310000e-04 1.040996e-05 1.053971e-05
	+9.284000e+01 2.340000e+00 2.660000e+00 9.833000e-05 8.455202e-06 8.490172e-06
	+9.783000e+01 2.330000e+00 2.670000e+00 6.325000e-05 5.894367e-06 6.420845e-06
	+1.048000e+02 4.300000e+00 5.700000e+00 3.315000e-05 3.122038e-06 3.772514e-06
	+1.148000e+02 4.300000e+00 5.700000e+00 1.362000e-05 1.501497e-06 1.784101e-06
	+1.247000e+02 4.200000e+00 5.800000e+00 5.350000e-06 7.749572e-07 9.417277e-07
	+1.374000e+02 6.900000e+00 1.310000e+01 1.163000e-06 1.894367e-07 2.264160e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d01-x01-y02
	+Path=/REF/ATLAS_2016_I1419652/d01-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 7.837000e-02 3.321995e-03 3.321995e-03
	+2.000000e+00 5.000000e-01 5.000000e-01 8.084000e-02 1.876993e-03 1.877993e-03
	+3.000000e+00 5.000000e-01 5.000000e-01 7.390000e-02 9.755241e-04 9.763230e-04
	+4.000000e+00 5.000000e-01 5.000000e-01 6.382000e-02 3.945907e-04 3.952864e-04
	+5.000000e+00 5.000000e-01 5.000000e-01 5.446000e-02 2.549860e-04 2.537991e-04
	+6.000000e+00 5.000000e-01 5.000000e-01 4.704000e-02 1.997913e-04 1.906275e-04
	+7.000000e+00 5.000000e-01 5.000000e-01 4.116000e-02 1.714259e-04 1.659146e-04
	+8.000000e+00 5.000000e-01 5.000000e-01 3.657000e-02 1.365407e-04 1.319384e-04
	+9.000000e+00 5.000000e-01 5.000000e-01 3.298000e-02 1.003691e-04 1.012698e-04
	+1.000000e+01 5.000000e-01 5.000000e-01 3.010000e-02 7.648463e-05 8.871091e-05
	+1.100000e+01 5.000000e-01 5.000000e-01 2.772000e-02 9.759128e-05 1.086324e-04
	+1.200000e+01 5.000000e-01 5.000000e-01 2.575000e-02 1.059498e-04 1.102680e-04
	+1.300000e+01 5.000000e-01 5.000000e-01 2.397000e-02 1.024973e-04 1.015847e-04
	+1.400000e+01 5.000000e-01 5.000000e-01 2.229000e-02 9.997785e-05 9.780713e-05
	+1.500000e+01 5.000000e-01 5.000000e-01 2.083000e-02 1.020381e-04 1.010927e-04
	+1.600000e+01 5.000000e-01 5.000000e-01 1.950000e-02 1.081148e-04 1.081148e-04
	+1.700000e+01 5.000000e-01 5.000000e-01 1.831000e-02 1.117614e-04 1.120583e-04
	+1.800000e+01 5.000000e-01 5.000000e-01 1.721000e-02 1.115597e-04 1.123521e-04
	+1.900000e+01 5.000000e-01 5.000000e-01 1.620000e-02 1.081041e-04 1.088967e-04
	+2.000000e+01 5.000000e-01 5.000000e-01 1.534000e-02 1.063443e-04 1.059478e-04
	+2.100000e+01 5.000000e-01 5.000000e-01 1.449000e-02 1.183838e-04 1.159007e-04
	+2.200000e+01 5.000000e-01 5.000000e-01 1.368000e-02 1.300594e-04 1.252847e-04
	+2.300000e+01 5.000000e-01 5.000000e-01 1.293000e-02 1.374786e-04 1.307087e-04
	+2.400000e+01 5.000000e-01 5.000000e-01 1.216000e-02 1.377264e-04 1.303563e-04
	+2.500000e+01 5.000000e-01 5.000000e-01 1.151000e-02 1.363959e-04 1.301199e-04
	+2.600000e+01 5.000000e-01 5.000000e-01 1.090000e-02 1.323755e-04 1.275934e-04
	+2.700000e+01 5.000000e-01 5.000000e-01 1.027000e-02 1.257629e-04 1.223757e-04
	+2.800000e+01 5.000000e-01 5.000000e-01 9.735000e-03 1.265298e-04 1.234406e-04
	+2.900000e+01 5.000000e-01 5.000000e-01 9.187000e-03 1.323813e-04 1.287919e-04
	+3.000000e+01 5.000000e-01 5.000000e-01 8.709000e-03 1.362446e-04 1.319558e-04
	+3.100000e+01 5.000000e-01 5.000000e-01 8.201000e-03 1.306336e-04 1.255472e-04
	+3.200000e+01 5.000000e-01 5.000000e-01 7.746000e-03 1.221312e-04 1.161483e-04
	+3.300000e+01 5.000000e-01 5.000000e-01 7.334000e-03 1.188203e-04 1.123389e-04
	+3.400000e+01 5.000000e-01 5.000000e-01 6.944000e-03 1.193968e-04 1.139111e-04
	+3.500000e+01 5.000000e-01 5.000000e-01 6.548000e-03 1.197770e-04 1.160858e-04
	+3.600000e+01 5.000000e-01 5.000000e-01 6.158000e-03 1.194561e-04 1.185580e-04
	+3.700000e+01 5.000000e-01 5.000000e-01 5.828000e-03 1.175465e-04 1.199416e-04
	+3.800000e+01 5.000000e-01 5.000000e-01 5.491000e-03 1.121395e-04 1.177281e-04
	+3.900000e+01 5.000000e-01 5.000000e-01 5.188000e-03 1.090314e-04 1.170155e-04
	+4.000000e+01 5.000000e-01 5.000000e-01 4.895000e-03 1.042260e-04 1.133079e-04
	+4.100000e+01 5.000000e-01 5.000000e-01 4.632000e-03 9.889539e-05 1.075073e-04
	+4.200000e+01 5.000000e-01 5.000000e-01 4.364000e-03 9.600745e-05 1.025036e-04
	+4.300000e+01 5.000000e-01 5.000000e-01 4.091000e-03 9.163000e-05 9.548151e-05
	+4.400000e+01 5.000000e-01 5.000000e-01 3.911000e-03 9.088420e-05 9.097400e-05
	+4.500000e+01 5.000000e-01 5.000000e-01 3.659000e-03 9.066075e-05 8.872492e-05
	+4.600000e+01 5.000000e-01 5.000000e-01 3.453000e-03 8.992993e-05 8.691619e-05
	+4.700000e+01 5.000000e-01 5.000000e-01 3.256000e-03 8.726432e-05 8.449005e-05
	+4.800000e+01 5.000000e-01 5.000000e-01 3.062000e-03 8.675456e-05 8.512772e-05
	+4.900000e+01 5.000000e-01 5.000000e-01 2.854000e-03 8.329836e-05 8.331833e-05
	+5.000000e+01 5.000000e-01 5.000000e-01 2.697000e-03 8.290020e-05 8.413798e-05
	+5.100000e+01 5.000000e-01 5.000000e-01 2.500000e-03 8.240834e-05 8.477447e-05
	+5.200000e+01 5.000000e-01 5.000000e-01 2.380000e-03 8.083681e-05 8.367216e-05
	+5.300000e+01 5.000000e-01 5.000000e-01 2.228000e-03 7.743215e-05 8.080663e-05
	+5.400000e+01 5.000000e-01 5.000000e-01 2.085000e-03 7.745360e-05 8.094826e-05
	+5.500000e+01 5.000000e-01 5.000000e-01 1.954000e-03 7.865361e-05 8.226861e-05
	+5.600000e+01 5.000000e-01 5.000000e-01 1.850000e-03 7.965688e-05 8.314239e-05
	+5.700000e+01 5.000000e-01 5.000000e-01 1.742000e-03 7.749439e-05 8.121960e-05
	+5.800000e+01 5.000000e-01 5.000000e-01 1.608000e-03 7.312027e-05 7.681544e-05
	+5.900000e+01 5.000000e-01 5.000000e-01 1.526000e-03 7.224786e-05 7.587317e-05
	+6.000000e+01 5.000000e-01 5.000000e-01 1.432000e-03 7.041446e-05 7.382009e-05
	+6.148000e+01 9.800000e-01 1.020000e+00 1.297000e-03 6.785428e-05 7.082242e-05
	+6.348000e+01 9.800000e-01 1.020000e+00 1.128000e-03 6.488050e-05 6.708916e-05
	+6.548000e+01 9.800000e-01 1.020000e+00 9.889000e-04 6.231720e-05 6.423609e-05
	+6.748000e+01 9.800000e-01 1.020000e+00 8.648000e-04 5.991413e-05 6.167316e-05
	+6.948000e+01 9.800000e-01 1.020000e+00 7.474000e-04 5.623164e-05 5.790072e-05
	+7.148000e+01 9.800000e-01 1.020000e+00 6.434000e-04 5.088989e-05 5.269887e-05
	+7.348000e+01 9.800000e-01 1.020000e+00 5.672000e-04 4.746917e-05 4.913818e-05
	+7.548000e+01 9.800000e-01 1.020000e+00 4.900000e-04 4.383738e-05 4.533647e-05
	+7.748000e+01 9.800000e-01 1.020000e+00 4.220000e-04 4.096546e-05 4.234463e-05
	+7.947000e+01 9.700000e-01 1.030000e+00 3.643000e-04 3.896388e-05 4.006323e-05
	+8.148000e+01 9.800000e-01 1.020000e+00 3.124000e-04 3.543245e-05 3.641184e-05
	+8.347000e+01 9.700000e-01 1.030000e+00 2.654000e-04 3.189154e-05 3.261107e-05
	+8.547000e+01 9.700000e-01 1.030000e+00 2.269000e-04 2.854052e-05 2.898021e-05
	+8.747000e+01 9.700000e-01 1.030000e+00 1.946000e-04 2.581016e-05 2.598003e-05
	+8.947000e+01 9.700000e-01 1.030000e+00 1.703000e-04 2.378974e-05 2.388966e-05
	+9.284000e+01 2.340000e+00 2.660000e+00 1.306000e-04 1.996740e-05 1.998740e-05
	+9.783000e+01 2.330000e+00 2.670000e+00 8.722000e-05 1.515698e-05 1.555681e-05
	+1.048000e+02 4.300000e+00 5.700000e+00 4.773000e-05 9.122495e-06 9.618315e-06
	+1.148000e+02 4.300000e+00 5.700000e+00 2.071000e-05 4.601463e-06 4.829300e-06
	+1.247000e+02 4.200000e+00 5.800000e+00 8.720000e-06 2.405685e-06 2.559463e-06
	+1.374000e+02 6.900000e+00 1.310000e+01 2.024000e-06 6.560102e-07 6.906192e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d01-x02-y01
	+Path=/REF/ATLAS_2016_I1419652/d01-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 2.131000e-01 4.447857e-03 4.439862e-03
	+2.000000e+00 5.000000e-01 5.000000e-01 1.531000e-01 6.236230e-04 6.041188e-04
	+3.000000e+00 5.000000e-01 5.000000e-01 1.118000e-01 4.231034e-04 4.088767e-04
	+4.000000e+00 5.000000e-01 5.000000e-01 8.655000e-02 2.214408e-04 2.105743e-04
	+5.000000e+00 5.000000e-01 5.000000e-01 6.984000e-02 1.018283e-04 9.605823e-05
	+6.000000e+00 5.000000e-01 5.000000e-01 5.781000e-02 5.559015e-05 6.193242e-05
	+7.000000e+00 5.000000e-01 5.000000e-01 4.833000e-02 4.737575e-05 4.193783e-05
	+8.000000e+00 5.000000e-01 5.000000e-01 4.079000e-02 7.827867e-05 4.669683e-05
	+9.000000e+00 5.000000e-01 5.000000e-01 3.453000e-02 1.073591e-04 7.939970e-05
	+1.000000e+01 5.000000e-01 5.000000e-01 2.922000e-02 1.414573e-04 1.065297e-04
	+1.100000e+01 5.000000e-01 5.000000e-01 2.478000e-02 1.543272e-04 1.389887e-04
	+1.200000e+01 5.000000e-01 5.000000e-01 2.102000e-02 1.574538e-04 1.563668e-04
	+1.300000e+01 5.000000e-01 5.000000e-01 1.775000e-02 1.598727e-04 1.620527e-04
	+1.400000e+01 5.000000e-01 5.000000e-01 1.499000e-02 1.585102e-04 1.646647e-04
	+1.500000e+01 5.000000e-01 5.000000e-01 1.267000e-02 1.524242e-04 1.626593e-04
	+1.600000e+01 5.000000e-01 5.000000e-01 1.067000e-02 1.460734e-04 1.566143e-04
	+1.700000e+01 5.000000e-01 5.000000e-01 8.956000e-03 1.389472e-04 1.486979e-04
	+1.800000e+01 5.000000e-01 5.000000e-01 7.536000e-03 1.302534e-04 1.407046e-04
	+1.900000e+01 5.000000e-01 5.000000e-01 6.274000e-03 1.193728e-04 1.312209e-04
	+2.000000e+01 5.000000e-01 5.000000e-01 5.263000e-03 1.096118e-04 1.226571e-04
	+2.100000e+01 5.000000e-01 5.000000e-01 4.408000e-03 1.008560e-04 1.130068e-04
	+2.200000e+01 5.000000e-01 5.000000e-01 3.688000e-03 9.308810e-05 1.039652e-04
	+2.300000e+01 5.000000e-01 5.000000e-01 3.051000e-03 8.376563e-05 9.542081e-05
	+2.400000e+01 5.000000e-01 5.000000e-01 2.514000e-03 7.409122e-05 8.606498e-05
	+2.500000e+01 5.000000e-01 5.000000e-01 2.066000e-03 6.489274e-05 7.640695e-05
	+2.600000e+01 5.000000e-01 5.000000e-01 1.687000e-03 5.623732e-05 6.658406e-05
	+2.700000e+01 5.000000e-01 5.000000e-01 1.395000e-03 4.975785e-05 5.799109e-05
	+2.800000e+01 5.000000e-01 5.000000e-01 1.142000e-03 4.338484e-05 5.072073e-05
	+2.900000e+01 5.000000e-01 5.000000e-01 9.266000e-04 3.703707e-05 4.437103e-05
	+3.000000e+01 5.000000e-01 5.000000e-01 7.858000e-04 3.275251e-05 4.023281e-05
	+3.100000e+01 5.000000e-01 5.000000e-01 6.533000e-04 2.843210e-05 3.505372e-05
	+3.200000e+01 5.000000e-01 5.000000e-01 5.330000e-04 2.433884e-05 2.987365e-05
	+3.300000e+01 5.000000e-01 5.000000e-01 4.219000e-04 2.042960e-05 2.460067e-05
	+3.400000e+01 5.000000e-01 5.000000e-01 3.378000e-04 1.733917e-05 2.103103e-05
	+3.500000e+01 5.000000e-01 5.000000e-01 2.720000e-04 1.451990e-05 1.806029e-05
	+3.600000e+01 5.000000e-01 5.000000e-01 2.110000e-04 1.161964e-05 1.466043e-05
	+3.700000e+01 5.000000e-01 5.000000e-01 1.801000e-04 1.028793e-05 1.297906e-05
	+3.800000e+01 5.000000e-01 5.000000e-01 1.437000e-04 8.711521e-06 1.088699e-05
	+3.900000e+01 5.000000e-01 5.000000e-01 1.126000e-04 7.267758e-06 8.973109e-06
	+4.000000e+01 5.000000e-01 5.000000e-01 9.495000e-05 6.163489e-06 7.846271e-06
	+4.100000e+01 5.000000e-01 5.000000e-01 7.233000e-05 4.894127e-06 6.175406e-06
	+4.200000e+01 5.000000e-01 5.000000e-01 5.903000e-05 3.916738e-06 5.272859e-06
	+4.300000e+01 5.000000e-01 5.000000e-01 4.889000e-05 3.263428e-06 4.490878e-06
	+4.400000e+01 5.000000e-01 5.000000e-01 3.720000e-05 2.569584e-06 3.422851e-06
	+4.500000e+01 5.000000e-01 5.000000e-01 3.230000e-05 2.372613e-06 3.080799e-06
	+4.714000e+01 1.640000e+00 2.860000e+00 1.681000e-05 1.195665e-06 1.661237e-06
	+5.150000e+01 1.500000e+00 3.500000e+00 7.330000e-06 6.456963e-07 7.417340e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d01-x02-y02
	+Path=/REF/ATLAS_2016_I1419652/d01-x02-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 2.108000e-01 4.421693e-03 4.413734e-03
	+2.000000e+00 5.000000e-01 5.000000e-01 1.520000e-01 6.251231e-04 6.060117e-04
	+3.000000e+00 5.000000e-01 5.000000e-01 1.111000e-01 4.927134e-04 4.806516e-04
	+4.000000e+00 5.000000e-01 5.000000e-01 8.599000e-02 3.793165e-04 3.732124e-04
	+5.000000e+00 5.000000e-01 5.000000e-01 6.936000e-02 3.451687e-04 3.435352e-04
	+6.000000e+00 5.000000e-01 5.000000e-01 5.741000e-02 3.698575e-04 3.708501e-04
	+7.000000e+00 5.000000e-01 5.000000e-01 4.802000e-02 3.849993e-04 3.843763e-04
	+8.000000e+00 5.000000e-01 5.000000e-01 4.058000e-02 3.683340e-04 3.629933e-04
	+9.000000e+00 5.000000e-01 5.000000e-01 3.443000e-02 3.244514e-04 3.163687e-04
	+1.000000e+01 5.000000e-01 5.000000e-01 2.921000e-02 2.895708e-04 2.742253e-04
	+1.100000e+01 5.000000e-01 5.000000e-01 2.484000e-02 2.618774e-04 2.531404e-04
	+1.200000e+01 5.000000e-01 5.000000e-01 2.114000e-02 2.353010e-04 2.345619e-04
	+1.300000e+01 5.000000e-01 5.000000e-01 1.795000e-02 2.017004e-04 2.035478e-04
	+1.400000e+01 5.000000e-01 5.000000e-01 1.524000e-02 1.729731e-04 1.788554e-04
	+1.500000e+01 5.000000e-01 5.000000e-01 1.296000e-02 1.644038e-04 1.743925e-04
	+1.600000e+01 5.000000e-01 5.000000e-01 1.100000e-02 1.722771e-04 1.817879e-04
	+1.700000e+01 5.000000e-01 5.000000e-01 9.298000e-03 1.785175e-04 1.867763e-04
	+1.800000e+01 5.000000e-01 5.000000e-01 7.887000e-03 1.827920e-04 1.911348e-04
	+1.900000e+01 5.000000e-01 5.000000e-01 6.620000e-03 1.805394e-04 1.894749e-04
	+2.000000e+01 5.000000e-01 5.000000e-01 5.599000e-03 1.735160e-04 1.831461e-04
	+2.100000e+01 5.000000e-01 5.000000e-01 4.730000e-03 1.640431e-04 1.728940e-04
	+2.200000e+01 5.000000e-01 5.000000e-01 3.988000e-03 1.559657e-04 1.637638e-04
	+2.300000e+01 5.000000e-01 5.000000e-01 3.331000e-03 1.510457e-04 1.590776e-04
	+2.400000e+01 5.000000e-01 5.000000e-01 2.775000e-03 1.417776e-04 1.497947e-04
	+2.500000e+01 5.000000e-01 5.000000e-01 2.305000e-03 1.321170e-04 1.395752e-04
	+2.600000e+01 5.000000e-01 5.000000e-01 1.904000e-03 1.208308e-04 1.273573e-04
	+2.700000e+01 5.000000e-01 5.000000e-01 1.588000e-03 1.094410e-04 1.145802e-04
	+2.800000e+01 5.000000e-01 5.000000e-01 1.309000e-03 9.545237e-05 1.000950e-04
	+2.900000e+01 5.000000e-01 5.000000e-01 1.073000e-03 8.399733e-05 8.862966e-05
	+3.000000e+01 5.000000e-01 5.000000e-01 9.198000e-04 7.915207e-05 8.374418e-05
	+3.100000e+01 5.000000e-01 5.000000e-01 7.719000e-04 7.255890e-05 7.649140e-05
	+3.200000e+01 5.000000e-01 5.000000e-01 6.357000e-04 6.327754e-05 6.656190e-05
	+3.300000e+01 5.000000e-01 5.000000e-01 5.090000e-04 5.280270e-05 5.532732e-05
	+3.400000e+01 5.000000e-01 5.000000e-01 4.135000e-04 4.593126e-05 4.818398e-05
	+3.500000e+01 5.000000e-01 5.000000e-01 3.363000e-04 4.052229e-05 4.264253e-05
	+3.600000e+01 5.000000e-01 5.000000e-01 2.616000e-04 3.334409e-05 3.513516e-05
	+3.700000e+01 5.000000e-01 5.000000e-01 2.231000e-04 2.861722e-05 3.025032e-05
	+3.800000e+01 5.000000e-01 5.000000e-01 1.793000e-04 2.293966e-05 2.434330e-05
	+3.900000e+01 5.000000e-01 5.000000e-01 1.425000e-04 1.867820e-05 1.983033e-05
	+4.000000e+01 5.000000e-01 5.000000e-01 1.212000e-04 1.594318e-05 1.710626e-05
	+4.100000e+01 5.000000e-01 5.000000e-01 9.257000e-05 1.264585e-05 1.353375e-05
	+4.200000e+01 5.000000e-01 5.000000e-01 7.614000e-05 1.121636e-05 1.210510e-05
	+4.300000e+01 5.000000e-01 5.000000e-01 6.385000e-05 1.013514e-05 1.090636e-05
	+4.400000e+01 5.000000e-01 5.000000e-01 4.897000e-05 7.979672e-06 8.516680e-06
	+4.500000e+01 5.000000e-01 5.000000e-01 4.291000e-05 7.127690e-06 7.590456e-06
	+4.714000e+01 1.640000e+00 2.860000e+00 2.275000e-05 3.858710e-06 4.162396e-06
	+5.150000e+01 1.500000e+00 3.500000e+00 1.017000e-05 1.844739e-06 1.912841e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d02-x01-y01
	+Path=/REF/ATLAS_2016_I1419652/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.474000e-01 4.740000e-02 5.260000e-02 1.685000e+00 2.008266e-02 2.040261e-02
	+6.480000e-01 4.800000e-02 5.200000e-02 1.102000e+00 1.296211e-02 1.316208e-02
	+7.481000e-01 4.810000e-02 5.190000e-02 7.422000e-01 8.603813e-03 8.730786e-03
	+8.482000e-01 4.820000e-02 5.180000e-02 5.130000e-01 5.970542e-03 6.059520e-03
	+9.482000e-01 4.820000e-02 5.180000e-02 3.634000e-01 4.218380e-03 4.280360e-03
	+1.049000e+00 4.900000e-02 5.100000e-02 2.616000e-01 3.969290e-03 4.001280e-03
	+1.149000e+00 4.900000e-02 5.100000e-02 1.918000e-01 2.931094e-03 2.955085e-03
	+1.249000e+00 4.900000e-02 5.100000e-02 1.425000e-01 2.181847e-03 2.199840e-03
	+1.349000e+00 4.900000e-02 5.100000e-02 1.075000e-01 1.627724e-03 1.640718e-03
	+1.449000e+00 4.900000e-02 5.100000e-02 8.174000e-02 1.240795e-03 1.250788e-03
	+1.549000e+00 4.900000e-02 5.100000e-02 6.297000e-02 9.494949e-04 9.564898e-04
	+1.649000e+00 4.900000e-02 5.100000e-02 4.885000e-02 7.363895e-04 7.417852e-04
	+1.749000e+00 4.900000e-02 5.100000e-02 3.827000e-02 5.779388e-04 5.821349e-04
	+1.849000e+00 4.900000e-02 5.100000e-02 3.024000e-02 4.574344e-04 4.608312e-04
	+1.949000e+00 4.900000e-02 5.100000e-02 2.399000e-02 3.626886e-04 3.653850e-04
	+2.049000e+00 4.900000e-02 5.100000e-02 1.916000e-02 2.872799e-04 2.892773e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 1.546000e-02 2.319821e-04 2.335795e-04
	+2.249000e+00 4.900000e-02 5.100000e-02 1.249000e-02 1.881026e-04 1.893000e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 1.018000e-02 1.537508e-04 1.548483e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 8.320000e-03 1.257997e-04 1.265978e-04
	+2.596000e+00 9.600000e-02 1.040000e-01 6.237000e-03 9.362336e-05 9.425207e-05
	+2.796000e+00 9.600000e-02 1.040000e-01 4.308000e-03 6.492919e-05 6.536818e-05
	+2.996000e+00 9.600000e-02 1.040000e-01 3.010000e-03 4.576592e-05 4.608462e-05
	+3.197000e+00 9.700000e-02 1.030000e-01 2.154000e-03 3.302845e-05 3.325749e-05
	+3.397000e+00 9.700000e-02 1.030000e-01 1.551000e-03 2.389232e-05 2.406153e-05
	+3.726000e+00 2.260000e-01 2.740000e-01 9.311000e-04 1.412090e-05 1.422061e-05
	+4.228000e+00 2.280000e-01 2.720000e-01 4.593000e-04 7.193022e-06 7.236839e-06
	+4.731000e+00 2.310000e-01 2.690000e-01 2.434000e-04 3.888072e-06 3.911937e-06
	+5.430000e+00 4.300000e-01 5.700000e-01 1.078000e-04 1.704113e-06 1.714060e-06
	+6.442000e+00 4.420000e-01 5.580000e-01 4.000000e-05 6.431284e-07 6.471953e-07
	+7.445000e+00 4.450000e-01 5.550000e-01 1.709000e-05 2.811267e-07 2.829043e-07
	+8.450000e+00 4.500000e-01 5.500000e-01 8.225000e-06 1.371052e-07 1.379889e-07
	+9.464000e+00 4.640000e-01 5.360000e-01 4.099000e-06 6.851026e-08 6.895805e-08
	+1.171000e+01 1.710000e+00 3.290000e+00 1.076000e-06 2.533884e-08 2.541778e-08
	+1.695000e+01 1.950000e+00 3.050000e+00 1.297000e-07 3.490784e-09 3.499450e-09
	+2.357000e+01 3.570000e+00 6.430000e+00 1.779000e-08 6.230317e-10 6.239542e-10
	+3.631000e+01 6.310000e+00 1.369000e+01 1.090000e-09 7.290178e-11 7.301291e-11
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d02-x01-y02
	+Path=/REF/ATLAS_2016_I1419652/d02-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.474000e-01 4.740000e-02 5.260000e-02 1.697000e+00 2.029267e-02 2.061263e-02
	+6.480000e-01 4.800000e-02 5.200000e-02 1.114000e+00 1.328211e-02 1.347208e-02
	+7.481000e-01 4.810000e-02 5.190000e-02 7.538000e-01 9.178755e-03 9.301732e-03
	+8.482000e-01 4.820000e-02 5.180000e-02 5.233000e-01 6.753422e-03 6.835405e-03
	+9.482000e-01 4.820000e-02 5.180000e-02 3.724000e-01 5.126195e-03 5.179183e-03
	+1.049000e+00 4.900000e-02 5.100000e-02 2.693000e-01 4.778138e-03 4.806132e-03
	+1.149000e+00 4.900000e-02 5.100000e-02 1.984000e-01 3.735921e-03 3.755916e-03
	+1.249000e+00 4.900000e-02 5.100000e-02 1.483000e-01 3.036661e-03 3.050658e-03
	+1.349000e+00 4.900000e-02 5.100000e-02 1.125000e-01 2.547510e-03 2.556508e-03
	+1.449000e+00 4.900000e-02 5.100000e-02 8.610000e-02 2.167507e-03 2.173506e-03
	+1.549000e+00 4.900000e-02 5.100000e-02 6.672000e-02 1.836406e-03 1.840405e-03
	+1.649000e+00 4.900000e-02 5.100000e-02 5.204000e-02 1.545321e-03 1.548320e-03
	+1.749000e+00 4.900000e-02 5.100000e-02 4.099000e-02 1.313274e-03 1.315274e-03
	+1.849000e+00 4.900000e-02 5.100000e-02 3.255000e-02 1.112209e-03 1.114209e-03
	+1.949000e+00 4.900000e-02 5.100000e-02 2.595000e-02 9.422219e-04 9.434217e-04
	+2.049000e+00 4.900000e-02 5.100000e-02 2.082000e-02 8.026625e-04 8.035623e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 1.688000e-02 6.876554e-04 6.882553e-04
	+2.249000e+00 4.900000e-02 5.100000e-02 1.369000e-02 5.845573e-04 5.850572e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 1.120000e-02 5.036313e-04 5.039312e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 9.192000e-03 4.298085e-04 4.301085e-04
	+2.596000e+00 9.600000e-02 1.040000e-01 6.924000e-03 3.408661e-04 3.410661e-04
	+2.796000e+00 9.600000e-02 1.040000e-01 4.809000e-03 2.512487e-04 2.513486e-04
	+2.996000e+00 9.600000e-02 1.040000e-01 3.373000e-03 1.828590e-04 1.829589e-04
	+3.197000e+00 9.700000e-02 1.030000e-01 2.422000e-03 1.357431e-04 1.357431e-04
	+3.397000e+00 9.700000e-02 1.030000e-01 1.747000e-03 9.936473e-05 9.941471e-05
	+3.726000e+00 2.260000e-01 2.740000e-01 1.051000e-03 6.119222e-05 6.122222e-05
	+4.228000e+00 2.280000e-01 2.720000e-01 5.180000e-04 2.953946e-05 2.954946e-05
	+4.731000e+00 2.310000e-01 2.690000e-01 2.735000e-04 1.484744e-05 1.485744e-05
	+5.430000e+00 4.300000e-01 5.700000e-01 1.202000e-04 5.832379e-06 5.836377e-06
	+6.442000e+00 4.420000e-01 5.580000e-01 4.408000e-05 1.748396e-06 1.750394e-06
	+7.445000e+00 4.450000e-01 5.550000e-01 1.860000e-05 5.680269e-07 5.690232e-07
	+8.450000e+00 4.500000e-01 5.500000e-01 8.860000e-06 2.056003e-07 2.062935e-07
	+9.464000e+00 4.640000e-01 5.360000e-01 4.373000e-06 8.020198e-08 8.062216e-08
	+1.171000e+01 1.710000e+00 3.290000e+00 1.137000e-06 2.950147e-08 2.958058e-08
	+1.695000e+01 1.950000e+00 3.050000e+00 1.357000e-07 3.941899e-09 3.949638e-09
	+2.357000e+01 3.570000e+00 6.430000e+00 1.857000e-08 6.809823e-10 6.819105e-10
	+3.631000e+01 6.310000e+00 1.369000e+01 1.142000e-09 7.736674e-11 7.748662e-11
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d02-x02-y01
	+Path=/REF/ATLAS_2016_I1419652/d02-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.481000e-01 4.810000e-02 5.190000e-02 2.022000e+00 1.646692e-02 1.635704e-02
	+6.481000e-01 4.810000e-02 5.190000e-02 1.329000e+00 1.083415e-02 1.076425e-02
	+7.481000e-01 4.810000e-02 5.190000e-02 9.037000e-01 8.218141e-03 8.172187e-03
	+8.482000e-01 4.820000e-02 5.180000e-02 6.288000e-01 5.777424e-03 5.746464e-03
	+9.482000e-01 4.820000e-02 5.180000e-02 4.471000e-01 4.177615e-03 4.157647e-03
	+1.049000e+00 4.900000e-02 5.100000e-02 3.239000e-01 2.997019e-03 2.982055e-03
	+1.149000e+00 4.900000e-02 5.100000e-02 2.382000e-01 2.215948e-03 2.204973e-03
	+1.249000e+00 4.900000e-02 5.100000e-02 1.778000e-01 1.641989e-03 1.634013e-03
	+1.349000e+00 4.900000e-02 5.100000e-02 1.344000e-01 1.245647e-03 1.238674e-03
	+1.449000e+00 4.900000e-02 5.100000e-02 1.026000e-01 9.410956e-04 9.359239e-04
	+1.549000e+00 4.900000e-02 5.100000e-02 7.937000e-02 7.265877e-04 7.225126e-04
	+1.649000e+00 4.900000e-02 5.100000e-02 6.167000e-02 5.677052e-04 5.645352e-04
	+1.749000e+00 4.900000e-02 5.100000e-02 4.850000e-02 4.475362e-04 4.451580e-04
	+1.849000e+00 4.900000e-02 5.100000e-02 3.836000e-02 3.551249e-04 3.531431e-04
	+1.949000e+00 4.900000e-02 5.100000e-02 3.062000e-02 2.845915e-04 2.831105e-04
	+2.049000e+00 4.900000e-02 5.100000e-02 2.440000e-02 2.235147e-04 2.222312e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 1.980000e-02 1.823165e-04 1.813326e-04
	+2.249000e+00 4.900000e-02 5.100000e-02 1.595000e-02 1.475086e-04 1.466221e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 1.306000e-02 1.219985e-04 1.213118e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 1.068000e-02 1.007862e-04 1.002792e-04
	+2.596000e+00 9.600000e-02 1.040000e-01 8.049000e-03 7.533895e-05 7.494519e-05
	+2.796000e+00 9.600000e-02 1.040000e-01 5.552000e-03 5.309927e-05 5.283699e-05
	+2.996000e+00 9.600000e-02 1.040000e-01 3.893000e-03 3.765830e-05 3.748281e-05
	+3.197000e+00 9.700000e-02 1.030000e-01 2.798000e-03 2.745415e-05 2.733733e-05
	+3.397000e+00 9.700000e-02 1.030000e-01 2.014000e-03 2.030387e-05 2.022701e-05
	+3.726000e+00 2.260000e-01 2.740000e-01 1.212000e-03 1.229436e-05 1.226495e-05
	+4.229000e+00 2.290000e-01 2.710000e-01 5.989000e-04 6.625354e-06 6.606930e-06
	+4.731000e+00 2.310000e-01 2.690000e-01 3.225000e-04 3.700562e-06 3.691944e-06
	+5.430000e+00 4.300000e-01 5.700000e-01 1.420000e-04 1.595281e-06 1.591422e-06
	+6.441000e+00 4.410000e-01 5.590000e-01 5.317000e-05 6.286445e-07 6.273386e-07
	+7.445000e+00 4.450000e-01 5.550000e-01 2.307000e-05 2.839721e-07 2.835151e-07
	+8.449000e+00 4.490000e-01 5.510000e-01 1.111000e-05 1.723828e-07 1.722907e-07
	+9.466000e+00 4.660000e-01 5.340000e-01 5.500000e-06 8.803254e-08 8.795239e-08
	+1.170000e+01 1.700000e+00 3.300000e+00 1.458000e-06 2.803130e-08 2.802211e-08
	+1.702000e+01 2.020000e+00 2.980000e+00 1.782000e-07 4.498445e-09 4.497630e-09
	+2.364000e+01 3.640000e+00 6.360000e+00 2.487000e-08 9.516311e-10 9.514862e-10
	+3.629000e+01 6.290000e+00 1.371000e+01 1.588000e-09 1.378921e-10 1.379170e-10
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d02-x02-y02
	+Path=/REF/ATLAS_2016_I1419652/d02-x02-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.481000e-01 4.810000e-02 5.190000e-02 2.025000e+00 1.683659e-02 1.672670e-02
	+6.481000e-01 4.810000e-02 5.190000e-02 1.335000e+00 1.091417e-02 1.083427e-02
	+7.481000e-01 4.810000e-02 5.190000e-02 9.108000e-01 8.410081e-03 8.365125e-03
	+8.482000e-01 4.820000e-02 5.180000e-02 6.363000e-01 6.206077e-03 6.176112e-03
	+9.482000e-01 4.820000e-02 5.180000e-02 4.544000e-01 4.842896e-03 4.823919e-03
	+1.049000e+00 4.900000e-02 5.100000e-02 3.308000e-01 3.852700e-03 3.839720e-03
	+1.149000e+00 4.900000e-02 5.100000e-02 2.445000e-01 3.204612e-03 3.196621e-03
	+1.249000e+00 4.900000e-02 5.100000e-02 1.836000e-01 2.781144e-03 2.775151e-03
	+1.349000e+00 4.900000e-02 5.100000e-02 1.397000e-01 2.514491e-03 2.510495e-03
	+1.449000e+00 4.900000e-02 5.100000e-02 1.073000e-01 2.259326e-03 2.257328e-03
	+1.549000e+00 4.900000e-02 5.100000e-02 8.352000e-02 2.002767e-03 2.000769e-03
	+1.649000e+00 4.900000e-02 5.100000e-02 6.527000e-02 1.736942e-03 1.735943e-03
	+1.749000e+00 4.900000e-02 5.100000e-02 5.162000e-02 1.515353e-03 1.514354e-03
	+1.849000e+00 4.900000e-02 5.100000e-02 4.106000e-02 1.324994e-03 1.323995e-03
	+1.949000e+00 4.900000e-02 5.100000e-02 3.296000e-02 1.154027e-03 1.154027e-03
	+2.049000e+00 4.900000e-02 5.100000e-02 2.641000e-02 1.000239e-03 9.999395e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 2.152000e-02 8.646279e-04 8.644280e-04
	+2.249000e+00 4.900000e-02 5.100000e-02 1.743000e-02 7.483222e-04 7.481223e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 1.434000e-02 6.533184e-04 6.532184e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 1.177000e-02 5.631459e-04 5.629461e-04
	+2.596000e+00 9.600000e-02 1.040000e-01 8.920000e-03 4.534393e-04 4.533394e-04
	+2.796000e+00 9.600000e-02 1.040000e-01 6.194000e-03 3.375933e-04 3.375933e-04
	+2.996000e+00 9.600000e-02 1.040000e-01 4.364000e-03 2.487785e-04 2.487785e-04
	+3.197000e+00 9.700000e-02 1.030000e-01 3.149000e-03 1.863354e-04 1.862355e-04
	+3.397000e+00 9.700000e-02 1.030000e-01 2.272000e-03 1.370487e-04 1.370487e-04
	+3.726000e+00 2.260000e-01 2.740000e-01 1.370000e-03 8.432580e-05 8.431581e-05
	+4.229000e+00 2.290000e-01 2.710000e-01 6.763000e-04 4.058169e-05 4.058169e-05
	+4.731000e+00 2.310000e-01 2.690000e-01 3.630000e-04 2.082512e-05 2.082512e-05
	+5.430000e+00 4.300000e-01 5.700000e-01 1.585000e-04 8.054929e-06 8.053931e-06
	+6.441000e+00 4.410000e-01 5.590000e-01 5.852000e-05 2.278909e-06 2.277915e-06
	+7.445000e+00 4.450000e-01 5.550000e-01 2.501000e-05 6.859281e-07 6.857315e-07
	+8.449000e+00 4.490000e-01 5.510000e-01 1.195000e-05 2.698963e-07 2.698001e-07
	+9.466000e+00 4.660000e-01 5.340000e-01 5.839000e-06 9.703270e-08 9.696101e-08
	+1.170000e+01 1.700000e+00 3.300000e+00 1.533000e-06 3.015011e-08 3.013167e-08
	+1.702000e+01 2.020000e+00 2.980000e+00 1.861000e-07 5.247596e-09 5.246744e-09
	+2.364000e+01 3.640000e+00 6.360000e+00 2.590000e-08 1.012492e-09 1.012345e-09
	+3.629000e+01 6.290000e+00 1.371000e+01 1.639000e-09 1.468077e-10 1.468402e-10
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d03-x01-y01
	+Path=/REF/ATLAS_2016_I1419652/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-2.450000e+00 5.000000e-02 5.000000e-02 2.670000e+00 4.351090e-02 4.433995e-02
	+-2.350000e+00 5.000000e-02 5.000000e-02 2.753000e+00 4.554793e-02 4.646698e-02
	+-2.250000e+00 5.000000e-02 5.000000e-02 2.789000e+00 4.320871e-02 4.394789e-02
	+-2.150000e+00 5.000000e-02 5.000000e-02 2.758000e+00 4.257625e-02 4.331546e-02
	+-2.050000e+00 5.000000e-02 5.000000e-02 2.782000e+00 4.282668e-02 4.355590e-02
	+-1.950000e+00 5.000000e-02 5.000000e-02 2.822000e+00 4.347812e-02 4.421731e-02
	+-1.850000e+00 5.000000e-02 5.000000e-02 2.845000e+00 4.491694e-02 4.573610e-02
	+-1.750000e+00 5.000000e-02 5.000000e-02 2.843000e+00 4.657439e-02 4.748354e-02
	+-1.650000e+00 5.000000e-02 5.000000e-02 2.840000e+00 4.440506e-02 4.519428e-02
	+-1.550000e+00 5.000000e-02 5.000000e-02 2.876000e+00 4.321635e-02 4.391561e-02
	+-1.450000e+00 5.000000e-02 5.000000e-02 2.881000e+00 3.831239e-02 3.875180e-02
	+-1.350000e+00 5.000000e-02 5.000000e-02 2.887000e+00 3.843125e-02 3.888065e-02
	+-1.250000e+00 5.000000e-02 5.000000e-02 2.901000e+00 3.543453e-02 3.574405e-02
	+-1.150000e+00 5.000000e-02 5.000000e-02 2.914000e+00 3.558468e-02 3.589421e-02
	+-1.050000e+00 5.000000e-02 5.000000e-02 2.911000e+00 3.512329e-02 3.541285e-02
	+-9.500000e-01 5.000000e-02 5.000000e-02 2.911000e+00 3.517233e-02 3.547189e-02
	+-8.500000e-01 5.000000e-02 5.000000e-02 2.906000e+00 3.344447e-02 3.368408e-02
	+-7.500000e-01 5.000000e-02 5.000000e-02 2.901000e+00 3.341395e-02 3.365356e-02
	+-6.500000e-01 5.000000e-02 5.000000e-02 2.898000e+00 3.291431e-02 3.313395e-02
	+-5.500000e-01 5.000000e-02 5.000000e-02 2.892000e+00 3.284414e-02 3.307376e-02
	+-4.500000e-01 5.000000e-02 5.000000e-02 2.888000e+00 3.240458e-02 3.261423e-02
	+-3.500000e-01 5.000000e-02 5.000000e-02 2.883000e+00 3.234445e-02 3.255410e-02
	+-2.500000e-01 5.000000e-02 5.000000e-02 2.882000e+00 3.218472e-02 3.238438e-02
	+-1.500000e-01 5.000000e-02 5.000000e-02 2.879000e+00 3.213481e-02 3.234445e-02
	+-5.000000e-02 5.000000e-02 5.000000e-02 2.879000e+00 3.257441e-02 3.279405e-02
	+5.000000e-02 5.000000e-02 5.000000e-02 2.872000e+00 3.249437e-02 3.271401e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 2.870000e+00 3.301318e-02 3.325279e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 2.871000e+00 3.302316e-02 3.326278e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 2.875000e+00 3.271372e-02 3.293336e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 2.882000e+00 3.277379e-02 3.300342e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 2.883000e+00 3.312351e-02 3.336312e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 2.888000e+00 3.316373e-02 3.340334e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 2.888000e+00 3.324394e-02 3.348355e-02
	+8.500000e-01 5.000000e-02 5.000000e-02 2.897000e+00 3.332432e-02 3.356393e-02
	+9.500000e-01 5.000000e-02 5.000000e-02 2.901000e+00 3.464275e-02 3.493231e-02
	+1.050000e+00 5.000000e-02 5.000000e-02 2.908000e+00 3.469345e-02 3.497302e-02
	+1.150000e+00 5.000000e-02 5.000000e-02 2.898000e+00 3.549410e-02 3.580363e-02
	+1.250000e+00 5.000000e-02 5.000000e-02 2.889000e+00 3.536436e-02 3.568387e-02
	+1.350000e+00 5.000000e-02 5.000000e-02 2.874000e+00 3.701246e-02 3.740192e-02
	+1.450000e+00 5.000000e-02 5.000000e-02 2.860000e+00 3.680352e-02 3.719295e-02
	+1.550000e+00 5.000000e-02 5.000000e-02 2.864000e+00 4.403540e-02 4.478464e-02
	+1.650000e+00 5.000000e-02 5.000000e-02 2.845000e+00 4.237699e-02 4.303627e-02
	+1.750000e+00 5.000000e-02 5.000000e-02 2.818000e+00 4.376646e-02 4.453565e-02
	+1.850000e+00 5.000000e-02 5.000000e-02 2.817000e+00 4.268868e-02 4.338789e-02
	+1.950000e+00 5.000000e-02 5.000000e-02 2.819000e+00 4.335858e-02 4.409777e-02
	+2.050000e+00 5.000000e-02 5.000000e-02 2.804000e+00 4.425663e-02 4.505580e-02
	+2.150000e+00 5.000000e-02 5.000000e-02 2.754000e+00 4.293614e-02 4.368535e-02
	+2.250000e+00 5.000000e-02 5.000000e-02 2.763000e+00 4.285782e-02 4.360700e-02
	+2.350000e+00 5.000000e-02 5.000000e-02 2.737000e+00 4.434838e-02 4.520746e-02
	+2.450000e+00 5.000000e-02 5.000000e-02 2.666000e+00 4.271078e-02 4.349985e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d03-x01-y02
	+Path=/REF/ATLAS_2016_I1419652/d03-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-2.450000e+00 5.000000e-02 5.000000e-02 2.754000e+00 5.158575e-02 5.233509e-02
	+-2.350000e+00 5.000000e-02 5.000000e-02 2.839000e+00 5.375330e-02 5.458264e-02
	+-2.250000e+00 5.000000e-02 5.000000e-02 2.877000e+00 5.208304e-02 5.274250e-02
	+-2.150000e+00 5.000000e-02 5.000000e-02 2.845000e+00 5.168063e-02 5.232014e-02
	+-2.050000e+00 5.000000e-02 5.000000e-02 2.870000e+00 5.210090e-02 5.274040e-02
	+-1.950000e+00 5.000000e-02 5.000000e-02 2.910000e+00 5.304202e-02 5.368152e-02
	+-1.850000e+00 5.000000e-02 5.000000e-02 2.932000e+00 5.423141e-02 5.494088e-02
	+-1.750000e+00 5.000000e-02 5.000000e-02 2.929000e+00 5.545966e-02 5.627908e-02
	+-1.650000e+00 5.000000e-02 5.000000e-02 2.926000e+00 5.371963e-02 5.440912e-02
	+-1.550000e+00 5.000000e-02 5.000000e-02 2.963000e+00 5.302015e-02 5.361970e-02
	+-1.450000e+00 5.000000e-02 5.000000e-02 2.966000e+00 4.902351e-02 4.939319e-02
	+-1.350000e+00 5.000000e-02 5.000000e-02 2.971000e+00 4.875283e-02 4.912250e-02
	+-1.250000e+00 5.000000e-02 5.000000e-02 2.984000e+00 4.609441e-02 4.634417e-02
	+-1.150000e+00 5.000000e-02 5.000000e-02 2.996000e+00 4.599478e-02 4.625452e-02
	+-1.050000e+00 5.000000e-02 5.000000e-02 2.991000e+00 4.560340e-02 4.584317e-02
	+-9.500000e-01 5.000000e-02 5.000000e-02 2.990000e+00 4.611219e-02 4.635197e-02
	+-8.500000e-01 5.000000e-02 5.000000e-02 2.984000e+00 4.473300e-02 4.492282e-02
	+-7.500000e-01 5.000000e-02 5.000000e-02 2.978000e+00 4.425303e-02 4.444284e-02
	+-6.500000e-01 5.000000e-02 5.000000e-02 2.972000e+00 4.304379e-02 4.322360e-02
	+-5.500000e-01 5.000000e-02 5.000000e-02 2.964000e+00 4.251401e-02 4.269383e-02
	+-4.500000e-01 5.000000e-02 5.000000e-02 2.960000e+00 4.216410e-02 4.233393e-02
	+-3.500000e-01 5.000000e-02 5.000000e-02 2.954000e+00 4.242365e-02 4.259348e-02
	+-2.500000e-01 5.000000e-02 5.000000e-02 2.953000e+00 4.234373e-02 4.251356e-02
	+-1.500000e-01 5.000000e-02 5.000000e-02 2.948000e+00 4.201403e-02 4.217386e-02
	+-5.000000e-02 5.000000e-02 5.000000e-02 2.948000e+00 4.188444e-02 4.206425e-02
	+5.000000e-02 5.000000e-02 5.000000e-02 2.941000e+00 4.172448e-02 4.190428e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 2.940000e+00 4.269320e-02 4.288300e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 2.942000e+00 4.305288e-02 4.324269e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 2.947000e+00 4.273324e-02 4.292305e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 2.953000e+00 4.251365e-02 4.269347e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 2.956000e+00 4.278360e-02 4.297341e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 2.961000e+00 4.309355e-02 4.328336e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 2.964000e+00 4.398303e-02 4.417284e-02
	+8.500000e-01 5.000000e-02 5.000000e-02 2.975000e+00 4.448303e-02 4.467284e-02
	+9.500000e-01 5.000000e-02 5.000000e-02 2.981000e+00 4.561239e-02 4.583219e-02
	+1.050000e+00 5.000000e-02 5.000000e-02 2.988000e+00 4.531328e-02 4.554306e-02
	+1.150000e+00 5.000000e-02 5.000000e-02 2.979000e+00 4.584435e-02 4.610410e-02
	+1.250000e+00 5.000000e-02 5.000000e-02 2.971000e+00 4.576451e-02 4.602426e-02
	+1.350000e+00 5.000000e-02 5.000000e-02 2.958000e+00 4.757333e-02 4.789304e-02
	+1.450000e+00 5.000000e-02 5.000000e-02 2.945000e+00 4.766389e-02 4.798360e-02
	+1.550000e+00 5.000000e-02 5.000000e-02 2.949000e+00 5.361962e-02 5.427914e-02
	+1.650000e+00 5.000000e-02 5.000000e-02 2.931000e+00 5.187080e-02 5.245035e-02
	+1.750000e+00 5.000000e-02 5.000000e-02 2.904000e+00 5.284091e-02 5.352039e-02
	+1.850000e+00 5.000000e-02 5.000000e-02 2.904000e+00 5.210246e-02 5.271197e-02
	+1.950000e+00 5.000000e-02 5.000000e-02 2.907000e+00 5.285246e-02 5.350194e-02
	+2.050000e+00 5.000000e-02 5.000000e-02 2.892000e+00 5.351110e-02 5.422057e-02
	+2.150000e+00 5.000000e-02 5.000000e-02 2.841000e+00 5.203060e-02 5.269009e-02
	+2.250000e+00 5.000000e-02 5.000000e-02 2.850000e+00 5.166229e-02 5.232176e-02
	+2.350000e+00 5.000000e-02 5.000000e-02 2.823000e+00 5.264347e-02 5.340285e-02
	+2.450000e+00 5.000000e-02 5.000000e-02 2.751000e+00 5.087541e-02 5.157479e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d03-x02-y01
	+Path=/REF/ATLAS_2016_I1419652/d03-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-7.500000e-01 5.000000e-02 5.000000e-02 3.520000e+00 3.494597e-02 3.521539e-02
	+-6.500000e-01 5.000000e-02 5.000000e-02 3.516000e+00 3.427678e-02 3.452623e-02
	+-5.500000e-01 5.000000e-02 5.000000e-02 3.508000e+00 3.421652e-02 3.445598e-02
	+-4.500000e-01 5.000000e-02 5.000000e-02 3.504000e+00 3.369722e-02 3.393668e-02
	+-3.500000e-01 5.000000e-02 5.000000e-02 3.497000e+00 3.364707e-02 3.387654e-02
	+-2.500000e-01 5.000000e-02 5.000000e-02 3.497000e+00 3.327792e-02 3.349741e-02
	+-1.500000e-01 5.000000e-02 5.000000e-02 3.492000e+00 3.322804e-02 3.344753e-02
	+-5.000000e-02 5.000000e-02 5.000000e-02 3.492000e+00 3.388699e-02 3.412645e-02
	+5.000000e-02 5.000000e-02 5.000000e-02 3.484000e+00 3.380697e-02 3.404643e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 3.482000e+00 3.449490e-02 3.476432e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 3.483000e+00 3.451486e-02 3.477430e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 3.488000e+00 3.411580e-02 3.436525e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 3.496000e+00 3.417600e-02 3.442545e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 3.498000e+00 3.463532e-02 3.489476e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 3.503000e+00 3.466565e-02 3.492509e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 3.504000e+00 3.483581e-02 3.510523e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d03-x02-y02
	+Path=/REF/ATLAS_2016_I1419652/d03-x02-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-7.500000e-01 5.000000e-02 5.000000e-02 3.601000e+00 3.576294e-02 3.603969e-02
	+-6.500000e-01 5.000000e-02 5.000000e-02 3.595000e+00 3.504059e-02 3.529536e-02
	+-5.500000e-01 5.000000e-02 5.000000e-02 3.585000e+00 3.496559e-02 3.521649e-02
	+-4.500000e-01 5.000000e-02 5.000000e-02 3.579000e+00 3.442768e-02 3.466319e-02
	+-3.500000e-01 5.000000e-02 5.000000e-02 3.572000e+00 3.437025e-02 3.460221e-02
	+-2.500000e-01 5.000000e-02 5.000000e-02 3.571000e+00 3.398903e-02 3.421554e-02
	+-1.500000e-01 5.000000e-02 5.000000e-02 3.566000e+00 3.393573e-02 3.415917e-02
	+-5.000000e-02 5.000000e-02 5.000000e-02 3.565000e+00 3.459223e-02 3.483952e-02
	+5.000000e-02 5.000000e-02 5.000000e-02 3.556000e+00 3.451114e-02 3.475477e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 3.555000e+00 3.522906e-02 3.549822e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 3.557000e+00 3.525040e-02 3.551662e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 3.563000e+00 3.485217e-02 3.510831e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 3.571000e+00 3.491782e-02 3.517077e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 3.574000e+00 3.538658e-02 3.565953e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 3.581000e+00 3.544271e-02 3.571163e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 3.585000e+00 3.564179e-02 3.591763e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d04-x01-y01
	+Path=/REF/ATLAS_2016_I1419652/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 7.729000e-01 1.548064e-02 1.548064e-02
	+2.000000e+00 5.000000e-01 5.000000e-01 7.891000e-01 1.580346e-02 1.580346e-02
	+3.000000e+00 5.000000e-01 5.000000e-01 8.075000e-01 8.139662e-03 8.139662e-03
	+4.000000e+00 5.000000e-01 5.000000e-01 8.269000e-01 8.364294e-03 8.364294e-03
	+5.000000e+00 5.000000e-01 5.000000e-01 8.463000e-01 2.570539e-03 2.570539e-03
	+6.000000e+00 5.000000e-01 5.000000e-01 8.647000e-01 2.685087e-03 2.685087e-03
	+7.000000e+00 5.000000e-01 5.000000e-01 8.815000e-01 2.771822e-03 2.771822e-03
	+8.000000e+00 5.000000e-01 5.000000e-01 8.967000e-01 2.835085e-03 2.835085e-03
	+9.000000e+00 5.000000e-01 5.000000e-01 9.101000e-01 2.883312e-03 2.883312e-03
	+1.000000e+01 5.000000e-01 5.000000e-01 9.222000e-01 2.926436e-03 2.926436e-03
	+1.100000e+01 5.000000e-01 5.000000e-01 9.331000e-01 2.960545e-03 2.960545e-03
	+1.200000e+01 5.000000e-01 5.000000e-01 9.430000e-01 2.988056e-03 2.988056e-03
	+1.300000e+01 5.000000e-01 5.000000e-01 9.520000e-01 3.011478e-03 3.011478e-03
	+1.400000e+01 5.000000e-01 5.000000e-01 9.604000e-01 3.031306e-03 3.031306e-03
	+1.500000e+01 5.000000e-01 5.000000e-01 9.682000e-01 3.047340e-03 3.047340e-03
	+1.600000e+01 5.000000e-01 5.000000e-01 9.755000e-01 3.065457e-03 3.065457e-03
	+1.700000e+01 5.000000e-01 5.000000e-01 9.824000e-01 3.088377e-03 3.088377e-03
	+1.800000e+01 5.000000e-01 5.000000e-01 9.889000e-01 3.114943e-03 3.114943e-03
	+1.900000e+01 5.000000e-01 5.000000e-01 9.950000e-01 3.143997e-03 3.143997e-03
	+2.000000e+01 5.000000e-01 5.000000e-01 1.001000e+00 3.170773e-03 3.170773e-03
	+2.100000e+01 5.000000e-01 5.000000e-01 1.006000e+00 3.198449e-03 3.198449e-03
	+2.200000e+01 5.000000e-01 5.000000e-01 1.012000e+00 3.225269e-03 3.225269e-03
	+2.300000e+01 5.000000e-01 5.000000e-01 1.017000e+00 3.249559e-03 3.249559e-03
	+2.400000e+01 5.000000e-01 5.000000e-01 1.022000e+00 3.269820e-03 3.269820e-03
	+2.500000e+01 5.000000e-01 5.000000e-01 1.026000e+00 3.287975e-03 3.287975e-03
	+2.600000e+01 5.000000e-01 5.000000e-01 1.031000e+00 3.307848e-03 3.307848e-03
	+2.700000e+01 5.000000e-01 5.000000e-01 1.035000e+00 3.329731e-03 3.329731e-03
	+2.800000e+01 5.000000e-01 5.000000e-01 1.040000e+00 3.357114e-03 3.357114e-03
	+2.900000e+01 5.000000e-01 5.000000e-01 1.044000e+00 3.384266e-03 3.384266e-03
	+3.000000e+01 5.000000e-01 5.000000e-01 1.048000e+00 3.409297e-03 3.409297e-03
	+3.100000e+01 5.000000e-01 5.000000e-01 1.052000e+00 3.428754e-03 3.428754e-03
	+3.200000e+01 5.000000e-01 5.000000e-01 1.055000e+00 3.440595e-03 3.440595e-03
	+3.300000e+01 5.000000e-01 5.000000e-01 1.059000e+00 3.449525e-03 3.449525e-03
	+3.400000e+01 5.000000e-01 5.000000e-01 1.062000e+00 3.459618e-03 3.459618e-03
	+3.500000e+01 5.000000e-01 5.000000e-01 1.066000e+00 3.477657e-03 3.477657e-03
	+3.600000e+01 5.000000e-01 5.000000e-01 1.069000e+00 3.501732e-03 3.501732e-03
	+3.700000e+01 5.000000e-01 5.000000e-01 1.072000e+00 3.533506e-03 3.533506e-03
	+3.800000e+01 5.000000e-01 5.000000e-01 1.075000e+00 3.568225e-03 3.568225e-03
	+3.900000e+01 5.000000e-01 5.000000e-01 1.079000e+00 3.602156e-03 3.602156e-03
	+4.000000e+01 5.000000e-01 5.000000e-01 1.082000e+00 3.633122e-03 3.633122e-03
	+4.100000e+01 5.000000e-01 5.000000e-01 1.085000e+00 3.659844e-03 3.659844e-03
	+4.200000e+01 5.000000e-01 5.000000e-01 1.088000e+00 3.690864e-03 3.690864e-03
	+4.300000e+01 5.000000e-01 5.000000e-01 1.091000e+00 3.716426e-03 3.716426e-03
	+4.400000e+01 5.000000e-01 5.000000e-01 1.094000e+00 3.749485e-03 3.749485e-03
	+4.500000e+01 5.000000e-01 5.000000e-01 1.097000e+00 3.788947e-03 3.788947e-03
	+4.600000e+01 5.000000e-01 5.000000e-01 1.099000e+00 3.824599e-03 3.824599e-03
	+4.700000e+01 5.000000e-01 5.000000e-01 1.102000e+00 3.862340e-03 3.862340e-03
	+4.800000e+01 5.000000e-01 5.000000e-01 1.104000e+00 3.906975e-03 3.906975e-03
	+4.900000e+01 5.000000e-01 5.000000e-01 1.107000e+00 3.951615e-03 3.951615e-03
	+5.000000e+01 5.000000e-01 5.000000e-01 1.110000e+00 4.000906e-03 4.000906e-03
	+5.100000e+01 5.000000e-01 5.000000e-01 1.112000e+00 4.051801e-03 4.051801e-03
	+5.200000e+01 5.000000e-01 5.000000e-01 1.114000e+00 4.111089e-03 4.111089e-03
	+5.300000e+01 5.000000e-01 5.000000e-01 1.117000e+00 4.163040e-03 4.163040e-03
	+5.400000e+01 5.000000e-01 5.000000e-01 1.119000e+00 4.208235e-03 4.208235e-03
	+5.500000e+01 5.000000e-01 5.000000e-01 1.122000e+00 4.258907e-03 4.258907e-03
	+5.600000e+01 5.000000e-01 5.000000e-01 1.124000e+00 4.292461e-03 4.292461e-03
	+5.700000e+01 5.000000e-01 5.000000e-01 1.126000e+00 4.339379e-03 4.339379e-03
	+5.800000e+01 5.000000e-01 5.000000e-01 1.129000e+00 4.381772e-03 4.381772e-03
	+5.900000e+01 5.000000e-01 5.000000e-01 1.131000e+00 4.424675e-03 4.424675e-03
	+6.000000e+01 5.000000e-01 5.000000e-01 1.133000e+00 4.481637e-03 4.481637e-03
	+6.148000e+01 9.800000e-01 1.020000e+00 1.136000e+00 4.571181e-03 4.571181e-03
	+6.348000e+01 9.800000e-01 1.020000e+00 1.140000e+00 4.725529e-03 4.725529e-03
	+6.548000e+01 9.800000e-01 1.020000e+00 1.144000e+00 4.908156e-03 4.908156e-03
	+6.748000e+01 9.800000e-01 1.020000e+00 1.148000e+00 5.103410e-03 5.103410e-03
	+6.948000e+01 9.800000e-01 1.020000e+00 1.152000e+00 5.347875e-03 5.347875e-03
	+7.148000e+01 9.800000e-01 1.020000e+00 1.156000e+00 5.610507e-03 5.610507e-03
	+7.348000e+01 9.800000e-01 1.020000e+00 1.161000e+00 5.914280e-03 5.914280e-03
	+7.548000e+01 9.800000e-01 1.020000e+00 1.165000e+00 6.210121e-03 6.210121e-03
	+7.748000e+01 9.800000e-01 1.020000e+00 1.169000e+00 6.526313e-03 6.526313e-03
	+7.947000e+01 9.700000e-01 1.030000e+00 1.173000e+00 6.906759e-03 6.906759e-03
	+8.148000e+01 9.800000e-01 1.020000e+00 1.177000e+00 7.284714e-03 7.284714e-03
	+8.347000e+01 9.700000e-01 1.030000e+00 1.181000e+00 7.697886e-03 7.697886e-03
	+8.547000e+01 9.700000e-01 1.030000e+00 1.185000e+00 8.187840e-03 8.187840e-03
	+8.747000e+01 9.700000e-01 1.030000e+00 1.188000e+00 8.703294e-03 8.703294e-03
	+8.947000e+01 9.700000e-01 1.030000e+00 1.191000e+00 9.304886e-03 9.304886e-03
	+9.284000e+01 2.340000e+00 2.660000e+00 1.197000e+00 1.026218e-02 1.026218e-02
	+9.783000e+01 2.330000e+00 2.670000e+00 1.203000e+00 1.239034e-02 1.239034e-02
	+1.048000e+02 4.300000e+00 5.700000e+00 1.216000e+00 1.594898e-02 1.594898e-02
	+1.148000e+02 4.300000e+00 5.700000e+00 1.241000e+00 2.369974e-02 2.369974e-02
	+1.247000e+02 4.200000e+00 5.800000e+00 1.259000e+00 3.768532e-02 3.768532e-02
	+1.374000e+02 6.900000e+00 1.310000e+01 1.263000e+00 6.496349e-02 6.496349e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d04-x01-y02
	+Path=/REF/ATLAS_2016_I1419652/d04-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 7.737000e-01 1.551068e-02 1.551068e-02
	+2.000000e+00 5.000000e-01 5.000000e-01 7.904000e-01 1.585348e-02 1.585348e-02
	+3.000000e+00 5.000000e-01 5.000000e-01 8.090000e-01 8.203584e-03 8.203584e-03
	+4.000000e+00 5.000000e-01 5.000000e-01 8.289000e-01 8.453159e-03 8.453159e-03
	+5.000000e+00 5.000000e-01 5.000000e-01 8.486000e-01 2.796241e-03 2.796241e-03
	+6.000000e+00 5.000000e-01 5.000000e-01 8.673000e-01 2.852605e-03 2.852605e-03
	+7.000000e+00 5.000000e-01 5.000000e-01 8.845000e-01 2.893773e-03 2.893773e-03
	+8.000000e+00 5.000000e-01 5.000000e-01 9.000000e-01 2.942523e-03 2.942523e-03
	+9.000000e+00 5.000000e-01 5.000000e-01 9.141000e-01 3.046130e-03 3.046130e-03
	+1.000000e+01 5.000000e-01 5.000000e-01 9.269000e-01 3.234950e-03 3.234950e-03
	+1.100000e+01 5.000000e-01 5.000000e-01 9.384000e-01 3.455692e-03 3.455692e-03
	+1.200000e+01 5.000000e-01 5.000000e-01 9.489000e-01 3.668033e-03 3.668033e-03
	+1.300000e+01 5.000000e-01 5.000000e-01 9.585000e-01 3.835376e-03 3.835376e-03
	+1.400000e+01 5.000000e-01 5.000000e-01 9.673000e-01 4.003938e-03 4.003938e-03
	+1.500000e+01 5.000000e-01 5.000000e-01 9.756000e-01 4.198012e-03 4.198012e-03
	+1.600000e+01 5.000000e-01 5.000000e-01 9.832000e-01 4.385304e-03 4.385304e-03
	+1.700000e+01 5.000000e-01 5.000000e-01 9.905000e-01 4.666821e-03 4.666821e-03
	+1.800000e+01 5.000000e-01 5.000000e-01 9.974000e-01 4.924876e-03 4.924876e-03
	+1.900000e+01 5.000000e-01 5.000000e-01 1.004000e+00 5.032104e-03 5.032104e-03
	+2.000000e+01 5.000000e-01 5.000000e-01 1.010000e+00 5.178853e-03 5.178853e-03
	+2.100000e+01 5.000000e-01 5.000000e-01 1.016000e+00 5.396909e-03 5.396909e-03
	+2.200000e+01 5.000000e-01 5.000000e-01 1.021000e+00 5.629183e-03 5.629183e-03
	+2.300000e+01 5.000000e-01 5.000000e-01 1.027000e+00 5.859125e-03 5.859125e-03
	+2.400000e+01 5.000000e-01 5.000000e-01 1.032000e+00 6.011629e-03 6.011629e-03
	+2.500000e+01 5.000000e-01 5.000000e-01 1.037000e+00 6.121549e-03 6.121549e-03
	+2.600000e+01 5.000000e-01 5.000000e-01 1.042000e+00 6.206885e-03 6.206885e-03
	+2.700000e+01 5.000000e-01 5.000000e-01 1.046000e+00 6.372262e-03 6.372262e-03
	+2.800000e+01 5.000000e-01 5.000000e-01 1.051000e+00 6.595059e-03 6.595059e-03
	+2.900000e+01 5.000000e-01 5.000000e-01 1.056000e+00 6.703378e-03 6.703378e-03
	+3.000000e+01 5.000000e-01 5.000000e-01 1.060000e+00 6.812691e-03 6.812691e-03
	+3.100000e+01 5.000000e-01 5.000000e-01 1.064000e+00 7.022066e-03 7.022066e-03
	+3.200000e+01 5.000000e-01 5.000000e-01 1.068000e+00 7.298351e-03 7.298351e-03
	+3.300000e+01 5.000000e-01 5.000000e-01 1.072000e+00 7.549613e-03 7.549613e-03
	+3.400000e+01 5.000000e-01 5.000000e-01 1.076000e+00 7.736196e-03 7.736196e-03
	+3.500000e+01 5.000000e-01 5.000000e-01 1.079000e+00 7.809872e-03 7.809872e-03
	+3.600000e+01 5.000000e-01 5.000000e-01 1.083000e+00 7.827043e-03 7.827043e-03
	+3.700000e+01 5.000000e-01 5.000000e-01 1.086000e+00 8.014094e-03 8.014094e-03
	+3.800000e+01 5.000000e-01 5.000000e-01 1.090000e+00 8.185609e-03 8.185609e-03
	+3.900000e+01 5.000000e-01 5.000000e-01 1.093000e+00 8.432982e-03 8.432982e-03
	+4.000000e+01 5.000000e-01 5.000000e-01 1.097000e+00 8.689757e-03 8.689757e-03
	+4.100000e+01 5.000000e-01 5.000000e-01 1.100000e+00 8.791884e-03 8.791884e-03
	+4.200000e+01 5.000000e-01 5.000000e-01 1.103000e+00 8.858097e-03 8.858097e-03
	+4.300000e+01 5.000000e-01 5.000000e-01 1.106000e+00 9.051833e-03 9.051833e-03
	+4.400000e+01 5.000000e-01 5.000000e-01 1.109000e+00 9.237705e-03 9.237705e-03
	+4.500000e+01 5.000000e-01 5.000000e-01 1.112000e+00 9.382981e-03 9.382981e-03
	+4.600000e+01 5.000000e-01 5.000000e-01 1.115000e+00 9.580090e-03 9.580090e-03
	+4.700000e+01 5.000000e-01 5.000000e-01 1.118000e+00 9.843476e-03 9.843476e-03
	+4.800000e+01 5.000000e-01 5.000000e-01 1.121000e+00 1.014274e-02 1.014274e-02
	+4.900000e+01 5.000000e-01 5.000000e-01 1.124000e+00 1.036853e-02 1.036853e-02
	+5.000000e+01 5.000000e-01 5.000000e-01 1.127000e+00 1.053772e-02 1.053772e-02
	+5.100000e+01 5.000000e-01 5.000000e-01 1.129000e+00 1.072677e-02 1.072677e-02
	+5.200000e+01 5.000000e-01 5.000000e-01 1.132000e+00 1.090900e-02 1.090900e-02
	+5.300000e+01 5.000000e-01 5.000000e-01 1.135000e+00 1.106951e-02 1.106951e-02
	+5.400000e+01 5.000000e-01 5.000000e-01 1.137000e+00 1.116260e-02 1.116260e-02
	+5.500000e+01 5.000000e-01 5.000000e-01 1.139000e+00 1.119940e-02 1.119940e-02
	+5.600000e+01 5.000000e-01 5.000000e-01 1.142000e+00 1.123439e-02 1.123439e-02
	+5.700000e+01 5.000000e-01 5.000000e-01 1.144000e+00 1.137141e-02 1.137141e-02
	+5.800000e+01 5.000000e-01 5.000000e-01 1.147000e+00 1.161655e-02 1.161655e-02
	+5.900000e+01 5.000000e-01 5.000000e-01 1.149000e+00 1.177106e-02 1.177106e-02
	+6.000000e+01 5.000000e-01 5.000000e-01 1.151000e+00 1.184480e-02 1.184480e-02
	+6.148000e+01 9.800000e-01 1.020000e+00 1.155000e+00 1.192047e-02 1.192047e-02
	+6.348000e+01 9.800000e-01 1.020000e+00 1.159000e+00 1.217888e-02 1.217888e-02
	+6.548000e+01 9.800000e-01 1.020000e+00 1.164000e+00 1.259955e-02 1.259955e-02
	+6.748000e+01 9.800000e-01 1.020000e+00 1.168000e+00 1.286793e-02 1.286793e-02
	+6.948000e+01 9.800000e-01 1.020000e+00 1.172000e+00 1.303596e-02 1.303596e-02
	+7.148000e+01 9.800000e-01 1.020000e+00 1.176000e+00 1.324147e-02 1.324147e-02
	+7.348000e+01 9.800000e-01 1.020000e+00 1.181000e+00 1.356225e-02 1.356225e-02
	+7.548000e+01 9.800000e-01 1.020000e+00 1.185000e+00 1.397335e-02 1.397335e-02
	+7.748000e+01 9.800000e-01 1.020000e+00 1.190000e+00 1.454861e-02 1.454861e-02
	+7.947000e+01 9.700000e-01 1.030000e+00 1.194000e+00 1.541121e-02 1.541121e-02
	+8.148000e+01 9.800000e-01 1.020000e+00 1.198000e+00 1.594047e-02 1.594047e-02
	+8.347000e+01 9.700000e-01 1.030000e+00 1.201000e+00 1.568544e-02 1.568544e-02
	+8.547000e+01 9.700000e-01 1.030000e+00 1.205000e+00 1.522005e-02 1.522005e-02
	+8.747000e+01 9.700000e-01 1.030000e+00 1.208000e+00 1.519401e-02 1.519401e-02
	+8.947000e+01 9.700000e-01 1.030000e+00 1.212000e+00 1.566531e-02 1.566531e-02
	+9.284000e+01 2.340000e+00 2.660000e+00 1.217000e+00 1.644417e-02 1.644417e-02
	+9.783000e+01 2.330000e+00 2.670000e+00 1.224000e+00 1.846948e-02 1.846948e-02
	+1.048000e+02 4.300000e+00 5.700000e+00 1.237000e+00 2.198395e-02 2.198395e-02
	+1.148000e+02 4.300000e+00 5.700000e+00 1.261000e+00 2.911178e-02 2.911178e-02
	+1.247000e+02 4.200000e+00 5.800000e+00 1.279000e+00 4.238585e-02 4.238585e-02
	+1.374000e+02 6.900000e+00 1.310000e+01 1.279000e+00 7.336675e-02 7.336675e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d04-x02-y01
	+Path=/REF/ATLAS_2016_I1419652/d04-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 8.255000e-01 1.654245e-02 1.654245e-02
	+2.000000e+00 5.000000e-01 5.000000e-01 8.671000e-01 1.047234e-02 1.047234e-02
	+3.000000e+00 5.000000e-01 5.000000e-01 9.062000e-01 4.719518e-03 4.719518e-03
	+4.000000e+00 5.000000e-01 5.000000e-01 9.384000e-01 3.145069e-03 3.145069e-03
	+5.000000e+00 5.000000e-01 5.000000e-01 9.646000e-01 1.453530e-03 1.453530e-03
	+6.000000e+00 5.000000e-01 5.000000e-01 9.863000e-01 1.449224e-03 1.449224e-03
	+7.000000e+00 5.000000e-01 5.000000e-01 1.005000e+00 1.481263e-03 1.481263e-03
	+8.000000e+00 5.000000e-01 5.000000e-01 1.020000e+00 1.567666e-03 1.567666e-03
	+9.000000e+00 5.000000e-01 5.000000e-01 1.034000e+00 1.617331e-03 1.617331e-03
	+1.000000e+01 5.000000e-01 5.000000e-01 1.047000e+00 1.630280e-03 1.630280e-03
	+1.100000e+01 5.000000e-01 5.000000e-01 1.059000e+00 1.643028e-03 1.643028e-03
	+1.200000e+01 5.000000e-01 5.000000e-01 1.070000e+00 1.705742e-03 1.705742e-03
	+1.300000e+01 5.000000e-01 5.000000e-01 1.080000e+00 1.840900e-03 1.840900e-03
	+1.400000e+01 5.000000e-01 5.000000e-01 1.089000e+00 1.993840e-03 1.993840e-03
	+1.500000e+01 5.000000e-01 5.000000e-01 1.098000e+00 2.114873e-03 2.114873e-03
	+1.600000e+01 5.000000e-01 5.000000e-01 1.106000e+00 2.263382e-03 2.263382e-03
	+1.700000e+01 5.000000e-01 5.000000e-01 1.114000e+00 2.411441e-03 2.411441e-03
	+1.800000e+01 5.000000e-01 5.000000e-01 1.122000e+00 2.524218e-03 2.524218e-03
	+1.900000e+01 5.000000e-01 5.000000e-01 1.130000e+00 2.649903e-03 2.649903e-03
	+2.000000e+01 5.000000e-01 5.000000e-01 1.137000e+00 2.813349e-03 2.813349e-03
	+2.100000e+01 5.000000e-01 5.000000e-01 1.144000e+00 2.986884e-03 2.986884e-03
	+2.200000e+01 5.000000e-01 5.000000e-01 1.152000e+00 3.182208e-03 3.182208e-03
	+2.300000e+01 5.000000e-01 5.000000e-01 1.159000e+00 3.407249e-03 3.407249e-03
	+2.400000e+01 5.000000e-01 5.000000e-01 1.166000e+00 3.673835e-03 3.673835e-03
	+2.500000e+01 5.000000e-01 5.000000e-01 1.172000e+00 3.997656e-03 3.997656e-03
	+2.600000e+01 5.000000e-01 5.000000e-01 1.179000e+00 4.367372e-03 4.367372e-03
	+2.700000e+01 5.000000e-01 5.000000e-01 1.186000e+00 4.793197e-03 4.793197e-03
	+2.800000e+01 5.000000e-01 5.000000e-01 1.192000e+00 5.212355e-03 5.212355e-03
	+2.900000e+01 5.000000e-01 5.000000e-01 1.197000e+00 5.677622e-03 5.677622e-03
	+3.000000e+01 5.000000e-01 5.000000e-01 1.202000e+00 6.193379e-03 6.193379e-03
	+3.100000e+01 5.000000e-01 5.000000e-01 1.207000e+00 6.785686e-03 6.785686e-03
	+3.200000e+01 5.000000e-01 5.000000e-01 1.213000e+00 7.512270e-03 7.512270e-03
	+3.300000e+01 5.000000e-01 5.000000e-01 1.219000e+00 8.289455e-03 8.289455e-03
	+3.400000e+01 5.000000e-01 5.000000e-01 1.225000e+00 9.213010e-03 9.213010e-03
	+3.500000e+01 5.000000e-01 5.000000e-01 1.232000e+00 1.013381e-02 1.013381e-02
	+3.600000e+01 5.000000e-01 5.000000e-01 1.238000e+00 1.120204e-02 1.120204e-02
	+3.700000e+01 5.000000e-01 5.000000e-01 1.245000e+00 1.230762e-02 1.230762e-02
	+3.800000e+01 5.000000e-01 5.000000e-01 1.252000e+00 1.343445e-02 1.343445e-02
	+3.900000e+01 5.000000e-01 5.000000e-01 1.259000e+00 1.519240e-02 1.519240e-02
	+4.000000e+01 5.000000e-01 5.000000e-01 1.263000e+00 1.650712e-02 1.650712e-02
	+4.100000e+01 5.000000e-01 5.000000e-01 1.267000e+00 1.824573e-02 1.824573e-02
	+4.200000e+01 5.000000e-01 5.000000e-01 1.270000e+00 1.999089e-02 1.999089e-02
	+4.300000e+01 5.000000e-01 5.000000e-01 1.274000e+00 2.257471e-02 2.257471e-02
	+4.400000e+01 5.000000e-01 5.000000e-01 1.279000e+00 2.516020e-02 2.516020e-02
	+4.500000e+01 5.000000e-01 5.000000e-01 1.286000e+00 2.820395e-02 2.820395e-02
	+4.714000e+01 1.640000e+00 2.860000e+00 1.306000e+00 3.514198e-02 3.514198e-02
	+5.150000e+01 1.500000e+00 3.500000e+00 1.341000e+00 5.518898e-02 5.518898e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1419652/d04-x02-y02
	+Path=/REF/ATLAS_2016_I1419652/d04-x02-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 8.284000e-01 1.664247e-02 1.664247e-02
	+2.000000e+00 5.000000e-01 5.000000e-01 8.706000e-01 1.056235e-02 1.056235e-02
	+3.000000e+00 5.000000e-01 5.000000e-01 9.110000e-01 4.994932e-03 4.994932e-03
	+4.000000e+00 5.000000e-01 5.000000e-01 9.445000e-01 3.825976e-03 3.825976e-03
	+5.000000e+00 5.000000e-01 5.000000e-01 9.724000e-01 3.484364e-03 3.484364e-03
	+6.000000e+00 5.000000e-01 5.000000e-01 9.955000e-01 4.196998e-03 4.196998e-03
	+7.000000e+00 5.000000e-01 5.000000e-01 1.015000e+00 4.980654e-03 4.980654e-03
	+8.000000e+00 5.000000e-01 5.000000e-01 1.032000e+00 5.682657e-03 5.682657e-03
	+9.000000e+00 5.000000e-01 5.000000e-01 1.047000e+00 6.363628e-03 6.363628e-03
	+1.000000e+01 5.000000e-01 5.000000e-01 1.060000e+00 6.979230e-03 6.979230e-03
	+1.100000e+01 5.000000e-01 5.000000e-01 1.073000e+00 7.566479e-03 7.566479e-03
	+1.200000e+01 5.000000e-01 5.000000e-01 1.085000e+00 8.373537e-03 8.373537e-03
	+1.300000e+01 5.000000e-01 5.000000e-01 1.096000e+00 8.903323e-03 8.903323e-03
	+1.400000e+01 5.000000e-01 5.000000e-01 1.106000e+00 9.528823e-03 9.528823e-03
	+1.500000e+01 5.000000e-01 5.000000e-01 1.115000e+00 9.892883e-03 9.892883e-03
	+1.600000e+01 5.000000e-01 5.000000e-01 1.124000e+00 1.059901e-02 1.059901e-02
	+1.700000e+01 5.000000e-01 5.000000e-01 1.133000e+00 1.070254e-02 1.070254e-02
	+1.800000e+01 5.000000e-01 5.000000e-01 1.142000e+00 1.155815e-02 1.155815e-02
	+1.900000e+01 5.000000e-01 5.000000e-01 1.149000e+00 1.186491e-02 1.186491e-02
	+2.000000e+01 5.000000e-01 5.000000e-01 1.157000e+00 1.204024e-02 1.204024e-02
	+2.100000e+01 5.000000e-01 5.000000e-01 1.165000e+00 1.210454e-02 1.210454e-02
	+2.200000e+01 5.000000e-01 5.000000e-01 1.172000e+00 1.303598e-02 1.303598e-02
	+2.300000e+01 5.000000e-01 5.000000e-01 1.180000e+00 1.355492e-02 1.355492e-02
	+2.400000e+01 5.000000e-01 5.000000e-01 1.187000e+00 1.345077e-02 1.345077e-02
	+2.500000e+01 5.000000e-01 5.000000e-01 1.194000e+00 1.335607e-02 1.335607e-02
	+2.600000e+01 5.000000e-01 5.000000e-01 1.200000e+00 1.373711e-02 1.373711e-02
	+2.700000e+01 5.000000e-01 5.000000e-01 1.207000e+00 1.335071e-02 1.335071e-02
	+2.800000e+01 5.000000e-01 5.000000e-01 1.215000e+00 1.693229e-02 1.693229e-02
	+2.900000e+01 5.000000e-01 5.000000e-01 1.218000e+00 1.261519e-02 1.261519e-02
	+3.000000e+01 5.000000e-01 5.000000e-01 1.225000e+00 1.562038e-02 1.562038e-02
	+3.100000e+01 5.000000e-01 5.000000e-01 1.229000e+00 1.607841e-02 1.607841e-02
	+3.200000e+01 5.000000e-01 5.000000e-01 1.234000e+00 1.494632e-02 1.494632e-02
	+3.300000e+01 5.000000e-01 5.000000e-01 1.241000e+00 1.585811e-02 1.585811e-02
	+3.400000e+01 5.000000e-01 5.000000e-01 1.246000e+00 1.520301e-02 1.520301e-02
	+3.500000e+01 5.000000e-01 5.000000e-01 1.255000e+00 2.033679e-02 2.033679e-02
	+3.600000e+01 5.000000e-01 5.000000e-01 1.259000e+00 1.786961e-02 1.786961e-02
	+3.700000e+01 5.000000e-01 5.000000e-01 1.267000e+00 1.904236e-02 1.904236e-02
	+3.800000e+01 5.000000e-01 5.000000e-01 1.271000e+00 1.809743e-02 1.809743e-02
	+3.900000e+01 5.000000e-01 5.000000e-01 1.279000e+00 2.119950e-02 2.119950e-02
	+4.000000e+01 5.000000e-01 5.000000e-01 1.284000e+00 2.349809e-02 2.349809e-02
	+4.100000e+01 5.000000e-01 5.000000e-01 1.287000e+00 2.522289e-02 2.522289e-02
	+4.200000e+01 5.000000e-01 5.000000e-01 1.289000e+00 2.480832e-02 2.480832e-02
	+4.300000e+01 5.000000e-01 5.000000e-01 1.288000e+00 2.760184e-02 2.760184e-02
	+4.400000e+01 5.000000e-01 5.000000e-01 1.287000e+00 2.906303e-02 2.906303e-02
	+4.500000e+01 5.000000e-01 5.000000e-01 1.311000e+00 3.533837e-02 3.533837e-02
	+4.714000e+01 1.640000e+00 2.860000e+00 1.324000e+00 3.992193e-02 3.992193e-02
	+5.150000e+01 1.500000e+00 3.500000e+00 1.347000e+00 5.906465e-02 5.906465e-02
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1426695.yoda b/data/refdata/ATLAS_2016_I1426695.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1426695.yoda
	@@ -0,0 +1,784 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d01-x01-y01
	+Path=/REF/ATLAS_2016_I1426695/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+00 5.000000e-01 5.000000e-01 2.130000e-02 1.061660e-03 1.059662e-03
	+3.000000e+00 5.000000e-01 5.000000e-01 2.142000e-02 8.449405e-04 8.446407e-04
	+4.000000e+00 5.000000e-01 5.000000e-01 2.349000e-02 8.048526e-04 8.047526e-04
	+5.000000e+00 5.000000e-01 5.000000e-01 2.605000e-02 7.699350e-04 7.690354e-04
	+6.000000e+00 5.000000e-01 5.000000e-01 2.831000e-02 8.295001e-04 8.246019e-04
	+7.000000e+00 5.000000e-01 5.000000e-01 3.002000e-02 8.749791e-04 8.604838e-04
	+8.000000e+00 5.000000e-01 5.000000e-01 3.112000e-02 9.039648e-04 8.743738e-04
	+9.000000e+00 5.000000e-01 5.000000e-01 3.157000e-02 9.147539e-04 8.671678e-04
	+1.000000e+01 5.000000e-01 5.000000e-01 3.131000e-02 9.053431e-04 8.414616e-04
	+1.100000e+01 5.000000e-01 5.000000e-01 3.045000e-02 7.486739e-04 6.601107e-04
	+1.200000e+01 5.000000e-01 5.000000e-01 2.917000e-02 7.086650e-04 6.177041e-04
	+1.300000e+01 5.000000e-01 5.000000e-01 2.772000e-02 6.606582e-04 5.764960e-04
	+1.400000e+01 5.000000e-01 5.000000e-01 2.617000e-02 6.080545e-04 5.372880e-04
	+1.500000e+01 5.000000e-01 5.000000e-01 2.453000e-02 5.535508e-04 4.993780e-04
	+1.600000e+01 5.000000e-01 5.000000e-01 2.302000e-02 4.028108e-04 3.529547e-04
	+1.700000e+01 5.000000e-01 5.000000e-01 2.165000e-02 3.646116e-04 3.303439e-04
	+1.800000e+01 5.000000e-01 5.000000e-01 2.033000e-02 3.326097e-04 3.096327e-04
	+1.900000e+01 5.000000e-01 5.000000e-01 1.927000e-02 3.093067e-04 2.931236e-04
	+2.000000e+01 5.000000e-01 5.000000e-01 1.827000e-02 2.902998e-04 2.780131e-04
	+2.100000e+01 5.000000e-01 5.000000e-01 1.744000e-02 2.755951e-04 2.656062e-04
	+2.200000e+01 5.000000e-01 5.000000e-01 1.667000e-02 2.626891e-04 2.539990e-04
	+2.300000e+01 5.000000e-01 5.000000e-01 1.606000e-02 2.527845e-04 2.446939e-04
	+2.400000e+01 5.000000e-01 5.000000e-01 1.542000e-02 2.426779e-04 2.347872e-04
	+2.500000e+01 5.000000e-01 5.000000e-01 1.492000e-02 2.348734e-04 2.271827e-04
	+2.600000e+01 5.000000e-01 5.000000e-01 1.435000e-02 2.262680e-04 2.183777e-04
	+2.700000e+01 5.000000e-01 5.000000e-01 1.393000e-02 2.200652e-04 2.116757e-04
	+2.800000e+01 5.000000e-01 5.000000e-01 1.347000e-02 2.132596e-04 2.044708e-04
	+2.900000e+01 5.000000e-01 5.000000e-01 1.300000e-02 2.064541e-04 1.972660e-04
	+3.000000e+01 5.000000e-01 5.000000e-01 1.258000e-02 2.001496e-04 1.906620e-04
	+3.100000e+01 5.000000e-01 5.000000e-01 1.220000e-02 1.943465e-04 1.847593e-04
	+3.200000e+01 5.000000e-01 5.000000e-01 1.182000e-02 1.882438e-04 1.788566e-04
	+3.300000e+01 5.000000e-01 5.000000e-01 1.145000e-02 1.817394e-04 1.730515e-04
	+3.400000e+01 5.000000e-01 5.000000e-01 1.113000e-02 1.759390e-04 1.682500e-04
	+3.500000e+01 5.000000e-01 5.000000e-01 1.083000e-02 1.701373e-04 1.636467e-04
	+3.600000e+01 5.000000e-01 5.000000e-01 1.050000e-02 1.641354e-04 1.587434e-04
	+3.700000e+01 5.000000e-01 5.000000e-01 1.017000e-02 1.581342e-04 1.539406e-04
	+3.800000e+01 5.000000e-01 5.000000e-01 9.869000e-03 1.527318e-04 1.496366e-04
	+3.900000e+01 5.000000e-01 5.000000e-01 9.571000e-03 1.476300e-04 1.455333e-04
	+4.000000e+01 5.000000e-01 5.000000e-01 9.303000e-03 1.433278e-04 1.419301e-04
	+4.100000e+01 5.000000e-01 5.000000e-01 9.046000e-03 1.393263e-04 1.385276e-04
	+4.200000e+01 5.000000e-01 5.000000e-01 8.761000e-03 1.352231e-04 1.348237e-04
	+4.300000e+01 5.000000e-01 5.000000e-01 8.481000e-03 1.313189e-04 1.311192e-04
	+4.400000e+01 5.000000e-01 5.000000e-01 8.226000e-03 1.280168e-04 1.279170e-04
	+4.500000e+01 5.000000e-01 5.000000e-01 7.966000e-03 1.246118e-04 1.246118e-04
	+4.600000e+01 5.000000e-01 5.000000e-01 7.712000e-03 1.214082e-04 1.215080e-04
	+4.700000e+01 5.000000e-01 5.000000e-01 7.485000e-03 1.187050e-04 1.191044e-04
	+4.800000e+01 5.000000e-01 5.000000e-01 7.259000e-03 1.160020e-04 1.168006e-04
	+4.900000e+01 5.000000e-01 5.000000e-01 7.068000e-03 1.139975e-04 1.154950e-04
	+5.000000e+01 5.000000e-01 5.000000e-01 6.824000e-03 1.110941e-04 1.132903e-04
	+5.100000e+01 5.000000e-01 5.000000e-01 6.637000e-03 1.090919e-04 1.121866e-04
	+5.200000e+01 5.000000e-01 5.000000e-01 6.428000e-03 1.069877e-04 1.109810e-04
	+5.300000e+01 5.000000e-01 5.000000e-01 6.235000e-03 1.050816e-04 1.100734e-04
	+5.400000e+01 5.000000e-01 5.000000e-01 6.029000e-03 1.030783e-04 1.092682e-04
	+5.500000e+01 5.000000e-01 5.000000e-01 5.845000e-03 1.013751e-04 1.088631e-04
	+5.600000e+01 5.000000e-01 5.000000e-01 5.682000e-03 1.001107e-04 1.087571e-04
	+5.700000e+01 5.000000e-01 5.000000e-01 5.505000e-03 9.877709e-05 1.087517e-04
	+5.800000e+01 5.000000e-01 5.000000e-01 5.304000e-03 9.675214e-05 1.079453e-04
	+5.900000e+01 5.000000e-01 5.000000e-01 5.138000e-03 9.553735e-05 1.081390e-04
	+6.000000e+01 5.000000e-01 5.000000e-01 4.998000e-03 9.472439e-05 1.086346e-04
	+6.149000e+01 9.900000e-01 1.010000e+00 4.729000e-03 9.229344e-05 1.078628e-04
	+6.349000e+01 9.900000e-01 1.010000e+00 4.441000e-03 9.036999e-05 1.081585e-04
	+6.549000e+01 9.900000e-01 1.010000e+00 4.116000e-03 8.726568e-05 1.068536e-04
	+6.749000e+01 9.900000e-01 1.010000e+00 3.853000e-03 8.512222e-05 1.065497e-04
	+6.949000e+01 9.900000e-01 1.010000e+00 3.591000e-03 8.272889e-05 1.057461e-04
	+7.149000e+01 9.900000e-01 1.010000e+00 3.328000e-03 7.998572e-05 1.042427e-04
	+7.349000e+01 9.900000e-01 1.010000e+00 3.102000e-03 7.780251e-05 1.032396e-04
	+7.549000e+01 9.900000e-01 1.010000e+00 2.883000e-03 7.577955e-05 1.023367e-04
	+7.749000e+01 9.900000e-01 1.010000e+00 2.672000e-03 7.343682e-05 1.009341e-04
	+7.949000e+01 9.900000e-01 1.010000e+00 2.476000e-03 7.133424e-05 9.988159e-05
	+8.149000e+01 9.900000e-01 1.010000e+00 2.295000e-03 7.548826e-05 1.032280e-04
	+8.349000e+01 9.900000e-01 1.010000e+00 2.115000e-03 7.212630e-05 1.007260e-04
	+8.549000e+01 9.900000e-01 1.010000e+00 1.944000e-03 6.850447e-05 9.740424e-05
	+8.749000e+01 9.900000e-01 1.010000e+00 1.803000e-03 6.562319e-05 9.474299e-05
	+8.949000e+01 9.900000e-01 1.010000e+00 1.644000e-03 6.183155e-05 9.037158e-05
	+9.149000e+01 9.900000e-01 1.010000e+00 1.523000e-03 6.332836e-05 9.008993e-05
	+9.349000e+01 9.900000e-01 1.010000e+00 1.394000e-03 5.972728e-05 8.580899e-05
	+9.549000e+01 9.900000e-01 1.010000e+00 1.287000e-03 5.672626e-05 8.222812e-05
	+9.749000e+01 9.900000e-01 1.010000e+00 1.198000e-03 5.465555e-05 7.984749e-05
	+9.949000e+01 9.900000e-01 1.010000e+00 1.076000e-03 5.069382e-05 7.460619e-05
	+1.015000e+02 1.000000e+00 1.000000e+00 9.820000e-04 5.376027e-05 7.509451e-05
	+1.063000e+02 3.800000e+00 4.200000e+00 7.893000e-04 4.607468e-05 6.522331e-05
	+1.151000e+02 4.600000e+00 5.400000e+00 5.117000e-04 3.619296e-05 4.978215e-05
	+1.251000e+02 4.600000e+00 5.400000e+00 3.103000e-04 2.730229e-05 3.676170e-05
	+1.414000e+02 1.090000e+01 1.910000e+01 1.133000e-04 1.288055e-05 1.671043e-05
	+1.724000e+02 1.190000e+01 2.810000e+01 1.534000e-05 2.515328e-06 3.157261e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d01-x02-y01
	+Path=/REF/ATLAS_2016_I1426695/d01-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 8.446000e-02 2.329561e-03 2.308576e-03
	+2.000000e+00 5.000000e-01 5.000000e-01 8.707000e-02 2.314869e-03 2.309871e-03
	+3.000000e+00 5.000000e-01 5.000000e-01 7.996000e-02 1.686823e-03 1.686823e-03
	+4.000000e+00 5.000000e-01 5.000000e-01 6.903000e-02 1.423705e-03 1.423705e-03
	+5.000000e+00 5.000000e-01 5.000000e-01 5.879000e-02 1.197625e-03 1.197625e-03
	+6.000000e+00 5.000000e-01 5.000000e-01 5.071000e-02 1.026570e-03 1.026570e-03
	+7.000000e+00 5.000000e-01 5.000000e-01 4.431000e-02 8.949264e-04 8.949264e-04
	+8.000000e+00 5.000000e-01 5.000000e-01 3.925000e-02 7.920905e-04 7.920905e-04
	+9.000000e+00 5.000000e-01 5.000000e-01 3.534000e-02 7.121650e-04 7.121650e-04
	+1.000000e+01 5.000000e-01 5.000000e-01 3.206000e-02 6.450403e-04 6.451403e-04
	+1.100000e+01 5.000000e-01 5.000000e-01 2.942000e-02 4.447614e-04 4.449612e-04
	+1.200000e+01 5.000000e-01 5.000000e-01 2.714000e-02 4.091403e-04 4.093401e-04
	+1.300000e+01 5.000000e-01 5.000000e-01 2.514000e-02 3.782228e-04 3.784225e-04
	+1.400000e+01 5.000000e-01 5.000000e-01 2.333000e-02 3.506039e-04 3.509034e-04
	+1.500000e+01 5.000000e-01 5.000000e-01 2.171000e-02 3.262897e-04 3.266891e-04
	+1.600000e+01 5.000000e-01 5.000000e-01 2.020000e-02 3.040722e-04 3.045715e-04
	+1.700000e+01 5.000000e-01 5.000000e-01 1.884000e-02 2.843584e-04 2.849575e-04
	+1.800000e+01 5.000000e-01 5.000000e-01 1.756000e-02 2.664431e-04 2.669423e-04
	+1.900000e+01 5.000000e-01 5.000000e-01 1.638000e-02 2.502298e-04 2.508288e-04
	+2.000000e+01 5.000000e-01 5.000000e-01 1.530000e-02 1.619056e-04 1.628022e-04
	+2.100000e+01 5.000000e-01 5.000000e-01 1.427000e-02 1.541799e-04 1.550766e-04
	+2.200000e+01 5.000000e-01 5.000000e-01 1.335000e-02 1.480509e-04 1.489476e-04
	+2.300000e+01 5.000000e-01 5.000000e-01 1.245000e-02 1.425206e-04 1.434173e-04
	+2.400000e+01 5.000000e-01 5.000000e-01 1.165000e-02 1.382941e-04 1.390913e-04
	+2.500000e+01 5.000000e-01 5.000000e-01 1.091000e-02 1.345677e-04 1.354646e-04
	+2.600000e+01 5.000000e-01 5.000000e-01 1.018000e-02 1.310376e-04 1.320343e-04
	+2.700000e+01 5.000000e-01 5.000000e-01 9.610000e-03 1.295150e-04 1.305118e-04
	+2.800000e+01 5.000000e-01 5.000000e-01 8.942000e-03 1.264872e-04 1.274842e-04
	+2.900000e+01 5.000000e-01 5.000000e-01 8.398000e-03 1.245646e-04 1.255616e-04
	+3.000000e+01 5.000000e-01 5.000000e-01 7.765000e-03 1.209388e-04 1.217366e-04
	+3.148000e+01 9.800000e-01 1.020000e+00 7.005000e-03 1.167551e-04 1.175540e-04
	+3.395000e+01 1.450000e+00 1.550000e+00 5.840000e-03 1.090887e-04 1.095883e-04
	+3.785000e+01 2.350000e+00 2.650000e+00 4.371000e-03 9.618295e-05 9.646282e-05
	+4.486000e+01 4.360000e+00 5.640000e+00 2.500000e-03 7.416469e-05 7.427467e-05
	+5.479000e+01 4.290000e+00 5.710000e+00 1.099000e-03 4.745915e-05 4.747915e-05
	+6.474000e+01 4.240000e+00 5.760000e+00 4.414000e-04 2.485640e-05 2.486640e-05
	+7.469000e+01 4.190000e+00 5.810000e+00 1.728000e-04 1.219481e-05 1.219481e-05
	+8.743000e+01 6.930000e+00 1.307000e+01 4.213000e-05 3.936671e-06 3.936671e-06
	+1.067000e+02 6.200000e+00 1.380000e+01 4.721000e-06 7.343159e-07 7.346153e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d02-x01-y01
	+Path=/REF/ATLAS_2016_I1426695/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.265000e-01 2.650000e-02 2.350000e-02 1.160000e+01 9.736083e-01 1.197007e+00
	+1.752000e-01 2.520000e-02 2.480000e-02 1.032000e+01 3.772113e-01 3.772113e-01
	+2.249000e-01 2.490000e-02 2.510000e-02 7.812000e+00 2.204023e-01 2.204023e-01
	+2.747000e-01 2.470000e-02 2.530000e-02 5.886000e+00 1.361018e-01 1.361018e-01
	+3.248000e-01 2.480000e-02 2.520000e-02 4.441000e+00 9.251156e-02 9.251156e-02
	+3.747000e-01 2.470000e-02 2.530000e-02 3.402000e+00 7.123129e-02 7.123129e-02
	+4.247000e-01 2.470000e-02 2.530000e-02 2.629000e+00 4.887125e-02 4.887125e-02
	+4.746000e-01 2.460000e-02 2.540000e-02 2.052000e+00 3.860108e-02 3.860108e-02
	+5.480000e-01 4.800000e-02 5.200000e-02 1.456000e+00 2.452051e-02 2.452051e-02
	+6.480000e-01 4.800000e-02 5.200000e-02 9.410000e-01 1.595042e-02 1.595042e-02
	+7.481000e-01 4.810000e-02 5.190000e-02 6.278000e-01 1.065035e-02 1.065035e-02
	+8.481000e-01 4.810000e-02 5.190000e-02 4.301000e-01 7.266301e-03 7.266301e-03
	+9.482000e-01 4.820000e-02 5.180000e-02 3.009000e-01 5.106258e-03 5.106258e-03
	+1.048000e+00 4.800000e-02 5.200000e-02 2.149000e-01 3.574228e-03 3.574228e-03
	+1.148000e+00 4.800000e-02 5.200000e-02 1.561000e-01 2.603197e-03 2.603197e-03
	+1.248000e+00 4.800000e-02 5.200000e-02 1.151000e-01 1.922171e-03 1.922171e-03
	+1.348000e+00 4.800000e-02 5.200000e-02 8.591000e-02 1.435150e-03 1.435150e-03
	+1.448000e+00 4.800000e-02 5.200000e-02 6.486000e-02 1.081133e-03 1.081133e-03
	+1.548000e+00 4.800000e-02 5.200000e-02 4.952000e-02 8.357169e-04 8.357169e-04
	+1.648000e+00 4.800000e-02 5.200000e-02 3.826000e-02 6.425049e-04 6.425049e-04
	+1.749000e+00 4.900000e-02 5.100000e-02 2.969000e-02 5.012941e-04 5.012941e-04
	+1.849000e+00 4.900000e-02 5.100000e-02 2.326000e-02 3.907850e-04 3.907850e-04
	+1.949000e+00 4.900000e-02 5.100000e-02 1.829000e-02 3.115763e-04 3.115763e-04
	+2.049000e+00 4.900000e-02 5.100000e-02 1.455000e-02 2.442710e-04 2.442710e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 1.161000e-02 1.973641e-04 1.973641e-04
	+2.249000e+00 4.900000e-02 5.100000e-02 9.410000e-03 1.588595e-04 1.588595e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 7.600000e-03 1.289549e-04 1.289549e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 6.169000e-03 1.061498e-04 1.061498e-04
	+2.617000e+00 1.170000e-01 1.330000e-01 4.401000e-03 7.385361e-05 7.385361e-05
	+2.867000e+00 1.170000e-01 1.330000e-01 2.737000e-03 4.673924e-05 4.673924e-05
	+3.118000e+00 1.180000e-01 1.320000e-01 1.760000e-03 2.994544e-05 2.994544e-05
	+3.368000e+00 1.180000e-01 1.320000e-01 1.146000e-03 1.997173e-05 1.997173e-05
	+3.725000e+00 2.250000e-01 2.750000e-01 6.507000e-04 1.121918e-05 1.121918e-05
	+4.226000e+00 2.260000e-01 2.740000e-01 3.164000e-04 5.987654e-06 5.987654e-06
	+4.729000e+00 2.290000e-01 2.710000e-01 1.641000e-04 3.221163e-06 3.221163e-06
	+5.426000e+00 4.260000e-01 5.740000e-01 7.236000e-05 1.580928e-06 1.565956e-06
	+6.437000e+00 4.370000e-01 5.630000e-01 2.588000e-05 7.161274e-07 6.990696e-07
	+7.444000e+00 4.440000e-01 5.560000e-01 1.092000e-05 3.575290e-07 3.403860e-07
	+8.455000e+00 4.550000e-01 5.450000e-01 5.153000e-06 2.024346e-07 1.870951e-07
	+9.462000e+00 4.620000e-01 5.380000e-01 2.722000e-06 1.272154e-07 1.205441e-07
	+1.170000e+01 1.700000e+00 3.300000e+00 6.485000e-07 5.249804e-08 4.876326e-08
	+1.689000e+01 1.890000e+00 3.110000e+00 7.604000e-08 1.044059e-08 8.481353e-09
	+2.347000e+01 3.470000e+00 6.530000e+00 1.056000e-08 2.042797e-09 1.747948e-09
	+3.699000e+01 6.990000e+00 1.301000e+01 7.060000e-10 2.141156e-10 1.861223e-10
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d02-x02-y01
	+Path=/REF/ATLAS_2016_I1426695/d02-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.480000e-01 4.800000e-02 5.200000e-02 1.502000e+00 2.547044e-02 2.547044e-02
	+6.480000e-01 4.800000e-02 5.200000e-02 9.760000e-01 1.653043e-02 1.653043e-02
	+7.481000e-01 4.810000e-02 5.190000e-02 6.514000e-01 1.106036e-02 1.106036e-02
	+8.481000e-01 4.810000e-02 5.190000e-02 4.465000e-01 7.561311e-03 7.561311e-03
	+9.481000e-01 4.810000e-02 5.190000e-02 3.123000e-01 5.306266e-03 5.306266e-03
	+1.048000e+00 4.800000e-02 5.200000e-02 2.231000e-01 3.721234e-03 3.721234e-03
	+1.148000e+00 4.800000e-02 5.200000e-02 1.620000e-01 2.704203e-03 2.704203e-03
	+1.248000e+00 4.800000e-02 5.200000e-02 1.194000e-01 1.999176e-03 1.999176e-03
	+1.348000e+00 4.800000e-02 5.200000e-02 8.913000e-02 1.492155e-03 1.492155e-03
	+1.448000e+00 4.800000e-02 5.200000e-02 6.728000e-02 1.125136e-03 1.125136e-03
	+1.548000e+00 4.800000e-02 5.200000e-02 5.137000e-02 8.688200e-04 8.688200e-04
	+1.648000e+00 4.800000e-02 5.200000e-02 3.968000e-02 6.714072e-04 6.714072e-04
	+1.749000e+00 4.900000e-02 5.100000e-02 3.080000e-02 5.214963e-04 5.214963e-04
	+1.849000e+00 4.900000e-02 5.100000e-02 2.412000e-02 4.092868e-04 4.092868e-04
	+1.949000e+00 4.900000e-02 5.100000e-02 1.897000e-02 3.224785e-04 3.224785e-04
	+2.049000e+00 4.900000e-02 5.100000e-02 1.509000e-02 2.563717e-04 2.563717e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 1.204000e-02 2.048653e-04 2.048653e-04
	+2.249000e+00 4.900000e-02 5.100000e-02 9.758000e-03 1.666600e-04 1.666600e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 7.881000e-03 1.352552e-04 1.352552e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 6.396000e-03 1.102506e-04 1.102506e-04
	+2.617000e+00 1.170000e-01 1.330000e-01 4.563000e-03 7.741420e-05 7.741420e-05
	+2.867000e+00 1.170000e-01 1.330000e-01 2.838000e-03 4.852996e-05 4.852996e-05
	+3.118000e+00 1.180000e-01 1.320000e-01 1.825000e-03 3.148570e-05 3.148570e-05
	+3.368000e+00 1.180000e-01 1.320000e-01 1.188000e-03 2.077217e-05 2.077217e-05
	+3.725000e+00 2.250000e-01 2.750000e-01 6.746000e-04 1.169935e-05 1.169935e-05
	+4.226000e+00 2.260000e-01 2.740000e-01 3.280000e-04 6.232708e-06 6.232708e-06
	+4.729000e+00 2.290000e-01 2.710000e-01 1.701000e-04 3.381219e-06 3.381219e-06
	+5.426000e+00 4.260000e-01 5.740000e-01 7.501000e-05 1.649986e-06 1.635013e-06
	+6.437000e+00 4.370000e-01 5.630000e-01 2.682000e-05 7.395709e-07 7.218146e-07
	+7.444000e+00 4.440000e-01 5.560000e-01 1.132000e-05 3.749271e-07 3.574823e-07
	+8.455000e+00 4.550000e-01 5.450000e-01 5.342000e-06 2.102514e-07 1.944129e-07
	+9.462000e+00 4.620000e-01 5.380000e-01 2.821000e-06 1.330288e-07 1.261578e-07
	+1.170000e+01 1.700000e+00 3.300000e+00 6.721000e-07 5.421076e-08 5.031625e-08
	+1.689000e+01 1.890000e+00 3.110000e+00 7.883000e-08 1.080138e-08 8.770347e-09
	+2.347000e+01 3.470000e+00 6.530000e+00 1.096000e-08 2.121034e-09 1.816220e-09
	+3.699000e+01 6.990000e+00 1.301000e+01 7.320000e-10 2.220891e-10 1.931063e-10
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d02-x03-y01
	+Path=/REF/ATLAS_2016_I1426695/d02-x03-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.481000e-01 4.810000e-02 5.190000e-02 2.134000e+00 3.309072e-02 3.309072e-02
	+6.481000e-01 4.810000e-02 5.190000e-02 1.404000e+00 2.154072e-02 2.154072e-02
	+7.481000e-01 4.810000e-02 5.190000e-02 9.487000e-01 1.447062e-02 1.447062e-02
	+8.482000e-01 4.820000e-02 5.180000e-02 6.576000e-01 9.933535e-03 9.933535e-03
	+9.482000e-01 4.820000e-02 5.180000e-02 4.645000e-01 6.990464e-03 6.990464e-03
	+1.048000e+00 4.800000e-02 5.200000e-02 3.347000e-01 4.908412e-03 4.908412e-03
	+1.148000e+00 4.800000e-02 5.200000e-02 2.449000e-01 3.574361e-03 3.574361e-03
	+1.248000e+00 4.800000e-02 5.200000e-02 1.817000e-01 2.650315e-03 2.650315e-03
	+1.348000e+00 4.800000e-02 5.200000e-02 1.363000e-01 1.980279e-03 1.980279e-03
	+1.448000e+00 4.800000e-02 5.200000e-02 1.033000e-01 1.494247e-03 1.494247e-03
	+1.548000e+00 4.800000e-02 5.200000e-02 7.921000e-02 1.155219e-03 1.155219e-03
	+1.649000e+00 4.900000e-02 5.100000e-02 6.138000e-02 8.935963e-04 8.935963e-04
	+1.749000e+00 4.900000e-02 5.100000e-02 4.779000e-02 6.944768e-04 6.944768e-04
	+1.849000e+00 4.900000e-02 5.100000e-02 3.751000e-02 5.455600e-04 5.455600e-04
	+1.949000e+00 4.900000e-02 5.100000e-02 2.956000e-02 4.306449e-04 4.306449e-04
	+2.049000e+00 4.900000e-02 5.100000e-02 2.357000e-02 3.423328e-04 3.423328e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 1.883000e-02 2.738212e-04 2.738212e-04
	+2.249000e+00 4.900000e-02 5.100000e-02 1.529000e-02 2.229115e-04 2.229115e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 1.237000e-02 1.812027e-04 1.812027e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 1.005000e-02 1.479941e-04 1.479941e-04
	+2.617000e+00 1.170000e-01 1.330000e-01 7.183000e-03 1.035640e-04 1.035640e-04
	+2.867000e+00 1.170000e-01 1.330000e-01 4.478000e-03 6.494627e-05 6.494627e-05
	+3.118000e+00 1.180000e-01 1.320000e-01 2.885000e-03 4.225826e-05 4.225826e-05
	+3.368000e+00 1.180000e-01 1.320000e-01 1.882000e-03 2.806147e-05 2.806147e-05
	+3.725000e+00 2.250000e-01 2.750000e-01 1.070000e-03 1.569766e-05 1.569766e-05
	+4.226000e+00 2.260000e-01 2.740000e-01 5.218000e-04 8.646309e-06 8.646309e-06
	+4.729000e+00 2.290000e-01 2.710000e-01 2.711000e-04 4.736510e-06 4.736510e-06
	+5.426000e+00 4.260000e-01 5.740000e-01 1.197000e-04 2.369321e-06 2.342382e-06
	+6.437000e+00 4.370000e-01 5.630000e-01 4.290000e-05 1.086095e-06 1.055186e-06
	+7.444000e+00 4.440000e-01 5.560000e-01 1.814000e-05 5.647251e-07 5.348331e-07
	+8.456000e+00 4.560000e-01 5.440000e-01 8.568000e-06 3.223623e-07 2.956767e-07
	+9.462000e+00 4.620000e-01 5.380000e-01 4.531000e-06 2.073759e-07 1.959273e-07
	+1.171000e+01 1.710000e+00 3.290000e+00 1.080000e-06 8.525616e-08 7.886559e-08
	+1.689000e+01 1.890000e+00 3.110000e+00 1.267000e-07 1.721467e-08 1.391292e-08
	+2.347000e+01 3.470000e+00 6.530000e+00 1.768000e-08 3.399395e-09 2.903350e-09
	+3.698000e+01 6.980000e+00 1.302000e+01 1.175000e-09 3.551644e-10 3.083809e-10
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d02-x04-y01
	+Path=/REF/ATLAS_2016_I1426695/d02-x04-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.483000e-01 4.830000e-02 5.170000e-02 3.394000e+00 5.170175e-02 5.170175e-02
	+6.483000e-01 4.830000e-02 5.170000e-02 2.288000e+00 3.437176e-02 3.437176e-02
	+7.483000e-01 4.830000e-02 5.170000e-02 1.585000e+00 2.352152e-02 2.352152e-02
	+8.484000e-01 4.840000e-02 5.160000e-02 1.123000e+00 1.646132e-02 1.646132e-02
	+9.484000e-01 4.840000e-02 5.160000e-02 8.100000e-01 1.176115e-02 1.176115e-02
	+1.048000e+00 4.800000e-02 5.200000e-02 5.948000e-01 8.388028e-03 8.388028e-03
	+1.148000e+00 4.800000e-02 5.200000e-02 4.433000e-01 6.197907e-03 6.197907e-03
	+1.248000e+00 4.800000e-02 5.200000e-02 3.343000e-01 4.637801e-03 4.637801e-03
	+1.349000e+00 4.900000e-02 5.100000e-02 2.545000e-01 3.510712e-03 3.510712e-03
	+1.449000e+00 4.900000e-02 5.100000e-02 1.955000e-01 2.665639e-03 2.665639e-03
	+1.549000e+00 4.900000e-02 5.100000e-02 1.517000e-01 2.074571e-03 2.074571e-03
	+1.649000e+00 4.900000e-02 5.100000e-02 1.188000e-01 1.614516e-03 1.614516e-03
	+1.749000e+00 4.900000e-02 5.100000e-02 9.346000e-02 1.264468e-03 1.264468e-03
	+1.849000e+00 4.900000e-02 5.100000e-02 7.414000e-02 9.983271e-04 9.983271e-04
	+1.949000e+00 4.900000e-02 5.100000e-02 5.897000e-02 7.946886e-04 7.946886e-04
	+2.049000e+00 4.900000e-02 5.100000e-02 4.736000e-02 6.617432e-04 6.617432e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 3.810000e-02 5.325145e-04 5.325145e-04
	+2.249000e+00 4.900000e-02 5.100000e-02 3.113000e-02 4.341912e-04 4.341912e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 2.533000e-02 3.549691e-04 3.549691e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 2.075000e-02 2.914476e-04 2.914476e-04
	+2.617000e+00 1.170000e-01 1.330000e-01 1.497000e-02 2.044702e-04 2.044702e-04
	+2.868000e+00 1.180000e-01 1.320000e-01 9.447000e-03 1.291511e-04 1.291511e-04
	+3.118000e+00 1.180000e-01 1.320000e-01 6.136000e-03 8.452028e-05 8.452028e-05
	+3.368000e+00 1.180000e-01 1.320000e-01 4.048000e-03 5.657282e-05 5.657282e-05
	+3.726000e+00 2.260000e-01 2.740000e-01 2.329000e-03 3.204814e-05 3.204814e-05
	+4.227000e+00 2.270000e-01 2.730000e-01 1.151000e-03 1.803352e-05 1.803352e-05
	+4.729000e+00 2.290000e-01 2.710000e-01 6.062000e-04 9.956177e-06 9.956177e-06
	+5.428000e+00 4.280000e-01 5.720000e-01 2.722000e-04 5.125555e-06 5.059745e-06
	+6.440000e+00 4.400000e-01 5.600000e-01 9.957000e-05 2.376626e-06 2.300911e-06
	+7.446000e+00 4.460000e-01 5.540000e-01 4.299000e-05 1.278329e-06 1.203661e-06
	+8.457000e+00 4.570000e-01 5.430000e-01 2.054000e-05 7.697709e-07 7.053801e-07
	+9.466000e+00 4.660000e-01 5.340000e-01 1.101000e-05 5.032339e-07 4.754708e-07
	+1.172000e+01 1.720000e+00 3.280000e+00 2.679000e-06 2.080165e-07 1.919430e-07
	+1.690000e+01 1.900000e+00 3.100000e+00 3.257000e-07 4.385441e-08 3.527743e-08
	+2.338000e+01 3.380000e+00 6.620000e+00 4.676000e-08 8.901098e-09 7.573573e-09
	+3.684000e+01 6.840000e+00 1.316000e+01 3.201000e-09 9.613911e-10 8.329102e-10
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d02-x05-y01
	+Path=/REF/ATLAS_2016_I1426695/d02-x05-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.485000e-01 4.850000e-02 5.150000e-02 5.658000e+00 1.042132e-01 1.042132e-01
	+6.485000e-01 4.850000e-02 5.150000e-02 3.914000e+00 7.074331e-02 7.074331e-02
	+7.485000e-01 4.850000e-02 5.150000e-02 2.784000e+00 4.976129e-02 4.976129e-02
	+8.485000e-01 4.850000e-02 5.150000e-02 2.021000e+00 3.538978e-02 3.538978e-02
	+9.485000e-01 4.850000e-02 5.150000e-02 1.491000e+00 2.580849e-02 2.580849e-02
	+1.049000e+00 4.900000e-02 5.100000e-02 1.119000e+00 1.875757e-02 1.875757e-02
	+1.149000e+00 4.900000e-02 5.100000e-02 8.527000e-01 1.415665e-02 1.415665e-02
	+1.249000e+00 4.900000e-02 5.100000e-02 6.549000e-01 1.073589e-02 1.073589e-02
	+1.349000e+00 4.900000e-02 5.100000e-02 5.084000e-01 8.267244e-03 8.267244e-03
	+1.449000e+00 4.900000e-02 5.100000e-02 3.979000e-01 6.406698e-03 6.406698e-03
	+1.549000e+00 4.900000e-02 5.100000e-02 3.134000e-01 5.031219e-03 5.031219e-03
	+1.649000e+00 4.900000e-02 5.100000e-02 2.496000e-01 3.949843e-03 3.949843e-03
	+1.749000e+00 4.900000e-02 5.100000e-02 1.995000e-01 3.156467e-03 3.156467e-03
	+1.849000e+00 4.900000e-02 5.100000e-02 1.610000e-01 2.493221e-03 2.493221e-03
	+1.949000e+00 4.900000e-02 5.100000e-02 1.299000e-01 1.992967e-03 1.992967e-03
	+2.049000e+00 4.900000e-02 5.100000e-02 1.058000e-01 1.709575e-03 1.709575e-03
	+2.149000e+00 4.900000e-02 5.100000e-02 8.565000e-02 1.385359e-03 1.385359e-03
	+2.249000e+00 4.900000e-02 5.100000e-02 7.094000e-02 1.140197e-03 1.140197e-03
	+2.349000e+00 4.900000e-02 5.100000e-02 5.837000e-02 9.378345e-04 9.378345e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 4.837000e-02 7.744869e-04 7.744869e-04
	+2.618000e+00 1.180000e-01 1.320000e-01 3.543000e-02 6.065796e-04 6.065796e-04
	+2.868000e+00 1.180000e-01 1.320000e-01 2.294000e-02 3.921494e-04 3.921494e-04
	+3.119000e+00 1.190000e-01 1.310000e-01 1.512000e-02 2.592108e-04 2.592108e-04
	+3.369000e+00 1.190000e-01 1.310000e-01 1.025000e-02 1.724165e-04 1.724165e-04
	+3.726000e+00 2.260000e-01 2.740000e-01 6.006000e-03 1.011434e-04 1.011434e-04
	+4.227000e+00 2.270000e-01 2.730000e-01 3.037000e-03 6.509417e-05 6.509417e-05
	+4.731000e+00 2.310000e-01 2.690000e-01 1.635000e-03 3.570256e-05 3.570256e-05
	+5.431000e+00 4.310000e-01 5.690000e-01 7.646000e-04 1.834067e-05 1.819150e-05
	+6.442000e+00 4.420000e-01 5.580000e-01 2.924000e-04 8.153574e-06 7.963155e-06
	+7.449000e+00 4.490000e-01 5.510000e-01 1.305000e-04 4.321586e-06 4.119696e-06
	+8.458000e+00 4.580000e-01 5.420000e-01 6.447000e-05 2.666233e-06 2.484251e-06
	+9.470000e+00 4.700000e-01 5.300000e-01 3.471000e-05 1.717324e-06 1.636293e-06
	+1.176000e+01 1.760000e+00 3.240000e+00 9.312000e-06 7.419490e-07 6.873682e-07
	+1.683000e+01 1.830000e+00 3.170000e+00 1.272000e-06 1.724469e-07 1.392502e-07
	+2.352000e+01 3.520000e+00 6.480000e+00 2.238000e-07 4.269522e-08 3.636354e-08
	+3.704000e+01 7.040000e+00 1.296000e+01 1.677000e-08 5.028001e-09 4.353485e-09
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d03-x01-y01
	+Path=/REF/ATLAS_2016_I1426695/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-2.450000e+00 5.000000e-02 5.000000e-02 5.947000e+00 2.140374e-01 2.140374e-01
	+-2.350000e+00 5.000000e-02 5.000000e-02 6.034000e+00 2.180367e-01 2.180367e-01
	+-2.250000e+00 5.000000e-02 5.000000e-02 6.051000e+00 1.680476e-01 1.680476e-01
	+-2.150000e+00 5.000000e-02 5.000000e-02 6.101000e+00 1.700471e-01 1.700471e-01
	+-2.050000e+00 5.000000e-02 5.000000e-02 6.114000e+00 1.700265e-01 1.700265e-01
	+-1.950000e+00 5.000000e-02 5.000000e-02 6.110000e+00 1.700471e-01 1.700471e-01
	+-1.850000e+00 5.000000e-02 5.000000e-02 6.087000e+00 1.680268e-01 1.680268e-01
	+-1.750000e+00 5.000000e-02 5.000000e-02 6.143000e+00 1.690266e-01 1.690266e-01
	+-1.650000e+00 5.000000e-02 5.000000e-02 6.205000e+00 1.560513e-01 1.560513e-01
	+-1.550000e+00 5.000000e-02 5.000000e-02 6.188000e+00 1.540519e-01 1.540519e-01
	+-1.450000e+00 5.000000e-02 5.000000e-02 6.116000e+00 1.300615e-01 1.300615e-01
	+-1.350000e+00 5.000000e-02 5.000000e-02 6.082000e+00 1.290349e-01 1.290349e-01
	+-1.250000e+00 5.000000e-02 5.000000e-02 6.075000e+00 1.270354e-01 1.270354e-01
	+-1.150000e+00 5.000000e-02 5.000000e-02 6.060000e+00 1.260357e-01 1.260357e-01
	+-1.050000e+00 5.000000e-02 5.000000e-02 6.023000e+00 1.130398e-01 1.130398e-01
	+-9.500000e-01 5.000000e-02 5.000000e-02 5.977000e+00 1.120402e-01 1.120402e-01
	+-8.500000e-01 5.000000e-02 5.000000e-02 5.929000e+00 1.110405e-01 1.110405e-01
	+-7.500000e-01 5.000000e-02 5.000000e-02 5.886000e+00 1.090413e-01 1.090413e-01
	+-6.500000e-01 5.000000e-02 5.000000e-02 5.829000e+00 1.060424e-01 1.060424e-01
	+-5.500000e-01 5.000000e-02 5.000000e-02 5.781000e+00 1.080417e-01 1.080417e-01
	+-4.500000e-01 5.000000e-02 5.000000e-02 5.738000e+00 1.080417e-01 1.080417e-01
	+-3.500000e-01 5.000000e-02 5.000000e-02 5.696000e+00 1.060754e-01 1.060754e-01
	+-2.500000e-01 5.000000e-02 5.000000e-02 5.651000e+00 1.040769e-01 1.040769e-01
	+-1.500000e-01 5.000000e-02 5.000000e-02 5.649000e+00 1.030776e-01 1.030776e-01
	+-5.000000e-02 5.000000e-02 5.000000e-02 5.644000e+00 1.030776e-01 1.030776e-01
	+5.000000e-02 5.000000e-02 5.000000e-02 5.637000e+00 1.030776e-01 1.030776e-01
	+1.500000e-01 5.000000e-02 5.000000e-02 5.647000e+00 1.040769e-01 1.040769e-01
	+2.500000e-01 5.000000e-02 5.000000e-02 5.672000e+00 1.050762e-01 1.050762e-01
	+3.500000e-01 5.000000e-02 5.000000e-02 5.696000e+00 1.060754e-01 1.060754e-01
	+4.500000e-01 5.000000e-02 5.000000e-02 5.733000e+00 1.080417e-01 1.080417e-01
	+5.500000e-01 5.000000e-02 5.000000e-02 5.791000e+00 1.090413e-01 1.090413e-01
	+6.500000e-01 5.000000e-02 5.000000e-02 5.839000e+00 1.070420e-01 1.070420e-01
	+7.500000e-01 5.000000e-02 5.000000e-02 5.883000e+00 1.090413e-01 1.090413e-01
	+8.500000e-01 5.000000e-02 5.000000e-02 5.930000e+00 1.110405e-01 1.110405e-01
	+9.500000e-01 5.000000e-02 5.000000e-02 5.971000e+00 1.130398e-01 1.130398e-01
	+1.050000e+00 5.000000e-02 5.000000e-02 6.018000e+00 1.150391e-01 1.150391e-01
	+1.150000e+00 5.000000e-02 5.000000e-02 6.062000e+00 1.270354e-01 1.270354e-01
	+1.250000e+00 5.000000e-02 5.000000e-02 6.080000e+00 1.270354e-01 1.270354e-01
	+1.350000e+00 5.000000e-02 5.000000e-02 6.094000e+00 1.290349e-01 1.290349e-01
	+1.450000e+00 5.000000e-02 5.000000e-02 6.125000e+00 1.310611e-01 1.310611e-01
	+1.550000e+00 5.000000e-02 5.000000e-02 6.187000e+00 1.540519e-01 1.540519e-01
	+1.650000e+00 5.000000e-02 5.000000e-02 6.212000e+00 1.570509e-01 1.570509e-01
	+1.750000e+00 5.000000e-02 5.000000e-02 6.156000e+00 1.690473e-01 1.690473e-01
	+1.850000e+00 5.000000e-02 5.000000e-02 6.118000e+00 1.700471e-01 1.700471e-01
	+1.950000e+00 5.000000e-02 5.000000e-02 6.111000e+00 1.700471e-01 1.700471e-01
	+2.050000e+00 5.000000e-02 5.000000e-02 6.133000e+00 1.720465e-01 1.720465e-01
	+2.150000e+00 5.000000e-02 5.000000e-02 6.102000e+00 1.700471e-01 1.700471e-01
	+2.250000e+00 5.000000e-02 5.000000e-02 6.004000e+00 1.680476e-01 1.680476e-01
	+2.350000e+00 5.000000e-02 5.000000e-02 5.955000e+00 2.140374e-01 2.140374e-01
	+2.450000e+00 5.000000e-02 5.000000e-02 5.871000e+00 2.110379e-01 2.110379e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d03-x02-y01
	+Path=/REF/ATLAS_2016_I1426695/d03-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-2.450000e+00 5.000000e-02 5.000000e-02 2.306000e+00 4.804165e-02 4.804165e-02
	+-2.350000e+00 5.000000e-02 5.000000e-02 2.331000e+00 4.904080e-02 4.904080e-02
	+-2.250000e+00 5.000000e-02 5.000000e-02 2.342000e+00 3.905125e-02 3.905125e-02
	+-2.150000e+00 5.000000e-02 5.000000e-02 2.367000e+00 3.905125e-02 3.905125e-02
	+-2.050000e+00 5.000000e-02 5.000000e-02 2.383000e+00 4.004997e-02 4.004997e-02
	+-1.950000e+00 5.000000e-02 5.000000e-02 2.391000e+00 4.004997e-02 4.004997e-02
	+-1.850000e+00 5.000000e-02 5.000000e-02 2.398000e+00 4.004997e-02 4.004997e-02
	+-1.750000e+00 5.000000e-02 5.000000e-02 2.428000e+00 4.004997e-02 4.004997e-02
	+-1.650000e+00 5.000000e-02 5.000000e-02 2.471000e+00 3.805260e-02 3.805260e-02
	+-1.550000e+00 5.000000e-02 5.000000e-02 2.486000e+00 3.805260e-02 3.805260e-02
	+-1.450000e+00 5.000000e-02 5.000000e-02 2.476000e+00 3.106445e-02 3.106445e-02
	+-1.350000e+00 5.000000e-02 5.000000e-02 2.483000e+00 3.106445e-02 3.106445e-02
	+-1.250000e+00 5.000000e-02 5.000000e-02 2.501000e+00 3.106445e-02 3.106445e-02
	+-1.150000e+00 5.000000e-02 5.000000e-02 2.506000e+00 3.106445e-02 3.106445e-02
	+-1.050000e+00 5.000000e-02 5.000000e-02 2.505000e+00 3.106445e-02 3.106445e-02
	+-9.500000e-01 5.000000e-02 5.000000e-02 2.503000e+00 3.106445e-02 3.106445e-02
	+-8.500000e-01 5.000000e-02 5.000000e-02 2.503000e+00 3.106445e-02 3.106445e-02
	+-7.500000e-01 5.000000e-02 5.000000e-02 2.502000e+00 3.106445e-02 3.106445e-02
	+-6.500000e-01 5.000000e-02 5.000000e-02 2.495000e+00 3.106445e-02 3.106445e-02
	+-5.500000e-01 5.000000e-02 5.000000e-02 2.489000e+00 3.106445e-02 3.106445e-02
	+-4.500000e-01 5.000000e-02 5.000000e-02 2.485000e+00 3.106445e-02 3.106445e-02
	+-3.500000e-01 5.000000e-02 5.000000e-02 2.482000e+00 3.106445e-02 3.106445e-02
	+-2.500000e-01 5.000000e-02 5.000000e-02 2.476000e+00 3.106445e-02 3.106445e-02
	+-1.500000e-01 5.000000e-02 5.000000e-02 2.476000e+00 3.106445e-02 3.106445e-02
	+-5.000000e-02 5.000000e-02 5.000000e-02 2.477000e+00 3.106445e-02 3.106445e-02
	+5.000000e-02 5.000000e-02 5.000000e-02 2.477000e+00 3.106445e-02 3.106445e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 2.478000e+00 3.106445e-02 3.106445e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 2.477000e+00 3.106445e-02 3.106445e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 2.483000e+00 3.106445e-02 3.106445e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 2.485000e+00 3.106445e-02 3.106445e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 2.493000e+00 3.106445e-02 3.106445e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 2.494000e+00 3.106445e-02 3.106445e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 2.498000e+00 3.106445e-02 3.106445e-02
	+8.500000e-01 5.000000e-02 5.000000e-02 2.501000e+00 3.106445e-02 3.106445e-02
	+9.500000e-01 5.000000e-02 5.000000e-02 2.502000e+00 3.106445e-02 3.106445e-02
	+1.050000e+00 5.000000e-02 5.000000e-02 2.501000e+00 3.106445e-02 3.106445e-02
	+1.150000e+00 5.000000e-02 5.000000e-02 2.501000e+00 3.106445e-02 3.106445e-02
	+1.250000e+00 5.000000e-02 5.000000e-02 2.496000e+00 3.106445e-02 3.106445e-02
	+1.350000e+00 5.000000e-02 5.000000e-02 2.482000e+00 3.106445e-02 3.106445e-02
	+1.450000e+00 5.000000e-02 5.000000e-02 2.472000e+00 3.106445e-02 3.106445e-02
	+1.550000e+00 5.000000e-02 5.000000e-02 2.486000e+00 3.805260e-02 3.805260e-02
	+1.650000e+00 5.000000e-02 5.000000e-02 2.478000e+00 3.805260e-02 3.805260e-02
	+1.750000e+00 5.000000e-02 5.000000e-02 2.430000e+00 4.004997e-02 4.004997e-02
	+1.850000e+00 5.000000e-02 5.000000e-02 2.409000e+00 4.004997e-02 4.004997e-02
	+1.950000e+00 5.000000e-02 5.000000e-02 2.394000e+00 4.004997e-02 4.004997e-02
	+2.050000e+00 5.000000e-02 5.000000e-02 2.386000e+00 4.004997e-02 4.004997e-02
	+2.150000e+00 5.000000e-02 5.000000e-02 2.368000e+00 3.905125e-02 3.905125e-02
	+2.250000e+00 5.000000e-02 5.000000e-02 2.335000e+00 3.905125e-02 3.905125e-02
	+2.350000e+00 5.000000e-02 5.000000e-02 2.309000e+00 4.804165e-02 4.804165e-02
	+2.450000e+00 5.000000e-02 5.000000e-02 2.280000e+00 4.704253e-02 4.704253e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d03-x03-y01
	+Path=/REF/ATLAS_2016_I1426695/d03-x03-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-2.450000e+00 5.000000e-02 5.000000e-02 3.344000e+00 6.307139e-02 6.307139e-02
	+-2.350000e+00 5.000000e-02 5.000000e-02 3.389000e+00 6.307139e-02 6.307139e-02
	+-2.250000e+00 5.000000e-02 5.000000e-02 3.411000e+00 4.909175e-02 4.909175e-02
	+-2.150000e+00 5.000000e-02 5.000000e-02 3.455000e+00 4.909175e-02 4.909175e-02
	+-2.050000e+00 5.000000e-02 5.000000e-02 3.486000e+00 5.008992e-02 5.008992e-02
	+-1.950000e+00 5.000000e-02 5.000000e-02 3.503000e+00 5.008992e-02 5.008992e-02
	+-1.850000e+00 5.000000e-02 5.000000e-02 3.518000e+00 5.008992e-02 5.008992e-02
	+-1.750000e+00 5.000000e-02 5.000000e-02 3.569000e+00 5.008992e-02 5.008992e-02
	+-1.650000e+00 5.000000e-02 5.000000e-02 3.636000e+00 4.609772e-02 4.609772e-02
	+-1.550000e+00 5.000000e-02 5.000000e-02 3.662000e+00 4.609772e-02 4.609772e-02
	+-1.450000e+00 5.000000e-02 5.000000e-02 3.652000e+00 3.612478e-02 3.612478e-02
	+-1.350000e+00 5.000000e-02 5.000000e-02 3.666000e+00 3.612478e-02 3.612478e-02
	+-1.250000e+00 5.000000e-02 5.000000e-02 3.697000e+00 3.712142e-02 3.712142e-02
	+-1.150000e+00 5.000000e-02 5.000000e-02 3.707000e+00 3.712142e-02 3.712142e-02
	+-1.050000e+00 5.000000e-02 5.000000e-02 3.708000e+00 3.712142e-02 3.712142e-02
	+-9.500000e-01 5.000000e-02 5.000000e-02 3.708000e+00 3.712142e-02 3.712142e-02
	+-8.500000e-01 5.000000e-02 5.000000e-02 3.713000e+00 3.712142e-02 3.712142e-02
	+-7.500000e-01 5.000000e-02 5.000000e-02 3.713000e+00 3.612478e-02 3.612478e-02
	+-6.500000e-01 5.000000e-02 5.000000e-02 3.703000e+00 3.712142e-02 3.712142e-02
	+-5.500000e-01 5.000000e-02 5.000000e-02 3.698000e+00 3.612478e-02 3.612478e-02
	+-4.500000e-01 5.000000e-02 5.000000e-02 3.693000e+00 3.612478e-02 3.612478e-02
	+-3.500000e-01 5.000000e-02 5.000000e-02 3.690000e+00 3.612478e-02 3.612478e-02
	+-2.500000e-01 5.000000e-02 5.000000e-02 3.682000e+00 3.612478e-02 3.612478e-02
	+-1.500000e-01 5.000000e-02 5.000000e-02 3.683000e+00 3.612478e-02 3.612478e-02
	+-5.000000e-02 5.000000e-02 5.000000e-02 3.685000e+00 3.612478e-02 3.612478e-02
	+5.000000e-02 5.000000e-02 5.000000e-02 3.684000e+00 3.612478e-02 3.612478e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 3.685000e+00 3.612478e-02 3.612478e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 3.684000e+00 3.612478e-02 3.612478e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 3.691000e+00 3.612478e-02 3.612478e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 3.694000e+00 3.612478e-02 3.612478e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 3.703000e+00 3.712142e-02 3.712142e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 3.703000e+00 3.612478e-02 3.612478e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 3.706000e+00 3.612478e-02 3.612478e-02
	+8.500000e-01 5.000000e-02 5.000000e-02 3.708000e+00 3.712142e-02 3.712142e-02
	+9.500000e-01 5.000000e-02 5.000000e-02 3.706000e+00 3.712142e-02 3.712142e-02
	+1.050000e+00 5.000000e-02 5.000000e-02 3.703000e+00 3.712142e-02 3.712142e-02
	+1.150000e+00 5.000000e-02 5.000000e-02 3.699000e+00 3.712142e-02 3.712142e-02
	+1.250000e+00 5.000000e-02 5.000000e-02 3.689000e+00 3.712142e-02 3.712142e-02
	+1.350000e+00 5.000000e-02 5.000000e-02 3.665000e+00 3.612478e-02 3.612478e-02
	+1.450000e+00 5.000000e-02 5.000000e-02 3.646000e+00 3.612478e-02 3.612478e-02
	+1.550000e+00 5.000000e-02 5.000000e-02 3.662000e+00 4.609772e-02 4.609772e-02
	+1.650000e+00 5.000000e-02 5.000000e-02 3.646000e+00 4.609772e-02 4.609772e-02
	+1.750000e+00 5.000000e-02 5.000000e-02 3.573000e+00 5.008992e-02 5.008992e-02
	+1.850000e+00 5.000000e-02 5.000000e-02 3.536000e+00 5.008992e-02 5.008992e-02
	+1.950000e+00 5.000000e-02 5.000000e-02 3.508000e+00 5.008992e-02 5.008992e-02
	+2.050000e+00 5.000000e-02 5.000000e-02 3.488000e+00 5.008992e-02 5.008992e-02
	+2.150000e+00 5.000000e-02 5.000000e-02 3.457000e+00 4.909175e-02 4.909175e-02
	+2.250000e+00 5.000000e-02 5.000000e-02 3.403000e+00 4.909175e-02 4.909175e-02
	+2.350000e+00 5.000000e-02 5.000000e-02 3.357000e+00 6.307139e-02 6.307139e-02
	+2.450000e+00 5.000000e-02 5.000000e-02 3.306000e+00 6.207254e-02 6.207254e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d03-x04-y01
	+Path=/REF/ATLAS_2016_I1426695/d03-x04-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-2.450000e+00 5.000000e-02 5.000000e-02 5.612000e+00 1.041729e-01 1.041729e-01
	+-2.350000e+00 5.000000e-02 5.000000e-02 5.709000e+00 1.061697e-01 1.061697e-01
	+-2.250000e+00 5.000000e-02 5.000000e-02 5.773000e+00 8.321658e-02 8.321658e-02
	+-2.150000e+00 5.000000e-02 5.000000e-02 5.867000e+00 8.421401e-02 8.421401e-02
	+-2.050000e+00 5.000000e-02 5.000000e-02 5.937000e+00 8.421401e-02 8.421401e-02
	+-1.950000e+00 5.000000e-02 5.000000e-02 6.000000e+00 8.521150e-02 8.521150e-02
	+-1.850000e+00 5.000000e-02 5.000000e-02 6.042000e+00 8.521150e-02 8.521150e-02
	+-1.750000e+00 5.000000e-02 5.000000e-02 6.149000e+00 8.620905e-02 8.620905e-02
	+-1.650000e+00 5.000000e-02 5.000000e-02 6.275000e+00 7.025667e-02 7.025667e-02
	+-1.550000e+00 5.000000e-02 5.000000e-02 6.334000e+00 7.025667e-02 7.025667e-02
	+-1.450000e+00 5.000000e-02 5.000000e-02 6.330000e+00 5.333854e-02 5.333854e-02
	+-1.350000e+00 5.000000e-02 5.000000e-02 6.372000e+00 5.433231e-02 5.433231e-02
	+-1.250000e+00 5.000000e-02 5.000000e-02 6.440000e+00 5.433231e-02 5.433231e-02
	+-1.150000e+00 5.000000e-02 5.000000e-02 6.467000e+00 5.532630e-02 5.532630e-02
	+-1.050000e+00 5.000000e-02 5.000000e-02 6.485000e+00 5.433231e-02 5.433231e-02
	+-9.500000e-01 5.000000e-02 5.000000e-02 6.493000e+00 5.532630e-02 5.532630e-02
	+-8.500000e-01 5.000000e-02 5.000000e-02 6.510000e+00 5.433231e-02 5.433231e-02
	+-7.500000e-01 5.000000e-02 5.000000e-02 6.526000e+00 5.433231e-02 5.433231e-02
	+-6.500000e-01 5.000000e-02 5.000000e-02 6.507000e+00 5.433231e-02 5.433231e-02
	+-5.500000e-01 5.000000e-02 5.000000e-02 6.514000e+00 5.433231e-02 5.433231e-02
	+-4.500000e-01 5.000000e-02 5.000000e-02 6.503000e+00 5.433231e-02 5.433231e-02
	+-3.500000e-01 5.000000e-02 5.000000e-02 6.503000e+00 5.333854e-02 5.333854e-02
	+-2.500000e-01 5.000000e-02 5.000000e-02 6.506000e+00 5.433231e-02 5.433231e-02
	+-1.500000e-01 5.000000e-02 5.000000e-02 6.501000e+00 5.433231e-02 5.433231e-02
	+-5.000000e-02 5.000000e-02 5.000000e-02 6.500000e+00 5.333854e-02 5.333854e-02
	+5.000000e-02 5.000000e-02 5.000000e-02 6.500000e+00 5.433231e-02 5.433231e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 6.503000e+00 5.433231e-02 5.433231e-02
	+2.500000e-01 5.000000e-02 5.000000e-02 6.494000e+00 5.433231e-02 5.433231e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 6.508000e+00 5.433231e-02 5.433231e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 6.512000e+00 5.433231e-02 5.433231e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 6.518000e+00 5.433231e-02 5.433231e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 6.513000e+00 5.433231e-02 5.433231e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 6.510000e+00 5.433231e-02 5.433231e-02
	+8.500000e-01 5.000000e-02 5.000000e-02 6.500000e+00 5.433231e-02 5.433231e-02
	+9.500000e-01 5.000000e-02 5.000000e-02 6.490000e+00 5.433231e-02 5.433231e-02
	+1.050000e+00 5.000000e-02 5.000000e-02 6.472000e+00 5.433231e-02 5.433231e-02
	+1.150000e+00 5.000000e-02 5.000000e-02 6.444000e+00 5.433231e-02 5.433231e-02
	+1.250000e+00 5.000000e-02 5.000000e-02 6.426000e+00 5.532630e-02 5.532630e-02
	+1.350000e+00 5.000000e-02 5.000000e-02 6.370000e+00 5.433231e-02 5.433231e-02
	+1.450000e+00 5.000000e-02 5.000000e-02 6.321000e+00 5.333854e-02 5.333854e-02
	+1.550000e+00 5.000000e-02 5.000000e-02 6.329000e+00 7.025667e-02 7.025667e-02
	+1.650000e+00 5.000000e-02 5.000000e-02 6.293000e+00 7.025667e-02 7.025667e-02
	+1.750000e+00 5.000000e-02 5.000000e-02 6.144000e+00 8.620905e-02 8.620905e-02
	+1.850000e+00 5.000000e-02 5.000000e-02 6.067000e+00 8.521150e-02 8.521150e-02
	+1.950000e+00 5.000000e-02 5.000000e-02 5.992000e+00 8.421401e-02 8.421401e-02
	+2.050000e+00 5.000000e-02 5.000000e-02 5.948000e+00 8.521150e-02 8.521150e-02
	+2.150000e+00 5.000000e-02 5.000000e-02 5.870000e+00 8.321658e-02 8.321658e-02
	+2.250000e+00 5.000000e-02 5.000000e-02 5.758000e+00 8.221922e-02 8.221922e-02
	+2.350000e+00 5.000000e-02 5.000000e-02 5.653000e+00 1.051713e-01 1.051713e-01
	+2.450000e+00 5.000000e-02 5.000000e-02 5.544000e+00 1.031746e-01 1.031746e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d03-x05-y01
	+Path=/REF/ATLAS_2016_I1426695/d03-x05-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-2.450000e+00 5.000000e-02 5.000000e-02 9.957000e+00 2.324586e-01 2.324586e-01
	+-2.350000e+00 5.000000e-02 5.000000e-02 1.015000e+01 2.384219e-01 2.384219e-01
	+-2.250000e+00 5.000000e-02 5.000000e-02 1.035000e+01 2.005642e-01 2.005642e-01
	+-2.150000e+00 5.000000e-02 5.000000e-02 1.058000e+01 2.045336e-01 2.045336e-01
	+-2.050000e+00 5.000000e-02 5.000000e-02 1.076000e+01 2.066422e-01 2.066422e-01
	+-1.950000e+00 5.000000e-02 5.000000e-02 1.096000e+01 2.106110e-01 2.106110e-01
	+-1.850000e+00 5.000000e-02 5.000000e-02 1.113000e+01 2.096187e-01 2.096187e-01
	+-1.750000e+00 5.000000e-02 5.000000e-02 1.129000e+01 2.135884e-01 2.135884e-01
	+-1.650000e+00 5.000000e-02 5.000000e-02 1.157000e+01 1.709883e-01 1.709883e-01
	+-1.550000e+00 5.000000e-02 5.000000e-02 1.172000e+01 1.690118e-01 1.690118e-01
	+-1.450000e+00 5.000000e-02 5.000000e-02 1.175000e+01 1.423938e-01 1.423938e-01
	+-1.350000e+00 5.000000e-02 5.000000e-02 1.187000e+01 1.423938e-01 1.423938e-01
	+-1.250000e+00 5.000000e-02 5.000000e-02 1.203000e+01 1.453444e-01 1.453444e-01
	+-1.150000e+00 5.000000e-02 5.000000e-02 1.211000e+01 1.433771e-01 1.433771e-01
	+-1.050000e+00 5.000000e-02 5.000000e-02 1.215000e+01 1.443607e-01 1.443607e-01
	+-9.500000e-01 5.000000e-02 5.000000e-02 1.222000e+01 1.443607e-01 1.443607e-01
	+-8.500000e-01 5.000000e-02 5.000000e-02 1.231000e+01 1.443607e-01 1.443607e-01
	+-7.500000e-01 5.000000e-02 5.000000e-02 1.239000e+01 1.433771e-01 1.433771e-01
	+-6.500000e-01 5.000000e-02 5.000000e-02 1.237000e+01 1.473126e-01 1.473126e-01
	+-5.500000e-01 5.000000e-02 5.000000e-02 1.240000e+01 1.443607e-01 1.443607e-01
	+-4.500000e-01 5.000000e-02 5.000000e-02 1.235000e+01 1.441839e-01 1.441839e-01
	+-3.500000e-01 5.000000e-02 5.000000e-02 1.238000e+01 1.443607e-01 1.443607e-01
	+-2.500000e-01 5.000000e-02 5.000000e-02 1.238000e+01 1.453444e-01 1.453444e-01
	+-1.500000e-01 5.000000e-02 5.000000e-02 1.239000e+01 1.453444e-01 1.453444e-01
	+-5.000000e-02 5.000000e-02 5.000000e-02 1.238000e+01 1.443607e-01 1.443607e-01
	+5.000000e-02 5.000000e-02 5.000000e-02 1.240000e+01 1.453444e-01 1.453444e-01
	+1.500000e-01 5.000000e-02 5.000000e-02 1.242000e+01 1.433771e-01 1.433771e-01
	+2.500000e-01 5.000000e-02 5.000000e-02 1.237000e+01 1.422146e-01 1.422146e-01
	+3.500000e-01 5.000000e-02 5.000000e-02 1.237000e+01 1.451689e-01 1.451689e-01
	+4.500000e-01 5.000000e-02 5.000000e-02 1.237000e+01 1.451689e-01 1.451689e-01
	+5.500000e-01 5.000000e-02 5.000000e-02 1.240000e+01 1.453444e-01 1.453444e-01
	+6.500000e-01 5.000000e-02 5.000000e-02 1.239000e+01 1.443607e-01 1.443607e-01
	+7.500000e-01 5.000000e-02 5.000000e-02 1.231000e+01 1.423938e-01 1.423938e-01
	+8.500000e-01 5.000000e-02 5.000000e-02 1.232000e+01 1.463284e-01 1.463284e-01
	+9.500000e-01 5.000000e-02 5.000000e-02 1.224000e+01 1.463284e-01 1.463284e-01
	+1.050000e+00 5.000000e-02 5.000000e-02 1.214000e+01 1.463284e-01 1.463284e-01
	+1.150000e+00 5.000000e-02 5.000000e-02 1.209000e+01 1.463284e-01 1.463284e-01
	+1.250000e+00 5.000000e-02 5.000000e-02 1.208000e+01 1.433771e-01 1.433771e-01
	+1.350000e+00 5.000000e-02 5.000000e-02 1.191000e+01 1.423938e-01 1.423938e-01
	+1.450000e+00 5.000000e-02 5.000000e-02 1.177000e+01 1.433771e-01 1.433771e-01
	+1.550000e+00 5.000000e-02 5.000000e-02 1.173000e+01 1.690118e-01 1.690118e-01
	+1.650000e+00 5.000000e-02 5.000000e-02 1.161000e+01 1.690118e-01 1.690118e-01
	+1.750000e+00 5.000000e-02 5.000000e-02 1.128000e+01 2.145810e-01 2.145810e-01
	+1.850000e+00 5.000000e-02 5.000000e-02 1.109000e+01 2.086265e-01 2.086265e-01
	+1.950000e+00 5.000000e-02 5.000000e-02 1.093000e+01 2.116034e-01 2.116034e-01
	+2.050000e+00 5.000000e-02 5.000000e-02 1.079000e+01 2.086265e-01 2.086265e-01
	+2.150000e+00 5.000000e-02 5.000000e-02 1.061000e+01 2.055262e-01 2.055262e-01
	+2.250000e+00 5.000000e-02 5.000000e-02 1.031000e+01 2.015564e-01 2.015564e-01
	+2.350000e+00 5.000000e-02 5.000000e-02 1.007000e+01 2.353317e-01 2.353317e-01
	+2.450000e+00 5.000000e-02 5.000000e-02 9.822000e+00 2.314649e-01 2.314649e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d04-x01-y01
	+Path=/REF/ATLAS_2016_I1426695/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+00 5.000000e-01 5.000000e-01 4.388000e-01 1.987926e-02 1.987926e-02
	+3.000000e+00 5.000000e-01 5.000000e-01 4.390000e-01 1.552979e-02 1.552979e-02
	+4.000000e+00 5.000000e-01 5.000000e-01 4.392000e-01 1.122719e-02 1.122719e-02
	+5.000000e+00 5.000000e-01 5.000000e-01 4.396000e-01 9.117755e-03 9.117755e-03
	+6.000000e+00 5.000000e-01 5.000000e-01 4.405000e-01 9.163179e-03 9.163179e-03
	+7.000000e+00 5.000000e-01 5.000000e-01 4.420000e-01 9.223257e-03 9.223257e-03
	+8.000000e+00 5.000000e-01 5.000000e-01 4.439000e-01 9.295673e-03 9.295673e-03
	+9.000000e+00 5.000000e-01 5.000000e-01 4.463000e-01 9.377281e-03 9.377281e-03
	+1.000000e+01 5.000000e-01 5.000000e-01 4.491000e-01 9.473001e-03 9.473001e-03
	+1.100000e+01 5.000000e-01 5.000000e-01 4.524000e-01 9.581802e-03 9.581802e-03
	+1.200000e+01 5.000000e-01 5.000000e-01 4.560000e-01 7.599111e-03 7.599111e-03
	+1.300000e+01 5.000000e-01 5.000000e-01 4.601000e-01 5.756633e-03 5.756633e-03
	+1.400000e+01 5.000000e-01 5.000000e-01 4.644000e-01 5.879476e-03 5.879476e-03
	+1.500000e+01 5.000000e-01 5.000000e-01 4.689000e-01 6.001355e-03 6.001355e-03
	+1.600000e+01 5.000000e-01 5.000000e-01 4.735000e-01 6.115259e-03 6.115259e-03
	+1.700000e+01 5.000000e-01 5.000000e-01 4.782000e-01 6.223188e-03 6.223188e-03
	+1.800000e+01 5.000000e-01 5.000000e-01 4.828000e-01 6.321130e-03 6.321130e-03
	+1.900000e+01 5.000000e-01 5.000000e-01 4.874000e-01 6.407081e-03 6.407081e-03
	+2.000000e+01 5.000000e-01 5.000000e-01 4.918000e-01 6.480038e-03 6.480038e-03
	+2.100000e+01 5.000000e-01 5.000000e-01 4.961000e-01 6.543006e-03 6.543006e-03
	+2.200000e+01 5.000000e-01 5.000000e-01 5.002000e-01 6.597977e-03 6.597977e-03
	+2.300000e+01 5.000000e-01 5.000000e-01 5.041000e-01 6.646948e-03 6.646948e-03
	+2.400000e+01 5.000000e-01 5.000000e-01 5.078000e-01 6.694917e-03 6.694917e-03
	+2.500000e+01 5.000000e-01 5.000000e-01 5.114000e-01 6.741887e-03 6.741887e-03
	+2.600000e+01 5.000000e-01 5.000000e-01 5.149000e-01 6.789864e-03 6.789864e-03
	+2.700000e+01 5.000000e-01 5.000000e-01 5.182000e-01 6.836844e-03 6.836844e-03
	+2.800000e+01 5.000000e-01 5.000000e-01 5.213000e-01 6.883820e-03 6.883820e-03
	+2.900000e+01 5.000000e-01 5.000000e-01 5.244000e-01 6.930794e-03 6.930794e-03
	+3.000000e+01 5.000000e-01 5.000000e-01 5.274000e-01 6.974774e-03 6.974774e-03
	+3.100000e+01 5.000000e-01 5.000000e-01 5.303000e-01 7.017756e-03 7.017756e-03
	+3.200000e+01 5.000000e-01 5.000000e-01 5.331000e-01 7.058746e-03 7.058746e-03
	+3.300000e+01 5.000000e-01 5.000000e-01 5.359000e-01 7.097721e-03 7.097721e-03
	+3.400000e+01 5.000000e-01 5.000000e-01 5.386000e-01 7.134714e-03 7.134714e-03
	+3.500000e+01 5.000000e-01 5.000000e-01 5.411000e-01 7.169702e-03 7.169702e-03
	+3.600000e+01 5.000000e-01 5.000000e-01 5.437000e-01 7.204689e-03 7.204689e-03
	+3.700000e+01 5.000000e-01 5.000000e-01 5.463000e-01 7.237688e-03 7.237688e-03
	+3.800000e+01 5.000000e-01 5.000000e-01 5.487000e-01 7.267677e-03 7.267677e-03
	+3.900000e+01 5.000000e-01 5.000000e-01 5.510000e-01 7.297674e-03 7.297674e-03
	+4.000000e+01 5.000000e-01 5.000000e-01 5.533000e-01 7.326669e-03 7.326669e-03
	+4.100000e+01 5.000000e-01 5.000000e-01 5.557000e-01 7.357671e-03 7.357671e-03
	+4.200000e+01 5.000000e-01 5.000000e-01 5.578000e-01 7.386671e-03 7.386671e-03
	+4.300000e+01 5.000000e-01 5.000000e-01 5.600000e-01 7.417666e-03 7.417666e-03
	+4.400000e+01 5.000000e-01 5.000000e-01 5.622000e-01 7.448678e-03 7.448678e-03
	+4.500000e+01 5.000000e-01 5.000000e-01 5.643000e-01 7.481671e-03 7.481671e-03
	+4.600000e+01 5.000000e-01 5.000000e-01 5.663000e-01 7.513676e-03 7.513676e-03
	+4.700000e+01 5.000000e-01 5.000000e-01 5.684000e-01 7.546681e-03 7.546681e-03
	+4.800000e+01 5.000000e-01 5.000000e-01 5.704000e-01 7.578691e-03 7.578691e-03
	+4.900000e+01 5.000000e-01 5.000000e-01 5.724000e-01 7.609684e-03 7.609684e-03
	+5.000000e+01 5.000000e-01 5.000000e-01 5.743000e-01 7.639701e-03 7.639701e-03
	+5.100000e+01 5.000000e-01 5.000000e-01 5.762000e-01 7.665718e-03 7.665718e-03
	+5.200000e+01 5.000000e-01 5.000000e-01 5.781000e-01 7.691729e-03 7.691729e-03
	+5.300000e+01 5.000000e-01 5.000000e-01 5.799000e-01 7.712720e-03 7.712720e-03
	+5.400000e+01 5.000000e-01 5.000000e-01 5.817000e-01 7.736745e-03 7.736745e-03
	+5.500000e+01 5.000000e-01 5.000000e-01 5.835000e-01 7.758765e-03 7.758765e-03
	+5.600000e+01 5.000000e-01 5.000000e-01 5.851000e-01 7.777774e-03 7.777774e-03
	+5.700000e+01 5.000000e-01 5.000000e-01 5.869000e-01 7.800796e-03 7.800796e-03
	+5.800000e+01 5.000000e-01 5.000000e-01 5.885000e-01 7.820815e-03 7.820815e-03
	+5.900000e+01 5.000000e-01 5.000000e-01 5.902000e-01 7.843829e-03 7.843829e-03
	+6.000000e+01 5.000000e-01 5.000000e-01 5.918000e-01 7.866852e-03 7.866852e-03
	+6.149000e+01 9.900000e-01 1.010000e+00 5.942000e-01 7.902942e-03 7.902942e-03
	+6.349000e+01 9.900000e-01 1.010000e+00 5.974000e-01 7.956968e-03 7.956968e-03
	+6.549000e+01 9.900000e-01 1.010000e+00 6.005000e-01 8.011994e-03 8.011994e-03
	+6.749000e+01 9.900000e-01 1.010000e+00 6.035000e-01 8.064021e-03 8.064021e-03
	+6.949000e+01 9.900000e-01 1.010000e+00 6.065000e-01 8.107055e-03 8.107055e-03
	+7.149000e+01 9.900000e-01 1.010000e+00 6.094000e-01 8.141098e-03 8.141098e-03
	+7.349000e+01 9.900000e-01 1.010000e+00 6.122000e-01 8.167134e-03 8.167134e-03
	+7.549000e+01 9.900000e-01 1.010000e+00 6.150000e-01 8.192181e-03 8.192181e-03
	+7.749000e+01 9.900000e-01 1.010000e+00 6.176000e-01 8.218236e-03 8.218236e-03
	+7.949000e+01 9.900000e-01 1.010000e+00 6.202000e-01 8.247292e-03 8.247292e-03
	+8.149000e+01 9.900000e-01 1.010000e+00 6.227000e-01 8.279350e-03 8.279350e-03
	+8.349000e+01 9.900000e-01 1.010000e+00 6.252000e-01 8.314413e-03 8.314413e-03
	+8.549000e+01 9.900000e-01 1.010000e+00 6.276000e-01 8.350480e-03 8.350480e-03
	+8.749000e+01 9.900000e-01 1.010000e+00 6.300000e-01 8.386555e-03 8.386555e-03
	+8.949000e+01 9.900000e-01 1.010000e+00 6.324000e-01 8.424642e-03 8.424642e-03
	+9.149000e+01 9.900000e-01 1.010000e+00 6.347000e-01 8.461724e-03 8.461724e-03
	+9.349000e+01 9.900000e-01 1.010000e+00 6.370000e-01 8.498829e-03 8.498829e-03
	+9.549000e+01 9.900000e-01 1.010000e+00 6.393000e-01 8.529925e-03 8.529925e-03
	+9.749000e+01 9.900000e-01 1.010000e+00 6.415000e-01 8.559043e-03 8.559043e-03
	+9.949000e+01 9.900000e-01 1.010000e+00 6.437000e-01 8.586154e-03 8.586154e-03
	+1.015000e+02 1.000000e+00 1.000000e+00 6.458000e-01 8.602297e-03 8.602297e-03
	+1.063000e+02 3.800000e+00 4.200000e+00 6.508000e-01 8.654679e-03 8.654679e-03
	+1.151000e+02 4.600000e+00 5.400000e+00 6.595000e-01 8.809743e-03 8.809743e-03
	+1.251000e+02 4.600000e+00 5.400000e+00 6.693000e-01 8.975087e-03 8.975087e-03
	+1.414000e+02 1.090000e+01 1.910000e+01 6.848000e-01 1.016076e-02 1.016076e-02
	+1.724000e+02 1.190000e+01 2.810000e+01 7.099000e-01 1.230351e-02 1.230351e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1426695/d04-x02-y01
	+Path=/REF/ATLAS_2016_I1426695/d04-x02-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 5.000000e-01 5.000000e-01 7.710000e-01 1.931988e-02 1.931988e-02
	+2.000000e+00 5.000000e-01 5.000000e-01 7.873000e-01 1.970104e-02 1.970104e-02
	+3.000000e+00 5.000000e-01 5.000000e-01 8.053000e-01 1.613849e-02 1.613849e-02
	+4.000000e+00 5.000000e-01 5.000000e-01 8.240000e-01 1.240857e-02 1.240857e-02
	+5.000000e+00 5.000000e-01 5.000000e-01 8.427000e-01 8.516766e-03 8.516766e-03
	+6.000000e+00 5.000000e-01 5.000000e-01 8.603000e-01 4.503556e-03 4.503556e-03
	+7.000000e+00 5.000000e-01 5.000000e-01 8.764000e-01 4.604972e-03 4.604972e-03
	+8.000000e+00 5.000000e-01 5.000000e-01 8.909000e-01 4.677837e-03 4.677837e-03
	+9.000000e+00 5.000000e-01 5.000000e-01 9.038000e-01 4.735000e-03 4.735000e-03
	+1.000000e+01 5.000000e-01 5.000000e-01 9.153000e-01 4.789260e-03 4.789260e-03
	+1.100000e+01 5.000000e-01 5.000000e-01 9.257000e-01 4.836679e-03 4.836679e-03
	+1.200000e+01 5.000000e-01 5.000000e-01 9.353000e-01 4.878198e-03 4.878198e-03
	+1.300000e+01 5.000000e-01 5.000000e-01 9.440000e-01 4.919817e-03 4.919817e-03
	+1.400000e+01 5.000000e-01 5.000000e-01 9.521000e-01 4.962464e-03 4.962464e-03
	+1.500000e+01 5.000000e-01 5.000000e-01 9.598000e-01 5.004248e-03 5.004248e-03
	+1.600000e+01 5.000000e-01 5.000000e-01 9.669000e-01 5.040029e-03 5.040029e-03
	+1.700000e+01 5.000000e-01 5.000000e-01 9.736000e-01 5.072937e-03 5.072937e-03
	+1.800000e+01 5.000000e-01 5.000000e-01 9.799000e-01 5.101855e-03 5.101855e-03
	+1.900000e+01 5.000000e-01 5.000000e-01 9.859000e-01 5.126858e-03 5.126858e-03
	+2.000000e+01 5.000000e-01 5.000000e-01 9.915000e-01 5.149873e-03 5.149873e-03
	+2.100000e+01 5.000000e-01 5.000000e-01 9.969000e-01 5.171945e-03 5.171945e-03
	+2.200000e+01 5.000000e-01 5.000000e-01 1.002000e+00 5.196975e-03 5.196975e-03
	+2.300000e+01 5.000000e-01 5.000000e-01 1.007000e+00 5.225033e-03 5.225033e-03
	+2.400000e+01 5.000000e-01 5.000000e-01 1.012000e+00 5.254176e-03 5.254176e-03
	+2.500000e+01 5.000000e-01 5.000000e-01 1.017000e+00 5.282350e-03 5.282350e-03
	+2.600000e+01 5.000000e-01 5.000000e-01 1.021000e+00 5.305488e-03 5.305488e-03
	+2.700000e+01 5.000000e-01 5.000000e-01 1.025000e+00 5.325743e-03 5.325743e-03
	+2.800000e+01 5.000000e-01 5.000000e-01 1.029000e+00 5.341006e-03 5.341006e-03
	+2.900000e+01 5.000000e-01 5.000000e-01 1.033000e+00 5.356277e-03 5.356277e-03
	+3.000000e+01 5.000000e-01 5.000000e-01 1.037000e+00 5.372619e-03 5.372619e-03
	+3.148000e+01 9.800000e-01 1.020000e+00 1.043000e+00 5.395100e-03 5.395100e-03
	+3.395000e+01 1.450000e+00 1.550000e+00 1.051000e+00 5.446120e-03 5.446120e-03
	+3.785000e+01 2.350000e+00 2.650000e+00 1.064000e+00 5.520548e-03 5.520548e-03
	+4.486000e+01 4.360000e+00 5.640000e+00 1.085000e+00 5.628460e-03 5.628460e-03
	+5.479000e+01 4.290000e+00 5.710000e+00 1.111000e+00 5.750275e-03 5.750275e-03
	+6.474000e+01 4.240000e+00 5.760000e+00 1.133000e+00 5.952235e-03 5.952235e-03
	+7.469000e+01 4.190000e+00 5.810000e+00 1.156000e+00 6.128379e-03 6.128379e-03
	+8.743000e+01 6.930000e+00 1.307000e+01 1.181000e+00 6.233548e-03 6.233548e-03
	+1.067000e+02 6.200000e+00 1.380000e+01 1.220000e+00 7.586393e-03 7.586393e-03
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1444991.yoda b/data/refdata/ATLAS_2016_I1444991.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1444991.yoda
	@@ -0,0 +1,98 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d01-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 0.000000e+00 0.000000e+00 3.600000e+01 1.003145e+01 1.003145e+01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d02-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.000000e+00 5.000000e-01 5.000000e-01 1.900000e+01 6.833740e+00 6.833740e+00
	+1.000000e+00 5.000000e-01 5.000000e-01 8.200000e+00 3.952215e+00 3.952215e+00
	+2.000000e+00 5.000000e-01 5.000000e-01 8.800000e+00 5.887274e+00 5.887274e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d03-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+01 1.000000e+01 1.000000e+01 6.100000e-01 2.839225e-01 2.839225e-01
	+4.000000e+01 2.000000e+01 2.000000e+01 3.900000e-01 1.344805e-01 1.344805e-01
	+1.800000e+02 1.200000e+02 1.200000e+02 3.400000e-02 2.543619e-02 2.543619e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d04-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-01 3.000000e-01 3.000000e-01 3.100000e+01 9.995499e+00 9.995499e+00
	+9.000000e-01 3.000000e-01 3.000000e-01 9.500000e+00 6.341136e+00 6.341136e+00
	+1.850000e+00 6.500000e-01 6.500000e-01 9.500000e+00 6.004165e+00 6.004165e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d05-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.500000e+01 1.500000e+01 1.500000e+01 6.900000e-01 2.402228e-01 2.402228e-01
	+4.500000e+01 1.500000e+01 1.500000e+01 2.600000e-01 1.267123e-01 1.267123e-01
	+1.800000e+02 1.200000e+02 1.200000e+02 3.400000e-02 2.963436e+00 2.963436e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d06-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.000000e+00 5.000000e-01 5.000000e-01 5.300000e-01 1.394825e-01 1.394825e-01
	+1.000000e+00 5.000000e-01 5.000000e-01 2.300000e-01 1.007291e-01 1.007291e-01
	+2.000000e+00 5.000000e-01 5.000000e-01 2.400000e-01 1.417939e-01 1.417939e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d07-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+01 1.000000e+01 1.000000e+01 1.700000e-02 5.949697e-03 5.949697e-03
	+4.000000e+01 2.000000e+01 2.000000e+01 1.100000e-02 3.266053e-03 3.266053e-03
	+1.800000e+02 1.200000e+02 1.200000e+02 9.600000e-04 6.222604e-04 6.222604e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d08-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-01 3.000000e-01 3.000000e-01 8.300000e-01 2.232706e-01 2.232706e-01
	+9.000000e-01 3.000000e-01 3.000000e-01 2.700000e-01 1.553430e-01 1.553430e-01
	+1.850000e+00 6.500000e-01 6.500000e-01 2.600000e-01 1.097523e-01 1.097523e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d09-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.500000e+01 1.500000e+01 1.500000e+01 1.900000e-02 4.693517e-03 4.693517e-03
	+4.500000e+01 1.500000e+01 1.500000e+01 7.000000e-03 3.331261e-03 3.331261e-03
	+1.800000e+02 1.200000e+02 1.200000e+02 9.100000e-04 5.947410e-04 5.947410e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1444991/d10-x01-y01
	+Path=/REF/ATLAS_2016_I1444991/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e+01 2.500000e+00 2.500000e+00 5.300000e-01 1.393707e-01 1.393707e-01
	+3.000000e+01 2.500000e+00 5.000000e+00 5.700000e-01 1.401320e-01 1.401320e-01
	+4.000000e+01 5.000000e+00 5.000000e+00 6.400000e-01 1.726236e-01 1.726236e-01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1457605.yoda b/data/refdata/ATLAS_2016_I1457605.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1457605.yoda
	@@ -0,0 +1,107 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1457605/d01-x01-y01
	+Path=/REF/ATLAS_2016_I1457605/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e+01 5.000000e+00 5.000000e+00 1.034000e+03 1.142000e+02 1.121000e+02
	+4.000000e+01 5.000000e+00 5.000000e+00 3.010000e+02 2.340000e+01 2.319000e+01
	+5.000000e+01 5.000000e+00 5.000000e+00 1.150000e+02 6.496000e+00 6.468000e+00
	+6.000000e+01 5.000000e+00 5.000000e+00 5.030000e+01 2.250000e+00 2.242000e+00
	+7.000000e+01 5.000000e+00 5.000000e+00 2.540000e+01 9.340000e-01 9.300000e-01
	+8.000000e+01 5.000000e+00 5.000000e+00 1.370000e+01 4.352000e-01 4.340000e-01
	+9.500000e+01 1.000000e+01 1.000000e+01 6.370000e+00 1.655000e-01 1.660000e-01
	+1.150000e+02 1.000000e+01 1.000000e+01 2.540000e+00 5.870000e-02 5.905000e-02
	+1.375000e+02 1.250000e+01 1.250000e+01 1.090000e+00 2.518000e-02 2.503000e-02
	+1.625000e+02 1.250000e+01 1.250000e+01 4.840000e-01 1.176000e-02 1.165000e-02
	+1.875000e+02 1.250000e+01 1.250000e+01 2.340000e-01 5.745000e-03 5.746000e-03
	+2.250000e+02 2.500000e+01 2.500000e+01 9.840000e-02 2.387000e-03 2.436000e-03
	+2.750000e+02 2.500000e+01 2.500000e+01 3.420000e-02 8.677000e-04 8.897000e-04
	+3.250000e+02 2.500000e+01 2.500000e+01 1.410000e-02 3.893000e-04 4.020000e-04
	+3.750000e+02 2.500000e+01 2.500000e+01 6.560000e-03 2.032000e-04 2.065000e-04
	+4.350000e+02 3.500000e+01 3.500000e+01 2.840000e-03 9.453000e-05 9.373000e-05
	+5.100000e+02 4.000000e+01 4.000000e+01 1.130000e-03 4.366000e-05 4.349000e-05
	+6.000000e+02 5.000000e+01 5.000000e+01 4.050000e-04 1.992000e-05 2.010000e-05
	+7.000000e+02 5.000000e+01 5.000000e+01 1.390000e-04 1.017000e-05 1.024000e-05
	+8.250000e+02 7.500000e+01 7.500000e+01 4.360000e-05 4.472000e-06 4.483000e-06
	+1.000000e+03 1.000000e+02 1.000000e+02 9.350000e-06 1.747000e-06 1.747000e-06
	+1.300000e+03 2.000000e+02 2.000000e+02 6.110000e-07 3.810000e-07 3.810000e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1457605/d02-x01-y01
	+Path=/REF/ATLAS_2016_I1457605/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e+01 5.000000e+00 5.000000e+00 1.339000e+03 1.759000e+02 1.690000e+02
	+4.000000e+01 5.000000e+00 5.000000e+00 3.880000e+02 3.340000e+01 3.246000e+01
	+5.000000e+01 5.000000e+00 5.000000e+00 1.440000e+02 8.642000e+00 8.426000e+00
	+6.000000e+01 5.000000e+00 5.000000e+00 6.610000e+01 2.858000e+00 2.808000e+00
	+7.000000e+01 5.000000e+00 5.000000e+00 3.300000e+01 1.108000e+00 1.095000e+00
	+8.000000e+01 5.000000e+00 5.000000e+00 1.770000e+01 5.227000e-01 5.191000e-01
	+9.500000e+01 1.000000e+01 1.000000e+01 8.200000e+00 2.248000e-01 2.242000e-01
	+1.150000e+02 1.000000e+01 1.000000e+01 3.240000e+00 8.734000e-02 8.749000e-02
	+1.375000e+02 1.250000e+01 1.250000e+01 1.390000e+00 3.768000e-02 3.813000e-02
	+1.625000e+02 1.250000e+01 1.250000e+01 6.160000e-01 1.725000e-02 1.737000e-02
	+1.875000e+02 1.250000e+01 1.250000e+01 3.010000e-01 8.818000e-03 8.716000e-03
	+2.250000e+02 2.500000e+01 2.500000e+01 1.250000e-01 3.826000e-03 3.754000e-03
	+2.750000e+02 2.500000e+01 2.500000e+01 4.310000e-02 1.396000e-03 1.396000e-03
	+3.250000e+02 2.500000e+01 2.500000e+01 1.660000e-02 5.872000e-04 5.901000e-04
	+3.750000e+02 2.500000e+01 2.500000e+01 7.560000e-03 2.974000e-04 2.977000e-04
	+4.350000e+02 3.500000e+01 3.500000e+01 3.080000e-03 1.290000e-04 1.290000e-04
	+5.100000e+02 4.000000e+01 4.000000e+01 1.160000e-03 5.440000e-05 5.527000e-05
	+6.000000e+02 5.000000e+01 5.000000e+01 3.820000e-04 2.329000e-05 2.383000e-05
	+7.000000e+02 5.000000e+01 5.000000e+01 1.240000e-04 1.048000e-05 1.063000e-05
	+8.250000e+02 7.500000e+01 7.500000e+01 2.960000e-05 3.843000e-06 3.856000e-06
	+1.000000e+03 1.000000e+02 1.000000e+02 7.230000e-06 1.828000e-06 1.826000e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1457605/d03-x01-y01
	+Path=/REF/ATLAS_2016_I1457605/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e+01 5.000000e+00 5.000000e+00 4.420000e+02 5.574000e+01 5.492000e+01
	+4.000000e+01 5.000000e+00 5.000000e+00 1.340000e+02 1.119000e+01 1.132000e+01
	+5.000000e+01 5.000000e+00 5.000000e+00 4.820000e+01 3.052000e+00 3.009000e+00
	+6.000000e+01 5.000000e+00 5.000000e+00 2.150000e+01 1.130000e+00 1.068000e+00
	+7.000000e+01 5.000000e+00 5.000000e+00 1.070000e+01 5.253000e-01 4.977000e-01
	+8.000000e+01 5.000000e+00 5.000000e+00 5.770000e+00 2.827000e-01 2.753000e-01
	+9.500000e+01 1.000000e+01 1.000000e+01 2.690000e+00 1.381000e-01 1.374000e-01
	+1.150000e+02 1.000000e+01 1.000000e+01 1.020000e+00 5.860000e-02 5.901000e-02
	+1.375000e+02 1.250000e+01 1.250000e+01 4.380000e-01 2.780000e-02 2.810000e-02
	+1.625000e+02 1.250000e+01 1.250000e+01 1.890000e-01 1.348000e-02 1.351000e-02
	+1.875000e+02 1.250000e+01 1.250000e+01 8.980000e-02 7.137000e-03 7.137000e-03
	+2.250000e+02 2.500000e+01 2.500000e+01 3.480000e-02 3.030000e-03 3.062000e-03
	+2.750000e+02 2.500000e+01 2.500000e+01 1.090000e-02 1.053000e-03 1.074000e-03
	+3.250000e+02 2.500000e+01 2.500000e+01 3.760000e-03 4.139000e-04 4.292000e-04
	+3.750000e+02 2.500000e+01 2.500000e+01 1.520000e-03 1.866000e-04 1.952000e-04
	+4.350000e+02 3.500000e+01 3.500000e+01 5.110000e-04 6.720000e-05 7.265000e-05
	+5.100000e+02 4.000000e+01 4.000000e+01 1.270000e-04 2.008000e-05 2.223000e-05
	+6.000000e+02 5.000000e+01 5.000000e+01 2.710000e-05 4.725000e-06 5.077000e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1457605/d04-x01-y01
	+Path=/REF/ATLAS_2016_I1457605/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e+01 5.000000e+00 5.000000e+00 9.470000e+02 1.073000e+02 1.051000e+02
	+4.000000e+01 5.000000e+00 5.000000e+00 2.840000e+02 2.212000e+01 2.202000e+01
	+5.000000e+01 5.000000e+00 5.000000e+00 1.040000e+02 6.012000e+00 6.031000e+00
	+6.000000e+01 5.000000e+00 5.000000e+00 4.480000e+01 2.015000e+00 2.039000e+00
	+7.000000e+01 5.000000e+00 5.000000e+00 2.160000e+01 8.358000e-01 8.462000e-01
	+8.000000e+01 5.000000e+00 5.000000e+00 1.180000e+01 4.010000e-01 4.043000e-01
	+9.500000e+01 1.000000e+01 1.000000e+01 5.370000e+00 1.696000e-01 1.690000e-01
	+1.150000e+02 1.000000e+01 1.000000e+01 2.050000e+00 5.895000e-02 5.856000e-02
	+1.375000e+02 1.250000e+01 1.250000e+01 8.290000e-01 2.322000e-02 2.304000e-02
	+1.625000e+02 1.250000e+01 1.250000e+01 3.320000e-01 1.168000e-02 1.166000e-02
	+1.875000e+02 1.250000e+01 1.250000e+01 1.520000e-01 4.832000e-03 4.836000e-03
	+2.250000e+02 2.500000e+01 2.500000e+01 5.410000e-02 1.846000e-03 1.834000e-03
	+2.750000e+02 2.500000e+01 2.500000e+01 1.420000e-02 5.684000e-04 5.750000e-04
	+3.250000e+02 2.500000e+01 2.500000e+01 4.180000e-03 2.091000e-04 2.125000e-04
	+3.750000e+02 2.500000e+01 2.500000e+01 1.350000e-03 8.381000e-05 8.541000e-05
	+4.350000e+02 3.500000e+01 3.500000e+01 3.870000e-04 2.864000e-05 2.919000e-05
	+5.100000e+02 4.000000e+01 4.000000e+01 7.170000e-05 8.613000e-06 8.706000e-06
	+6.000000e+02 5.000000e+01 5.000000e+01 1.080000e-05 2.566000e-06 2.575000e-06
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1467230.yoda b/data/refdata/ATLAS_2016_I1467230.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1467230.yoda
	@@ -0,0 +1,590 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467230/d01-x01-y01
	+Path=/REF/ATLAS_2016_I1467230/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+00 5.000000e-01 5.000000e-01 2.141900e-02 1.025319e-03 9.246785e-04
	+3.000000e+00 5.000000e-01 5.000000e-01 2.155100e-02 9.208569e-04 8.379211e-04
	+4.000000e+00 5.000000e-01 5.000000e-01 2.329400e-02 8.212832e-04 7.273514e-04
	+5.000000e+00 5.000000e-01 5.000000e-01 2.521000e-02 8.408955e-04 7.430684e-04
	+6.000000e+00 5.000000e-01 5.000000e-01 2.681300e-02 8.425190e-04 7.324355e-04
	+7.000000e+00 5.000000e-01 5.000000e-01 2.805600e-02 8.601845e-04 6.823213e-04
	+8.000000e+00 5.000000e-01 5.000000e-01 2.884000e-02 8.946556e-04 6.121029e-04
	+9.000000e+00 5.000000e-01 5.000000e-01 2.907000e-02 9.196476e-04 5.275092e-04
	+1.000000e+01 5.000000e-01 5.000000e-01 2.880000e-02 9.015899e-04 4.332803e-04
	+1.100000e+01 5.000000e-01 5.000000e-01 2.814400e-02 8.264054e-04 3.558734e-04
	+1.200000e+01 5.000000e-01 5.000000e-01 2.711100e-02 7.087661e-04 3.164288e-04
	+1.300000e+01 5.000000e-01 5.000000e-01 2.579600e-02 5.715931e-04 2.988294e-04
	+1.400000e+01 5.000000e-01 5.000000e-01 2.430700e-02 4.405366e-04 2.739898e-04
	+1.500000e+01 5.000000e-01 5.000000e-01 2.286200e-02 3.326397e-04 2.361498e-04
	+1.600000e+01 5.000000e-01 5.000000e-01 2.140800e-02 2.511824e-04 1.901507e-04
	+1.700000e+01 5.000000e-01 5.000000e-01 2.011500e-02 1.953701e-04 1.449434e-04
	+1.800000e+01 5.000000e-01 5.000000e-01 1.900500e-02 1.600732e-04 1.068363e-04
	+1.900000e+01 5.000000e-01 5.000000e-01 1.794600e-02 1.384027e-04 7.710877e-05
	+2.000000e+01 5.000000e-01 5.000000e-01 1.698800e-02 1.261370e-04 5.691293e-05
	+2.100000e+01 5.000000e-01 5.000000e-01 1.621900e-02 1.206887e-04 4.607853e-05
	+2.200000e+01 5.000000e-01 5.000000e-01 1.555300e-02 1.190454e-04 4.161062e-05
	+2.300000e+01 5.000000e-01 5.000000e-01 1.492900e-02 1.189542e-04 3.953716e-05
	+2.400000e+01 5.000000e-01 5.000000e-01 1.441000e-02 1.195687e-04 3.814706e-05
	+2.500000e+01 5.000000e-01 5.000000e-01 1.386700e-02 1.189556e-04 3.697225e-05
	+2.600000e+01 5.000000e-01 5.000000e-01 1.345000e-02 1.179050e-04 3.678410e-05
	+2.700000e+01 5.000000e-01 5.000000e-01 1.304700e-02 1.153114e-04 3.678636e-05
	+2.800000e+01 5.000000e-01 5.000000e-01 1.261700e-02 1.110834e-04 3.610028e-05
	+2.900000e+01 5.000000e-01 5.000000e-01 1.227500e-02 1.064152e-04 3.478244e-05
	+3.000000e+01 5.000000e-01 5.000000e-01 1.194000e-02 1.009810e-04 3.245203e-05
	+3.100000e+01 5.000000e-01 5.000000e-01 1.155400e-02 9.479839e-05 2.934205e-05
	+3.200000e+01 5.000000e-01 5.000000e-01 1.126700e-02 8.944441e-05 2.654242e-05
	+3.300000e+01 5.000000e-01 5.000000e-01 1.094700e-02 8.342203e-05 2.443047e-05
	+3.400000e+01 5.000000e-01 5.000000e-01 1.068100e-02 7.787175e-05 2.345314e-05
	+3.500000e+01 5.000000e-01 5.000000e-01 1.036600e-02 7.161175e-05 2.401041e-05
	+3.600000e+01 5.000000e-01 5.000000e-01 1.005800e-02 6.564309e-05 2.534873e-05
	+3.700000e+01 5.000000e-01 5.000000e-01 9.840400e-03 6.045143e-05 2.714445e-05
	+3.800000e+01 5.000000e-01 5.000000e-01 9.553800e-03 5.554064e-05 2.810698e-05
	+3.900000e+01 5.000000e-01 5.000000e-01 9.298500e-03 5.169588e-05 2.853396e-05
	+4.000000e+01 5.000000e-01 5.000000e-01 9.021200e-03 4.827447e-05 2.901692e-05
	+4.100000e+01 5.000000e-01 5.000000e-01 8.766200e-03 4.516870e-05 2.995329e-05
	+4.200000e+01 5.000000e-01 5.000000e-01 8.521400e-03 4.267974e-05 3.114448e-05
	+4.300000e+01 5.000000e-01 5.000000e-01 8.309600e-03 4.094800e-05 3.235820e-05
	+4.400000e+01 5.000000e-01 5.000000e-01 8.088500e-03 3.943801e-05 3.417762e-05
	+4.500000e+01 5.000000e-01 5.000000e-01 7.893200e-03 3.905198e-05 3.597207e-05
	+4.600000e+01 5.000000e-01 5.000000e-01 7.665100e-03 3.914582e-05 3.808626e-05
	+4.700000e+01 5.000000e-01 5.000000e-01 7.518400e-03 4.014877e-05 4.100223e-05
	+4.800000e+01 5.000000e-01 5.000000e-01 7.306000e-03 4.144036e-05 4.369889e-05
	+4.900000e+01 5.000000e-01 5.000000e-01 7.137200e-03 4.344973e-05 4.732856e-05
	+5.000000e+01 5.000000e-01 5.000000e-01 6.954000e-03 4.552899e-05 5.107070e-05
	+5.100000e+01 5.000000e-01 5.000000e-01 6.828100e-03 4.807828e-05 5.584072e-05
	+5.200000e+01 5.000000e-01 5.000000e-01 6.615100e-03 5.016267e-05 6.028080e-05
	+5.300000e+01 5.000000e-01 5.000000e-01 6.452700e-03 5.256827e-05 6.566416e-05
	+5.400000e+01 5.000000e-01 5.000000e-01 6.290900e-03 5.501738e-05 7.107606e-05
	+5.500000e+01 5.000000e-01 5.000000e-01 6.130300e-03 5.731689e-05 7.669531e-05
	+5.600000e+01 5.000000e-01 5.000000e-01 5.990200e-03 6.023477e-05 8.245896e-05
	+5.700000e+01 5.000000e-01 5.000000e-01 5.789700e-03 6.219747e-05 8.662892e-05
	+5.800000e+01 5.000000e-01 5.000000e-01 5.686800e-03 6.524241e-05 9.200999e-05
	+5.900000e+01 5.000000e-01 5.000000e-01 5.531400e-03 6.780295e-05 9.657064e-05
	+6.000000e+01 5.000000e-01 5.000000e-01 5.348800e-03 6.976659e-05 9.986751e-05
	+6.100000e+01 5.000000e-01 5.000000e-01 5.176100e-03 7.174076e-05 1.029813e-04
	+6.249300e+01 9.930000e-01 1.007000e+00 5.016600e-03 7.532736e-05 1.086037e-04
	+6.449300e+01 9.930000e-01 1.007000e+00 4.731100e-03 7.869932e-05 1.135054e-04
	+6.649300e+01 9.930000e-01 1.007000e+00 4.458100e-03 8.113045e-05 1.180480e-04
	+6.849400e+01 9.940000e-01 1.006000e+00 4.244100e-03 8.378765e-05 1.236226e-04
	+7.049300e+01 9.930000e-01 1.007000e+00 4.014900e-03 8.594863e-05 1.278075e-04
	+7.249200e+01 9.920000e-01 1.008000e+00 3.766800e-03 8.698233e-05 1.306728e-04
	+7.449300e+01 9.930000e-01 1.007000e+00 3.567700e-03 8.942235e-05 1.339290e-04
	+7.649200e+01 9.920000e-01 1.008000e+00 3.347600e-03 9.061036e-05 1.361055e-04
	+7.849300e+01 9.930000e-01 1.007000e+00 3.172300e-03 9.280682e-05 1.390826e-04
	+8.049300e+01 9.930000e-01 1.007000e+00 2.990500e-03 9.410404e-05 1.414999e-04
	+8.249200e+01 9.920000e-01 1.008000e+00 2.810200e-03 9.426171e-05 1.432774e-04
	+8.449100e+01 9.910000e-01 1.009000e+00 2.638000e-03 9.422189e-05 1.438255e-04
	+8.649200e+01 9.920000e-01 1.008000e+00 2.486200e-03 9.416304e-05 1.445235e-04
	+8.849300e+01 9.930000e-01 1.007000e+00 2.320400e-03 9.325162e-05 1.432819e-04
	+9.048700e+01 9.870000e-01 1.013000e+00 2.167200e-03 9.235321e-05 1.416703e-04
	+9.249000e+01 9.900000e-01 1.010000e+00 2.032700e-03 9.166628e-05 1.405591e-04
	+9.449200e+01 9.920000e-01 1.008000e+00 1.892300e-03 8.992045e-05 1.384178e-04
	+9.649200e+01 9.920000e-01 1.008000e+00 1.776500e-03 8.875996e-05 1.372668e-04
	+9.849000e+01 9.900000e-01 1.010000e+00 1.653900e-03 8.636953e-05 1.346757e-04
	+1.004900e+02 9.900000e-01 1.010000e+00 1.534200e-03 8.358507e-05 1.315247e-04
	+1.057700e+02 4.270000e+00 4.730000e+00 1.268300e-03 7.571660e-05 1.224228e-04
	+1.151900e+02 4.690000e+00 5.310000e+00 9.025700e-04 6.370738e-05 1.050120e-04
	+1.251600e+02 4.660000e+00 5.340000e+00 6.003800e-04 5.032269e-05 8.604058e-05
	+1.422700e+02 1.177000e+01 1.823000e+01 2.749400e-04 2.915367e-05 5.118538e-05
	+1.742800e+02 1.378000e+01 2.622000e+01 5.437400e-05 8.098220e-06 1.547217e-05
	+2.145400e+02 1.404000e+01 3.596000e+01 5.170100e-06 1.069464e-06 2.263777e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467230/d01-x01-y02
	+Path=/REF/ATLAS_2016_I1467230/d01-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+00 5.000000e-01 5.000000e-01 2.099300e-02 1.016596e-03 9.191204e-04
	+3.000000e+00 5.000000e-01 5.000000e-01 2.117200e-02 9.279201e-04 8.486802e-04
	+4.000000e+00 5.000000e-01 5.000000e-01 2.292400e-02 8.518506e-04 7.647006e-04
	+5.000000e+00 5.000000e-01 5.000000e-01 2.484300e-02 8.810140e-04 7.910086e-04
	+6.000000e+00 5.000000e-01 5.000000e-01 2.645600e-02 8.673545e-04 7.638844e-04
	+7.000000e+00 5.000000e-01 5.000000e-01 2.771500e-02 8.602696e-04 6.872625e-04
	+8.000000e+00 5.000000e-01 5.000000e-01 2.852000e-02 8.849147e-04 6.055915e-04
	+9.000000e+00 5.000000e-01 5.000000e-01 2.878300e-02 9.131061e-04 5.267241e-04
	+1.000000e+01 5.000000e-01 5.000000e-01 2.854200e-02 9.035566e-04 4.499255e-04
	+1.100000e+01 5.000000e-01 5.000000e-01 2.791300e-02 8.374395e-04 3.925526e-04
	+1.200000e+01 5.000000e-01 5.000000e-01 2.692100e-02 7.241279e-04 3.574131e-04
	+1.300000e+01 5.000000e-01 5.000000e-01 2.564600e-02 5.883920e-04 3.339923e-04
	+1.400000e+01 5.000000e-01 5.000000e-01 2.419200e-02 4.557425e-04 2.997063e-04
	+1.500000e+01 5.000000e-01 5.000000e-01 2.279200e-02 3.411172e-04 2.486364e-04
	+1.600000e+01 5.000000e-01 5.000000e-01 2.138000e-02 2.533074e-04 1.931291e-04
	+1.700000e+01 5.000000e-01 5.000000e-01 2.011400e-02 1.953701e-04 1.449534e-04
	+1.800000e+01 5.000000e-01 5.000000e-01 1.901800e-02 1.613687e-04 1.086705e-04
	+1.900000e+01 5.000000e-01 5.000000e-01 1.796800e-02 1.423052e-04 8.371059e-05
	+2.000000e+01 5.000000e-01 5.000000e-01 1.701600e-02 1.322164e-04 6.905779e-05
	+2.100000e+01 5.000000e-01 5.000000e-01 1.624700e-02 1.269962e-04 6.036101e-05
	+2.200000e+01 5.000000e-01 5.000000e-01 1.557500e-02 1.241110e-04 5.410543e-05
	+2.300000e+01 5.000000e-01 5.000000e-01 1.494500e-02 1.228456e-04 4.976467e-05
	+2.400000e+01 5.000000e-01 5.000000e-01 1.442300e-02 1.228140e-04 4.711313e-05
	+2.500000e+01 5.000000e-01 5.000000e-01 1.387400e-02 1.209273e-04 4.275362e-05
	+2.600000e+01 5.000000e-01 5.000000e-01 1.344800e-02 1.185623e-04 3.891113e-05
	+2.700000e+01 5.000000e-01 5.000000e-01 1.304100e-02 1.155914e-04 3.779197e-05
	+2.800000e+01 5.000000e-01 5.000000e-01 1.261100e-02 1.113321e-04 3.698264e-05
	+2.900000e+01 5.000000e-01 5.000000e-01 1.226800e-02 1.065646e-04 3.541628e-05
	+3.000000e+01 5.000000e-01 5.000000e-01 1.193200e-02 1.010517e-04 3.284723e-05
	+3.100000e+01 5.000000e-01 5.000000e-01 1.154800e-02 9.476128e-05 2.937858e-05
	+3.200000e+01 5.000000e-01 5.000000e-01 1.126000e-02 8.957065e-05 2.715032e-05
	+3.300000e+01 5.000000e-01 5.000000e-01 1.093500e-02 8.452246e-05 2.821094e-05
	+3.400000e+01 5.000000e-01 5.000000e-01 1.066400e-02 7.979833e-05 2.951421e-05
	+3.500000e+01 5.000000e-01 5.000000e-01 1.034800e-02 7.324882e-05 2.880251e-05
	+3.600000e+01 5.000000e-01 5.000000e-01 1.004000e-02 6.689751e-05 2.866408e-05
	+3.700000e+01 5.000000e-01 5.000000e-01 9.823300e-03 6.205925e-05 3.072456e-05
	+3.800000e+01 5.000000e-01 5.000000e-01 9.539500e-03 5.748986e-05 3.189375e-05
	+3.900000e+01 5.000000e-01 5.000000e-01 9.289000e-03 5.320669e-05 3.124858e-05
	+4.000000e+01 5.000000e-01 5.000000e-01 9.010800e-03 5.030660e-05 3.233929e-05
	+4.100000e+01 5.000000e-01 5.000000e-01 8.749400e-03 5.048418e-05 3.755012e-05
	+4.200000e+01 5.000000e-01 5.000000e-01 8.501500e-03 5.194555e-05 4.301933e-05
	+4.300000e+01 5.000000e-01 5.000000e-01 8.289500e-03 5.170168e-05 4.523625e-05
	+4.400000e+01 5.000000e-01 5.000000e-01 8.068400e-03 5.037699e-05 4.639571e-05
	+4.500000e+01 5.000000e-01 5.000000e-01 7.873700e-03 4.954163e-05 4.716483e-05
	+4.600000e+01 5.000000e-01 5.000000e-01 7.647100e-03 4.896394e-05 4.812510e-05
	+4.700000e+01 5.000000e-01 5.000000e-01 7.501400e-03 5.087321e-05 5.154609e-05
	+4.800000e+01 5.000000e-01 5.000000e-01 7.288400e-03 5.413683e-05 5.587658e-05
	+4.900000e+01 5.000000e-01 5.000000e-01 7.118600e-03 5.765051e-05 6.061258e-05
	+5.000000e+01 5.000000e-01 5.000000e-01 6.933900e-03 6.105635e-05 6.526923e-05
	+5.100000e+01 5.000000e-01 5.000000e-01 6.805700e-03 6.528237e-05 7.115590e-05
	+5.200000e+01 5.000000e-01 5.000000e-01 6.593200e-03 6.716795e-05 7.497697e-05
	+5.300000e+01 5.000000e-01 5.000000e-01 6.435600e-03 6.640765e-05 7.713777e-05
	+5.400000e+01 5.000000e-01 5.000000e-01 6.280500e-03 6.462760e-05 7.870751e-05
	+5.500000e+01 5.000000e-01 5.000000e-01 6.124000e-03 6.567915e-05 8.309923e-05
	+5.600000e+01 5.000000e-01 5.000000e-01 5.985200e-03 7.002487e-05 8.982900e-05
	+5.700000e+01 5.000000e-01 5.000000e-01 5.784900e-03 7.293299e-05 9.460114e-05
	+5.800000e+01 5.000000e-01 5.000000e-01 5.682400e-03 7.615502e-05 1.000117e-04
	+5.900000e+01 5.000000e-01 5.000000e-01 5.527300e-03 7.857868e-05 1.043843e-04
	+6.000000e+01 5.000000e-01 5.000000e-01 5.342700e-03 8.133630e-05 1.082102e-04
	+6.100000e+01 5.000000e-01 5.000000e-01 5.166200e-03 8.555932e-05 1.129579e-04
	+6.249300e+01 9.930000e-01 1.007000e+00 5.006200e-03 9.013590e-05 1.192472e-04
	+6.449300e+01 9.930000e-01 1.007000e+00 4.725600e-03 9.115924e-05 1.224105e-04
	+6.649300e+01 9.930000e-01 1.007000e+00 4.459600e-03 9.080880e-05 1.249151e-04
	+6.849400e+01 9.940000e-01 1.006000e+00 4.249700e-03 9.289932e-05 1.300602e-04
	+7.049300e+01 9.930000e-01 1.007000e+00 4.021500e-03 9.623448e-05 1.350452e-04
	+7.249200e+01 9.920000e-01 1.008000e+00 3.772900e-03 9.784148e-05 1.382507e-04
	+7.449300e+01 9.930000e-01 1.007000e+00 3.575100e-03 9.957469e-05 1.410572e-04
	+7.649200e+01 9.920000e-01 1.008000e+00 3.359200e-03 9.966911e-05 1.425443e-04
	+7.849300e+01 9.930000e-01 1.007000e+00 3.187800e-03 1.011256e-04 1.451318e-04
	+8.049300e+01 9.930000e-01 1.007000e+00 3.008000e-03 1.016827e-04 1.470995e-04
	+8.249200e+01 9.920000e-01 1.008000e+00 2.828400e-03 1.020994e-04 1.490570e-04
	+8.449100e+01 9.910000e-01 1.009000e+00 2.658700e-03 1.025167e-04 1.500051e-04
	+8.649200e+01 9.920000e-01 1.008000e+00 2.512100e-03 1.012849e-04 1.501035e-04
	+8.849300e+01 9.930000e-01 1.007000e+00 2.349200e-03 9.933904e-05 1.483221e-04
	+9.048700e+01 9.870000e-01 1.013000e+00 2.198400e-03 9.759110e-05 1.462907e-04
	+9.249000e+01 9.900000e-01 1.010000e+00 2.067900e-03 9.564893e-05 1.445698e-04
	+9.449200e+01 9.920000e-01 1.008000e+00 1.929400e-03 9.332341e-05 1.422086e-04
	+9.649200e+01 9.920000e-01 1.008000e+00 1.813400e-03 9.220899e-05 1.411676e-04
	+9.849000e+01 9.900000e-01 1.010000e+00 1.689900e-03 9.007446e-05 1.387765e-04
	+1.004900e+02 9.900000e-01 1.010000e+00 1.572900e-03 8.732320e-05 1.358856e-04
	+1.057700e+02 4.270000e+00 4.730000e+00 1.311000e-03 7.886398e-05 1.269231e-04
	+1.151900e+02 4.690000e+00 5.310000e+00 9.454000e-04 6.673882e-05 1.100023e-04
	+1.251600e+02 4.660000e+00 5.340000e+00 6.415000e-04 5.403319e-05 9.208887e-05
	+1.422700e+02 1.177000e+01 1.823000e+01 3.049900e-04 3.331586e-05 5.734050e-05
	+1.742800e+02 1.378000e+01 2.622000e+01 6.457500e-05 1.036648e-05 1.877827e-05
	+2.145400e+02 1.404000e+01 3.596000e+01 6.803800e-06 1.636739e-06 3.094079e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467230/d02-x01-y01
	+Path=/REF/ATLAS_2016_I1467230/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.257800e-01 2.578000e-02 2.422000e-02 1.395200e+01 5.300135e-01 5.272095e-01
	+1.750800e-01 2.508000e-02 2.492000e-02 1.121600e+01 4.001243e-01 3.964346e-01
	+2.248200e-01 2.482000e-02 2.518000e-02 8.506700e+00 2.529927e-01 2.433236e-01
	+2.746800e-01 2.468000e-02 2.532000e-02 6.403100e+00 1.854878e-01 1.776086e-01
	+3.246300e-01 2.463000e-02 2.537000e-02 4.850300e+00 1.299565e-01 1.229774e-01
	+3.746100e-01 2.461000e-02 2.539000e-02 3.718700e+00 9.845671e-02 9.305033e-02
	+4.245900e-01 2.459000e-02 2.541000e-02 2.885000e+00 7.521429e-02 7.082599e-02
	+4.746000e-01 2.460000e-02 2.540000e-02 2.260200e+00 5.875684e-02 5.526046e-02
	+5.479300e-01 4.793000e-02 5.207000e-02 1.619100e+00 4.221427e-02 3.941258e-02
	+6.479900e-01 4.799000e-02 5.201000e-02 1.056500e+00 2.741843e-02 2.555568e-02
	+7.480800e-01 4.808000e-02 5.192000e-02 7.121300e-01 1.832701e-02 1.706116e-02
	+8.481500e-01 4.815000e-02 5.185000e-02 4.922000e-01 1.265930e-02 1.178247e-02
	+9.481900e-01 4.819000e-02 5.181000e-02 3.487100e-01 8.951884e-03 8.329810e-03
	+1.048600e+00 4.860000e-02 5.140000e-02 2.510600e-01 6.377873e-03 5.926501e-03
	+1.148600e+00 4.860000e-02 5.140000e-02 1.841500e-01 4.700638e-03 4.369462e-03
	+1.248700e+00 4.870000e-02 5.130000e-02 1.368100e-01 3.490677e-03 3.243890e-03
	+1.348700e+00 4.870000e-02 5.130000e-02 1.031700e-01 2.621520e-03 2.434514e-03
	+1.448800e+00 4.880000e-02 5.120000e-02 7.847700e-02 1.981194e-03 1.837535e-03
	+1.548800e+00 4.880000e-02 5.120000e-02 6.046400e-02 1.516722e-03 1.405387e-03
	+1.648800e+00 4.880000e-02 5.120000e-02 4.691800e-02 1.176269e-03 1.089346e-03
	+1.748900e+00 4.890000e-02 5.110000e-02 3.676300e-02 9.215721e-04 8.529354e-04
	+1.848900e+00 4.890000e-02 5.110000e-02 2.903500e-02 7.282084e-04 6.735384e-04
	+1.948900e+00 4.890000e-02 5.110000e-02 2.304300e-02 5.773224e-04 5.336881e-04
	+2.049000e+00 4.900000e-02 5.100000e-02 1.839800e-02 4.580194e-04 4.232901e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 1.485500e-02 3.694444e-04 3.412129e-04
	+2.248900e+00 4.890000e-02 5.110000e-02 1.199900e-02 2.986704e-04 2.756540e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 9.774800e-03 2.433959e-04 2.244885e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 7.991700e-03 1.991429e-04 1.837036e-04
	+2.596300e+00 9.630000e-02 1.037000e-01 5.990800e-03 1.487527e-04 1.374127e-04
	+2.796400e+00 9.640000e-02 1.036000e-01 4.136800e-03 1.028844e-04 9.499703e-05
	+2.996400e+00 9.640000e-02 1.036000e-01 2.889300e-03 7.206319e-05 6.647709e-05
	+3.196500e+00 9.650000e-02 1.035000e-01 2.066400e-03 5.166954e-05 4.761785e-05
	+3.396800e+00 9.680000e-02 1.032000e-01 1.488300e-03 3.736655e-05 3.444572e-05
	+3.725900e+00 2.259000e-01 2.741000e-01 8.932300e-04 2.222400e-05 2.054060e-05
	+4.228100e+00 2.281000e-01 2.719000e-01 4.397800e-04 1.112028e-05 1.020988e-05
	+4.730700e+00 2.307000e-01 2.693000e-01 2.329900e-04 5.940892e-06 5.436770e-06
	+5.429700e+00 4.297000e-01 5.703000e-01 1.029200e-04 2.620663e-06 2.394470e-06
	+6.441700e+00 4.417000e-01 5.583000e-01 3.820300e-05 9.802720e-07 8.936688e-07
	+7.444600e+00 4.446000e-01 5.554000e-01 1.624400e-05 4.252159e-07 3.849002e-07
	+8.449800e+00 4.498000e-01 5.502000e-01 7.825800e-06 2.065273e-07 1.867132e-07
	+9.464100e+00 4.641000e-01 5.359000e-01 3.876800e-06 1.042742e-07 9.417216e-08
	+1.171100e+01 1.711000e+00 3.289000e+00 1.016700e-06 3.540822e-08 3.371783e-08
	+1.694800e+01 1.948000e+00 3.052000e+00 1.217800e-07 4.626555e-09 4.387390e-09
	+2.356500e+01 3.565000e+00 6.435000e+00 1.672200e-08 7.401197e-10 7.076147e-10
	+3.631100e+01 6.311000e+00 1.368900e+01 1.024600e-09 7.465643e-11 7.324250e-11
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467230/d02-x01-y02
	+Path=/REF/ATLAS_2016_I1467230/d02-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.257800e-01 2.578000e-02 2.422000e-02 1.395700e+01 5.303536e-01 5.275398e-01
	+1.750800e-01 2.508000e-02 2.492000e-02 1.122500e+01 4.006243e-01 3.969246e-01
	+2.248200e-01 2.482000e-02 2.518000e-02 8.518200e+00 2.535427e-01 2.438836e-01
	+2.746800e-01 2.468000e-02 2.532000e-02 6.416400e+00 1.860678e-01 1.781686e-01
	+3.246300e-01 2.463000e-02 2.537000e-02 4.864900e+00 1.304865e-01 1.234974e-01
	+3.746100e-01 2.461000e-02 2.539000e-02 3.734100e+00 9.894074e-02 9.351637e-02
	+4.245900e-01 2.459000e-02 2.541000e-02 2.900800e+00 7.565235e-02 7.124205e-02
	+4.746000e-01 2.460000e-02 2.540000e-02 2.275800e+00 5.916591e-02 5.564553e-02
	+5.479300e-01 4.793000e-02 5.207000e-02 1.634200e+00 4.262531e-02 3.979862e-02
	+6.479900e-01 4.799000e-02 5.201000e-02 1.070500e+00 2.789846e-02 2.601971e-02
	+7.480800e-01 4.808000e-02 5.192000e-02 7.245800e-01 1.889702e-02 1.762716e-02
	+8.481500e-01 4.815000e-02 5.185000e-02 5.030000e-01 1.329328e-02 1.242344e-02
	+9.481900e-01 4.819000e-02 5.181000e-02 3.579900e-01 9.615654e-03 9.007166e-03
	+1.048600e+00 4.860000e-02 5.140000e-02 2.589500e-01 7.041114e-03 6.608220e-03
	+1.148600e+00 4.860000e-02 5.140000e-02 1.908500e-01 5.343249e-03 5.032345e-03
	+1.248700e+00 4.870000e-02 5.130000e-02 1.425900e-01 4.157149e-03 3.934026e-03
	+1.348700e+00 4.870000e-02 5.130000e-02 1.082100e-01 3.328459e-03 3.168312e-03
	+1.448800e+00 4.880000e-02 5.120000e-02 8.282100e-02 2.697270e-03 2.581536e-03
	+1.548800e+00 4.880000e-02 5.120000e-02 6.418400e-02 2.207338e-03 2.122564e-03
	+1.648800e+00 4.880000e-02 5.120000e-02 5.007600e-02 1.811419e-03 1.748345e-03
	+1.748900e+00 4.890000e-02 5.110000e-02 3.944700e-02 1.504769e-03 1.457384e-03
	+1.848900e+00 4.890000e-02 5.110000e-02 3.130900e-02 1.251901e-03 1.215816e-03
	+1.948900e+00 4.890000e-02 5.110000e-02 2.497200e-02 1.044622e-03 1.017036e-03
	+2.049000e+00 4.900000e-02 5.100000e-02 2.003200e-02 8.768293e-04 8.558805e-04
	+2.149000e+00 4.900000e-02 5.100000e-02 1.624800e-02 7.427292e-04 7.263971e-04
	+2.248900e+00 4.890000e-02 5.110000e-02 1.317800e-02 6.256610e-04 6.127874e-04
	+2.349000e+00 4.900000e-02 5.100000e-02 1.078000e-02 5.339453e-04 5.237695e-04
	+2.449000e+00 4.900000e-02 5.100000e-02 8.845600e-03 4.528913e-04 4.448161e-04
	+2.596300e+00 9.630000e-02 1.037000e-01 6.663000e-03 3.563059e-04 3.506280e-04
	+2.796400e+00 9.640000e-02 1.036000e-01 4.626600e-03 2.604114e-04 2.566330e-04
	+2.996400e+00 9.640000e-02 1.036000e-01 3.244400e-03 1.885885e-04 1.859900e-04
	+3.196500e+00 9.650000e-02 1.035000e-01 2.328100e-03 1.393093e-04 1.374704e-04
	+3.396800e+00 9.680000e-02 1.032000e-01 1.679800e-03 1.019051e-04 1.005865e-04
	+3.725900e+00 2.259000e-01 2.741000e-01 1.010400e-03 6.253163e-05 6.179093e-05
	+4.228100e+00 2.281000e-01 2.719000e-01 4.969000e-04 3.021906e-05 2.980632e-05
	+4.730700e+00 2.307000e-01 2.693000e-01 2.622800e-04 1.527124e-05 1.503145e-05
	+5.429700e+00 4.297000e-01 5.703000e-01 1.149700e-04 6.082803e-06 5.965306e-06
	+6.441700e+00 4.417000e-01 5.583000e-01 4.216900e-05 1.889770e-06 1.836770e-06
	+7.444600e+00 4.446000e-01 5.554000e-01 1.771100e-05 6.562203e-07 6.259323e-07
	+8.449800e+00 4.498000e-01 5.502000e-01 8.445300e-06 2.616529e-07 2.437029e-07
	+9.464100e+00 4.641000e-01 5.359000e-01 4.142900e-06 1.163148e-07 1.060192e-07
	+1.171100e+01 1.711000e+00 3.289000e+00 1.076600e-06 3.750012e-08 3.571177e-08
	+1.694800e+01 1.948000e+00 3.052000e+00 1.277000e-07 5.029717e-09 4.788338e-09
	+2.356500e+01 3.565000e+00 6.435000e+00 1.748400e-08 7.909732e-10 7.577477e-10
	+3.631100e+01 6.311000e+00 1.368900e+01 1.075200e-09 7.859412e-11 7.711514e-11
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467230/d03-x01-y01
	+Path=/REF/ATLAS_2016_I1467230/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-2.450000e+00 5.000000e-02 5.000000e-02 6.449800e+00 3.877774e-01 4.374854e-01
	+-2.350000e+00 5.000000e-02 5.000000e-02 6.526800e+00 3.355068e-01 3.736451e-01
	+-2.250000e+00 5.000000e-02 5.000000e-02 6.618000e+00 2.499713e-01 2.708796e-01
	+-2.150000e+00 5.000000e-02 5.000000e-02 6.730600e+00 1.992662e-01 2.123546e-01
	+-2.050000e+00 5.000000e-02 5.000000e-02 6.816000e+00 1.889779e-01 2.003463e-01
	+-1.950000e+00 5.000000e-02 5.000000e-02 6.815500e+00 1.848890e-01 1.954274e-01
	+-1.850000e+00 5.000000e-02 5.000000e-02 6.822000e+00 1.762006e-01 1.853691e-01
	+-1.750000e+00 5.000000e-02 5.000000e-02 6.885000e+00 1.528660e-01 1.589846e-01
	+-1.650000e+00 5.000000e-02 5.000000e-02 6.935600e+00 1.411407e-01 1.461693e-01
	+-1.550000e+00 5.000000e-02 5.000000e-02 6.947100e+00 1.428507e-01 1.483292e-01
	+-1.450000e+00 5.000000e-02 5.000000e-02 6.897000e+00 1.253241e-01 1.291128e-01
	+-1.350000e+00 5.000000e-02 5.000000e-02 6.856100e+00 1.119376e-01 1.146864e-01
	+-1.250000e+00 5.000000e-02 5.000000e-02 6.829900e+00 9.311244e-02 9.480146e-02
	+-1.150000e+00 5.000000e-02 5.000000e-02 6.825400e+00 1.014307e-01 1.034797e-01
	+-1.050000e+00 5.000000e-02 5.000000e-02 6.789500e+00 8.871438e-02 9.013649e-02
	+-9.500000e-01 5.000000e-02 5.000000e-02 6.749700e+00 8.988463e-02 9.138174e-02
	+-8.500000e-01 5.000000e-02 5.000000e-02 6.703500e+00 8.729840e-02 8.873551e-02
	+-7.500000e-01 5.000000e-02 5.000000e-02 6.653700e+00 8.363785e-02 8.489401e-02
	+-6.500000e-01 5.000000e-02 5.000000e-02 6.604600e+00 7.948795e-02 8.055917e-02
	+-5.500000e-01 5.000000e-02 5.000000e-02 6.558200e+00 8.086449e-02 8.201968e-02
	+-4.500000e-01 5.000000e-02 5.000000e-02 6.509800e+00 7.968595e-02 8.082013e-02
	+-3.500000e-01 5.000000e-02 5.000000e-02 6.480000e+00 8.151270e-02 8.281981e-02
	+-2.500000e-01 5.000000e-02 5.000000e-02 6.447000e+00 8.784274e-02 8.957072e-02
	+-1.500000e-01 5.000000e-02 5.000000e-02 6.431600e+00 9.277928e-02 9.486318e-02
	+-5.000000e-02 5.000000e-02 5.000000e-02 6.422900e+00 9.175482e-02 9.391864e-02
	+5.000000e-02 5.000000e-02 5.000000e-02 6.410500e+00 9.462108e-02 9.699188e-02
	+1.500000e-01 5.000000e-02 5.000000e-02 6.416200e+00 9.940550e-02 1.020253e-01
	+2.500000e-01 5.000000e-02 5.000000e-02 6.434500e+00 9.663583e-02 9.900069e-02
	+3.500000e-01 5.000000e-02 5.000000e-02 6.461500e+00 9.250789e-02 9.459879e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 6.504200e+00 9.254917e-02 9.467204e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 6.541300e+00 9.225145e-02 9.422540e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 6.588100e+00 9.038386e-02 9.215586e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 6.631000e+00 8.705427e-02 8.861232e-02
	+8.500000e-01 5.000000e-02 5.000000e-02 6.677900e+00 8.834015e-02 8.993519e-02
	+9.500000e-01 5.000000e-02 5.000000e-02 6.719600e+00 9.249549e-02 9.428350e-02
	+1.050000e+00 5.000000e-02 5.000000e-02 6.765500e+00 8.957138e-02 9.118939e-02
	+1.150000e+00 5.000000e-02 5.000000e-02 6.795700e+00 9.447302e-02 9.633098e-02
	+1.250000e+00 5.000000e-02 5.000000e-02 6.817300e+00 9.382100e-02 9.561397e-02
	+1.350000e+00 5.000000e-02 5.000000e-02 6.826900e+00 9.532913e-02 9.710812e-02
	+1.450000e+00 5.000000e-02 5.000000e-02 6.840800e+00 9.510682e-02 9.689577e-02
	+1.550000e+00 5.000000e-02 5.000000e-02 6.880700e+00 1.166185e-01 1.195973e-01
	+1.650000e+00 5.000000e-02 5.000000e-02 6.906500e+00 1.312943e-01 1.360127e-01
	+1.750000e+00 5.000000e-02 5.000000e-02 6.863900e+00 1.481775e-01 1.542861e-01
	+1.850000e+00 5.000000e-02 5.000000e-02 6.822700e+00 1.614736e-01 1.688121e-01
	+1.950000e+00 5.000000e-02 5.000000e-02 6.805600e+00 1.977474e-01 2.098958e-01
	+2.050000e+00 5.000000e-02 5.000000e-02 6.821700e+00 2.257138e-01 2.417023e-01
	+2.150000e+00 5.000000e-02 5.000000e-02 6.779700e+00 2.283033e-01 2.447317e-01
	+2.250000e+00 5.000000e-02 5.000000e-02 6.627100e+00 2.169144e-01 2.322428e-01
	+2.350000e+00 5.000000e-02 5.000000e-02 6.519200e+00 2.606111e-01 2.825495e-01
	+2.450000e+00 5.000000e-02 5.000000e-02 6.452400e+00 2.800723e-01 3.031606e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467230/d03-x01-y02
	+Path=/REF/ATLAS_2016_I1467230/d03-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-2.450000e+00 5.000000e-02 5.000000e-02 6.553700e+00 3.944277e-01 4.448957e-01
	+-2.350000e+00 5.000000e-02 5.000000e-02 6.631100e+00 3.413571e-01 3.800453e-01
	+-2.250000e+00 5.000000e-02 5.000000e-02 6.723100e+00 2.546716e-01 2.758499e-01
	+-2.150000e+00 5.000000e-02 5.000000e-02 6.836800e+00 2.034365e-01 2.166749e-01
	+-2.050000e+00 5.000000e-02 5.000000e-02 6.922900e+00 1.931082e-01 2.045866e-01
	+-1.950000e+00 5.000000e-02 5.000000e-02 6.921200e+00 1.889993e-01 1.996277e-01
	+-1.850000e+00 5.000000e-02 5.000000e-02 6.926100e+00 1.801809e-01 1.894294e-01
	+-1.750000e+00 5.000000e-02 5.000000e-02 6.988700e+00 1.566962e-01 1.628548e-01
	+-1.650000e+00 5.000000e-02 5.000000e-02 7.038900e+00 1.450308e-01 1.500795e-01
	+-1.550000e+00 5.000000e-02 5.000000e-02 7.049600e+00 1.468508e-01 1.523393e-01
	+-1.450000e+00 5.000000e-02 5.000000e-02 6.997500e+00 1.294040e-01 1.331828e-01
	+-1.350000e+00 5.000000e-02 5.000000e-02 6.954100e+00 1.159573e-01 1.186862e-01
	+-1.250000e+00 5.000000e-02 5.000000e-02 6.925500e+00 9.725862e-02 9.892270e-02
	+-1.150000e+00 5.000000e-02 5.000000e-02 6.919100e+00 1.054202e-01 1.074492e-01
	+-1.050000e+00 5.000000e-02 5.000000e-02 6.881500e+00 9.293134e-02 9.432552e-02
	+-9.500000e-01 5.000000e-02 5.000000e-02 6.840500e+00 9.432152e-02 9.578770e-02
	+-8.500000e-01 5.000000e-02 5.000000e-02 6.792400e+00 9.181813e-02 9.322232e-02
	+-7.500000e-01 5.000000e-02 5.000000e-02 6.740400e+00 8.809344e-02 8.931768e-02
	+-6.500000e-01 5.000000e-02 5.000000e-02 6.688300e+00 8.373244e-02 8.477573e-02
	+-5.500000e-01 5.000000e-02 5.000000e-02 6.639900e+00 8.491217e-02 8.603943e-02
	+-4.500000e-01 5.000000e-02 5.000000e-02 6.590300e+00 8.380552e-02 8.491078e-02
	+-3.500000e-01 5.000000e-02 5.000000e-02 6.560000e+00 8.574229e-02 8.701648e-02
	+-2.500000e-01 5.000000e-02 5.000000e-02 6.526200e+00 9.194368e-02 9.363674e-02
	+-1.500000e-01 5.000000e-02 5.000000e-02 6.509900e+00 9.673145e-02 9.878043e-02
	+-5.000000e-02 5.000000e-02 5.000000e-02 6.500400e+00 9.554602e-02 9.767593e-02
	+5.000000e-02 5.000000e-02 5.000000e-02 6.487800e+00 9.834041e-02 1.006773e-01
	+1.500000e-01 5.000000e-02 5.000000e-02 6.494400e+00 1.032359e-01 1.058248e-01
	+2.500000e-01 5.000000e-02 5.000000e-02 6.513700e+00 1.005971e-01 1.029261e-01
	+3.500000e-01 5.000000e-02 5.000000e-02 6.541500e+00 9.653205e-02 9.858802e-02
	+4.500000e-01 5.000000e-02 5.000000e-02 6.584700e+00 9.640840e-02 9.849835e-02
	+5.500000e-01 5.000000e-02 5.000000e-02 6.622900e+00 9.610869e-02 9.805270e-02
	+6.500000e-01 5.000000e-02 5.000000e-02 6.671500e+00 9.433800e-02 9.608007e-02
	+7.500000e-01 5.000000e-02 5.000000e-02 6.717200e+00 9.137311e-02 9.289723e-02
	+8.500000e-01 5.000000e-02 5.000000e-02 6.766500e+00 9.277299e-02 9.433411e-02
	+9.500000e-01 5.000000e-02 5.000000e-02 6.809900e+00 9.683554e-02 9.859163e-02
	+1.050000e+00 5.000000e-02 5.000000e-02 6.857200e+00 9.379638e-02 9.538447e-02
	+1.150000e+00 5.000000e-02 5.000000e-02 6.889100e+00 9.855426e-02 1.003823e-01
	+1.250000e+00 5.000000e-02 5.000000e-02 6.912500e+00 9.789424e-02 9.966228e-02
	+1.350000e+00 5.000000e-02 5.000000e-02 6.924400e+00 9.949938e-02 1.012534e-01
	+1.450000e+00 5.000000e-02 5.000000e-02 6.940500e+00 9.938702e-02 1.011550e-01
	+1.550000e+00 5.000000e-02 5.000000e-02 6.982100e+00 1.206083e-01 1.235672e-01
	+1.650000e+00 5.000000e-02 5.000000e-02 7.009200e+00 1.351343e-01 1.398628e-01
	+1.750000e+00 5.000000e-02 5.000000e-02 6.967200e+00 1.519777e-01 1.581163e-01
	+1.850000e+00 5.000000e-02 5.000000e-02 6.926800e+00 1.653438e-01 1.727324e-01
	+1.950000e+00 5.000000e-02 5.000000e-02 6.911200e+00 2.019577e-01 2.142261e-01
	+2.050000e+00 5.000000e-02 5.000000e-02 6.928700e+00 2.302341e-01 2.464025e-01
	+2.150000e+00 5.000000e-02 5.000000e-02 6.886900e+00 2.328236e-01 2.494520e-01
	+2.250000e+00 5.000000e-02 5.000000e-02 6.732400e+00 2.211848e-01 2.367131e-01
	+2.350000e+00 5.000000e-02 5.000000e-02 6.623400e+00 2.654214e-01 2.876698e-01
	+2.450000e+00 5.000000e-02 5.000000e-02 6.556400e+00 2.851527e-01 3.085709e-01
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467230/d04-x01-y01
	+Path=/REF/ATLAS_2016_I1467230/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+00 5.000000e-01 5.000000e-01 4.602200e-01 9.724974e-03 9.724974e-03
	+3.000000e+00 5.000000e-01 5.000000e-01 4.511600e-01 9.259506e-03 9.259506e-03
	+4.000000e+00 5.000000e-01 5.000000e-01 4.456800e-01 8.994456e-03 8.994456e-03
	+5.000000e+00 5.000000e-01 5.000000e-01 4.431000e-01 8.891106e-03 8.891106e-03
	+6.000000e+00 5.000000e-01 5.000000e-01 4.425700e-01 8.871652e-03 8.871652e-03
	+7.000000e+00 5.000000e-01 5.000000e-01 4.434000e-01 8.898838e-03 8.898838e-03
	+8.000000e+00 5.000000e-01 5.000000e-01 4.451600e-01 8.958000e-03 8.958000e-03
	+9.000000e+00 5.000000e-01 5.000000e-01 4.476100e-01 9.043097e-03 9.043097e-03
	+1.000000e+01 5.000000e-01 5.000000e-01 4.506000e-01 9.150088e-03 9.150088e-03
	+1.100000e+01 5.000000e-01 5.000000e-01 4.541000e-01 9.278570e-03 9.278570e-03
	+1.200000e+01 5.000000e-01 5.000000e-01 4.580100e-01 9.424576e-03 9.424576e-03
	+1.300000e+01 5.000000e-01 5.000000e-01 4.623400e-01 9.588367e-03 9.588367e-03
	+1.400000e+01 5.000000e-01 5.000000e-01 4.670000e-01 9.764500e-03 9.764500e-03
	+1.500000e+01 5.000000e-01 5.000000e-01 4.718600e-01 9.946783e-03 9.946783e-03
	+1.600000e+01 5.000000e-01 5.000000e-01 4.768400e-01 1.012837e-02 1.012837e-02
	+1.700000e+01 5.000000e-01 5.000000e-01 4.818900e-01 4.357019e-03 4.357019e-03
	+1.800000e+01 5.000000e-01 5.000000e-01 4.869000e-01 4.516797e-03 4.516797e-03
	+1.900000e+01 5.000000e-01 5.000000e-01 4.917800e-01 4.632729e-03 4.632729e-03
	+2.000000e+01 5.000000e-01 5.000000e-01 4.965100e-01 4.711244e-03 4.711244e-03
	+2.100000e+01 5.000000e-01 5.000000e-01 5.010500e-01 4.762779e-03 4.762779e-03
	+2.200000e+01 5.000000e-01 5.000000e-01 5.054500e-01 4.795372e-03 4.795372e-03
	+2.300000e+01 5.000000e-01 5.000000e-01 5.096300e-01 4.817439e-03 4.817439e-03
	+2.400000e+01 5.000000e-01 5.000000e-01 5.136000e-01 4.834532e-03 4.834532e-03
	+2.500000e+01 5.000000e-01 5.000000e-01 5.174100e-01 4.851142e-03 4.851142e-03
	+2.600000e+01 5.000000e-01 5.000000e-01 5.209700e-01 4.865965e-03 4.865965e-03
	+2.700000e+01 5.000000e-01 5.000000e-01 5.244400e-01 4.879538e-03 4.879538e-03
	+2.800000e+01 5.000000e-01 5.000000e-01 5.277500e-01 4.889058e-03 4.889058e-03
	+2.900000e+01 5.000000e-01 5.000000e-01 5.309200e-01 4.897697e-03 4.897697e-03
	+3.000000e+01 5.000000e-01 5.000000e-01 5.339900e-01 4.906397e-03 4.906397e-03
	+3.100000e+01 5.000000e-01 5.000000e-01 5.370000e-01 4.921433e-03 4.921433e-03
	+3.200000e+01 5.000000e-01 5.000000e-01 5.398600e-01 4.941604e-03 4.941604e-03
	+3.300000e+01 5.000000e-01 5.000000e-01 5.426900e-01 4.968297e-03 4.968297e-03
	+3.400000e+01 5.000000e-01 5.000000e-01 5.454300e-01 4.998194e-03 4.998194e-03
	+3.500000e+01 5.000000e-01 5.000000e-01 5.481200e-01 5.031108e-03 5.031108e-03
	+3.600000e+01 5.000000e-01 5.000000e-01 5.507300e-01 5.062742e-03 5.062742e-03
	+3.700000e+01 5.000000e-01 5.000000e-01 5.532700e-01 5.096020e-03 5.096020e-03
	+3.800000e+01 5.000000e-01 5.000000e-01 5.558100e-01 5.128840e-03 5.128840e-03
	+3.900000e+01 5.000000e-01 5.000000e-01 5.582200e-01 5.163469e-03 5.163469e-03
	+4.000000e+01 5.000000e-01 5.000000e-01 5.605600e-01 5.199854e-03 5.199854e-03
	+4.100000e+01 5.000000e-01 5.000000e-01 5.629500e-01 5.240132e-03 5.240132e-03
	+4.200000e+01 5.000000e-01 5.000000e-01 5.652200e-01 5.279052e-03 5.279052e-03
	+4.300000e+01 5.000000e-01 5.000000e-01 5.674800e-01 5.317091e-03 5.317091e-03
	+4.400000e+01 5.000000e-01 5.000000e-01 5.697100e-01 5.352393e-03 5.352393e-03
	+4.500000e+01 5.000000e-01 5.000000e-01 5.718800e-01 5.383145e-03 5.383145e-03
	+4.600000e+01 5.000000e-01 5.000000e-01 5.740600e-01 5.408482e-03 5.408482e-03
	+4.700000e+01 5.000000e-01 5.000000e-01 5.761500e-01 5.429897e-03 5.429897e-03
	+4.800000e+01 5.000000e-01 5.000000e-01 5.781900e-01 5.446283e-03 5.446283e-03
	+4.900000e+01 5.000000e-01 5.000000e-01 5.803300e-01 5.462982e-03 5.462982e-03
	+5.000000e+01 5.000000e-01 5.000000e-01 5.823200e-01 5.476876e-03 5.476876e-03
	+5.100000e+01 5.000000e-01 5.000000e-01 5.843200e-01 5.489216e-03 5.489216e-03
	+5.200000e+01 5.000000e-01 5.000000e-01 5.862800e-01 5.502804e-03 5.502804e-03
	+5.300000e+01 5.000000e-01 5.000000e-01 5.882100e-01 5.516277e-03 5.516277e-03
	+5.400000e+01 5.000000e-01 5.000000e-01 5.901100e-01 5.528502e-03 5.528502e-03
	+5.500000e+01 5.000000e-01 5.000000e-01 5.919400e-01 5.543712e-03 5.543712e-03
	+5.600000e+01 5.000000e-01 5.000000e-01 5.937600e-01 5.561594e-03 5.561594e-03
	+5.700000e+01 5.000000e-01 5.000000e-01 5.955100e-01 5.580516e-03 5.580516e-03
	+5.800000e+01 5.000000e-01 5.000000e-01 5.971800e-01 5.603547e-03 5.603547e-03
	+5.900000e+01 5.000000e-01 5.000000e-01 5.989100e-01 5.632583e-03 5.632583e-03
	+6.000000e+01 5.000000e-01 5.000000e-01 6.005600e-01 5.661979e-03 5.661979e-03
	+6.100000e+01 5.000000e-01 5.000000e-01 6.022400e-01 5.692679e-03 5.692679e-03
	+6.249300e+01 9.930000e-01 1.007000e+00 6.046800e-01 5.741044e-03 5.741044e-03
	+6.449300e+01 9.930000e-01 1.007000e+00 6.078900e-01 5.801355e-03 5.801355e-03
	+6.649300e+01 9.930000e-01 1.007000e+00 6.110700e-01 5.851976e-03 5.851976e-03
	+6.849400e+01 9.940000e-01 1.006000e+00 6.141700e-01 5.894625e-03 5.894625e-03
	+7.049300e+01 9.930000e-01 1.007000e+00 6.172000e-01 5.927124e-03 5.927124e-03
	+7.249200e+01 9.920000e-01 1.008000e+00 6.201400e-01 5.958171e-03 5.958171e-03
	+7.449300e+01 9.930000e-01 1.007000e+00 6.230200e-01 5.994448e-03 5.994448e-03
	+7.649200e+01 9.920000e-01 1.008000e+00 6.258300e-01 6.035496e-03 6.035496e-03
	+7.849300e+01 9.930000e-01 1.007000e+00 6.285500e-01 6.075397e-03 6.075397e-03
	+8.049300e+01 9.930000e-01 1.007000e+00 6.312100e-01 6.112539e-03 6.112539e-03
	+8.249200e+01 9.920000e-01 1.008000e+00 6.337900e-01 6.140293e-03 6.140293e-03
	+8.449100e+01 9.910000e-01 1.009000e+00 6.362800e-01 6.162492e-03 6.162492e-03
	+8.649200e+01 9.920000e-01 1.008000e+00 6.387500e-01 6.185753e-03 6.185753e-03
	+8.849300e+01 9.930000e-01 1.007000e+00 6.412000e-01 6.223948e-03 6.223948e-03
	+9.048700e+01 9.870000e-01 1.013000e+00 6.435700e-01 6.271712e-03 6.271712e-03
	+9.249000e+01 9.900000e-01 1.010000e+00 6.459700e-01 6.331310e-03 6.331310e-03
	+9.449200e+01 9.920000e-01 1.008000e+00 6.483200e-01 6.399037e-03 6.399037e-03
	+9.649200e+01 9.920000e-01 1.008000e+00 6.507000e-01 6.465545e-03 6.465545e-03
	+9.849000e+01 9.900000e-01 1.010000e+00 6.530200e-01 6.527472e-03 6.527472e-03
	+1.004900e+02 9.900000e-01 1.010000e+00 6.553600e-01 6.581473e-03 6.581473e-03
	+1.057700e+02 4.270000e+00 4.730000e+00 6.612200e-01 6.627891e-03 6.627891e-03
	+1.151900e+02 4.690000e+00 5.310000e+00 6.705200e-01 6.640054e-03 6.640054e-03
	+1.251600e+02 4.660000e+00 5.340000e+00 6.800200e-01 6.840592e-03 6.840592e-03
	+1.422700e+02 1.177000e+01 1.823000e+01 6.945400e-01 7.096284e-03 7.096284e-03
	+1.742800e+02 1.378000e+01 2.622000e+01 7.194100e-01 8.402981e-03 8.402981e-03
	+2.145400e+02 1.404000e+01 3.596000e+01 7.453000e-01 1.495693e-02 1.495693e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467230/d04-x01-y02
	+Path=/REF/ATLAS_2016_I1467230/d04-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+00 5.000000e-01 5.000000e-01 4.629600e-01 9.786300e-03 9.786300e-03
	+3.000000e+00 5.000000e-01 5.000000e-01 4.540900e-01 9.323887e-03 9.323887e-03
	+4.000000e+00 5.000000e-01 5.000000e-01 4.486600e-01 9.063069e-03 9.063069e-03
	+5.000000e+00 5.000000e-01 5.000000e-01 4.460200e-01 8.969874e-03 8.969874e-03
	+6.000000e+00 5.000000e-01 5.000000e-01 4.453900e-01 8.966079e-03 8.966079e-03
	+7.000000e+00 5.000000e-01 5.000000e-01 4.461700e-01 9.010235e-03 9.010235e-03
	+8.000000e+00 5.000000e-01 5.000000e-01 4.479200e-01 9.085078e-03 9.085078e-03
	+9.000000e+00 5.000000e-01 5.000000e-01 4.503700e-01 9.180757e-03 9.180757e-03
	+1.000000e+01 5.000000e-01 5.000000e-01 4.533700e-01 9.286245e-03 9.286245e-03
	+1.100000e+01 5.000000e-01 5.000000e-01 4.569100e-01 9.404533e-03 9.404533e-03
	+1.200000e+01 5.000000e-01 5.000000e-01 4.609100e-01 9.544740e-03 9.544740e-03
	+1.300000e+01 5.000000e-01 5.000000e-01 4.653900e-01 9.705134e-03 9.705134e-03
	+1.400000e+01 5.000000e-01 5.000000e-01 4.701300e-01 9.869378e-03 9.869378e-03
	+1.500000e+01 5.000000e-01 5.000000e-01 4.750600e-01 1.003826e-02 1.003826e-02
	+1.600000e+01 5.000000e-01 5.000000e-01 4.801400e-01 1.021145e-02 1.021145e-02
	+1.700000e+01 5.000000e-01 5.000000e-01 4.852600e-01 4.404153e-03 4.404153e-03
	+1.800000e+01 5.000000e-01 5.000000e-01 4.902900e-01 4.556177e-03 4.556177e-03
	+1.900000e+01 5.000000e-01 5.000000e-01 4.952200e-01 4.667314e-03 4.667314e-03
	+2.000000e+01 5.000000e-01 5.000000e-01 5.000300e-01 4.745546e-03 4.745546e-03
	+2.100000e+01 5.000000e-01 5.000000e-01 5.047200e-01 4.799592e-03 4.799592e-03
	+2.200000e+01 5.000000e-01 5.000000e-01 5.092400e-01 4.834475e-03 4.834475e-03
	+2.300000e+01 5.000000e-01 5.000000e-01 5.135700e-01 4.858878e-03 4.858878e-03
	+2.400000e+01 5.000000e-01 5.000000e-01 5.177400e-01 4.884768e-03 4.884768e-03
	+2.500000e+01 5.000000e-01 5.000000e-01 5.217400e-01 4.916628e-03 4.916628e-03
	+2.600000e+01 5.000000e-01 5.000000e-01 5.254400e-01 4.939468e-03 4.939468e-03
	+2.700000e+01 5.000000e-01 5.000000e-01 5.290700e-01 4.966144e-03 4.966144e-03
	+2.800000e+01 5.000000e-01 5.000000e-01 5.326400e-01 5.008299e-03 5.008299e-03
	+2.900000e+01 5.000000e-01 5.000000e-01 5.360100e-01 5.050617e-03 5.050617e-03
	+3.000000e+01 5.000000e-01 5.000000e-01 5.392300e-01 5.082364e-03 5.082364e-03
	+3.100000e+01 5.000000e-01 5.000000e-01 5.423300e-01 5.108292e-03 5.108292e-03
	+3.200000e+01 5.000000e-01 5.000000e-01 5.453000e-01 5.146298e-03 5.146298e-03
	+3.300000e+01 5.000000e-01 5.000000e-01 5.483100e-01 5.213770e-03 5.213770e-03
	+3.400000e+01 5.000000e-01 5.000000e-01 5.512400e-01 5.290787e-03 5.290787e-03
	+3.500000e+01 5.000000e-01 5.000000e-01 5.541200e-01 5.359696e-03 5.359696e-03
	+3.600000e+01 5.000000e-01 5.000000e-01 5.568400e-01 5.399314e-03 5.399314e-03
	+3.700000e+01 5.000000e-01 5.000000e-01 5.595100e-01 5.453226e-03 5.453226e-03
	+3.800000e+01 5.000000e-01 5.000000e-01 5.622500e-01 5.539279e-03 5.539279e-03
	+3.900000e+01 5.000000e-01 5.000000e-01 5.648200e-01 5.610440e-03 5.610440e-03
	+4.000000e+01 5.000000e-01 5.000000e-01 5.672800e-01 5.663937e-03 5.663937e-03
	+4.100000e+01 5.000000e-01 5.000000e-01 5.698000e-01 5.736335e-03 5.736335e-03
	+4.200000e+01 5.000000e-01 5.000000e-01 5.722300e-01 5.817563e-03 5.817563e-03
	+4.300000e+01 5.000000e-01 5.000000e-01 5.746400e-01 5.892756e-03 5.892756e-03
	+4.400000e+01 5.000000e-01 5.000000e-01 5.770100e-01 5.967770e-03 5.967770e-03
	+4.500000e+01 5.000000e-01 5.000000e-01 5.793400e-01 6.053219e-03 6.053219e-03
	+4.600000e+01 5.000000e-01 5.000000e-01 5.817100e-01 6.142731e-03 6.142731e-03
	+4.700000e+01 5.000000e-01 5.000000e-01 5.839300e-01 6.204361e-03 6.204361e-03
	+4.800000e+01 5.000000e-01 5.000000e-01 5.860700e-01 6.249313e-03 6.249313e-03
	+4.900000e+01 5.000000e-01 5.000000e-01 5.883200e-01 6.308910e-03 6.308910e-03
	+5.000000e+01 5.000000e-01 5.000000e-01 5.904300e-01 6.370269e-03 6.370269e-03
	+5.100000e+01 5.000000e-01 5.000000e-01 5.925700e-01 6.428171e-03 6.428171e-03
	+5.200000e+01 5.000000e-01 5.000000e-01 5.946400e-01 6.457324e-03 6.457324e-03
	+5.300000e+01 5.000000e-01 5.000000e-01 5.966700e-01 6.459128e-03 6.459128e-03
	+5.400000e+01 5.000000e-01 5.000000e-01 5.986800e-01 6.496063e-03 6.496063e-03
	+5.500000e+01 5.000000e-01 5.000000e-01 6.006800e-01 6.589374e-03 6.589374e-03
	+5.600000e+01 5.000000e-01 5.000000e-01 6.026800e-01 6.694671e-03 6.694671e-03
	+5.700000e+01 5.000000e-01 5.000000e-01 6.045500e-01 6.789424e-03 6.789424e-03
	+5.800000e+01 5.000000e-01 5.000000e-01 6.063800e-01 6.889091e-03 6.889091e-03
	+5.900000e+01 5.000000e-01 5.000000e-01 6.082700e-01 6.972122e-03 6.972122e-03
	+6.000000e+01 5.000000e-01 5.000000e-01 6.100200e-01 7.008172e-03 7.008172e-03
	+6.100000e+01 5.000000e-01 5.000000e-01 6.117900e-01 7.046972e-03 7.046972e-03
	+6.249300e+01 9.930000e-01 1.007000e+00 6.144200e-01 7.182619e-03 7.182619e-03
	+6.449300e+01 9.930000e-01 1.007000e+00 6.179300e-01 7.366924e-03 7.366924e-03
	+6.649300e+01 9.930000e-01 1.007000e+00 6.213300e-01 7.468874e-03 7.468874e-03
	+6.849400e+01 9.940000e-01 1.006000e+00 6.246000e-01 7.566055e-03 7.566055e-03
	+7.049300e+01 9.930000e-01 1.007000e+00 6.278800e-01 7.726847e-03 7.726847e-03
	+7.249200e+01 9.920000e-01 1.008000e+00 6.310800e-01 7.883833e-03 7.883833e-03
	+7.449300e+01 9.930000e-01 1.007000e+00 6.342200e-01 8.029788e-03 8.029788e-03
	+7.649200e+01 9.920000e-01 1.008000e+00 6.373300e-01 8.219890e-03 8.219890e-03
	+7.849300e+01 9.930000e-01 1.007000e+00 6.403200e-01 8.393449e-03 8.393449e-03
	+8.049300e+01 9.930000e-01 1.007000e+00 6.431800e-01 8.487754e-03 8.487754e-03
	+8.249200e+01 9.920000e-01 1.008000e+00 6.458700e-01 8.541684e-03 8.541684e-03
	+8.449100e+01 9.910000e-01 1.009000e+00 6.485300e-01 8.634353e-03 8.634353e-03
	+8.649200e+01 9.920000e-01 1.008000e+00 6.513100e-01 8.811018e-03 8.811018e-03
	+8.849300e+01 9.930000e-01 1.007000e+00 6.540700e-01 8.981117e-03 8.981117e-03
	+9.048700e+01 9.870000e-01 1.013000e+00 6.565800e-01 9.068816e-03 9.068816e-03
	+9.249000e+01 9.900000e-01 1.010000e+00 6.591500e-01 9.218032e-03 9.218032e-03
	+9.449200e+01 9.920000e-01 1.008000e+00 6.618000e-01 9.454297e-03 9.454297e-03
	+9.649200e+01 9.920000e-01 1.008000e+00 6.644000e-01 9.622007e-03 9.622007e-03
	+9.849000e+01 9.900000e-01 1.010000e+00 6.668800e-01 9.740118e-03 9.740118e-03
	+1.004900e+02 9.900000e-01 1.010000e+00 6.694800e-01 9.932081e-03 9.932081e-03
	+1.057700e+02 4.270000e+00 4.730000e+00 6.759100e-01 1.030502e-02 1.030502e-02
	+1.151900e+02 4.690000e+00 5.310000e+00 6.859900e-01 1.071229e-02 1.071229e-02
	+1.251600e+02 4.660000e+00 5.340000e+00 6.963500e-01 1.123582e-02 1.123582e-02
	+1.422700e+02 1.177000e+01 1.823000e+01 7.119700e-01 1.205458e-02 1.205458e-02
	+1.742800e+02 1.378000e+01 2.622000e+01 7.379900e-01 1.381673e-02 1.381673e-02
	+2.145400e+02 1.404000e+01 3.596000e+01 7.646900e-01 1.989102e-02 1.989102e-02
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1467454.yoda b/data/refdata/ATLAS_2016_I1467454.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1467454.yoda
	@@ -0,0 +1,368 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d18-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d18-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.230000e+02 7.000000e+00 7.000000e+00 2.206304e-01 4.721696e-03 4.721696e-03
	+1.400000e+02 1.000000e+01 1.000000e+01 1.003824e-01 2.308795e-03 2.308795e-03
	+1.625000e+02 1.250000e+01 1.250000e+01 4.832856e-02 1.180840e-03 1.180840e-03
	+1.875000e+02 1.250000e+01 1.250000e+01 2.471483e-02 6.786460e-04 6.786460e-04
	+2.150000e+02 1.500000e+01 1.500000e+01 1.320038e-02 4.159691e-04 4.159691e-04
	+2.450000e+02 1.500000e+01 1.500000e+01 7.528409e-03 2.664887e-04 2.664887e-04
	+2.800000e+02 2.000000e+01 2.000000e+01 4.187146e-03 1.618428e-04 1.618428e-04
	+3.400000e+02 4.000000e+01 4.000000e+01 1.730950e-03 7.084219e-05 7.084219e-05
	+4.400000e+02 6.000000e+01 6.000000e+01 5.613871e-04 2.761089e-05 2.761089e-05
	+6.000000e+02 1.000000e+02 1.000000e+02 1.413953e-04 8.808601e-06 8.808601e-06
	+8.500000e+02 1.500000e+02 1.500000e+02 2.433180e-05 2.641877e-06 2.641877e-06
	+1.250000e+03 2.500000e+02 2.500000e+02 2.936364e-06 6.842735e-07 6.842735e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d19-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d19-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 3.959924e-02 9.193507e-04 9.193507e-04
	+3.000000e-01 1.000000e-01 1.000000e-01 3.921756e-02 9.338391e-04 9.338391e-04
	+5.000000e-01 1.000000e-01 1.000000e-01 3.906399e-02 9.464456e-04 9.464456e-04
	+7.000000e-01 1.000000e-01 1.000000e-01 3.902672e-02 9.341989e-04 9.341989e-04
	+9.000000e-01 1.000000e-01 1.000000e-01 3.791786e-02 9.365021e-04 9.365021e-04
	+1.100000e+00 1.000000e-01 1.000000e-01 3.791786e-02 9.494620e-04 9.494620e-04
	+1.300000e+00 1.000000e-01 1.000000e-01 3.690249e-02 9.473235e-04 9.473235e-04
	+1.500000e+00 1.000000e-01 1.000000e-01 3.288719e-02 8.769232e-04 8.769232e-04
	+1.700000e+00 1.000000e-01 1.000000e-01 2.739464e-02 8.033684e-04 8.033684e-04
	+1.900000e+00 1.000000e-01 1.000000e-01 2.195590e-02 6.813407e-04 6.813407e-04
	+2.100000e+00 1.000000e-01 1.000000e-01 1.427203e-02 4.923333e-04 4.923333e-04
	+2.300000e+00 1.000000e-01 1.000000e-01 6.746411e-03 3.301609e-04 3.301609e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d20-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d20-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 1.007605e-02 3.187918e-04 3.187918e-04
	+3.000000e-01 1.000000e-01 1.000000e-01 1.009524e-02 3.173182e-04 3.173182e-04
	+5.000000e-01 1.000000e-01 1.000000e-01 9.980989e-03 3.212576e-04 3.212576e-04
	+7.000000e-01 1.000000e-01 1.000000e-01 1.006648e-02 3.254136e-04 3.254136e-04
	+9.000000e-01 1.000000e-01 1.000000e-01 9.714286e-03 3.100973e-04 3.100973e-04
	+1.100000e+00 1.000000e-01 1.000000e-01 9.247619e-03 3.104502e-04 3.104502e-04
	+1.300000e+00 1.000000e-01 1.000000e-01 8.826336e-03 2.934010e-04 2.934010e-04
	+1.500000e+00 1.000000e-01 1.000000e-01 7.265774e-03 2.613660e-04 2.613660e-04
	+1.700000e+00 1.000000e-01 1.000000e-01 6.385427e-03 2.491953e-04 2.491953e-04
	+1.900000e+00 1.000000e-01 1.000000e-01 4.736337e-03 1.908103e-04 1.908103e-04
	+2.100000e+00 1.000000e-01 1.000000e-01 3.179191e-03 1.402092e-04 1.402092e-04
	+2.300000e+00 1.000000e-01 1.000000e-01 1.464355e-03 9.706804e-05 9.706804e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d21-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d21-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 2.191910e-03 9.822104e-05 9.822104e-05
	+3.000000e-01 1.000000e-01 1.000000e-01 2.201317e-03 9.758069e-05 9.758069e-05
	+5.000000e-01 1.000000e-01 1.000000e-01 2.342427e-03 1.050964e-04 1.050964e-04
	+7.000000e-01 1.000000e-01 1.000000e-01 2.396226e-03 1.038703e-04 1.038703e-04
	+9.000000e-01 1.000000e-01 1.000000e-01 2.168561e-03 9.688395e-05 9.688395e-05
	+1.100000e+00 1.000000e-01 1.000000e-01 2.032289e-03 9.335265e-05 9.335265e-05
	+1.300000e+00 1.000000e-01 1.000000e-01 1.744519e-03 8.286004e-05 8.286004e-05
	+1.500000e+00 1.000000e-01 1.000000e-01 1.561303e-03 7.316498e-05 7.316498e-05
	+1.700000e+00 1.000000e-01 1.000000e-01 1.268012e-03 6.556981e-05 6.556981e-05
	+1.900000e+00 1.000000e-01 1.000000e-01 9.454023e-04 5.382155e-05 5.382155e-05
	+2.100000e+00 1.000000e-01 1.000000e-01 5.871648e-04 3.728843e-05 3.728843e-05
	+2.300000e+00 1.000000e-01 1.000000e-01 2.408829e-04 2.371443e-05 2.371443e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d22-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d22-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-01 2.000000e-01 2.000000e-01 2.990741e-04 1.801906e-05 1.801906e-05
	+6.000000e-01 2.000000e-01 2.000000e-01 3.115672e-04 1.711352e-05 1.711352e-05
	+1.000000e+00 2.000000e-01 2.000000e-01 2.986767e-04 1.642722e-05 1.642722e-05
	+1.400000e+00 2.000000e-01 2.000000e-01 2.184236e-04 1.317440e-05 1.317440e-05
	+1.800000e+00 2.000000e-01 2.000000e-01 1.251194e-04 9.354714e-06 9.354714e-06
	+2.200000e+00 2.000000e-01 2.000000e-01 3.460803e-05 4.210675e-06 4.210675e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d23-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d23-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-01 2.000000e-01 2.000000e-01 1.322993e-05 1.259556e-06 1.259556e-06
	+6.000000e-01 2.000000e-01 2.000000e-01 1.338873e-05 1.227390e-06 1.227390e-06
	+1.000000e+00 2.000000e-01 2.000000e-01 9.840675e-06 1.059645e-06 1.059645e-06
	+1.400000e+00 2.000000e-01 2.000000e-01 7.450237e-06 8.802637e-07 8.802637e-07
	+1.800000e+00 2.000000e-01 2.000000e-01 2.168561e-06 4.754146e-07 4.754146e-07
	+2.200000e+00 2.000000e-01 2.000000e-01 2.352390e-07 1.433465e-07 1.433465e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d24-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d24-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.250000e-01 1.250000e-01 1.250000e-01 4.784276e-02 1.133177e-03 1.133177e-03
	+3.750000e-01 1.250000e-01 1.250000e-01 4.521073e-02 1.083172e-03 1.083172e-03
	+6.250000e-01 1.250000e-01 1.250000e-01 4.214559e-02 1.025447e-03 1.025447e-03
	+8.750000e-01 1.250000e-01 1.250000e-01 3.875598e-02 9.138526e-04 9.138526e-04
	+1.125000e+00 1.250000e-01 1.250000e-01 3.425573e-02 8.397894e-04 8.397894e-04
	+1.375000e+00 1.250000e-01 1.250000e-01 3.095238e-02 7.663449e-04 7.663449e-04
	+1.625000e+00 1.250000e-01 1.250000e-01 2.476190e-02 6.322777e-04 6.322777e-04
	+1.875000e+00 1.250000e-01 1.250000e-01 1.924171e-02 5.387678e-04 5.387678e-04
	+2.125000e+00 1.250000e-01 1.250000e-01 1.137441e-02 3.683974e-04 3.683974e-04
	+2.375000e+00 1.250000e-01 1.250000e-01 4.059217e-03 1.997696e-04 1.997696e-04
	+2.625000e+00 1.250000e-01 1.250000e-01 6.417625e-04 8.158464e-05 8.158464e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d25-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d25-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.250000e-01 1.250000e-01 1.250000e-01 1.036468e-02 3.023575e-04 3.023575e-04
	+3.750000e-01 1.250000e-01 1.250000e-01 9.980806e-03 2.932048e-04 2.932048e-04
	+6.250000e-01 1.250000e-01 1.250000e-01 9.232982e-03 2.788299e-04 2.788299e-04
	+8.750000e-01 1.250000e-01 1.250000e-01 8.984674e-03 2.759041e-04 2.759041e-04
	+1.125000e+00 1.250000e-01 1.250000e-01 7.877629e-03 2.433155e-04 2.433155e-04
	+1.375000e+00 1.250000e-01 1.250000e-01 6.806482e-03 2.227499e-04 2.227499e-04
	+1.625000e+00 1.250000e-01 1.250000e-01 5.891841e-03 2.068028e-04 2.068028e-04
	+1.875000e+00 1.250000e-01 1.250000e-01 4.678639e-03 1.859134e-04 1.859134e-04
	+2.125000e+00 1.250000e-01 1.250000e-01 3.515038e-03 1.604644e-04 1.604644e-04
	+2.375000e+00 1.250000e-01 1.250000e-01 2.745098e-03 1.402689e-04 1.402689e-04
	+2.625000e+00 1.250000e-01 1.250000e-01 1.873253e-03 1.166090e-04 1.166090e-04
	+2.875000e+00 1.250000e-01 1.250000e-01 8.635514e-04 8.306269e-05 8.306269e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d26-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d26-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.250000e-01 1.250000e-01 1.250000e-01 2.023011e-03 7.753701e-05 7.753701e-05
	+3.750000e-01 1.250000e-01 1.250000e-01 1.992337e-03 7.896796e-05 7.896796e-05
	+6.250000e-01 1.250000e-01 1.250000e-01 1.896552e-03 7.671077e-05 7.671077e-05
	+8.750000e-01 1.250000e-01 1.250000e-01 1.805158e-03 7.438476e-05 7.438476e-05
	+1.125000e+00 1.250000e-01 1.250000e-01 1.660305e-03 6.772743e-05 6.772743e-05
	+1.375000e+00 1.250000e-01 1.250000e-01 1.334604e-03 6.188306e-05 6.188306e-05
	+1.625000e+00 1.250000e-01 1.250000e-01 1.182592e-03 5.760815e-05 5.760815e-05
	+1.875000e+00 1.250000e-01 1.250000e-01 9.622642e-04 5.401551e-05 5.401551e-05
	+2.125000e+00 1.250000e-01 1.250000e-01 8.838951e-04 5.273825e-05 5.273825e-05
	+2.375000e+00 1.250000e-01 1.250000e-01 6.113173e-04 4.678874e-05 4.678874e-05
	+2.625000e+00 1.250000e-01 1.250000e-01 5.289788e-04 4.325676e-05 4.325676e-05
	+2.875000e+00 1.250000e-01 1.250000e-01 3.882883e-04 3.985775e-05 3.985775e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d27-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d27-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-01 2.500000e-01 2.500000e-01 2.480916e-04 1.224477e-05 1.224477e-05
	+7.500000e-01 2.500000e-01 2.500000e-01 2.175573e-04 1.143573e-05 1.143573e-05
	+1.250000e+00 2.500000e-01 2.500000e-01 2.062441e-04 1.100656e-05 1.100656e-05
	+1.750000e+00 2.500000e-01 2.500000e-01 1.541353e-04 9.826052e-06 9.826052e-06
	+2.250000e+00 2.500000e-01 2.500000e-01 9.611830e-05 8.132085e-06 8.132085e-06
	+2.750000e+00 2.500000e-01 2.500000e-01 4.706414e-05 6.864430e-06 6.864430e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d28-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d28-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-01 2.500000e-01 2.500000e-01 7.296015e-06 7.632622e-07 7.632622e-07
	+7.500000e-01 2.500000e-01 2.500000e-01 8.260870e-06 8.215309e-07 8.215309e-07
	+1.250000e+00 2.500000e-01 2.500000e-01 8.165569e-06 8.071119e-07 8.071119e-07
	+1.750000e+00 2.500000e-01 2.500000e-01 6.484230e-06 7.331769e-07 7.331769e-07
	+2.250000e+00 2.500000e-01 2.500000e-01 2.666667e-06 5.268607e-07 5.268607e-07
	+2.750000e+00 2.500000e-01 2.500000e-01 1.696429e-06 4.601201e-07 4.601201e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d29-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d29-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.230000e+02 7.000000e+00 7.000000e+00 2.132701e-01 4.442986e-03 4.442986e-03
	+1.400000e+02 1.000000e+01 1.000000e+01 9.933142e-02 2.116482e-03 2.116482e-03
	+1.625000e+02 1.250000e+01 1.250000e+01 4.736337e-02 1.063305e-03 1.063305e-03
	+1.875000e+02 1.250000e+01 1.250000e+01 2.413462e-02 6.052931e-04 6.052931e-04
	+2.150000e+02 1.500000e+01 1.500000e+01 1.321119e-02 3.658807e-04 3.658807e-04
	+2.450000e+02 1.500000e+01 1.500000e+01 7.596525e-03 2.336472e-04 2.336472e-04
	+2.800000e+02 2.000000e+01 2.000000e+01 4.291225e-03 1.428404e-04 1.428404e-04
	+3.400000e+02 4.000000e+01 4.000000e+01 1.835749e-03 6.479959e-05 6.479959e-05
	+4.400000e+02 6.000000e+01 6.000000e+01 6.171649e-04 2.554347e-05 2.554347e-05
	+6.000000e+02 1.000000e+02 1.000000e+02 1.486486e-04 8.489907e-06 8.489907e-06
	+8.500000e+02 1.500000e+02 1.500000e+02 2.557692e-05 2.558715e-06 2.558715e-06
	+1.250000e+03 2.500000e+02 2.500000e+02 2.080537e-06 5.453944e-07 5.453944e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d30-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d30-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 3.814042e-02 8.854822e-04 8.854822e-04
	+3.000000e-01 1.000000e-01 1.000000e-01 3.745247e-02 8.727310e-04 8.727310e-04
	+5.000000e-01 1.000000e-01 1.000000e-01 3.700190e-02 8.614372e-04 8.614372e-04
	+7.000000e-01 1.000000e-01 1.000000e-01 3.766603e-02 8.752795e-04 8.752795e-04
	+9.000000e-01 1.000000e-01 1.000000e-01 3.738140e-02 8.638259e-04 8.638259e-04
	+1.100000e+00 1.000000e-01 1.000000e-01 3.690702e-02 8.407999e-04 8.407999e-04
	+1.300000e+00 1.000000e-01 1.000000e-01 3.599240e-02 8.262589e-04 8.262589e-04
	+1.500000e+00 1.000000e-01 1.000000e-01 3.304762e-02 7.629635e-04 7.629635e-04
	+1.700000e+00 1.000000e-01 1.000000e-01 2.790476e-02 6.702954e-04 6.702954e-04
	+1.900000e+00 1.000000e-01 1.000000e-01 2.163966e-02 5.555115e-04 5.555115e-04
	+2.100000e+00 1.000000e-01 1.000000e-01 1.489971e-02 4.292566e-04 4.292566e-04
	+2.300000e+00 1.000000e-01 1.000000e-01 7.100478e-03 2.961844e-04 2.961844e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d31-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d31-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 9.665072e-03 3.025646e-04 3.025646e-04
	+3.000000e-01 1.000000e-01 1.000000e-01 9.683605e-03 2.992532e-04 2.992532e-04
	+5.000000e-01 1.000000e-01 1.000000e-01 9.587728e-03 2.964453e-04 2.964453e-04
	+7.000000e-01 1.000000e-01 1.000000e-01 9.865900e-03 2.910023e-04 2.910023e-04
	+9.000000e-01 1.000000e-01 1.000000e-01 9.530651e-03 2.773731e-04 2.773731e-04
	+1.100000e+00 1.000000e-01 1.000000e-01 9.145053e-03 2.597903e-04 2.597903e-04
	+1.300000e+00 1.000000e-01 1.000000e-01 8.542665e-03 2.416231e-04 2.416231e-04
	+1.500000e+00 1.000000e-01 1.000000e-01 7.519231e-03 2.222947e-04 2.222947e-04
	+1.700000e+00 1.000000e-01 1.000000e-01 6.306654e-03 1.898292e-04 1.898292e-04
	+1.900000e+00 1.000000e-01 1.000000e-01 4.537572e-03 1.547439e-04 1.547439e-04
	+2.100000e+00 1.000000e-01 1.000000e-01 3.227666e-03 1.262508e-04 1.262508e-04
	+2.300000e+00 1.000000e-01 1.000000e-01 1.676301e-03 1.023642e-04 1.023642e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d32-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d32-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 2.341040e-03 9.989963e-05 9.989963e-05
	+3.000000e-01 1.000000e-01 1.000000e-01 2.278846e-03 9.775161e-05 9.775161e-05
	+5.000000e-01 1.000000e-01 1.000000e-01 2.237223e-03 9.372335e-05 9.372335e-05
	+7.000000e-01 1.000000e-01 1.000000e-01 2.295082e-03 9.061942e-05 9.061942e-05
	+9.000000e-01 1.000000e-01 1.000000e-01 2.164251e-03 8.443354e-05 8.443354e-05
	+1.100000e+00 1.000000e-01 1.000000e-01 2.054002e-03 7.783556e-05 7.783556e-05
	+1.300000e+00 1.000000e-01 1.000000e-01 1.819942e-03 6.802299e-05 6.802299e-05
	+1.500000e+00 1.000000e-01 1.000000e-01 1.605416e-03 6.159443e-05 6.159443e-05
	+1.700000e+00 1.000000e-01 1.000000e-01 1.285024e-03 5.257618e-05 5.257618e-05
	+1.900000e+00 1.000000e-01 1.000000e-01 9.623552e-04 4.465370e-05 4.465370e-05
	+2.100000e+00 1.000000e-01 1.000000e-01 5.660559e-04 3.470066e-05 3.470066e-05
	+2.300000e+00 1.000000e-01 1.000000e-01 2.201923e-04 2.480464e-05 2.480464e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d33-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d33-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-01 2.000000e-01 2.000000e-01 3.590734e-04 1.893580e-05 1.893580e-05
	+6.000000e-01 2.000000e-01 2.000000e-01 3.166023e-04 1.626732e-05 1.626732e-05
	+1.000000e+00 2.000000e-01 2.000000e-01 2.988395e-04 1.402955e-05 1.402955e-05
	+1.400000e+00 2.000000e-01 2.000000e-01 2.425121e-04 1.127616e-05 1.127616e-05
	+1.800000e+00 2.000000e-01 2.000000e-01 1.240385e-04 7.603871e-06 7.603871e-06
	+2.200000e+00 2.000000e-01 2.000000e-01 3.789778e-05 4.364831e-06 4.364831e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d34-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d34-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-01 2.000000e-01 2.000000e-01 1.409266e-05 1.281425e-06 1.281425e-06
	+6.000000e-01 2.000000e-01 2.000000e-01 1.245174e-05 1.132287e-06 1.132287e-06
	+1.000000e+00 2.000000e-01 2.000000e-01 1.156069e-05 1.019834e-06 1.019834e-06
	+1.400000e+00 2.000000e-01 2.000000e-01 7.764933e-06 7.960476e-07 7.960476e-07
	+1.800000e+00 2.000000e-01 2.000000e-01 2.005758e-06 3.952412e-07 3.952412e-07
	+2.200000e+00 2.000000e-01 2.000000e-01 2.811016e-07 1.318888e-07 1.318888e-07
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d35-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d35-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.250000e-01 1.250000e-01 1.250000e-01 4.674952e-02 1.030612e-03 1.030612e-03
	+3.750000e-01 1.250000e-01 1.250000e-01 4.422159e-02 9.748829e-04 9.748829e-04
	+6.250000e-01 1.250000e-01 1.250000e-01 4.231137e-02 9.318112e-04 9.318112e-04
	+8.750000e-01 1.250000e-01 1.250000e-01 3.816794e-02 8.636419e-04 8.636419e-04
	+1.125000e+00 1.250000e-01 1.250000e-01 3.469582e-02 7.789192e-04 7.789192e-04
	+1.375000e+00 1.250000e-01 1.250000e-01 2.934473e-02 6.806459e-04 6.806459e-04
	+1.625000e+00 1.250000e-01 1.250000e-01 2.365184e-02 5.764455e-04 5.764455e-04
	+1.875000e+00 1.250000e-01 1.250000e-01 1.893158e-02 4.721523e-04 4.721523e-04
	+2.125000e+00 1.250000e-01 1.250000e-01 1.037998e-02 2.983229e-04 2.983229e-04
	+2.375000e+00 1.250000e-01 1.250000e-01 3.446691e-03 1.451708e-04 1.451708e-04
	+2.625000e+00 1.250000e-01 1.250000e-01 5.395814e-04 5.184476e-05 5.184476e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d36-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d36-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.250000e-01 1.250000e-01 1.250000e-01 1.051109e-02 2.749007e-04 2.749007e-04
	+3.750000e-01 1.250000e-01 1.250000e-01 9.932498e-03 2.614719e-04 2.614719e-04
	+6.250000e-01 1.250000e-01 1.250000e-01 9.045323e-03 2.427115e-04 2.427115e-04
	+8.750000e-01 1.250000e-01 1.250000e-01 8.554913e-03 2.375433e-04 2.375433e-04
	+1.125000e+00 1.250000e-01 1.250000e-01 7.490385e-03 2.147534e-04 2.147534e-04
	+1.375000e+00 1.250000e-01 1.250000e-01 6.589817e-03 2.024694e-04 2.024694e-04
	+1.625000e+00 1.250000e-01 1.250000e-01 5.656759e-03 1.833000e-04 1.833000e-04
	+1.875000e+00 1.250000e-01 1.250000e-01 4.674952e-03 1.658785e-04 1.658785e-04
	+2.125000e+00 1.250000e-01 1.250000e-01 3.590476e-03 1.407632e-04 1.407632e-04
	+2.375000e+00 1.250000e-01 1.250000e-01 2.753075e-03 1.178367e-04 1.178367e-04
	+2.625000e+00 1.250000e-01 1.250000e-01 1.832707e-03 8.783619e-05 8.783619e-05
	+2.875000e+00 1.250000e-01 1.250000e-01 7.265193e-04 5.449864e-05 5.449864e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d37-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d37-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.250000e-01 1.250000e-01 1.250000e-01 2.151163e-03 7.033348e-05 7.033348e-05
	+3.750000e-01 1.250000e-01 1.250000e-01 2.042594e-03 6.869315e-05 6.869315e-05
	+6.250000e-01 1.250000e-01 1.250000e-01 1.907067e-03 6.620022e-05 6.620022e-05
	+8.750000e-01 1.250000e-01 1.250000e-01 1.843629e-03 6.621684e-05 6.621684e-05
	+1.125000e+00 1.250000e-01 1.250000e-01 1.565217e-03 6.098325e-05 6.098325e-05
	+1.375000e+00 1.250000e-01 1.250000e-01 1.420290e-03 5.850836e-05 5.850836e-05
	+1.625000e+00 1.250000e-01 1.250000e-01 1.225869e-03 5.524576e-05 5.524576e-05
	+1.875000e+00 1.250000e-01 1.250000e-01 1.030829e-03 5.232914e-05 5.232914e-05
	+2.125000e+00 1.250000e-01 1.250000e-01 8.448940e-04 4.712510e-05 4.712510e-05
	+2.375000e+00 1.250000e-01 1.250000e-01 6.051873e-04 4.085351e-05 4.085351e-05
	+2.625000e+00 1.250000e-01 1.250000e-01 4.694073e-04 3.645998e-05 3.645998e-05
	+2.875000e+00 1.250000e-01 1.250000e-01 3.519924e-04 3.108912e-05 3.108912e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d38-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d38-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-01 2.500000e-01 2.500000e-01 2.582205e-04 1.086062e-05 1.086062e-05
	+7.500000e-01 2.500000e-01 2.500000e-01 2.575024e-04 1.081204e-05 1.081204e-05
	+1.250000e+00 2.500000e-01 2.500000e-01 2.067633e-04 9.971908e-06 9.971908e-06
	+1.750000e+00 2.500000e-01 2.500000e-01 1.650579e-04 9.464600e-06 9.464600e-06
	+2.250000e+00 2.500000e-01 2.500000e-01 9.238921e-05 7.731492e-06 7.731492e-06
	+2.750000e+00 2.500000e-01 2.500000e-01 6.484150e-05 6.684967e-06 6.684967e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1467454/d39-x01-y01
	+Path=/REF/ATLAS_2016_I1467454/d39-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-01 2.500000e-01 2.500000e-01 7.922705e-06 7.355753e-07 7.355753e-07
	+7.500000e-01 2.500000e-01 2.500000e-01 8.280193e-06 7.524049e-07 7.524049e-07
	+1.250000e+00 2.500000e-01 2.500000e-01 6.805019e-06 6.997268e-07 6.997268e-07
	+1.750000e+00 2.500000e-01 2.500000e-01 6.605593e-06 7.063971e-07 7.063971e-07
	+2.250000e+00 2.500000e-01 2.500000e-01 4.721689e-06 6.156691e-07 6.156691e-07
	+2.750000e+00 2.500000e-01 2.500000e-01 2.692308e-06 4.944253e-07 4.944253e-07
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1468167.yoda b/data/refdata/ATLAS_2016_I1468167.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1468167.yoda
	@@ -0,0 +1,9 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1468167/d01-x01-y01
	+IsRef=1
	+Path=/REF/ATLAS_2016_I1468167/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.300000e+04 5.000000e-01 5.000000e-01 6.810000e+01 1.431782e+00 1.431782e+00
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1468168.yoda b/data/refdata/ATLAS_2016_I1468168.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1468168.yoda
	@@ -0,0 +1,8 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1468168/d02-x01-y01
	+Path=/REF/ATLAS_2016_I1468168/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.000000e-01 5.000000e-01 5.000000e-01 1.132000e+01 4.365776e-01 4.365776e-01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/ATLAS_2016_I1479760.yoda b/data/refdata/ATLAS_2016_I1479760.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/ATLAS_2016_I1479760.yoda
	@@ -0,0 +1,501 @@
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d01-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-02 2.500000e-02 2.500000e-02 2.259510e-01 8.436963e-03 1.182188e-02
	+7.500000e-02 2.500000e-02 2.500000e-02 5.713490e-01 1.898704e-02 4.197721e-02
	+1.250000e-01 2.500000e-02 2.500000e-02 7.983650e-01 2.002999e-02 2.886567e-02
	+1.750000e-01 2.500000e-02 2.500000e-02 9.010300e-01 2.178402e-02 2.893672e-02
	+2.250000e-01 2.500000e-02 2.500000e-02 9.247110e-01 2.209393e-02 2.963943e-02
	+2.750000e-01 2.500000e-02 2.500000e-02 9.034240e-01 2.024580e-02 3.956748e-02
	+3.250000e-01 2.500000e-02 2.500000e-02 9.170850e-01 4.470438e-02 2.872035e-02
	+3.750000e-01 2.500000e-02 2.500000e-02 8.998480e-01 2.789828e-02 3.193255e-02
	+4.250000e-01 2.500000e-02 2.500000e-02 8.356040e-01 2.191445e-02 3.567992e-02
	+4.750000e-01 2.500000e-02 2.500000e-02 8.395260e-01 2.301138e-02 2.886344e-02
	+5.250000e-01 2.500000e-02 2.500000e-02 7.873730e-01 2.454560e-02 4.575426e-02
	+5.750000e-01 2.500000e-02 2.500000e-02 8.430670e-01 3.875917e-02 2.450123e-02
	+6.250000e-01 2.500000e-02 2.500000e-02 8.234150e-01 3.249362e-02 2.580189e-02
	+6.750000e-01 2.500000e-02 2.500000e-02 8.164000e-01 2.866388e-02 4.366513e-02
	+7.250000e-01 2.500000e-02 2.500000e-02 8.692290e-01 3.122209e-02 2.318793e-02
	+7.750000e-01 2.500000e-02 2.500000e-02 9.106890e-01 3.098679e-02 5.539311e-02
	+8.250000e-01 2.500000e-02 2.500000e-02 1.060605e+00 3.275742e-02 3.187497e-02
	+8.750000e-01 2.500000e-02 2.500000e-02 1.269669e+00 4.783334e-02 3.276139e-02
	+9.250000e-01 2.500000e-02 2.500000e-02 1.595773e+00 5.480455e-02 4.644044e-02
	+9.750000e-01 2.500000e-02 2.500000e-02 3.206888e+00 1.121424e-01 6.163978e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d02-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 2.315150e-01 8.478258e-03 9.822621e-03
	+3.000000e-01 1.000000e-01 1.000000e-01 2.523040e-01 1.515158e-02 7.050013e-03
	+5.000000e-01 1.000000e-01 1.000000e-01 2.601570e-01 1.170128e-02 7.095826e-03
	+7.000000e-01 1.000000e-01 1.000000e-01 2.894390e-01 8.287186e-03 9.507979e-03
	+9.000000e-01 1.000000e-01 1.000000e-01 3.068830e-01 1.494569e-02 8.278549e-03
	+1.100000e+00 1.000000e-01 1.000000e-01 2.883950e-01 1.552534e-02 8.106673e-03
	+1.300000e+00 1.000000e-01 1.000000e-01 2.878550e-01 9.733985e-03 1.318905e-02
	+1.500000e+00 1.000000e-01 1.000000e-01 2.936290e-01 9.809860e-03 7.739376e-03
	+1.700000e+00 1.000000e-01 1.000000e-01 2.951510e-01 9.323428e-03 1.221695e-02
	+1.900000e+00 1.000000e-01 1.000000e-01 3.197090e-01 1.162003e-02 9.534625e-03
	+2.100000e+00 1.000000e-01 1.000000e-01 3.275900e-01 1.177208e-02 1.113327e-02
	+2.300000e+00 1.000000e-01 1.000000e-01 3.461880e-01 9.487907e-03 1.723610e-02
	+2.500000e+00 1.000000e-01 1.000000e-01 3.749100e-01 1.781132e-02 1.189000e-02
	+2.700000e+00 1.000000e-01 1.000000e-01 3.890580e-01 9.704733e-03 1.440975e-02
	+2.900000e+00 1.000000e-01 1.000000e-01 4.187730e-01 1.073052e-02 1.949529e-02
	+3.100000e+00 1.000000e-01 1.000000e-01 3.184430e-01 1.052026e-02 1.362144e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d03-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-02 2.500000e-02 2.500000e-02 3.793150e-01 5.626329e-02 2.328694e-02
	+7.500000e-02 2.500000e-02 2.500000e-02 1.004156e+00 7.227490e-02 6.286608e-02
	+1.250000e-01 2.500000e-02 2.500000e-02 1.510480e+00 9.207869e-02 9.189021e-02
	+1.750000e-01 2.500000e-02 2.500000e-02 1.884680e+00 1.005621e-01 1.130517e-01
	+2.250000e-01 2.500000e-02 2.500000e-02 2.133776e+00 9.211876e-02 8.146518e-02
	+2.750000e-01 2.500000e-02 2.500000e-02 2.309389e+00 7.708896e-02 4.974799e-02
	+3.250000e-01 2.500000e-02 2.500000e-02 2.158379e+00 3.881126e-02 5.852754e-02
	+3.750000e-01 2.500000e-02 2.500000e-02 1.956346e+00 7.318480e-02 7.318480e-02
	+4.250000e-01 2.500000e-02 2.500000e-02 1.585008e+00 9.206347e-02 6.913669e-02
	+4.750000e-01 2.500000e-02 2.500000e-02 1.266816e+00 8.115196e-02 7.451437e-02
	+5.250000e-01 2.500000e-02 2.500000e-02 9.187560e-01 5.974772e-02 9.525027e-02
	+5.750000e-01 2.500000e-02 2.500000e-02 6.882830e-01 4.483243e-02 5.909450e-02
	+6.250000e-01 2.500000e-02 2.500000e-02 4.776800e-01 3.179584e-02 5.857473e-02
	+6.750000e-01 2.500000e-02 2.500000e-02 3.856010e-01 2.971948e-02 3.638388e-02
	+7.250000e-01 2.500000e-02 2.500000e-02 2.827810e-01 2.135050e-02 3.507631e-02
	+7.750000e-01 2.500000e-02 2.500000e-02 2.474470e-01 1.757993e-02 2.301822e-02
	+8.250000e-01 2.500000e-02 2.500000e-02 1.998110e-01 3.965129e-02 1.720162e-02
	+8.750000e-01 2.500000e-02 2.500000e-02 1.924000e-01 3.831409e-02 1.591633e-02
	+9.250000e-01 2.500000e-02 2.500000e-02 1.984700e-01 3.731454e-02 1.873621e-02
	+9.750000e-01 2.500000e-02 2.500000e-02 2.204260e-01 2.490977e-02 3.504433e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d04-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-02 2.500000e-02 2.500000e-02 6.103000e-03 9.886243e-04 6.150650e-04
	+7.500000e-02 2.500000e-02 2.500000e-02 3.771100e-02 4.441433e-03 3.447542e-03
	+1.250000e-01 2.500000e-02 2.500000e-02 1.171290e-01 5.159514e-03 1.779449e-02
	+1.750000e-01 2.500000e-02 2.500000e-02 2.756620e-01 1.288472e-02 3.276478e-02
	+2.250000e-01 2.500000e-02 2.500000e-02 5.633620e-01 5.350952e-02 4.956491e-02
	+2.750000e-01 2.500000e-02 2.500000e-02 9.915760e-01 8.453489e-02 7.035895e-02
	+3.250000e-01 2.500000e-02 2.500000e-02 1.418996e+00 8.487098e-02 7.886440e-02
	+3.750000e-01 2.500000e-02 2.500000e-02 1.776722e+00 8.492970e-02 5.070987e-02
	+4.250000e-01 2.500000e-02 2.500000e-02 1.913167e+00 4.739359e-02 2.662115e-02
	+4.750000e-01 2.500000e-02 2.500000e-02 1.932184e+00 4.801068e-02 5.980248e-02
	+5.250000e-01 2.500000e-02 2.500000e-02 1.818711e+00 6.040604e-02 6.232606e-02
	+5.750000e-01 2.500000e-02 2.500000e-02 1.622084e+00 8.602618e-02 7.416553e-02
	+6.250000e-01 2.500000e-02 2.500000e-02 1.334657e+00 7.349835e-02 9.317836e-02
	+6.750000e-01 2.500000e-02 2.500000e-02 1.136755e+00 6.414864e-02 4.999425e-02
	+7.250000e-01 2.500000e-02 2.500000e-02 9.489890e-01 5.089813e-02 3.888308e-02
	+7.750000e-01 2.500000e-02 2.500000e-02 7.851540e-01 3.063863e-02 2.491442e-02
	+8.250000e-01 2.500000e-02 2.500000e-02 7.445940e-01 2.584645e-02 6.825854e-02
	+8.750000e-01 2.500000e-02 2.500000e-02 7.026140e-01 2.521086e-02 2.895380e-02
	+9.250000e-01 2.500000e-02 2.500000e-02 7.748240e-01 3.066898e-02 3.630651e-02
	+9.750000e-01 2.500000e-02 2.500000e-02 1.099008e+00 6.467777e-02 7.540837e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d05-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-02 2.500000e-02 2.500000e-02 8.566700e-02 1.310631e-02 8.069536e-03
	+7.500000e-02 2.500000e-02 2.500000e-02 2.200920e-01 3.749218e-02 1.029662e-02
	+1.250000e-01 2.500000e-02 2.500000e-02 3.016530e-01 3.264633e-02 1.203188e-02
	+1.750000e-01 2.500000e-02 2.500000e-02 3.812960e-01 2.799010e-02 2.052248e-02
	+2.250000e-01 2.500000e-02 2.500000e-02 4.551770e-01 2.124291e-02 4.424751e-02
	+2.750000e-01 2.500000e-02 2.500000e-02 4.809270e-01 1.777555e-02 3.822514e-02
	+3.250000e-01 2.500000e-02 2.500000e-02 5.373150e-01 1.708503e-02 3.648021e-02
	+3.750000e-01 2.500000e-02 2.500000e-02 5.995290e-01 1.916172e-02 4.153857e-02
	+4.250000e-01 2.500000e-02 2.500000e-02 7.065990e-01 4.970502e-02 2.582429e-02
	+4.750000e-01 2.500000e-02 2.500000e-02 6.779210e-01 2.630621e-02 7.961469e-02
	+5.250000e-01 2.500000e-02 2.500000e-02 7.791250e-01 3.029837e-02 3.098798e-02
	+5.750000e-01 2.500000e-02 2.500000e-02 8.190110e-01 2.116798e-02 3.709976e-02
	+6.250000e-01 2.500000e-02 2.500000e-02 9.375330e-01 5.444917e-02 2.968265e-02
	+6.750000e-01 2.500000e-02 2.500000e-02 9.939690e-01 4.641992e-02 2.781294e-02
	+7.250000e-01 2.500000e-02 2.500000e-02 1.065006e+00 6.462069e-02 3.006187e-02
	+7.750000e-01 2.500000e-02 2.500000e-02 1.211501e+00 3.542528e-02 3.318792e-02
	+8.250000e-01 2.500000e-02 2.500000e-02 1.349548e+00 3.875960e-02 8.303731e-02
	+8.750000e-01 2.500000e-02 2.500000e-02 1.671353e+00 4.269924e-02 1.122138e-01
	+9.250000e-01 2.500000e-02 2.500000e-02 2.243055e+00 4.643981e-02 6.694871e-02
	+9.750000e-01 2.500000e-02 2.500000e-02 4.483723e+00 1.805083e-01 7.162864e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d06-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-02 2.500000e-02 2.500000e-02 2.400000e-05 2.236068e-06 1.290039e-04
	+7.500000e-02 2.500000e-02 2.500000e-02 2.635000e-03 5.179286e-04 3.069674e-04
	+1.250000e-01 2.500000e-02 2.500000e-02 1.625400e-02 1.479855e-03 1.645369e-03
	+1.750000e-01 2.500000e-02 2.500000e-02 5.568100e-02 7.809896e-03 7.839128e-03
	+2.250000e-01 2.500000e-02 2.500000e-02 1.311680e-01 1.042458e-02 2.213189e-02
	+2.750000e-01 2.500000e-02 2.500000e-02 2.975580e-01 2.341996e-02 3.987990e-02
	+3.250000e-01 2.500000e-02 2.500000e-02 6.086780e-01 4.162072e-02 7.067914e-02
	+3.750000e-01 2.500000e-02 2.500000e-02 1.110857e+00 7.166842e-02 6.375786e-02
	+4.250000e-01 2.500000e-02 2.500000e-02 1.435497e+00 6.566397e-02 5.502575e-02
	+4.750000e-01 2.500000e-02 2.500000e-02 1.616446e+00 7.138290e-02 2.563330e-02
	+5.250000e-01 2.500000e-02 2.500000e-02 1.663246e+00 3.589959e-02 3.378108e-02
	+5.750000e-01 2.500000e-02 2.500000e-02 1.695835e+00 4.621030e-02 4.401214e-02
	+6.250000e-01 2.500000e-02 2.500000e-02 1.529871e+00 4.928885e-02 7.349446e-02
	+6.750000e-01 2.500000e-02 2.500000e-02 1.444184e+00 5.699249e-02 7.632838e-02
	+7.250000e-01 2.500000e-02 2.500000e-02 1.247717e+00 6.597580e-02 6.875522e-02
	+7.750000e-01 2.500000e-02 2.500000e-02 1.138871e+00 4.876119e-02 3.587423e-02
	+8.250000e-01 2.500000e-02 2.500000e-02 1.100362e+00 2.987743e-02 4.535788e-02
	+8.750000e-01 2.500000e-02 2.500000e-02 1.151870e+00 5.442201e-02 3.001527e-02
	+9.250000e-01 2.500000e-02 2.500000e-02 1.415797e+00 4.531659e-02 3.630610e-02
	+9.750000e-01 2.500000e-02 2.500000e-02 2.337449e+00 1.194577e-01 9.140840e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d07-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.500000e-02 2.500000e-02 2.500000e-02 9.801000e-03 5.544484e-04 4.993907e-03
	+7.500000e-02 2.500000e-02 2.500000e-02 7.958000e-02 1.656000e-02 3.722881e-03
	+1.250000e-01 2.500000e-02 2.500000e-02 1.648750e-01 4.735213e-03 3.020564e-02
	+1.750000e-01 2.500000e-02 2.500000e-02 3.189580e-01 2.396353e-02 2.142759e-02
	+2.250000e-01 2.500000e-02 2.500000e-02 4.653290e-01 2.373918e-02 2.251847e-02
	+2.750000e-01 2.500000e-02 2.500000e-02 6.013570e-01 1.453883e-02 2.096989e-02
	+3.250000e-01 2.500000e-02 2.500000e-02 7.331700e-01 2.009579e-02 1.742590e-02
	+3.750000e-01 2.500000e-02 2.500000e-02 8.527280e-01 7.342785e-02 1.702335e-02
	+4.250000e-01 2.500000e-02 2.500000e-02 8.540610e-01 2.364016e-02 1.743631e-02
	+4.750000e-01 2.500000e-02 2.500000e-02 8.996740e-01 3.452593e-02 3.016570e-02
	+5.250000e-01 2.500000e-02 2.500000e-02 8.884860e-01 2.420016e-02 2.615341e-02
	+5.750000e-01 2.500000e-02 2.500000e-02 9.147470e-01 2.113040e-02 3.518717e-02
	+6.250000e-01 2.500000e-02 2.500000e-02 9.553570e-01 3.210283e-02 4.657600e-02
	+6.750000e-01 2.500000e-02 2.500000e-02 9.796210e-01 3.384633e-02 3.077072e-02
	+7.250000e-01 2.500000e-02 2.500000e-02 1.008602e+00 2.884784e-02 2.756856e-02
	+7.750000e-01 2.500000e-02 2.500000e-02 1.061820e+00 2.081634e-02 3.542189e-02
	+8.250000e-01 2.500000e-02 2.500000e-02 1.209474e+00 4.661174e-02 2.664227e-02
	+8.750000e-01 2.500000e-02 2.500000e-02 1.583771e+00 3.687662e-02 2.965989e-02
	+9.250000e-01 2.500000e-02 2.500000e-02 2.145414e+00 3.973771e-02 3.571013e-02
	+9.750000e-01 2.500000e-02 2.500000e-02 4.273175e+00 6.728949e-02 8.978934e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d08-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 1.700400e-02 5.000144e-03 2.567567e-03
	+3.000000e-01 1.000000e-01 1.000000e-01 1.390500e-02 1.583321e-03 1.150429e-02
	+5.000000e-01 1.000000e-01 1.000000e-01 1.905200e-02 4.206904e-03 2.021457e-03
	+7.000000e-01 1.000000e-01 1.000000e-01 3.003200e-02 5.492226e-03 3.819048e-03
	+9.000000e-01 1.000000e-01 1.000000e-01 3.979400e-02 7.642228e-03 4.744684e-03
	+1.100000e+00 1.000000e-01 1.000000e-01 5.011400e-02 8.834726e-03 3.870450e-03
	+1.300000e+00 1.000000e-01 1.000000e-01 6.323300e-02 9.796648e-03 4.698413e-03
	+1.500000e+00 1.000000e-01 1.000000e-01 8.668900e-02 5.564657e-03 6.502699e-03
	+1.700000e+00 1.000000e-01 1.000000e-01 1.249460e-01 1.133604e-02 1.481400e-02
	+1.900000e+00 1.000000e-01 1.000000e-01 1.948320e-01 8.654472e-03 1.562237e-02
	+2.100000e+00 1.000000e-01 1.000000e-01 2.992250e-01 1.076932e-02 1.881904e-02
	+2.300000e+00 1.000000e-01 1.000000e-01 4.702940e-01 2.005833e-02 1.389304e-02
	+2.500000e+00 1.000000e-01 1.000000e-01 6.729980e-01 3.090511e-02 2.589027e-02
	+2.700000e+00 1.000000e-01 1.000000e-01 8.932210e-01 1.677880e-02 4.587405e-02
	+2.900000e+00 1.000000e-01 1.000000e-01 1.122176e+00 3.951127e-02 2.856009e-02
	+3.100000e+00 1.000000e-01 1.000000e-01 9.024860e-01 3.335332e-02 2.694700e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d09-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 7.481200e-02 9.270458e-03 5.574044e-03
	+3.000000e-01 1.000000e-01 1.000000e-01 7.007500e-02 4.784537e-03 1.007742e-02
	+5.000000e-01 1.000000e-01 1.000000e-01 8.496200e-02 3.579224e-03 7.576098e-03
	+7.000000e-01 1.000000e-01 1.000000e-01 1.307830e-01 8.278976e-03 9.969669e-03
	+9.000000e-01 1.000000e-01 1.000000e-01 1.330740e-01 6.409461e-03 7.952523e-03
	+1.100000e+00 1.000000e-01 1.000000e-01 1.569690e-01 6.901924e-03 5.882222e-03
	+1.300000e+00 1.000000e-01 1.000000e-01 1.869190e-01 6.640680e-03 1.347009e-02
	+1.500000e+00 1.000000e-01 1.000000e-01 2.229940e-01 1.108734e-02 6.795152e-03
	+1.700000e+00 1.000000e-01 1.000000e-01 2.787430e-01 8.716163e-03 1.204215e-02
	+1.900000e+00 1.000000e-01 1.000000e-01 3.501870e-01 1.310190e-02 1.068363e-02
	+2.100000e+00 1.000000e-01 1.000000e-01 4.318520e-01 1.530070e-02 9.738899e-03
	+2.300000e+00 1.000000e-01 1.000000e-01 5.015240e-01 1.203552e-02 1.354942e-02
	+2.500000e+00 1.000000e-01 1.000000e-01 5.790760e-01 1.198843e-02 1.442383e-02
	+2.700000e+00 1.000000e-01 1.000000e-01 6.528230e-01 2.991396e-02 1.253243e-02
	+2.900000e+00 1.000000e-01 1.000000e-01 6.594270e-01 1.325821e-02 1.337427e-02
	+3.100000e+00 1.000000e-01 1.000000e-01 4.857810e-01 1.264140e-02 1.919837e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d10-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 3.269440e-01 1.713065e-02 9.415571e-03
	+3.000000e-01 1.000000e-01 1.000000e-01 3.360260e-01 2.532315e-02 8.721758e-03
	+5.000000e-01 1.000000e-01 1.000000e-01 3.579260e-01 1.408999e-02 1.372623e-02
	+7.000000e-01 1.000000e-01 1.000000e-01 4.069370e-01 1.174768e-02 1.656271e-02
	+9.000000e-01 1.000000e-01 1.000000e-01 4.080230e-01 1.041293e-02 2.891371e-02
	+1.100000e+00 1.000000e-01 1.000000e-01 3.888060e-01 9.720139e-03 1.619305e-02
	+1.300000e+00 1.000000e-01 1.000000e-01 3.625420e-01 9.903581e-03 3.044931e-02
	+1.500000e+00 1.000000e-01 1.000000e-01 3.590990e-01 2.263638e-02 1.016740e-02
	+1.700000e+00 1.000000e-01 1.000000e-01 3.473080e-01 2.087516e-02 9.218847e-03
	+1.900000e+00 1.000000e-01 1.000000e-01 3.286930e-01 1.704400e-02 1.351546e-02
	+2.100000e+00 1.000000e-01 1.000000e-01 3.045350e-01 9.487450e-03 1.683054e-02
	+2.300000e+00 1.000000e-01 1.000000e-01 2.785100e-01 9.521794e-03 9.408026e-03
	+2.500000e+00 1.000000e-01 1.000000e-01 2.267210e-01 6.431762e-03 2.773807e-02
	+2.700000e+00 1.000000e-01 1.000000e-01 2.243580e-01 9.768321e-03 1.607270e-02
	+2.900000e+00 1.000000e-01 1.000000e-01 2.049380e-01 1.713533e-02 7.185872e-03
	+3.100000e+00 1.000000e-01 1.000000e-01 1.386330e-01 1.558011e-02 5.544130e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d11-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d11-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 1.366010e-01 6.769532e-03 6.979609e-03
	+3.000000e-01 1.000000e-01 1.000000e-01 1.500670e-01 1.000305e-02 1.183878e-02
	+5.000000e-01 1.000000e-01 1.000000e-01 1.762540e-01 1.166285e-02 8.052644e-03
	+7.000000e-01 1.000000e-01 1.000000e-01 2.297560e-01 1.845226e-02 8.522655e-03
	+9.000000e-01 1.000000e-01 1.000000e-01 2.326460e-01 8.742834e-03 1.185509e-02
	+1.100000e+00 1.000000e-01 1.000000e-01 2.241090e-01 9.427414e-03 8.917911e-03
	+1.300000e+00 1.000000e-01 1.000000e-01 2.439010e-01 7.275711e-03 9.846531e-03
	+1.500000e+00 1.000000e-01 1.000000e-01 2.607900e-01 1.055084e-02 1.349872e-02
	+1.700000e+00 1.000000e-01 1.000000e-01 2.975500e-01 8.701760e-03 8.648177e-03
	+1.900000e+00 1.000000e-01 1.000000e-01 3.394440e-01 1.041546e-02 1.136179e-02
	+2.100000e+00 1.000000e-01 1.000000e-01 3.652730e-01 9.593406e-03 1.586672e-02
	+2.300000e+00 1.000000e-01 1.000000e-01 4.190380e-01 8.216259e-03 1.254061e-02
	+2.500000e+00 1.000000e-01 1.000000e-01 4.630670e-01 1.032632e-02 1.222405e-02
	+2.700000e+00 1.000000e-01 1.000000e-01 5.108180e-01 1.641758e-02 9.546694e-03
	+2.900000e+00 1.000000e-01 1.000000e-01 5.481150e-01 9.726773e-03 1.369927e-02
	+3.100000e+00 1.000000e-01 1.000000e-01 4.025710e-01 1.642233e-02 9.335302e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d12-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d12-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 2.922330e-01 7.335450e-03 1.408357e-02
	+3.000000e-01 1.000000e-01 1.000000e-01 3.033960e-01 6.427024e-03 1.283598e-02
	+5.000000e-01 1.000000e-01 1.000000e-01 3.425650e-01 1.384758e-02 7.288716e-03
	+7.000000e-01 1.000000e-01 1.000000e-01 3.792590e-01 1.248829e-02 1.257385e-02
	+9.000000e-01 1.000000e-01 1.000000e-01 3.818490e-01 1.090165e-02 9.078862e-03
	+1.100000e+00 1.000000e-01 1.000000e-01 3.486940e-01 1.961433e-02 6.691983e-03
	+1.300000e+00 1.000000e-01 1.000000e-01 3.101830e-01 6.860817e-03 1.142398e-02
	+1.500000e+00 1.000000e-01 1.000000e-01 3.062130e-01 6.494347e-03 8.448949e-03
	+1.700000e+00 1.000000e-01 1.000000e-01 3.030780e-01 8.322116e-03 8.730375e-03
	+1.900000e+00 1.000000e-01 1.000000e-01 3.086110e-01 9.103219e-03 1.647031e-02
	+2.100000e+00 1.000000e-01 1.000000e-01 3.163160e-01 8.508146e-03 7.303854e-03
	+2.300000e+00 1.000000e-01 1.000000e-01 3.133040e-01 1.223466e-02 6.808527e-03
	+2.500000e+00 1.000000e-01 1.000000e-01 2.986120e-01 8.633537e-03 7.420918e-03
	+2.700000e+00 1.000000e-01 1.000000e-01 3.038150e-01 8.443946e-03 9.725851e-03
	+2.900000e+00 1.000000e-01 1.000000e-01 2.862060e-01 7.116474e-03 8.301206e-03
	+3.100000e+00 1.000000e-01 1.000000e-01 2.056660e-01 7.170299e-03 7.273911e-03
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d13-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d13-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-01 3.000000e-01 3.000000e-01 3.155860e-01 1.489555e-02 1.496289e-02
	+9.000000e-01 3.000000e-01 3.000000e-01 3.121450e-01 9.924288e-03 9.549110e-03
	+1.500000e+00 3.000000e-01 3.000000e-01 3.002850e-01 1.390458e-02 7.155672e-03
	+2.100000e+00 3.000000e-01 3.000000e-01 2.437430e-01 6.617320e-03 1.106038e-02
	+2.700000e+00 3.000000e-01 3.000000e-01 1.839890e-01 5.783624e-03 5.101694e-03
	+3.300000e+00 3.000000e-01 3.000000e-01 1.306200e-01 6.452272e-03 1.207547e-02
	+3.900000e+00 3.000000e-01 3.000000e-01 8.724700e-02 8.885952e-03 6.501002e-03
	+4.500000e+00 3.000000e-01 3.000000e-01 4.894800e-02 5.718999e-03 5.296580e-03
	+5.100000e+00 3.000000e-01 3.000000e-01 2.540000e-02 4.042662e-03 5.756781e-03
	+5.700000e+00 3.000000e-01 3.000000e-01 1.241300e-02 3.048636e-03 3.567714e-03
	+6.300000e+00 3.000000e-01 3.000000e-01 4.883000e-03 1.825404e-03 2.534064e-03
	+6.900000e+00 3.000000e-01 3.000000e-01 1.034000e-03 4.539218e-04 1.095875e-03
	+7.500000e+00 3.000000e-01 3.000000e-01 3.230000e-04 2.488715e-04 3.034633e-04
	+8.100000e+00 3.000000e-01 3.000000e-01 5.200000e-05 2.961419e-05 1.897367e-05
	+8.700000e+00 3.000000e-01 3.000000e-01 0.000000e+00 0.000000e+00 0.000000e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d14-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d14-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-01 3.000000e-01 3.000000e-01 2.813240e-01 1.497178e-02 1.690516e-02
	+9.000000e-01 3.000000e-01 3.000000e-01 3.051970e-01 1.226743e-02 2.361710e-02
	+1.500000e+00 3.000000e-01 3.000000e-01 2.736520e-01 1.339670e-02 8.465987e-03
	+2.100000e+00 3.000000e-01 3.000000e-01 2.297370e-01 9.290285e-03 7.943947e-03
	+2.700000e+00 3.000000e-01 3.000000e-01 1.825290e-01 5.532780e-03 7.202633e-03
	+3.300000e+00 3.000000e-01 3.000000e-01 1.453440e-01 9.361131e-03 4.930608e-03
	+3.900000e+00 3.000000e-01 3.000000e-01 9.736000e-02 8.277840e-03 9.900609e-03
	+4.500000e+00 3.000000e-01 3.000000e-01 6.544600e-02 9.911816e-03 7.413480e-03
	+5.100000e+00 3.000000e-01 3.000000e-01 3.940400e-02 6.980582e-03 8.288835e-03
	+5.700000e+00 3.000000e-01 3.000000e-01 2.425900e-02 6.723315e-03 6.319557e-03
	+6.300000e+00 3.000000e-01 3.000000e-01 1.284400e-02 3.645726e-03 4.007917e-03
	+6.900000e+00 3.000000e-01 3.000000e-01 5.911000e-03 2.677249e-03 2.801033e-03
	+7.500000e+00 3.000000e-01 3.000000e-01 2.210000e-03 1.334575e-03 8.877759e-04
	+8.100000e+00 3.000000e-01 3.000000e-01 1.100000e-03 9.317264e-04 3.564842e-04
	+8.700000e+00 3.000000e-01 3.000000e-01 3.490000e-04 5.573984e-04 4.433058e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d15-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d15-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-01 3.000000e-01 3.000000e-01 3.099900e-01 1.349849e-02 8.527379e-03
	+9.000000e-01 3.000000e-01 3.000000e-01 3.213290e-01 1.106480e-02 1.404113e-02
	+1.500000e+00 3.000000e-01 3.000000e-01 2.785200e-01 9.578460e-03 8.138183e-03
	+2.100000e+00 3.000000e-01 3.000000e-01 2.325500e-01 7.131515e-03 4.768450e-03
	+2.700000e+00 3.000000e-01 3.000000e-01 1.800320e-01 3.717819e-03 7.711965e-03
	+3.300000e+00 3.000000e-01 3.000000e-01 1.343930e-01 6.327098e-03 4.994138e-03
	+3.900000e+00 3.000000e-01 3.000000e-01 9.079000e-02 6.153976e-03 6.522082e-03
	+4.500000e+00 3.000000e-01 3.000000e-01 5.593300e-02 5.255281e-03 7.247436e-03
	+5.100000e+00 3.000000e-01 3.000000e-01 3.502000e-02 7.323221e-03 5.124903e-03
	+5.700000e+00 3.000000e-01 3.000000e-01 1.721600e-02 3.918456e-03 2.698696e-03
	+6.300000e+00 3.000000e-01 3.000000e-01 6.159000e-03 1.334189e-03 3.332884e-03
	+6.900000e+00 3.000000e-01 3.000000e-01 3.641000e-03 2.380605e-03 1.230343e-03
	+7.500000e+00 3.000000e-01 3.000000e-01 9.850000e-04 4.741308e-04 1.239897e-03
	+8.100000e+00 3.000000e-01 3.000000e-01 1.070000e-04 8.709191e-05 1.241934e-04
	+8.700000e+00 3.000000e-01 3.000000e-01 1.000000e-06 1.000000e-06 0.000000e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d16-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d16-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-01 3.000000e-01 3.000000e-01 2.852290e-01 1.137856e-02 1.085924e-02
	+9.000000e-01 3.000000e-01 3.000000e-01 3.461050e-01 1.354983e-02 1.060781e-02
	+1.500000e+00 3.000000e-01 3.000000e-01 2.759970e-01 8.886379e-03 1.103531e-02
	+2.100000e+00 3.000000e-01 3.000000e-01 2.331810e-01 7.292812e-03 7.247580e-03
	+2.700000e+00 3.000000e-01 3.000000e-01 1.724830e-01 4.242473e-03 5.711234e-03
	+3.300000e+00 3.000000e-01 3.000000e-01 1.278560e-01 5.064854e-03 6.946585e-03
	+3.900000e+00 3.000000e-01 3.000000e-01 9.290900e-02 9.685218e-03 6.112187e-03
	+4.500000e+00 3.000000e-01 3.000000e-01 6.404800e-02 9.105294e-03 5.672623e-03
	+5.100000e+00 3.000000e-01 3.000000e-01 3.503600e-02 5.445143e-03 7.664026e-03
	+5.700000e+00 3.000000e-01 3.000000e-01 2.056100e-02 4.706816e-03 5.157530e-03
	+6.300000e+00 3.000000e-01 3.000000e-01 8.242000e-03 2.074012e-03 2.876569e-03
	+6.900000e+00 3.000000e-01 3.000000e-01 3.639000e-03 1.763229e-03 2.322847e-03
	+7.500000e+00 3.000000e-01 3.000000e-01 1.238000e-03 5.122207e-04 5.440561e-04
	+8.100000e+00 3.000000e-01 3.000000e-01 1.420000e-04 1.284134e-04 5.377220e-04
	+8.700000e+00 3.000000e-01 3.000000e-01 0.000000e+00 0.000000e+00 1.000000e-06
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d17-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d17-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-01 3.000000e-01 3.000000e-01 3.036220e-01 1.317218e-02 1.767986e-02
	+9.000000e-01 3.000000e-01 3.000000e-01 3.281110e-01 1.462139e-02 1.070601e-02
	+1.500000e+00 3.000000e-01 3.000000e-01 2.736090e-01 8.481757e-03 1.045041e-02
	+2.100000e+00 3.000000e-01 3.000000e-01 2.287720e-01 5.557007e-03 5.078776e-03
	+2.700000e+00 3.000000e-01 3.000000e-01 1.822140e-01 7.074795e-03 4.622105e-03
	+3.300000e+00 3.000000e-01 3.000000e-01 1.334570e-01 9.627879e-03 4.363339e-03
	+3.900000e+00 3.000000e-01 3.000000e-01 9.218000e-02 5.751990e-03 9.467286e-03
	+4.500000e+00 3.000000e-01 3.000000e-01 5.905500e-02 7.997390e-03 6.425835e-03
	+5.100000e+00 3.000000e-01 3.000000e-01 3.308200e-02 5.170362e-03 7.354896e-03
	+5.700000e+00 3.000000e-01 3.000000e-01 2.018000e-02 5.671410e-03 5.160353e-03
	+6.300000e+00 3.000000e-01 3.000000e-01 8.249000e-03 2.210462e-03 1.961381e-03
	+6.900000e+00 3.000000e-01 3.000000e-01 3.297000e-03 1.317822e-03 2.175748e-03
	+7.500000e+00 3.000000e-01 3.000000e-01 6.230000e-04 2.795300e-04 4.179677e-04
	+8.100000e+00 3.000000e-01 3.000000e-01 2.160000e-04 1.836001e-04 1.142366e-04
	+8.700000e+00 3.000000e-01 3.000000e-01 0.000000e+00 0.000000e+00 0.000000e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d18-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d18-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.000000e-01 3.000000e-01 3.000000e-01 2.815460e-01 1.368408e-02 1.152967e-02
	+9.000000e-01 3.000000e-01 3.000000e-01 3.437700e-01 1.480019e-02 1.164523e-02
	+1.500000e+00 3.000000e-01 3.000000e-01 2.813640e-01 8.721978e-03 8.102272e-03
	+2.100000e+00 3.000000e-01 3.000000e-01 2.201490e-01 3.595803e-03 9.426071e-03
	+2.700000e+00 3.000000e-01 3.000000e-01 1.770770e-01 7.081900e-03 3.342784e-03
	+3.300000e+00 3.000000e-01 3.000000e-01 1.324150e-01 4.758404e-03 7.223570e-03
	+3.900000e+00 3.000000e-01 3.000000e-01 9.344000e-02 6.139616e-03 6.120010e-03
	+4.500000e+00 3.000000e-01 3.000000e-01 6.012100e-02 4.613473e-03 7.288549e-03
	+5.100000e+00 3.000000e-01 3.000000e-01 3.798100e-02 7.399383e-03 4.180893e-03
	+5.700000e+00 3.000000e-01 3.000000e-01 2.157000e-02 4.693134e-03 4.398912e-03
	+6.300000e+00 3.000000e-01 3.000000e-01 1.046700e-02 2.948378e-03 3.388268e-03
	+6.900000e+00 3.000000e-01 3.000000e-01 4.723000e-03 1.944970e-03 1.646637e-03
	+7.500000e+00 3.000000e-01 3.000000e-01 1.680000e-03 7.630177e-04 9.415546e-04
	+8.100000e+00 3.000000e-01 3.000000e-01 3.640000e-04 2.718124e-04 1.443676e-04
	+8.700000e+00 3.000000e-01 3.000000e-01 0.000000e+00 0.000000e+00 5.000000e-05
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d19-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d19-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 4.808100e-02 3.434557e-03 6.978858e-03
	+3.000000e-01 1.000000e-01 1.000000e-01 5.138000e-02 4.369807e-03 5.017808e-03
	+5.000000e-01 1.000000e-01 1.000000e-01 5.399300e-02 4.455950e-03 3.861102e-03
	+7.000000e-01 1.000000e-01 1.000000e-01 5.392700e-02 4.463269e-03 4.883928e-03
	+9.000000e-01 1.000000e-01 1.000000e-01 6.112000e-02 4.122762e-03 5.746376e-03
	+1.100000e+00 1.000000e-01 1.000000e-01 6.670300e-02 3.465539e-03 9.366036e-03
	+1.300000e+00 1.000000e-01 1.000000e-01 8.374300e-02 7.095965e-03 5.692195e-03
	+1.500000e+00 1.000000e-01 1.000000e-01 1.005090e-01 5.791760e-03 9.113261e-03
	+1.700000e+00 1.000000e-01 1.000000e-01 1.203170e-01 7.585601e-03 5.482264e-03
	+1.900000e+00 1.000000e-01 1.000000e-01 1.646990e-01 1.160307e-02 6.752683e-03
	+2.100000e+00 1.000000e-01 1.000000e-01 2.315930e-01 1.926340e-02 8.439483e-03
	+2.300000e+00 1.000000e-01 1.000000e-01 3.279210e-01 2.356013e-02 1.015385e-02
	+2.500000e+00 1.000000e-01 1.000000e-01 4.968070e-01 2.068815e-02 1.748346e-02
	+2.700000e+00 1.000000e-01 1.000000e-01 7.844070e-01 2.061846e-02 8.735845e-03
	+2.900000e+00 1.000000e-01 1.000000e-01 1.208513e+00 2.889983e-02 4.164053e-02
	+3.100000e+00 1.000000e-01 1.000000e-01 1.146289e+00 4.320932e-02 7.019655e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d20-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d20-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 1.171700e-02 1.809246e-03 1.600435e-03
	+3.000000e-01 1.000000e-01 1.000000e-01 1.312300e-02 1.943515e-03 1.890684e-03
	+5.000000e-01 1.000000e-01 1.000000e-01 1.132300e-02 1.068272e-03 9.768301e-04
	+7.000000e-01 1.000000e-01 1.000000e-01 1.271700e-02 4.126811e-03 9.882358e-04
	+9.000000e-01 1.000000e-01 1.000000e-01 1.194700e-02 1.399538e-03 8.333731e-03
	+1.100000e+00 1.000000e-01 1.000000e-01 1.946600e-02 2.030591e-03 8.756483e-04
	+1.300000e+00 1.000000e-01 1.000000e-01 2.395300e-02 2.417177e-03 1.419117e-03
	+1.500000e+00 1.000000e-01 1.000000e-01 3.595600e-02 4.675623e-03 1.390408e-03
	+1.700000e+00 1.000000e-01 1.000000e-01 4.737700e-02 7.328947e-03 4.992780e-03
	+1.900000e+00 1.000000e-01 1.000000e-01 7.194600e-02 1.179016e-02 6.558543e-03
	+2.100000e+00 1.000000e-01 1.000000e-01 1.276420e-01 1.731028e-02 6.382027e-03
	+2.300000e+00 1.000000e-01 1.000000e-01 1.979490e-01 1.279674e-02 9.618712e-03
	+2.500000e+00 1.000000e-01 1.000000e-01 3.939370e-01 2.453150e-02 1.377055e-02
	+2.700000e+00 1.000000e-01 1.000000e-01 7.704290e-01 3.037686e-02 1.936731e-02
	+2.900000e+00 1.000000e-01 1.000000e-01 1.528689e+00 1.432041e-02 3.462237e-02
	+3.100000e+00 1.000000e-01 1.000000e-01 1.721829e+00 4.650005e-02 7.625356e-02
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/ATLAS_2016_I1479760/d21-x01-y01
	+Path=/REF/ATLAS_2016_I1479760/d21-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e-01 1.000000e-01 1.000000e-01 9.876000e-03 2.946691e-03 1.186080e-03
	+3.000000e-01 1.000000e-01 1.000000e-01 9.583000e-03 1.687658e-03 6.679416e-04
	+5.000000e-01 1.000000e-01 1.000000e-01 1.246000e-02 3.270072e-03 1.289503e-03
	+7.000000e-01 1.000000e-01 1.000000e-01 1.446500e-02 3.432230e-03 8.153257e-04
	+9.000000e-01 1.000000e-01 1.000000e-01 1.727200e-02 7.537046e-03 1.566091e-03
	+1.100000e+00 1.000000e-01 1.000000e-01 1.965500e-02 2.725410e-03 1.380357e-03
	+1.300000e+00 1.000000e-01 1.000000e-01 2.168300e-02 2.341628e-03 5.580466e-03
	+1.500000e+00 1.000000e-01 1.000000e-01 2.935000e-02 4.829400e-03 5.344381e-03
	+1.700000e+00 1.000000e-01 1.000000e-01 4.126000e-02 5.944111e-03 3.788257e-03
	+1.900000e+00 1.000000e-01 1.000000e-01 5.875800e-02 6.328900e-03 5.290212e-03
	+2.100000e+00 1.000000e-01 1.000000e-01 9.381900e-02 8.424623e-03 1.308062e-02
	+2.300000e+00 1.000000e-01 1.000000e-01 1.737040e-01 1.325726e-02 7.528234e-03
	+2.500000e+00 1.000000e-01 1.000000e-01 3.405400e-01 2.514140e-02 1.099764e-02
	+2.700000e+00 1.000000e-01 1.000000e-01 7.309200e-01 3.832751e-02 1.297035e-02
	+2.900000e+00 1.000000e-01 1.000000e-01 1.548863e+00 1.600290e-02 2.537637e-02
	+3.100000e+00 1.000000e-01 1.000000e-01 1.877793e+00 4.237437e-02 8.558472e-02
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/BABAR_2013_I1116411.yoda b/data/refdata/BABAR_2013_I1116411.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/BABAR_2013_I1116411.yoda
	@@ -0,0 +1,12 @@
	+BEGIN YODA_SCATTER2D /REF/BABAR_2013_I1116411/d01-x01-y01
	+Path=/REF/BABAR_2013_I1116411/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+00 2.000000e+00 2.000000e+00 5.350000e-02 1.615549e-02 1.615549e-02
	+6.000000e+00 2.000000e+00 2.000000e+00 5.000000e-02 9.581884e-03 9.581884e-03
	+9.000000e+00 1.000000e+00 1.000000e+00 7.350000e-02 1.533786e-02 1.533786e-02
	+1.100000e+01 1.000000e+00 1.000000e+00 8.450000e-02 1.628650e-02 1.628650e-02
	+1.650000e+01 4.500000e+00 4.500000e+00 5.355556e-02 1.116266e-02 1.116266e-02
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/BABAR_2015_I1334693.yoda b/data/refdata/BABAR_2015_I1334693.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/BABAR_2015_I1334693.yoda
	@@ -0,0 +1,17 @@
	+BEGIN YODA_SCATTER2D /REF/BABAR_2015_I1334693/d01-x01-y01
	+Path=/REF/BABAR_2015_I1334693/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.500000e-01 1.500000e-01 1.500000e-01 6.830000e+01 3.700000e+00 3.700000e+00
	+4.500000e-01 1.500000e-01 1.500000e-01 6.330000e+01 4.742362e+00 4.742362e+00
	+7.500000e-01 1.500000e-01 1.500000e-01 6.170000e+01 4.143670e+00 4.143670e+00
	+1.050000e+00 1.500000e-01 1.500000e-01 5.190000e+01 4.016217e+00 4.016217e+00
	+1.350000e+00 1.500000e-01 1.500000e-01 4.120000e+01 3.794733e+00 3.794733e+00
	+1.650000e+00 1.500000e-01 1.500000e-01 3.610000e+01 3.716181e+00 3.716181e+00
	+1.950000e+00 1.500000e-01 1.500000e-01 2.860000e+01 4.000000e+00 4.000000e+00
	+2.250000e+00 1.500000e-01 1.500000e-01 1.670000e+01 3.420526e+00 3.420526e+00
	+2.550000e+00 1.500000e-01 1.500000e-01 6.500000e+00 2.683282e+00 2.683282e+00
	+2.850000e+00 1.500000e-01 1.500000e-01 1.200000e+00 8.544004e-01 8.544004e-01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/BELLE_2011_I878990.yoda b/data/refdata/BELLE_2011_I878990.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/BELLE_2011_I878990.yoda
	@@ -0,0 +1,21 @@
	+BEGIN YODA_SCATTER2D /REF/BELLE_2011_I878990/d01-x01-y01
	+Path=/REF/BELLE_2011_I878990/d01-x01-y01
	+Title=
	+IsRef=1
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.173300e+02 2.190000e+01 2.190000e+01
	+3.000000e+00 1.000000e+00 1.000000e+00 1.525800e+02 1.035000e+01 1.035000e+01
	+5.000000e+00 1.000000e+00 1.000000e+00 1.212800e+02 1.048000e+01 1.048000e+01
	+7.000000e+00 1.000000e+00 1.000000e+00 1.465400e+02 1.020000e+01 1.020000e+01
	+9.000000e+00 1.000000e+00 1.000000e+00 1.473200e+02 1.084000e+01 1.084000e+01
	+1.100000e+01 1.000000e+00 1.000000e+00 1.403900e+02 1.241000e+01 1.241000e+01
	+1.300000e+01 1.000000e+00 1.000000e+00 1.450000e+02 1.246000e+01 1.246000e+01
	+1.500000e+01 1.000000e+00 1.000000e+00 1.259000e+02 1.329000e+01 1.329000e+01
	+1.700000e+01 1.000000e+00 1.000000e+00 1.185700e+02 1.301000e+01 1.301000e+01
	+1.900000e+01 1.000000e+00 1.000000e+00 7.359000e+01 1.960000e+01 1.960000e+01
	+2.100000e+01 1.000000e+00 1.000000e+00 9.421000e+01 1.312000e+01 1.312000e+01
	+2.300000e+01 1.000000e+00 1.000000e+00 7.980000e+01 1.539000e+01 1.539000e+01
	+2.520000e+01 1.200000e+00 1.200000e+00 3.159000e+01 2.208000e+01 2.208000e+01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/BELLE_2013_I1238273.yoda b/data/refdata/BELLE_2013_I1238273.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/BELLE_2013_I1238273.yoda
	@@ -0,0 +1,75 @@
	+BEGIN YODA_SCATTER2D /REF/BELLE_2013_I1238273/d01-x01-y01
	+Path=/REF/BELLE_2013_I1238273/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.950000e+01 3.200000e+00 3.200000e+00
	+3.000000e+00 1.000000e+00 1.000000e+00 1.060000e+01 2.700000e+00 2.700000e+00
	+5.000000e+00 1.000000e+00 1.000000e+00 1.510000e+01 2.800000e+00 2.800000e+00
	+7.000000e+00 1.000000e+00 1.000000e+00 9.700000e+00 2.300000e+00 2.300000e+00
	+9.000000e+00 1.000000e+00 1.000000e+00 7.800000e+00 2.200000e+00 2.200000e+00
	+1.100000e+01 1.000000e+00 1.000000e+00 1.590000e+01 2.800000e+00 2.800000e+00
	+1.300000e+01 1.000000e+00 1.000000e+00 1.350000e+01 2.700000e+00 2.700000e+00
	+1.500000e+01 1.000000e+00 1.000000e+00 1.360000e+01 2.800000e+00 2.800000e+00
	+1.700000e+01 1.000000e+00 1.000000e+00 1.070000e+01 2.500000e+00 2.500000e+00
	+1.900000e+01 1.000000e+00 1.000000e+00 1.160000e+01 2.500000e+00 2.500000e+00
	+2.100000e+01 1.000000e+00 1.000000e+00 1.180000e+01 2.800000e+00 2.800000e+00
	+2.300000e+01 1.000000e+00 1.000000e+00 6.700000e+00 2.100000e+00 2.100000e+00
	+2.500000e+01 1.000000e+00 1.000000e+00 2.800000e+00 3.100000e+00 3.100000e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/BELLE_2013_I1238273/d02-x01-y01
	+Path=/REF/BELLE_2013_I1238273/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+00 2.000000e+00 2.000000e+00 1.810000e+01 3.200000e+00 3.200000e+00
	+6.000000e+00 2.000000e+00 2.000000e+00 1.570000e+01 3.400000e+00 3.400000e+00
	+1.000000e+01 2.000000e+00 2.000000e+00 1.080000e+01 2.700000e+00 2.700000e+00
	+1.400000e+01 2.000000e+00 2.000000e+00 1.850000e+01 3.400000e+00 3.400000e+00
	+1.800000e+01 2.000000e+00 2.000000e+00 1.070000e+01 2.800000e+00 2.800000e+00
	+2.200000e+01 2.000000e+00 2.000000e+00 5.100000e+00 2.600000e+00 2.600000e+00
	+2.600000e+01 2.000000e+00 2.000000e+00 2.300000e+00 2.500000e+00 2.500000e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/BELLE_2013_I1238273/d03-x01-y01
	+Path=/REF/BELLE_2013_I1238273/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e+00 2.000000e+00 2.000000e+00 3.730000e+01 1.060000e+01 1.060000e+01
	+6.000000e+00 2.000000e+00 2.000000e+00 7.180000e+01 1.160000e+01 1.160000e+01
	+1.000000e+01 2.000000e+00 2.000000e+00 8.060000e+01 1.230000e+01 1.230000e+01
	+1.400000e+01 2.000000e+00 2.000000e+00 7.230000e+01 1.250000e+01 1.250000e+01
	+1.800000e+01 2.000000e+00 2.000000e+00 6.260000e+01 1.150000e+01 1.150000e+01
	+2.200000e+01 2.000000e+00 2.000000e+00 1.700000e+00 7.900000e+00 7.900000e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/BELLE_2013_I1238273/d04-x01-y01
	+Path=/REF/BELLE_2013_I1238273/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.000000e+00 1.000000e+00 1.000000e+00 1.240000e+01 3.400000e+00 3.400000e+00
	+3.000000e+00 1.000000e+00 1.000000e+00 1.530000e+01 3.100000e+00 3.100000e+00
	+5.000000e+00 1.000000e+00 1.000000e+00 1.790000e+01 3.400000e+00 3.400000e+00
	+7.000000e+00 1.000000e+00 1.000000e+00 2.170000e+01 3.400000e+00 3.400000e+00
	+9.000000e+00 1.000000e+00 1.000000e+00 1.430000e+01 2.900000e+00 2.900000e+00
	+1.100000e+01 1.000000e+00 1.000000e+00 1.990000e+01 3.400000e+00 3.400000e+00
	+1.300000e+01 1.000000e+00 1.000000e+00 2.240000e+01 3.400000e+00 3.400000e+00
	+1.500000e+01 1.000000e+00 1.000000e+00 2.170000e+01 3.300000e+00 3.300000e+00
	+1.700000e+01 1.000000e+00 1.000000e+00 1.750000e+01 3.200000e+00 3.200000e+00
	+1.900000e+01 1.000000e+00 1.000000e+00 1.430000e+01 2.800000e+00 2.800000e+00
	+2.100000e+01 1.000000e+00 1.000000e+00 5.900000e+00 2.600000e+00 2.600000e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/BELLE_2013_I1238273/d05-x01-y01
	+Path=/REF/BELLE_2013_I1238273/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+3.500000e+00 3.500000e+00 3.500000e+00 2.280000e+01 6.200000e+00 6.200000e+00
	+1.050000e+01 3.500000e+00 3.500000e+00 5.650000e+01 1.060000e+01 1.060000e+01
	+1.750000e+01 3.500000e+00 3.500000e+00 3.390000e+01 1.150000e+01 1.150000e+01
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/BELLE_2015_I1397632.yoda b/data/refdata/BELLE_2015_I1397632.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/BELLE_2015_I1397632.yoda
	@@ -0,0 +1,72 @@
	+BEGIN YODA_SCATTER2D /REF/BELLE_2015_I1397632/d01-x01-y01
	+Path=/REF/BELLE_2015_I1397632/d01-x01-y01
	+Title=
	+IsRef=1
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.030000e+00 3.000000e-02 3.000000e-02 3.000000e-01 3.157531e-01 3.157531e-01
	+1.090000e+00 3.000000e-02 3.000000e-02 4.410000e+00 8.780091e-01 8.780091e-01
	+1.150000e+00 3.000000e-02 3.000000e-02 9.060000e+00 1.221966e+00 1.221966e+00
	+1.210000e+00 3.000000e-02 3.000000e-02 1.181000e+01 1.405276e+00 1.405276e+00
	+1.270000e+00 3.000000e-02 3.000000e-02 1.373000e+01 1.507116e+00 1.507116e+00
	+1.330000e+00 3.000000e-02 3.000000e-02 1.992000e+01 1.794714e+00 1.794714e+00
	+1.390000e+00 3.000000e-02 3.000000e-02 2.545000e+01 2.116034e+00 2.116034e+00
	+1.450000e+00 3.000000e-02 3.000000e-02 3.045000e+01 2.308528e+00 2.308528e+00
	+1.510000e+00 3.000000e-02 3.000000e-02 3.157000e+01 2.289738e+00 2.289738e+00
	+1.570000e+00 3.000000e-02 3.000000e-02 3.581000e+01 2.521270e+00 2.521270e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/BELLE_2015_I1397632/d01-x01-y02
	+Path=/REF/BELLE_2015_I1397632/d01-x01-y02
	+Title=
	+IsRef=1
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.030000e+00 3.000000e-02 3.000000e-02 8.100000e-01 4.751842e-01 4.751842e-01
	+1.090000e+00 3.000000e-02 3.000000e-02 3.630000e+00 7.397973e-01 7.397973e-01
	+1.150000e+00 3.000000e-02 3.000000e-02 7.730000e+00 1.103857e+00 1.103857e+00
	+1.210000e+00 3.000000e-02 3.000000e-02 1.347000e+01 1.570127e+00 1.570127e+00
	+1.270000e+00 3.000000e-02 3.000000e-02 1.411000e+01 1.583161e+00 1.583161e+00
	+1.330000e+00 3.000000e-02 3.000000e-02 2.009000e+01 1.867753e+00 1.867753e+00
	+1.390000e+00 3.000000e-02 3.000000e-02 2.463000e+01 2.111161e+00 2.111161e+00
	+1.450000e+00 3.000000e-02 3.000000e-02 2.948000e+01 2.332145e+00 2.332145e+00
	+1.510000e+00 3.000000e-02 3.000000e-02 3.031000e+01 2.420021e+00 2.420021e+00
	+1.570000e+00 3.000000e-02 3.000000e-02 3.462000e+01 2.730018e+00 2.730018e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/BELLE_2015_I1397632/d01-x01-y03
	+Path=/REF/BELLE_2015_I1397632/d01-x01-y03
	+Title=
	+IsRef=1
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.030000e+00 3.000000e-02 3.000000e-02 7.200000e-01 6.806614e-01 6.806614e-01
	+1.090000e+00 3.000000e-02 3.000000e-02 3.840000e+00 8.448077e-01 8.448077e-01
	+1.150000e+00 3.000000e-02 3.000000e-02 7.640000e+00 9.889894e-01 9.889894e-01
	+1.210000e+00 3.000000e-02 3.000000e-02 1.120000e+01 1.179915e+00 1.179915e+00
	+1.270000e+00 3.000000e-02 3.000000e-02 1.468000e+01 1.368247e+00 1.368247e+00
	+1.330000e+00 3.000000e-02 3.000000e-02 2.015000e+01 1.564001e+00 1.564001e+00
	+1.390000e+00 3.000000e-02 3.000000e-02 2.420000e+01 1.746683e+00 1.746683e+00
	+1.450000e+00 3.000000e-02 3.000000e-02 2.892000e+01 1.952562e+00 1.952562e+00
	+1.510000e+00 3.000000e-02 3.000000e-02 3.090000e+01 1.988291e+00 1.988291e+00
	+1.570000e+00 3.000000e-02 3.000000e-02 3.442000e+01 2.128497e+00 2.128497e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/BELLE_2015_I1397632/d01-x01-y04
	+Path=/REF/BELLE_2015_I1397632/d01-x01-y04
	+Title=
	+IsRef=1
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.030000e+00 3.000000e-02 3.000000e-02 1.330000e+00 4.295346e-01 4.295346e-01
	+1.090000e+00 3.000000e-02 3.000000e-02 4.280000e+00 7.400000e-01 7.400000e-01
	+1.150000e+00 3.000000e-02 3.000000e-02 7.520000e+00 1.007224e+00 1.007224e+00
	+1.210000e+00 3.000000e-02 3.000000e-02 1.176000e+01 1.151217e+00 1.151217e+00
	+1.270000e+00 3.000000e-02 3.000000e-02 1.754000e+01 1.502431e+00 1.502431e+00
	+1.330000e+00 3.000000e-02 3.000000e-02 2.067000e+01 1.614435e+00 1.614435e+00
	+1.390000e+00 3.000000e-02 3.000000e-02 2.445000e+01 1.803136e+00 1.803136e+00
	+1.450000e+00 3.000000e-02 3.000000e-02 2.693000e+01 1.889577e+00 1.889577e+00
	+1.510000e+00 3.000000e-02 3.000000e-02 2.985000e+01 2.024747e+00 2.024747e+00
	+1.570000e+00 3.000000e-02 3.000000e-02 3.283000e+01 2.174971e+00 2.174971e+00
	+END YODA_SCATTER2D
	+
	diff --git a/data/refdata/CDF_2009_S8383952.yoda b/data/refdata/CDF_2009_I856131.yoda
	rename from data/refdata/CDF_2009_S8383952.yoda
	rename to data/refdata/CDF_2009_I856131.yoda
	--- a/data/refdata/CDF_2009_S8383952.yoda
	+++ b/data/refdata/CDF_2009_I856131.yoda
	@@ -1,46 +1,46 @@
	-BEGIN YODA_SCATTER2D /REF/CDF_2009_S8383952/d01-x01-y01
	+BEGIN YODA_SCATTER2D /REF/CDF_2009_I856131/d01-x01-y01
	IsRef=1
	-Path=/REF/CDF_2009_S8383952/d01-x01-y01
	+Path=/REF/CDF_2009_I856131/d01-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	1.960000e+03 5.000000e-01 5.000000e-01 2.560000e+02 2.118962e+00 2.118962e+00
	END YODA_SCATTER2D

	-BEGIN YODA_SCATTER2D /REF/CDF_2009_S8383952/d02-x01-y01
	+BEGIN YODA_SCATTER2D /REF/CDF_2009_I856131/d02-x01-y01
	IsRef=1
	-Path=/REF/CDF_2009_S8383952/d02-x01-y01
	+Path=/REF/CDF_2009_I856131/d02-x01-y01
	Title=
	Type=Scatter2D
	# xval xerr- xerr+ yval yerr- yerr+
	5.000000e-02 5.000000e-02 5.000000e-02 6.941000e+01 8.792042e-01 8.792042e-01
	1.500000e-01 5.000000e-02 5.000000e-02 7.094000e+01 8.875246e-01 8.875246e-01
	2.500000e-01 5.000000e-02 5.000000e-02 7.086000e+01 8.792042e-01 8.792042e-01
	3.500000e-01 5.000000e-02 5.000000e-02 6.968000e+01 8.653323e-01 8.653323e-01
	4.500000e-01 5.000000e-02 5.000000e-02 6.762000e+01 8.431489e-01 8.431489e-01
	5.500000e-01 5.000000e-02 5.000000e-02 6.779000e+01 8.431489e-01 8.431489e-01
	6.500000e-01 5.000000e-02 5.000000e-02 6.607000e+01 8.348653e-01 8.348653e-01
	7.500000e-01 5.000000e-02 5.000000e-02 6.619000e+01 8.405355e-01 8.405355e-01
	8.500000e-01 5.000000e-02 5.000000e-02 6.431000e+01 8.381527e-01 8.381527e-01
	9.500000e-01 5.000000e-02 5.000000e-02 6.388000e+01 8.381527e-01 8.381527e-01
	1.050000e+00 5.000000e-02 5.000000e-02 6.191000e+01 8.280097e-01 8.280097e-01
	1.150000e+00 5.000000e-02 5.000000e-02 6.127000e+01 8.140025e-01 8.140025e-01
	1.250000e+00 5.000000e-02 5.000000e-02 5.821000e+01 8.021222e-01 8.021222e-01
	1.350000e+00 5.000000e-02 5.000000e-02 5.559000e+01 7.655064e-01 7.655064e-01
	1.450000e+00 5.000000e-02 5.000000e-02 5.311000e+01 7.462573e-01 7.462573e-01
	1.550000e+00 5.000000e-02 5.000000e-02 4.991000e+01 7.220111e-01 7.220111e-01
	1.650000e+00 5.000000e-02 5.000000e-02 4.648000e+01 6.946222e-01 6.946222e-01
	1.750000e+00 5.000000e-02 5.000000e-02 4.083000e+01 6.673080e-01 6.673080e-01
	1.850000e+00 5.000000e-02 5.000000e-02 3.703000e+01 6.449806e-01 6.449806e-01
	1.950000e+00 5.000000e-02 5.000000e-02 3.321000e+01 6.313478e-01 6.313478e-01
	2.050000e+00 5.000000e-02 5.000000e-02 2.805000e+01 5.860034e-01 5.860034e-01
	2.150000e+00 5.000000e-02 5.000000e-02 2.243000e+01 5.636488e-01 5.636488e-01
	2.250000e+00 5.000000e-02 5.000000e-02 1.907000e+01 5.515433e-01 5.515433e-01
	2.350000e+00 5.000000e-02 5.000000e-02 1.485000e+01 5.502727e-01 5.502727e-01
	2.450000e+00 5.000000e-02 5.000000e-02 9.400000e+00 4.924429e-01 4.924429e-01
	2.550000e+00 5.000000e-02 5.000000e-02 6.160000e+00 4.903060e-01 4.903060e-01
	2.650000e+00 5.000000e-02 5.000000e-02 3.270000e+00 4.904080e-01 4.904080e-01
	2.750000e+00 5.000000e-02 5.000000e-02 1.480000e+00 4.159327e-01 4.159327e-01
	2.850000e+00 5.000000e-02 5.000000e-02 9.600000e-01 5.770615e-01 5.770615e-01
	END YODA_SCATTER2D

	diff --git a/data/refdata/CDF_2015_1388868.yoda b/data/refdata/CDF_2015_1388868.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/CDF_2015_1388868.yoda
	@@ -0,0 +1,520 @@
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d03-x01-y09
	+Path=/REF/CDF_2015_I1388868/d03-x01-y09
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 4.180000e-02 8.100000e-03 8.100000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 1.267000e-01 9.500000e-03 9.500000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 1.910000e-01 9.700000e-03 9.700000e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 2.291000e-01 1.050000e-02 1.050000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 2.542000e-01 7.500000e-03 7.500000e-03
	+3.250000e+00 2.500000e-01 2.500000e-01 2.693000e-01 9.800000e-03 9.800000e-03
	+3.750000e+00 2.500000e-01 2.500000e-01 2.844000e-01 1.030000e-02 1.030000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 2.791000e-01 1.080000e-02 1.080000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 2.869000e-01 1.370000e-02 1.370000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 2.829000e-01 1.200000e-02 1.200000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 2.858000e-01 2.020000e-02 2.020000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 3.061000e-01 3.370000e-02 3.370000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 2.842000e-01 4.680000e-02 4.680000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 2.429000e-01 6.800000e-02 6.800000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d03-x01-y08
	+Path=/REF/CDF_2015_I1388868/d03-x01-y08
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 7.710000e-02 1.460000e-02 1.460000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 2.224000e-01 1.610000e-02 1.610000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 3.265000e-01 1.560000e-02 1.560000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 3.890000e-01 1.610000e-02 1.610000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 4.298000e-01 1.200000e-02 1.200000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 4.510000e-01 1.630000e-02 1.630000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 4.731000e-01 1.700000e-02 1.700000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 4.658000e-01 1.800000e-02 1.800000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 4.847000e-01 2.070000e-02 2.070000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 4.834000e-01 1.970000e-02 1.970000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 4.876000e-01 3.410000e-02 3.410000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 4.990000e-01 5.460000e-02 5.460000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 4.984000e-01 7.850000e-02 7.850000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 4.011000e-01 1.125000e-01 1.125000e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d03-x01-y04
	+Path=/REF/CDF_2015_I1388868/d03-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 6.700000e-02 1.290000e-02 1.290000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 1.723000e-01 1.300000e-02 1.300000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 2.347000e-01 1.260000e-02 1.260000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 2.664000e-01 1.320000e-02 1.320000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 2.844000e-01 9.700000e-03 9.700000e-03
	+3.250000e+00 2.500000e-01 2.500000e-01 2.979000e-01 9.200000e-03 9.200000e-03
	+3.750000e+00 2.500000e-01 2.500000e-01 3.087000e-01 1.040000e-02 1.040000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 3.011000e-01 1.130000e-02 1.130000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 3.118000e-01 1.510000e-02 1.510000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 3.031000e-01 1.380000e-02 1.380000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 3.015000e-01 1.950000e-02 1.950000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 3.304000e-01 3.360000e-02 3.360000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 2.925000e-01 4.010000e-02 4.010000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 2.644000e-01 6.670000e-02 6.670000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d03-x01-y07
	+Path=/REF/CDF_2015_I1388868/d03-x01-y07
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 6.400000e-03 1.500000e-03 1.500000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 3.100000e-02 3.000000e-03 3.000000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 5.550000e-02 3.800000e-03 3.800000e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 6.910000e-02 5.200000e-03 5.200000e-03
	+2.750000e+00 2.500000e-01 2.500000e-01 7.860000e-02 3.300000e-03 3.300000e-03
	+3.250000e+00 2.500000e-01 2.500000e-01 8.760000e-02 3.500000e-03 3.500000e-03
	+3.750000e+00 2.500000e-01 2.500000e-01 9.570000e-02 4.200000e-03 4.200000e-03
	+4.250000e+00 2.500000e-01 2.500000e-01 9.230000e-02 5.000000e-03 5.000000e-03
	+4.750000e+00 2.500000e-01 2.500000e-01 8.920000e-02 8.700000e-03 8.700000e-03
	+5.500000e+00 5.000000e-01 5.000000e-01 8.230000e-02 6.600000e-03 6.600000e-03
	+6.500000e+00 5.000000e-01 5.000000e-01 8.410000e-02 1.180000e-02 1.180000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 1.132000e-01 2.030000e-02 2.030000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 7.010000e-02 2.170000e-02 2.170000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 8.470000e-02 3.360000e-02 3.360000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d03-x01-y06
	+Path=/REF/CDF_2015_I1388868/d03-x01-y06
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 7.070000e-02 1.310000e-02 1.310000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 1.914000e-01 1.320000e-02 1.320000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 2.710000e-01 1.190000e-02 1.190000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 3.199000e-01 1.130000e-02 1.130000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 3.512000e-01 9.500000e-03 9.500000e-03
	+3.250000e+00 2.500000e-01 2.500000e-01 3.635000e-01 1.380000e-02 1.380000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 3.774000e-01 1.510000e-02 1.510000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 3.735000e-01 1.810000e-02 1.810000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 3.955000e-01 2.320000e-02 2.320000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 4.011000e-01 2.430000e-02 2.430000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 4.034000e-01 4.310000e-02 4.310000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 3.858000e-01 5.740000e-02 5.740000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 4.283000e-01 9.310000e-02 9.310000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 3.164000e-01 1.170000e-01 1.170000e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d03-x01-y01
	+Path=/REF/CDF_2015_I1388868/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.126000e-01 2.060000e-02 2.060000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 2.529000e-01 1.730000e-02 1.730000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 3.201000e-01 1.450000e-02 1.450000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 3.553000e-01 1.280000e-02 1.280000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 3.737000e-01 1.150000e-02 1.150000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 3.817000e-01 1.290000e-02 1.290000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 3.849000e-01 1.450000e-02 1.450000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 3.828000e-01 1.770000e-02 1.770000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 4.084000e-01 2.230000e-02 2.230000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 3.981000e-01 2.480000e-02 2.480000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 3.976000e-01 3.790000e-02 3.790000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 3.822000e-01 5.570000e-02 5.570000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 4.182000e-01 8.430000e-02 8.430000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 3.144000e-01 1.177000e-01 1.177000e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d03-x01-y03
	+Path=/REF/CDF_2015_I1388868/d03-x01-y03
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.233000e-01 2.320000e-02 2.320000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 2.987000e-01 2.160000e-02 2.160000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 3.947000e-01 1.980000e-02 1.980000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 4.441000e-01 1.940000e-02 1.940000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 4.713000e-01 1.530000e-02 1.530000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 4.888000e-01 1.520000e-02 1.520000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 5.011000e-01 1.680000e-02 1.680000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 4.926000e-01 1.850000e-02 1.850000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 5.160000e-01 2.240000e-02 2.240000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 5.022000e-01 2.270000e-02 2.270000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 5.003000e-01 3.170000e-02 3.170000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 5.215000e-01 5.370000e-02 5.370000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 5.016000e-01 6.650000e-02 6.650000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 4.217000e-01 1.040000e-01 1.040000e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d03-x01-y02
	+Path=/REF/CDF_2015_I1388868/d03-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.080000e-02 2.500000e-03 2.500000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 4.580000e-02 4.500000e-03 4.500000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 7.470000e-02 5.500000e-03 5.500000e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 8.880000e-02 7.200000e-03 7.200000e-03
	+2.750000e+00 2.500000e-01 2.500000e-01 9.760000e-02 4.300000e-03 4.300000e-03
	+3.250000e+00 2.500000e-01 2.500000e-01 1.071000e-01 3.800000e-03 3.800000e-03
	+3.750000e+00 2.500000e-01 2.500000e-01 1.162000e-01 4.700000e-03 4.700000e-03
	+4.250000e+00 2.500000e-01 2.500000e-01 1.097000e-01 5.600000e-03 5.600000e-03
	+4.750000e+00 2.500000e-01 2.500000e-01 1.075000e-01 9.700000e-03 9.700000e-03
	+5.500000e+00 5.000000e-01 5.000000e-01 1.040000e-01 7.500000e-03 7.500000e-03
	+6.500000e+00 5.000000e-01 5.000000e-01 1.027000e-01 1.270000e-02 1.270000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 1.393000e-01 2.340000e-02 2.340000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 8.340000e-02 2.160000e-02 2.160000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 1.072000e-01 4.420000e-02 4.420000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d02-x01-y04
	+Path=/REF/CDF_2015_I1388868/d02-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 8.750000e-02 8.600000e-03 8.600000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 2.346000e-01 9.000000e-03 9.000000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 3.421000e-01 1.150000e-02 1.150000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 4.060000e-01 1.260000e-02 1.260000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 4.422000e-01 1.490000e-02 1.490000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 4.644000e-01 1.350000e-02 1.350000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 4.747000e-01 1.150000e-02 1.150000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 4.809000e-01 1.220000e-02 1.220000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 4.859000e-01 1.260000e-02 1.260000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 4.855000e-01 1.440000e-02 1.440000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 4.961000e-01 1.410000e-02 1.410000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 4.770000e-01 2.030000e-02 2.030000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 4.931000e-01 1.910000e-02 1.910000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 4.729000e-01 2.790000e-02 2.790000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 4.521000e-01 6.430000e-02 6.430000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d02-x01-y06
	+Path=/REF/CDF_2015_I1388868/d02-x01-y06
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 9.000000e-02 8.600000e-03 8.600000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 2.486000e-01 8.500000e-03 8.500000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 3.685000e-01 1.070000e-02 1.070000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 4.517000e-01 1.190000e-02 1.190000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 5.010000e-01 1.300000e-02 1.300000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 5.315000e-01 1.940000e-02 1.940000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 5.505000e-01 1.460000e-02 1.460000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 5.668000e-01 1.430000e-02 1.430000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 5.786000e-01 1.480000e-02 1.480000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 5.935000e-01 1.470000e-02 1.470000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 6.244000e-01 1.720000e-02 1.720000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 6.108000e-01 2.440000e-02 2.440000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 6.446000e-01 2.450000e-02 2.450000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 7.023000e-01 4.070000e-02 4.070000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 6.076000e-01 9.430000e-02 9.430000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d02-x01-y07
	+Path=/REF/CDF_2015_I1388868/d02-x01-y07
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.000000e-02 1.200000e-03 1.200000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 5.110000e-02 2.400000e-03 2.400000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 1.002000e-01 3.800000e-03 3.800000e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 1.343000e-01 4.700000e-03 4.700000e-03
	+2.750000e+00 2.500000e-01 2.500000e-01 1.578000e-01 6.700000e-03 6.700000e-03
	+3.250000e+00 2.500000e-01 2.500000e-01 1.696000e-01 9.400000e-03 9.400000e-03
	+3.750000e+00 2.500000e-01 2.500000e-01 1.778000e-01 9.000000e-03 9.000000e-03
	+4.250000e+00 2.500000e-01 2.500000e-01 1.800000e-01 9.100000e-03 9.100000e-03
	+4.750000e+00 2.500000e-01 2.500000e-01 1.852000e-01 9.300000e-03 9.300000e-03
	+5.500000e+00 5.000000e-01 5.000000e-01 1.858000e-01 9.300000e-03 9.300000e-03
	+6.500000e+00 5.000000e-01 5.000000e-01 1.924000e-01 9.900000e-03 9.900000e-03
	+7.500000e+00 5.000000e-01 5.000000e-01 1.828000e-01 1.220000e-02 1.220000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 1.919000e-01 1.420000e-02 1.420000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 1.711000e-01 1.640000e-02 1.640000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 1.777000e-01 3.030000e-02 3.030000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d02-x01-y01
	+Path=/REF/CDF_2015_I1388868/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.420000e-01 1.340000e-02 1.340000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 3.221000e-01 1.120000e-02 1.120000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 4.229000e-01 1.310000e-02 1.310000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 4.789000e-01 1.350000e-02 1.350000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 5.093000e-01 1.320000e-02 1.320000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 5.324000e-01 1.080000e-02 1.080000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 5.395000e-01 1.270000e-02 1.270000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 5.470000e-01 1.230000e-02 1.230000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 5.500000e-01 1.270000e-02 1.270000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 5.529000e-01 1.450000e-02 1.450000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 5.659000e-01 1.550000e-02 1.550000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 5.435000e-01 2.280000e-02 2.280000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 5.591000e-01 2.280000e-02 2.280000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 5.700000e-01 3.670000e-02 3.670000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 5.108000e-01 8.830000e-02 8.830000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d02-x01-y02
	+Path=/REF/CDF_2015_I1388868/d02-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.650000e-02 1.900000e-03 1.900000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 7.350000e-02 3.500000e-03 3.500000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 1.307000e-01 4.900000e-03 4.900000e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 1.665000e-01 5.900000e-03 5.900000e-03
	+2.750000e+00 2.500000e-01 2.500000e-01 1.875000e-01 8.700000e-03 8.700000e-03
	+3.250000e+00 2.500000e-01 2.500000e-01 1.982000e-01 1.090000e-02 1.090000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 2.049000e-01 1.030000e-02 1.030000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 2.074000e-01 1.000000e-02 1.000000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 2.109000e-01 9.500000e-03 9.500000e-03
	+5.500000e+00 5.000000e-01 5.000000e-01 2.091000e-01 9.700000e-03 9.700000e-03
	+6.500000e+00 5.000000e-01 5.000000e-01 2.131000e-01 9.300000e-03 9.300000e-03
	+7.500000e+00 5.000000e-01 5.000000e-01 2.053000e-01 1.100000e-02 1.100000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 2.135000e-01 1.070000e-02 1.070000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 1.879000e-01 1.420000e-02 1.420000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 1.967000e-01 3.170000e-02 3.170000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d02-x01-y03
	+Path=/REF/CDF_2015_I1388868/d02-x01-y03
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.585000e-01 1.530000e-02 1.530000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 3.956000e-01 1.450000e-02 1.450000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 5.536000e-01 1.800000e-02 1.800000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 6.454000e-01 1.930000e-02 1.930000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 6.968000e-01 2.130000e-02 2.130000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 7.306000e-01 1.740000e-02 1.740000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 7.444000e-01 1.540000e-02 1.540000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 7.544000e-01 1.650000e-02 1.650000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 7.609000e-01 1.740000e-02 1.740000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 7.619000e-01 2.050000e-02 2.050000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 7.791000e-01 2.040000e-02 2.040000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 7.488000e-01 3.060000e-02 3.060000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 7.726000e-01 2.880000e-02 2.880000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 7.579000e-01 4.370000e-02 4.370000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 7.075000e-01 1.033000e-01 1.033000e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d02-x01-y08
	+Path=/REF/CDF_2015_I1388868/d02-x01-y08
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.000000e-01 9.700000e-03 9.700000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 2.997000e-01 1.080000e-02 1.080000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 4.687000e-01 1.450000e-02 1.450000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 5.860000e-01 1.650000e-02 1.650000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 6.587000e-01 1.930000e-02 1.930000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 7.011000e-01 2.840000e-02 2.840000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 7.284000e-01 2.190000e-02 2.190000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 7.468000e-01 2.150000e-02 2.150000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 7.637000e-01 2.210000e-02 2.210000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 7.793000e-01 2.200000e-02 2.200000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 8.168000e-01 2.340000e-02 2.340000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 7.936000e-01 3.200000e-02 3.200000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 8.365000e-01 3.100000e-02 3.100000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 8.734000e-01 4.380000e-02 4.380000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 7.853000e-01 1.116000e-01 1.116000e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d02-x01-y09
	+Path=/REF/CDF_2015_I1388868/d02-x01-y09
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 5.500000e-02 5.500000e-03 5.500000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 1.754000e-01 6.600000e-03 6.600000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 2.845000e-01 9.100000e-03 9.100000e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 3.601000e-01 1.060000e-02 1.060000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 4.082000e-01 1.290000e-02 1.290000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 4.353000e-01 1.880000e-02 1.880000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 4.531000e-01 1.510000e-02 1.510000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 4.634000e-01 1.500000e-02 1.500000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 4.744000e-01 1.540000e-02 1.540000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 4.826000e-01 1.530000e-02 1.530000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 5.046000e-01 1.620000e-02 1.620000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 4.882000e-01 2.150000e-02 2.150000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 5.142000e-01 2.170000e-02 2.170000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 5.222000e-01 2.870000e-02 2.870000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 4.815000e-01 6.650000e-02 6.650000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d01-x01-y07
	+Path=/REF/CDF_2015_I1388868/d01-x01-y07
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.120000e-02 1.900000e-03 1.900000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 6.220000e-02 3.800000e-03 3.800000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 1.259000e-01 6.000000e-03 6.000000e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 1.824000e-01 7.700000e-03 7.700000e-03
	+2.750000e+00 2.500000e-01 2.500000e-01 2.194000e-01 7.900000e-03 7.900000e-03
	+3.250000e+00 2.500000e-01 2.500000e-01 2.375000e-01 7.200000e-03 7.200000e-03
	+3.750000e+00 2.500000e-01 2.500000e-01 2.488000e-01 1.010000e-02 1.010000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 2.567000e-01 1.090000e-02 1.090000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 2.624000e-01 1.120000e-02 1.120000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 2.653000e-01 1.130000e-02 1.130000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 2.611000e-01 1.260000e-02 1.260000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 2.724000e-01 1.300000e-02 1.300000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 2.806000e-01 1.370000e-02 1.370000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 2.754000e-01 1.880000e-02 1.880000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 2.916000e-01 2.830000e-02 2.830000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d01-x01-y06
	+Path=/REF/CDF_2015_I1388868/d01-x01-y06
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 9.460000e-02 1.260000e-02 1.260000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 2.680000e-01 1.240000e-02 1.240000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 4.134000e-01 1.240000e-02 1.240000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 5.154000e-01 1.340000e-02 1.340000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 5.835000e-01 1.480000e-02 1.480000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 6.273000e-01 1.300000e-02 1.300000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 6.543000e-01 1.900000e-02 1.900000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 6.748000e-01 1.910000e-02 1.910000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 6.942000e-01 2.030000e-02 2.030000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 7.142000e-01 1.920000e-02 1.920000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 7.411000e-01 2.040000e-02 2.040000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 7.605000e-01 2.570000e-02 2.570000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 7.816000e-01 3.290000e-02 3.290000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 8.091000e-01 3.340000e-02 3.340000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 9.155000e-01 6.610000e-02 6.610000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d01-x01-y04
	+Path=/REF/CDF_2015_I1388868/d01-x01-y04
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 9.270000e-02 1.280000e-02 1.280000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 2.606000e-01 1.320000e-02 1.320000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 3.938000e-01 1.450000e-02 1.450000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 4.860000e-01 1.640000e-02 1.640000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 5.397000e-01 1.710000e-02 1.710000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 5.664000e-01 1.560000e-02 1.560000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 5.790000e-01 1.700000e-02 1.700000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 5.889000e-01 2.080000e-02 2.080000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 5.962000e-01 2.190000e-02 2.190000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 6.013000e-01 2.120000e-02 2.120000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 6.031000e-01 2.240000e-02 2.240000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 6.158000e-01 2.460000e-02 2.460000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 6.145000e-01 2.850000e-02 2.850000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 6.154000e-01 3.240000e-02 3.240000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 6.710000e-01 4.760000e-02 4.760000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d01-x01-y03
	+Path=/REF/CDF_2015_I1388868/d01-x01-y03
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.669000e-01 2.250000e-02 2.250000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 4.327000e-01 2.110000e-02 2.110000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 6.262000e-01 2.160000e-02 2.160000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 7.527000e-01 2.360000e-02 2.360000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 8.261000e-01 2.430000e-02 2.430000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 8.631000e-01 2.250000e-02 2.250000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 8.814000e-01 2.360000e-02 2.360000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 8.964000e-01 2.880000e-02 2.880000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 9.061000e-01 3.110000e-02 3.110000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 9.139000e-01 3.030000e-02 3.030000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 9.228000e-01 3.240000e-02 3.240000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 9.370000e-01 3.750000e-02 3.750000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 9.337000e-01 4.330000e-02 4.330000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 9.355000e-01 4.940000e-02 4.940000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 1.021800e+00 7.460000e-02 7.460000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d01-x01-y02
	+Path=/REF/CDF_2015_I1388868/d01-x01-y02
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.850000e-02 3.100000e-03 3.100000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 8.850000e-02 5.400000e-03 5.400000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 1.614000e-01 7.700000e-03 7.700000e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 2.192000e-01 9.200000e-03 9.200000e-03
	+2.750000e+00 2.500000e-01 2.500000e-01 2.532000e-01 1.000000e-02 1.000000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 2.698000e-01 9.000000e-03 9.000000e-03
	+3.750000e+00 2.500000e-01 2.500000e-01 2.765000e-01 1.070000e-02 1.070000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 2.814000e-01 1.310000e-02 1.310000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 2.862000e-01 1.280000e-02 1.280000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 2.886000e-01 1.230000e-02 1.230000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 2.835000e-01 1.270000e-02 1.270000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 2.946000e-01 1.230000e-02 1.230000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 2.954000e-01 1.440000e-02 1.440000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 2.953000e-01 1.650000e-02 1.650000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 3.201000e-01 2.660000e-02 2.660000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d01-x01-y01
	+Path=/REF/CDF_2015_I1388868/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.484000e-01 1.950000e-02 1.950000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 3.442000e-01 1.580000e-02 1.580000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 4.648000e-01 1.430000e-02 1.430000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 5.335000e-01 1.480000e-02 1.480000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 5.729000e-01 1.480000e-02 1.480000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 5.933000e-01 1.390000e-02 1.390000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 6.050000e-01 1.400000e-02 1.400000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 6.150000e-01 1.650000e-02 1.650000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 6.199000e-01 1.900000e-02 1.900000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 6.252000e-01 1.860000e-02 1.860000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 6.392000e-01 2.070000e-02 2.070000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 6.425000e-01 2.680000e-02 2.680000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 6.383000e-01 3.070000e-02 3.070000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 6.401000e-01 3.570000e-02 3.570000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 7.017000e-01 6.180000e-02 6.180000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d01-x01-y09
	+Path=/REF/CDF_2015_I1388868/d01-x01-y09
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 5.850000e-02 8.100000e-03 8.100000e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 1.962000e-01 9.900000e-03 9.900000e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 3.326000e-01 1.190000e-02 1.190000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 4.401000e-01 1.400000e-02 1.400000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 5.112000e-01 1.510000e-02 1.510000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 5.512000e-01 1.300000e-02 1.300000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 5.760000e-01 1.890000e-02 1.890000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 5.941000e-01 1.970000e-02 1.970000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 6.095000e-01 2.060000e-02 2.060000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 6.224000e-01 2.000000e-02 2.000000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 6.316000e-01 2.130000e-02 2.130000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 6.527000e-01 2.410000e-02 2.410000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 6.714000e-01 2.840000e-02 2.840000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 6.799000e-01 3.220000e-02 3.220000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 7.493000e-01 4.530000e-02 4.530000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CDF_2015_I1388868/d01-x01-y08
	+Path=/REF/CDF_2015_I1388868/d01-x01-y08
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.058000e-01 1.440000e-02 1.440000e-02
	+1.250000e+00 2.500000e-01 2.500000e-01 3.302000e-01 1.600000e-02 1.600000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 5.393000e-01 1.800000e-02 1.800000e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 6.978000e-01 2.060000e-02 2.060000e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 8.029000e-01 2.240000e-02 2.240000e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 8.649000e-01 1.930000e-02 1.930000e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 9.031000e-01 2.810000e-02 2.810000e-02
	+4.250000e+00 2.500000e-01 2.500000e-01 9.315000e-01 2.890000e-02 2.890000e-02
	+4.750000e+00 2.500000e-01 2.500000e-01 9.566000e-01 3.040000e-02 3.040000e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 9.795000e-01 2.920000e-02 2.920000e-02
	+6.500000e+00 5.000000e-01 5.000000e-01 1.002200e+00 3.070000e-02 3.070000e-02
	+7.500000e+00 5.000000e-01 5.000000e-01 1.032900e+00 3.610000e-02 3.610000e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 1.062200e+00 4.390000e-02 4.390000e-02
	+1.250000e+01 2.500000e+00 2.500000e+00 1.084500e+00 4.730000e-02 4.730000e-02
	+1.750000e+01 2.500000e+00 2.500000e+00 1.207100e+00 7.020000e-02 7.020000e-02
	+# END YODA_SCATTER2D
	+
	diff --git a/data/refdata/CMS_QCD_10_024.yoda b/data/refdata/CMS_2010_PAS_QCD_10_024.yoda
	rename from data/refdata/CMS_QCD_10_024.yoda
	rename to data/refdata/CMS_2010_PAS_QCD_10_024.yoda
	diff --git a/data/refdata/CMS_2012_I1298807.yoda b/data/refdata/CMS_2012_I1298807.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/CMS_2012_I1298807.yoda
	@@ -0,0 +1,83 @@
	+# BEGIN YODA_SCATTER2D /REF/CMS_2012_I1298807/d01-x01-y01
	+Path=/REF/CMS_2012_I1298807/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25 5 5 0.00508377 0.00581415 0.00581415
	+35 5 5 0.0197758 0.0109372 0.0109372
	+45 5 5 0.0910899 0.0237791 0.0237791
	+55 5 5 0.231394 0.03662 0.03662
	+65 5 5 0.182361 0.033151 0.033151
	+75 5 5 0.160737 0.0310452 0.0310452
	+85 5 5 0.127266 0.0272982 0.0272982
	+95 5 5 0.0373462 0.0151661 0.0151661
	+105 5 5 0.0520419 0.0178548 0.0178548
	+115 5 5 0.0541439 0.0181087 0.0181087
	+125 5 5 0.0267868 0.0125603 0.0125603
	+135 5 5 0.011973 0.00922171 0.00922171
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2012_I1298807/d01-x01-y02
	+Path=/REF/CMS_2012_I1298807/d01-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+12.5 12.5 12.5 0.142437 0.0270222 0.0270222
	+37.5 12.5 12.5 0.29585 0.0393331 0.0393331
	+62.5 12.5 12.5 0.277851 0.038096 0.038096
	+87.5 12.5 12.5 0.129176 0.0261016 0.0261016
	+112.5 12.5 12.5 0.0848657 0.0211508 0.0211508
	+137.5 12.5 12.5 0.0498192 0.0161439 0.0161439
	+175 25 25 0.0131277 0.00616809 0.00616809
	+225 25 25 0.00687291 0.00431605 0.00431605
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2012_I1298807/d01-x01-y03
	+Path=/REF/CMS_2012_I1298807/d01-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+12.5 12.5 12.5 0.651851 0.0611792 0.0611792
	+37.5 12.5 12.5 0.211876 0.0350765 0.0350765
	+62.5 12.5 12.5 0.0995765 0.0233401 0.0233401
	+87.5 12.5 12.5 0.0196394 0.0111332 0.0111332
	+125 25 25 0.0170567 0.00681341 0.00681341
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2012_I1298807/d01-x01-y04
	+Path=/REF/CMS_2012_I1298807/d01-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+150 50 50 0.0668442 0.0166218 0.0166218
	+225 25 25 0.546111 0.0588423 0.0588423
	+275 25 25 0.171797 0.0334175 0.0334175
	+325 25 25 0.119972 0.027286 0.027286
	+375 25 25 0.0446584 0.0170675 0.0170675
	+450 50 50 0.0298161 0.00967825 0.00967825
	+550 50 50 0.0158882 0.00693701 0.00693701
	+700 100 100 0.00491362 0.00277285 0.00277285
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2012_I1298807/d01-x01-y05
	+Path=/REF/CMS_2012_I1298807/d01-x01-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.75 0.75 0.75 0.000791167 0.000981382 0.000981382
	+1.75 0.25 0.25 0.0430752 0.0158713 0.0158713
	+2.125 0.125 0.125 0.0491121 0.0252134 0.0252134
	+2.375 0.125 0.125 0.0799915 0.0318515 0.0318515
	+2.625 0.125 0.125 0.132789 0.0404465 0.0404465
	+2.875 0.125 0.125 0.250435 0.0556969 0.0556969
	+3.125 0.125 0.125 0.443806 0.068276 0.068276
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2012_I1298807/d01-x01-y06
	+Path=/REF/CMS_2012_I1298807/d01-x01-y06
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.5 0.5 0.5 0.00274354 0.0041508 0.0041508
	+1.5 0.5 0.5 0.0431439 0.0147001 0.0147001
	+2.5 0.5 0.5 0.125061 0.0257779 0.0257779
	+3.5 0.5 0.5 0.618881 0.0584761 0.0584761
	+4.5 0.5 0.5 0.153371 0.0276537 0.0276537
	+5.5 0.5 0.5 0.0567988 0.0167839 0.0167839
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/CMS_2012_PAS_FSQ_12_020.yoda b/data/refdata/CMS_2012_PAS_FSQ_12_020.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/CMS_2012_PAS_FSQ_12_020.yoda
	@@ -0,0 +1,144 @@
	+# BEGIN YODA_SCATTER2D /REF/CMS_PAS_FSQ_12_020/d06-x01-y01
	+Path=/REF/CMS_PAS_FSQ_12_020/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.583000e-02 5.728610e-04 5.728610e-04
	+1.250000e+00 2.500000e-01 2.500000e-01 1.014700e-01 3.665380e-03 3.665380e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 2.156300e-01 7.788580e-03 7.788580e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 3.110400e-01 1.123670e-02 1.123670e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 3.786700e-01 1.368640e-02 1.368640e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 4.231700e-01 1.530780e-02 1.530780e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 4.507900e-01 1.633280e-02 1.633280e-02
	+4.500000e+00 5.000000e-01 5.000000e-01 4.699400e-01 1.703190e-02 1.703190e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 4.866600e-01 1.774820e-02 1.774820e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 4.885600e-01 1.791430e-02 1.791430e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 5.053500e-01 1.929380e-02 1.929380e-02
	+1.100000e+01 1.000000e+00 1.000000e+00 4.953800e-01 2.059250e-02 2.059250e-02
	+1.300000e+01 1.000000e+00 1.000000e+00 5.102600e-01 2.445150e-02 2.445150e-02
	+1.500000e+01 1.000000e+00 1.000000e+00 5.397900e-01 3.058980e-02 3.058980e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 5.456700e-01 3.261160e-02 3.261160e-02
	+2.200000e+01 2.000000e+00 2.000000e+00 4.475800e-01 4.283000e-02 4.283000e-02
	+2.600000e+01 2.000000e+00 2.000000e+00 4.961400e-01 6.434000e-02 6.434000e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_PAS_FSQ_12_020/d05-x01-y01
	+Path=/REF/CMS_PAS_FSQ_12_020/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.455400e-01 5.255140e-03 5.255140e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 4.868700e-01 1.757820e-02 1.757820e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 7.828700e-01 2.826580e-02 2.826580e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 9.955700e-01 3.594860e-02 3.594860e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 1.137540e+00 4.108220e-02 4.108220e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 1.227410e+00 4.434210e-02 4.434210e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 1.286970e+00 4.652050e-02 4.652050e-02
	+4.500000e+00 5.000000e-01 5.000000e-01 1.327840e+00 4.800380e-02 4.800380e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 1.372350e+00 4.972890e-02 4.972890e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 1.388000e+00 5.040120e-02 5.040120e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 1.434680e+00 5.291820e-02 5.291820e-02
	+1.100000e+01 1.000000e+00 1.000000e+00 1.438390e+00 5.509620e-02 5.509620e-02
	+1.300000e+01 1.000000e+00 1.000000e+00 1.446540e+00 5.914950e-02 5.914950e-02
	+1.500000e+01 1.000000e+00 1.000000e+00 1.507990e+00 6.928580e-02 6.928580e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 1.494830e+00 7.055320e-02 7.055320e-02
	+2.200000e+01 2.000000e+00 2.000000e+00 1.435580e+00 9.572250e-02 9.572250e-02
	+2.600000e+01 2.000000e+00 2.000000e+00 1.613830e+00 1.390890e-01 1.390890e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_PAS_FSQ_12_020/d07-x01-y01
	+Path=/REF/CMS_PAS_FSQ_12_020/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 1.297000e-01 4.674380e-03 4.674380e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 3.854100e-01 1.388000e-02 1.388000e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 5.672400e-01 2.042770e-02 2.042770e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 6.845300e-01 2.465510e-02 2.465510e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 7.588700e-01 2.734140e-02 2.734140e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 8.042400e-01 2.899350e-02 2.899350e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 8.361900e-01 3.017810e-02 3.017810e-02
	+4.500000e+00 5.000000e-01 5.000000e-01 8.579100e-01 3.096810e-02 3.096810e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 8.856900e-01 3.210930e-02 3.210930e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 8.994400e-01 3.273220e-02 3.273220e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 9.293300e-01 3.479500e-02 3.479500e-02
	+1.100000e+01 1.000000e+00 1.000000e+00 9.430100e-01 3.760700e-02 3.760700e-02
	+1.300000e+01 1.000000e+00 1.000000e+00 9.362700e-01 4.162810e-02 4.162810e-02
	+1.500000e+01 1.000000e+00 1.000000e+00 9.682000e-01 4.987930e-02 4.987930e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 9.491600e-01 5.104410e-02 5.104410e-02
	+2.200000e+01 2.000000e+00 2.000000e+00 9.880100e-01 8.526320e-02 8.526320e-02
	+2.600000e+01 2.000000e+00 2.000000e+00 1.117690e+00 1.262910e-01 1.262910e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_PAS_FSQ_12_020/d09-x01-y01
	+Path=/REF/CMS_PAS_FSQ_12_020/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 9.630000e-03 3.607170e-04 3.607170e-04
	+1.250000e+00 2.500000e-01 2.500000e-01 7.227000e-02 2.704400e-03 2.704400e-03
	+1.750000e+00 2.500000e-01 2.500000e-01 1.725000e-01 6.455250e-03 6.455250e-03
	+2.250000e+00 2.500000e-01 2.500000e-01 2.676600e-01 1.001850e-02 1.001850e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 3.406900e-01 1.275890e-02 1.275890e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 3.929300e-01 1.473030e-02 1.473030e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 4.247600e-01 1.595290e-02 1.595290e-02
	+4.500000e+00 5.000000e-01 5.000000e-01 4.500100e-01 1.690910e-02 1.690910e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 4.720000e-01 1.786880e-02 1.786880e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 4.806900e-01 1.831920e-02 1.831920e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 5.047900e-01 2.029220e-02 2.029220e-02
	+1.100000e+01 1.000000e+00 1.000000e+00 4.984100e-01 2.245480e-02 2.245480e-02
	+1.300000e+01 1.000000e+00 1.000000e+00 5.214100e-01 2.710800e-02 2.710800e-02
	+1.500000e+01 1.000000e+00 1.000000e+00 5.667800e-01 3.739780e-02 3.739780e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 5.575700e-01 3.680710e-02 3.680710e-02
	+2.200000e+01 2.000000e+00 2.000000e+00 4.738600e-01 5.507910e-02 5.507910e-02
	+2.600000e+01 2.000000e+00 2.000000e+00 4.802100e-01 7.082500e-02 7.082500e-02
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_PAS_FSQ_12_020/d08-x01-y01
	+Path=/REF/CMS_PAS_FSQ_12_020/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 9.229000e-02 3.452360e-03 3.452360e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 3.753400e-01 1.403940e-02 1.403940e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 6.860300e-01 2.566140e-02 2.566140e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 9.459500e-01 3.538750e-02 3.538750e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 1.140940e+00 4.269100e-02 4.269100e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 1.278260e+00 4.784750e-02 4.784750e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 1.368930e+00 5.127840e-02 5.127840e-02
	+4.500000e+00 5.000000e-01 5.000000e-01 1.449490e+00 5.430700e-02 5.430700e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 1.529270e+00 5.747310e-02 5.747310e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 1.588540e+00 5.988420e-02 5.988420e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 1.690910e+00 6.529940e-02 6.529940e-02
	+1.100000e+01 1.000000e+00 1.000000e+00 1.739370e+00 7.107380e-02 7.107380e-02
	+1.300000e+01 1.000000e+00 1.000000e+00 1.736740e+00 7.795280e-02 7.795280e-02
	+1.500000e+01 1.000000e+00 1.000000e+00 1.893030e+00 1.015640e-01 1.015640e-01
	+1.800000e+01 2.000000e+00 2.000000e+00 1.898560e+00 1.088040e-01 1.088040e-01
	+2.200000e+01 2.000000e+00 2.000000e+00 2.095860e+00 2.110190e-01 2.110190e-01
	+2.600000e+01 2.000000e+00 2.000000e+00 2.179860e+00 2.439840e-01 2.439840e-01
	+# END YODA_SCATTER2D
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_PAS_FSQ_12_020/d10-x01-y01
	+Path=/REF/CMS_PAS_FSQ_12_020/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7.500000e-01 2.500000e-01 2.500000e-01 8.266000e-02 3.062100e-03 3.062100e-03
	+1.250000e+00 2.500000e-01 2.500000e-01 3.030800e-01 1.121830e-02 1.121830e-02
	+1.750000e+00 2.500000e-01 2.500000e-01 5.135200e-01 1.900730e-02 1.900730e-02
	+2.250000e+00 2.500000e-01 2.500000e-01 6.782900e-01 2.511040e-02 2.511040e-02
	+2.750000e+00 2.500000e-01 2.500000e-01 8.002500e-01 2.963700e-02 2.963700e-02
	+3.250000e+00 2.500000e-01 2.500000e-01 8.853300e-01 3.281110e-02 3.281110e-02
	+3.750000e+00 2.500000e-01 2.500000e-01 9.441800e-01 3.503810e-02 3.503810e-02
	+4.500000e+00 5.000000e-01 5.000000e-01 9.994800e-01 3.710230e-02 3.710230e-02
	+5.500000e+00 5.000000e-01 5.000000e-01 1.057270e+00 3.946180e-02 3.946180e-02
	+7.000000e+00 1.000000e+00 1.000000e+00 1.107850e+00 4.155550e-02 4.155550e-02
	+9.000000e+00 1.000000e+00 1.000000e+00 1.186120e+00 4.630520e-02 4.630520e-02
	+1.100000e+01 1.000000e+00 1.000000e+00 1.240960e+00 5.293920e-02 5.293920e-02
	+1.300000e+01 1.000000e+00 1.000000e+00 1.215330e+00 5.865430e-02 5.865430e-02
	+1.500000e+01 1.000000e+00 1.000000e+00 1.326250e+00 7.942280e-02 7.942280e-02
	+1.800000e+01 2.000000e+00 2.000000e+00 1.340990e+00 8.256200e-02 8.256200e-02
	+2.200000e+01 2.000000e+00 2.000000e+00 1.622000e+00 1.761490e-01 1.761490e-01
	+2.600000e+01 2.000000e+00 2.000000e+00 1.699650e+00 2.223200e-01 2.223200e-01
	+# END YODA_SCATTER2D
	+
	diff --git a/data/refdata/CMS_2014_I1305624.yoda b/data/refdata/CMS_2014_I1305624.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/CMS_2014_I1305624.yoda
	@@ -0,0 +1,625 @@
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x01-y01
	+Path=/REF/CMS_2014_I1305624/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-9.54 1.33 1.3299999999999983 0.0375722 0.0023133418416111788 0.0023133418416111788
	+-7.72 0.4900000000000011 0.4899999999999993 0.0801239 0.0037627120843753115 0.0037627120843753115
	+-6.89 0.34000000000000075 0.33999999999999986 0.106547 0.0032003822851809434 0.0032003822851809434
	+-6.275 0.27499999999999947 0.27500000000000036 0.123341 0.005894367158245235 0.005894367158245235
	+-5.765 0.23500000000000032 0.23499999999999943 0.133318 0.007286710807222968 0.007286710807222968
	+-5.315 0.21499999999999986 0.21500000000000075 0.13221 0.007495771224023583 0.007495771224023583
	+-4.9 0.1999999999999993 0.20000000000000018 0.137307 0.007088120100569684 0.007088120100569684
	+-4.51 0.1900000000000004 0.1899999999999995 0.138825 0.006880595574977504 0.006880595574977504
	+-4.135 0.1850000000000005 0.1849999999999996 0.146707 0.0053873000247805026 0.0053873000247805026
	+-3.77 0.18000000000000016 0.18000000000000016 0.148807 0.006596550883863475 0.006596550883863475
	+-3.415 0.17499999999999982 0.17499999999999982 0.162241 0.008421991508574443 0.008421991508574443
	+-3.07 0.17000000000000037 0.16999999999999993 0.154429 0.005262192990170543 0.005262192990170543
	+-2.735 0.16500000000000004 0.16500000000000004 0.157441 0.007425841491743546 0.007425841491743546
	+-2.41 0.1599999999999997 0.16000000000000014 0.173378 0.012463212833491211 0.012463212833491211
	+-2.1 0.1499999999999999 0.15000000000000013 0.177128 0.01260571771978494 0.01260571771978494
	+-1.76 0.18999999999999995 0.18999999999999995 0.136199 0.00857440819856391 0.00857440819856391
	+-1.275 0.29500000000000015 0.29499999999999993 0.0416745 0.004499705682697481 0.004499705682697481
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x01-y02
	+Path=/REF/CMS_2014_I1305624/d01-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-9.54 1.33 1.3299999999999983 0.0417121 0.001673602735759296 0.001673602735759296
	+-7.72 0.4900000000000011 0.4899999999999993 0.0798878 0.0026745733203679426 0.0026745733203679426
	+-6.89 0.34000000000000075 0.33999999999999986 0.0952894 0.0043644515308754435 0.0043644515308754435
	+-6.275 0.27499999999999947 0.27500000000000036 0.104938 0.0038599993860622566 0.0038599993860622566
	+-5.765 0.23500000000000032 0.23499999999999943 0.101397 0.005540582356440522 0.005540582356440522
	+-5.315 0.21499999999999986 0.21500000000000075 0.10122 0.004589114864470054 0.004589114864470054
	+-4.9 0.1999999999999993 0.20000000000000018 0.104726 0.002682795411674174 0.002682795411674174
	+-4.51 0.1900000000000004 0.1899999999999995 0.117333 0.0037335887262659236 0.0037335887262659236
	+-4.135 0.1850000000000005 0.1849999999999996 0.146363 0.00478303689837325 0.00478303689837325
	+-3.77 0.18000000000000016 0.18000000000000016 0.164386 0.006452439051552521 0.006452439051552521
	+-3.415 0.17499999999999982 0.17499999999999982 0.179742 0.005858692220521573 0.005858692220521573
	+-3.07 0.17000000000000037 0.16999999999999993 0.196247 0.00826454991169513 0.00826454991169513
	+-2.735 0.16500000000000004 0.16500000000000004 0.220856 0.008279947446602546 0.008279947446602546
	+-2.41 0.1599999999999997 0.16000000000000014 0.224477 0.011032198478997737 0.011032198478997737
	+-2.1 0.1499999999999999 0.15000000000000013 0.187586 0.011369257947293659 0.011369257947293659
	+-1.76 0.18999999999999995 0.18999999999999995 0.123287 0.009602458120127366 0.009602458120127366
	+-1.275 0.29500000000000015 0.29499999999999993 0.0335227 0.0026780407969560507 0.0026780407969560507
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x01-y03
	+Path=/REF/CMS_2014_I1305624/d01-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-9.54 1.33 1.3299999999999983 0.0454352 0.00219160006419602 0.00219160006419602
	+-7.72 0.4900000000000011 0.4899999999999993 0.0749684 0.0027322150903389725 0.0027322150903389725
	+-6.89 0.34000000000000075 0.33999999999999986 0.0816251 0.00400605564520764 0.00400605564520764
	+-6.275 0.27499999999999947 0.27500000000000036 0.0811369 0.004818954708038352 0.004818954708038352
	+-5.765 0.23500000000000032 0.23499999999999943 0.0805647 0.003017466703181495 0.003017466703181495
	+-5.315 0.21499999999999986 0.21500000000000075 0.0834326 0.00339607681537815 0.00339607681537815
	+-4.9 0.1999999999999993 0.20000000000000018 0.0992403 0.00530204528268705 0.00530204528268705
	+-4.51 0.1900000000000004 0.1899999999999995 0.127633 0.00558133256851229 0.00558133256851229
	+-4.135 0.1850000000000005 0.1849999999999996 0.157408 0.011568720781555755 0.011568720781555755
	+-3.77 0.18000000000000016 0.18000000000000016 0.179957 0.005580671135669974 0.005580671135669974
	+-3.415 0.17499999999999982 0.17499999999999982 0.205881 0.007807510298219273 0.007807510298219273
	+-3.07 0.17000000000000037 0.16999999999999993 0.235458 0.01134740855975936 0.01134740855975936
	+-2.735 0.16500000000000004 0.16500000000000004 0.250612 0.010652398476685898 0.010652398476685898
	+-2.41 0.1599999999999997 0.16000000000000014 0.226521 0.011394381584377453 0.011394381584377453
	+-2.1 0.1499999999999999 0.15000000000000013 0.181943 0.009403246325498445 0.009403246325498445
	+-1.76 0.18999999999999995 0.18999999999999995 0.111973 0.006219276750934067 0.006219276750934067
	+-1.275 0.29500000000000015 0.29499999999999993 0.0273638 0.0018110165253801523 0.0018110165253801523
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x01-y04
	+Path=/REF/CMS_2014_I1305624/d01-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-9.54 1.33 1.3299999999999983 0.0471814 0.0021610423206917997 0.0021610423206917997
	+-7.72 0.4900000000000011 0.4899999999999993 0.0714125 0.0024512960048270385 0.0024512960048270385
	+-6.89 0.34000000000000075 0.33999999999999986 0.0706191 0.003383588009181378 0.003383588009181378
	+-6.275 0.27499999999999947 0.27500000000000036 0.0669465 0.0026678664497466883 0.0026678664497466883
	+-5.765 0.23500000000000032 0.23499999999999943 0.0700821 0.0027603730385781194 0.0027603730385781194
	+-5.315 0.21499999999999986 0.21500000000000075 0.0785864 0.0028718692858173403 0.0028718692858173403
	+-4.9 0.1999999999999993 0.20000000000000018 0.100742 0.005823664777013182 0.005823664777013182
	+-4.51 0.1900000000000004 0.1899999999999995 0.132387 0.009288754297557881 0.009288754297557881
	+-4.135 0.1850000000000005 0.1849999999999996 0.162741 0.008297239330777436 0.008297239330777436
	+-3.77 0.18000000000000016 0.18000000000000016 0.200872 0.008003346349727719 0.008003346349727719
	+-3.415 0.17499999999999982 0.17499999999999982 0.232816 0.005801117734618045 0.005801117734618045
	+-3.07 0.17000000000000037 0.16999999999999993 0.260152 0.006300257485508033 0.006300257485508033
	+-2.735 0.16500000000000004 0.16500000000000004 0.258706 0.010917240253658431 0.010917240253658431
	+-2.41 0.1599999999999997 0.16000000000000014 0.224017 0.00833534537175875 0.00833534537175875
	+-2.1 0.1499999999999999 0.15000000000000013 0.169597 0.010261485671582842 0.010261485671582842
	+-1.76 0.18999999999999995 0.18999999999999995 0.102035 0.006484412414035985 0.006484412414035985
	+-1.275 0.29500000000000015 0.29499999999999993 0.0223067 0.002200124961365831 0.002200124961365831
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x01-y05
	+Path=/REF/CMS_2014_I1305624/d01-x01-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-9.54 1.33 1.3299999999999983 0.0492667 0.0026173861711041436 0.0026173861711041436
	+-7.72 0.4900000000000011 0.4899999999999993 0.0619831 0.0042904664405744985 0.0042904664405744985
	+-6.89 0.34000000000000075 0.33999999999999986 0.0568575 0.0034192294043496117 0.0034192294043496117
	+-6.275 0.27499999999999947 0.27500000000000036 0.0569476 0.0026069843520389606 0.0026069843520389606
	+-5.765 0.23500000000000032 0.23499999999999943 0.0641019 0.00332604173598348 0.00332604173598348
	+-5.315 0.21499999999999986 0.21500000000000075 0.0851017 0.0054109678523836195 0.0054109678523836195
	+-4.9 0.1999999999999993 0.20000000000000018 0.114816 0.004376583604468216 0.004376583604468216
	+-4.51 0.1900000000000004 0.1899999999999995 0.150268 0.003937017930968692 0.003937017930968692
	+-4.135 0.1850000000000005 0.1849999999999996 0.187555 0.0030997084428315185 0.0030997084428315185
	+-3.77 0.18000000000000016 0.18000000000000016 0.220135 0.01009813720832194 0.01009813720832194
	+-3.415 0.17499999999999982 0.17499999999999982 0.260058 0.005055572854927619 0.005055572854927619
	+-3.07 0.17000000000000037 0.16999999999999993 0.270411 0.01178115974009728 0.01178115974009728
	+-2.735 0.16500000000000004 0.16500000000000004 0.251183 0.011966480465873038 0.011966480465873038
	+-2.41 0.1599999999999997 0.16000000000000014 0.207513 0.008866751155399819 0.008866751155399819
	+-2.1 0.1499999999999999 0.15000000000000013 0.151204 0.00886555284168878 0.00886555284168878
	+-1.76 0.18999999999999995 0.18999999999999995 0.0845248 0.0061918572811091995 0.0061918572811091995
	+-1.275 0.29500000000000015 0.29499999999999993 0.0171081 0.0016914276379085805 0.0016914276379085805
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x02-y01
	+Path=/REF/CMS_2014_I1305624/d01-x02-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-3.09 0.18000000000000016 0.17999999999999972 0.0166851 0.009188027928995427 0.009188027928995427
	+-2.82 0.0900000000000003 0.08999999999999986 0.140398 0.019633938939234784 0.019633938939234784
	+-2.645 0.08499999999999996 0.08499999999999996 0.292669 0.030338772613157903 0.030338772613157903
	+-2.475 0.08499999999999996 0.08499999999999996 0.385617 0.03691102277749697 0.03691102277749697
	+-2.31 0.08000000000000007 0.08000000000000007 0.415145 0.019112913365303578 0.019112913365303578
	+-2.15 0.08000000000000007 0.08000000000000007 0.443225 0.024973118034200294 0.024973118034200294
	+-1.995 0.07499999999999973 0.07500000000000018 0.485379 0.02403117742350549 0.02403117742350549
	+-1.85 0.06999999999999984 0.07000000000000006 0.529049 0.019737146766946836 0.019737146766946836
	+-1.71 0.07000000000000006 0.07000000000000006 0.588558 0.021457503476639588 0.021457503476639588
	+-1.575 0.06499999999999995 0.06499999999999995 0.616621 0.03549307043198714 0.03549307043198714
	+-1.45 0.06000000000000005 0.06000000000000005 0.625155 0.022850711719550443 0.022850711719550443
	+-1.33 0.05999999999999983 0.06000000000000005 0.596075 0.018368908671992465 0.018368908671992465
	+-1.215 0.05499999999999994 0.05500000000000016 0.564071 0.0490434459561112 0.0490434459561112
	+-1.11 0.04999999999999982 0.050000000000000044 0.495599 0.02717528487008002 0.02717528487008002
	+-1.01 0.050000000000000044 0.050000000000000044 0.446706 0.017694724244813765 0.017694724244813765
	+-0.915 0.04499999999999993 0.04500000000000004 0.363506 0.022188670073936382 0.022188670073936382
	+-0.825 0.04500000000000004 0.04499999999999993 0.299086 0.025499100426022877 0.025499100426022877
	+-0.74 0.040000000000000036 0.040000000000000036 0.230307 0.018479239622454707 0.018479239622454707
	+-0.66 0.039999999999999925 0.040000000000000036 0.170633 0.017448455511121893 0.017448455511121893
	+-0.55 0.06999999999999995 0.07000000000000006 0.0864782 0.009620773242920757 0.009620773242920757
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x02-y02
	+Path=/REF/CMS_2014_I1305624/d01-x02-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-3.36 0.27 0.27 0.0192168 0.004318650545668635 0.004318650545668635
	+-3.0 0.08999999999999986 0.08999999999999986 0.123908 0.005475925721967018 0.005475925721967018
	+-2.82 0.0900000000000003 0.08999999999999986 0.231627 0.018364296473660516 0.018364296473660516
	+-2.645 0.08499999999999996 0.08499999999999996 0.322414 0.015247174970806887 0.015247174970806887
	+-2.475 0.08499999999999996 0.08499999999999996 0.374541 0.03605296203773554 0.03605296203773554
	+-2.31 0.08000000000000007 0.08000000000000007 0.413935 0.015313375376202988 0.015313375376202988
	+-2.15 0.08000000000000007 0.08000000000000007 0.472776 0.02077453058824916 0.02077453058824916
	+-1.995 0.07499999999999973 0.07500000000000018 0.505027 0.01594318664279196 0.01594318664279196
	+-1.85 0.06999999999999984 0.07000000000000006 0.554142 0.012112411688280745 0.012112411688280745
	+-1.71 0.07000000000000006 0.07000000000000006 0.578467 0.022756016491840128 0.022756016491840128
	+-1.575 0.06499999999999995 0.06499999999999995 0.594796 0.021430808280566555 0.021430808280566555
	+-1.45 0.06000000000000005 0.06000000000000005 0.585567 0.01956290985786368 0.01956290985786368
	+-1.33 0.05999999999999983 0.06000000000000005 0.533731 0.023770646071701543 0.023770646071701543
	+-1.215 0.05499999999999994 0.05500000000000016 0.516146 0.026341381097839192 0.026341381097839192
	+-1.11 0.04999999999999982 0.050000000000000044 0.459887 0.0191619602586583 0.0191619602586583
	+-1.01 0.050000000000000044 0.050000000000000044 0.381689 0.02041593859245516 0.02041593859245516
	+-0.915 0.04499999999999993 0.04500000000000004 0.298784 0.017569330957654592 0.017569330957654592
	+-0.825 0.04500000000000004 0.04499999999999993 0.219506 0.01382759291597782 0.01382759291597782
	+-0.74 0.040000000000000036 0.040000000000000036 0.167875 0.010920977023114736 0.010920977023114736
	+-0.66 0.039999999999999925 0.040000000000000036 0.115796 0.009051887741974048 0.009051887741974048
	+-0.55 0.06999999999999995 0.07000000000000006 0.0645598 0.00882690643014301 0.00882690643014301
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x02-y03
	+Path=/REF/CMS_2014_I1305624/d01-x02-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-3.54 0.08999999999999986 0.08999999999999986 0.0231348 0.007408527780428511 0.007408527780428511
	+-3.36 0.0900000000000003 0.08999999999999986 0.0699219 0.004957663620880303 0.004957663620880303
	+-3.18 0.08999999999999986 0.0900000000000003 0.11812 0.016132357958141146 0.016132357958141146
	+-3.0 0.08999999999999986 0.08999999999999986 0.168196 0.01568282256656626 0.01568282256656626
	+-2.82 0.0900000000000003 0.08999999999999986 0.241273 0.02354645124562298 0.02354645124562298
	+-2.645 0.08499999999999996 0.08499999999999996 0.321724 0.019496435652931538 0.019496435652931538
	+-2.475 0.08499999999999996 0.08499999999999996 0.375723 0.020624445629601782 0.020624445629601782
	+-2.31 0.08000000000000007 0.08000000000000007 0.436561 0.030831898689934748 0.030831898689934748
	+-2.15 0.08000000000000007 0.08000000000000007 0.470044 0.01878540693095574 0.01878540693095574
	+-1.995 0.07499999999999973 0.07500000000000018 0.517478 0.019947026789286167 0.019947026789286167
	+-1.85 0.06999999999999984 0.07000000000000006 0.545591 0.022599507296109354 0.022599507296109354
	+-1.71 0.07000000000000006 0.07000000000000006 0.576369 0.015970213085979786 0.015970213085979786
	+-1.575 0.06499999999999995 0.06499999999999995 0.569524 0.015435736996415168 0.015435736996415168
	+-1.45 0.06000000000000005 0.06000000000000005 0.566693 0.029995657029336764 0.029995657029336764
	+-1.33 0.05999999999999983 0.06000000000000005 0.511048 0.03566895253601373 0.03566895253601373
	+-1.215 0.05499999999999994 0.05500000000000016 0.472896 0.02584115310983819 0.02584115310983819
	+-1.11 0.04999999999999982 0.050000000000000044 0.400268 0.038301310186573255 0.038301310186573255
	+-1.01 0.050000000000000044 0.050000000000000044 0.318779 0.02119066438026189 0.02119066438026189
	+-0.915 0.04499999999999993 0.04500000000000004 0.256793 0.018312549962700445 0.018312549962700445
	+-0.825 0.04500000000000004 0.04499999999999993 0.188766 0.018343162325248064 0.018343162325248064
	+-0.74 0.040000000000000036 0.040000000000000036 0.12253 0.016110220389743277 0.016110220389743277
	+-0.66 0.039999999999999925 0.040000000000000036 0.0812416 0.015252036458440558 0.015252036458440558
	+-0.55 0.06999999999999995 0.07000000000000006 0.0448028 0.006714354224569925 0.006714354224569925
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x02-y04
	+Path=/REF/CMS_2014_I1305624/d01-x02-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-3.54 0.08999999999999986 0.08999999999999986 0.0667368 0.00890670580216951 0.00890670580216951
	+-3.36 0.0900000000000003 0.08999999999999986 0.103119 0.010699397681178132 0.010699397681178132
	+-3.18 0.08999999999999986 0.0900000000000003 0.141074 0.013525829315809068 0.013525829315809068
	+-3.0 0.08999999999999986 0.08999999999999986 0.192138 0.01265469843213974 0.01265469843213974
	+-2.82 0.0900000000000003 0.08999999999999986 0.265313 0.010051560545532221 0.010051560545532221
	+-2.645 0.08499999999999996 0.08499999999999996 0.334574 0.00945395019352757 0.00945395019352757
	+-2.475 0.08499999999999996 0.08499999999999996 0.387293 0.017799007277755692 0.017799007277755692
	+-2.31 0.08000000000000007 0.08000000000000007 0.429268 0.014966166106067378 0.014966166106067378
	+-2.15 0.08000000000000007 0.08000000000000007 0.487315 0.017825652619817316 0.017825652619817316
	+-1.995 0.07499999999999973 0.07500000000000018 0.533337 0.017061741750665434 0.017061741750665434
	+-1.85 0.06999999999999984 0.07000000000000006 0.553693 0.023055189634919513 0.023055189634919513
	+-1.71 0.07000000000000006 0.07000000000000006 0.556487 0.010012379176025047 0.010012379176025047
	+-1.575 0.06499999999999995 0.06499999999999995 0.556114 0.02999681260322336 0.02999681260322336
	+-1.45 0.06000000000000005 0.06000000000000005 0.532561 0.029879250727555064 0.029879250727555064
	+-1.33 0.05999999999999983 0.06000000000000005 0.488056 0.029455845389227926 0.029455845389227926
	+-1.215 0.05499999999999994 0.05500000000000016 0.423813 0.024449058145900017 0.024449058145900017
	+-1.11 0.04999999999999982 0.050000000000000044 0.353161 0.01707984548415178 0.01707984548415178
	+-1.01 0.050000000000000044 0.050000000000000044 0.288058 0.026869807712717263 0.026869807712717263
	+-0.915 0.04499999999999993 0.04500000000000004 0.219553 0.029159081200444227 0.029159081200444227
	+-0.825 0.04500000000000004 0.04499999999999993 0.157348 0.021123691787573496 0.021123691787573496
	+-0.74 0.040000000000000036 0.040000000000000036 0.103233 0.015494571355168235 0.015494571355168235
	+-0.66 0.039999999999999925 0.040000000000000036 0.0678872 0.011584655845142747 0.011584655845142747
	+-0.55 0.06999999999999995 0.07000000000000006 0.026956 0.0048115095075454235 0.0048115095075454235
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x02-y05
	+Path=/REF/CMS_2014_I1305624/d01-x02-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-3.54 0.08999999999999986 0.08999999999999986 0.1042 0.009826709107954502 0.009826709107954502
	+-3.36 0.0900000000000003 0.08999999999999986 0.137696 0.010008139953589828 0.010008139953589828
	+-3.18 0.08999999999999986 0.0900000000000003 0.173784 0.009161481103118043 0.009161481103118043
	+-3.0 0.08999999999999986 0.08999999999999986 0.22229 0.012989001203325834 0.012989001203325834
	+-2.82 0.0900000000000003 0.08999999999999986 0.297613 0.00854571847868276 0.00854571847868276
	+-2.645 0.08499999999999996 0.08499999999999996 0.359165 0.010786707310852559 0.010786707310852559
	+-2.475 0.08499999999999996 0.08499999999999996 0.408541 0.010273952942567917 0.010273952942567917
	+-2.31 0.08000000000000007 0.08000000000000007 0.462437 0.012972429161895624 0.012972429161895624
	+-2.15 0.08000000000000007 0.08000000000000007 0.501117 0.011274486602985521 0.011274486602985521
	+-1.995 0.07499999999999973 0.07500000000000018 0.532558 0.007217014842668678 0.007217014842668678
	+-1.85 0.06999999999999984 0.07000000000000006 0.555114 0.014315585390321977 0.014315585390321977
	+-1.71 0.07000000000000006 0.07000000000000006 0.557104 0.025569843937977017 0.025569843937977017
	+-1.575 0.06499999999999995 0.06499999999999995 0.543409 0.024173220231713026 0.024173220231713026
	+-1.45 0.06000000000000005 0.06000000000000005 0.497363 0.01778190535439046 0.01778190535439046
	+-1.33 0.05999999999999983 0.06000000000000005 0.438024 0.015775149424411165 0.015775149424411165
	+-1.215 0.05499999999999994 0.05500000000000016 0.369303 0.015082751065783722 0.015082751065783722
	+-1.11 0.04999999999999982 0.050000000000000044 0.316935 0.037350561258258225 0.037350561258258225
	+-1.01 0.050000000000000044 0.050000000000000044 0.222163 0.01814367351325525 0.01814367351325525
	+-0.915 0.04499999999999993 0.04500000000000004 0.152322 0.018443084267236867 0.018443084267236867
	+-0.825 0.04500000000000004 0.04499999999999993 0.109842 0.014079667702488578 0.014079667702488578
	+-0.74 0.040000000000000036 0.040000000000000036 0.0697961 0.013564278604570167 0.013564278604570167
	+-0.66 0.039999999999999925 0.040000000000000036 0.0330457 0.006448537906840279 0.006448537906840279
	+-0.55 0.06999999999999995 0.07000000000000006 0.0148376 0.0023608543230695107 0.0023608543230695107
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x03-y01
	+Path=/REF/CMS_2014_I1305624/d01-x03-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.87 0.2400000000000002 0.2400000000000002 0.210322 0.02272163784047268 0.02272163784047268
	+-5.425 0.20500000000000007 0.20500000000000007 0.250153 0.03987967293126788 0.03987967293126788
	+-5.035 0.1849999999999996 0.1850000000000005 0.27487 0.04136618993614109 0.04136618993614109
	+-4.68 0.16999999999999993 0.16999999999999993 0.285129 0.027527871003940715 0.027527871003940715
	+-4.355 0.15499999999999936 0.15500000000000025 0.260139 0.026793616498151197 0.026793616498151197
	+-4.055 0.14500000000000046 0.14499999999999957 0.224484 0.03472916621818036 0.03472916621818036
	+-3.77 0.14000000000000012 0.14000000000000012 0.190795 0.03456071382274388 0.03456071382274388
	+-3.5 0.1299999999999999 0.1299999999999999 0.167951 0.02192192902526828 0.02192192902526828
	+-3.245 0.125 0.125 0.161912 0.014108420926822391 0.014108420926822391
	+-3.0 0.1200000000000001 0.1200000000000001 0.165915 0.014641885716068134 0.014641885716068134
	+-2.76 0.1200000000000001 0.11999999999999966 0.166756 0.01145520381516191 0.01145520381516191
	+-2.525 0.11500000000000021 0.11499999999999977 0.158816 0.013893940102375569 0.013893940102375569
	+-2.3 0.11000000000000032 0.10999999999999988 0.153113 0.014880751629286069 0.014880751629286069
	+-2.085 0.10499999999999998 0.10499999999999998 0.15725 0.013905316313137217 0.013905316313137217
	+-1.88 0.10000000000000009 0.09999999999999987 0.145797 0.014181486072115291 0.014181486072115291
	+-1.685 0.09499999999999997 0.09499999999999997 0.133438 0.014029521033595551 0.014029521033595551
	+-1.5 0.09000000000000008 0.09000000000000008 0.118764 0.007965141392844197 0.007965141392844197
	+-1.325 0.08499999999999996 0.08499999999999996 0.103498 0.01228037188697883 0.01228037188697883
	+-1.16 0.08000000000000007 0.07999999999999985 0.0913002 0.010354149981244237 0.010354149981244237
	+-1.005 0.07500000000000018 0.07499999999999984 0.0708977 0.011085818021688792 0.011085818021688792
	+-0.795 0.135 0.135 0.0471184 0.005687179408335911 0.005687179408335911
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x03-y02
	+Path=/REF/CMS_2014_I1305624/d01-x03-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.87 0.2400000000000002 0.2400000000000002 0.170877 0.022072908109782456 0.022072908109782456
	+-5.425 0.20500000000000007 0.20500000000000007 0.204032 0.034172870521915484 0.034172870521915484
	+-5.035 0.1849999999999996 0.1850000000000005 0.221787 0.026377553616853858 0.026377553616853858
	+-4.68 0.16999999999999993 0.16999999999999993 0.220732 0.011480853762351476 0.011480853762351476
	+-4.355 0.15499999999999936 0.15500000000000025 0.202225 0.018653877901307812 0.018653877901307812
	+-4.055 0.14500000000000046 0.14499999999999957 0.19017 0.017633896303755447 0.017633896303755447
	+-3.77 0.14000000000000012 0.14000000000000012 0.190842 0.010104379734946623 0.010104379734946623
	+-3.5 0.1299999999999999 0.1299999999999999 0.202099 0.013500772251704716 0.013500772251704716
	+-3.245 0.125 0.125 0.202378 0.008462114583412351 0.008462114583412351
	+-3.0 0.1200000000000001 0.1200000000000001 0.21329 0.01224894126086414 0.01224894126086414
	+-2.76 0.1200000000000001 0.11999999999999966 0.212319 0.011665039815144225 0.011665039815144225
	+-2.525 0.11500000000000021 0.11499999999999977 0.21542 0.014698085062718204 0.014698085062718204
	+-2.3 0.11000000000000032 0.10999999999999988 0.208804 0.016504635635254117 0.016504635635254117
	+-2.085 0.10499999999999998 0.10499999999999998 0.201032 0.016709031219699723 0.016709031219699723
	+-1.88 0.10000000000000009 0.09999999999999987 0.183725 0.015307847494001239 0.015307847494001239
	+-1.685 0.09499999999999997 0.09499999999999997 0.167114 0.011165451174856303 0.011165451174856303
	+-1.5 0.09000000000000008 0.09000000000000008 0.151304 0.015288182385179084 0.015288182385179084
	+-1.325 0.08499999999999996 0.08499999999999996 0.133094 0.014972219081872936 0.014972219081872936
	+-1.16 0.08000000000000007 0.07999999999999985 0.116413 0.01277761435984433 0.01277761435984433
	+-1.005 0.07500000000000018 0.07499999999999984 0.0888967 0.009897369434819536 0.009897369434819536
	+-0.795 0.135 0.135 0.0467993 0.00624924869372311 0.00624924869372311
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x03-y03
	+Path=/REF/CMS_2014_I1305624/d01-x03-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.87 0.2400000000000002 0.2400000000000002 0.145905 0.02925137199528501 0.02925137199528501
	+-5.425 0.20500000000000007 0.20500000000000007 0.177562 0.028485987933089138 0.028485987933089138
	+-5.035 0.1849999999999996 0.1850000000000005 0.181453 0.019914022313947524 0.019914022313947524
	+-4.68 0.16999999999999993 0.16999999999999993 0.176756 0.007576808666721102 0.007576808666721102
	+-4.355 0.15499999999999936 0.15500000000000025 0.174449 0.00956318178847396 0.00956318178847396
	+-4.055 0.14500000000000046 0.14499999999999957 0.18089 0.005848058995128212 0.005848058995128212
	+-3.77 0.14000000000000012 0.14000000000000012 0.201946 0.006270090998669796 0.006270090998669796
	+-3.5 0.1299999999999999 0.1299999999999999 0.223235 0.015283340419083781 0.015283340419083781
	+-3.245 0.125 0.125 0.225634 0.009132687479931633 0.009132687479931633
	+-3.0 0.1200000000000001 0.1200000000000001 0.23109 0.010457514641653629 0.010457514641653629
	+-2.76 0.1200000000000001 0.11999999999999966 0.241383 0.01580631673980058 0.01580631673980058
	+-2.525 0.11500000000000021 0.11499999999999977 0.243454 0.024566693613852476 0.024566693613852476
	+-2.3 0.11000000000000032 0.10999999999999988 0.240913 0.016466066131741973 0.016466066131741973
	+-2.085 0.10499999999999998 0.10499999999999998 0.230898 0.018262725303658814 0.018262725303658814
	+-1.88 0.10000000000000009 0.09999999999999987 0.216033 0.01602844364286502 0.01602844364286502
	+-1.685 0.09499999999999997 0.09499999999999997 0.195875 0.015387975764212783 0.015387975764212783
	+-1.5 0.09000000000000008 0.09000000000000008 0.173585 0.017090490254117935 0.017090490254117935
	+-1.325 0.08499999999999996 0.08499999999999996 0.15128 0.01334478989360267 0.01334478989360267
	+-1.16 0.08000000000000007 0.07999999999999985 0.122679 0.012637231781193222 0.012637231781193222
	+-1.005 0.07500000000000018 0.07499999999999984 0.0898352 0.010168575953696761 0.010168575953696761
	+-0.795 0.135 0.135 0.0408588 0.006324915205528766 0.006324915205528766
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x03-y04
	+Path=/REF/CMS_2014_I1305624/d01-x03-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.87 0.2400000000000002 0.2400000000000002 0.135689 0.03274490116469897 0.03274490116469897
	+-5.425 0.20500000000000007 0.20500000000000007 0.156732 0.02724777983359378 0.02724777983359378
	+-5.035 0.1849999999999996 0.1850000000000005 0.155341 0.01868901758923941 0.01868901758923941
	+-4.68 0.16999999999999993 0.16999999999999993 0.153807 0.007920462561050333 0.007920462561050333
	+-4.355 0.15499999999999936 0.15500000000000025 0.167313 0.008445826258697251 0.008445826258697251
	+-4.055 0.14500000000000046 0.14499999999999957 0.190984 0.010900202178326785 0.010900202178326785
	+-3.77 0.14000000000000012 0.14000000000000012 0.203326 0.010839485214234114 0.010839485214234114
	+-3.5 0.1299999999999999 0.1299999999999999 0.221105 0.009228633476707155 0.009228633476707155
	+-3.245 0.125 0.125 0.236901 0.006903506897693375 0.006903506897693375
	+-3.0 0.1200000000000001 0.1200000000000001 0.250551 0.01095193700146691 0.01095193700146691
	+-2.76 0.1200000000000001 0.11999999999999966 0.262517 0.015516995643245506 0.015516995643245506
	+-2.525 0.11500000000000021 0.11499999999999977 0.259824 0.01742149386458004 0.01742149386458004
	+-2.3 0.11000000000000032 0.10999999999999988 0.25601 0.022705402386940868 0.022705402386940868
	+-2.085 0.10499999999999998 0.10499999999999998 0.24555 0.01793491065435231 0.01793491065435231
	+-1.88 0.10000000000000009 0.09999999999999987 0.232673 0.021940851914593017 0.021940851914593017
	+-1.685 0.09499999999999997 0.09499999999999997 0.211389 0.020083352672509637 0.020083352672509637
	+-1.5 0.09000000000000008 0.09000000000000008 0.193497 0.020443863425350893 0.020443863425350893
	+-1.325 0.08499999999999996 0.08499999999999996 0.153584 0.02146147888805662 0.02146147888805662
	+-1.16 0.08000000000000007 0.07999999999999985 0.119665 0.015533369938374609 0.015533369938374609
	+-1.005 0.07500000000000018 0.07499999999999984 0.0796025 0.008311551259043044 0.008311551259043044
	+-0.795 0.135 0.135 0.0386474 0.0053187129887242455 0.0053187129887242455
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x03-y05
	+Path=/REF/CMS_2014_I1305624/d01-x03-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.87 0.2400000000000002 0.2400000000000002 0.124399 0.03863099688841396 0.03863099688841396
	+-5.425 0.20500000000000007 0.20500000000000007 0.144318 0.023961892824303842 0.023961892824303842
	+-5.035 0.1849999999999996 0.1850000000000005 0.14204 0.014435822866511488 0.014435822866511488
	+-4.68 0.16999999999999993 0.16999999999999993 0.14783 0.006379855240221051 0.006379855240221051
	+-4.355 0.15499999999999936 0.15500000000000025 0.163481 0.0031492305343807396 0.0031492305343807396
	+-4.055 0.14500000000000046 0.14499999999999957 0.185429 0.003172107121772529 0.003172107121772529
	+-3.77 0.14000000000000012 0.14000000000000012 0.209675 0.006202558487619122 0.006202558487619122
	+-3.5 0.1299999999999999 0.1299999999999999 0.230016 0.0061347213133368175 0.0061347213133368175
	+-3.245 0.125 0.125 0.245589 0.011001417770632292 0.011001417770632292
	+-3.0 0.1200000000000001 0.1200000000000001 0.265816 0.018933522728050375 0.018933522728050375
	+-2.76 0.1200000000000001 0.11999999999999966 0.272029 0.014736924091885659 0.014736924091885659
	+-2.525 0.11500000000000021 0.11499999999999977 0.27639 0.01836317082275281 0.01836317082275281
	+-2.3 0.11000000000000032 0.10999999999999988 0.277446 0.017379576758370728 0.017379576758370728
	+-2.085 0.10499999999999998 0.10499999999999998 0.264898 0.01590612081045847 0.01590612081045847
	+-1.88 0.10000000000000009 0.09999999999999987 0.245149 0.020234105486984098 0.020234105486984098
	+-1.685 0.09499999999999997 0.09499999999999997 0.225245 0.0226621374041285 0.0226621374041285
	+-1.5 0.09000000000000008 0.09000000000000008 0.187639 0.020195750351342953 0.020195750351342953
	+-1.325 0.08499999999999996 0.08499999999999996 0.142746 0.009377049177528931 0.009377049177528931
	+-1.16 0.08000000000000007 0.07999999999999985 0.104528 0.008898728971948745 0.008898728971948745
	+-1.005 0.07500000000000018 0.07499999999999984 0.0673358 0.007649166633240251 0.007649166633240251
	+-0.795 0.135 0.135 0.0293512 0.003733000374768934 0.003733000374768934
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x04-y01
	+Path=/REF/CMS_2014_I1305624/d01-x04-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.285 0.23499999999999943 0.23500000000000032 0.28022 0.060217821997665275 0.060217821997665275
	+-4.85 0.20000000000000018 0.1999999999999993 0.360494 0.05799819607392027 0.05799819607392027
	+-4.475 0.1750000000000007 0.17499999999999982 0.377483 0.01835372130205752 0.01835372130205752
	+-4.14 0.16000000000000014 0.1599999999999997 0.326026 0.04982701775395453 0.04982701775395453
	+-3.835 0.14500000000000002 0.14500000000000002 0.246707 0.05500418633697257 0.05500418633697257
	+-3.555 0.1349999999999998 0.13500000000000023 0.202647 0.03352238897592026 0.03352238897592026
	+-3.295 0.125 0.125 0.180173 0.01723278256788787 0.01723278256788787
	+-3.05 0.1200000000000001 0.11999999999999966 0.176037 0.013489334158323011 0.013489334158323011
	+-2.815 0.11500000000000021 0.11499999999999977 0.180476 0.01442184308788582 0.01442184308788582
	+-2.59 0.11000000000000032 0.10999999999999988 0.183203 0.015383414345274588 0.015383414345274588
	+-2.375 0.10499999999999998 0.10499999999999998 0.197808 0.015645578828796972 0.015645578828796972
	+-2.17 0.10000000000000009 0.10000000000000009 0.205476 0.01707425672105231 0.01707425672105231
	+-1.97 0.09999999999999987 0.09999999999999987 0.190298 0.01678499372951923 0.01678499372951923
	+-1.775 0.0950000000000002 0.09499999999999997 0.155588 0.014429499540178099 0.014429499540178099
	+-1.59 0.08999999999999986 0.09000000000000008 0.120631 0.01383545936551801 0.01383545936551801
	+-1.415 0.08499999999999996 0.08499999999999996 0.0780985 0.009499279232304944 0.009499279232304944
	+-1.025 0.30500000000000016 0.30499999999999994 0.0115387 0.0019049143368794828 0.0019049143368794828
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x04-y02
	+Path=/REF/CMS_2014_I1305624/d01-x04-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.285 0.23499999999999943 0.23500000000000032 0.26171 0.04757566481920773 0.04757566481920773
	+-4.85 0.20000000000000018 0.1999999999999993 0.299531 0.033019243008700246 0.033019243008700246
	+-4.475 0.1750000000000007 0.17499999999999982 0.289176 0.01797972323102055 0.01797972323102055
	+-4.14 0.16000000000000014 0.1599999999999997 0.250009 0.024411844029611936 0.024411844029611936
	+-3.835 0.14500000000000002 0.14500000000000002 0.233379 0.01890937419032158 0.01890937419032158
	+-3.555 0.1349999999999998 0.13500000000000023 0.232191 0.020419952414756012 0.020419952414756012
	+-3.295 0.125 0.125 0.23131 0.006987868761911604 0.006987868761911604
	+-3.05 0.1200000000000001 0.11999999999999966 0.24589 0.016262473374431704 0.016262473374431704
	+-2.815 0.11500000000000021 0.11499999999999977 0.258974 0.013261421888624914 0.013261421888624914
	+-2.59 0.11000000000000032 0.10999999999999988 0.271976 0.018634672524828547 0.018634672524828547
	+-2.375 0.10499999999999998 0.10499999999999998 0.268259 0.02084337170435964 0.02084337170435964
	+-2.17 0.10000000000000009 0.10000000000000009 0.243828 0.018296643965080045 0.018296643965080045
	+-1.97 0.09999999999999987 0.09999999999999987 0.202911 0.019436435421107956 0.019436435421107956
	+-1.775 0.0950000000000002 0.09499999999999997 0.150168 0.015556216345229967 0.015556216345229967
	+-1.59 0.08999999999999986 0.09000000000000008 0.109122 0.011108988354251705 0.011108988354251705
	+-1.415 0.08499999999999996 0.08499999999999996 0.0626926 0.007650828765963855 0.007650828765963855
	+-1.025 0.30500000000000016 0.30499999999999994 0.0079423 0.0016837621132455142 0.0016837621132455142
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x04-y03
	+Path=/REF/CMS_2014_I1305624/d01-x04-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.285 0.23499999999999943 0.23500000000000032 0.237582 0.04045498261924779 0.04045498261924779
	+-4.85 0.20000000000000018 0.1999999999999993 0.253798 0.022634173867161576 0.022634173867161576
	+-4.475 0.1750000000000007 0.17499999999999982 0.246749 0.011586644702281157 0.011586644702281157
	+-4.14 0.16000000000000014 0.1599999999999997 0.243114 0.010765620044702488 0.010765620044702488
	+-3.835 0.14500000000000002 0.14500000000000002 0.248258 0.011059406595816975 0.011059406595816975
	+-3.555 0.1349999999999998 0.13500000000000023 0.256206 0.004125555401506566 0.004125555401506566
	+-3.295 0.125 0.125 0.273945 0.008762437809907696 0.008762437809907696
	+-3.05 0.1200000000000001 0.11999999999999966 0.292308 0.015847902393884814 0.015847902393884814
	+-2.815 0.11500000000000021 0.11499999999999977 0.313219 0.017629164843224993 0.017629164843224993
	+-2.59 0.11000000000000032 0.10999999999999988 0.310117 0.01741078144875755 0.01741078144875755
	+-2.375 0.10499999999999998 0.10499999999999998 0.280005 0.020312414090720484 0.020312414090720484
	+-2.17 0.10000000000000009 0.10000000000000009 0.245009 0.017537634171221613 0.017537634171221613
	+-1.97 0.09999999999999987 0.09999999999999987 0.194314 0.01556482164852524 0.01556482164852524
	+-1.775 0.0950000000000002 0.09499999999999997 0.139795 0.013076673709353615 0.013076673709353615
	+-1.59 0.08999999999999986 0.09000000000000008 0.0936299 0.0073120910709659525 0.0073120910709659525
	+-1.415 0.08499999999999996 0.08499999999999996 0.0513681 0.004500951459537083 0.004500951459537083
	+-1.025 0.30500000000000016 0.30499999999999994 0.00617886 0.0017650804577415162 0.0017650804577415162
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x04-y04
	+Path=/REF/CMS_2014_I1305624/d01-x04-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.285 0.23499999999999943 0.23500000000000032 0.218974 0.03716272067587206 0.03716272067587206
	+-4.85 0.20000000000000018 0.1999999999999993 0.228083 0.01941035273874486 0.01941035273874486
	+-4.475 0.1750000000000007 0.17499999999999982 0.23769 0.010259662921441426 0.010259662921441426
	+-4.14 0.16000000000000014 0.1599999999999997 0.240275 0.018101104477064374 0.018101104477064374
	+-3.835 0.14500000000000002 0.14500000000000002 0.260641 0.015924038398207913 0.015924038398207913
	+-3.555 0.1349999999999998 0.13500000000000023 0.283014 0.009295619570663377 0.009295619570663377
	+-3.295 0.125 0.125 0.30732 0.014812017668599374 0.014812017668599374
	+-3.05 0.1200000000000001 0.11999999999999966 0.336233 0.017008818765278794 0.017008818765278794
	+-2.815 0.11500000000000021 0.11499999999999977 0.328179 0.012828208980602086 0.012828208980602086
	+-2.59 0.11000000000000032 0.10999999999999988 0.315381 0.023775901514213924 0.023775901514213924
	+-2.375 0.10499999999999998 0.10499999999999998 0.283512 0.016410047006517076 0.016410047006517076
	+-2.17 0.10000000000000009 0.10000000000000009 0.232374 0.02058844250642578 0.02058844250642578
	+-1.97 0.09999999999999987 0.09999999999999987 0.181996 0.014761490949480678 0.014761490949480678
	+-1.775 0.0950000000000002 0.09499999999999997 0.12714 0.00991184863091139 0.00991184863091139
	+-1.59 0.08999999999999986 0.09000000000000008 0.0822205 0.010105471571559638 0.010105471571559638
	+-1.415 0.08499999999999996 0.08499999999999996 0.0406077 0.008025842768669779 0.008025842768669779
	+-1.025 0.30500000000000016 0.30499999999999994 0.00509423 0.001674831460249359 0.001674831460249359
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x04-y05
	+Path=/REF/CMS_2014_I1305624/d01-x04-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.285 0.23499999999999943 0.23500000000000032 0.205701 0.037916135526582996 0.037916135526582996
	+-4.85 0.20000000000000018 0.1999999999999993 0.226238 0.015886960258579864 0.015886960258579864
	+-4.475 0.1750000000000007 0.17499999999999982 0.245542 0.0052683049749866415 0.0052683049749866415
	+-4.14 0.16000000000000014 0.1599999999999997 0.269637 0.009007959293714864 0.009007959293714864
	+-3.835 0.14500000000000002 0.14500000000000002 0.283068 0.0040848660506611475 0.0040848660506611475
	+-3.555 0.1349999999999998 0.13500000000000023 0.31076 0.008826400609739002 0.008826400609739002
	+-3.295 0.125 0.125 0.337267 0.012809968951127437 0.012809968951127437
	+-3.05 0.1200000000000001 0.11999999999999966 0.347334 0.01710999116486692 0.01710999116486692
	+-2.815 0.11500000000000021 0.11499999999999977 0.330492 0.019798759534144787 0.019798759534144787
	+-2.59 0.11000000000000032 0.10999999999999988 0.297923 0.018778318035320016 0.018778318035320016
	+-2.375 0.10499999999999998 0.10499999999999998 0.257809 0.017139656162361717 0.017139656162361717
	+-2.17 0.10000000000000009 0.10000000000000009 0.208908 0.02303095574549665 0.02303095574549665
	+-1.97 0.09999999999999987 0.09999999999999987 0.153613 0.014838440722356913 0.014838440722356913
	+-1.775 0.0950000000000002 0.09499999999999997 0.103957 0.00794923852766169 0.00794923852766169
	+-1.59 0.08999999999999986 0.09000000000000008 0.0637393 0.005681948751359519 0.005681948751359519
	+-1.255 0.2450000000000001 0.24499999999999988 0.0153148 0.002117840046637375 0.002117840046637375
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x05-y01
	+Path=/REF/CMS_2014_I1305624/d01-x05-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-5.705 0.4349999999999996 0.4350000000000005 0.0235153 0.005865854603755534 0.005865854603755534
	+-5.05 0.21999999999999975 0.21999999999999975 0.224653 0.02047673005640549 0.02047673005640549
	+-4.625 0.20500000000000007 0.20500000000000007 0.447003 0.020826945701808992 0.020826945701808992
	+-4.23 0.1899999999999995 0.1900000000000004 0.557421 0.03168556166319922 0.03168556166319922
	+-3.875 0.16500000000000004 0.16500000000000004 0.552702 0.05080466458308725 0.05080466458308725
	+-3.565 0.14500000000000002 0.14500000000000002 0.487126 0.05894877175198903 0.05894877175198903
	+-3.295 0.125 0.125 0.365589 0.03266526207745623 0.03266526207745623
	+-3.06 0.10999999999999988 0.10999999999999988 0.20057 0.011852980408673592 0.011852980408673592
	+-2.855 0.0950000000000002 0.0950000000000002 0.0936645 0.00905156341576415 0.00905156341576415
	+-2.61 0.1499999999999999 0.1499999999999999 0.0287536 0.003679295672407968 0.003679295672407968
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x05-y02
	+Path=/REF/CMS_2014_I1305624/d01-x05-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-6.505 0.3650000000000002 0.3650000000000002 0.017534 0.0018345404308733565 0.0018345404308733565
	+-5.925 0.21499999999999986 0.21499999999999986 0.157053 0.010404154819859228 0.010404154819859228
	+-5.49 0.21999999999999975 0.22000000000000064 0.290083 0.009960493408872877 0.009960493408872877
	+-5.05 0.21999999999999975 0.21999999999999975 0.333347 0.009114431985560044 0.009114431985560044
	+-4.625 0.20500000000000007 0.20500000000000007 0.366823 0.0116878782385042 0.0116878782385042
	+-4.23 0.1899999999999995 0.1900000000000004 0.403828 0.024672621497117003 0.024672621497117003
	+-3.875 0.16500000000000004 0.16500000000000004 0.389609 0.00717343514175043 0.00717343514175043
	+-3.565 0.14500000000000002 0.14500000000000002 0.349482 0.013979378119304879 0.013979378119304879
	+-3.295 0.125 0.125 0.263225 0.013487878901072621 0.013487878901072621
	+-3.06 0.10999999999999988 0.10999999999999988 0.136549 0.007342653027155783 0.007342653027155783
	+-2.855 0.0950000000000002 0.0950000000000002 0.0592771 0.005103076248460334 0.005103076248460334
	+-2.61 0.1499999999999999 0.1499999999999999 0.0149188 0.0012421031696481578 0.0012421031696481578
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x05-y03
	+Path=/REF/CMS_2014_I1305624/d01-x05-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-7.37 0.5 0.5 0.00466295 9.082155562447717E-4 9.082155562447717E-4
	+-6.7 0.16999999999999993 0.16999999999999993 0.112519 0.01020788548108275 0.01020788548108275
	+-6.335 0.19500000000000028 0.19500000000000028 0.214097 0.010328972983312522 0.010328972983312522
	+-5.925 0.21499999999999986 0.21499999999999986 0.241158 0.004886179590334354 0.004886179590334354
	+-5.49 0.21999999999999975 0.22000000000000064 0.256923 0.005994542808138083 0.005994542808138083
	+-5.05 0.21999999999999975 0.21999999999999975 0.280337 0.011933617965181388 0.011933617965181388
	+-4.625 0.20500000000000007 0.20500000000000007 0.300493 0.013850445117598207 0.013850445117598207
	+-4.23 0.1899999999999995 0.1900000000000004 0.33531 0.016455031836383666 0.016455031836383666
	+-3.875 0.16500000000000004 0.16500000000000004 0.327254 0.011094039535538893 0.011094039535538893
	+-3.565 0.14500000000000002 0.14500000000000002 0.299096 0.005377127913421811 0.005377127913421811
	+-3.295 0.125 0.125 0.22183 0.009471431571441563 0.009471431571441563
	+-3.06 0.10999999999999988 0.10999999999999988 0.100166 0.005785836977317975 0.005785836977317975
	+-2.855 0.0950000000000002 0.0950000000000002 0.0395002 0.0019465273686955957 0.0019465273686955957
	+-2.61 0.1499999999999999 0.1499999999999999 0.0104656 0.0012777430594700953 0.0012777430594700953
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x05-y04
	+Path=/REF/CMS_2014_I1305624/d01-x05-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-7.37 0.5 0.5 0.0623511 0.004856302474399222 0.004856302474399222
	+-6.7 0.16999999999999993 0.16999999999999993 0.191526 0.007232636059038226 0.007232636059038226
	+-6.335 0.19500000000000028 0.19500000000000028 0.209777 0.012900505762628068 0.012900505762628068
	+-5.925 0.21499999999999986 0.21499999999999986 0.223785 0.011750265626703935 0.011750265626703935
	+-5.49 0.21999999999999975 0.22000000000000064 0.238773 0.01166167014157492 0.01166167014157492
	+-5.05 0.21999999999999975 0.21999999999999975 0.2574 0.013576762356821304 0.013576762356821304
	+-4.625 0.20500000000000007 0.20500000000000007 0.278152 0.016432380522337597 0.016432380522337597
	+-4.23 0.1899999999999995 0.1900000000000004 0.295254 0.008546660415998754 0.008546660415998754
	+-3.875 0.16500000000000004 0.16500000000000004 0.28523 0.01782099207188253 0.01782099207188253
	+-3.565 0.14500000000000002 0.14500000000000002 0.268909 0.010083741302125913 0.010083741302125913
	+-3.295 0.125 0.125 0.201955 0.015969091857788907 0.015969091857788907
	+-3.06 0.10999999999999988 0.10999999999999988 0.0837385 0.00493321397293894 0.00493321397293894
	+-2.855 0.0950000000000002 0.0950000000000002 0.0318727 0.004323850688325049 0.004323850688325049
	+-2.61 0.1499999999999999 0.1499999999999999 0.00952649 0.0028281043105099573 0.0028281043105099573
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2014_I1305624/d01-x05-y05
	+Path=/REF/CMS_2014_I1305624/d01-x05-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-9.12 0.75 0.75 0.00162719 1.1044326928337462E-4 1.1044326928337462E-4
	+-8.12 0.25 0.2499999999999991 0.023821 0.0017017537865887064 0.0017017537865887064
	+-7.62 0.25 0.25 0.105974 0.0069335205062784665 0.0069335205062784665
	+-7.12 0.25 0.25 0.172977 0.004994159960058949 0.004994159960058949
	+-6.7 0.16999999999999993 0.16999999999999993 0.185113 0.004977840237318188 0.004977840237318188
	+-6.335 0.19500000000000028 0.19500000000000028 0.196063 0.007474074387097643 0.007474074387097643
	+-5.925 0.21499999999999986 0.21499999999999986 0.20822 0.0023888400743364967 0.0023888400743364967
	+-5.49 0.21999999999999975 0.22000000000000064 0.218942 0.003117802652975329 0.003117802652975329
	+-5.05 0.21999999999999975 0.21999999999999975 0.233752 0.008276612173312459 0.008276612173312459
	+-4.625 0.20500000000000007 0.20500000000000007 0.249273 0.006052825139514275 0.006052825139514275
	+-4.23 0.1899999999999995 0.1900000000000004 0.259059 0.004570461579033894 0.004570461579033894
	+-3.875 0.16500000000000004 0.16500000000000004 0.258645 0.011721616868156074 0.011721616868156074
	+-3.565 0.14500000000000002 0.14500000000000002 0.234884 0.015371296011766346 0.015371296011766346
	+-3.295 0.125 0.125 0.170903 0.005139482436285682 0.005139482436285682
	+-3.06 0.10999999999999988 0.10999999999999988 0.0674676 0.0058499010826351585 0.0058499010826351585
	+-2.705 0.2450000000000001 0.2450000000000001 0.0129963 0.0018619844747282401 0.0018619844747282401
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/CMS_2015_I1397174.yoda b/data/refdata/CMS_2015_I1397174.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/CMS_2015_I1397174.yoda
	@@ -0,0 +1,1286 @@
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d01-x01-y01
	+Path=/REF/CMS_2015_I1397174/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.0 0.5 0.5 2.59 0.15079870689100752 0.15079870689100752
	+3.0 0.5 0.5 1.43 0.1445923926076334 0.1445923926076334
	+4.0 0.5 0.5 0.51 0.07227309319518573 0.07227309319518573
	+5.0 0.5 0.5 0.15 0.04234571997262534 0.04234571997262534
	+6.0 0.5 0.5 0.05 0.01049952379872535 0.01049952379872535
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d02-x01-y01
	+Path=/REF/CMS_2015_I1397174/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.0 0.5 0.5 0.538 0.019667051126185643 0.019667051126185643
	+3.0 0.5 0.5 0.295 0.011746131277999578 0.011746131277999578
	+4.0 0.5 0.5 0.105 0.010014634291875065 0.010014634291875065
	+5.0 0.5 0.5 0.031 0.008746930890318043 0.008746930890318043
	+6.0 0.5 0.5 0.011 0.0018875179469345451 0.0018875179469345451
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d03-x01-y01
	+Path=/REF/CMS_2015_I1397174/d03-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0 0.5 0.5 0.556 0.041937639418546196 0.041937639418546196
	+1.0 0.5 0.5 1.73 0.12296812595140254 0.12296812595140254
	+2.0 0.5 0.5 1.87 0.11225756099256745 0.11225756099256745
	+3.0 0.5 0.5 0.473 0.0410396150079408 0.0410396150079408
	+4.0 0.5 0.5 0.092 0.018003969006860684 0.018003969006860684
	+5.0 0.5 0.5 0.019 0.003015592810709032 0.003015592810709032
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d04-x01-y01
	+Path=/REF/CMS_2015_I1397174/d04-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0 0.5 0.5 0.117 0.007285986549534661 0.007285986549534661
	+1.0 0.5 0.5 0.367 0.008660282905309733 0.008660282905309733
	+2.0 0.5 0.5 0.393 0.008088868894969185 0.008088868894969185
	+3.0 0.5 0.5 0.0985 0.004187421641057895 0.004187421641057895
	+4.0 0.5 0.5 0.02 0.00370599514300815 0.00370599514300815
	+5.0 0.5 0.5 0.0042 5.31244764680086E-4 5.31244764680086E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d05-x01-y01
	+Path=/REF/CMS_2015_I1397174/d05-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0 0.5 0.5 2.66 0.16278820596099705 0.16278820596099705
	+1.0 0.5 0.5 1.37 0.10628080729840171 0.10628080729840171
	+2.0 0.5 0.5 0.6 0.04080441152620633 0.04080441152620633
	+3.0 0.5 0.5 0.0929 0.012801656142859016 0.012801656142859016
	+4.0 0.5 0.5 0.0137 0.002525074256333861 0.002525074256333861
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d06-x01-y01
	+Path=/REF/CMS_2015_I1397174/d06-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0 0.5 0.5 0.559 0.016542747655694925 0.016542747655694925
	+1.0 0.5 0.5 0.292 0.013640014662748718 0.013640014662748718
	+2.0 0.5 0.5 0.125 0.0033634060117684276 0.0033634060117684276
	+3.0 0.5 0.5 0.02 0.002744886154287642 0.002744886154287642
	+4.0 0.5 0.5 0.0029 4.938522046118657E-4 4.938522046118657E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d07-x01-y01
	+Path=/REF/CMS_2015_I1397174/d07-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.053 0.004370615059691255 0.004370615059691255
	+62.5 17.5 17.5 0.0217 0.0017367869759990716 0.0017367869759990716
	+110.0 30.0 30.0 0.00864 7.089351169183256E-4 7.089351169183256E-4
	+170.0 30.0 30.0 0.0028 2.768809130294105E-4 2.768809130294105E-4
	+300.0 100.0 100.0 6.9E-4 1.0008995953640905E-4 1.0008995953640905E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d08-x01-y01
	+Path=/REF/CMS_2015_I1397174/d08-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.0182 5.304865691042517E-4 5.304865691042517E-4
	+62.5 17.5 17.5 0.00744 3.0808440401941805E-4 3.0808440401941805E-4
	+110.0 30.0 30.0 0.00296 1.5777781846634844E-4 1.5777781846634844E-4
	+170.0 30.0 30.0 9.78E-4 7.303108927025532E-5 7.303108927025532E-5
	+300.0 100.0 100.0 2.4E-4 3.4634087255188346E-5 3.4634087255188346E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d09-x01-y01
	+Path=/REF/CMS_2015_I1397174/d09-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 1.32 0.08724265012022503 0.08724265012022503
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 1.5 0.16826764394856192 0.16826764394856192
	+1.5 0.30000000000000004 0.30000000000000004 1.3 0.13257450735341242 0.13257450735341242
	+2.1 0.30000000000000004 0.2999999999999998 1.1 0.21066076995966762 0.21066076995966762
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d10-x01-y01
	+Path=/REF/CMS_2015_I1397174/d10-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.427 0.028248851304079607 0.028248851304079607
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.477 0.01286943666210763 0.01286943666210763
	+1.5 0.30000000000000004 0.30000000000000004 0.42 0.008929322482697106 0.008929322482697106
	+2.1 0.30000000000000004 0.2999999999999998 0.342 0.03245751068705054 0.03245751068705054
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d11-x01-y01
	+Path=/REF/CMS_2015_I1397174/d11-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+27.5 7.5 7.5 0.047 0.005770441924151043 0.005770441924151043
	+42.5 7.5 7.5 0.017 0.001699529640812422 0.001699529640812422
	+65.0 15.0 15.0 0.00682 6.498068943924803E-4 6.498068943924803E-4
	+140.0 60.0 60.0 9.0E-4 2.469692490979393E-4 2.469692490979393E-4
	+300.0 100.0 100.0 4.0E-5 1.5231546211727817E-5 1.5231546211727817E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d12-x01-y01
	+Path=/REF/CMS_2015_I1397174/d12-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+27.5 7.5 7.5 0.0368 0.0017086910194649002 0.0017086910194649002
	+42.5 7.5 7.5 0.0132 8.20278611204754E-4 8.20278611204754E-4
	+65.0 15.0 15.0 0.0053 4.6642469917447554E-4 4.6642469917447554E-4
	+140.0 60.0 60.0 7.1E-4 1.8097870040421882E-4 1.8097870040421882E-4
	+300.0 100.0 100.0 2.7E-5 1.3888930844381076E-5 1.3888930844381076E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d13-x01-y01
	+Path=/REF/CMS_2015_I1397174/d13-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.64 0.07113508276511668 0.07113508276511668
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.62 0.09135912652822377 0.09135912652822377
	+1.5 0.30000000000000004 0.30000000000000004 0.53 0.1086390353418144 0.1086390353418144
	+2.1 0.30000000000000004 0.2999999999999998 0.47 0.13801539769170687 0.13801539769170687
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d14-x01-y01
	+Path=/REF/CMS_2015_I1397174/d14-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.469 0.04300104649889349 0.04300104649889349
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.45 0.02681734513332742 0.02681734513332742
	+1.5 0.30000000000000004 0.30000000000000004 0.399 0.027111805546661774 0.027111805546661774
	+2.1 0.30000000000000004 0.2999999999999998 0.35 0.05077292585620805 0.05077292585620805
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d15-x01-y01
	+Path=/REF/CMS_2015_I1397174/d15-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+30.0 30.0 30.0 0.0044 6.186500141436999E-4 6.186500141436999E-4
	+80.0 20.0 20.0 0.0076 0.0012848381220994338 0.0012848381220994338
	+135.0 35.0 35.0 0.0047 7.283639200289921E-4 7.283639200289921E-4
	+285.0 115.0 115.0 0.0013 1.8669375993856892E-4 1.8669375993856892E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d16-x01-y01
	+Path=/REF/CMS_2015_I1397174/d16-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+30.0 30.0 30.0 0.0045 5.066448460213525E-4 5.066448460213525E-4
	+80.0 20.0 20.0 0.00633 3.848168395483753E-4 3.848168395483753E-4
	+135.0 35.0 35.0 0.00396 2.235106261456041E-4 2.235106261456041E-4
	+285.0 115.0 115.0 0.00108 5.313915693723415E-5 5.313915693723415E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d17-x01-y01
	+Path=/REF/CMS_2015_I1397174/d17-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.75 0.25 0.25 0.34 0.03827983281050219 0.03827983281050219
	+1.5 0.5 0.5 0.3 0.08896606094460965 0.08896606094460965
	+2.5 0.5 0.5 0.41 0.1168837456620894 0.1168837456620894
	+3.5 0.5 0.5 0.28 0.06058547680756503 0.06058547680756503
	+4.5 0.5 0.5 0.077 0.018767727619506843 0.018767727619506843
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d18-x01-y01
	+Path=/REF/CMS_2015_I1397174/d18-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.75 0.25 0.25 0.28 0.052613401334640965 0.052613401334640965
	+1.5 0.5 0.5 0.24 0.02390783135292702 0.02390783135292702
	+2.5 0.5 0.5 0.329 0.026599001860972152 0.026599001860972152
	+3.5 0.5 0.5 0.228 0.018238431950143085 0.018238431950143085
	+4.5 0.5 0.5 0.06 0.012212469037831785 0.012212469037831785
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d19-x01-y01
	+Path=/REF/CMS_2015_I1397174/d19-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.0396 0.0030359374170097777 0.0030359374170097777
	+62.5 17.5 17.5 0.02 0.002066494616494318 0.002066494616494318
	+110.0 30.0 30.0 0.0106 0.0010085335889299869 0.0010085335889299869
	+170.0 30.0 30.0 0.0047 6.240592920548495E-4 6.240592920548495E-4
	+400.0 200.0 200.0 8.3E-4 1.258672316371501E-4 1.258672316371501E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d20-x01-y01
	+Path=/REF/CMS_2015_I1397174/d20-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.0135 5.010788361126421E-4 5.010788361126421E-4
	+62.5 17.5 17.5 0.00691 2.500599928017275E-4 2.500599928017275E-4
	+110.0 30.0 30.0 0.00353 1.1370861884659402E-4 1.1370861884659402E-4
	+170.0 30.0 30.0 0.00162 1.1498439024493716E-4 1.1498439024493716E-4
	+400.0 200.0 200.0 2.8E-4 3.146607061582364E-5 3.146607061582364E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d21-x01-y01
	+Path=/REF/CMS_2015_I1397174/d21-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 2.7 0.2710912945854219 0.2710912945854219
	+62.5 17.5 17.5 1.13 0.10674099493634111 0.10674099493634111
	+110.0 30.0 30.0 0.425 0.033193561122603285 0.033193561122603285
	+170.0 30.0 30.0 0.136 0.01121734817147083 0.01121734817147083
	+300.0 100.0 100.0 0.0304 0.0025394180435682505 0.0025394180435682505
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d22-x01-y01
	+Path=/REF/CMS_2015_I1397174/d22-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.0185 4.451033587831033E-4 4.451033587831033E-4
	+62.5 17.5 17.5 0.00766 2.7842442421598E-4 2.7842442421598E-4
	+110.0 30.0 30.0 0.00288 1.0441187671907828E-4 1.0441187671907828E-4
	+170.0 30.0 30.0 9.26E-4 4.7300105708127125E-5 4.7300105708127125E-5
	+300.0 100.0 100.0 2.07E-4 1.765106229097841E-5 1.765106229097841E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d23-x01-y01
	+Path=/REF/CMS_2015_I1397174/d23-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 65.7 4.1726849869119045 4.1726849869119045
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 70.6 6.851608862157851 6.851608862157851
	+1.5 0.30000000000000004 0.30000000000000004 63.2 6.143582342575056 6.143582342575056
	+2.1 0.30000000000000004 0.2999999999999998 51.0 8.217332961490609 8.217332961490609
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d24-x01-y01
	+Path=/REF/CMS_2015_I1397174/d24-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.437 0.026134125200587832 0.026134125200587832
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.472 0.011840422289766526 0.011840422289766526
	+1.5 0.30000000000000004 0.30000000000000004 0.419 0.006397265040624782 0.006397265040624782
	+2.1 0.30000000000000004 0.2999999999999998 0.338 0.025652728899670695 0.025652728899670695
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d25-x01-y01
	+Path=/REF/CMS_2015_I1397174/d25-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+27.5 7.5 7.5 2.4 0.3620422074841551 0.3620422074841551
	+42.5 7.5 7.5 0.87 0.09370186764414036 0.09370186764414036
	+65.0 15.0 15.0 0.34 0.04291305162768083 0.04291305162768083
	+140.0 60.0 60.0 0.042 0.007334984662560651 0.007334984662560651
	+300.0 100.0 100.0 0.0015 6.594884381094183E-4 6.594884381094183E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d26-x01-y01
	+Path=/REF/CMS_2015_I1397174/d26-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+27.5 7.5 7.5 0.0376 0.0015083580476796614 0.0015083580476796614
	+42.5 7.5 7.5 0.0133 8.560519844028165E-4 8.560519844028165E-4
	+65.0 15.0 15.0 0.00518 3.618756692567214E-4 3.618756692567214E-4
	+140.0 60.0 60.0 6.5E-4 1.392088000091948E-4 1.392088000091948E-4
	+300.0 100.0 100.0 2.2E-5 1.1808742524079352E-5 1.1808742524079352E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d27-x01-y01
	+Path=/REF/CMS_2015_I1397174/d27-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 31.6 3.050233597611829 3.050233597611829
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 30.0 4.016416313083095 4.016416313083095
	+1.5 0.30000000000000004 0.30000000000000004 27.0 5.473013886333562 5.473013886333562
	+2.1 0.30000000000000004 0.2999999999999998 23.0 6.505382386916238 6.505382386916238
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d28-x01-y01
	+Path=/REF/CMS_2015_I1397174/d28-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.469 0.04481350242951336 0.04481350242951336
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.45 0.022553935355055003 0.022553935355055003
	+1.5 0.30000000000000004 0.30000000000000004 0.402 0.02536178227175685 0.02536178227175685
	+2.1 0.30000000000000004 0.2999999999999998 0.35 0.04703041569027431 0.04703041569027431
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d29-x01-y01
	+Path=/REF/CMS_2015_I1397174/d29-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+30.0 30.0 30.0 0.23 0.04158422898167045 0.04158422898167045
	+80.0 20.0 20.0 0.4 0.05571355310873648 0.05571355310873648
	+135.0 35.0 35.0 0.24 0.025273037015760492 0.025273037015760492
	+285.0 115.0 115.0 0.064 0.0066296983340118874 0.0066296983340118874
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d30-x01-y01
	+Path=/REF/CMS_2015_I1397174/d30-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+30.0 30.0 30.0 0.0037 4.891282449419579E-4 4.891282449419579E-4
	+80.0 20.0 20.0 0.00647 3.582736384385544E-4 3.582736384385544E-4
	+135.0 35.0 35.0 0.00398 2.0276587484091105E-4 2.0276587484091105E-4
	+285.0 115.0 115.0 0.00104 6.192285523132796E-5 6.192285523132796E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d31-x01-y01
	+Path=/REF/CMS_2015_I1397174/d31-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.75 0.25 0.25 17.0 2.2759692440804202 2.2759692440804202
	+1.5 0.5 0.5 16.0 2.176235281397671 2.176235281397671
	+2.5 0.5 0.5 22.0 3.3837115716325465 3.3837115716325465
	+3.5 0.5 0.5 15.0 2.46 2.46
	+4.5 0.5 0.5 3.8 0.871725300768539 0.871725300768539
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d32-x01-y01
	+Path=/REF/CMS_2015_I1397174/d32-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.75 0.25 0.25 0.26 0.03238718882521297 0.03238718882521297
	+1.5 0.5 0.5 0.245 0.015108358613694604 0.015108358613694604
	+2.5 0.5 0.5 0.335 0.020723214036437492 0.020723214036437492
	+3.5 0.5 0.5 0.227 0.015013647125199127 0.015013647125199127
	+4.5 0.5 0.5 0.058 0.009370186764414036 0.009370186764414036
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d33-x01-y01
	+Path=/REF/CMS_2015_I1397174/d33-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 2.01 0.16621976416780287 0.16621976416780287
	+62.5 17.5 17.5 1.1 0.11119802156513398 0.11119802156513398
	+110.0 30.0 30.0 0.53 0.05899211896516347 0.05899211896516347
	+170.0 30.0 30.0 0.23 0.028102386019695908 0.028102386019695908
	+400.0 200.0 200.0 0.038 0.0035815639042183793 0.0035815639042183793
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d34-x01-y01
	+Path=/REF/CMS_2015_I1397174/d34-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.0136 3.86746687122204E-4 3.86746687122204E-4
	+62.5 17.5 17.5 0.00708 1.772004514666935E-4 1.772004514666935E-4
	+110.0 30.0 30.0 0.00356 1.2123530838827442E-4 1.2123530838827442E-4
	+170.0 30.0 30.0 0.00158 8.204590178674375E-5 8.204590178674375E-5
	+400.0 200.0 200.0 2.56E-4 1.5577535106684884E-5 1.5577535106684884E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d35-x01-y01
	+Path=/REF/CMS_2015_I1397174/d35-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.0027 9.172055385790036E-4 9.172055385790036E-4
	+62.5 17.5 17.5 0.0016 4.6729861972832746E-4 4.6729861972832746E-4
	+140.0 60.0 60.0 2.9E-4 9.812976103099405E-5 9.812976103099405E-5
	+300.0 100.0 100.0 2.6E-5 2.048316381812146E-5 2.048316381812146E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d36-x01-y01
	+Path=/REF/CMS_2015_I1397174/d36-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.016 0.0057711004149988586 0.0057711004149988586
	+62.5 17.5 17.5 0.0098 0.0029192636057745794 0.0029192636057745794
	+140.0 60.0 60.0 0.0018 6.3E-4 6.3E-4
	+300.0 100.0 100.0 1.6E-4 1.2352165801996021E-4 1.2352165801996021E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d37-x01-y01
	+Path=/REF/CMS_2015_I1397174/d37-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.083 0.021738896016127406 0.021738896016127406
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.066 0.023557470152798663 0.023557470152798663
	+1.5 0.30000000000000004 0.30000000000000004 0.054 0.023030423356942446 0.023030423356942446
	+2.1 0.30000000000000004 0.2999999999999998 0.066 0.024419999999999997 0.024419999999999997
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d38-x01-y01
	+Path=/REF/CMS_2015_I1397174/d38-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.5 0.16492422502470644 0.16492422502470644
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.4 0.1232233744059949 0.1232233744059949
	+1.5 0.30000000000000004 0.30000000000000004 0.3 0.10816653826391967 0.10816653826391967
	+2.1 0.30000000000000004 0.2999999999999998 0.4 0.12553883861180173 0.12553883861180173
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d39-x01-y01
	+Path=/REF/CMS_2015_I1397174/d39-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 9.6E-4 3.3425289826716535E-4 3.3425289826716535E-4
	+62.5 17.5 17.5 1.8E-4 1.0636766425939794E-4 1.0636766425939794E-4
	+140.0 60.0 60.0 1.8E-5 2.3172828916642873E-5 2.3172828916642873E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d40-x01-y01
	+Path=/REF/CMS_2015_I1397174/d40-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.03 0.005909314681077663 0.005909314681077663
	+62.5 17.5 17.5 0.0055 0.0030955451862313367 0.0030955451862313367
	+140.0 60.0 60.0 5.5E-4 7.297122720634482E-4 7.297122720634482E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d41-x01-y01
	+Path=/REF/CMS_2015_I1397174/d41-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.023 0.01223529729920773 0.01223529729920773
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.012 0.0072874686963307084 0.0072874686963307084
	+1.7999999999999998 0.5999999999999999 0.6000000000000001 0.0076 0.007916375433239633 0.007916375433239633
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d42-x01-y01
	+Path=/REF/CMS_2015_I1397174/d42-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.8 0.49793172222705395 0.49793172222705395
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.4 0.19616319736382765 0.19616319736382765
	+1.7999999999999998 0.5999999999999999 0.6000000000000001 0.3 0.26170594185077267 0.26170594185077267
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d43-x01-y01
	+Path=/REF/CMS_2015_I1397174/d43-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+35.0 25.0 25.0 2.6E-4 1.680171419825965E-4 1.680171419825965E-4
	+80.0 20.0 20.0 1.7E-4 2.1330485226548411E-4 2.1330485226548411E-4
	+135.0 35.0 35.0 5.0E-5 7.510825520540336E-5 7.510825520540336E-5
	+285.0 115.0 115.0 2.9E-5 2.2578751072634645E-5 2.2578751072634645E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d44-x01-y01
	+Path=/REF/CMS_2015_I1397174/d44-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+35.0 25.0 25.0 0.0082 0.005579838707346298 0.005579838707346298
	+80.0 20.0 20.0 0.0055 0.006146616955691969 0.006146616955691969
	+135.0 35.0 35.0 0.0016 0.002287160685216498 0.002287160685216498
	+285.0 115.0 115.0 9.4E-4 7.50552463189616E-4 7.50552463189616E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d45-x01-y01
	+Path=/REF/CMS_2015_I1397174/d45-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.75 0.25 0.25 0.0025 0.008535209429182157 0.008535209429182157
	+1.5 0.5 0.5 0.0077 0.0065032991627327124 0.0065032991627327124
	+3.5 1.5 1.5 0.0098 0.0031531730050855127 0.0031531730050855127
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d46-x01-y01
	+Path=/REF/CMS_2015_I1397174/d46-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.75 0.25 0.25 0.1 0.3480804504708646 0.3480804504708646
	+1.5 0.5 0.5 0.2 0.1451206394693739 0.1451206394693739
	+3.5 1.5 1.5 0.3 0.07262231062146123 0.07262231062146123
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d47-x01-y01
	+Path=/REF/CMS_2015_I1397174/d47-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.11 0.04554053139786579 0.04554053139786579
	+62.5 17.5 17.5 0.063 0.01607762420259909 0.01607762420259909
	+140.0 60.0 60.0 0.012 0.003567856499356441 0.003567856499356441
	+300.0 100.0 100.0 0.001 6.58027355054484E-4 6.58027355054484E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d48-x01-y01
	+Path=/REF/CMS_2015_I1397174/d48-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.017 0.005769991334482229 0.005769991334482229
	+62.5 17.5 17.5 0.0095 0.002559726547895302 0.002559726547895302
	+140.0 60.0 60.0 0.0018 5.904439008068422E-4 5.904439008068422E-4
	+300.0 100.0 100.0 1.5E-4 1.0113604698622543E-4 1.0113604698622543E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d49-x01-y01
	+Path=/REF/CMS_2015_I1397174/d49-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 3.5 0.9424038412485383 0.9424038412485383
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 2.9 0.7174203788574729 0.7174203788574729
	+1.5 0.30000000000000004 0.30000000000000004 2.4 0.7058611761529316 0.7058611761529316
	+2.1 0.30000000000000004 0.2999999999999998 2.7 0.8282445291096102 0.8282445291096102
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d50-x01-y01
	+Path=/REF/CMS_2015_I1397174/d50-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.5 0.13462912017836262 0.13462912017836262
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.4 0.0950789145920377 0.0950789145920377
	+1.5 0.30000000000000004 0.30000000000000004 0.4 0.11005453193758083 0.11005453193758083
	+2.1 0.30000000000000004 0.2999999999999998 0.4 0.11142710621747295 0.11142710621747295
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d51-x01-y01
	+Path=/REF/CMS_2015_I1397174/d51-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.042 0.017317043627594172 0.017317043627594172
	+62.5 17.5 17.5 0.0073 0.00408306257605734 0.00408306257605734
	+140.0 60.0 60.0 6.8E-4 7.716216689544169E-4 7.716216689544169E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d52-x01-y01
	+Path=/REF/CMS_2015_I1397174/d52-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+32.5 12.5 12.5 0.03 0.00579396237474839 0.00579396237474839
	+62.5 17.5 17.5 0.0053 0.003276171546180084 0.003276171546180084
	+140.0 60.0 60.0 4.9E-4 5.84569927382516E-4 5.84569927382516E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d53-x01-y01
	+Path=/REF/CMS_2015_I1397174/d53-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 1.0 0.5126402247190518 0.5126402247190518
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.58 0.2912953827303138 0.2912953827303138
	+1.7999999999999998 0.5999999999999999 0.6000000000000001 0.34 0.2668819214559128 0.2668819214559128
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d54-x01-y01
	+Path=/REF/CMS_2015_I1397174/d54-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.3 0.3 0.3 0.7 0.3457744929863972 0.3457744929863972
	+0.8999999999999999 0.29999999999999993 0.30000000000000004 0.4 0.17088007490635063 0.17088007490635063
	+1.7999999999999998 0.5999999999999999 0.6000000000000001 0.3 0.21627066375262272 0.21627066375262272
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d55-x01-y01
	+Path=/REF/CMS_2015_I1397174/d55-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+35.0 25.0 25.0 0.011 0.009474059320059168 0.009474059320059168
	+80.0 20.0 20.0 0.0079 0.007671727315279135 0.007671727315279135
	+135.0 35.0 35.0 0.0025 0.002833972476930572 0.002833972476930572
	+285.0 115.0 115.0 0.0011 7.813097977115096E-4 7.813097977115096E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d56-x01-y01
	+Path=/REF/CMS_2015_I1397174/d56-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+35.0 25.0 25.0 0.0084 0.006112683535076881 0.006112683535076881
	+80.0 20.0 20.0 0.0058 0.005445475185876803 0.005445475185876803
	+135.0 35.0 35.0 0.0018 0.0020968786326347076 0.0020968786326347076
	+285.0 115.0 115.0 8.4E-4 6.569056248807739E-4 6.569056248807739E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d57-x01-y01
	+Path=/REF/CMS_2015_I1397174/d57-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.75 0.25 0.25 0.0055 0.4281798687467686 0.4281798687467686
	+1.5 0.5 0.5 0.27 0.21529514625276622 0.21529514625276622
	+3.5 1.5 1.5 0.36 0.101 0.101
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d58-x01-y01
	+Path=/REF/CMS_2015_I1397174/d58-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.75 0.25 0.25 0.0041 0.3194075140005319 0.3194075140005319
	+1.5 0.5 0.5 0.2 0.14243595051811886 0.14243595051811886
	+3.5 1.5 1.5 0.27 0.0734479407471714 0.0734479407471714
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d59-x01-y01
	+Path=/REF/CMS_2015_I1397174/d59-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.478 0.018439088914585774 0.018439088914585774
	+35.0 5.0 5.0 0.595 0.012649110640673518 0.012649110640673518
	+45.0 5.0 5.0 0.671 0.010770329614269008 0.010770329614269008
	+55.0 5.0 5.0 0.729 0.008944271909999158 0.008944271909999158
	+65.0 5.0 5.0 0.774 0.009486832980505138 0.009486832980505138
	+75.0 5.0 5.0 0.81 0.009486832980505138 0.009486832980505138
	+85.0 5.0 5.0 0.84 0.007615773105863909 0.007615773105863909
	+95.0 5.0 5.0 0.863 0.007615773105863909 0.007615773105863909
	+110.0 10.0 10.0 0.893 0.0058309518948453 0.0058309518948453
	+130.0 10.0 10.0 0.921 0.005385164807134504 0.005385164807134504
	+150.0 10.0 10.0 0.939 0.004472135954999579 0.004472135954999579
	+170.0 10.0 10.0 0.954 0.0036055512754639895 0.0036055512754639895
	+190.0 10.0 10.0 0.964 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d60-x01-y01
	+Path=/REF/CMS_2015_I1397174/d60-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.75 0.011704699910719625 0.011704699910719625
	+35.0 5.0 5.0 0.816 0.008544003745317531 0.008544003745317531
	+45.0 5.0 5.0 0.856 0.00670820393249937 0.00670820393249937
	+55.0 5.0 5.0 0.884 0.0058309518948453 0.0058309518948453
	+65.0 5.0 5.0 0.905 0.004472135954999579 0.004472135954999579
	+75.0 5.0 5.0 0.922 0.004472135954999579 0.004472135954999579
	+85.0 5.0 5.0 0.935 0.0036055512754639895 0.0036055512754639895
	+95.0 5.0 5.0 0.945 0.0036055512754639895 0.0036055512754639895
	+110.0 10.0 10.0 0.956 0.0036055512754639895 0.0036055512754639895
	+130.0 10.0 10.0 0.968 0.0022360679774997894 0.0022360679774997894
	+150.0 10.0 10.0 0.975 0.0022360679774997894 0.0022360679774997894
	+170.0 10.0 10.0 0.98 0.001414213562373095 0.001414213562373095
	+190.0 10.0 10.0 0.984 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d61-x01-y01
	+Path=/REF/CMS_2015_I1397174/d61-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.78 0.009486832980505138 0.009486832980505138
	+35.0 5.0 5.0 0.841 0.00670820393249937 0.00670820393249937
	+45.0 5.0 5.0 0.874 0.005 0.005
	+55.0 5.0 5.0 0.899 0.004472135954999579 0.004472135954999579
	+65.0 5.0 5.0 0.917 0.0036055512754639895 0.0036055512754639895
	+75.0 5.0 5.0 0.931 0.0036055512754639895 0.0036055512754639895
	+85.0 5.0 5.0 0.942 0.0036055512754639895 0.0036055512754639895
	+95.0 5.0 5.0 0.951 0.0036055512754639895 0.0036055512754639895
	+110.0 10.0 10.0 0.962 0.00282842712474619 0.00282842712474619
	+130.0 10.0 10.0 0.972 0.0022360679774997894 0.0022360679774997894
	+150.0 10.0 10.0 0.979 0.0022360679774997894 0.0022360679774997894
	+170.0 10.0 10.0 0.985 0.0022360679774997894 0.0022360679774997894
	+190.0 10.0 10.0 0.988 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d62-x01-y01
	+Path=/REF/CMS_2015_I1397174/d62-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.78 0.013341664064126334 0.013341664064126334
	+35.0 5.0 5.0 0.843 0.009486832980505138 0.009486832980505138
	+45.0 5.0 5.0 0.878 0.007280109889280519 0.007280109889280519
	+55.0 5.0 5.0 0.904 0.005385164807134504 0.005385164807134504
	+65.0 5.0 5.0 0.922 0.006324555320336759 0.006324555320336759
	+75.0 5.0 5.0 0.936 0.005385164807134504 0.005385164807134504
	+85.0 5.0 5.0 0.948 0.005385164807134504 0.005385164807134504
	+95.0 5.0 5.0 0.957 0.004472135954999579 0.004472135954999579
	+110.0 10.0 10.0 0.967 0.00412310562561766 0.00412310562561766
	+130.0 10.0 10.0 0.977 0.0031622776601683794 0.0031622776601683794
	+150.0 10.0 10.0 0.982 0.0022360679774997894 0.0022360679774997894
	+170.0 10.0 10.0 0.987 0.001414213562373095 0.001414213562373095
	+190.0 10.0 10.0 0.99 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d63-x01-y01
	+Path=/REF/CMS_2015_I1397174/d63-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.798 0.015297058540778355 0.015297058540778355
	+35.0 5.0 5.0 0.878 0.008544003745317531 0.008544003745317531
	+45.0 5.0 5.0 0.92 0.005385164807134504 0.005385164807134504
	+55.0 5.0 5.0 0.945 0.0036055512754639895 0.0036055512754639895
	+65.0 5.0 5.0 0.96 0.0036055512754639895 0.0036055512754639895
	+75.0 5.0 5.0 0.971 0.0031622776601683794 0.0031622776601683794
	+85.0 5.0 5.0 0.979 0.0022360679774997894 0.0022360679774997894
	+95.0 5.0 5.0 0.984 0.0022360679774997894 0.0022360679774997894
	+110.0 10.0 10.0 0.99 0.0016124515496597099 0.0016124515496597099
	+130.0 10.0 10.0 0.9937 0.001 0.001
	+150.0 10.0 10.0 0.9956 7.810249675906653E-4 7.810249675906653E-4
	+170.0 10.0 10.0 0.9972 5.65685424949238E-4 5.65685424949238E-4
	+190.0 10.0 10.0 0.9981 3.605551275463989E-4 3.605551275463989E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d64-x01-y01
	+Path=/REF/CMS_2015_I1397174/d64-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.956 0.005385164807134504 0.005385164807134504
	+35.0 5.0 5.0 0.975 0.0031622776601683794 0.0031622776601683794
	+45.0 5.0 5.0 0.985 0.0022360679774997894 0.0022360679774997894
	+55.0 5.0 5.0 0.99 0.001414213562373095 0.001414213562373095
	+65.0 5.0 5.0 0.9926 0.001140175425099138 0.001140175425099138
	+75.0 5.0 5.0 0.9946 9.219544457292887E-4 9.219544457292887E-4
	+85.0 5.0 5.0 0.996 8.602325267042626E-4 8.602325267042626E-4
	+95.0 5.0 5.0 0.9969 7.211102550927978E-4 7.211102550927978E-4
	+110.0 10.0 10.0 0.9979 5.0E-4 5.0E-4
	+130.0 10.0 10.0 0.9987 3.605551275463989E-4 3.605551275463989E-4
	+150.0 10.0 10.0 0.9992 2.82842712474619E-4 2.82842712474619E-4
	+170.0 10.0 10.0 0.9994 3.605551275463989E-4 3.605551275463989E-4
	+190.0 10.0 10.0 0.9995 2.2360679774997898E-4 2.2360679774997898E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d65-x01-y01
	+Path=/REF/CMS_2015_I1397174/d65-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.969 0.0031622776601683794 0.0031622776601683794
	+35.0 5.0 5.0 0.982 0.001414213562373095 0.001414213562373095
	+45.0 5.0 5.0 0.989 0.001414213562373095 0.001414213562373095
	+55.0 5.0 5.0 0.993 0.001414213562373095 0.001414213562373095
	+65.0 5.0 5.0 0.9952 7.071067811865475E-4 7.071067811865475E-4
	+75.0 5.0 5.0 0.9965 6.403124237432849E-4 6.403124237432849E-4
	+85.0 5.0 5.0 0.9975 5.65685424949238E-4 5.65685424949238E-4
	+95.0 5.0 5.0 0.9981 4.242640687119285E-4 4.242640687119285E-4
	+110.0 10.0 10.0 0.9988 3.605551275463989E-4 3.605551275463989E-4
	+130.0 10.0 10.0 0.9992 2.2360679774997898E-4 2.2360679774997898E-4
	+150.0 10.0 10.0 0.9994 2.2360679774997898E-4 2.2360679774997898E-4
	+170.0 10.0 10.0 0.9996 1.414213562373095E-4 1.414213562373095E-4
	+190.0 10.0 10.0 0.9997 1.414213562373095E-4 1.414213562373095E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d66-x01-y01
	+Path=/REF/CMS_2015_I1397174/d66-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.968 0.0031622776601683794 0.0031622776601683794
	+35.0 5.0 5.0 0.983 0.001414213562373095 0.001414213562373095
	+45.0 5.0 5.0 0.99 0.001414213562373095 0.001414213562373095
	+55.0 5.0 5.0 0.994 0.001414213562373095 0.001414213562373095
	+65.0 5.0 5.0 0.9957 6.403124237432849E-4 6.403124237432849E-4
	+75.0 5.0 5.0 0.9971 5.65685424949238E-4 5.65685424949238E-4
	+85.0 5.0 5.0 0.9978 4.242640687119285E-4 4.242640687119285E-4
	+95.0 5.0 5.0 0.9985 4.242640687119285E-4 4.242640687119285E-4
	+110.0 10.0 10.0 0.9991 3.605551275463989E-4 3.605551275463989E-4
	+130.0 10.0 10.0 0.9995 2.82842712474619E-4 2.82842712474619E-4
	+150.0 10.0 10.0 0.9997 1.414213562373095E-4 1.414213562373095E-4
	+170.0 10.0 10.0 0.9999 1.414213562373095E-4 1.414213562373095E-4
	+190.0 10.0 10.0 0.9999 1.414213562373095E-4 1.414213562373095E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d67-x01-y01
	+Path=/REF/CMS_2015_I1397174/d67-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.469 0.021377558326431952 0.021377558326431952
	+35.0 5.0 5.0 0.552 0.022360679774997894 0.022360679774997894
	+45.0 5.0 5.0 0.599 0.021377558326431952 0.021377558326431952
	+55.0 5.0 5.0 0.647 0.01746424919657298 0.01746424919657298
	+65.0 5.0 5.0 0.688 0.01649242250247064 0.01649242250247064
	+75.0 5.0 5.0 0.724 0.015524174696260024 0.015524174696260024
	+85.0 5.0 5.0 0.755 0.014317821063276354 0.014317821063276354
	+95.0 5.0 5.0 0.781 0.013341664064126334 0.013341664064126334
	+110.0 10.0 10.0 0.816 0.011401754250991379 0.011401754250991379
	+130.0 10.0 10.0 0.852 0.01044030650891055 0.01044030650891055
	+150.0 10.0 10.0 0.881 0.009486832980505138 0.009486832980505138
	+170.0 10.0 10.0 0.903 0.007280109889280519 0.007280109889280519
	+190.0 10.0 10.0 0.92 0.006324555320336759 0.006324555320336759
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d68-x01-y01
	+Path=/REF/CMS_2015_I1397174/d68-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.747 0.011704699910719625 0.011704699910719625
	+35.0 5.0 5.0 0.804 0.009486832980505138 0.009486832980505138
	+45.0 5.0 5.0 0.837 0.008544003745317531 0.008544003745317531
	+55.0 5.0 5.0 0.864 0.007615773105863909 0.007615773105863909
	+65.0 5.0 5.0 0.886 0.00670820393249937 0.00670820393249937
	+75.0 5.0 5.0 0.903 0.005385164807134504 0.005385164807134504
	+85.0 5.0 5.0 0.917 0.005385164807134504 0.005385164807134504
	+95.0 5.0 5.0 0.928 0.004472135954999579 0.004472135954999579
	+110.0 10.0 10.0 0.942 0.004472135954999579 0.004472135954999579
	+130.0 10.0 10.0 0.956 0.0036055512754639895 0.0036055512754639895
	+150.0 10.0 10.0 0.965 0.0031622776601683794 0.0031622776601683794
	+170.0 10.0 10.0 0.972 0.0022360679774997894 0.0022360679774997894
	+190.0 10.0 10.0 0.978 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d69-x01-y01
	+Path=/REF/CMS_2015_I1397174/d69-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.778 0.009486832980505138 0.009486832980505138
	+35.0 5.0 5.0 0.832 0.007615773105863909 0.007615773105863909
	+45.0 5.0 5.0 0.861 0.00670820393249937 0.00670820393249937
	+55.0 5.0 5.0 0.886 0.005385164807134504 0.005385164807134504
	+65.0 5.0 5.0 0.903 0.004472135954999579 0.004472135954999579
	+75.0 5.0 5.0 0.919 0.0036055512754639895 0.0036055512754639895
	+85.0 5.0 5.0 0.93 0.0036055512754639895 0.0036055512754639895
	+95.0 5.0 5.0 0.94 0.0036055512754639895 0.0036055512754639895
	+110.0 10.0 10.0 0.952 0.0036055512754639895 0.0036055512754639895
	+130.0 10.0 10.0 0.964 0.0022360679774997894 0.0022360679774997894
	+150.0 10.0 10.0 0.972 0.0022360679774997894 0.0022360679774997894
	+170.0 10.0 10.0 0.979 0.0022360679774997894 0.0022360679774997894
	+190.0 10.0 10.0 0.984 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d70-x01-y01
	+Path=/REF/CMS_2015_I1397174/d70-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+25.0 5.0 5.0 0.779 0.015297058540778355 0.015297058540778355
	+35.0 5.0 5.0 0.834 0.013341664064126334 0.013341664064126334
	+45.0 5.0 5.0 0.865 0.009486832980505138 0.009486832980505138
	+55.0 5.0 5.0 0.889 0.007280109889280519 0.007280109889280519
	+65.0 5.0 5.0 0.908 0.007280109889280519 0.007280109889280519
	+75.0 5.0 5.0 0.923 0.006324555320336759 0.006324555320336759
	+85.0 5.0 5.0 0.935 0.005385164807134504 0.005385164807134504
	+95.0 5.0 5.0 0.945 0.004472135954999579 0.004472135954999579
	+110.0 10.0 10.0 0.957 0.004472135954999579 0.004472135954999579
	+130.0 10.0 10.0 0.968 0.0031622776601683794 0.0031622776601683794
	+150.0 10.0 10.0 0.976 0.0022360679774997894 0.0022360679774997894
	+170.0 10.0 10.0 0.982 0.001414213562373095 0.001414213562373095
	+190.0 10.0 10.0 0.986 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d71-x01-y01
	+Path=/REF/CMS_2015_I1397174/d71-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 -905.3054 0.0 0.0
	+5.0 0.5 0.5 -2048.381 0.0 0.0
	+4.0 0.5 0.5 -7034.302 0.0 0.0
	+3.0 0.5 0.5 -15977.67 0.0 0.0
	+2.0 0.5 0.5 82850.59 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d71-x01-y02
	+Path=/REF/CMS_2015_I1397174/d71-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 3117.798 0.0 0.0
	+5.0 0.5 0.5 1155.393 0.0 0.0
	+4.0 0.5 0.5 -14072.43 0.0 0.0
	+3.0 0.5 0.5 177755.4 0.0 0.0
	+2.0 0.5 0.5 -15977.67 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d71-x01-y03
	+Path=/REF/CMS_2015_I1397174/d71-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 -1687.869 0.0 0.0
	+5.0 0.5 0.5 -2858.785 0.0 0.0
	+4.0 0.5 0.5 50861.32 0.0 0.0
	+3.0 0.5 0.5 -14072.43 0.0 0.0
	+2.0 0.5 0.5 -7034.302 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d71-x01-y04
	+Path=/REF/CMS_2015_I1397174/d71-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 492.5734 0.0 0.0
	+5.0 0.5 0.5 11613.32 0.0 0.0
	+4.0 0.5 0.5 -2858.785 0.0 0.0
	+3.0 0.5 0.5 1155.393 0.0 0.0
	+2.0 0.5 0.5 -2048.381 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d71-x01-y05
	+Path=/REF/CMS_2015_I1397174/d71-x01-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 4007.95 0.0 0.0
	+5.0 0.5 0.5 492.5734 0.0 0.0
	+4.0 0.5 0.5 -1687.869 0.0 0.0
	+3.0 0.5 0.5 3117.798 0.0 0.0
	+2.0 0.5 0.5 -905.3054 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d72-x01-y01
	+Path=/REF/CMS_2015_I1397174/d72-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 -2.996142E-7 0.0 0.0
	+5.0 0.5 0.5 -4.28941E-7 0.0 0.0
	+4.0 0.5 0.5 -1.366921E-6 0.0 0.0
	+3.0 0.5 0.5 -7.488104E-6 0.0 0.0
	+2.0 0.5 0.5 8.849487E-6 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d72-x01-y02
	+Path=/REF/CMS_2015_I1397174/d72-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 9.585635E-8 0.0 0.0
	+5.0 0.5 0.5 -3.495208E-7 0.0 0.0
	+4.0 0.5 0.5 -3.026936E-6 0.0 0.0
	+3.0 0.5 0.5 1.159564E-5 0.0 0.0
	+2.0 0.5 0.5 -7.488104E-6 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d72-x01-y03
	+Path=/REF/CMS_2015_I1397174/d72-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 -2.315373E-7 0.0 0.0
	+5.0 0.5 0.5 -4.021918E-7 0.0 0.0
	+4.0 0.5 0.5 4.997158E-6 0.0 0.0
	+3.0 0.5 0.5 -3.026936E-6 0.0 0.0
	+2.0 0.5 0.5 -1.366921E-6 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d72-x01-y04
	+Path=/REF/CMS_2015_I1397174/d72-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 3.321594E-8 0.0 0.0
	+5.0 0.5 0.5 1.170524E-6 0.0 0.0
	+4.0 0.5 0.5 -4.021918E-7 0.0 0.0
	+3.0 0.5 0.5 -3.495208E-7 0.0 0.0
	+2.0 0.5 0.5 -4.28941E-7 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d72-x01-y05
	+Path=/REF/CMS_2015_I1397174/d72-x01-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+6.0 0.5 0.5 4.252816E-7 0.0 0.0
	+5.0 0.5 0.5 3.321594E-8 0.0 0.0
	+4.0 0.5 0.5 -2.315373E-7 0.0 0.0
	+3.0 0.5 0.5 9.585635E-8 0.0 0.0
	+2.0 0.5 0.5 -2.996142E-7 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d73-x01-y01
	+Path=/REF/CMS_2015_I1397174/d73-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 -372.9907 0.0 0.0
	+4.0 0.5 0.5 -1143.391 0.0 0.0
	+3.0 0.5 0.5 -7289.519 0.0 0.0
	+2.0 0.5 0.5 -20148.63 0.0 0.0
	+1.0 0.5 0.5 -76422.33 0.0 0.0
	+0.0 0.5 0.5 26665.18 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d73-x01-y02
	+Path=/REF/CMS_2015_I1397174/d73-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 1209.7 0.0 0.0
	+4.0 0.5 0.5 5944.214 0.0 0.0
	+3.0 0.5 0.5 24278.44 0.0 0.0
	+2.0 0.5 0.5 14741.04 0.0 0.0
	+1.0 0.5 0.5 499574.8 0.0 0.0
	+0.0 0.5 0.5 -76422.33 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d73-x01-y03
	+Path=/REF/CMS_2015_I1397174/d73-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 -163.1962 0.0 0.0
	+4.0 0.5 0.5 3757.64 0.0 0.0
	+3.0 0.5 0.5 -18137.51 0.0 0.0
	+2.0 0.5 0.5 192147.1 0.0 0.0
	+1.0 0.5 0.5 14741.04 0.0 0.0
	+0.0 0.5 0.5 -20148.63 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d73-x01-y04
	+Path=/REF/CMS_2015_I1397174/d73-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 -311.9526 0.0 0.0
	+4.0 0.5 0.5 -2246.668 0.0 0.0
	+3.0 0.5 0.5 44344.64 0.0 0.0
	+2.0 0.5 0.5 -18137.51 0.0 0.0
	+1.0 0.5 0.5 24278.44 0.0 0.0
	+0.0 0.5 0.5 -7289.519 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d73-x01-y05
	+Path=/REF/CMS_2015_I1397174/d73-x01-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 -509.944 0.0 0.0
	+4.0 0.5 0.5 8378.594 0.0 0.0
	+3.0 0.5 0.5 -2246.668 0.0 0.0
	+2.0 0.5 0.5 3757.64 0.0 0.0
	+1.0 0.5 0.5 5944.214 0.0 0.0
	+0.0 0.5 0.5 -1143.391 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d73-x01-y06
	+Path=/REF/CMS_2015_I1397174/d73-x01-y06
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 1531.4 0.0 0.0
	+4.0 0.5 0.5 -509.944 0.0 0.0
	+3.0 0.5 0.5 -311.9526 0.0 0.0
	+2.0 0.5 0.5 -163.1962 0.0 0.0
	+1.0 0.5 0.5 1209.7 0.0 0.0
	+0.0 0.5 0.5 -372.9907 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d74-x01-y01
	+Path=/REF/CMS_2015_I1397174/d74-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 2.389776E-8 0.0 0.0
	+4.0 0.5 0.5 1.451728E-9 0.0 0.0
	+3.0 0.5 0.5 2.591345E-7 0.0 0.0
	+2.0 0.5 0.5 2.128729E-6 0.0 0.0
	+1.0 0.5 0.5 -8.126137E-6 0.0 0.0
	+0.0 0.5 0.5 5.674287E-6 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d74-x01-y02
	+Path=/REF/CMS_2015_I1397174/d74-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 5.672003E-9 0.0 0.0
	+4.0 0.5 0.5 -4.248421E-7 0.0 0.0
	+3.0 0.5 0.5 -1.477508E-6 0.0 0.0
	+2.0 0.5 0.5 -1.545728E-5 0.0 0.0
	+1.0 0.5 0.5 2.558405E-5 0.0 0.0
	+0.0 0.5 0.5 -8.126137E-6 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d74-x01-y03
	+Path=/REF/CMS_2015_I1397174/d74-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 -1.877839E-8 0.0 0.0
	+4.0 0.5 0.5 5.695753E-8 0.0 0.0
	+3.0 0.5 0.5 -2.92026E-6 0.0 0.0
	+2.0 0.5 0.5 1.631986E-5 0.0 0.0
	+1.0 0.5 0.5 -1.545728E-5 0.0 0.0
	+0.0 0.5 0.5 2.128729E-6 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d74-x01-y04
	+Path=/REF/CMS_2015_I1397174/d74-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 -2.429544E-8 0.0 0.0
	+4.0 0.5 0.5 -3.662879E-7 0.0 0.0
	+3.0 0.5 0.5 4.543406E-6 0.0 0.0
	+2.0 0.5 0.5 -2.92026E-6 0.0 0.0
	+1.0 0.5 0.5 -1.477508E-6 0.0 0.0
	+0.0 0.5 0.5 2.591345E-7 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d74-x01-y05
	+Path=/REF/CMS_2015_I1397174/d74-x01-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 -5.368462E-8 0.0 0.0
	+4.0 0.5 0.5 8.958488E-7 0.0 0.0
	+3.0 0.5 0.5 -3.662879E-7 0.0 0.0
	+2.0 0.5 0.5 5.695753E-8 0.0 0.0
	+1.0 0.5 0.5 -4.248421E-7 0.0 0.0
	+0.0 0.5 0.5 1.451728E-9 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d74-x01-y06
	+Path=/REF/CMS_2015_I1397174/d74-x01-y06
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 0.5 0.5 1.737393E-7 0.0 0.0
	+4.0 0.5 0.5 -5.368462E-8 0.0 0.0
	+3.0 0.5 0.5 -2.429544E-8 0.0 0.0
	+2.0 0.5 0.5 -1.877839E-8 0.0 0.0
	+1.0 0.5 0.5 5.672003E-9 0.0 0.0
	+0.0 0.5 0.5 2.389776E-8 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d75-x01-y01
	+Path=/REF/CMS_2015_I1397174/d75-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 -206.69 0.0 0.0
	+3.0 0.5 0.5 -2681.049 0.0 0.0
	+2.0 0.5 0.5 518.692 0.0 0.0
	+1.0 0.5 0.5 -32988.8 0.0 0.0
	+0.0 0.5 0.5 88999.53 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d75-x01-y02
	+Path=/REF/CMS_2015_I1397174/d75-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 1355.415 0.0 0.0
	+3.0 0.5 0.5 466.0136 0.0 0.0
	+2.0 0.5 0.5 -17433.47 0.0 0.0
	+1.0 0.5 0.5 196032.0 0.5 0.5
	+0.0 0.5 0.5 -32988.8 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d75-x01-y03
	+Path=/REF/CMS_2015_I1397174/d75-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 -26.21793 0.0 0.0
	+3.0 0.5 0.5 -2807.842 0.0 0.0
	+2.0 0.5 0.5 55726.46 0.0 0.0
	+1.0 0.5 0.5 -17433.47 0.0 0.0
	+0.0 0.5 0.5 518.692 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d75-x01-y04
	+Path=/REF/CMS_2015_I1397174/d75-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 -180.0701 0.0 0.0
	+3.0 0.5 0.5 7360.646 0.0 0.0
	+2.0 0.5 0.5 -2807.842 0.0 0.0
	+1.0 0.5 0.5 466.0136 0.0 0.0
	+0.0 0.5 0.5 -2681.049 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d75-x01-y05
	+Path=/REF/CMS_2015_I1397174/d75-x01-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 1218.146 0.0 0.0
	+3.0 0.5 0.5 -180.0701 0.0 0.0
	+2.0 0.5 0.5 -26.21793 0.0 0.0
	+1.0 0.5 0.5 1355.415 0.0 0.0
	+0.0 0.5 0.5 -206.69 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d76-x01-y01
	+Path=/REF/CMS_2015_I1397174/d76-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 -1.264296E-7 0.0 0.0
	+3.0 0.5 0.5 -2.481563E-7 0.0 0.0
	+2.0 0.5 0.5 -8.568074E-7 0.0 0.0
	+1.0 0.5 0.5 -9.89715E-6 0.0 0.0
	+0.0 0.5 0.5 1.11646E-5 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d76-x01-y02
	+Path=/REF/CMS_2015_I1397174/d76-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 4.856234E-8 0.0 0.0
	+3.0 0.5 0.5 -1.861362E-7 0.0 0.0
	+2.0 0.5 0.5 -4.083183E-6 0.0 0.0
	+1.0 0.5 0.5 1.412075E-5 0.0 0.0
	+0.0 0.5 0.5 -9.89715E-6 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d76-x01-y03
	+Path=/REF/CMS_2015_I1397174/d76-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 -2.207321E-8 0.0 0.0
	+3.0 0.5 0.5 -3.554269E-7 0.0 0.0
	+2.0 0.5 0.5 5.368993E-6 0.0 0.0
	+1.0 0.5 0.5 -4.083183E-6 0.0 0.0
	+0.0 0.5 0.5 -8.568074E-7 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d76-x01-y04
	+Path=/REF/CMS_2015_I1397174/d76-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 1.656702E-7 0.0 0.0
	+3.0 0.5 0.5 8.242375E-7 0.0 0.0
	+2.0 0.5 0.5 -3.554269E-7 0.0 0.0
	+1.0 0.5 0.5 -1.861362E-7 0.0 0.0
	+0.0 0.5 0.5 -2.481563E-7 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2015_I1397174/d76-x01-y05
	+Path=/REF/CMS_2015_I1397174/d76-x01-y05
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+4.0 0.5 0.5 1.331767E-7 0.0 0.0
	+3.0 0.5 0.5 1.656702E-7 0.0 0.0
	+2.0 0.5 0.5 -2.207321E-8 0.0 0.0
	+1.0 0.5 0.5 4.856234E-8 0.0 0.0
	+0.0 0.5 0.5 -1.264296E-7 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/CMS_2016_I1459051.yoda b/data/refdata/CMS_2016_I1459051.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/CMS_2016_I1459051.yoda
	@@ -0,0 +1,481 @@
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d08-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d08-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 5.349333e+03 7.459876e+02 7.459876e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 3.064668e+03 2.872695e+02 2.872695e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 1.777823e+03 1.964067e+02 1.964067e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 8.519472e+02 1.120843e+02 1.120843e+02
	+2.080000e+02 1.200000e+01 1.200000e+01 4.261803e+02 6.184187e+01 6.184187e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 2.535485e+02 2.325514e+01 2.325514e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 1.485225e+02 1.447419e+01 1.447419e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 8.111851e+01 8.068457e+00 8.068457e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 4.570495e+01 3.572737e+00 3.572737e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 2.864304e+01 2.298171e+00 2.298171e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 1.707655e+01 1.409458e+00 1.409458e+00
	+4.125000e+02 1.750000e+01 1.750000e+01 9.797789e+00 8.411060e-01 8.411060e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 6.292110e+00 5.167736e-01 5.167736e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 4.132791e+00 3.509635e-01 3.509635e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 2.593749e+00 2.220893e-01 2.220893e-01
	+5.700000e+02 2.200000e+01 2.200000e+01 1.598369e+00 1.408139e-01 1.408139e-01
	+6.150000e+02 2.300000e+01 2.300000e+01 1.041591e+00 9.531299e-02 9.531299e-02
	+6.620000e+02 2.400000e+01 2.400000e+01 6.574779e-01 5.977806e-02 5.977806e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 4.126620e-01 3.892076e-02 3.892076e-02
	+7.635000e+02 2.650000e+01 2.650000e+01 2.645759e-01 2.562189e-02 2.562189e-02
	+8.180000e+02 2.800000e+01 2.800000e+01 1.691189e-01 1.714684e-02 1.714684e-02
	+8.755000e+02 2.950000e+01 2.950000e+01 1.092561e-01 1.167958e-02 1.167958e-02
	+9.360000e+02 3.100000e+01 3.100000e+01 6.994366e-02 7.972677e-03 7.972677e-03
	+9.995000e+02 3.250000e+01 3.250000e+01 4.392855e-02 5.394731e-03 5.394731e-03
	+1.066500e+03 3.450000e+01 3.450000e+01 2.803895e-02 3.768607e-03 3.768607e-03
	+1.136500e+03 3.550000e+01 3.550000e+01 1.960086e-02 2.830236e-03 2.830236e-03
	+1.210000e+03 3.800000e+01 3.800000e+01 1.357665e-02 2.181339e-03 2.181339e-03
	+1.287500e+03 3.950000e+01 3.950000e+01 6.816121e-03 1.304976e-03 1.304976e-03
	+1.368500e+03 4.150000e+01 4.150000e+01 3.414207e-03 8.395095e-04 8.395095e-04
	+1.453500e+03 4.350000e+01 4.350000e+01 2.255163e-03 6.273120e-04 6.273120e-04
	+1.542500e+03 4.550000e+01 4.550000e+01 2.078894e-03 6.164632e-04 6.164632e-04
	+1.636000e+03 4.800000e+01 4.800000e+01 1.769146e-03 5.297189e-04 5.297189e-04
	+1.734000e+03 5.000000e+01 5.000000e+01 1.111309e-03 4.187156e-04 4.187156e-04
	+1.837000e+03 5.300000e+01 5.300000e+01 4.202761e-04 2.226260e-04 2.226260e-04
	+1.945000e+03 5.500000e+01 5.500000e+01 1.888823e-04 1.521694e-04 1.521694e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d09-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d09-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 5.591624e+03 7.663446e+02 7.663446e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 2.752736e+03 2.725435e+02 2.725435e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 1.383414e+03 1.605487e+02 1.605487e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 7.223568e+02 9.892092e+01 9.892092e+01
	+2.080000e+02 1.200000e+01 1.200000e+01 3.871942e+02 5.738174e+01 5.738174e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 2.458650e+02 2.306598e+01 2.306598e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 1.468734e+02 1.474898e+01 1.474898e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 7.504363e+01 7.913318e+00 7.913318e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 4.110762e+01 3.349098e+00 3.349098e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 2.460344e+01 2.072654e+00 2.072654e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 1.469676e+01 1.265702e+00 1.265702e+00
	+4.125000e+02 1.750000e+01 1.750000e+01 1.000269e+01 8.892260e-01 8.892260e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 6.449620e+00 5.579016e-01 5.579016e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 3.725526e+00 3.306663e-01 3.306663e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 2.277073e+00 2.033639e-01 2.033639e-01
	+5.700000e+02 2.200000e+01 2.200000e+01 1.435859e+00 1.330076e-01 1.330076e-01
	+6.150000e+02 2.300000e+01 2.300000e+01 9.058148e-01 8.603474e-02 8.603474e-02
	+6.620000e+02 2.400000e+01 2.400000e+01 5.708064e-01 5.399614e-02 5.399614e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 3.647552e-01 3.619814e-02 3.619814e-02
	+7.635000e+02 2.650000e+01 2.650000e+01 2.396395e-01 2.422088e-02 2.422088e-02
	+8.180000e+02 2.800000e+01 2.800000e+01 1.556954e-01 1.650145e-02 1.650145e-02
	+8.755000e+02 2.950000e+01 2.950000e+01 9.249055e-02 1.039118e-02 1.039118e-02
	+9.360000e+02 3.100000e+01 3.100000e+01 5.582966e-02 6.759939e-03 6.759939e-03
	+9.995000e+02 3.250000e+01 3.250000e+01 3.447595e-02 4.527075e-03 4.527075e-03
	+1.066500e+03 3.450000e+01 3.450000e+01 2.211067e-02 3.199404e-03 3.199404e-03
	+1.136500e+03 3.550000e+01 3.550000e+01 1.398225e-02 2.252656e-03 2.252656e-03
	+1.210000e+03 3.800000e+01 3.800000e+01 9.649750e-03 1.713413e-03 1.713413e-03
	+1.287500e+03 3.950000e+01 3.950000e+01 7.488311e-03 1.436989e-03 1.436989e-03
	+1.368500e+03 4.150000e+01 4.150000e+01 5.084757e-03 1.095949e-03 1.095949e-03
	+1.453500e+03 4.350000e+01 4.350000e+01 2.503552e-03 6.952825e-04 6.952825e-04
	+1.542500e+03 4.550000e+01 4.550000e+01 1.239137e-03 4.353192e-04 4.353192e-04
	+1.636000e+03 4.800000e+01 4.800000e+01 9.289458e-04 3.771168e-04 3.771168e-04
	+1.734000e+03 5.000000e+01 5.000000e+01 4.640058e-04 2.573742e-04 2.573742e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d10-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d10-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 4.653987e+03 7.205772e+02 7.205772e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 2.445515e+03 2.695687e+02 2.695687e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 1.260362e+03 1.666812e+02 1.666812e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 6.118203e+02 8.928204e+01 8.928204e+01
	+2.080000e+02 1.200000e+01 1.200000e+01 3.615503e+02 6.199503e+01 6.199503e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 2.003162e+02 2.151390e+01 2.151390e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 1.089087e+02 1.275462e+01 1.275462e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 5.737134e+01 6.731063e+00 6.731063e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 3.338283e+01 3.141373e+00 3.141373e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 2.179427e+01 2.090882e+00 2.090882e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 1.327045e+01 1.306369e+00 1.306369e+00
	+4.125000e+02 1.750000e+01 1.750000e+01 7.367883e+00 7.555028e-01 7.555028e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 4.460132e+00 4.405146e-01 4.405146e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 2.896842e+00 3.084504e-01 3.084504e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 1.765874e+00 1.800177e-01 1.800177e-01
	+5.700000e+02 2.200000e+01 2.200000e+01 1.115790e+00 1.194575e-01 1.194575e-01
	+6.150000e+02 2.300000e+01 2.300000e+01 7.069312e-01 7.882497e-02 7.882497e-02
	+6.620000e+02 2.400000e+01 2.400000e+01 4.035860e-01 4.366028e-02 4.366028e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 2.383066e-01 2.675139e-02 2.675139e-02
	+7.635000e+02 2.650000e+01 2.650000e+01 1.513887e-01 1.752520e-02 1.752520e-02
	+8.180000e+02 2.800000e+01 2.800000e+01 9.454945e-02 1.151746e-02 1.151746e-02
	+8.755000e+02 2.950000e+01 2.950000e+01 5.514911e-02 7.173956e-03 7.173956e-03
	+9.360000e+02 3.100000e+01 3.100000e+01 3.356394e-02 4.732863e-03 4.732863e-03
	+9.995000e+02 3.250000e+01 3.250000e+01 2.280692e-02 3.454591e-03 3.454591e-03
	+1.066500e+03 3.450000e+01 3.450000e+01 1.637021e-02 2.679955e-03 2.679955e-03
	+1.136500e+03 3.550000e+01 3.550000e+01 9.982799e-03 1.837274e-03 1.837274e-03
	+1.210000e+03 3.800000e+01 3.800000e+01 5.072365e-03 1.141277e-03 1.141277e-03
	+1.287500e+03 3.950000e+01 3.950000e+01 2.470518e-03 7.022411e-04 7.022411e-04
	+1.368500e+03 4.150000e+01 4.150000e+01 1.654246e-03 5.398295e-04 5.398295e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d11-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d11-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 3.709510e+03 6.847865e+02 6.847865e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 1.935420e+03 2.866040e+02 2.866040e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 1.071854e+03 1.792689e+02 1.792689e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 4.951906e+02 9.296393e+01 9.296393e+01
	+2.080000e+02 1.200000e+01 1.200000e+01 2.692816e+02 5.510558e+01 5.510558e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 1.521635e+02 2.311614e+01 2.311614e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 7.733121e+01 1.258380e+01 1.258380e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 4.572248e+01 7.682872e+00 7.682872e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 2.780038e+01 3.915440e+00 3.915440e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 1.610931e+01 2.328569e+00 2.328569e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 9.492320e+00 1.401092e+00 1.401092e+00
	+4.125000e+02 1.750000e+01 1.750000e+01 5.382967e+00 8.204295e-01 8.204295e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 3.101013e+00 4.656466e-01 4.656466e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 1.942202e+00 3.007790e-01 3.007790e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 1.161551e+00 1.792149e-01 1.792149e-01
	+5.700000e+02 2.200000e+01 2.200000e+01 6.578659e-01 1.049280e-01 1.049280e-01
	+6.150000e+02 2.300000e+01 2.300000e+01 3.651019e-01 6.008594e-02 6.008594e-02
	+6.620000e+02 2.400000e+01 2.400000e+01 2.187385e-01 3.647187e-02 3.647187e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 1.337425e-01 2.317806e-02 2.317806e-02
	+7.635000e+02 2.650000e+01 2.650000e+01 7.766047e-02 1.373448e-02 1.373448e-02
	+8.180000e+02 2.800000e+01 2.800000e+01 4.093636e-02 7.642407e-03 7.642407e-03
	+8.755000e+02 2.950000e+01 2.950000e+01 2.392806e-02 4.788946e-03 4.788946e-03
	+9.360000e+02 3.100000e+01 3.100000e+01 1.259160e-02 2.784685e-03 2.784685e-03
	+9.995000e+02 3.250000e+01 3.250000e+01 6.474560e-03 1.635253e-03 1.635253e-03
	+1.066500e+03 3.450000e+01 3.450000e+01 3.936939e-03 1.140156e-03 1.140156e-03
	+1.136500e+03 3.550000e+01 3.550000e+01 1.683165e-03 6.500323e-04 6.500323e-04
	+1.210000e+03 3.800000e+01 3.800000e+01 7.120324e-04 3.459130e-04 3.459130e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d12-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d12-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 2.504885e+03 5.548265e+02 5.548265e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 1.773248e+03 2.905186e+02 2.905186e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 9.444769e+02 1.719123e+02 1.719123e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 4.142963e+02 8.829265e+01 8.829265e+01
	+2.080000e+02 1.200000e+01 1.200000e+01 1.911738e+02 4.589101e+01 4.589101e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 1.019460e+02 1.790971e+01 1.790971e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 5.400291e+01 1.016651e+01 1.016651e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 3.177874e+01 6.096565e+00 6.096565e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 1.816977e+01 2.987190e+00 2.987190e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 8.927706e+00 1.537455e+00 1.537455e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 4.780310e+00 8.579006e-01 8.579006e-01
	+4.125000e+02 1.750000e+01 1.750000e+01 2.852018e+00 5.349464e-01 5.349464e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 1.517434e+00 2.802943e-01 2.802943e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 7.661462e-01 1.552894e-01 1.552894e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 4.323490e-01 8.636733e-02 8.636733e-02
	+5.700000e+02 2.200000e+01 2.200000e+01 2.614012e-01 5.558091e-02 5.558091e-02
	+6.150000e+02 2.300000e+01 2.300000e+01 1.184682e-01 2.581683e-02 2.581683e-02
	+6.620000e+02 2.400000e+01 2.400000e+01 5.025679e-02 1.114535e-02 1.114535e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 2.589662e-02 6.192840e-03 6.192840e-03
	+7.635000e+02 2.650000e+01 2.650000e+01 1.374945e-02 3.513097e-03 3.513097e-03
	+8.180000e+02 2.800000e+01 2.800000e+01 6.587821e-03 1.943082e-03 1.943082e-03
	+8.755000e+02 2.950000e+01 2.950000e+01 2.727123e-03 9.953932e-04 9.953932e-04
	+9.360000e+02 3.100000e+01 3.100000e+01 1.422214e-03 6.397867e-04 6.397867e-04
	+9.995000e+02 3.250000e+01 3.250000e+01 8.552332e-04 4.647686e-04 4.647686e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d13-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d13-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 2.070681e+03 6.556184e+02 6.556184e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 1.112424e+03 3.096399e+02 3.096399e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 5.100095e+02 1.537402e+02 1.537402e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 2.576865e+02 8.673118e+01 8.673118e+01
	+2.080000e+02 1.200000e+01 1.200000e+01 1.169219e+02 4.176108e+01 4.176108e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 5.397857e+01 1.635927e+01 1.635927e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 2.921325e+01 9.241137e+00 9.241137e+00
	+2.860000e+02 1.400000e+01 1.400000e+01 1.848780e+01 6.238231e+00 6.238231e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 7.600512e+00 2.254216e+00 2.254216e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 2.893158e+00 9.123120e-01 9.123120e-01
	+3.785000e+02 1.650000e+01 1.650000e+01 1.509144e+00 4.903074e-01 4.903074e-01
	+4.125000e+02 1.750000e+01 1.750000e+01 8.400111e-01 2.859685e-01 2.859685e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 3.000366e-01 1.005292e-01 1.005292e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 1.129489e-01 4.096867e-02 4.096867e-02
	+5.275000e+02 2.050000e+01 2.050000e+01 5.649333e-02 2.073421e-02 2.073421e-02
	+5.700000e+02 2.200000e+01 2.200000e+01 2.035675e-02 8.842851e-03 8.842851e-03
	+6.150000e+02 2.300000e+01 2.300000e+01 4.562913e-03 2.528683e-03 2.528683e-03
	+6.620000e+02 2.400000e+01 2.400000e+01 1.492714e-03 8.928782e-04 8.928782e-04
	+7.115000e+02 2.550000e+01 2.550000e+01 5.574281e-04 4.626537e-04 4.626537e-04
	+7.635000e+02 2.650000e+01 2.650000e+01 7.210948e-05 1.189087e-04 1.189087e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d14-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d14-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 2.547196e+02 1.813409e+02 1.813409e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 1.259140e+02 7.744540e+01 7.744540e+01
	+1.635000e+02 1.050000e+01 1.050000e+01 4.402723e+01 3.276009e+01 3.276009e+01
	+1.850000e+02 1.100000e+01 1.100000e+01 1.489167e+01 1.403686e+01 1.403686e+01
	+2.080000e+02 1.200000e+01 1.200000e+01 5.859141e+00 4.098782e+00 4.098782e+00
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d01-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 8.189417e+03 9.321203e+02 9.321203e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 4.419657e+03 3.795033e+02 3.795033e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 2.394082e+03 2.356685e+02 2.356685e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 1.230380e+03 1.415349e+02 1.415349e+02
	+2.080000e+02 1.200000e+01 1.200000e+01 5.962532e+02 7.646068e+01 7.646068e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 3.363686e+02 2.909431e+01 2.909431e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 2.081755e+02 1.901679e+01 1.901679e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 1.133712e+02 1.048212e+01 1.048212e+01
	+3.150000e+02 1.500000e+01 1.500000e+01 6.179289e+01 4.721297e+00 4.721297e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 3.693404e+01 2.904638e+00 2.904638e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 2.256299e+01 1.822000e+00 1.822000e+00
	+4.125000e+02 1.750000e+01 1.750000e+01 1.339611e+01 1.119190e+00 1.119190e+00
	+4.490000e+02 1.900000e+01 1.900000e+01 8.533224e+00 6.927613e-01 6.927613e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 5.377614e+00 4.518139e-01 4.518139e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 3.299870e+00 2.801786e-01 2.801786e-01
	+5.700000e+02 2.200000e+01 2.200000e+01 1.977009e+00 1.718774e-01 1.718774e-01
	+6.150000e+02 2.300000e+01 2.300000e+01 1.312961e+00 1.174293e-01 1.174293e-01
	+6.620000e+02 2.400000e+01 2.400000e+01 8.625319e-01 7.780853e-02 7.780853e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 5.488639e-01 5.151809e-02 5.151809e-02
	+7.635000e+02 2.650000e+01 2.650000e+01 3.435918e-01 3.292859e-02 3.292859e-02
	+8.180000e+02 2.800000e+01 2.800000e+01 2.148947e-01 2.152791e-02 2.152791e-02
	+8.755000e+02 2.950000e+01 2.950000e+01 1.341241e-01 1.414349e-02 1.414349e-02
	+9.360000e+02 3.100000e+01 3.100000e+01 8.838111e-02 9.843542e-03 9.843542e-03
	+9.995000e+02 3.250000e+01 3.250000e+01 5.909044e-02 7.024072e-03 7.024072e-03
	+1.066500e+03 3.450000e+01 3.450000e+01 3.577869e-02 4.618039e-03 4.618039e-03
	+1.136500e+03 3.550000e+01 3.550000e+01 2.466286e-02 3.431722e-03 3.431722e-03
	+1.210000e+03 3.800000e+01 3.800000e+01 1.700107e-02 2.602381e-03 2.602381e-03
	+1.287500e+03 3.950000e+01 3.950000e+01 8.466715e-03 1.533562e-03 1.533562e-03
	+1.368500e+03 4.150000e+01 4.150000e+01 4.336915e-03 9.870813e-04 9.870813e-04
	+1.453500e+03 4.350000e+01 4.350000e+01 2.873000e-03 7.384531e-04 7.384531e-04
	+1.542500e+03 4.550000e+01 4.550000e+01 2.554812e-03 7.041408e-04 7.041408e-04
	+1.636000e+03 4.800000e+01 4.800000e+01 2.065235e-03 5.895186e-04 5.895186e-04
	+1.734000e+03 5.000000e+01 5.000000e+01 1.289849e-03 4.568461e-04 4.568461e-04
	+1.837000e+03 5.300000e+01 5.300000e+01 3.854719e-04 2.206452e-04 2.206452e-04
	+1.945000e+03 5.500000e+01 5.500000e+01 2.159436e-04 1.324747e-04 1.324747e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d02-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 8.743649e+03 1.005084e+03 1.005084e+03
	+1.430000e+02 1.000000e+01 1.000000e+01 4.041416e+03 3.563952e+02 3.563952e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 1.852153e+03 1.948766e+02 1.948766e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 9.906291e+02 1.162181e+02 1.162181e+02
	+2.080000e+02 1.200000e+01 1.200000e+01 6.004697e+02 7.689599e+01 7.689599e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 3.365950e+02 2.960856e+01 2.960856e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 1.870092e+02 1.766594e+01 1.766594e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 1.021450e+02 9.710969e+00 9.710969e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 5.590632e+01 4.443624e+00 4.443624e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 3.204626e+01 2.624570e+00 2.624570e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 1.941044e+01 1.630918e+00 1.630918e+00
	+4.125000e+02 1.750000e+01 1.750000e+01 1.299248e+01 1.121395e+00 1.121395e+00
	+4.490000e+02 1.900000e+01 1.900000e+01 8.270603e+00 7.052656e-01 7.052656e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 4.831749e+00 4.223558e-01 4.223558e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 2.924148e+00 2.576303e-01 2.576303e-01
	+5.700000e+02 2.200000e+01 2.200000e+01 1.856421e+00 1.705410e-01 1.705410e-01
	+6.150000e+02 2.300000e+01 2.300000e+01 1.169093e+00 1.099321e-01 1.099321e-01
	+6.620000e+02 2.400000e+01 2.400000e+01 7.107702e-01 6.680354e-02 6.680354e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 4.503694e-01 4.384830e-02 4.384830e-02
	+7.635000e+02 2.650000e+01 2.650000e+01 2.936668e-01 2.939353e-02 2.939353e-02
	+8.180000e+02 2.800000e+01 2.800000e+01 1.874668e-01 1.959529e-02 1.959529e-02
	+8.755000e+02 2.950000e+01 2.950000e+01 1.183909e-01 1.302369e-02 1.302369e-02
	+9.360000e+02 3.100000e+01 3.100000e+01 7.160440e-02 8.410571e-03 8.410571e-03
	+9.995000e+02 3.250000e+01 3.250000e+01 4.403936e-02 5.551180e-03 5.551180e-03
	+1.066500e+03 3.450000e+01 3.450000e+01 2.952438e-02 4.036461e-03 4.036461e-03
	+1.136500e+03 3.550000e+01 3.550000e+01 1.782971e-02 2.700725e-03 2.700725e-03
	+1.210000e+03 3.800000e+01 3.800000e+01 1.084284e-02 1.855179e-03 1.855179e-03
	+1.287500e+03 3.950000e+01 3.950000e+01 7.957768e-03 1.484181e-03 1.484181e-03
	+1.368500e+03 4.150000e+01 4.150000e+01 6.406217e-03 1.269275e-03 1.269275e-03
	+1.453500e+03 4.350000e+01 4.350000e+01 3.714827e-03 8.899165e-04 8.899165e-04
	+1.542500e+03 4.550000e+01 4.550000e+01 1.410744e-03 4.657840e-04 4.657840e-04
	+1.636000e+03 4.800000e+01 4.800000e+01 7.923702e-04 3.308724e-04 3.308724e-04
	+1.734000e+03 5.000000e+01 5.000000e+01 5.678964e-04 2.862263e-04 2.862263e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d03-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d03-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 7.166225e+03 8.617168e+02 8.617168e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 3.843291e+03 3.762828e+02 3.762828e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 1.826735e+03 2.065746e+02 2.065746e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 7.453094e+02 9.704408e+01 9.704408e+01
	+2.080000e+02 1.200000e+01 1.200000e+01 3.924276e+02 5.714668e+01 5.714668e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 2.443700e+02 2.513225e+01 2.513225e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 1.538877e+02 1.619217e+01 1.619217e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 9.023099e+01 9.600365e+00 9.600365e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 4.650985e+01 4.279070e+00 4.279070e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 2.620885e+01 2.459091e+00 2.459091e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 1.659956e+01 1.597714e+00 1.597714e+00
	+4.125000e+02 1.750000e+01 1.750000e+01 1.007887e+01 9.909964e-01 9.909964e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 5.907590e+00 5.778259e-01 5.778259e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 3.540140e+00 3.603907e-01 3.603907e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 2.180995e+00 2.197612e-01 2.197612e-01
	+5.700000e+02 2.200000e+01 2.200000e+01 1.387115e+00 1.441683e-01 1.441683e-01
	+6.150000e+02 2.300000e+01 2.300000e+01 8.602038e-01 9.255594e-02 9.255594e-02
	+6.620000e+02 2.400000e+01 2.400000e+01 4.949638e-01 5.307867e-02 5.307867e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 2.914058e-01 3.213914e-02 3.213914e-02
	+7.635000e+02 2.650000e+01 2.650000e+01 1.879552e-01 2.140731e-02 2.140731e-02
	+8.180000e+02 2.800000e+01 2.800000e+01 1.160837e-01 1.380664e-02 1.380664e-02
	+8.755000e+02 2.950000e+01 2.950000e+01 6.620399e-02 8.349123e-03 8.349123e-03
	+9.360000e+02 3.100000e+01 3.100000e+01 3.961504e-02 5.354188e-03 5.354188e-03
	+9.995000e+02 3.250000e+01 3.250000e+01 2.665367e-02 3.853739e-03 3.853739e-03
	+1.066500e+03 3.450000e+01 3.450000e+01 1.933950e-02 2.974210e-03 2.974210e-03
	+1.136500e+03 3.550000e+01 3.550000e+01 1.220764e-02 2.090993e-03 2.090993e-03
	+1.210000e+03 3.800000e+01 3.800000e+01 5.488331e-03 1.142123e-03 1.142123e-03
	+1.287500e+03 3.950000e+01 3.950000e+01 2.665987e-03 6.802063e-04 6.802063e-04
	+1.368500e+03 4.150000e+01 4.150000e+01 2.041374e-03 5.883609e-04 5.883609e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d04-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d04-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 5.457292e+03 8.733014e+02 8.733014e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 3.251243e+03 4.537130e+02 4.537130e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 1.487919e+03 2.302875e+02 2.302875e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 6.373289e+02 1.114889e+02 1.114889e+02
	+2.080000e+02 1.200000e+01 1.200000e+01 3.447847e+02 6.594147e+01 6.594147e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 1.899331e+02 2.781482e+01 2.781482e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 1.079765e+02 1.693323e+01 1.693323e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 5.662039e+01 9.023954e+00 9.023954e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 3.364888e+01 4.699141e+00 4.699141e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 2.096000e+01 2.992080e+00 2.992080e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 1.181032e+01 1.727851e+00 1.727851e+00
	+4.125000e+02 1.750000e+01 1.750000e+01 6.456684e+00 9.737958e-01 9.737958e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 3.837383e+00 5.722821e-01 5.722821e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 2.418710e+00 3.754023e-01 3.754023e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 1.414665e+00 2.174105e-01 2.174105e-01
	+5.700000e+02 2.200000e+01 2.200000e+01 8.378774e-01 1.327521e-01 1.327521e-01
	+6.150000e+02 2.300000e+01 2.300000e+01 4.868706e-01 7.946103e-02 7.946103e-02
	+6.620000e+02 2.400000e+01 2.400000e+01 2.716668e-01 4.490532e-02 4.490532e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 1.578503e-01 2.718262e-02 2.718262e-02
	+7.635000e+02 2.650000e+01 2.650000e+01 9.596344e-02 1.682129e-02 1.682129e-02
	+8.180000e+02 2.800000e+01 2.800000e+01 5.368804e-02 9.897390e-03 9.897390e-03
	+8.755000e+02 2.950000e+01 2.950000e+01 2.793420e-02 5.518171e-03 5.518171e-03
	+9.360000e+02 3.100000e+01 3.100000e+01 1.512076e-02 3.284367e-03 3.284367e-03
	+9.995000e+02 3.250000e+01 3.250000e+01 8.361527e-03 2.031715e-03 2.031715e-03
	+1.066500e+03 3.450000e+01 3.450000e+01 5.061764e-03 1.388748e-03 1.388748e-03
	+1.136500e+03 3.550000e+01 3.550000e+01 2.383007e-03 8.382779e-04 8.382779e-04
	+1.210000e+03 3.800000e+01 3.800000e+01 9.439647e-04 4.334696e-04 4.334696e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d05-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d05-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 3.612545e+03 7.419047e+02 7.419047e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 2.252004e+03 3.527572e+02 3.527572e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 1.251506e+03 2.187778e+02 2.187778e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 5.874578e+02 1.156478e+02 1.156478e+02
	+2.080000e+02 1.200000e+01 1.200000e+01 2.859510e+02 6.455028e+01 6.455028e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 1.344312e+02 2.257325e+01 2.257325e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 6.886325e+01 1.279001e+01 1.279001e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 3.124422e+01 5.731954e+00 5.731954e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 2.100884e+01 3.431989e+00 3.431989e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 1.267035e+01 2.141112e+00 2.141112e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 6.271997e+00 1.105647e+00 1.105647e+00
	+4.125000e+02 1.750000e+01 1.750000e+01 3.640268e+00 6.753391e-01 6.753391e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 1.932699e+00 3.525945e-01 3.525945e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 9.558208e-01 1.893044e-01 1.893044e-01
	+5.275000e+02 2.050000e+01 2.050000e+01 4.881366e-01 9.517194e-02 9.517194e-02
	+5.700000e+02 2.200000e+01 2.200000e+01 2.920254e-01 6.164616e-02 6.164616e-02
	+6.150000e+02 2.300000e+01 2.300000e+01 1.311035e-01 2.852452e-02 2.852452e-02
	+6.620000e+02 2.400000e+01 2.400000e+01 6.261501e-02 1.396065e-02 1.396065e-02
	+7.115000e+02 2.550000e+01 2.550000e+01 3.800097e-02 9.936837e-03 9.936837e-03
	+7.635000e+02 2.650000e+01 2.650000e+01 1.900858e-02 4.695956e-03 4.695956e-03
	+8.180000e+02 2.800000e+01 2.800000e+01 8.749591e-03 2.529349e-03 2.529349e-03
	+8.755000e+02 2.950000e+01 2.950000e+01 2.526664e-03 9.423273e-04 9.423273e-04
	+9.360000e+02 3.100000e+01 3.100000e+01 1.498447e-03 6.934283e-04 6.934283e-04
	+9.995000e+02 3.250000e+01 3.250000e+01 1.111701e-03 5.685206e-04 5.685206e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d06-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d06-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 3.311825e+03 9.968211e+02 9.968211e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 1.478185e+03 4.016950e+02 4.016950e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 6.999442e+02 2.079579e+02 2.079579e+02
	+1.850000e+02 1.100000e+01 1.100000e+01 3.122140e+02 1.012159e+02 1.012159e+02
	+2.080000e+02 1.200000e+01 1.200000e+01 1.439716e+02 5.188412e+01 5.188412e+01
	+2.325000e+02 1.250000e+01 1.250000e+01 7.298935e+01 2.155508e+01 2.155508e+01
	+2.585000e+02 1.350000e+01 1.350000e+01 3.813035e+01 1.197656e+01 1.197656e+01
	+2.860000e+02 1.400000e+01 1.400000e+01 1.853291e+01 6.218958e+00 6.218958e+00
	+3.150000e+02 1.500000e+01 1.500000e+01 8.292831e+00 2.452819e+00 2.452819e+00
	+3.460000e+02 1.600000e+01 1.600000e+01 3.809844e+00 1.183984e+00 1.183984e+00
	+3.785000e+02 1.650000e+01 1.650000e+01 1.682632e+00 5.417504e-01 5.417504e-01
	+4.125000e+02 1.750000e+01 1.750000e+01 8.807414e-01 2.980287e-01 2.980287e-01
	+4.490000e+02 1.900000e+01 1.900000e+01 3.454012e-01 1.149877e-01 1.149877e-01
	+4.875000e+02 1.950000e+01 1.950000e+01 1.130397e-01 4.120612e-02 4.120612e-02
	+5.275000e+02 2.050000e+01 2.050000e+01 5.886082e-02 2.147827e-02 2.147827e-02
	+5.700000e+02 2.200000e+01 2.200000e+01 3.254388e-02 1.318687e-02 1.318687e-02
	+6.150000e+02 2.300000e+01 2.300000e+01 7.256611e-03 3.748273e-03 3.748273e-03
	+6.620000e+02 2.400000e+01 2.400000e+01 1.801518e-03 1.012944e-03 1.012944e-03
	+7.115000e+02 2.550000e+01 2.550000e+01 6.730899e-04 5.230248e-04 5.230248e-04
	+7.635000e+02 2.650000e+01 2.650000e+01 8.026697e-05 1.329144e-04 1.329144e-04
	+END YODA_SCATTER2D
	+
	+BEGIN YODA_SCATTER2D /REF/CMS_2016_I1459051/d07-x01-y01
	+IsRef=1
	+Path=/REF/CMS_2016_I1459051/d07-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.235000e+02 9.500000e+00 9.500000e+00 3.866285e+02 2.429858e+02 2.429858e+02
	+1.430000e+02 1.000000e+01 1.000000e+01 2.189378e+02 1.259266e+02 1.259266e+02
	+1.635000e+02 1.050000e+01 1.050000e+01 9.852430e+01 6.292727e+01 6.292727e+01
	+1.850000e+02 1.100000e+01 1.100000e+01 2.476665e+01 1.760192e+01 1.760192e+01
	+2.080000e+02 1.200000e+01 1.200000e+01 7.367668e+00 4.960204e+00 4.960204e+00
	+END YODA_SCATTER2D
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	diff --git a/data/refdata/CMS_2016_I1473674.yoda b/data/refdata/CMS_2016_I1473674.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/CMS_2016_I1473674.yoda
	@@ -0,0 +1,138 @@
	+# BEGIN YODA_SCATTER2D /REF/CMS_2016_I1473674/d01-x01-y01
	+Path=/REF/CMS_2016_I1473674/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+13.5 13.5 13.5 0.00644 2.946882357746912E-4 2.946882357746912E-4
	+39.5 12.5 12.5 0.0132 3.779904760704957E-4 3.779904760704957E-4
	+69.5 17.5 17.5 0.00875 1.7382354558574624E-4 1.7382354558574624E-4
	+108.5 21.5 21.5 0.00314 1.9006728913729474E-4 1.9006728913729474E-4
	+151.0 21.0 21.0 8.93E-4 1.0760927900975826E-4 1.0760927900975826E-4
	+236.0 64.0 64.0 1.32E-4 2.514799204708002E-5 2.514799204708002E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2016_I1473674/d02-x01-y01
	+Path=/REF/CMS_2016_I1473674/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+152.5 32.5 32.5 0.00248 1.7269420835685256E-4 1.7269420835685256E-4
	+200.0 15.0 15.0 0.00486 2.758237328440031E-4 2.758237328440031E-4
	+231.0 16.0 16.0 0.00489 2.2435456425042927E-4 2.2435456425042927E-4
	+265.0 18.0 18.0 0.00405 1.2337552431499531E-4 1.2337552431499531E-4
	+303.0 20.0 20.0 0.00299 9.273821326723951E-5 9.273821326723951E-5
	+344.0 21.0 21.0 0.00206 1.13524504843668E-4 1.13524504843668E-4
	+387.0 22.0 22.0 0.00137 9.707685048455167E-5 9.707685048455167E-5
	+433.5 24.5 24.5 8.93E-4 8.36279123857579E-5 8.36279123857579E-5
	+485.0 27.0 27.0 5.49E-4 5.474881683653082E-5 5.474881683653082E-5
	+541.0 29.0 29.0 3.38E-4 4.419406548395384E-5 4.419406548395384E-5
	+599.5 29.5 29.5 2.04E-4 2.072784561887704E-5 2.072784561887704E-5
	+660.0 31.0 31.0 1.25E-4 1.7714753738056873E-5 1.7714753738056873E-5
	+730.0 39.0 39.0 7.2E-5 8.856000000000001E-6 8.856000000000001E-6
	+884.5 115.5 115.5 2.51E-5 4.332931801909649E-6 4.332931801909649E-6
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2016_I1473674/d03-x01-y01
	+Path=/REF/CMS_2016_I1473674/d03-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+211.5 65.5 65.5 0.00131 1.1115718600252526E-4 1.1115718600252526E-4
	+298.0 21.0 21.0 0.00412 2.797355608427359E-4 2.797355608427359E-4
	+340.0 21.0 21.0 0.00405 1.748549684738755E-4 1.748549684738755E-4
	+384.5 23.5 23.5 0.00318 6.413911009672647E-5 6.413911009672647E-5
	+433.5 25.5 25.5 0.00221 1.0155160416753642E-4 1.0155160416753642E-4
	+486.5 27.5 27.5 0.00144 1.1752552743978645E-4 1.1752552743978645E-4
	+543.5 29.5 29.5 8.96E-4 9.014045005434573E-5 9.014045005434573E-5
	+605.0 32.0 32.0 5.42E-4 5.997371437554956E-5 5.997371437554956E-5
	+671.0 34.0 34.0 3.25E-4 3.5998793382556595E-5 3.5998793382556595E-5
	+739.5 34.5 34.5 1.95E-4 2.360708368265763E-5 2.360708368265763E-5
	+814.0 40.0 40.0 1.13E-4 1.3728918711974371E-5 1.3728918711974371E-5
	+897.0 43.0 43.0 6.32E-5 6.485009865836751E-6 6.485009865836751E-6
	+1070.0 130.0 130.0 2.26E-5 3.2223035300852716E-6 3.2223035300852716E-6
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2016_I1473674/d04-x01-y01
	+Path=/REF/CMS_2016_I1473674/d04-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+13.5 13.5 13.5 0.00358 1.4378057309664613E-4 1.4378057309664613E-4
	+39.5 12.5 12.5 0.00856 3.0241887602462913E-4 3.0241887602462913E-4
	+65.0 13.0 13.0 0.00933 2.451873586239715E-4 2.451873586239715E-4
	+91.5 13.5 13.5 0.00706 1.5029013865187562E-4 1.5029013865187562E-4
	+119.5 14.5 14.5 0.00428 1.8284168014979515E-4 1.8284168014979515E-4
	+150.0 16.0 16.0 0.0022 1.3721370193971156E-4 1.3721370193971156E-4
	+183.0 17.0 17.0 0.00102 8.321599846183424E-5 8.321599846183424E-5
	+218.5 18.5 18.5 4.56E-4 4.624523499778112E-5 4.624523499778112E-5
	+268.5 31.5 31.5 1.63E-4 2.1710841278034344E-5 2.1710841278034344E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2016_I1473674/d05-x01-y01
	+Path=/REF/CMS_2016_I1473674/d05-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+13.5 13.5 13.5 0.0059 6.499328704566341E-4 6.499328704566341E-4
	+39.5 12.5 12.5 0.0132 5.169885785972452E-4 5.169885785972452E-4
	+69.5 17.5 17.5 0.00922 3.6146633425534943E-4 3.6146633425534943E-4
	+108.5 21.5 21.5 0.0032 2.7576221641116826E-4 2.7576221641116826E-4
	+151.0 21.0 21.0 8.46E-4 1.1019327804707508E-4 1.1019327804707508E-4
	+236.0 64.0 64.0 1.18E-4 2.2472417671447813E-5 2.2472417671447813E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2016_I1473674/d06-x01-y01
	+Path=/REF/CMS_2016_I1473674/d06-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+152.5 32.5 32.5 0.0021 1.916327957318371E-4 1.916327957318371E-4
	+200.0 15.0 15.0 0.00426 2.613311227159903E-4 2.613311227159903E-4
	+231.0 16.0 16.0 0.00452 1.871023412360198E-4 1.871023412360198E-4
	+265.0 18.0 18.0 0.00399 1.1741723297710605E-4 1.1741723297710605E-4
	+303.0 20.0 20.0 0.00312 1.256225294443636E-4 1.256225294443636E-4
	+344.0 21.0 21.0 0.00228 1.0308928665967187E-4 1.0308928665967187E-4
	+387.0 22.0 22.0 0.0016 9.306665138490801E-5 9.306665138490801E-5
	+433.5 24.5 24.5 0.00107 8.465512448162841E-5 8.465512448162841E-5
	+485.0 27.0 27.0 6.83E-4 5.881835637154442E-5 5.881835637154442E-5
	+541.0 29.0 29.0 4.26E-4 3.840150766259054E-5 3.840150766259054E-5
	+599.5 29.5 29.5 2.66E-4 2.6390699062359072E-5 2.6390699062359072E-5
	+660.0 31.0 31.0 1.64E-4 1.596474086980431E-5 1.596474086980431E-5
	+730.0 39.0 39.0 9.93E-5 1.0967148928728013E-5 1.0967148928728013E-5
	+884.5 115.5 115.5 3.78E-5 4.1787382832620665E-6 4.1787382832620665E-6
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2016_I1473674/d07-x01-y01
	+Path=/REF/CMS_2016_I1473674/d07-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+211.5 65.5 65.5 0.0011 6.991328629094759E-5 6.991328629094759E-5
	+298.0 21.0 21.0 0.00361 2.1094296044428694E-4 2.1094296044428694E-4
	+340.0 21.0 21.0 0.00382 1.5797258871082665E-4 1.5797258871082665E-4
	+384.5 23.5 23.5 0.00324 2.9899425011193776E-5 2.9899425011193776E-5
	+433.5 25.5 25.5 0.00241 6.846436316800149E-5 6.846436316800149E-5
	+486.5 27.5 27.5 0.00166 1.0170111623772868E-4 1.0170111623772868E-4
	+543.5 29.5 29.5 0.00107 9.658260034291891E-5 9.658260034291891E-5
	+605.0 32.0 32.0 6.65E-4 6.402938263797331E-5 6.402938263797331E-5
	+671.0 34.0 34.0 4.03E-4 4.040144846029656E-5 4.040144846029656E-5
	+739.5 34.5 34.5 2.43E-4 2.6788796561435903E-5 2.6788796561435903E-5
	+814.0 40.0 40.0 1.44E-4 1.3451819945271345E-5 1.3451819945271345E-5
	+897.0 43.0 43.0 8.21E-5 7.3730188288108965E-6 7.3730188288108965E-6
	+1070.0 130.0 130.0 3.15E-5 2.936266379264661E-6 2.936266379264661E-6
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/CMS_2016_I1473674/d08-x01-y01
	+Path=/REF/CMS_2016_I1473674/d08-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+13.5 13.5 13.5 0.00361 1.6003175196191536E-4 1.6003175196191536E-4
	+39.5 12.5 12.5 0.00856 3.6966912773451886E-4 3.6966912773451886E-4
	+65.0 13.0 13.0 0.00923 2.3287419870822958E-4 2.3287419870822958E-4
	+91.5 13.5 13.5 0.00702 1.157768059673439E-4 1.157768059673439E-4
	+119.5 14.5 14.5 0.00429 1.8571290585201665E-4 1.8571290585201665E-4
	+150.0 16.0 16.0 0.00222 1.580922151783572E-4 1.580922151783572E-4
	+183.0 17.0 17.0 0.00104 1.0008285879210286E-4 1.0008285879210286E-4
	+218.5 18.5 18.5 4.66E-4 6.0738161843770014E-5 6.0738161843770014E-5
	+268.5 31.5 31.5 1.69E-4 2.704E-5 2.704E-5
	+# END YODA_SCATTER2D
	diff --git a/data/refdata/D0_1995_I398175.yoda b/data/refdata/D0_1995_I398175.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/D0_1995_I398175.yoda
	@@ -0,0 +1,102 @@
	+# BEGIN YODA_SCATTER2D /REF/D0_1995_I398175/d01-x01-y01
	+Path=/REF/D0_1995_I398175/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.05 0.05 0.33 0.041 0.041
	+0.2 0.05 0.05 0.55 0.043 0.043
	+0.3 0.05 0.05 0.67 0.038 0.038
	+0.4 0.05 0.05 0.75 0.03 0.03
	+0.5 0.05 0.05 0.81 0.027 0.027
	+0.6 0.05 0.05 0.85 0.02 0.02
	+0.7 0.05 0.05 0.89 0.017 0.017
	+0.8 0.05 0.05 0.92 0.015 0.015
	+0.9 0.05 0.05 0.96 0.01 0.01
	+1.0 0.05 0.05 1.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/D0_1995_I398175/d02-x01-y01
	+Path=/REF/D0_1995_I398175/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.05 0.05 0.42 0.03 0.03
	+0.2 0.05 0.05 0.63 0.036 0.036
	+0.3 0.05 0.05 0.74 0.028 0.028
	+0.4 0.05 0.05 0.81 0.024 0.024
	+0.5 0.05 0.05 0.86 0.02 0.02
	+0.6 0.05 0.05 0.89 0.016 0.016
	+0.7 0.05 0.05 0.93 0.011 0.011
	+0.8 0.05 0.05 0.95 0.008 0.008
	+0.9 0.05 0.05 0.98 0.004 0.004
	+1.0 0.05 0.05 1.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/D0_1995_I398175/d03-x01-y01
	+Path=/REF/D0_1995_I398175/d03-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.05 0.05 0.49 0.038 0.038
	+0.2 0.05 0.05 0.7 0.041 0.041
	+0.3 0.05 0.05 0.8 0.032 0.032
	+0.4 0.05 0.05 0.85 0.027 0.027
	+0.5 0.05 0.05 0.89 0.02 0.02
	+0.6 0.05 0.05 0.92 0.015 0.015
	+0.7 0.05 0.05 0.95 0.012 0.012
	+0.8 0.05 0.05 0.97 0.007 0.007
	+0.9 0.05 0.05 0.98 0.006 0.006
	+1.0 0.05 0.05 1.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/D0_1995_I398175/d04-x01-y01
	+Path=/REF/D0_1995_I398175/d04-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.05 0.05 0.55 0.036 0.036
	+0.2 0.05 0.05 0.73 0.038 0.038
	+0.3 0.05 0.05 0.83 0.027 0.027
	+0.4 0.05 0.05 0.88 0.027 0.027
	+0.5 0.05 0.05 0.92 0.015 0.015
	+0.6 0.05 0.05 0.94 0.012 0.012
	+0.7 0.05 0.05 0.96 0.01 0.01
	+0.8 0.05 0.05 0.98 0.007 0.007
	+0.9 0.05 0.05 0.99 0.004 0.004
	+1.0 0.05 0.05 1.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/D0_1995_I398175/d05-x01-y01
	+Path=/REF/D0_1995_I398175/d05-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.05 0.05 0.49 0.028 0.028
	+0.2 0.05 0.05 0.67 0.026 0.026
	+0.3 0.05 0.05 0.76 0.018 0.018
	+0.4 0.05 0.05 0.82 0.014 0.014
	+0.5 0.05 0.05 0.86 0.012 0.012
	+0.6 0.05 0.05 0.9 0.01 0.01
	+0.7 0.05 0.05 0.93 0.007 0.007
	+0.8 0.05 0.05 0.96 0.005 0.005
	+0.9 0.05 0.05 0.98 0.003 0.003
	+1.0 0.05 0.05 1.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/D0_1995_I398175/d06-x01-y01
	+Path=/REF/D0_1995_I398175/d06-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.05 0.05 0.59 0.039 0.039
	+0.2 0.05 0.05 0.75 0.035 0.035
	+0.3 0.05 0.05 0.82 0.031 0.031
	+0.4 0.05 0.05 0.86 0.03 0.03
	+0.5 0.05 0.05 0.88 0.025 0.025
	+0.6 0.05 0.05 0.91 0.022 0.022
	+0.7 0.05 0.05 0.94 0.018 0.018
	+0.8 0.05 0.05 0.96 0.008 0.008
	+0.9 0.05 0.05 0.98 0.006 0.006
	+1.0 0.05 0.05 1.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/DELPHI_2011_I890503.yoda b/data/refdata/DELPHI_2011_I890503.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/DELPHI_2011_I890503.yoda
	@@ -0,0 +1,26 @@
	+BEGIN YODA_SCATTER2D /REF/DELPHI_2011_I890503/d01-x01-y01
	+IsRef=1
	+Path=/REF/DELPHI_2011_I890503/d01-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.000000e-01 1.000000e-01 1.000000e-01 1.940000e-01 2.000000e-02 2.000000e-02
	+3.600000e-01 6.000000e-02 6.000000e-02 4.740000e-01 3.200000e-02 3.200000e-02
	+4.800000e-01 6.000000e-02 6.000000e-02 7.340000e-01 3.800000e-02 3.800000e-02
	+5.900000e-01 5.000000e-02 5.000000e-02 1.112000e-00 5.000000e-02 5.000000e-02
	+6.850000e-01 4.500000e-02 4.500000e-02 1.753000e-00 6.000000e-02 6.000000e-02
	+7.650000e-01 3.500000e-02 3.500000e-02 2.641000e-00 7.000000e-02 7.000000e-02
	+8.400000e-01 4.000000e-02 4.000000e-02 3.013000e-00 1.220000e-01 1.220000e-02
	+9.100000e-01 3.000000e-02 3.000000e-02 1.787000e-00 1.220000e-01 1.220000e-02
	+9.700000e-01 3.000000e-02 3.000000e-02 2.270000e-01 4.900000e-02 4.900000e-02
	+END YODA_SCATTER2D
	+
	+
	+BEGIN YODA_SCATTER2D /REF/DELPHI_2011_I890503/d02-x01-y01
	+IsRef=1
	+Path=/REF/DELPHI_2011_I890503/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+9.100000e+01 5.000000e-01 5.000000e-01 6.990000e-01 1.100000e-02 1.100000e-02
	+END YODA_SCATTER2D
	diff --git a/data/refdata/L3_1992_I336180.yoda b/data/refdata/L3_1992_I336180.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/L3_1992_I336180.yoda
	@@ -0,0 +1,27 @@
	+# BEGIN YODA_SCATTER2D /REF/L3_1992_I336180/d01-x01-y01
	+Path=/REF/L3_1992_I336180/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.04 0.005 0.005 9.19 1.7647662734764624 1.7647662734764624
	+0.055 0.010 0.010 6.48 1.2384667940643381 1.2384667940643381
	+0.08 0.015 0.015 5.2 1.0125709851659783 1.0125709851659783
	+0.115 0.020 0.020 3.3 0.6762396025078685 0.6762396025078685
	+0.155 0.020 0.020 2.61 0.5663920903402518 0.5663920903402518
	+0.2 0.025 0.025 1.26 0.3252691193458119 0.3252691193458119
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_1992_I336180/d02-x01-y01
	+Path=/REF/L3_1992_I336180/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+1.6 0.200 0.200 0.262 0.06506919393998976 0.06506919393998976
	+1.95 0.150 0.150 0.406 0.08823831367382312 0.08823831367382312
	+2.25 0.150 0.150 0.378 0.07621679604916491 0.07621679604916491
	+2.55 0.150 0.150 0.408 0.08324061508662703 0.08324061508662703
	+2.85 0.150 0.150 0.361 0.07158910531638177 0.07158910531638177
	+3.1 0.100 0.100 0.384 0.078873316146844 0.078873316146844
	+3.3 0.100 0.100 0.31 0.07211102550927978 0.07211102550927978
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/L3_2004_I652683.yoda b/data/refdata/L3_2004_I652683.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/L3_2004_I652683.yoda
	@@ -0,0 +1,5567 @@
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d01-x01-y01
	+Path=/REF/L3_2004_I652683/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.013 0.006324555320336759 0.006324555320336759
	+0.002 0.0 0.0 0.065 0.013152946437965905 0.013152946437965905
	+0.004 0.0 0.0 0.148 0.01811077027627483 0.01811077027627483
	+0.006 0.0 0.0 0.222 0.02209072203437452 0.02209072203437452
	+0.008 0.0 0.0 0.287 0.024083189157584593 0.024083189157584593
	+0.01 0.0 0.0 0.323 0.0261725046566048 0.0261725046566048
	+0.02 0.0 0.0 0.491 0.0327566787083184 0.0327566787083184
	+0.04 0.0 0.0 0.678 0.037656340767525456 0.037656340767525456
	+0.06 0.0 0.0 0.775 0.039319206502675 0.039319206502675
	+0.08 0.0 0.0 0.839 0.04011234224026316 0.04011234224026316
	+0.1 0.0 0.0 0.889 0.041109609582188934 0.041109609582188934
	+0.12 0.0 0.0 0.92 0.04204759208325728 0.04204759208325728
	+0.14 0.0 0.0 0.93 0.04204759208325728 0.04204759208325728
	+0.16 0.0 0.0 0.949 0.04204759208325728 0.04204759208325728
	+0.18 0.0 0.0 0.97 0.04301162633521313 0.04301162633521313
	+0.2 0.0 0.0 0.977 0.04301162633521313 0.04301162633521313
	+0.22 0.0 0.0 0.986 0.04301162633521313 0.04301162633521313
	+0.24 0.0 0.0 0.992 0.04301162633521313 0.04301162633521313
	+0.26 0.0 0.0 0.994 0.04301162633521313 0.04301162633521313
	+0.28 0.0 0.0 0.996 0.04301162633521313 0.04301162633521313
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d01-x01-y02
	+Path=/REF/L3_2004_I652683/d01-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.161 0.0191049731745428 0.0191049731745428
	+0.002 0.0 0.0 0.341 0.0261725046566048 0.0261725046566048
	+0.004 0.0 0.0 0.478 0.03114482300479487 0.03114482300479487
	+0.006 0.0 0.0 0.535 0.032388269481403296 0.032388269481403296
	+0.008 0.0 0.0 0.529 0.03114482300479487 0.03114482300479487
	+0.01 0.0 0.0 0.525 0.031064449134018134 0.031064449134018134
	+0.02 0.0 0.0 0.445 0.028442925306655785 0.028442925306655785
	+0.04 0.0 0.0 0.31 0.024041630560342614 0.024041630560342614
	+0.06 0.0 0.0 0.221 0.018681541692269404 0.018681541692269404
	+0.08 0.0 0.0 0.159 0.015297058540778355 0.015297058540778355
	+0.1 0.0 0.0 0.11 0.012369316876852983 0.012369316876852983
	+0.12 0.0 0.0 0.078 0.01019803902718557 0.01019803902718557
	+0.14 0.0 0.0 0.07 0.01019803902718557 0.01019803902718557
	+0.16 0.0 0.0 0.051 0.00824621125123532 0.00824621125123532
	+0.18 0.0 0.0 0.03 0.00608276253029822 0.00608276253029822
	+0.2 0.0 0.0 0.023 0.005099019513592785 0.005099019513592785
	+0.22 0.0 0.0 0.014 0.00412310562561766 0.00412310562561766
	+0.24 0.0 0.0 0.008 0.0031622776601683794 0.0031622776601683794
	+0.26 0.0 0.0 0.006 0.0031622776601683794 0.0031622776601683794
	+0.28 0.0 0.0 0.004 0.0031622776601683794 0.0031622776601683794
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d01-x01-y03
	+Path=/REF/L3_2004_I652683/d01-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.316 0.024083189157584593 0.024083189157584593
	+0.002 0.0 0.0 0.355 0.02531797780234433 0.02531797780234433
	+0.004 0.0 0.0 0.293 0.02209072203437452 0.02209072203437452
	+0.006 0.0 0.0 0.204 0.018439088914585774 0.018439088914585774
	+0.008 0.0 0.0 0.155 0.01676305461424021 0.01676305461424021
	+0.01 0.0 0.0 0.133 0.014317821063276354 0.014317821063276354
	+0.02 0.0 0.0 0.061 0.009486832980505138 0.009486832980505138
	+0.04 0.0 0.0 0.013 0.00412310562561766 0.00412310562561766
	+0.06 0.0 0.0 0.004 0.0022360679774997894 0.0022360679774997894
	+0.08 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+0.1 0.0 0.0 0.001 0.001 0.001
	+0.12 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d01-x01-y04
	+Path=/REF/L3_2004_I652683/d01-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.271 0.022360679774997894 0.022360679774997894
	+0.002 0.0 0.0 0.187 0.018439088914585774 0.018439088914585774
	+0.004 0.0 0.0 0.07 0.01019803902718557 0.01019803902718557
	+0.006 0.0 0.0 0.035 0.007280109889280519 0.007280109889280519
	+0.008 0.0 0.0 0.029 0.007071067811865475 0.007071067811865475
	+0.01 0.0 0.0 0.019 0.005099019513592785 0.005099019513592785
	+0.02 0.0 0.0 0.003 0.0022360679774997894 0.0022360679774997894
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d02-x01-y01
	+Path=/REF/L3_2004_I652683/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.019 0.007071067811865475 0.007071067811865475
	+0.002 0.0 0.0 0.061 0.013341664064126334 0.013341664064126334
	+0.004 0.0 0.0 0.149 0.021095023109728987 0.021095023109728987
	+0.006 0.0 0.0 0.206 0.02418677324489565 0.02418677324489565
	+0.008 0.0 0.0 0.266 0.02716615541441225 0.02716615541441225
	+0.01 0.0 0.0 0.319 0.0304138126514911 0.0304138126514911
	+0.02 0.0 0.0 0.507 0.03721558813185679 0.03721558813185679
	+0.04 0.0 0.0 0.683 0.0422965719651132 0.0422965719651132
	+0.06 0.0 0.0 0.774 0.045099889135118726 0.045099889135118726
	+0.08 0.0 0.0 0.825 0.046097722286464436 0.046097722286464436
	+0.1 0.0 0.0 0.865 0.047095647357266464 0.047095647357266464
	+0.12 0.0 0.0 0.9 0.048093658625644194 0.048093658625644194
	+0.14 0.0 0.0 0.919 0.04916299421312742 0.04916299421312742
	+0.16 0.0 0.0 0.94 0.04904079934095692 0.04904079934095692
	+0.18 0.0 0.0 0.966 0.05000999900019996 0.05000999900019996
	+0.2 0.0 0.0 0.978 0.05000999900019996 0.05000999900019996
	+0.22 0.0 0.0 0.983 0.05003998401278722 0.05003998401278722
	+0.24 0.0 0.0 0.984 0.05000999900019996 0.05000999900019996
	+0.26 0.0 0.0 0.99 0.05000999900019996 0.05000999900019996
	+0.28 0.0 0.0 0.997 0.05000999900019996 0.05000999900019996
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d02-x01-y02
	+Path=/REF/L3_2004_I652683/d02-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.175 0.022203603311174516 0.022203603311174516
	+0.002 0.0 0.0 0.344 0.03157530680769389 0.03157530680769389
	+0.004 0.0 0.0 0.464 0.03405877273185281 0.03405877273185281
	+0.006 0.0 0.0 0.512 0.03622154055254966 0.03622154055254966
	+0.008 0.0 0.0 0.523 0.03601388621073821 0.03601388621073821
	+0.01 0.0 0.0 0.504 0.035227829907617074 0.035227829907617074
	+0.02 0.0 0.0 0.406 0.031400636936215164 0.031400636936215164
	+0.04 0.0 0.0 0.294 0.02647640458974745 0.02647640458974745
	+0.06 0.0 0.0 0.218 0.022360679774997894 0.022360679774997894
	+0.08 0.0 0.0 0.175 0.019235384061671346 0.019235384061671346
	+0.1 0.0 0.0 0.135 0.016278820596099707 0.016278820596099707
	+0.12 0.0 0.0 0.1 0.014317821063276354 0.014317821063276354
	+0.14 0.0 0.0 0.081 0.012649110640673518 0.012649110640673518
	+0.16 0.0 0.0 0.06 0.01019803902718557 0.01019803902718557
	+0.18 0.0 0.0 0.034 0.007071067811865475 0.007071067811865475
	+0.2 0.0 0.0 0.022 0.00608276253029822 0.00608276253029822
	+0.22 0.0 0.0 0.017 0.005385164807134504 0.005385164807134504
	+0.24 0.0 0.0 0.016 0.005099019513592785 0.005099019513592785
	+0.26 0.0 0.0 0.01 0.00412310562561766 0.00412310562561766
	+0.28 0.0 0.0 0.003 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d02-x01-y03
	+Path=/REF/L3_2004_I652683/d02-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.305 0.0282842712474619 0.0282842712474619
	+0.002 0.0 0.0 0.326 0.029410882339705485 0.029410882339705485
	+0.004 0.0 0.0 0.272 0.025495097567963927 0.025495097567963927
	+0.006 0.0 0.0 0.224 0.023345235059857503 0.023345235059857503
	+0.008 0.0 0.0 0.175 0.020615528128088305 0.020615528128088305
	+0.01 0.0 0.0 0.148 0.01811077027627483 0.01811077027627483
	+0.02 0.0 0.0 0.08 0.012369316876852983 0.012369316876852983
	+0.04 0.0 0.0 0.024 0.007280109889280519 0.007280109889280519
	+0.06 0.0 0.0 0.008 0.00412310562561766 0.00412310562561766
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d02-x01-y04
	+Path=/REF/L3_2004_I652683/d02-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.236 0.024020824298928628 0.024020824298928628
	+0.002 0.0 0.0 0.157 0.0196468827043885 0.0196468827043885
	+0.004 0.0 0.0 0.092 0.01414213562373095 0.01414213562373095
	+0.006 0.0 0.0 0.047 0.010770329614269008 0.010770329614269008
	+0.008 0.0 0.0 0.034 0.009055385138137416 0.009055385138137416
	+0.01 0.0 0.0 0.03 0.00824621125123532 0.00824621125123532
	+0.02 0.0 0.0 0.008 0.00412310562561766 0.00412310562561766
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d03-x01-y01
	+Path=/REF/L3_2004_I652683/d03-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.062 0.017088007490635063 0.017088007490635063
	+0.002 0.0 0.0 0.108 0.02213594362117866 0.02213594362117866
	+0.004 0.0 0.0 0.196 0.02765863337187866 0.02765863337187866
	+0.006 0.0 0.0 0.278 0.0322490309931942 0.0322490309931942
	+0.008 0.0 0.0 0.337 0.0356931365951495 0.0356931365951495
	+0.01 0.0 0.0 0.387 0.037656340767525456 0.037656340767525456
	+0.02 0.0 0.0 0.529 0.04317406628984581 0.04317406628984581
	+0.04 0.0 0.0 0.681 0.04687216658103186 0.04687216658103186
	+0.06 0.0 0.0 0.768 0.04949747468305833 0.04949747468305833
	+0.08 0.0 0.0 0.826 0.051244511901275824 0.051244511901275824
	+0.1 0.0 0.0 0.87 0.052239831546435904 0.052239831546435904
	+0.12 0.0 0.0 0.906 0.05315072906367325 0.05315072906367325
	+0.14 0.0 0.0 0.924 0.05315072906367325 0.05315072906367325
	+0.16 0.0 0.0 0.95 0.054083269131959835 0.054083269131959835
	+0.18 0.0 0.0 0.962 0.054083269131959835 0.054083269131959835
	+0.2 0.0 0.0 0.984 0.054037024344425186 0.054037024344425186
	+0.22 0.0 0.0 0.99 0.054037024344425186 0.054037024344425186
	+0.24 0.0 0.0 0.992 0.05503635162326805 0.05503635162326805
	+0.26 0.0 0.0 0.994 0.055009090157900266 0.055009090157900266
	+0.28 0.0 0.0 0.992 0.055009090157900266 0.055009090157900266
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d03-x01-y02
	+Path=/REF/L3_2004_I652683/d03-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.228 0.030364452901377955 0.030364452901377955
	+0.002 0.0 0.0 0.369 0.036687872655688285 0.036687872655688285
	+0.004 0.0 0.0 0.493 0.04026164427839479 0.04026164427839479
	+0.006 0.0 0.0 0.504 0.03863935817272331 0.03863935817272331
	+0.008 0.0 0.0 0.503 0.03748332962798262 0.03748332962798262
	+0.01 0.0 0.0 0.489 0.036124783736376884 0.036124783736376884
	+0.02 0.0 0.0 0.42 0.03420526275297414 0.03420526275297414
	+0.04 0.0 0.0 0.313 0.030463092423455636 0.030463092423455636
	+0.06 0.0 0.0 0.226 0.025 0.025
	+0.08 0.0 0.0 0.174 0.021587033144922906 0.021587033144922906
	+0.1 0.0 0.0 0.13 0.018681541692269404 0.018681541692269404
	+0.12 0.0 0.0 0.094 0.015524174696260024 0.015524174696260024
	+0.14 0.0 0.0 0.076 0.013601470508735444 0.013601470508735444
	+0.16 0.0 0.0 0.05 0.01044030650891055 0.01044030650891055
	+0.18 0.0 0.0 0.038 0.009486832980505138 0.009486832980505138
	+0.2 0.0 0.0 0.016 0.006324555320336759 0.006324555320336759
	+0.22 0.0 0.0 0.01 0.004472135954999579 0.004472135954999579
	+0.24 0.0 0.0 0.008 0.004472135954999579 0.004472135954999579
	+0.26 0.0 0.0 0.006 0.0031622776601683794 0.0031622776601683794
	+0.28 0.0 0.0 0.008 0.0031622776601683794 0.0031622776601683794
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d03-x01-y03
	+Path=/REF/L3_2004_I652683/d03-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.313 0.0304138126514911 0.0304138126514911
	+0.002 0.0 0.0 0.366 0.03157530680769389 0.03157530680769389
	+0.004 0.0 0.0 0.257 0.025495097567963927 0.025495097567963927
	+0.006 0.0 0.0 0.199 0.022360679774997894 0.022360679774997894
	+0.008 0.0 0.0 0.153 0.021540659228538015 0.021540659228538015
	+0.01 0.0 0.0 0.12 0.018973665961010275 0.018973665961010275
	+0.02 0.0 0.0 0.051 0.013152946437965905 0.013152946437965905
	+0.04 0.0 0.0 0.007 0.007615773105863909 0.007615773105863909
	+0.06 0.0 0.0 0.006 0.005099019513592785 0.005099019513592785
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d03-x01-y04
	+Path=/REF/L3_2004_I652683/d03-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.262 0.026019223662515373 0.026019223662515373
	+0.002 0.0 0.0 0.132 0.020591260281974 0.020591260281974
	+0.004 0.0 0.0 0.054 0.015264337522473748 0.015264337522473748
	+0.006 0.0 0.0 0.019 0.009848857801796104 0.009848857801796104
	+0.008 0.0 0.0 0.007 0.007280109889280519 0.007280109889280519
	+0.01 0.0 0.0 0.004 0.00608276253029822 0.00608276253029822
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d04-x01-y01
	+Path=/REF/L3_2004_I652683/d04-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.055 0.020223748416156685 0.020223748416156685
	+0.002 0.0 0.0 0.115 0.027513632984395207 0.027513632984395207
	+0.004 0.0 0.0 0.17 0.030675723300355937 0.030675723300355937
	+0.006 0.0 0.0 0.245 0.03452535300326414 0.03452535300326414
	+0.008 0.0 0.0 0.287 0.03687817782917155 0.03687817782917155
	+0.01 0.0 0.0 0.323 0.039849717690342554 0.039849717690342554
	+0.02 0.0 0.0 0.491 0.04684015371452147 0.04684015371452147
	+0.04 0.0 0.0 0.656 0.05385164807134505 0.05385164807134505
	+0.06 0.0 0.0 0.762 0.05608921464952063 0.05608921464952063
	+0.08 0.0 0.0 0.86 0.05842088667591412 0.05842088667591412
	+0.1 0.0 0.0 0.907 0.06001666435249463 0.06001666435249463
	+0.12 0.0 0.0 0.924 0.060299253726725344 0.060299253726725344
	+0.14 0.0 0.0 0.956 0.061522353661088096 0.061522353661088096
	+0.16 0.0 0.0 0.972 0.06212889826803627 0.06212889826803627
	+0.18 0.0 0.0 0.984 0.06228964600958974 0.06228964600958974
	+0.2 0.0 0.0 0.986 0.06220128616033594 0.06220128616033594
	+0.22 0.0 0.0 0.988 0.06212889826803627 0.06212889826803627
	+0.24 0.0 0.0 0.989 0.06207253821135398 0.06207253821135398
	+0.26 0.0 0.0 0.99 0.06212889826803627 0.06212889826803627
	+0.28 0.0 0.0 0.996 0.06300793600809346 0.06300793600809346
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d04-x01-y02
	+Path=/REF/L3_2004_I652683/d04-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.186 0.03026549190084311 0.03026549190084311
	+0.002 0.0 0.0 0.342 0.03889730067755345 0.03889730067755345
	+0.004 0.0 0.0 0.455 0.04964876634922564 0.04964876634922564
	+0.006 0.0 0.0 0.466 0.044283179650969055 0.044283179650969055
	+0.008 0.0 0.0 0.463 0.041484937025383084 0.041484937025383084
	+0.01 0.0 0.0 0.448 0.040024992192379 0.040024992192379
	+0.02 0.0 0.0 0.399 0.03736308338453881 0.03736308338453881
	+0.04 0.0 0.0 0.27 0.03257299494980466 0.03257299494980466
	+0.06 0.0 0.0 0.23 0.030675723300355937 0.030675723300355937
	+0.08 0.0 0.0 0.14 0.02435159132377184 0.02435159132377184
	+0.1 0.0 0.0 0.093 0.02195449840010015 0.02195449840010015
	+0.12 0.0 0.0 0.076 0.01802775637731995 0.01802775637731995
	+0.14 0.0 0.0 0.044 0.015264337522473748 0.015264337522473748
	+0.16 0.0 0.0 0.028 0.010770329614269008 0.010770329614269008
	+0.18 0.0 0.0 0.016 0.008944271909999158 0.008944271909999158
	+0.2 0.0 0.0 0.014 0.00806225774829855 0.00806225774829855
	+0.22 0.0 0.0 0.012 0.007615773105863909 0.007615773105863909
	+0.24 0.0 0.0 0.011 0.00670820393249937 0.00670820393249937
	+0.26 0.0 0.0 0.01 0.0058309518948453 0.0058309518948453
	+0.28 0.0 0.0 0.004 0.00412310562561766 0.00412310562561766
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d04-x01-y03
	+Path=/REF/L3_2004_I652683/d04-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.34 0.0366742416417845 0.0366742416417845
	+0.002 0.0 0.0 0.29 0.03324154027718932 0.03324154027718932
	+0.004 0.0 0.0 0.255 0.030364452901377955 0.030364452901377955
	+0.006 0.0 0.0 0.2 0.027513632984395207 0.027513632984395207
	+0.008 0.0 0.0 0.177 0.026925824035672518 0.026925824035672518
	+0.01 0.0 0.0 0.157 0.02596150997149434 0.02596150997149434
	+0.02 0.0 0.0 0.068 0.025238858928247926 0.025238858928247926
	+0.04 0.0 0.0 0.074 0.030886890422961 0.030886890422961
	+0.06 0.0 0.0 0.008 0.01802775637731995 0.01802775637731995
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d04-x01-y04
	+Path=/REF/L3_2004_I652683/d04-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.253 0.03580502757993632 0.03580502757993632
	+0.002 0.0 0.0 0.183 0.026570660511172847 0.026570660511172847
	+0.004 0.0 0.0 0.083 0.0208806130178211 0.0208806130178211
	+0.006 0.0 0.0 0.049 0.01802775637731995 0.01802775637731995
	+0.008 0.0 0.0 0.037 0.01746424919657298 0.01746424919657298
	+0.01 0.0 0.0 0.038 0.019235384061671346 0.019235384061671346
	+0.02 0.0 0.0 0.04 0.022825424421026655 0.022825424421026655
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d05-x01-y01
	+Path=/REF/L3_2004_I652683/d05-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.028 0.004472135954999579 0.004472135954999579
	+0.002 0.0 0.0 0.069 0.007280109889280519 0.007280109889280519
	+0.004 0.0 0.0 0.154 0.011401754250991379 0.011401754250991379
	+0.006 0.0 0.0 0.231 0.01392838827718412 0.01392838827718412
	+0.008 0.0 0.0 0.293 0.015811388300841896 0.015811388300841896
	+0.01 0.0 0.0 0.365 0.01802775637731995 0.01802775637731995
	+0.02 0.0 0.0 0.514 0.0208806130178211 0.0208806130178211
	+0.04 0.0 0.0 0.692 0.02308679276123039 0.02308679276123039
	+0.06 0.0 0.0 0.784 0.02531797780234433 0.02531797780234433
	+0.08 0.0 0.0 0.839 0.026076809620810593 0.026076809620810593
	+0.1 0.0 0.0 0.886 0.027073972741361765 0.027073972741361765
	+0.12 0.0 0.0 0.923 0.027018512172212593 0.027018512172212593
	+0.14 0.0 0.0 0.939 0.0280713376952364 0.0280713376952364
	+0.16 0.0 0.0 0.957 0.0280178514522438 0.0280178514522438
	+0.18 0.0 0.0 0.971 0.0280713376952364 0.0280713376952364
	+0.2 0.0 0.0 0.98 0.02816025568065745 0.02816025568065745
	+0.22 0.0 0.0 0.982 0.0280713376952364 0.0280713376952364
	+0.24 0.0 0.0 0.985 0.0280178514522438 0.0280178514522438
	+0.26 0.0 0.0 0.991 0.02901723625709382 0.02901723625709382
	+0.28 0.0 0.0 0.997 0.02901723625709382 0.02901723625709382
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d05-x01-y02
	+Path=/REF/L3_2004_I652683/d05-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.209 0.01216552506059644 0.01216552506059644
	+0.002 0.0 0.0 0.363 0.01649242250247064 0.01649242250247064
	+0.004 0.0 0.0 0.477 0.0191049731745428 0.0191049731745428
	+0.006 0.0 0.0 0.498 0.0191049731745428 0.0191049731745428
	+0.008 0.0 0.0 0.493 0.0191049731745428 0.0191049731745428
	+0.01 0.0 0.0 0.472 0.0194164878389476 0.0194164878389476
	+0.02 0.0 0.0 0.413 0.018439088914585774 0.018439088914585774
	+0.04 0.0 0.0 0.298 0.0161245154965971 0.0161245154965971
	+0.06 0.0 0.0 0.209 0.014317821063276354 0.014317821063276354
	+0.08 0.0 0.0 0.154 0.012369316876852983 0.012369316876852983
	+0.1 0.0 0.0 0.114 0.01019803902718557 0.01019803902718557
	+0.12 0.0 0.0 0.077 0.00806225774829855 0.00806225774829855
	+0.14 0.0 0.0 0.061 0.007280109889280519 0.007280109889280519
	+0.16 0.0 0.0 0.043 0.00608276253029822 0.00608276253029822
	+0.18 0.0 0.0 0.029 0.005385164807134504 0.005385164807134504
	+0.2 0.0 0.0 0.02 0.005099019513592785 0.005099019513592785
	+0.22 0.0 0.0 0.018 0.004472135954999579 0.004472135954999579
	+0.24 0.0 0.0 0.015 0.00412310562561766 0.00412310562561766
	+0.26 0.0 0.0 0.009 0.0031622776601683794 0.0031622776601683794
	+0.28 0.0 0.0 0.003 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d05-x01-y03
	+Path=/REF/L3_2004_I652683/d05-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.345 0.01649242250247064 0.01649242250247064
	+0.002 0.0 0.0 0.345 0.01676305461424021 0.01676305461424021
	+0.004 0.0 0.0 0.284 0.01746424919657298 0.01746424919657298
	+0.006 0.0 0.0 0.216 0.015524174696260024 0.015524174696260024
	+0.008 0.0 0.0 0.177 0.014560219778561038 0.014560219778561038
	+0.01 0.0 0.0 0.144 0.013601470508735444 0.013601470508735444
	+0.02 0.0 0.0 0.067 0.012083045973594572 0.012083045973594572
	+0.04 0.0 0.0 0.003 0.007071067811865475 0.007071067811865475
	+0.06 0.0 0.0 0.007 0.008544003745317531 0.008544003745317531
	+0.08 0.0 0.0 0.007 0.00824621125123532 0.00824621125123532
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d05-x01-y04
	+Path=/REF/L3_2004_I652683/d05-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.23 0.014560219778561038 0.014560219778561038
	+0.002 0.0 0.0 0.169 0.01414213562373095 0.01414213562373095
	+0.004 0.0 0.0 0.077 0.013038404810405297 0.013038404810405297
	+0.006 0.0 0.0 0.045 0.010770329614269008 0.010770329614269008
	+0.008 0.0 0.0 0.026 0.010816653826391968 0.010816653826391968
	+0.01 0.0 0.0 0.018 0.009219544457292887 0.009219544457292887
	+0.02 0.0 0.0 0.006 0.005099019513592785 0.005099019513592785
	+0.04 0.0 0.0 0.007 0.01019803902718557 0.01019803902718557
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d06-x01-y01
	+Path=/REF/L3_2004_I652683/d06-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.038 0.0031622776601683794 0.0031622776601683794
	+0.002 0.0 0.0 0.082 0.0058309518948453 0.0058309518948453
	+0.004 0.0 0.0 0.162 0.00806225774829855 0.00806225774829855
	+0.006 0.0 0.0 0.235 0.011401754250991379 0.011401754250991379
	+0.008 0.0 0.0 0.289 0.012806248474865698 0.012806248474865698
	+0.01 0.0 0.0 0.334 0.01345362404707371 0.01345362404707371
	+0.02 0.0 0.0 0.507 0.015264337522473748 0.015264337522473748
	+0.04 0.0 0.0 0.678 0.015811388300841896 0.015811388300841896
	+0.06 0.0 0.0 0.78 0.01746424919657298 0.01746424919657298
	+0.08 0.0 0.0 0.834 0.01676305461424021 0.01676305461424021
	+0.1 0.0 0.0 0.876 0.017088007490635063 0.017088007490635063
	+0.12 0.0 0.0 0.91 0.01802775637731995 0.01802775637731995
	+0.14 0.0 0.0 0.932 0.01746424919657298 0.01746424919657298
	+0.16 0.0 0.0 0.953 0.01726267650163207 0.01726267650163207
	+0.18 0.0 0.0 0.966 0.01711724276862369 0.01711724276862369
	+0.2 0.0 0.0 0.976 0.01746424919657298 0.01746424919657298
	+0.22 0.0 0.0 0.983 0.01811077027627483 0.01811077027627483
	+0.24 0.0 0.0 0.987 0.01811077027627483 0.01811077027627483
	+0.26 0.0 0.0 0.993 0.018248287590894658 0.018248287590894658
	+0.28 0.0 0.0 0.997 0.01811077027627483 0.01811077027627483
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d06-x01-y02
	+Path=/REF/L3_2004_I652683/d06-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.215 0.009433981132056603 0.009433981132056603
	+0.002 0.0 0.0 0.356 0.0116619037896906 0.0116619037896906
	+0.004 0.0 0.0 0.472 0.01341640786499874 0.01341640786499874
	+0.006 0.0 0.0 0.503 0.012649110640673518 0.012649110640673518
	+0.008 0.0 0.0 0.51 0.012649110640673518 0.012649110640673518
	+0.01 0.0 0.0 0.511 0.013892443989449804 0.013892443989449804
	+0.02 0.0 0.0 0.439 0.013601470508735444 0.013601470508735444
	+0.04 0.0 0.0 0.312 0.010770329614269008 0.010770329614269008
	+0.06 0.0 0.0 0.22 0.01063014581273465 0.01063014581273465
	+0.08 0.0 0.0 0.165 0.008602325267042627 0.008602325267042627
	+0.1 0.0 0.0 0.123 0.0078102496759066544 0.0078102496759066544
	+0.12 0.0 0.0 0.089 0.008602325267042627 0.008602325267042627
	+0.14 0.0 0.0 0.068 0.006403124237432849 0.006403124237432849
	+0.16 0.0 0.0 0.047 0.005 0.005
	+0.18 0.0 0.0 0.034 0.004472135954999579 0.004472135954999579
	+0.2 0.0 0.0 0.024 0.004242640687119285 0.004242640687119285
	+0.22 0.0 0.0 0.017 0.0036055512754639895 0.0036055512754639895
	+0.24 0.0 0.0 0.013 0.00282842712474619 0.00282842712474619
	+0.26 0.0 0.0 0.007 0.0022360679774997894 0.0022360679774997894
	+0.28 0.0 0.0 0.003 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d06-x01-y03
	+Path=/REF/L3_2004_I652683/d06-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.318 0.009219544457292887 0.009219544457292887
	+0.002 0.0 0.0 0.345 0.01345362404707371 0.01345362404707371
	+0.004 0.0 0.0 0.286 0.01345362404707371 0.01345362404707371
	+0.006 0.0 0.0 0.22 0.010816653826391968 0.010816653826391968
	+0.008 0.0 0.0 0.174 0.01063014581273465 0.01063014581273465
	+0.01 0.0 0.0 0.142 0.009433981132056603 0.009433981132056603
	+0.02 0.0 0.0 0.054 0.006324555320336759 0.006324555320336759
	+0.04 0.0 0.0 0.01 0.005385164807134504 0.005385164807134504
	+
	+0.08 0.0 0.0 0.001 0.00608276253029822 0.00608276253029822
	+0.1 0.0 0.0 0.001 0.0022360679774997894 0.0022360679774997894
	+0.12 0.0 0.0 0.0 0.001 0.001
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d06-x01-y04
	+Path=/REF/L3_2004_I652683/d06-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.252 0.009848857801796104 0.009848857801796104
	+0.002 0.0 0.0 0.166 0.008944271909999158 0.008944271909999158
	+0.004 0.0 0.0 0.07 0.008602325267042627 0.008602325267042627
	+0.006 0.0 0.0 0.042 0.007280109889280519 0.007280109889280519
	+0.008 0.0 0.0 0.026 0.007211102550927979 0.007211102550927979
	+0.01 0.0 0.0 0.012 0.0058309518948453 0.0058309518948453
	+
	+0.04 0.0 0.0 0.0 0.001 0.001
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d07-x01-y01
	+Path=/REF/L3_2004_I652683/d07-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.031 0.004472135954999579 0.004472135954999579
	+0.002 0.0 0.0 0.078 0.007211102550927979 0.007211102550927979
	+0.004 0.0 0.0 0.154 0.01131370849898476 0.01131370849898476
	+0.006 0.0 0.0 0.218 0.01414213562373095 0.01414213562373095
	+0.008 0.0 0.0 0.273 0.015556349186104044 0.015556349186104044
	+0.01 0.0 0.0 0.321 0.015620499351813309 0.015620499351813309
	+0.02 0.0 0.0 0.499 0.016999999999999998 0.016999999999999998
	+0.04 0.0 0.0 0.669 0.018973665961010275 0.018973665961010275
	+0.06 0.0 0.0 0.777 0.02039607805437114 0.02039607805437114
	+0.08 0.0 0.0 0.833 0.02213594362117866 0.02213594362117866
	+0.1 0.0 0.0 0.878 0.022472205054244233 0.022472205054244233
	+0.12 0.0 0.0 0.91 0.02340939982143925 0.02340939982143925
	+0.14 0.0 0.0 0.935 0.023769728648009424 0.023769728648009424
	+0.16 0.0 0.0 0.95 0.02308679276123039 0.02308679276123039
	+0.18 0.0 0.0 0.959 0.02308679276123039 0.02308679276123039
	+0.2 0.0 0.0 0.969 0.024041630560342614 0.024041630560342614
	+0.22 0.0 0.0 0.983 0.024041630560342614 0.024041630560342614
	+0.24 0.0 0.0 0.987 0.023345235059857503 0.023345235059857503
	+0.26 0.0 0.0 0.992 0.02308679276123039 0.02308679276123039
	+0.28 0.0 0.0 0.998 0.023021728866442676 0.023021728866442676
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d07-x01-y02
	+Path=/REF/L3_2004_I652683/d07-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.213 0.010770329614269008 0.010770329614269008
	+0.002 0.0 0.0 0.351 0.012649110640673518 0.012649110640673518
	+0.004 0.0 0.0 0.483 0.015524174696260024 0.015524174696260024
	+0.006 0.0 0.0 0.531 0.01746424919657298 0.01746424919657298
	+0.008 0.0 0.0 0.547 0.02 0.02
	+0.01 0.0 0.0 0.527 0.0194164878389476 0.0194164878389476
	+0.02 0.0 0.0 0.454 0.018357559750685818 0.018357559750685818
	+0.04 0.0 0.0 0.324 0.0161245154965971 0.0161245154965971
	+0.06 0.0 0.0 0.223 0.013000000000000001 0.013000000000000001
	+0.08 0.0 0.0 0.167 0.012206555615733704 0.012206555615733704
	+0.1 0.0 0.0 0.122 0.012041594578792296 0.012041594578792296
	+0.12 0.0 0.0 0.09 0.01131370849898476 0.01131370849898476
	+0.14 0.0 0.0 0.065 0.011401754250991379 0.011401754250991379
	+0.16 0.0 0.0 0.05 0.009219544457292887 0.009219544457292887
	+0.18 0.0 0.0 0.041 0.008602325267042627 0.008602325267042627
	+0.2 0.0 0.0 0.031 0.008602325267042627 0.008602325267042627
	+0.22 0.0 0.0 0.017 0.00565685424949238 0.00565685424949238
	+0.24 0.0 0.0 0.013 0.005 0.005
	+0.26 0.0 0.0 0.008 0.0036055512754639895 0.0036055512754639895
	+0.28 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d07-x01-y03
	+Path=/REF/L3_2004_I652683/d07-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.332 0.013892443989449804 0.013892443989449804
	+0.002 0.0 0.0 0.375 0.016643316977093238 0.016643316977093238
	+0.004 0.0 0.0 0.275 0.017204650534085254 0.017204650534085254
	+0.006 0.0 0.0 0.217 0.014317821063276353 0.014317821063276353
	+0.008 0.0 0.0 0.173 0.015264337522473748 0.015264337522473748
	+0.01 0.0 0.0 0.151 0.01392838827718412 0.01392838827718412
	+0.02 0.0 0.0 0.044 0.013000000000000001 0.013000000000000001
	+0.04 0.0 0.0 0.008 0.007615773105863909 0.007615773105863909
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d07-x01-y04
	+Path=/REF/L3_2004_I652683/d07-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.244 0.016278820596099707 0.016278820596099707
	+0.002 0.0 0.0 0.142 0.014422205101855958 0.014422205101855958
	+0.004 0.0 0.0 0.078 0.015 0.015
	+0.006 0.0 0.0 0.034 0.012649110640673518 0.012649110640673518
	+0.008 0.0 0.0 0.007 0.009486832980505138 0.009486832980505138
	+0.01 0.0 0.0 0.001 0.007071067811865475 0.007071067811865475
	+0.02 0.0 0.0 0.003 0.008544003745317531 0.008544003745317531
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d08-x01-y01
	+Path=/REF/L3_2004_I652683/d08-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.036 0.004472135954999579 0.004472135954999579
	+0.002 0.0 0.0 0.072 0.00670820393249937 0.00670820393249937
	+0.004 0.0 0.0 0.155 0.011401754250991379 0.011401754250991379
	+0.006 0.0 0.0 0.226 0.012206555615733704 0.012206555615733704
	+0.008 0.0 0.0 0.285 0.015620499351813309 0.015620499351813309
	+0.01 0.0 0.0 0.329 0.0170293863659264 0.0170293863659264
	+0.02 0.0 0.0 0.493 0.01860107523773827 0.01860107523773827
	+0.04 0.0 0.0 0.662 0.020124611797498106 0.020124611797498106
	+0.06 0.0 0.0 0.744 0.023600847442411893 0.023600847442411893
	+0.08 0.0 0.0 0.817 0.0233238075793812 0.0233238075793812
	+0.1 0.0 0.0 0.871 0.02418677324489565 0.02418677324489565
	+0.12 0.0 0.0 0.898 0.02213594362117866 0.02213594362117866
	+0.14 0.0 0.0 0.922 0.02256102834535695 0.02256102834535695
	+0.16 0.0 0.0 0.945 0.02256102834535695 0.02256102834535695
	+0.18 0.0 0.0 0.954 0.022360679774997894 0.022360679774997894
	+0.2 0.0 0.0 0.968 0.023537204591879638 0.023537204591879638
	+0.22 0.0 0.0 0.978 0.023345235059857503 0.023345235059857503
	+0.24 0.0 0.0 0.982 0.02308679276123039 0.02308679276123039
	+0.26 0.0 0.0 0.987 0.023194827009486402 0.023194827009486402
	+0.28 0.0 0.0 0.995 0.023021728866442676 0.023021728866442676
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d08-x01-y02
	+Path=/REF/L3_2004_I652683/d08-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.207 0.011401754250991379 0.011401754250991379
	+0.002 0.0 0.0 0.351 0.013000000000000001 0.013000000000000001
	+0.004 0.0 0.0 0.473 0.015524174696260024 0.015524174696260024
	+0.006 0.0 0.0 0.507 0.019209372712298545 0.019209372712298545
	+0.008 0.0 0.0 0.522 0.02 0.02
	+0.01 0.0 0.0 0.519 0.018357559750685818 0.018357559750685818
	+0.02 0.0 0.0 0.435 0.017492855684535902 0.017492855684535902
	+0.04 0.0 0.0 0.322 0.016643316977093238 0.016643316977093238
	+0.06 0.0 0.0 0.237 0.01341640786499874 0.01341640786499874
	+0.08 0.0 0.0 0.177 0.014866068747318505 0.014866068747318505
	+0.1 0.0 0.0 0.129 0.01345362404707371 0.01345362404707371
	+0.12 0.0 0.0 0.102 0.011401754250991379 0.011401754250991379
	+0.14 0.0 0.0 0.078 0.009433981132056603 0.009433981132056603
	+0.16 0.0 0.0 0.055 0.008602325267042627 0.008602325267042627
	+0.18 0.0 0.0 0.046 0.00806225774829855 0.00806225774829855
	+0.2 0.0 0.0 0.032 0.007211102550927979 0.007211102550927979
	+0.22 0.0 0.0 0.023 0.0058309518948453 0.0058309518948453
	+0.24 0.0 0.0 0.018 0.004472135954999579 0.004472135954999579
	+0.26 0.0 0.0 0.013 0.005 0.005
	+0.28 0.0 0.0 0.005 0.0031622776601683794 0.0031622776601683794
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d08-x01-y03
	+Path=/REF/L3_2004_I652683/d08-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.324 0.01341640786499874 0.01341640786499874
	+0.002 0.0 0.0 0.338 0.014317821063276353 0.014317821063276353
	+0.004 0.0 0.0 0.282 0.014317821063276353 0.014317821063276353
	+0.006 0.0 0.0 0.229 0.01769180601295413 0.01769180601295413
	+0.008 0.0 0.0 0.182 0.01769180601295413 0.01769180601295413
	+0.01 0.0 0.0 0.148 0.01341640786499874 0.01341640786499874
	+0.02 0.0 0.0 0.072 0.01341640786499874 0.01341640786499874
	+0.04 0.0 0.0 0.015 0.012649110640673518 0.012649110640673518
	+0.06 0.0 0.0 0.02 0.01860107523773827 0.01860107523773827
	+0.08 0.0 0.0 0.006 0.016999999999999998 0.016999999999999998
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d08-x01-y04
	+Path=/REF/L3_2004_I652683/d08-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.248 0.01341640786499874 0.01341640786499874
	+0.002 0.0 0.0 0.171 0.012649110640673518 0.012649110640673518
	+0.004 0.0 0.0 0.073 0.012206555615733704 0.012206555615733704
	+0.006 0.0 0.0 0.023 0.012041594578792296 0.012041594578792296
	+0.008 0.0 0.0 0.01 0.012041594578792296 0.012041594578792296
	+0.01 0.0 0.0 0.004 0.008944271909999158 0.008944271909999158
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d09-x01-y01
	+Path=/REF/L3_2004_I652683/d09-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.03 0.0036055512754639895 0.0036055512754639895
	+0.002 0.0 0.0 0.075 0.005 0.005
	+0.004 0.0 0.0 0.149 0.008602325267042627 0.008602325267042627
	+0.006 0.0 0.0 0.213 0.01131370849898476 0.01131370849898476
	+0.008 0.0 0.0 0.272 0.01345362404707371 0.01345362404707371
	+0.01 0.0 0.0 0.323 0.01414213562373095 0.01414213562373095
	+0.02 0.0 0.0 0.496 0.015 0.015
	+0.04 0.0 0.0 0.674 0.0161245154965971 0.0161245154965971
	+0.06 0.0 0.0 0.769 0.016155494421403512 0.016155494421403512
	+0.08 0.0 0.0 0.826 0.01746424919657298 0.01746424919657298
	+0.1 0.0 0.0 0.873 0.01746424919657298 0.01746424919657298
	+0.12 0.0 0.0 0.901 0.018384776310850236 0.018384776310850236
	+0.14 0.0 0.0 0.928 0.01772004514666935 0.01772004514666935
	+0.16 0.0 0.0 0.943 0.01802775637731995 0.01802775637731995
	+0.18 0.0 0.0 0.96 0.01746424919657298 0.01746424919657298
	+0.2 0.0 0.0 0.97 0.01811077027627483 0.01811077027627483
	+0.22 0.0 0.0 0.976 0.018027756377319945 0.018027756377319945
	+0.24 0.0 0.0 0.986 0.01811077027627483 0.01811077027627483
	+0.26 0.0 0.0 0.988 0.01811077027627483 0.01811077027627483
	+0.28 0.0 0.0 0.994 0.018027756377319945 0.018027756377319945
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d09-x01-y02
	+Path=/REF/L3_2004_I652683/d09-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.216 0.008944271909999158 0.008944271909999158
	+0.002 0.0 0.0 0.367 0.0116619037896906 0.0116619037896906
	+0.004 0.0 0.0 0.478 0.011180339887498947 0.011180339887498947
	+0.006 0.0 0.0 0.51 0.012649110640673518 0.012649110640673518
	+0.008 0.0 0.0 0.518 0.013892443989449804 0.013892443989449804
	+0.01 0.0 0.0 0.513 0.014422205101855958 0.014422205101855958
	+0.02 0.0 0.0 0.451 0.013892443989449804 0.013892443989449804
	+0.04 0.0 0.0 0.321 0.012083045973594572 0.012083045973594572
	+0.06 0.0 0.0 0.231 0.010770329614269008 0.010770329614269008
	+0.08 0.0 0.0 0.174 0.012727922061357855 0.012727922061357855
	+0.1 0.0 0.0 0.127 0.01063014581273465 0.01063014581273465
	+0.12 0.0 0.0 0.098 0.009899494936611667 0.009899494936611667
	+0.14 0.0 0.0 0.072 0.0078102496759066544 0.0078102496759066544
	+0.16 0.0 0.0 0.057 0.00848528137423857 0.00848528137423857
	+0.18 0.0 0.0 0.04 0.006403124237432849 0.006403124237432849
	+0.2 0.0 0.0 0.03 0.005385164807134504 0.005385164807134504
	+0.22 0.0 0.0 0.024 0.00412310562561766 0.00412310562561766
	+0.24 0.0 0.0 0.014 0.004472135954999579 0.004472135954999579
	+0.26 0.0 0.0 0.012 0.0036055512754639895 0.0036055512754639895
	+0.28 0.0 0.0 0.006 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d09-x01-y03
	+Path=/REF/L3_2004_I652683/d09-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.337 0.010770329614269008 0.010770329614269008
	+0.002 0.0 0.0 0.341 0.012806248474865698 0.012806248474865698
	+0.004 0.0 0.0 0.279 0.01345362404707371 0.01345362404707371
	+0.006 0.0 0.0 0.222 0.012806248474865698 0.012806248474865698
	+0.008 0.0 0.0 0.18 0.012206555615733704 0.012206555615733704
	+0.01 0.0 0.0 0.149 0.0116619037896906 0.0116619037896906
	+0.02 0.0 0.0 0.054 0.011401754250991379 0.011401754250991379
	+0.04 0.0 0.0 0.006 0.008544003745317531 0.008544003745317531
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d09-x01-y04
	+Path=/REF/L3_2004_I652683/d09-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.24 0.010295630140987 0.010295630140987
	+0.002 0.0 0.0 0.157 0.012041594578792296 0.012041594578792296
	+0.004 0.0 0.0 0.08 0.009486832980505138 0.009486832980505138
	+0.006 0.0 0.0 0.052 0.009433981132056603 0.009433981132056603
	+0.008 0.0 0.0 0.025 0.01063014581273465 0.01063014581273465
	+0.01 0.0 0.0 0.014 0.008602325267042627 0.008602325267042627
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d10-x01-y01
	+Path=/REF/L3_2004_I652683/d10-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.234 0.022203603311174516 0.022203603311174516
	+0.002 0.0 0.0 0.395 0.028442925306655785 0.028442925306655785
	+0.004 0.0 0.0 0.502 0.032015621187164243 0.032015621187164243
	+0.006 0.0 0.0 0.58 0.03452535300326414 0.03452535300326414
	+0.008 0.0 0.0 0.624 0.03535533905932738 0.03535533905932738
	+0.01 0.0 0.0 0.654 0.036496575181789316 0.036496575181789316
	+0.02 0.0 0.0 0.77 0.0396232255123179 0.0396232255123179
	+0.04 0.0 0.0 0.876 0.041109609582188934 0.041109609582188934
	+0.06 0.0 0.0 0.914 0.0421070065428546 0.0421070065428546
	+0.08 0.0 0.0 0.941 0.04204759208325728 0.04204759208325728
	+0.1 0.0 0.0 0.954 0.04201190307520001 0.04201190307520001
	+0.12 0.0 0.0 0.962 0.04301162633521313 0.04301162633521313
	+0.14 0.0 0.0 0.973 0.04301162633521313 0.04301162633521313
	+0.16 0.0 0.0 0.978 0.04301162633521313 0.04301162633521313
	+0.18 0.0 0.0 0.983 0.04301162633521313 0.04301162633521313
	+0.2 0.0 0.0 0.992 0.04301162633521313 0.04301162633521313
	+0.22 0.0 0.0 0.994 0.04301162633521313 0.04301162633521313
	+0.24 0.0 0.0 0.997 0.04301162633521313 0.04301162633521313
	+0.26 0.0 0.0 0.998 0.04301162633521313 0.04301162633521313
	+0.28 0.0 0.0 1.0 0.04301162633521313 0.04301162633521313
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d10-x01-y02
	+Path=/REF/L3_2004_I652683/d10-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.367 0.026683328128252668 0.026683328128252668
	+0.002 0.0 0.0 0.369 0.0261725046566048 0.0261725046566048
	+0.004 0.0 0.0 0.374 0.02647640458974745 0.02647640458974745
	+0.006 0.0 0.0 0.349 0.02531797780234433 0.02531797780234433
	+0.008 0.0 0.0 0.322 0.024515301344262524 0.024515301344262524
	+0.01 0.0 0.0 0.305 0.023769728648009424 0.023769728648009424
	+0.02 0.0 0.0 0.218 0.019313207915827964 0.019313207915827964
	+0.04 0.0 0.0 0.119 0.013341664064126334 0.013341664064126334
	+0.06 0.0 0.0 0.085 0.01044030650891055 0.01044030650891055
	+0.08 0.0 0.0 0.058 0.009219544457292887 0.009219544457292887
	+0.1 0.0 0.0 0.046 0.00806225774829855 0.00806225774829855
	+0.12 0.0 0.0 0.038 0.007071067811865475 0.007071067811865475
	+0.14 0.0 0.0 0.027 0.00608276253029822 0.00608276253029822
	+0.16 0.0 0.0 0.022 0.005099019513592785 0.005099019513592785
	+0.18 0.0 0.0 0.017 0.005099019513592785 0.005099019513592785
	+0.2 0.0 0.0 0.009 0.00412310562561766 0.00412310562561766
	+0.22 0.0 0.0 0.006 0.0031622776601683794 0.0031622776601683794
	+0.24 0.0 0.0 0.003 0.0022360679774997894 0.0022360679774997894
	+0.26 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d10-x01-y03
	+Path=/REF/L3_2004_I652683/d10-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.271 0.02256102834535695 0.02256102834535695
	+0.002 0.0 0.0 0.195 0.019313207915827964 0.019313207915827964
	+0.004 0.0 0.0 0.116 0.014317821063276354 0.014317821063276354
	+0.006 0.0 0.0 0.068 0.01044030650891055 0.01044030650891055
	+0.008 0.0 0.0 0.054 0.009219544457292887 0.009219544457292887
	+0.01 0.0 0.0 0.041 0.00824621125123532 0.00824621125123532
	+0.02 0.0 0.0 0.012 0.00412310562561766 0.00412310562561766
	+0.04 0.0 0.0 0.004 0.0031622776601683794 0.0031622776601683794
	+0.06 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+0.08 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d10-x01-y04
	+Path=/REF/L3_2004_I652683/d10-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.089 0.012369316876852983 0.012369316876852983
	+0.002 0.0 0.0 0.031 0.007280109889280519 0.007280109889280519
	+0.004 0.0 0.0 0.008 0.00412310562561766 0.00412310562561766
	+0.006 0.0 0.0 0.003 0.0022360679774997894 0.0022360679774997894
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d11-x01-y01
	+Path=/REF/L3_2004_I652683/d11-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.224 0.026248809496813377 0.026248809496813377
	+0.002 0.0 0.0 0.374 0.03228002478313795 0.03228002478313795
	+0.004 0.0 0.0 0.515 0.0366742416417845 0.0366742416417845
	+0.006 0.0 0.0 0.586 0.03920459156782532 0.03920459156782532
	+0.008 0.0 0.0 0.622 0.04011234224026316 0.04011234224026316
	+0.01 0.0 0.0 0.649 0.041109609582188934 0.041109609582188934
	+0.02 0.0 0.0 0.763 0.045099889135118726 0.045099889135118726
	+0.04 0.0 0.0 0.853 0.04738143096192853 0.04738143096192853
	+0.06 0.0 0.0 0.89 0.048166378315169185 0.048166378315169185
	+0.08 0.0 0.0 0.923 0.04904079934095692 0.04904079934095692
	+0.1 0.0 0.0 0.947 0.04904079934095692 0.04904079934095692
	+0.12 0.0 0.0 0.96 0.050089919145472776 0.050089919145472776
	+0.14 0.0 0.0 0.973 0.05003998401278722 0.05003998401278722
	+0.16 0.0 0.0 0.981 0.05003998401278722 0.05003998401278722
	+0.18 0.0 0.0 0.988 0.05003998401278722 0.05003998401278722
	+0.2 0.0 0.0 0.991 0.05000999900019996 0.05000999900019996
	+0.22 0.0 0.0 0.995 0.05000999900019996 0.05000999900019996
	+0.24 0.0 0.0 0.995 0.05000999900019996 0.05000999900019996
	+0.26 0.0 0.0 0.997 0.05003998401278722 0.05003998401278722
	+0.28 0.0 0.0 1.0 0.050089919145472776 0.050089919145472776
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d11-x01-y02
	+Path=/REF/L3_2004_I652683/d11-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.37 0.03059411708155671 0.03059411708155671
	+0.002 0.0 0.0 0.369 0.03162277660168379 0.03162277660168379
	+0.004 0.0 0.0 0.352 0.030364452901377955 0.030364452901377955
	+0.006 0.0 0.0 0.316 0.02716615541441225 0.02716615541441225
	+0.008 0.0 0.0 0.303 0.027073972741361765 0.027073972741361765
	+0.01 0.0 0.0 0.29 0.0261725046566048 0.0261725046566048
	+0.02 0.0 0.0 0.209 0.021213203435596427 0.021213203435596427
	+0.04 0.0 0.0 0.141 0.01746424919657298 0.01746424919657298
	+0.06 0.0 0.0 0.11 0.014560219778561038 0.014560219778561038
	+0.08 0.0 0.0 0.077 0.011180339887498947 0.011180339887498947
	+0.1 0.0 0.0 0.053 0.009219544457292887 0.009219544457292887
	+0.12 0.0 0.0 0.04 0.008544003745317531 0.008544003745317531
	+0.14 0.0 0.0 0.027 0.006324555320336759 0.006324555320336759
	+0.16 0.0 0.0 0.019 0.005385164807134504 0.005385164807134504
	+0.18 0.0 0.0 0.012 0.004472135954999579 0.004472135954999579
	+0.2 0.0 0.0 0.01 0.00412310562561766 0.00412310562561766
	+0.22 0.0 0.0 0.005 0.0031622776601683794 0.0031622776601683794
	+0.24 0.0 0.0 0.005 0.0031622776601683794 0.0031622776601683794
	+0.26 0.0 0.0 0.003 0.0022360679774997894 0.0022360679774997894
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d11-x01-y03
	+Path=/REF/L3_2004_I652683/d11-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.219 0.023345235059857503 0.023345235059857503
	+0.002 0.0 0.0 0.185 0.021840329667841555 0.021840329667841555
	+0.004 0.0 0.0 0.101 0.01655294535724685 0.01655294535724685
	+0.006 0.0 0.0 0.079 0.013601470508735444 0.013601470508735444
	+0.008 0.0 0.0 0.062 0.012649110640673518 0.012649110640673518
	+0.01 0.0 0.0 0.051 0.010770329614269008 0.010770329614269008
	+0.02 0.0 0.0 0.026 0.008544003745317531 0.008544003745317531
	+0.04 0.0 0.0 0.006 0.0031622776601683794 0.0031622776601683794
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d11-x01-y04
	+Path=/REF/L3_2004_I652683/d11-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.115 0.01711724276862369 0.01711724276862369
	+0.002 0.0 0.0 0.053 0.01104536101718726 0.01104536101718726
	+0.004 0.0 0.0 0.032 0.009486832980505138 0.009486832980505138
	+0.006 0.0 0.0 0.02 0.007280109889280519 0.007280109889280519
	+0.008 0.0 0.0 0.013 0.006324555320336759 0.006324555320336759
	+0.01 0.0 0.0 0.011 0.006324555320336759 0.006324555320336759
	+0.02 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d12-x01-y01
	+Path=/REF/L3_2004_I652683/d12-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.252 0.031048349392520047 0.031048349392520047
	+0.002 0.0 0.0 0.343 0.0360555127546399 0.0360555127546399
	+0.004 0.0 0.0 0.491 0.041109609582188934 0.041109609582188934
	+0.006 0.0 0.0 0.577 0.04396589587396122 0.04396589587396122
	+0.008 0.0 0.0 0.619 0.04617358552246078 0.04617358552246078
	+0.01 0.0 0.0 0.656 0.04684015371452147 0.04684015371452147
	+0.02 0.0 0.0 0.763 0.048166378315169185 0.048166378315169185
	+0.04 0.0 0.0 0.866 0.051244511901275824 0.051244511901275824
	+0.06 0.0 0.0 0.908 0.052469038489379616 0.052469038489379616
	+0.08 0.0 0.0 0.932 0.05323532661682465 0.05323532661682465
	+0.1 0.0 0.0 0.947 0.054083269131959835 0.054083269131959835
	+0.12 0.0 0.0 0.967 0.05414794548272353 0.05414794548272353
	+0.14 0.0 0.0 0.984 0.054037024344425186 0.054037024344425186
	+0.16 0.0 0.0 0.988 0.054009258465563106 0.054009258465563106
	+0.18 0.0 0.0 0.991 0.054009258465563106 0.054009258465563106
	+0.2 0.0 0.0 0.991 0.055009090157900266 0.055009090157900266
	+0.22 0.0 0.0 0.991 0.055009090157900266 0.055009090157900266
	+0.24 0.0 0.0 0.991 0.055009090157900266 0.055009090157900266
	+0.26 0.0 0.0 0.991 0.055009090157900266 0.055009090157900266
	+0.28 0.0 0.0 0.991 0.054009258465563106 0.054009258465563106
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d12-x01-y02
	+Path=/REF/L3_2004_I652683/d12-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.382 0.03301514803843836 0.03301514803843836
	+0.002 0.0 0.0 0.47 0.03640054944640259 0.03640054944640259
	+0.004 0.0 0.0 0.403 0.034481879299133336 0.034481879299133336
	+0.006 0.0 0.0 0.37 0.034014702703389896 0.034014702703389896
	+0.008 0.0 0.0 0.349 0.0331058907144937 0.0331058907144937
	+0.01 0.0 0.0 0.323 0.03264965543462902 0.03264965543462902
	+0.02 0.0 0.0 0.228 0.024515301344262524 0.024515301344262524
	+0.04 0.0 0.0 0.13 0.018681541692269404 0.018681541692269404
	+0.06 0.0 0.0 0.092 0.01655294535724685 0.01655294535724685
	+0.08 0.0 0.0 0.068 0.01392838827718412 0.01392838827718412
	+0.1 0.0 0.0 0.053 0.011401754250991379 0.011401754250991379
	+0.12 0.0 0.0 0.033 0.009848857801796104 0.009848857801796104
	+0.14 0.0 0.0 0.016 0.006324555320336759 0.006324555320336759
	+0.16 0.0 0.0 0.012 0.005099019513592785 0.005099019513592785
	+0.18 0.0 0.0 0.009 0.00412310562561766 0.00412310562561766
	+0.2 0.0 0.0 0.009 0.00412310562561766 0.00412310562561766
	+0.22 0.0 0.0 0.009 0.00412310562561766 0.00412310562561766
	+0.24 0.0 0.0 0.009 0.00412310562561766 0.00412310562561766
	+0.26 0.0 0.0 0.009 0.00412310562561766 0.00412310562561766
	+0.28 0.0 0.0 0.009 0.00412310562561766 0.00412310562561766
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d12-x01-y03
	+Path=/REF/L3_2004_I652683/d12-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.253 0.026683328128252668 0.026683328128252668
	+0.002 0.0 0.0 0.16 0.022803508501982758 0.022803508501982758
	+0.004 0.0 0.0 0.106 0.0194164878389476 0.0194164878389476
	+0.006 0.0 0.0 0.052 0.015231546211727818 0.015231546211727818
	+0.008 0.0 0.0 0.032 0.01216552506059644 0.01216552506059644
	+0.01 0.0 0.0 0.021 0.011401754250991379 0.011401754250991379
	+0.02 0.0 0.0 0.009 0.008544003745317531 0.008544003745317531
	+0.04 0.0 0.0 0.004 0.005099019513592785 0.005099019513592785
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d12-x01-y04
	+Path=/REF/L3_2004_I652683/d12-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.107 0.01711724276862369 0.01711724276862369
	+0.002 0.0 0.0 0.027 0.010770329614269008 0.010770329614269008
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d13-x01-y01
	+Path=/REF/L3_2004_I652683/d13-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.252 0.03420526275297414 0.03420526275297414
	+0.002 0.0 0.0 0.365 0.0383275357934736 0.0383275357934736
	+0.004 0.0 0.0 0.458 0.04220189569201839 0.04220189569201839
	+0.006 0.0 0.0 0.454 0.0412310562561766 0.0412310562561766
	+0.008 0.0 0.0 0.619 0.052392747589718944 0.052392747589718944
	+0.01 0.0 0.0 0.657 0.05255473337388365 0.05255473337388365
	+0.02 0.0 0.0 0.707 0.05590169943749475 0.05590169943749475
	+0.04 0.0 0.0 0.793 0.06037383539249432 0.06037383539249432
	+0.06 0.0 0.0 0.913 0.060299253726725344 0.060299253726725344
	+0.08 0.0 0.0 0.951 0.061131006862311696 0.061131006862311696
	+0.1 0.0 0.0 0.972 0.06228964600958974 0.06228964600958974
	+0.12 0.0 0.0 0.978 0.06203224967708329 0.06203224967708329
	+0.14 0.0 0.0 0.98 0.06212889826803627 0.06212889826803627
	+0.16 0.0 0.0 0.982 0.06212889826803627 0.06212889826803627
	+0.18 0.0 0.0 0.985 0.06220128616033594 0.06220128616033594
	+0.2 0.0 0.0 0.987 0.06220128616033594 0.06220128616033594
	+0.22 0.0 0.0 0.993 0.06203224967708329 0.06203224967708329
	+0.24 0.0 0.0 0.994 0.06203224967708329 0.06203224967708329
	+0.26 0.0 0.0 0.994 0.06203224967708329 0.06203224967708329
	+0.28 0.0 0.0 0.994 0.06203224967708329 0.06203224967708329
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d13-x01-y02
	+Path=/REF/L3_2004_I652683/d13-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.363 0.03827531841800927 0.03827531841800927
	+0.002 0.0 0.0 0.361 0.03640054944640259 0.03640054944640259
	+0.004 0.0 0.0 0.335 0.0354682957019364 0.0354682957019364
	+0.006 0.0 0.0 0.273 0.04031128874149275 0.04031128874149275
	+0.008 0.0 0.0 0.293 0.032388269481403296 0.032388269481403296
	+0.01 0.0 0.0 0.252 0.03026549190084311 0.03026549190084311
	+0.02 0.0 0.0 0.185 0.026683328128252668 0.026683328128252668
	+0.04 0.0 0.0 0.14 0.023345235059857503 0.023345235059857503
	+0.06 0.0 0.0 0.087 0.019924858845171277 0.019924858845171277
	+0.08 0.0 0.0 0.049 0.014560219778561038 0.014560219778561038
	+0.1 0.0 0.0 0.028 0.012529964086141668 0.012529964086141668
	+0.12 0.0 0.0 0.022 0.009486832980505138 0.009486832980505138
	+0.14 0.0 0.0 0.02 0.007615773105863909 0.007615773105863909
	+0.16 0.0 0.0 0.018 0.00670820393249937 0.00670820393249937
	+0.18 0.0 0.0 0.015 0.007211102550927979 0.007211102550927979
	+0.2 0.0 0.0 0.013 0.00806225774829855 0.00806225774829855
	+0.22 0.0 0.0 0.007 0.005385164807134504 0.005385164807134504
	+0.24 0.0 0.0 0.006 0.004472135954999579 0.004472135954999579
	+0.26 0.0 0.0 0.006 0.005385164807134504 0.005385164807134504
	+0.28 0.0 0.0 0.006 0.006324555320336759 0.006324555320336759
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d13-x01-y03
	+Path=/REF/L3_2004_I652683/d13-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.255 0.0331058907144937 0.0331058907144937
	+0.002 0.0 0.0 0.193 0.028861739379323625 0.028861739379323625
	+0.004 0.0 0.0 0.135 0.027892651361962704 0.027892651361962704
	+0.006 0.0 0.0 0.047 0.022803508501982758 0.022803508501982758
	+0.008 0.0 0.0 0.033 0.022360679774997897 0.022360679774997897
	+0.01 0.0 0.0 0.032 0.021840329667841555 0.021840329667841555
	+0.02 0.0 0.0 0.093 0.046957427527495585 0.046957427527495585
	+0.04 0.0 0.0 0.067 0.05011985634456667 0.05011985634456667
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d13-x01-y04
	+Path=/REF/L3_2004_I652683/d13-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.095 0.021587033144922906 0.021587033144922906
	+0.002 0.0 0.0 0.036 0.018384776310850236 0.018384776310850236
	+0.004 0.0 0.0 0.011 0.014560219778561038 0.014560219778561038
	+0.006 0.0 0.0 0.014 0.014866068747318507 0.014866068747318507
	+0.008 0.0 0.0 0.048 0.028653097563788806 0.028653097563788806
	+0.01 0.0 0.0 0.052 0.028653097563788806 0.028653097563788806
	+0.02 0.0 0.0 0.015 0.011401754250991379 0.011401754250991379
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d14-x01-y01
	+Path=/REF/L3_2004_I652683/d14-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.265 0.014866068747318507 0.014866068747318507
	+0.002 0.0 0.0 0.392 0.018384776310850236 0.018384776310850236
	+0.004 0.0 0.0 0.524 0.021931712199461308 0.021931712199461308
	+0.006 0.0 0.0 0.594 0.02213594362117866 0.02213594362117866
	+0.008 0.0 0.0 0.64 0.022803508501982758 0.022803508501982758
	+0.01 0.0 0.0 0.668 0.023194827009486402 0.023194827009486402
	+0.02 0.0 0.0 0.785 0.02531797780234433 0.02531797780234433
	+0.04 0.0 0.0 0.876 0.0261725046566048 0.0261725046566048
	+0.06 0.0 0.0 0.915 0.027073972741361765 0.027073972741361765
	+0.08 0.0 0.0 0.943 0.02816025568065745 0.02816025568065745
	+0.1 0.0 0.0 0.957 0.0280713376952364 0.0280713376952364
	+0.12 0.0 0.0 0.969 0.0280713376952364 0.0280713376952364
	+0.14 0.0 0.0 0.98 0.0280713376952364 0.0280713376952364
	+0.16 0.0 0.0 0.98 0.0280713376952364 0.0280713376952364
	+0.18 0.0 0.0 0.984 0.0280713376952364 0.0280713376952364
	+0.2 0.0 0.0 0.987 0.02901723625709382 0.02901723625709382
	+0.22 0.0 0.0 0.991 0.029068883707497266 0.029068883707497266
	+0.24 0.0 0.0 0.998 0.02901723625709382 0.02901723625709382
	+0.26 0.0 0.0 0.998 0.02901723625709382 0.02901723625709382
	+0.28 0.0 0.0 1.0 0.02901723625709382 0.02901723625709382
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d14-x01-y02
	+Path=/REF/L3_2004_I652683/d14-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.385 0.01726267650163207 0.01726267650163207
	+0.002 0.0 0.0 0.396 0.01746424919657298 0.01746424919657298
	+0.004 0.0 0.0 0.347 0.016278820596099707 0.016278820596099707
	+0.006 0.0 0.0 0.32 0.016278820596099707 0.016278820596099707
	+0.008 0.0 0.0 0.287 0.015524174696260024 0.015524174696260024
	+0.01 0.0 0.0 0.271 0.015524174696260024 0.015524174696260024
	+0.02 0.0 0.0 0.201 0.013152946437965905 0.013152946437965905
	+0.04 0.0 0.0 0.123 0.01104536101718726 0.01104536101718726
	+0.06 0.0 0.0 0.085 0.009219544457292887 0.009219544457292887
	+0.08 0.0 0.0 0.057 0.007615773105863909 0.007615773105863909
	+0.1 0.0 0.0 0.043 0.006324555320336759 0.006324555320336759
	+0.12 0.0 0.0 0.031 0.005385164807134504 0.005385164807134504
	+0.14 0.0 0.0 0.02 0.004472135954999579 0.004472135954999579
	+0.16 0.0 0.0 0.02 0.004472135954999579 0.004472135954999579
	+0.18 0.0 0.0 0.016 0.004472135954999579 0.004472135954999579
	+0.2 0.0 0.0 0.013 0.00412310562561766 0.00412310562561766
	+0.22 0.0 0.0 0.009 0.0036055512754639895 0.0036055512754639895
	+0.24 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+0.26 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d14-x01-y03
	+Path=/REF/L3_2004_I652683/d14-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.241 0.016999999999999998 0.016999999999999998
	+0.002 0.0 0.0 0.159 0.017804493814764857 0.017804493814764857
	+0.004 0.0 0.0 0.112 0.015811388300841896 0.015811388300841896
	+0.006 0.0 0.0 0.08 0.0147648230602334 0.0147648230602334
	+0.008 0.0 0.0 0.071 0.013341664064126334 0.013341664064126334
	+0.01 0.0 0.0 0.061 0.01392838827718412 0.01392838827718412
	+0.02 0.0 0.0 0.014 0.010770329614269008 0.010770329614269008
	+0.04 0.0 0.0 0.0 0.007 0.007
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d14-x01-y04
	+Path=/REF/L3_2004_I652683/d14-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.082 0.011401754250991379 0.011401754250991379
	+0.002 0.0 0.0 0.04 0.010770329614269008 0.010770329614269008
	+0.004 0.0 0.0 0.014 0.009219544457292887 0.009219544457292887
	+0.006 0.0 0.0 0.001 0.007071067811865475 0.007071067811865475
	+0.008 0.0 0.0 0.002 0.007280109889280519 0.007280109889280519
	+
	+0.02 0.0 0.0 0.001 0.0031622776601683794 0.0031622776601683794
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d15-x01-y01
	+Path=/REF/L3_2004_I652683/d15-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.267 0.010295630140987 0.010295630140987
	+0.002 0.0 0.0 0.395 0.013038404810405297 0.013038404810405297
	+0.004 0.0 0.0 0.52 0.015811388300841896 0.015811388300841896
	+0.006 0.0 0.0 0.582 0.016401219466856725 0.016401219466856725
	+0.008 0.0 0.0 0.634 0.017204650534085254 0.017204650534085254
	+0.01 0.0 0.0 0.67 0.0161245154965971 0.0161245154965971
	+0.02 0.0 0.0 0.786 0.017492855684535902 0.017492855684535902
	+0.04 0.0 0.0 0.867 0.01676305461424021 0.01676305461424021
	+0.06 0.0 0.0 0.907 0.01746424919657298 0.01746424919657298
	+0.08 0.0 0.0 0.935 0.01746424919657298 0.01746424919657298
	+0.1 0.0 0.0 0.951 0.01746424919657298 0.01746424919657298
	+0.12 0.0 0.0 0.965 0.01726267650163207 0.01726267650163207
	+0.14 0.0 0.0 0.974 0.01746424919657298 0.01746424919657298
	+0.16 0.0 0.0 0.982 0.018248287590894658 0.018248287590894658
	+0.18 0.0 0.0 0.986 0.01811077027627483 0.01811077027627483
	+0.2 0.0 0.0 0.989 0.01811077027627483 0.01811077027627483
	+0.22 0.0 0.0 0.992 0.018027756377319945 0.018027756377319945
	+0.24 0.0 0.0 0.996 0.01811077027627483 0.01811077027627483
	+0.26 0.0 0.0 0.997 0.018027756377319945 0.018027756377319945
	+0.28 0.0 0.0 0.998 0.018027756377319945 0.018027756377319945
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d15-x01-y02
	+Path=/REF/L3_2004_I652683/d15-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.386 0.01044030650891055 0.01044030650891055
	+0.002 0.0 0.0 0.399 0.011180339887498949 0.011180339887498949
	+0.004 0.0 0.0 0.373 0.012206555615733704 0.012206555615733704
	+0.006 0.0 0.0 0.346 0.012206555615733704 0.012206555615733704
	+0.008 0.0 0.0 0.325 0.0116619037896906 0.0116619037896906
	+0.01 0.0 0.0 0.298 0.010295630140987 0.010295630140987
	+0.02 0.0 0.0 0.206 0.01131370849898476 0.01131370849898476
	+0.04 0.0 0.0 0.133 0.008602325267042627 0.008602325267042627
	+0.06 0.0 0.0 0.093 0.007211102550927979 0.007211102550927979
	+0.08 0.0 0.0 0.065 0.0058309518948453 0.0058309518948453
	+0.1 0.0 0.0 0.049 0.00565685424949238 0.00565685424949238
	+0.12 0.0 0.0 0.035 0.005 0.005
	+0.14 0.0 0.0 0.026 0.005 0.005
	+0.16 0.0 0.0 0.019 0.004242640687119285 0.004242640687119285
	+0.18 0.0 0.0 0.014 0.0036055512754639895 0.0036055512754639895
	+0.2 0.0 0.0 0.011 0.00282842712474619 0.00282842712474619
	+0.22 0.0 0.0 0.008 0.0022360679774997894 0.0022360679774997894
	+0.24 0.0 0.0 0.004 0.0022360679774997894 0.0022360679774997894
	+0.26 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+0.28 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d15-x01-y03
	+Path=/REF/L3_2004_I652683/d15-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.231 0.011401754250991379 0.011401754250991379
	+0.002 0.0 0.0 0.161 0.01 0.01
	+0.004 0.0 0.0 0.099 0.009433981132056603 0.009433981132056603
	+0.006 0.0 0.0 0.068 0.009219544457292887 0.009219544457292887
	+0.008 0.0 0.0 0.04 0.008602325267042627 0.008602325267042627
	+0.01 0.0 0.0 0.031 0.007211102550927979 0.007211102550927979
	+0.02 0.0 0.0 0.007 0.0078102496759066544 0.0078102496759066544
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d15-x01-y04
	+Path=/REF/L3_2004_I652683/d15-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.095 0.008602325267042627 0.008602325267042627
	+0.002 0.0 0.0 0.043 0.00806225774829855 0.00806225774829855
	+0.004 0.0 0.0 0.007 0.0058309518948453 0.0058309518948453
	+
	+0.008 0.0 0.0 0.001 0.004472135954999579 0.004472135954999579
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d16-x01-y01
	+Path=/REF/L3_2004_I652683/d16-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.259 0.015556349186104044 0.015556349186104044
	+0.002 0.0 0.0 0.389 0.018384776310850236 0.018384776310850236
	+0.004 0.0 0.0 0.511 0.021213203435596427 0.021213203435596427
	+0.006 0.0 0.0 0.581 0.022022715545545243 0.022022715545545243
	+0.008 0.0 0.0 0.63 0.01972308292331602 0.01972308292331602
	+0.01 0.0 0.0 0.679 0.022203603311174516 0.022203603311174516
	+0.02 0.0 0.0 0.766 0.023021728866442676 0.023021728866442676
	+0.04 0.0 0.0 0.872 0.02469817807045694 0.02469817807045694
	+0.06 0.0 0.0 0.907 0.025553864678361272 0.025553864678361272
	+0.08 0.0 0.0 0.935 0.025059928172283336 0.025059928172283336
	+0.1 0.0 0.0 0.95 0.025059928172283336 0.025059928172283336
	+0.12 0.0 0.0 0.96 0.023769728648009424 0.023769728648009424
	+0.14 0.0 0.0 0.968 0.02435159132377184 0.02435159132377184
	+0.16 0.0 0.0 0.978 0.024041630560342614 0.024041630560342614
	+0.18 0.0 0.0 0.984 0.023537204591879638 0.023537204591879638
	+0.2 0.0 0.0 0.988 0.023537204591879638 0.023537204591879638
	+0.22 0.0 0.0 0.996 0.023345235059857503 0.023345235059857503
	+0.24 0.0 0.0 0.996 0.02308679276123039 0.02308679276123039
	+0.26 0.0 0.0 0.998 0.023194827009486402 0.023194827009486402
	+0.28 0.0 0.0 0.999 0.02308679276123039 0.02308679276123039
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d16-x01-y02
	+Path=/REF/L3_2004_I652683/d16-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.397 0.0147648230602334 0.0147648230602334
	+0.002 0.0 0.0 0.416 0.016643316977093238 0.016643316977093238
	+0.004 0.0 0.0 0.404 0.017804493814764857 0.017804493814764857
	+0.006 0.0 0.0 0.368 0.016643316977093238 0.016643316977093238
	+0.008 0.0 0.0 0.326 0.018439088914585774 0.018439088914585774
	+0.01 0.0 0.0 0.303 0.015231546211727818 0.015231546211727818
	+0.02 0.0 0.0 0.215 0.016278820596099707 0.016278820596099707
	+0.04 0.0 0.0 0.128 0.014866068747318505 0.014866068747318505
	+0.06 0.0 0.0 0.093 0.015264337522473748 0.015264337522473748
	+0.08 0.0 0.0 0.065 0.013892443989449804 0.013892443989449804
	+0.1 0.0 0.0 0.05 0.01341640786499874 0.01341640786499874
	+0.12 0.0 0.0 0.04 0.010295630140987 0.010295630140987
	+0.14 0.0 0.0 0.032 0.009433981132056603 0.009433981132056603
	+0.16 0.0 0.0 0.022 0.007211102550927979 0.007211102550927979
	+0.18 0.0 0.0 0.016 0.006403124237432849 0.006403124237432849
	+0.2 0.0 0.0 0.012 0.005 0.005
	+0.22 0.0 0.0 0.004 0.0031622776601683794 0.0031622776601683794
	+0.24 0.0 0.0 0.004 0.0022360679774997894 0.0022360679774997894
	+0.26 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+0.28 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d16-x01-y03
	+Path=/REF/L3_2004_I652683/d16-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.228 0.020808652046684813 0.020808652046684813
	+0.002 0.0 0.0 0.161 0.0212602916254693 0.0212602916254693
	+0.004 0.0 0.0 0.079 0.025806975801127882 0.025806975801127882
	+0.006 0.0 0.0 0.051 0.0194164878389476 0.0194164878389476
	+0.008 0.0 0.0 0.045 0.024758836806279896 0.024758836806279896
	+0.01 0.0 0.0 0.018 0.0206155281280883 0.0206155281280883
	+0.02 0.0 0.0 0.019 0.02545584412271571 0.02545584412271571
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d16-x01-y04
	+Path=/REF/L3_2004_I652683/d16-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.08 0.014866068747318505 0.014866068747318505
	+0.002 0.0 0.0 0.028 0.012083045973594572 0.012083045973594572
	+0.004 0.0 0.0 0.002 0.0078102496759066544 0.0078102496759066544
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d17-x01-y01
	+Path=/REF/L3_2004_I652683/d17-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.267 0.013038404810405297 0.013038404810405297
	+0.002 0.0 0.0 0.372 0.016401219466856725 0.016401219466856725
	+0.004 0.0 0.0 0.492 0.019849433241279208 0.019849433241279208
	+0.006 0.0 0.0 0.573 0.021931712199461308 0.021931712199461308
	+0.008 0.0 0.0 0.619 0.022671568097509268 0.022671568097509268
	+0.01 0.0 0.0 0.661 0.024083189157584593 0.024083189157584593
	+0.02 0.0 0.0 0.764 0.023021728866442676 0.023021728866442676
	+0.04 0.0 0.0 0.852 0.025238858928247926 0.025238858928247926
	+0.06 0.0 0.0 0.893 0.023259406699226014 0.023259406699226014
	+0.08 0.0 0.0 0.926 0.023769728648009424 0.023769728648009424
	+0.1 0.0 0.0 0.944 0.02340939982143925 0.02340939982143925
	+0.12 0.0 0.0 0.963 0.02256102834535695 0.02256102834535695
	+0.14 0.0 0.0 0.967 0.023345235059857503 0.023345235059857503
	+0.16 0.0 0.0 0.977 0.023537204591879638 0.023537204591879638
	+0.18 0.0 0.0 0.982 0.023194827009486402 0.023194827009486402
	+0.2 0.0 0.0 0.99 0.02308679276123039 0.02308679276123039
	+0.22 0.0 0.0 0.992 0.023194827009486402 0.023194827009486402
	+0.24 0.0 0.0 0.996 0.02308679276123039 0.02308679276123039
	+0.26 0.0 0.0 0.997 0.023021728866442676 0.023021728866442676
	+0.28 0.0 0.0 0.997 0.02308679276123039 0.02308679276123039
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d17-x01-y02
	+Path=/REF/L3_2004_I652683/d17-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.369 0.015811388300841896 0.015811388300841896
	+0.002 0.0 0.0 0.398 0.017804493814764857 0.017804493814764857
	+0.004 0.0 0.0 0.396 0.01565247584249853 0.01565247584249853
	+0.006 0.0 0.0 0.368 0.015231546211727818 0.015231546211727818
	+0.008 0.0 0.0 0.34 0.0161245154965971 0.0161245154965971
	+0.01 0.0 0.0 0.313 0.017804493814764857 0.017804493814764857
	+0.02 0.0 0.0 0.226 0.015620499351813309 0.015620499351813309
	+0.04 0.0 0.0 0.144 0.01414213562373095 0.01414213562373095
	+0.06 0.0 0.0 0.106 0.012727922061357855 0.012727922061357855
	+0.08 0.0 0.0 0.074 0.012041594578792296 0.012041594578792296
	+0.1 0.0 0.0 0.056 0.01063014581273465 0.01063014581273465
	+0.12 0.0 0.0 0.037 0.0078102496759066544 0.0078102496759066544
	+0.14 0.0 0.0 0.033 0.0058309518948453 0.0058309518948453
	+0.16 0.0 0.0 0.023 0.007071067811865475 0.007071067811865475
	+0.18 0.0 0.0 0.018 0.0058309518948453 0.0058309518948453
	+0.2 0.0 0.0 0.01 0.004472135954999579 0.004472135954999579
	+0.22 0.0 0.0 0.008 0.004472135954999579 0.004472135954999579
	+0.24 0.0 0.0 0.004 0.0036055512754639895 0.0036055512754639895
	+0.26 0.0 0.0 0.003 0.0022360679774997894 0.0022360679774997894
	+0.28 0.0 0.0 0.003 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d17-x01-y03
	+Path=/REF/L3_2004_I652683/d17-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.245 0.015264337522473748 0.015264337522473748
	+0.002 0.0 0.0 0.179 0.016401219466856725 0.016401219466856725
	+0.004 0.0 0.0 0.104 0.0147648230602334 0.0147648230602334
	+0.006 0.0 0.0 0.054 0.016278820596099707 0.016278820596099707
	+0.008 0.0 0.0 0.041 0.015 0.015
	+0.01 0.0 0.0 0.026 0.016278820596099707 0.016278820596099707
	+0.02 0.0 0.0 0.01 0.015231546211727818 0.015231546211727818
	+0.04 0.0 0.0 0.004 0.0058309518948453 0.0058309518948453
	+0.06 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d17-x01-y04
	+Path=/REF/L3_2004_I652683/d17-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.104 0.011704699910719625 0.011704699910719625
	+0.002 0.0 0.0 0.048 0.012206555615733704 0.012206555615733704
	+0.004 0.0 0.0 0.006 0.01063014581273465 0.01063014581273465
	+0.006 0.0 0.0 0.005 0.00806225774829855 0.00806225774829855
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d18-x01-y01
	+Path=/REF/L3_2004_I652683/d18-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.251 0.009433981132056603 0.009433981132056603
	+0.002 0.0 0.0 0.379 0.012806248474865698 0.012806248474865698
	+0.004 0.0 0.0 0.509 0.016278820596099707 0.016278820596099707
	+0.006 0.0 0.0 0.583 0.018384776310850236 0.018384776310850236
	+0.008 0.0 0.0 0.627 0.0191049731745428 0.0191049731745428
	+0.01 0.0 0.0 0.666 0.018439088914585774 0.018439088914585774
	+0.02 0.0 0.0 0.765 0.017492855684535902 0.017492855684535902
	+0.04 0.0 0.0 0.855 0.01746424919657298 0.01746424919657298
	+0.06 0.0 0.0 0.9 0.018384776310850236 0.018384776310850236
	+0.08 0.0 0.0 0.926 0.01802775637731995 0.01802775637731995
	+0.1 0.0 0.0 0.942 0.01772004514666935 0.01772004514666935
	+0.12 0.0 0.0 0.955 0.01726267650163207 0.01726267650163207
	+0.14 0.0 0.0 0.966 0.018439088914585774 0.018439088914585774
	+0.16 0.0 0.0 0.974 0.018248287590894658 0.018248287590894658
	+0.18 0.0 0.0 0.981 0.018439088914585774 0.018439088914585774
	+0.2 0.0 0.0 0.983 0.018248287590894658 0.018248287590894658
	+0.22 0.0 0.0 0.991 0.018027756377319945 0.018027756377319945
	+0.24 0.0 0.0 0.995 0.01811077027627483 0.01811077027627483
	+0.26 0.0 0.0 0.996 0.018248287590894658 0.018248287590894658
	+0.28 0.0 0.0 0.997 0.018248287590894658 0.018248287590894658
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d18-x01-y02
	+Path=/REF/L3_2004_I652683/d18-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.394 0.011180339887498949 0.011180339887498949
	+0.002 0.0 0.0 0.412 0.012529964086141668 0.012529964086141668
	+0.004 0.0 0.0 0.39 0.013038404810405297 0.013038404810405297
	+0.006 0.0 0.0 0.367 0.012529964086141668 0.012529964086141668
	+0.008 0.0 0.0 0.343 0.013601470508735444 0.013601470508735444
	+0.01 0.0 0.0 0.316 0.014212670403551895 0.014212670403551895
	+0.02 0.0 0.0 0.234 0.010770329614269008 0.010770329614269008
	+0.04 0.0 0.0 0.144 0.008544003745317531 0.008544003745317531
	+0.06 0.0 0.0 0.1 0.009899494936611667 0.009899494936611667
	+0.08 0.0 0.0 0.074 0.00848528137423857 0.00848528137423857
	+0.1 0.0 0.0 0.058 0.0078102496759066544 0.0078102496759066544
	+0.12 0.0 0.0 0.045 0.0058309518948453 0.0058309518948453
	+0.14 0.0 0.0 0.034 0.006403124237432849 0.006403124237432849
	+0.16 0.0 0.0 0.026 0.005 0.005
	+0.18 0.0 0.0 0.019 0.00565685424949238 0.00565685424949238
	+0.2 0.0 0.0 0.016 0.005 0.005
	+0.22 0.0 0.0 0.008 0.0036055512754639895 0.0036055512754639895
	+0.24 0.0 0.0 0.005 0.0022360679774997894 0.0022360679774997894
	+0.26 0.0 0.0 0.004 0.0031622776601683794 0.0031622776601683794
	+0.28 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d18-x01-y03
	+Path=/REF/L3_2004_I652683/d18-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.237 0.014866068747318505 0.014866068747318505
	+0.002 0.0 0.0 0.169 0.01345362404707371 0.01345362404707371
	+0.004 0.0 0.0 0.09 0.016401219466856725 0.016401219466856725
	+0.006 0.0 0.0 0.048 0.016643316977093238 0.016643316977093238
	+0.008 0.0 0.0 0.03 0.015811388300841896 0.015811388300841896
	+0.01 0.0 0.0 0.018 0.01345362404707371 0.01345362404707371
	+0.02 0.0 0.0 0.001 0.009055385138137416 0.009055385138137416
	+0.04 0.0 0.0 0.001 0.013038404810405297 0.013038404810405297
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d18-x01-y04
	+Path=/REF/L3_2004_I652683/d18-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.093 0.008944271909999158 0.008944271909999158
	+0.002 0.0 0.0 0.034 0.008944271909999158 0.008944271909999158
	+0.004 0.0 0.0 0.011 0.007280109889280519 0.007280109889280519
	+0.006 0.0 0.0 0.002 0.005385164807134504 0.005385164807134504
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d19-x01-y01
	+Path=/REF/L3_2004_I652683/d19-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.336 0.015264337522473748 0.015264337522473748
	+0.002 0.0 0.0 0.435 0.017204650534085254 0.017204650534085254
	+0.004 0.0 0.0 0.538 0.0206155281280883 0.0206155281280883
	+0.006 0.0 0.0 0.605 0.022671568097509268 0.022671568097509268
	+0.008 0.0 0.0 0.647 0.022803508501982758 0.022803508501982758
	+0.01 0.0 0.0 0.68 0.023430749027719962 0.023430749027719962
	+0.02 0.0 0.0 0.781 0.023853720883753128 0.023853720883753128
	+0.04 0.0 0.0 0.862 0.02418677324489565 0.02418677324489565
	+0.06 0.0 0.0 0.9 0.024166091947189144 0.024166091947189144
	+0.08 0.0 0.0 0.929 0.02340939982143925 0.02340939982143925
	+0.1 0.0 0.0 0.945 0.02308679276123039 0.02308679276123039
	+0.12 0.0 0.0 0.963 0.022803508501982758 0.022803508501982758
	+0.14 0.0 0.0 0.967 0.023537204591879638 0.023537204591879638
	+0.16 0.0 0.0 0.977 0.023537204591879638 0.023537204591879638
	+0.18 0.0 0.0 0.979 0.023345235059857503 0.023345235059857503
	+0.2 0.0 0.0 0.988 0.023194827009486402 0.023194827009486402
	+0.22 0.0 0.0 0.991 0.02308679276123039 0.02308679276123039
	+0.24 0.0 0.0 0.993 0.02308679276123039 0.02308679276123039
	+0.26 0.0 0.0 0.994 0.02308679276123039 0.02308679276123039
	+0.28 0.0 0.0 0.995 0.02308679276123039 0.02308679276123039
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d19-x01-y02
	+Path=/REF/L3_2004_I652683/d19-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.38 0.0147648230602334 0.0147648230602334
	+0.002 0.0 0.0 0.379 0.017804493814764857 0.017804493814764857
	+0.004 0.0 0.0 0.367 0.017804493814764857 0.017804493814764857
	+0.006 0.0 0.0 0.339 0.0161245154965971 0.0161245154965971
	+0.008 0.0 0.0 0.317 0.0161245154965971 0.0161245154965971
	+0.01 0.0 0.0 0.294 0.0170293863659264 0.0170293863659264
	+0.02 0.0 0.0 0.212 0.015 0.015
	+0.04 0.0 0.0 0.137 0.01414213562373095 0.01414213562373095
	+0.06 0.0 0.0 0.1 0.012727922061357855 0.012727922061357855
	+0.08 0.0 0.0 0.071 0.01063014581273465 0.01063014581273465
	+0.1 0.0 0.0 0.055 0.009899494936611667 0.009899494936611667
	+0.12 0.0 0.0 0.037 0.00848528137423857 0.00848528137423857
	+0.14 0.0 0.0 0.033 0.006403124237432849 0.006403124237432849
	+0.16 0.0 0.0 0.023 0.006403124237432849 0.006403124237432849
	+0.18 0.0 0.0 0.021 0.006403124237432849 0.006403124237432849
	+0.2 0.0 0.0 0.012 0.005 0.005
	+0.22 0.0 0.0 0.009 0.004472135954999579 0.004472135954999579
	+0.24 0.0 0.0 0.007 0.0036055512754639895 0.0036055512754639895
	+0.26 0.0 0.0 0.006 0.0036055512754639895 0.0036055512754639895
	+0.28 0.0 0.0 0.005 0.0036055512754639895 0.0036055512754639895
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d19-x01-y03
	+Path=/REF/L3_2004_I652683/d19-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.214 0.016401219466856725 0.016401219466856725
	+0.002 0.0 0.0 0.157 0.018384776310850236 0.018384776310850236
	+0.004 0.0 0.0 0.088 0.015620499351813309 0.015620499351813309
	+0.006 0.0 0.0 0.05 0.014866068747318505 0.014866068747318505
	+0.008 0.0 0.0 0.035 0.013038404810405297 0.013038404810405297
	+0.01 0.0 0.0 0.026 0.014866068747318505 0.014866068747318505
	+0.02 0.0 0.0 0.005 0.00806225774829855 0.00806225774829855
	+0.04 0.0 0.0 0.002 0.00412310562561766 0.00412310562561766
	+0.06 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d19-x01-y04
	+Path=/REF/L3_2004_I652683/d19-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.064 0.010770329614269008 0.010770329614269008
	+0.002 0.0 0.0 0.024 0.010816653826391968 0.010816653826391968
	+0.004 0.0 0.0 0.005 0.008944271909999158 0.008944271909999158
	+0.006 0.0 0.0 0.006 0.008602325267042627 0.008602325267042627
	+
	+
	+0.02 0.0 0.0 0.001 0.0022360679774997894 0.0022360679774997894
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d20-x01-y01
	+Path=/REF/L3_2004_I652683/d20-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.339 0.012206555615733704 0.012206555615733704
	+0.002 0.0 0.0 0.434 0.014212670403551895 0.014212670403551895
	+0.004 0.0 0.0 0.551 0.0170293863659264 0.0170293863659264
	+0.006 0.0 0.0 0.608 0.01769180601295413 0.01769180601295413
	+0.008 0.0 0.0 0.651 0.018439088914585774 0.018439088914585774
	+0.01 0.0 0.0 0.688 0.018439088914585774 0.018439088914585774
	+0.02 0.0 0.0 0.779 0.016999999999999998 0.016999999999999998
	+0.04 0.0 0.0 0.861 0.01746424919657298 0.01746424919657298
	+0.06 0.0 0.0 0.906 0.01802775637731995 0.01802775637731995
	+0.08 0.0 0.0 0.93 0.01772004514666935 0.01772004514666935
	+0.1 0.0 0.0 0.945 0.01746424919657298 0.01746424919657298
	+0.12 0.0 0.0 0.957 0.018248287590894658 0.018248287590894658
	+0.14 0.0 0.0 0.966 0.018248287590894658 0.018248287590894658
	+0.16 0.0 0.0 0.972 0.01811077027627483 0.01811077027627483
	+0.18 0.0 0.0 0.98 0.018248287590894658 0.018248287590894658
	+0.2 0.0 0.0 0.982 0.01811077027627483 0.01811077027627483
	+0.22 0.0 0.0 0.989 0.01811077027627483 0.01811077027627483
	+0.24 0.0 0.0 0.993 0.018027756377319945 0.018027756377319945
	+0.26 0.0 0.0 0.993 0.01811077027627483 0.01811077027627483
	+0.28 0.0 0.0 0.998 0.018248287590894658 0.018248287590894658
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d20-x01-y02
	+Path=/REF/L3_2004_I652683/d20-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.401 0.013601470508735444 0.013601470508735444
	+0.002 0.0 0.0 0.408 0.013038404810405297 0.013038404810405297
	+0.004 0.0 0.0 0.374 0.012529964086141668 0.012529964086141668
	+0.006 0.0 0.0 0.344 0.013038404810405297 0.013038404810405297
	+0.008 0.0 0.0 0.32 0.012529964086141668 0.012529964086141668
	+0.01 0.0 0.0 0.292 0.0116619037896906 0.0116619037896906
	+0.02 0.0 0.0 0.213 0.009848857801796104 0.009848857801796104
	+0.04 0.0 0.0 0.133 0.008544003745317531 0.008544003745317531
	+0.06 0.0 0.0 0.094 0.009219544457292887 0.009219544457292887
	+0.08 0.0 0.0 0.07 0.0078102496759066544 0.0078102496759066544
	+0.1 0.0 0.0 0.055 0.007071067811865475 0.007071067811865475
	+0.12 0.0 0.0 0.043 0.0058309518948453 0.0058309518948453
	+0.14 0.0 0.0 0.034 0.0058309518948453 0.0058309518948453
	+0.16 0.0 0.0 0.028 0.005 0.005
	+0.18 0.0 0.0 0.02 0.005 0.005
	+0.2 0.0 0.0 0.017 0.004472135954999579 0.004472135954999579
	+0.22 0.0 0.0 0.011 0.0036055512754639895 0.0036055512754639895
	+0.24 0.0 0.0 0.007 0.00282842712474619 0.00282842712474619
	+0.26 0.0 0.0 0.007 0.0031622776601683794 0.0031622776601683794
	+0.28 0.0 0.0 0.002 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d20-x01-y03
	+Path=/REF/L3_2004_I652683/d20-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.183 0.015 0.015
	+0.002 0.0 0.0 0.132 0.014212670403551895 0.014212670403551895
	+0.004 0.0 0.0 0.07 0.014212670403551895 0.014212670403551895
	+0.006 0.0 0.0 0.045 0.015811388300841896 0.015811388300841896
	+0.008 0.0 0.0 0.029 0.015 0.015
	+0.01 0.0 0.0 0.02 0.01345362404707371 0.01345362404707371
	+0.02 0.0 0.0 0.008 0.010816653826391968 0.010816653826391968
	+0.04 0.0 0.0 0.006 0.015231546211727818 0.015231546211727818
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d20-x01-y04
	+Path=/REF/L3_2004_I652683/d20-x01-y04
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.001 0.0 0.0 0.073 0.01063014581273465 0.01063014581273465
	+0.002 0.0 0.0 0.024 0.007615773105863909 0.007615773105863909
	+0.004 0.0 0.0 0.005 0.00670820393249937 0.00670820393249937
	+0.006 0.0 0.0 0.002 0.005385164807134504 0.005385164807134504
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d21-x01-y01
	+Path=/REF/L3_2004_I652683/d21-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 1.636 0.6730267453823807 0.6730267453823807
	+0.035 0.010000000000000002 0.009999999999999995 9.12 1.4471627413667063 1.4471627413667063
	+0.055 0.010000000000000002 0.010000000000000002 9.768 1.9425756098540927 1.9425756098540927
	+0.07500000000000001 0.010000000000000009 0.009999999999999995 7.872 1.3684871208747271 1.3684871208747271
	+0.1 0.015 0.015 4.156 0.5499709083215221 0.5499709083215221
	+0.13 0.015 0.014999999999999986 3.547 0.8324091542024271 0.8324091542024271
	+0.15999999999999998 0.014999999999999986 0.015000000000000013 2.24 0.5438979683727454 0.5438979683727454
	+0.1925 0.017500000000000016 0.017499999999999988 1.244 0.4398920322079044 0.4398920322079044
	+0.22999999999999998 0.01999999999999999 0.020000000000000018 0.882 0.2623833073958784 0.2623833073958784
	+0.27 0.020000000000000018 0.019999999999999962 0.598 0.22784643951574052 0.22784643951574052
	+0.31 0.020000000000000018 0.020000000000000018 0.283 0.20094277792446286 0.20094277792446286
	+0.35 0.019999999999999962 0.020000000000000018 0.218 0.10780074211247341 0.10780074211247341
	+0.395 0.025000000000000022 0.024999999999999967 0.056 0.06363175307973214 0.06363175307973214
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d21-x01-y02
	+Path=/REF/L3_2004_I652683/d21-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 3.604 1.3448364212795547 1.3448364212795547
	+0.035 0.010000000000000002 0.009999999999999995 14.245 2.467180779756522 2.467180779756522
	+0.055 0.010000000000000002 0.010000000000000002 8.897 1.2119905115140135 1.2119905115140135
	+0.07500000000000001 0.010000000000000009 0.009999999999999995 6.593 1.4343402664639935 1.4343402664639935
	+0.1 0.015 0.015 2.989 0.7338017443424347 0.7338017443424347
	+0.13 0.015 0.014999999999999986 2.237 1.4671250798756048 1.4671250798756048
	+0.15999999999999998 0.014999999999999986 0.015000000000000013 2.229 0.6543408897509004 0.6543408897509004
	+0.1925 0.017500000000000016 0.017499999999999988 1.112 0.3433322006453808 0.3433322006453808
	+0.22999999999999998 0.01999999999999999 0.020000000000000018 0.531 0.2305558500667463 0.2305558500667463
	+0.27 0.020000000000000018 0.019999999999999962 0.42 0.18962331080328704 0.18962331080328704
	+0.31 0.020000000000000018 0.020000000000000018 0.14 0.11063453348751465 0.11063453348751465
	+0.35 0.019999999999999962 0.020000000000000018 0.168 0.097082439194738 0.097082439194738
	+0.395 0.025000000000000022 0.024999999999999967 0.046 0.040224370722237536 0.040224370722237536
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d21-x01-y03
	+Path=/REF/L3_2004_I652683/d21-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 4.737 1.3501585092128998 1.3501585092128998
	+0.035 0.010000000000000002 0.009999999999999995 12.412 1.7219210202561557 1.7219210202561557
	+0.055 0.010000000000000002 0.010000000000000002 9.618 1.5660051085485003 1.5660051085485003
	+0.07500000000000001 0.010000000000000009 0.009999999999999995 7.229 0.8032160356964994 0.8032160356964994
	+0.1 0.015 0.015 3.604 0.8308507687906416 0.8308507687906416
	+0.13 0.015 0.014999999999999986 1.722 0.551487080537704 0.551487080537704
	+0.15999999999999998 0.014999999999999986 0.015000000000000013 1.172 0.3 0.3
	+0.1925 0.017500000000000016 0.017499999999999988 0.902 0.2742353004264768 0.2742353004264768
	+0.22999999999999998 0.01999999999999999 0.020000000000000018 0.809 0.20721245136332903 0.20721245136332903
	+0.27 0.020000000000000018 0.019999999999999962 0.417 0.22453952881397074 0.22453952881397074
	+0.31 0.020000000000000018 0.020000000000000018 0.269 0.10568822072492279 0.10568822072492279
	+0.35 0.019999999999999962 0.020000000000000018 0.253 0.11967038062946068 0.11967038062946068
	+0.395 0.025000000000000022 0.024999999999999967 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d22-x01-y01
	+Path=/REF/L3_2004_I652683/d22-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 5.754 1.294222932882894 1.294222932882894
	+0.035 0.010000000000000002 0.009999999999999995 15.307 1.1506976144930516 1.1506976144930516
	+0.055 0.010000000000000002 0.010000000000000002 7.994 1.1509843613186062 1.1509843613186062
	+0.07500000000000001 0.010000000000000009 0.009999999999999995 5.056 0.46890190871865733 0.46890190871865733
	+0.1 0.015 0.015 3.569 0.48150285565092965 0.48150285565092965
	+0.13 0.015 0.014999999999999986 1.932 0.3253459696999488 0.3253459696999488
	+0.15999999999999998 0.014999999999999986 0.015000000000000013 1.462 0.22559476944291063 0.22559476944291063
	+0.1925 0.017500000000000016 0.017499999999999988 0.944 0.21111608181282637 0.21111608181282637
	+0.22999999999999998 0.01999999999999999 0.020000000000000018 0.491 0.14534097839219332 0.14534097839219332
	+0.27 0.020000000000000018 0.019999999999999962 0.397 0.1260634760745554 0.1260634760745554
	+0.31 0.020000000000000018 0.020000000000000018 0.186 0.06826419266350404 0.06826419266350404
	+0.35 0.019999999999999962 0.020000000000000018 0.092 0.04743416490252569 0.04743416490252569
	+0.395 0.025000000000000022 0.024999999999999967 0.009 0.010295630140987 0.010295630140987
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d22-x01-y02
	+Path=/REF/L3_2004_I652683/d22-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 6.277 1.448481963988506 1.448481963988506
	+0.035 0.010000000000000002 0.009999999999999995 15.551 0.8073468895090883 0.8073468895090883
	+0.055 0.010000000000000002 0.010000000000000002 8.884 0.6154648649598123 0.6154648649598123
	+0.07500000000000001 0.010000000000000009 0.009999999999999995 4.322 1.4285769142751816 1.4285769142751816
	+0.1 0.015 0.015 3.408 0.3090064724241225 0.3090064724241225
	+0.13 0.015 0.014999999999999986 1.485 0.40115458367068424 0.40115458367068424
	+0.15999999999999998 0.014999999999999986 0.015000000000000013 1.46 0.3565908019004416 0.3565908019004416
	+0.1925 0.017500000000000016 0.017499999999999988 0.894 0.2540649523251879 0.2540649523251879
	+0.22999999999999998 0.01999999999999999 0.020000000000000018 0.617 0.18835073665903196 0.18835073665903196
	+0.27 0.020000000000000018 0.019999999999999962 0.354 0.15769908052997647 0.15769908052997647
	+0.31 0.020000000000000018 0.020000000000000018 0.104 0.0641404708432983 0.0641404708432983
	+0.35 0.019999999999999962 0.020000000000000018 0.078 0.041400483088968904 0.041400483088968904
	+0.395 0.025000000000000022 0.024999999999999967 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d22-x01-y03
	+Path=/REF/L3_2004_I652683/d22-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 7.602 1.490409675223561 1.490409675223561
	+0.035 0.010000000000000002 0.009999999999999995 15.215 1.0993680002619688 1.0993680002619688
	+0.055 0.010000000000000002 0.010000000000000002 8.031 1.0989199242892997 1.0989199242892997
	+0.07500000000000001 0.010000000000000009 0.009999999999999995 3.804 0.6829480214481919 0.6829480214481919
	+0.1 0.015 0.015 3.078 0.43388132017868664 0.43388132017868664
	+0.13 0.015 0.014999999999999986 1.641 1.177074339198676 1.177074339198676
	+0.15999999999999998 0.014999999999999986 0.015000000000000013 1.563 0.4632202499891386 0.4632202499891386
	+0.1925 0.017500000000000016 0.017499999999999988 1.116 0.3712963775745732 0.3712963775745732
	+0.22999999999999998 0.01999999999999999 0.020000000000000018 0.502 0.21654098919142306 0.21654098919142306
	+0.27 0.020000000000000018 0.019999999999999962 0.296 0.12149074038789952 0.12149074038789952
	+0.31 0.020000000000000018 0.020000000000000018 0.191 0.10830050784737807 0.10830050784737807
	+0.35 0.019999999999999962 0.020000000000000018 0.047 0.04220189569201839 0.04220189569201839
	+0.395 0.025000000000000022 0.024999999999999967 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d23-x01-y01
	+Path=/REF/L3_2004_I652683/d23-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 14.875 1.6138581102438962 1.6138581102438962
	+0.037500000000000006 0.012500000000000004 0.012499999999999997 11.125 1.0889302089665802 1.0889302089665802
	+0.0625 0.012499999999999997 0.012499999999999997 5.057 0.7208335452793523 0.7208335452793523
	+0.0875 0.012499999999999997 0.012500000000000011 2.763 0.4620140690498505 0.4620140690498505
	+0.1125 0.012499999999999997 0.012499999999999997 2.046 0.3995309750194595 0.3995309750194595
	+0.1375 0.012500000000000011 0.012499999999999983 1.552 0.30948020938341114 0.30948020938341114
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 0.833 0.2310411218809327 0.2310411218809327
	+0.1875 0.012500000000000011 0.012500000000000011 0.367 0.1365283853270081 0.1365283853270081
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.461 0.1462942240828393 0.1462942240828393
	+0.2375 0.012499999999999983 0.012500000000000011 0.257 0.1189663818059539 0.1189663818059539
	+0.2625 0.012500000000000011 0.012500000000000011 0.329 0.14176741515595184 0.14176741515595184
	+0.2875 0.012499999999999956 0.012500000000000011 0.125 0.09888377015466188 0.09888377015466188
	+0.3125 0.012500000000000011 0.012500000000000011 0.05 0.05000999900019996 0.05000999900019996
	+0.3375 0.012500000000000011 0.012499999999999956 0.054 0.05474486277268398 0.05474486277268398
	+0.3625 0.012500000000000011 0.012500000000000011 0.034 0.04049691346263317 0.04049691346263317
	+0.3875 0.012500000000000011 0.012500000000000011 0.072 0.07648529270389177 0.07648529270389177
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d23-x01-y02
	+Path=/REF/L3_2004_I652683/d23-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 14.171 1.656104465304046 1.656104465304046
	+0.037500000000000006 0.012500000000000004 0.012499999999999997 11.992 1.439391885484978 1.439391885484978
	+0.0625 0.012499999999999997 0.012499999999999997 4.622 0.7634821543428503 0.7634821543428503
	+0.0875 0.012499999999999997 0.012500000000000011 2.174 0.4755123552548346 0.4755123552548346
	+0.1125 0.012499999999999997 0.012499999999999997 2.099 0.4620140690498505 0.4620140690498505
	+0.1375 0.012500000000000011 0.012499999999999983 0.941 0.3257299494980466 0.3257299494980466
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 1.327 0.3897088656933532 0.3897088656933532
	+0.1875 0.012500000000000011 0.012500000000000011 1.153 0.30592973049378513 0.30592973049378513
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.452 0.19087430418995638 0.19087430418995638
	+0.2375 0.012499999999999983 0.012500000000000011 0.274 0.14894629904767692 0.14894629904767692
	+0.2625 0.012500000000000011 0.012500000000000011 0.046 0.04601086828130936 0.04601086828130936
	+0.2875 0.012499999999999956 0.012500000000000011 0.218 0.15870097668256486 0.15870097668256486
	+0.3125 0.012500000000000011 0.012500000000000011 0.179 0.09093404203047394 0.09093404203047394
	+0.3375 0.012500000000000011 0.012499999999999956 0.161 0.21137644144984558 0.21137644144984558
	+0.3625 0.012500000000000011 0.012500000000000011 0.107 0.1406627171641441 0.1406627171641441
	+0.3875 0.012500000000000011 0.012500000000000011 0.085 0.08981091247727084 0.08981091247727084
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d23-x01-y03
	+Path=/REF/L3_2004_I652683/d23-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 19.149 1.797478789860954 1.797478789860954
	+0.037500000000000006 0.012500000000000004 0.012499999999999997 8.102 1.0808237599164814 1.0808237599164814
	+0.0625 0.012499999999999997 0.012499999999999997 3.535 0.6346124801798338 0.6346124801798338
	+0.0875 0.012499999999999997 0.012500000000000011 3.123 0.5793556765925402 0.5793556765925402
	+0.1125 0.012499999999999997 0.012499999999999997 1.626 0.42765640413771433 0.42765640413771433
	+0.1375 0.012500000000000011 0.012499999999999983 1.331 0.372307668467895 0.372307668467895
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 0.943 0.3556880655855633 0.3556880655855633
	+0.1875 0.012500000000000011 0.012500000000000011 0.635 0.24919470299346252 0.24919470299346252
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.84 0.2846137733842128 0.2846137733842128
	+0.2375 0.012499999999999983 0.012500000000000011 0.166 0.15741982086128797 0.15741982086128797
	+0.2625 0.012500000000000011 0.012500000000000011 0.195 0.13870832707519762 0.13870832707519762
	+0.2875 0.012499999999999956 0.012500000000000011 0.202 0.12240914998479484 0.12240914998479484
	+0.3125 0.012500000000000011 0.012500000000000011 0.132 0.10024470060806208 0.10024470060806208
	+0.3375 0.012500000000000011 0.012499999999999956 0.023 0.05907622195096771 0.05907622195096771
	+0.3625 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+0.3875 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d24-x01-y01
	+Path=/REF/L3_2004_I652683/d24-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 17.499 2.0693791339433187 2.0693791339433187
	+0.037500000000000006 0.012500000000000004 0.012499999999999997 8.458 1.3401984927614268 1.3401984927614268
	+0.0625 0.012499999999999997 0.012499999999999997 4.705 0.8437843326348268 0.8437843326348268
	+0.0875 0.012499999999999997 0.012500000000000011 2.454 0.656269761607222 0.656269761607222
	+0.1125 0.012499999999999997 0.012499999999999997 2.087 0.5891629655706476 0.5891629655706476
	+0.1375 0.012500000000000011 0.012499999999999983 1.55 0.5628756523425046 0.5628756523425046
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 0.957 0.452642242836437 0.452642242836437
	+0.1875 0.012500000000000011 0.012500000000000011 0.759 0.36934807431473093 0.36934807431473093
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.706 0.3683313725438006 0.3683313725438006
	+0.2375 0.012499999999999983 0.012500000000000011 0.213 0.20276587484091102 0.20276587484091102
	+0.2625 0.012500000000000011 0.012500000000000011 0.257 0.27932955446926844 0.27932955446926844
	+0.2875 0.012499999999999956 0.012500000000000011 0.206 0.24965776575143822 0.24965776575143822
	+0.3125 0.012500000000000011 0.012500000000000011 0.045 0.10800462953040485 0.10800462953040485
	+0.3375 0.012500000000000011 0.012499999999999956 0.103 0.1444749113168096 0.1444749113168096
	+0.3625 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+0.3875 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d24-x01-y02
	+Path=/REF/L3_2004_I652683/d24-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 16.92 1.586193241695349 1.586193241695349
	+0.037500000000000006 0.012500000000000004 0.012499999999999997 9.107 1.0046676067237363 1.0046676067237363
	+0.0625 0.012499999999999997 0.012499999999999997 5.099 0.6356382619068806 0.6356382619068806
	+0.0875 0.012499999999999997 0.012500000000000011 2.655 0.3020761493398643 0.3020761493398643
	+0.1125 0.012499999999999997 0.012499999999999997 1.896 0.26146701512810366 0.26146701512810366
	+0.1375 0.012500000000000011 0.012499999999999983 1.328 0.2901930391997713 0.2901930391997713
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 0.75 0.18777113729218342 0.18777113729218342
	+0.1875 0.012500000000000011 0.012500000000000011 0.598 0.17861690849412887 0.17861690849412887
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.563 0.13845215780189202 0.13845215780189202
	+0.2375 0.012499999999999983 0.012500000000000011 0.299 0.1136001760562016 0.1136001760562016
	+0.2625 0.012500000000000011 0.012500000000000011 0.247 0.15493547043850223 0.15493547043850223
	+0.2875 0.012499999999999956 0.012500000000000011 0.245 0.133843191832831 0.133843191832831
	+0.3125 0.012500000000000011 0.012500000000000011 0.194 0.13813399291991815 0.13813399291991815
	+0.3375 0.012500000000000011 0.012499999999999956 0.1 0.12780062597655772 0.12780062597655772
	+0.3625 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+0.3875 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d24-x01-y03
	+Path=/REF/L3_2004_I652683/d24-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 16.067 0.6418231843740143 0.6418231843740143
	+0.037500000000000006 0.012500000000000004 0.012499999999999997 9.908 0.3735304539123952 0.3735304539123952
	+0.0625 0.012499999999999997 0.012499999999999997 4.641 0.25913895886184307 0.25913895886184307
	+0.0875 0.012499999999999997 0.012500000000000011 2.94 0.19932385707686875 0.19932385707686875
	+0.1125 0.012499999999999997 0.012499999999999997 1.721 0.1506320019119443 0.1506320019119443
	+0.1375 0.012500000000000011 0.012499999999999983 1.494 0.19379370474811614 0.19379370474811614
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 0.952 0.11543396380615195 0.11543396380615195
	+0.1875 0.012500000000000011 0.012500000000000011 0.736 0.1208801058900926 0.1208801058900926
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.511 0.08372574275573792 0.08372574275573792
	+0.2375 0.012499999999999983 0.012500000000000011 0.424 0.08723531395025755 0.08723531395025755
	+0.2625 0.012500000000000011 0.012500000000000011 0.288 0.14543727170158274 0.14543727170158274
	+0.2875 0.012499999999999956 0.012500000000000011 0.194 0.10466135867644753 0.10466135867644753
	+0.3125 0.012500000000000011 0.012500000000000011 0.076 0.0918313671900838 0.0918313671900838
	+0.3375 0.012500000000000011 0.012499999999999956 0.019 0.06585590330410783 0.06585590330410783
	+0.3625 0.012500000000000011 0.012500000000000011 0.02 0.0657419196555744 0.0657419196555744
	+0.3875 0.012500000000000011 0.012500000000000011 0.01 0.01341640786499874 0.01341640786499874
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d25-x01-y01
	+Path=/REF/L3_2004_I652683/d25-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 16.177 0.7184267533993983 0.7184267533993983
	+0.037500000000000006 0.012500000000000004 0.012499999999999997 9.285 0.48431394776528996 0.48431394776528996
	+0.0625 0.012499999999999997 0.012499999999999997 5.302 0.42862687736538413 0.42862687736538413
	+0.0875 0.012499999999999997 0.012500000000000011 2.823 0.3076263967867517 0.3076263967867517
	+0.1125 0.012499999999999997 0.012499999999999997 1.837 0.27070278905101813 0.27070278905101813
	+0.1375 0.012500000000000011 0.012499999999999983 1.229 0.24622144504490262 0.24622144504490262
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 0.902 0.16829141392239833 0.16829141392239833
	+0.1875 0.012500000000000011 0.012500000000000011 0.732 0.2516445906432324 0.2516445906432324
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.569 0.16070469812671936 0.16070469812671936
	+0.2375 0.012499999999999983 0.012500000000000011 0.454 0.20181674856165926 0.20181674856165926
	+0.2625 0.012500000000000011 0.012500000000000011 0.366 0.1655566368346494 0.1655566368346494
	+0.2875 0.012499999999999956 0.012500000000000011 0.13 0.13744089638822934 0.13744089638822934
	+0.3125 0.012500000000000011 0.012500000000000011 0.096 0.1212023102090055 0.1212023102090055
	+0.3375 0.012500000000000011 0.012499999999999956 0.081 0.07402702209328699 0.07402702209328699
	+0.3625 0.012500000000000011 0.012500000000000011 0.015 0.026925824035672518 0.026925824035672518
	+0.3875 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d25-x01-y02
	+Path=/REF/L3_2004_I652683/d25-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 16.119 0.7288484067348984 0.7288484067348984
	+0.037500000000000006 0.012500000000000004 0.012499999999999997 9.277 0.4992995093127971 0.4992995093127971
	+0.0625 0.012499999999999997 0.012499999999999997 4.534 0.3516390194503448 0.3516390194503448
	+0.0875 0.012499999999999997 0.012500000000000011 2.947 0.3440930106817051 0.3440930106817051
	+0.1125 0.012499999999999997 0.012499999999999997 1.904 0.24136486902612814 0.24136486902612814
	+0.1375 0.012500000000000011 0.012499999999999983 1.636 0.3274049480383582 0.3274049480383582
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 1.041 0.23570532450498438 0.23570532450498438
	+0.1875 0.012500000000000011 0.012500000000000011 0.693 0.17788198334851116 0.17788198334851116
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.497 0.15860012610335467 0.15860012610335467
	+0.2375 0.012499999999999983 0.012500000000000011 0.659 0.1553319027115808 0.1553319027115808
	+0.2625 0.012500000000000011 0.012500000000000011 0.242 0.2039607805437114 0.2039607805437114
	+0.2875 0.012499999999999956 0.012500000000000011 0.328 0.195 0.195
	+0.3125 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+0.3375 0.012500000000000011 0.012499999999999956 0.11 0.11462111498323509 0.11462111498323509
	+0.3625 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+0.3875 0.012500000000000011 0.012500000000000011 0.011 0.022803508501982758 0.022803508501982758
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d25-x01-y03
	+Path=/REF/L3_2004_I652683/d25-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0125 0.0125 0.0125 16.202 0.6900992682216088 0.6900992682216088
	+0.037500000000000006 0.012500000000000004 0.012499999999999997 9.321 0.44100453512407334 0.44100453512407334
	+0.0625 0.012499999999999997 0.012499999999999997 4.637 0.29353194034039976 0.29353194034039976
	+0.0875 0.012499999999999997 0.012500000000000011 3.013 0.2245885126180767 0.2245885126180767
	+0.1125 0.012499999999999997 0.012499999999999997 1.707 0.18500270268296085 0.18500270268296085
	+0.1375 0.012500000000000011 0.012499999999999983 1.553 0.17328012003689286 0.17328012003689286
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 1.031 0.1421724305201258 0.1421724305201258
	+0.1875 0.012500000000000011 0.012500000000000011 0.624 0.11941942890501528 0.11941942890501528
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.686 0.16617159805454118 0.16617159805454118
	+0.2375 0.012499999999999983 0.012500000000000011 0.466 0.1321892582625381 0.1321892582625381
	+0.2625 0.012500000000000011 0.012500000000000011 0.208 0.12856126943990556 0.12856126943990556
	+0.2875 0.012499999999999956 0.012500000000000011 0.193 0.1632207094703365 0.1632207094703365
	+0.3125 0.012500000000000011 0.012500000000000011 0.357 0.17112568480505783 0.17112568480505783
	+0.3375 0.012500000000000011 0.012499999999999956 0.003 0.04743416490252569 0.04743416490252569
	+0.3625 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+0.3875 0.012500000000000011 0.012500000000000011 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d26-x01-y01
	+Path=/REF/L3_2004_I652683/d26-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 0.183 0.8588410795950552 0.8588410795950552
	+0.020999999999999998 0.005999999999999998 0.006000000000000002 6.119 0.792709909109253 0.792709909109253
	+0.033 0.006000000000000002 0.005999999999999998 12.263 3.5003228422532686 3.5003228422532686
	+0.045 0.005999999999999998 0.005999999999999998 16.68 2.9618619144045186 2.9618619144045186
	+0.058499999999999996 0.0075 0.007500000000000007 10.037 1.3270094197103501 1.3270094197103501
	+0.07500000000000001 0.009000000000000008 0.008999999999999994 5.589 1.2176050262708347 1.2176050262708347
	+0.093 0.008999999999999994 0.008999999999999994 6.752 2.1479788174002086 2.1479788174002086
	+0.11399999999999999 0.011999999999999997 0.01200000000000001 2.55 0.7216009977820153 0.7216009977820153
	+0.1395 0.013500000000000012 0.013499999999999984 2.029 0.6670832032063166 0.6670832032063166
	+0.16799999999999998 0.014999999999999986 0.015000000000000013 1.615 0.4526897392254435 0.4526897392254435
	+0.1995 0.016500000000000015 0.016499999999999987 0.683 0.28589508565206223 0.28589508565206223
	+0.23399999999999999 0.017999999999999988 0.018000000000000016 0.211 0.2419008061168875 0.2419008061168875
	+0.276 0.02400000000000002 0.023999999999999966 0.193 0.15023315213360863 0.15023315213360863
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d26-x01-y02
	+Path=/REF/L3_2004_I652683/d26-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 1.329 0.651850442969858 0.651850442969858
	+0.020999999999999998 0.005999999999999998 0.006000000000000002 13.192 3.4691627231941715 3.4691627231941715
	+0.033 0.006000000000000002 0.005999999999999998 19.031 3.230478911864308 3.230478911864308
	+0.045 0.005999999999999998 0.005999999999999998 11.201 3.6480259045132892 3.6480259045132892
	+0.058499999999999996 0.0075 0.007500000000000007 9.616 5.7886375771851535 5.7886375771851535
	+0.07500000000000001 0.009000000000000008 0.008999999999999994 4.482 2.0874206571747824 2.0874206571747824
	+0.093 0.008999999999999994 0.008999999999999994 3.114 0.7130981699597889 0.7130981699597889
	+0.11399999999999999 0.011999999999999997 0.01200000000000001 3.591 1.1276688343658345 1.1276688343658345
	+0.1395 0.013500000000000012 0.013499999999999984 1.312 0.5703139486282972 0.5703139486282972
	+0.16799999999999998 0.014999999999999986 0.015000000000000013 0.559 0.2638825496314601 0.2638825496314601
	+0.1995 0.016500000000000015 0.016499999999999987 0.691 0.2794154612758571 0.2794154612758571
	+0.23399999999999999 0.017999999999999988 0.018000000000000016 0.213 0.13241223508422476 0.13241223508422476
	+0.276 0.02400000000000002 0.023999999999999966 0.191 0.12587692401707312 0.12587692401707312
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d26-x01-y03
	+Path=/REF/L3_2004_I652683/d26-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 2.063 0.9433323910478215 0.9433323910478215
	+0.020999999999999998 0.005999999999999998 0.006000000000000002 14.082 1.0772427767221278 1.0772427767221278
	+0.033 0.006000000000000002 0.005999999999999998 20.593 1.9326812980934027 1.9326812980934027
	+0.045 0.005999999999999998 0.005999999999999998 12.065 1.4914972343252937 1.4914972343252937
	+0.058499999999999996 0.0075 0.007500000000000007 7.04 0.8540193206245394 0.8540193206245394
	+0.07500000000000001 0.009000000000000008 0.008999999999999994 5.751 0.6155428498488144 0.6155428498488144
	+0.093 0.008999999999999994 0.008999999999999994 3.361 0.4953271646094125 0.4953271646094125
	+0.11399999999999999 0.011999999999999997 0.01200000000000001 1.803 0.5948108943185221 0.5948108943185221
	+0.1395 0.013500000000000012 0.013499999999999984 0.928 0.28321899653801474 0.28321899653801474
	+0.16799999999999998 0.014999999999999986 0.015000000000000013 1.116 0.3264552036650664 0.3264552036650664
	+0.1995 0.016500000000000015 0.016499999999999987 0.517 0.13482581355215328 0.13482581355215328
	+0.23399999999999999 0.017999999999999988 0.018000000000000016 0.405 0.130862523283024 0.130862523283024
	+0.276 0.02400000000000002 0.023999999999999966 0.107 0.18506755523321747 0.18506755523321747
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d27-x01-y01
	+Path=/REF/L3_2004_I652683/d27-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 3.092 1.3561976257168422 1.3561976257168422
	+0.020999999999999998 0.005999999999999998 0.006000000000000002 22.135 1.4722802043089487 1.4722802043089487
	+0.033 0.006000000000000002 0.005999999999999998 15.391 1.245032128099512 1.245032128099512
	+0.045 0.005999999999999998 0.005999999999999998 10.937 2.434926076906648 2.434926076906648
	+0.058499999999999996 0.0075 0.007500000000000007 6.363 1.1414363758002457 1.1414363758002457
	+0.07500000000000001 0.009000000000000008 0.008999999999999994 4.329 1.1213465120113406 1.1213465120113406
	+0.093 0.008999999999999994 0.008999999999999994 3.554 0.5300037735714719 0.5300037735714719
	+0.11399999999999999 0.011999999999999997 0.01200000000000001 2.11 0.35533223889762666 0.35533223889762666
	+0.1395 0.013500000000000012 0.013499999999999984 1.01 0.22036787424667872 0.22036787424667872
	+0.16799999999999998 0.014999999999999986 0.015000000000000013 0.915 0.1722614292289484 0.1722614292289484
	+0.1995 0.016500000000000015 0.016499999999999987 0.415 0.2153346233191495 0.2153346233191495
	+0.23399999999999999 0.017999999999999988 0.018000000000000016 0.347 0.13420134127496638 0.13420134127496638
	+0.276 0.02400000000000002 0.023999999999999966 0.066 0.02968164415931166 0.02968164415931166
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d27-x01-y02
	+Path=/REF/L3_2004_I652683/d27-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 3.493 1.495272884793943 1.495272884793943
	+0.020999999999999998 0.005999999999999998 0.006000000000000002 21.585 1.1676716147958723 1.1676716147958723
	+0.033 0.006000000000000002 0.005999999999999998 18.963 1.4920764055503324 1.4920764055503324
	+0.045 0.005999999999999998 0.005999999999999998 10.236 1.176857680435489 1.176857680435489
	+0.058499999999999996 0.0075 0.007500000000000007 5.674 1.6715935510763373 1.6715935510763373
	+0.07500000000000001 0.009000000000000008 0.008999999999999994 3.804 0.9841061934567835 0.9841061934567835
	+0.093 0.008999999999999994 0.008999999999999994 2.835 0.4380707705382773 0.4380707705382773
	+0.11399999999999999 0.011999999999999997 0.01200000000000001 1.717 0.39121605284037103 0.39121605284037103
	+0.1395 0.013500000000000012 0.013499999999999984 1.406 0.25800193797721754 0.25800193797721754
	+0.16799999999999998 0.014999999999999986 0.015000000000000013 0.435 0.2057692882818036 0.2057692882818036
	+0.1995 0.016500000000000015 0.016499999999999987 1.017 0.3492005154635371 0.3492005154635371
	+0.23399999999999999 0.017999999999999988 0.018000000000000016 0.119 0.05292447448959697 0.05292447448959697
	+0.276 0.02400000000000002 0.023999999999999966 0.074 0.059413803110051795 0.059413803110051795
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d27-x01-y03
	+Path=/REF/L3_2004_I652683/d27-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 5.058 2.3357315770439033 2.3357315770439033
	+0.020999999999999998 0.005999999999999998 0.006000000000000002 24.679 2.146396515092214 2.146396515092214
	+0.033 0.006000000000000002 0.005999999999999998 15.534 1.6466553980721041 1.6466553980721041
	+0.045 0.005999999999999998 0.005999999999999998 8.703 1.5698614588555257 1.5698614588555257
	+0.058499999999999996 0.0075 0.007500000000000007 4.801 0.7561911134098311 0.7561911134098311
	+0.07500000000000001 0.009000000000000008 0.008999999999999994 3.787 0.8572572542708519 0.8572572542708519
	+0.093 0.008999999999999994 0.008999999999999994 2.764 0.9940080482571557 0.9940080482571557
	+0.11399999999999999 0.011999999999999997 0.01200000000000001 1.764 0.4034959727184399 0.4034959727184399
	+0.1395 0.013500000000000012 0.013499999999999984 1.732 0.4459820624195552 0.4459820624195552
	+0.16799999999999998 0.014999999999999986 0.015000000000000013 0.978 0.38946630149475064 0.38946630149475064
	+0.1995 0.016500000000000015 0.016499999999999987 0.394 0.14400347218036097 0.14400347218036097
	+0.23399999999999999 0.017999999999999988 0.018000000000000016 0.305 0.13753544997563355 0.13753544997563355
	+0.276 0.02400000000000002 0.023999999999999966 0.099 0.05556977595779922 0.05556977595779922
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d28-x01-y01
	+Path=/REF/L3_2004_I652683/d28-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 16.201 1.979815395434635 1.979815395434635
	+0.0225 0.0075 0.0075 18.462 1.7563077748504106 1.7563077748504106
	+0.0375 0.0075 0.0075 10.243 1.3047992182707653 1.3047992182707653
	+0.0525 0.0075 0.0075 6.326 1.0443035957038547 1.0443035957038547
	+0.0675 0.007500000000000007 0.007499999999999993 3.81 0.687654709865351 0.687654709865351
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 3.533 0.6791178101036668 0.6791178101036668
	+0.0975 0.007500000000000007 0.007499999999999993 1.987 0.5492585911936199 0.5492585911936199
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.731 0.5174794681917342 0.5174794681917342
	+0.1275 0.007500000000000007 0.007500000000000007 0.64 0.2726242835845699 0.2726242835845699
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.045 0.33362403990120376 0.33362403990120376
	+0.1575 0.007500000000000007 0.007500000000000007 0.256 0.1654841382127 0.1654841382127
	+0.1725 0.007499999999999979 0.007500000000000007 0.859 0.3342528982671654 0.3342528982671654
	+0.1875 0.007500000000000007 0.007500000000000007 0.422 0.21310091506138587 0.21310091506138587
	+0.2025 0.007500000000000007 0.007499999999999979 0.18 0.11415778554264269 0.11415778554264269
	+0.2175 0.007500000000000007 0.007500000000000007 0.183 0.12901550294441363 0.12901550294441363
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.34 0.20525106577067997 0.20525106577067997
	+0.2475 0.007500000000000007 0.007500000000000007 0.314 0.21390885909657878 0.21390885909657878
	+0.2625 0.007500000000000007 0.007500000000000007 0.067 0.07907591289387686 0.07907591289387686
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.067 0.07083784299369936 0.07083784299369936
	+0.2925 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d28-x01-y02
	+Path=/REF/L3_2004_I652683/d28-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 15.749 2.2587883920367573 2.2587883920367573
	+0.0225 0.0075 0.0075 22.091 2.6566665202843955 2.6566665202843955
	+0.0375 0.0075 0.0075 8.738 1.419026779169442 1.419026779169442
	+0.0525 0.0075 0.0075 4.134 0.9977820403274454 0.9977820403274454
	+0.0675 0.007500000000000007 0.007499999999999993 3.169 0.9602832915343263 0.9602832915343263
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 3.11 0.8211905990694244 0.8211905990694244
	+0.0975 0.007500000000000007 0.007499999999999993 1.982 0.5954603261343278 0.5954603261343278
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.525 0.5167668720032274 0.5167668720032274
	+0.1275 0.007500000000000007 0.007500000000000007 1.235 0.5143947900202722 0.5143947900202722
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.744 0.566364723477725 0.566364723477725
	+0.1575 0.007500000000000007 0.007500000000000007 1.084 0.3757046712512369 0.3757046712512369
	+0.1725 0.007499999999999979 0.007500000000000007 0.375 0.22429444932944728 0.22429444932944728
	+0.1875 0.007500000000000007 0.007500000000000007 0.493 0.247315587862957 0.247315587862957
	+0.2025 0.007500000000000007 0.007499999999999979 0.65 0.2632052431088712 0.2632052431088712
	+0.2175 0.007500000000000007 0.007500000000000007 0.082 0.08440379138403678 0.08440379138403678
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.086 0.1252078272313676 0.1252078272313676
	+0.2475 0.007500000000000007 0.007500000000000007 0.072 0.07920227269466451 0.07920227269466451
	+0.2625 0.007500000000000007 0.007500000000000007 0.089 0.09272000862812729 0.09272000862812729
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.158 0.17431580536486072 0.17431580536486072
	+0.2925 0.007500000000000007 0.007500000000000007 0.1 0.11713667231059623 0.11713667231059623
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d28-x01-y03
	+Path=/REF/L3_2004_I652683/d28-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 24.327 2.4203869525346557 2.4203869525346557
	+0.0225 0.0075 0.0075 14.684 2.0758925791090443 2.0758925791090443
	+0.0375 0.0075 0.0075 7.505 1.205192930613186 1.205192930613186
	+0.0525 0.0075 0.0075 4.597 1.026031188609781 1.026031188609781
	+0.0675 0.007500000000000007 0.007499999999999993 3.471 0.9038478854320565 0.9038478854320565
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 3.026 0.9110965920252364 0.9110965920252364
	+0.0975 0.007500000000000007 0.007499999999999993 1.736 0.6786464469810477 0.6786464469810477
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.727 0.647222527420052 0.647222527420052
	+0.1275 0.007500000000000007 0.007500000000000007 1.184 0.49317035596231856 0.49317035596231856
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.097 0.4467807068350199 0.4467807068350199
	+0.1575 0.007500000000000007 0.007500000000000007 0.981 0.5035642957954823 0.5035642957954823
	+0.1725 0.007499999999999979 0.007500000000000007 0.656 0.3564337245547901 0.3564337245547901
	+0.1875 0.007500000000000007 0.007500000000000007 0.631 0.3306433123473088 0.3306433123473088
	+0.2025 0.007500000000000007 0.007499999999999979 0.604 0.39358099547615355 0.39358099547615355
	+0.2175 0.007500000000000007 0.007500000000000007 0.153 0.16215116404145855 0.16215116404145855
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.047 0.10207840124139875 0.10207840124139875
	+0.2475 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+0.2625 0.007500000000000007 0.007500000000000007 0.176 0.17104677722775136 0.17104677722775136
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.065 0.08702298546935745 0.08702298546935745
	+0.2925 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d29-x01-y01
	+Path=/REF/L3_2004_I652683/d29-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 20.528 2.501603485766679 2.501603485766679
	+0.0225 0.0075 0.0075 14.956 2.485410428882924 2.485410428882924
	+0.0375 0.0075 0.0075 9.336 1.5148042777864077 1.5148042777864077
	+0.0525 0.0075 0.0075 4.641 1.4523498201191063 1.4523498201191063
	+0.0675 0.007500000000000007 0.007499999999999993 4.249 1.1529705113314912 1.1529705113314912
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 3.184 1.1358001584785944 1.1358001584785944
	+0.0975 0.007500000000000007 0.007499999999999993 2.702 0.9317091820949281 0.9317091820949281
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 2.16 0.8013401275363664 0.8013401275363664
	+0.1275 0.007500000000000007 0.007500000000000007 0.92 0.8332760646988489 0.8332760646988489
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 2.023 1.0676371106326343 1.0676371106326343
	+0.1575 0.007500000000000007 0.007500000000000007 0.564 0.5114528326248667 0.5114528326248667
	+0.1725 0.007499999999999979 0.007500000000000007 0.334 0.31702523558858847 0.31702523558858847
	+0.1875 0.007500000000000007 0.007500000000000007 0.342 0.3166228039797513 0.3166228039797513
	+0.2025 0.007500000000000007 0.007499999999999979 0.177 0.23551220775153037 0.23551220775153037
	+0.2175 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.201 0.21833002542023394 0.21833002542023394
	+0.2475 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+0.2625 0.007500000000000007 0.007500000000000007 0.101 0.14600342461736984 0.14600342461736984
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.113 0.15208221460775745 0.15208221460775745
	+0.2925 0.007500000000000007 0.007500000000000007 0.136 0.1970913493789111 0.1970913493789111
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d29-x01-y02
	+Path=/REF/L3_2004_I652683/d29-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 21.698 2.49865503821556 2.49865503821556
	+0.0225 0.0075 0.0075 15.979 1.7410341754256289 1.7410341754256289
	+0.0375 0.0075 0.0075 9.381 1.026505236226294 1.026505236226294
	+0.0525 0.0075 0.0075 5.032 0.7263952092353033 0.7263952092353033
	+0.0675 0.007500000000000007 0.007499999999999993 3.422 0.6755183195147264 0.6755183195147264
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 2.524 0.40230461096040154 0.40230461096040154
	+0.0975 0.007500000000000007 0.007499999999999993 1.987 0.4002811511925087 0.4002811511925087
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.457 0.3559845502265513 0.3559845502265513
	+0.1275 0.007500000000000007 0.007500000000000007 1.171 0.3162056292984045 0.3162056292984045
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.089 0.3156596268134397 0.3156596268134397
	+0.1575 0.007500000000000007 0.007500000000000007 0.831 0.2539310930154084 0.2539310930154084
	+0.1725 0.007499999999999979 0.007500000000000007 0.346 0.18648860555004426 0.18648860555004426
	+0.1875 0.007500000000000007 0.007500000000000007 0.448 0.15902201105507377 0.15902201105507377
	+0.2025 0.007500000000000007 0.007499999999999979 0.345 0.16055217220579732 0.16055217220579732
	+0.2175 0.007500000000000007 0.007500000000000007 0.157 0.12093386622447824 0.12093386622447824
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.061 0.12096693763173473 0.12096693763173473
	+0.2475 0.007500000000000007 0.007500000000000007 0.338 0.16883423823383692 0.16883423823383692
	+0.2625 0.007500000000000007 0.007500000000000007 0.228 0.16683225107874075 0.16683225107874075
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.175 0.10165136496870075 0.10165136496870075
	+0.2925 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d29-x01-y03
	+Path=/REF/L3_2004_I652683/d29-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 20.41 0.9254020747761484 0.9254020747761484
	+0.0225 0.0075 0.0075 16.738 0.7074326823097729 0.7074326823097729
	+0.0375 0.0075 0.0075 8.711 0.48619851912567563 0.48619851912567563
	+0.0525 0.0075 0.0075 5.259 0.41142800099166804 0.41142800099166804
	+0.0675 0.007500000000000007 0.007499999999999993 3.489 0.27965872058636043 0.27965872058636043
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 2.641 0.2551960031034969 0.2551960031034969
	+0.0975 0.007500000000000007 0.007499999999999993 2.037 0.2263846284534354 0.2263846284534354
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.799 0.2906905571221742 0.2906905571221742
	+0.1275 0.007500000000000007 0.007500000000000007 1.058 0.16735889578985635 0.16735889578985635
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.158 0.16536626016210199 0.16536626016210199
	+0.1575 0.007500000000000007 0.007500000000000007 0.657 0.12935609765295178 0.12935609765295178
	+0.1725 0.007499999999999979 0.007500000000000007 0.805 0.15725775020646837 0.15725775020646837
	+0.1875 0.007500000000000007 0.007500000000000007 0.554 0.13940229553346675 0.13940229553346675
	+0.2025 0.007500000000000007 0.007499999999999979 0.336 0.12124768039018315 0.12124768039018315
	+0.2175 0.007500000000000007 0.007500000000000007 0.344 0.0941541289588513 0.0941541289588513
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.116 0.07433034373659253 0.07433034373659253
	+0.2475 0.007500000000000007 0.007500000000000007 0.232 0.0810246875958186 0.0810246875958186
	+0.2625 0.007500000000000007 0.007500000000000007 0.156 0.06324555320336758 0.06324555320336758
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.099 0.08527602242131138 0.08527602242131138
	+0.2925 0.007500000000000007 0.007500000000000007 0.069 0.04606517122512409 0.04606517122512409
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d30-x01-y01
	+Path=/REF/L3_2004_I652683/d30-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 20.87 1.0146945353159247 1.0146945353159247
	+0.0225 0.0075 0.0075 16.523 1.0045780208624913 1.0045780208624913
	+0.0375 0.0075 0.0075 8.747 0.8044532304615353 0.8044532304615353
	+0.0525 0.0075 0.0075 5.854 0.6889593601947795 0.6889593601947795
	+0.0675 0.007500000000000007 0.007499999999999993 3.817 0.49357876777673493 0.49357876777673493
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 2.036 0.3796972478172577 0.3796972478172577
	+0.0975 0.007500000000000007 0.007499999999999993 2.06 0.3651260056473655 0.3651260056473655
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.795 0.41581726755871984 0.41581726755871984
	+0.1275 0.007500000000000007 0.007500000000000007 1.065 0.3114434138009664 0.3114434138009664
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 0.84 0.30688760157425715 0.30688760157425715
	+0.1575 0.007500000000000007 0.007500000000000007 0.577 0.24300205760445734 0.24300205760445734
	+0.1725 0.007499999999999979 0.007500000000000007 0.394 0.147648230602334 0.147648230602334
	+0.1875 0.007500000000000007 0.007500000000000007 0.522 0.1970913493789111 0.1970913493789111
	+0.2025 0.007500000000000007 0.007499999999999979 0.302 0.2102308255228048 0.2102308255228048
	+0.2175 0.007500000000000007 0.007500000000000007 0.592 0.2539310930154084 0.2539310930154084
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.388 0.2432817296880306 0.2432817296880306
	+0.2475 0.007500000000000007 0.007500000000000007 0.111 0.1082266141020775 0.1082266141020775
	+0.2625 0.007500000000000007 0.007500000000000007 0.022 0.05035871324805669 0.05035871324805669
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.089 0.07615773105863909 0.07615773105863909
	+0.2925 0.007500000000000007 0.007500000000000007 0.064 0.09718538984847465 0.09718538984847465
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d30-x01-y02
	+Path=/REF/L3_2004_I652683/d30-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 20.671 1.073421631978786 1.073421631978786
	+0.0225 0.0075 0.0075 16.098 0.8846157357858835 0.8846157357858835
	+0.0375 0.0075 0.0075 8.739 0.6981246307071539 0.6981246307071539
	+0.0525 0.0075 0.0075 4.727 0.5295554739590556 0.5295554739590556
	+0.0675 0.007500000000000007 0.007499999999999993 3.701 0.45038761084203904 0.45038761084203904
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 2.676 0.6237603706552701 0.6237603706552701
	+0.0975 0.007500000000000007 0.007499999999999993 2.64 0.4419683246568695 0.4419683246568695
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.571 0.30871507899679923 0.30871507899679923
	+0.1275 0.007500000000000007 0.007500000000000007 1.46 0.5008922039720722 0.5008922039720722
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.098 0.2752035610234722 0.2752035610234722
	+0.1575 0.007500000000000007 0.007500000000000007 0.586 0.21833231551925614 0.21833231551925614
	+0.1725 0.007499999999999979 0.007500000000000007 0.502 0.19858751219550538 0.19858751219550538
	+0.1875 0.007500000000000007 0.007500000000000007 0.218 0.09464142856064674 0.09464142856064674
	+0.2025 0.007500000000000007 0.007499999999999979 0.407 0.1712921480979207 0.1712921480979207
	+0.2175 0.007500000000000007 0.007500000000000007 0.469 0.17800000000000002 0.17800000000000002
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.388 0.17664653973401234 0.17664653973401234
	+0.2475 0.007500000000000007 0.007500000000000007 0.496 0.26389770745499097 0.26389770745499097
	+0.2625 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.119 0.09712878049270464 0.09712878049270464
	+0.2925 0.007500000000000007 0.007500000000000007 0.102 0.10261578825892242 0.10261578825892242
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d30-x01-y03
	+Path=/REF/L3_2004_I652683/d30-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 21.199 1.0107586259834738 1.0107586259834738
	+0.0225 0.0075 0.0075 15.088 0.6776614198845909 0.6776614198845909
	+0.0375 0.0075 0.0075 9.048 0.5930935845210266 0.5930935845210266
	+0.0525 0.0075 0.0075 5.218 0.41058494857946265 0.41058494857946265
	+0.0675 0.007500000000000007 0.007499999999999993 3.669 0.311004823113726 0.311004823113726
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 3.101 0.3665760494085777 0.3665760494085777
	+0.0975 0.007500000000000007 0.007499999999999993 2.133 0.26551459470243816 0.26551459470243816
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.634 0.2693584971743049 0.2693584971743049
	+0.1275 0.007500000000000007 0.007500000000000007 1.142 0.21351580737734618 0.21351580737734618
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 0.764 0.2863092733391638 0.2863092733391638
	+0.1575 0.007500000000000007 0.007500000000000007 0.738 0.189992105099133 0.189992105099133
	+0.1725 0.007499999999999979 0.007500000000000007 0.735 0.1654841382127 0.1654841382127
	+0.1875 0.007500000000000007 0.007500000000000007 0.642 0.16638509548634456 0.16638509548634456
	+0.2025 0.007500000000000007 0.007499999999999979 0.444 0.15128780519261956 0.15128780519261956
	+0.2175 0.007500000000000007 0.007500000000000007 0.387 0.218908656749796 0.218908656749796
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.119 0.15498709623707388 0.15498709623707388
	+0.2475 0.007500000000000007 0.007500000000000007 0.069 0.09013878188659974 0.09013878188659974
	+0.2625 0.007500000000000007 0.007500000000000007 0.283 0.1027861858422619 0.1027861858422619
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.139 0.1039471019317037 0.1039471019317037
	+0.2925 0.007500000000000007 0.007500000000000007 0.116 0.05961543424315552 0.05961543424315552
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d31-x01-y01
	+Path=/REF/L3_2004_I652683/d31-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.02 0.02 0.02 0.229 0.12220065466273085 0.12220065466273085
	+0.05500000000000001 0.015000000000000006 0.015 2.056 0.4195616760382197 0.4195616760382197
	+0.085 0.015 0.015 7.981 1.1907564822414363 1.1907564822414363
	+0.115 0.015 0.015 7.756 0.7955029855380807 0.7955029855380807
	+0.14500000000000002 0.015000000000000013 0.014999999999999986 4.514 0.7863841300535 0.7863841300535
	+0.175 0.014999999999999986 0.015000000000000013 3.935 1.063609420793178 1.063609420793178
	+0.20500000000000002 0.015000000000000013 0.014999999999999986 2.887 0.7966486050951197 0.7966486050951197
	+0.235 0.014999999999999986 0.015000000000000013 1.817 0.36891733491393436 0.36891733491393436
	+0.265 0.015000000000000013 0.015000000000000013 0.732 0.30197516454172185 0.30197516454172185
	+0.29500000000000004 0.015000000000000013 0.014999999999999958 0.849 0.35967346301888886 0.35967346301888886
	+0.325 0.015000000000000013 0.015000000000000013 0.372 0.19740820651634522 0.19740820651634522
	+0.37 0.02999999999999997 0.030000000000000027 0.064 0.040816663263917106 0.040816663263917106
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d31-x01-y02
	+Path=/REF/L3_2004_I652683/d31-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.02 0.02 0.02 0.445 0.2760615873315228 0.2760615873315228
	+0.05500000000000001 0.015000000000000006 0.015 5.108 1.1958946441890272 1.1958946441890272
	+0.085 0.015 0.015 9.488 1.80154628028258 1.80154628028258
	+0.115 0.015 0.015 5.946 0.7898385911058032 0.7898385911058032
	+0.14500000000000002 0.015000000000000013 0.014999999999999986 4.592 0.8796931283123678 0.8796931283123678
	+0.175 0.014999999999999986 0.015000000000000013 2.816 0.9336134103578418 0.9336134103578418
	+0.20500000000000002 0.015000000000000013 0.014999999999999986 2.26 0.48758178801099616 0.48758178801099616
	+0.235 0.014999999999999986 0.015000000000000013 1.136 0.4354595273960601 0.4354595273960601
	+0.265 0.015000000000000013 0.015000000000000013 0.704 0.2673798795721174 0.2673798795721174
	+0.29500000000000004 0.015000000000000013 0.014999999999999958 0.408 0.22831995094603535 0.22831995094603535
	+0.325 0.015000000000000013 0.015000000000000013 0.168 0.11880235687897779 0.11880235687897779
	+0.37 0.02999999999999997 0.030000000000000027 0.058 0.0354400902933387 0.0354400902933387
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d31-x01-y03
	+Path=/REF/L3_2004_I652683/d31-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.02 0.02 0.02 0.232 0.1279531164137865 0.1279531164137865
	+0.05500000000000001 0.015000000000000006 0.015 6.125 1.566660780130785 1.566660780130785
	+0.085 0.015 0.015 9.335 0.7289842247950226 0.7289842247950226
	+0.115 0.015 0.015 6.114 0.47641368578159043 0.47641368578159043
	+0.14500000000000002 0.015000000000000013 0.014999999999999986 4.384 0.6195627490416125 0.6195627490416125
	+0.175 0.014999999999999986 0.015000000000000013 2.529 0.3157926534927626 0.3157926534927626
	+0.20500000000000002 0.015000000000000013 0.014999999999999986 1.289 0.8551847753555952 0.8551847753555952
	+0.235 0.014999999999999986 0.015000000000000013 1.452 0.3001466308323317 0.3001466308323317
	+0.265 0.015000000000000013 0.015000000000000013 0.94 0.3333616654626023 0.3333616654626023
	+0.29500000000000004 0.015000000000000013 0.014999999999999958 0.384 0.13875518008348373 0.13875518008348373
	+0.325 0.015000000000000013 0.015000000000000013 0.402 0.17397126199461796 0.17397126199461796
	+0.37 0.02999999999999997 0.030000000000000027 0.035 0.029068883707497266 0.029068883707497266
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d32-x01-y01
	+Path=/REF/L3_2004_I652683/d32-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.02 0.02 0.02 0.243 0.12466354719804823 0.12466354719804823
	+0.05500000000000001 0.015000000000000006 0.015 8.069 1.0458800122384977 1.0458800122384977
	+0.085 0.015 0.015 8.805 0.41214681850039797 0.41214681850039797
	+0.115 0.015 0.015 5.694 0.4090036674652197 0.4090036674652197
	+0.14500000000000002 0.015000000000000013 0.014999999999999986 3.663 0.42698594824654357 0.42698594824654357
	+0.175 0.014999999999999986 0.015000000000000013 2.536 0.23935329536064465 0.23935329536064465
	+0.20500000000000002 0.015000000000000013 0.014999999999999986 1.384 0.3614484748895754 0.3614484748895754
	+0.235 0.014999999999999986 0.015000000000000013 1.42 0.423727506777646 0.423727506777646
	+0.265 0.015000000000000013 0.015000000000000013 0.723 0.1711432148815722 0.1711432148815722
	+0.29500000000000004 0.015000000000000013 0.014999999999999958 0.488 0.17991386828146408 0.17991386828146408
	+0.325 0.015000000000000013 0.015000000000000013 0.184 0.10167103815738285 0.10167103815738285
	+0.37 0.02999999999999997 0.030000000000000027 0.022 0.015811388300841896 0.015811388300841896
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d32-x01-y02
	+Path=/REF/L3_2004_I652683/d32-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.02 0.02 0.02 0.324 0.18462123388169627 0.18462123388169627
	+0.05500000000000001 0.015000000000000006 0.015 8.448 1.2156117801337727 1.2156117801337727
	+0.085 0.015 0.015 9.377 0.45810915729769036 0.45810915729769036
	+0.115 0.015 0.015 5.446 0.9992602263674863 0.9992602263674863
	+0.14500000000000002 0.015000000000000013 0.014999999999999986 3.437 0.49600403224167444 0.49600403224167444
	+0.175 0.014999999999999986 0.015000000000000013 2.341 0.6432573357529628 0.6432573357529628
	+0.20500000000000002 0.015000000000000013 0.014999999999999986 1.551 0.2322003445303215 0.2322003445303215
	+0.235 0.014999999999999986 0.015000000000000013 0.999 0.2408422720371156 0.2408422720371156
	+0.265 0.015000000000000013 0.015000000000000013 0.886 0.26447306101000156 0.26447306101000156
	+0.29500000000000004 0.015000000000000013 0.014999999999999958 0.267 0.17963574254585307 0.17963574254585307
	+0.325 0.015000000000000013 0.015000000000000013 0.115 0.09050966799187808 0.09050966799187808
	+0.37 0.02999999999999997 0.030000000000000027 0.017 0.015620499351813309 0.015620499351813309
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d32-x01-y03
	+Path=/REF/L3_2004_I652683/d32-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.02 0.02 0.02 0.637 0.3265287123669219 0.3265287123669219
	+0.05500000000000001 0.015000000000000006 0.015 9.054 1.2428616173975282 1.2428616173975282
	+0.085 0.015 0.015 8.5 1.235612398772366 1.235612398772366
	+0.115 0.015 0.015 5.978 0.5780112455653437 0.5780112455653437
	+0.14500000000000002 0.015000000000000013 0.014999999999999986 2.353 0.5606005708166912 0.5606005708166912
	+0.175 0.014999999999999986 0.015000000000000013 2.51 0.7089351169183257 0.7089351169183257
	+0.20500000000000002 0.015000000000000013 0.014999999999999986 1.557 0.3765912903931794 0.3765912903931794
	+0.235 0.014999999999999986 0.015000000000000013 1.465 0.40690170803278775 0.40690170803278775
	+0.265 0.015000000000000013 0.015000000000000013 0.609 0.25748398008419865 0.25748398008419865
	+0.29500000000000004 0.015000000000000013 0.014999999999999958 0.248 0.12175795661885921 0.12175795661885921
	+0.325 0.015000000000000013 0.015000000000000013 0.185 0.1329661611087573 0.1329661611087573
	+0.37 0.02999999999999997 0.030000000000000027 0.012 0.019209372712298545 0.019209372712298545
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d33-x01-y01
	+Path=/REF/L3_2004_I652683/d33-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.082 0.09362157870918433 0.09362157870918433
	+0.03 0.009999999999999998 0.010000000000000002 4.01 0.8287822391919364 0.8287822391919364
	+0.05 0.010000000000000002 0.009999999999999995 11.651 1.227 1.227
	+0.07 0.010000000000000009 0.009999999999999995 8.865 0.9757791758384681 0.9757791758384681
	+0.09 0.009999999999999995 0.010000000000000009 7.778 1.2473395688424223 1.2473395688424223
	+0.11 0.009999999999999995 0.009999999999999995 4.239 0.7467181529867879 0.7467181529867879
	+0.13 0.010000000000000009 0.010000000000000009 3.78 0.6401538877488756 0.6401538877488756
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 2.509 0.46401077573694344 0.46401077573694344
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 2.031 0.42991278185231946 0.42991278185231946
	+0.19 0.010000000000000009 0.010000000000000009 1.82 0.3959217094325594 0.3959217094325594
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 0.897 0.2467589917307979 0.2467589917307979
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 0.79 0.2303584163862914 0.2303584163862914
	+0.25 0.010000000000000009 0.010000000000000009 0.363 0.17528548142958103 0.17528548142958103
	+0.27 0.010000000000000009 0.010000000000000009 0.629 0.24930302846134864 0.24930302846134864
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.227 0.11691449867317569 0.11691449867317569
	+0.31 0.010000000000000009 0.010000000000000009 0.052 0.056648036153074184 0.056648036153074184
	+0.33 0.010000000000000009 0.010000000000000009 0.086 0.06419501538281613 0.06419501538281613
	+0.35 0.009999999999999953 0.010000000000000009 0.092 0.07905694150420949 0.07905694150420949
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d33-x01-y02
	+Path=/REF/L3_2004_I652683/d33-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.103 0.1184440796325422 0.1184440796325422
	+0.03 0.009999999999999998 0.010000000000000002 5.454 1.2946018693019101 1.2946018693019101
	+0.05 0.010000000000000002 0.009999999999999995 11.111 1.6130728439844249 1.6130728439844249
	+0.07 0.010000000000000009 0.009999999999999995 8.945 1.1143271512441937 1.1143271512441937
	+0.09 0.009999999999999995 0.010000000000000009 7.419 1.1422731722315815 1.1422731722315815
	+0.11 0.009999999999999995 0.009999999999999995 3.464 0.709074044088486 0.709074044088486
	+0.13 0.010000000000000009 0.010000000000000009 3.259 0.6849846713613379 0.6849846713613379
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 2.237 0.5414766846319424 0.5414766846319424
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 1.568 0.4329457240809753 0.4329457240809753
	+0.19 0.010000000000000009 0.010000000000000009 1.865 0.5274552113687 0.5274552113687
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 1.516 0.47443650787012587 0.47443650787012587
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 1.074 0.3469437994834322 0.3469437994834322
	+0.25 0.010000000000000009 0.010000000000000009 0.661 0.24794555854057962 0.24794555854057962
	+0.27 0.010000000000000009 0.010000000000000009 0.548 0.22005681084665385 0.22005681084665385
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.198 0.12209013064126027 0.12209013064126027
	+0.31 0.010000000000000009 0.010000000000000009 0.252 0.16018114745499862 0.16018114745499862
	+0.33 0.010000000000000009 0.010000000000000009 0.217 0.1752369823981228 0.1752369823981228
	+0.35 0.009999999999999953 0.010000000000000009 0.108 0.07955501241279521 0.07955501241279521
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d33-x01-y03
	+Path=/REF/L3_2004_I652683/d33-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.117 0.1134063490286148 0.1134063490286148
	+0.03 0.009999999999999998 0.010000000000000002 9.224 1.5207162786003179 1.5207162786003179
	+0.05 0.010000000000000002 0.009999999999999995 9.486 1.6440696457267252 1.6440696457267252
	+0.07 0.010000000000000009 0.009999999999999995 8.45 1.1248897723777205 1.1248897723777205
	+0.09 0.009999999999999995 0.010000000000000009 5.53 0.8678000921871349 0.8678000921871349
	+0.11 0.009999999999999995 0.009999999999999995 4.231 0.7657734651971169 0.7657734651971169
	+0.13 0.010000000000000009 0.010000000000000009 3.08 0.7847732156489542 0.7847732156489542
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 3.025 0.6125177548447065 0.6125177548447065
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 1.894 0.534072092511863 0.534072092511863
	+0.19 0.010000000000000009 0.010000000000000009 1.293 0.4321400236034612 0.4321400236034612
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 1.069 0.40134025464685197 0.40134025464685197
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 1.338 0.4422951503238533 0.4422951503238533
	+0.25 0.010000000000000009 0.010000000000000009 0.408 0.27280029325497435 0.27280029325497435
	+0.27 0.010000000000000009 0.010000000000000009 0.067 0.12940247292845683 0.12940247292845683
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.71 0.32683329083800505 0.32683329083800505
	+0.31 0.010000000000000009 0.010000000000000009 0.0 0.0 0.0
	+0.33 0.010000000000000009 0.010000000000000009 0.078 0.12800390619039717 0.12800390619039717
	+0.35 0.009999999999999953 0.010000000000000009 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d34-x01-y01
	+Path=/REF/L3_2004_I652683/d34-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.41 0.22228360263411245 0.22228360263411245
	+0.03 0.009999999999999998 0.010000000000000002 8.824 2.1662248267435213 2.1662248267435213
	+0.05 0.010000000000000002 0.009999999999999995 10.568 1.5857909698317745 1.5857909698317745
	+0.07 0.010000000000000009 0.009999999999999995 6.654 1.282909973458777 1.282909973458777
	+0.09 0.009999999999999995 0.010000000000000009 6.733 1.4651935025790963 1.4651935025790963
	+0.11 0.009999999999999995 0.009999999999999995 3.987 0.8286259711112125 0.8286259711112125
	+0.13 0.010000000000000009 0.010000000000000009 3.13 0.7887420364098772 0.7887420364098772
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 1.937 0.5983385329393386 0.5983385329393386
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 1.847 0.6435503088337383 0.6435503088337383
	+0.19 0.010000000000000009 0.010000000000000009 1.482 0.5675394259432555 0.5675394259432555
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 1.51 0.8075345193860136 0.8075345193860136
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 0.53 0.41454070970171314 0.41454070970171314
	+0.25 0.010000000000000009 0.010000000000000009 0.274 0.2776058356735319 0.2776058356735319
	+0.27 0.010000000000000009 0.010000000000000009 0.223 0.31323154374998696 0.31323154374998696
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.734 0.7544037380607284 0.7544037380607284
	+0.31 0.010000000000000009 0.010000000000000009 0.865 0.7535847663003811 0.7535847663003811
	+0.33 0.010000000000000009 0.010000000000000009 0.0 0.0 0.0
	+0.35 0.009999999999999953 0.010000000000000009 0.294 0.3883529322665145 0.3883529322665145
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d34-x01-y02
	+Path=/REF/L3_2004_I652683/d34-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.343 0.4787870090134025 0.4787870090134025
	+0.03 0.009999999999999998 0.010000000000000002 8.245 0.897390104692491 0.897390104692491
	+0.05 0.010000000000000002 0.009999999999999995 10.962 0.7834034720372384 0.7834034720372384
	+0.07 0.010000000000000009 0.009999999999999995 7.658 0.5812761822060147 0.5812761822060147
	+0.09 0.009999999999999995 0.010000000000000009 5.831 0.6113763161915908 0.6113763161915908
	+0.11 0.009999999999999995 0.009999999999999995 4.179 0.4596346375111432 0.4596346375111432
	+0.13 0.010000000000000009 0.010000000000000009 3.865 0.49191970889566927 0.49191970889566927
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 2.068 0.29613848111989766 0.29613848111989766
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 1.787 0.2747216773390844 0.2747216773390844
	+0.19 0.010000000000000009 0.010000000000000009 1.763 0.3007191380674 0.3007191380674
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 0.783 0.23644872594285637 0.23644872594285637
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 0.637 0.30160238725845656 0.30160238725845656
	+0.25 0.010000000000000009 0.010000000000000009 0.691 0.19480503073586164 0.19480503073586164
	+0.27 0.010000000000000009 0.010000000000000009 0.656 0.25298221281347033 0.25298221281347033
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.314 0.1706282508847817 0.1706282508847817
	+0.31 0.010000000000000009 0.010000000000000009 0.212 0.1712921480979207 0.1712921480979207
	+0.33 0.010000000000000009 0.010000000000000009 0.0 0.0 0.0
	+0.35 0.009999999999999953 0.010000000000000009 0.008 0.073 0.073
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d34-x01-y03
	+Path=/REF/L3_2004_I652683/d34-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.418 0.08914033879226621 0.08914033879226621
	+0.03 0.009999999999999998 0.010000000000000002 8.634 0.5654599897428642 0.5654599897428642
	+0.05 0.010000000000000002 0.009999999999999995 10.279 0.5050792017099892 0.5050792017099892
	+0.07 0.010000000000000009 0.009999999999999995 8.186 0.3467333269243094 0.3467333269243094
	+0.09 0.009999999999999995 0.010000000000000009 5.241 0.32321045775160184 0.32321045775160184
	+0.11 0.009999999999999995 0.009999999999999995 4.633 0.2879236009777594 0.2879236009777594
	+0.13 0.010000000000000009 0.010000000000000009 3.143 0.22961271741782946 0.22961271741782946
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 2.525 0.18396738841436 0.18396738841436
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 1.644 0.15582361823549087 0.15582361823549087
	+0.19 0.010000000000000009 0.010000000000000009 1.527 0.19334942461771124 0.19334942461771124
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 1.179 0.141315250415516 0.141315250415516
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 1.119 0.1692926460304759 0.1692926460304759
	+0.25 0.010000000000000009 0.010000000000000009 0.677 0.18843035848822237 0.18843035848822237
	+0.27 0.010000000000000009 0.010000000000000009 0.399 0.19059118552545917 0.19059118552545917
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.144 0.13238202294873727 0.13238202294873727
	+0.31 0.010000000000000009 0.010000000000000009 0.228 0.12258874336577563 0.12258874336577563
	+0.33 0.010000000000000009 0.010000000000000009 0.0 0.0 0.0
	+0.35 0.009999999999999953 0.010000000000000009 0.013 0.12083045973594572 0.12083045973594572
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d35-x01-y01
	+Path=/REF/L3_2004_I652683/d35-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.376 0.1464923206178399 0.1464923206178399
	+0.03 0.009999999999999998 0.010000000000000002 8.334 0.6345273831758563 0.6345273831758563
	+0.05 0.010000000000000002 0.009999999999999995 10.931 0.6512219283777229 0.6512219283777229
	+0.07 0.010000000000000009 0.009999999999999995 7.336 0.505618433208284 0.505618433208284
	+0.09 0.009999999999999995 0.010000000000000009 6.187 0.4507238622482728 0.4507238622482728
	+0.11 0.009999999999999995 0.009999999999999995 4.157 0.3676955262170047 0.3676955262170047
	+0.13 0.010000000000000009 0.010000000000000009 3.356 0.3772280477377047 0.3772280477377047
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 2.245 0.3275622078323444 0.3275622078323444
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 2.367 0.3292567387313432 0.3292567387313432
	+0.19 0.010000000000000009 0.010000000000000009 0.992 0.22 0.22
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 1.011 0.21639316070523118 0.21639316070523118
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 0.816 0.21507673049402626 0.21507673049402626
	+0.25 0.010000000000000009 0.010000000000000009 1.141 0.40659193302376273 0.40659193302376273
	+0.27 0.010000000000000009 0.010000000000000009 0.339 0.228114006584427 0.228114006584427
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.099 0.15116877984557525 0.15116877984557525
	+0.31 0.010000000000000009 0.010000000000000009 0.168 0.09726767191621274 0.09726767191621274
	+0.33 0.010000000000000009 0.010000000000000009 0.144 0.1390898989862312 0.1390898989862312
	+0.35 0.009999999999999953 0.010000000000000009 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d35-x01-y02
	+Path=/REF/L3_2004_I652683/d35-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.449 0.13822445514452208 0.13822445514452208
	+0.03 0.009999999999999998 0.010000000000000002 8.633 0.6395701681598354 0.6395701681598354
	+0.05 0.010000000000000002 0.009999999999999995 10.228 0.5453897688809354 0.5453897688809354
	+0.07 0.010000000000000009 0.009999999999999995 7.197 0.4523549491273418 0.4523549491273418
	+0.09 0.009999999999999995 0.010000000000000009 5.78 0.3864556895686748 0.3864556895686748
	+0.11 0.009999999999999995 0.009999999999999995 4.282 0.4617412695438865 0.4617412695438865
	+0.13 0.010000000000000009 0.010000000000000009 2.929 0.3790197884016084 0.3790197884016084
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 2.839 0.3370014836762592 0.3370014836762592
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 2.384 0.28629530209208814 0.28629530209208814
	+0.19 0.010000000000000009 0.010000000000000009 1.43 0.24078621222985339 0.24078621222985339
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 1.073 0.25160286166894047 0.25160286166894047
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 1.191 0.295 0.295
	+0.25 0.010000000000000009 0.010000000000000009 0.429 0.2623833073958784 0.2623833073958784
	+0.27 0.010000000000000009 0.010000000000000009 0.553 0.25223203603031874 0.25223203603031874
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.211 0.20573040611440985 0.20573040611440985
	+0.31 0.010000000000000009 0.010000000000000009 0.281 0.23447174669882936 0.23447174669882936
	+0.33 0.010000000000000009 0.010000000000000009 0.095 0.1569745202254175 0.1569745202254175
	+0.35 0.009999999999999953 0.010000000000000009 0.015 0.05366563145999496 0.05366563145999496
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d35-x01-y03
	+Path=/REF/L3_2004_I652683/d35-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.491 0.11957006314291216 0.11957006314291216
	+0.03 0.009999999999999998 0.010000000000000002 8.694 0.5465939992352643 0.5465939992352643
	+0.05 0.010000000000000002 0.009999999999999995 10.221 0.4612862451883863 0.4612862451883863
	+0.07 0.010000000000000009 0.009999999999999995 7.299 0.34505072090926 0.34505072090926
	+0.09 0.009999999999999995 0.010000000000000009 5.821 0.3857784338192066 0.3857784338192066
	+0.11 0.009999999999999995 0.009999999999999995 4.079 0.29842419472958287 0.29842419472958287
	+0.13 0.010000000000000009 0.010000000000000009 3.432 0.2906578744847626 0.2906578744847626
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 2.411 0.2379936973955403 0.2379936973955403
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 1.725 0.20479257799051215 0.20479257799051215
	+0.19 0.010000000000000009 0.010000000000000009 1.568 0.22663186007267383 0.22663186007267383
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 1.441 0.23332380932943814 0.23332380932943814
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 0.96 0.1818928255869373 0.1818928255869373
	+0.25 0.010000000000000009 0.010000000000000009 0.576 0.17434735443934904 0.17434735443934904
	+0.27 0.010000000000000009 0.010000000000000009 0.632 0.20218061232472315 0.20218061232472315
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.5 0.25538402455909415 0.25538402455909415
	+0.31 0.010000000000000009 0.010000000000000009 0.063 0.11180339887498948 0.11180339887498948
	+0.33 0.010000000000000009 0.010000000000000009 0.04 0.08080841540334768 0.08080841540334768
	+0.35 0.009999999999999953 0.010000000000000009 0.048 0.06935416353759881 0.06935416353759881
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d36-x01-y01
	+Path=/REF/L3_2004_I652683/d36-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.015 0.015 0.015 0.641 0.3653956759459532 0.3653956759459532
	+0.04 0.010000000000000002 0.010000000000000002 8.586 2.454742349005288 2.454742349005288
	+0.0625 0.012499999999999997 0.012499999999999997 12.655 1.0802407139151902 1.0802407139151902
	+0.0875 0.012499999999999997 0.012500000000000011 6.548 0.8765500556157647 0.8765500556157647
	+0.1125 0.012499999999999997 0.012499999999999997 5.168 1.064370706098209 1.064370706098209
	+0.1375 0.012500000000000011 0.012499999999999983 2.9 0.6611391684055634 0.6611391684055634
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 2.101 0.6376746819499737 0.6376746819499737
	+0.1875 0.012500000000000011 0.012500000000000011 1.856 0.3710417766236034 0.3710417766236034
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.636 0.32907901786653004 0.32907901786653004
	+0.2625 0.037500000000000006 0.03749999999999998 0.166 0.11745637488020819 0.11745637488020819
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d36-x01-y02
	+Path=/REF/L3_2004_I652683/d36-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.015 0.015 0.015 1.498 0.781716060983782 0.781716060983782
	+0.04 0.010000000000000002 0.010000000000000002 13.144 2.720996324878077 2.720996324878077
	+0.0625 0.012499999999999997 0.012499999999999997 11.029 1.9989409696136602 1.9989409696136602
	+0.0875 0.012499999999999997 0.012500000000000011 6.442 0.8175946428395919 0.8175946428395919
	+0.1125 0.012499999999999997 0.012499999999999997 3.544 0.744280860965805 0.744280860965805
	+0.1375 0.012500000000000011 0.012499999999999983 3.117 1.6692040019122887 1.6692040019122887
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 1.703 0.45079152609604367 0.45079152609604367
	+0.1875 0.012500000000000011 0.012500000000000011 0.692 0.6132087735836792 0.6132087735836792
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.751 0.3344981315343929 0.3344981315343929
	+0.2625 0.037500000000000006 0.03749999999999998 0.137 0.08348652585896721 0.08348652585896721
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d36-x01-y03
	+Path=/REF/L3_2004_I652683/d36-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.015 0.015 0.015 1.264 0.6413236312502448 0.6413236312502448
	+0.04 0.010000000000000002 0.010000000000000002 13.873 1.0891244189714966 1.0891244189714966
	+0.0625 0.012499999999999997 0.012499999999999997 10.676 0.7191175147359434 0.7191175147359434
	+0.0875 0.012499999999999997 0.012500000000000011 6.186 0.611778554707502 0.611778554707502
	+0.1125 0.012499999999999997 0.012499999999999997 4.246 0.9573808019800689 0.9573808019800689
	+0.1375 0.012500000000000011 0.012499999999999983 2.485 0.4505208097302499 0.4505208097302499
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 1.445 0.3334441482467491 0.3334441482467491
	+0.1875 0.012500000000000011 0.012500000000000011 1.175 0.7352312561364621 0.7352312561364621
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.669 0.22274873737015885 0.22274873737015885
	+0.2625 0.037500000000000006 0.03749999999999998 0.167 0.062481997407253236 0.062481997407253236
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d37-x01-y01
	+Path=/REF/L3_2004_I652683/d37-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.015 0.015 0.015 2.299 1.1333746070915829 1.1333746070915829
	+0.04 0.010000000000000002 0.010000000000000002 16.308 0.8418859780279037 0.8418859780279037
	+0.0625 0.012499999999999997 0.012499999999999997 9.129 0.5953830699642039 0.5953830699642039
	+0.0875 0.012499999999999997 0.012500000000000011 5.427 0.9075709338668796 0.9075709338668796
	+0.1125 0.012499999999999997 0.012499999999999997 3.611 0.3874970967633177 0.3874970967633177
	+0.1375 0.012500000000000011 0.012499999999999983 2.499 0.32693118541980665 0.32693118541980665
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 1.297 0.30391610684529374 0.30391610684529374
	+0.1875 0.012500000000000011 0.012500000000000011 1.32 0.3041052449399714 0.3041052449399714
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.449 0.21221922627321022 0.21221922627321022
	+0.2625 0.037500000000000006 0.03749999999999998 0.154 0.03911521443121589 0.03911521443121589
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d37-x01-y02
	+Path=/REF/L3_2004_I652683/d37-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.015 0.015 0.015 2.628 1.271471981602426 1.271471981602426
	+0.04 0.010000000000000002 0.010000000000000002 15.538 0.9861749337718942 0.9861749337718942
	+0.0625 0.012499999999999997 0.012499999999999997 9.862 0.8073468895090883 0.8073468895090883
	+0.0875 0.012499999999999997 0.012500000000000011 4.651 1.4543795928161258 1.4543795928161258
	+0.1125 0.012499999999999997 0.012499999999999997 3.8 0.8396010957591706 0.8396010957591706
	+0.1375 0.012500000000000011 0.012499999999999983 2.442 0.3995910409406097 0.3995910409406097
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 1.5 0.32649655434629016 0.32649655434629016
	+0.1875 0.012500000000000011 0.012500000000000011 0.883 0.20169283576765934 0.20169283576765934
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 1.026 0.3120544824225411 0.3120544824225411
	+0.2625 0.037500000000000006 0.03749999999999998 0.084 0.04967896939349688 0.04967896939349688
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d37-x01-y03
	+Path=/REF/L3_2004_I652683/d37-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.015 0.015 0.015 3.26 1.6006264398665917 1.6006264398665917
	+0.04 0.010000000000000002 0.010000000000000002 15.441 1.5454788901825869 1.5454788901825869
	+0.0625 0.012499999999999997 0.012499999999999997 10.235 0.8194754419749258 0.8194754419749258
	+0.0875 0.012499999999999997 0.012500000000000011 3.917 1.2614737413041937 1.2614737413041937
	+0.1125 0.012499999999999997 0.012499999999999997 3.173 0.6191865631617016 0.6191865631617016
	+0.1375 0.012500000000000011 0.012499999999999983 2.226 0.43707436438208086 0.43707436438208086
	+0.16249999999999998 0.012499999999999983 0.012500000000000011 1.775 0.4590098038168684 0.4590098038168684
	+0.1875 0.012500000000000011 0.012500000000000011 1.205 0.34096920682079196 0.34096920682079196
	+0.21250000000000002 0.012500000000000011 0.012499999999999983 0.686 0.2834395879195424 0.2834395879195424
	+0.2625 0.037500000000000006 0.03749999999999998 0.173 0.08203657720797473 0.08203657720797473
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d38-x01-y01
	+Path=/REF/L3_2004_I652683/d38-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 0.157 0.13669308687713508 0.13669308687713508
	+0.0225 0.0075 0.0075 12.915 1.6627907264595867 1.6627907264595867
	+0.0375 0.0075 0.0075 14.268 1.6436523355016412 1.6436523355016412
	+0.0525 0.0075 0.0075 10.861 1.456801976934408 1.456801976934408
	+0.0675 0.007500000000000007 0.007499999999999993 6.32 0.9603254656625534 0.9603254656625534
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 5.646 0.9561887888905621 0.9561887888905621
	+0.0975 0.007500000000000007 0.007499999999999993 4.097 0.7302088742270939 0.7302088742270939
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 3.866 0.8645166279488209 0.8645166279488209
	+0.1275 0.007500000000000007 0.007500000000000007 2.078 0.526677320567347 0.526677320567347
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.974 0.5362629951805364 0.5362629951805364
	+0.1575 0.007500000000000007 0.007500000000000007 1.16 0.34546345682285995 0.34546345682285995
	+0.1725 0.007499999999999979 0.007500000000000007 0.647 0.24112444919584575 0.24112444919584575
	+0.1875 0.007500000000000007 0.007500000000000007 0.802 0.2675855003545596 0.2675855003545596
	+0.2025 0.007500000000000007 0.007499999999999979 0.877 0.2686633581268573 0.2686633581268573
	+0.2175 0.007500000000000007 0.007500000000000007 0.23 0.126003968191482 0.126003968191482
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.514 0.23532105728132366 0.23532105728132366
	+0.2475 0.007500000000000007 0.007500000000000007 0.197 0.13203408650799234 0.13203408650799234
	+0.2625 0.007500000000000007 0.007500000000000007 0.057 0.05854912467321779 0.05854912467321779
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.0 0.0 0.0
	+0.2925 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d38-x01-y02
	+Path=/REF/L3_2004_I652683/d38-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 0.235 0.26828715958837834 0.26828715958837834
	+0.0225 0.0075 0.0075 14.66 2.278524303140083 2.278524303140083
	+0.0375 0.0075 0.0075 15.618 1.7660452995322629 1.7660452995322629
	+0.0525 0.0075 0.0075 8.923 1.3449420061846533 1.3449420061846533
	+0.0675 0.007500000000000007 0.007499999999999993 5.144 1.3634258322329087 1.3634258322329087
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 5.51 1.0793516572461452 1.0793516572461452
	+0.0975 0.007500000000000007 0.007499999999999993 3.752 0.8484161714630385 0.8484161714630385
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 2.436 0.7206004440742456 0.7206004440742456
	+0.1275 0.007500000000000007 0.007500000000000007 2.427 0.6392972704462299 0.6392972704462299
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.802 0.5655864213362977 0.5655864213362977
	+0.1575 0.007500000000000007 0.007500000000000007 1.292 0.5256805113374473 0.5256805113374473
	+0.1725 0.007499999999999979 0.007500000000000007 1.66 0.5676521822383844 0.5676521822383844
	+0.1875 0.007500000000000007 0.007500000000000007 1.177 0.4043612246494463 0.4043612246494463
	+0.2025 0.007500000000000007 0.007499999999999979 0.656 0.26318814562969967 0.26318814562969967
	+0.2175 0.007500000000000007 0.007500000000000007 0.587 0.22926403991904182 0.22926403991904182
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.259 0.18027756377319948 0.18027756377319948
	+0.2475 0.007500000000000007 0.007500000000000007 0.144 0.11636150566231085 0.11636150566231085
	+0.2625 0.007500000000000007 0.007500000000000007 0.17 0.15530936868070774 0.15530936868070774
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.072 0.08285529554590944 0.08285529554590944
	+0.2925 0.007500000000000007 0.007500000000000007 0.144 0.17418381095842403 0.17418381095842403
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d38-x01-y03
	+Path=/REF/L3_2004_I652683/d38-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 2.601 1.0445515784297108 1.0445515784297108
	+0.0225 0.0075 0.0075 16.194 2.237030621158325 2.237030621158325
	+0.0375 0.0075 0.0075 10.741 1.6733804110243433 1.6733804110243433
	+0.0525 0.0075 0.0075 10.016 1.3456069262604142 1.3456069262604142
	+0.0675 0.007500000000000007 0.007499999999999993 5.587 1.1347532771488258 1.1347532771488258
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 4.394 0.9206590031059274 0.9206590031059274
	+0.0975 0.007500000000000007 0.007499999999999993 4.149 0.8972429994154314 0.8972429994154314
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 3.511 0.8533024082938007 0.8533024082938007
	+0.1275 0.007500000000000007 0.007500000000000007 2.089 0.6391189247706565 0.6391189247706565
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 2.024 0.5891731494221372 0.5891731494221372
	+0.1575 0.007500000000000007 0.007500000000000007 1.162 0.6429906686725709 0.6429906686725709
	+0.1725 0.007499999999999979 0.007500000000000007 0.779 0.40440079129497264 0.40440079129497264
	+0.1875 0.007500000000000007 0.007500000000000007 1.449 0.5088202040013742 0.5088202040013742
	+0.2025 0.007500000000000007 0.007499999999999979 0.8 0.38596631977414814 0.38596631977414814
	+0.2175 0.007500000000000007 0.007500000000000007 0.581 0.2821435804692356 0.2821435804692356
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.092 0.12824975633505117 0.12824975633505117
	+0.2475 0.007500000000000007 0.007500000000000007 0.114 0.12775758294520134 0.12775758294520134
	+0.2625 0.007500000000000007 0.007500000000000007 0.053 0.08602325267042626 0.08602325267042626
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.33 0.23153617427952808 0.23153617427952808
	+0.2925 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d39-x01-y01
	+Path=/REF/L3_2004_I652683/d39-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 2.337 1.0376598672011943 1.0376598672011943
	+0.0225 0.0075 0.0075 15.587 2.6265492571052236 2.6265492571052236
	+0.0375 0.0075 0.0075 11.428 1.755383149058917 1.755383149058917
	+0.0525 0.0075 0.0075 8.594 1.6740982647383635 1.6740982647383635
	+0.0675 0.007500000000000007 0.007499999999999993 8.232 1.5243726578497792 1.5243726578497792
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 4.833 1.2440739527857658 1.2440739527857658
	+0.0975 0.007500000000000007 0.007499999999999993 3.079 0.8792041856133307 0.8792041856133307
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 2.021 0.8680397456338045 0.8680397456338045
	+0.1275 0.007500000000000007 0.007500000000000007 1.842 0.7368174807915457 0.7368174807915457
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 2.506 0.9518870731342033 0.9518870731342033
	+0.1575 0.007500000000000007 0.007500000000000007 2.968 1.1575741876873378 1.1575741876873378
	+0.1725 0.007499999999999979 0.007500000000000007 0.748 0.6828594291653297 0.6828594291653297
	+0.1875 0.007500000000000007 0.007500000000000007 1.099 0.5975014644333518 0.5975014644333518
	+0.2025 0.007500000000000007 0.007499999999999979 0.909 0.5207657822860484 0.5207657822860484
	+0.2175 0.007500000000000007 0.007500000000000007 0.079 0.20300246303924493 0.20300246303924493
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.0 0.0 0.0
	+0.2475 0.007500000000000007 0.007500000000000007 0.331 0.24654614172604689 0.24654614172604689
	+0.2625 0.007500000000000007 0.007500000000000007 0.075 0.11800423721205948 0.11800423721205948
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.0 0.0 0.0
	+0.2925 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d39-x01-y02
	+Path=/REF/L3_2004_I652683/d39-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 1.727 1.4390514236815861 1.4390514236815861
	+0.0225 0.0075 0.0075 16.496 1.0463077941026722 1.0463077941026722
	+0.0375 0.0075 0.0075 12.573 1.0065088176464227 1.0065088176464227
	+0.0525 0.0075 0.0075 8.528 0.7256679681507239 0.7256679681507239
	+0.0675 0.007500000000000007 0.007499999999999993 6.961 1.038491694718836 1.038491694718836
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 4.354 0.5420452010672172 0.5420452010672172
	+0.0975 0.007500000000000007 0.007499999999999993 3.945 0.5316060571513459 0.5316060571513459
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 3.23 0.5385164807134505 0.5385164807134505
	+0.1275 0.007500000000000007 0.007500000000000007 1.965 0.36508766070630216 0.36508766070630216
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.745 0.3597624216062595 0.3597624216062595
	+0.1575 0.007500000000000007 0.007500000000000007 1.325 0.4157787873376899 0.4157787873376899
	+0.1725 0.007499999999999979 0.007500000000000007 1.225 0.305 0.305
	+0.1875 0.007500000000000007 0.007500000000000007 0.873 0.24848541204666322 0.24848541204666322
	+0.2025 0.007500000000000007 0.007499999999999979 0.584 0.2296105398277701 0.2296105398277701
	+0.2175 0.007500000000000007 0.007500000000000007 0.211 0.12887590930814027 0.12887590930814027
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.182 0.17274258305351348 0.17274258305351348
	+0.2475 0.007500000000000007 0.007500000000000007 0.568 0.16769317219254934 0.16769317219254934
	+0.2625 0.007500000000000007 0.007500000000000007 0.045 0.1120044641967453 0.1120044641967453
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.089 0.0588727441181401 0.0588727441181401
	+0.2925 0.007500000000000007 0.007500000000000007 0.039 0.05240229002629561 0.05240229002629561
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d39-x01-y03
	+Path=/REF/L3_2004_I652683/d39-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 2.17 0.3401543767173958 0.3401543767173958
	+0.0225 0.0075 0.0075 15.348 0.6849656925715331 0.6849656925715331
	+0.0375 0.0075 0.0075 12.889 0.6773662229547618 0.6773662229547618
	+0.0525 0.0075 0.0075 8.46 0.43204166465747257 0.43204166465747257
	+0.0675 0.007500000000000007 0.007499999999999993 6.632 0.47046041278730355 0.47046041278730355
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 4.898 0.3349641771891436 0.3349641771891436
	+0.0975 0.007500000000000007 0.007499999999999993 3.648 0.3275622078323444 0.3275622078323444
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 2.908 0.2754813968310746 0.2754813968310746
	+0.1275 0.007500000000000007 0.007500000000000007 1.899 0.2122286502807762 0.2122286502807762
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.786 0.208806130178211 0.208806130178211
	+0.1575 0.007500000000000007 0.007500000000000007 1.793 0.24200206610688266 0.24200206610688266
	+0.1725 0.007499999999999979 0.007500000000000007 1.156 0.17363179432350517 0.17363179432350517
	+0.1875 0.007500000000000007 0.007500000000000007 0.951 0.20365166338628318 0.20365166338628318
	+0.2025 0.007500000000000007 0.007499999999999979 0.872 0.14855638660118253 0.14855638660118253
	+0.2175 0.007500000000000007 0.007500000000000007 0.375 0.09946356116689167 0.09946356116689167
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.253 0.13994641831786905 0.13994641831786905
	+0.2475 0.007500000000000007 0.007500000000000007 0.335 0.10292715870944849 0.10292715870944849
	+0.2625 0.007500000000000007 0.007500000000000007 0.11 0.09604165762834375 0.09604165762834375
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.06 0.030149626863362672 0.030149626863362672
	+0.2925 0.007500000000000007 0.007500000000000007 0.125 0.06103277807866852 0.06103277807866852
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d40-x01-y01
	+Path=/REF/L3_2004_I652683/d40-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 2.446 0.3566090296108611 0.3566090296108611
	+0.0225 0.0075 0.0075 15.023 0.9583741440585717 0.9583741440585717
	+0.0375 0.0075 0.0075 12.061 0.7278598766246152 0.7278598766246152
	+0.0525 0.0075 0.0075 9.734 0.6631696615497426 0.6631696615497426
	+0.0675 0.007500000000000007 0.007499999999999993 6.486 0.5932461546440904 0.5932461546440904
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 4.938 0.5161492032348786 0.5161492032348786
	+0.0975 0.007500000000000007 0.007499999999999993 3.758 0.5094722759876145 0.5094722759876145
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 3.145 0.4372516437933653 0.4372516437933653
	+0.1275 0.007500000000000007 0.007500000000000007 2.2 0.4250270579621961 0.4250270579621961
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.734 0.29882603634890986 0.29882603634890986
	+0.1575 0.007500000000000007 0.007500000000000007 1.585 0.34032484481741854 0.34032484481741854
	+0.1725 0.007499999999999979 0.007500000000000007 0.736 0.24358981916328112 0.24358981916328112
	+0.1875 0.007500000000000007 0.007500000000000007 0.958 0.2948847232394381 0.2948847232394381
	+0.2025 0.007500000000000007 0.007499999999999979 0.576 0.2996064084761873 0.2996064084761873
	+0.2175 0.007500000000000007 0.007500000000000007 0.62 0.20861447696648475 0.20861447696648475
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.537 0.26633249895572264 0.26633249895572264
	+0.2475 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+0.2625 0.007500000000000007 0.007500000000000007 0.073 0.10123734488813899 0.10123734488813899
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.057 0.05420332093147061 0.05420332093147061
	+0.2925 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d40-x01-y02
	+Path=/REF/L3_2004_I652683/d40-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 3.055 0.3778306498948967 0.3778306498948967
	+0.0225 0.0075 0.0075 14.545 0.8816575298833442 0.8816575298833442
	+0.0375 0.0075 0.0075 12.038 0.7309945280232952 0.7309945280232952
	+0.0525 0.0075 0.0075 8.41 0.633199020845737 0.633199020845737
	+0.0675 0.007500000000000007 0.007499999999999993 6.472 0.6189345684319143 0.6189345684319143
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 5.464 0.4888077331630505 0.4888077331630505
	+0.0975 0.007500000000000007 0.007499999999999993 3.203 0.4362499283667563 0.4362499283667563
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 3.097 0.46448466067244887 0.46448466067244887
	+0.1275 0.007500000000000007 0.007500000000000007 2.536 0.3618756692567214 0.3618756692567214
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 2.702 0.4202154209450196 0.4202154209450196
	+0.1575 0.007500000000000007 0.007500000000000007 1.326 0.3684087403957729 0.3684087403957729
	+0.1725 0.007499999999999979 0.007500000000000007 1.051 0.30813146544940845 0.30813146544940845
	+0.1875 0.007500000000000007 0.007500000000000007 0.925 0.2552802381697416 0.2552802381697416
	+0.2025 0.007500000000000007 0.007499999999999979 0.032 0.08945389874119516 0.08945389874119516
	+0.2175 0.007500000000000007 0.007500000000000007 0.595 0.20890667772955465 0.20890667772955465
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.775 0.2344013651837378 0.2344013651837378
	+0.2475 0.007500000000000007 0.007500000000000007 0.207 0.15200328943809077 0.15200328943809077
	+0.2625 0.007500000000000007 0.007500000000000007 0.199 0.1292478239662084 0.1292478239662084
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.027 0.03847076812334269 0.03847076812334269
	+0.2925 0.007500000000000007 0.007500000000000007 0.009 0.023021728866442676 0.023021728866442676
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d40-x01-y03
	+Path=/REF/L3_2004_I652683/d40-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 2.69 0.3772002120890178 0.3772002120890178
	+0.0225 0.0075 0.0075 14.846 0.8904027178754567 0.8904027178754567
	+0.0375 0.0075 0.0075 11.911 0.5163099844085914 0.5163099844085914
	+0.0525 0.0075 0.0075 8.842 0.4918699014983535 0.4918699014983535
	+0.0675 0.007500000000000007 0.007499999999999993 6.541 0.5047068456044559 0.5047068456044559
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 5.08 0.39302162790360534 0.39302162790360534
	+0.0975 0.007500000000000007 0.007499999999999993 3.618 0.3251245915030113 0.3251245915030113
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 3.343 0.3080584360149872 0.3080584360149872
	+0.1275 0.007500000000000007 0.007500000000000007 2.171 0.26612966764342527 0.26612966764342527
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 2.0 0.2518034948129195 0.2518034948129195
	+0.1575 0.007500000000000007 0.007500000000000007 1.376 0.3829843338832543 0.3829843338832543
	+0.1725 0.007499999999999979 0.007500000000000007 0.842 0.1963593644316461 0.1963593644316461
	+0.1875 0.007500000000000007 0.007500000000000007 0.8 0.22196396103872357 0.22196396103872357
	+0.2025 0.007500000000000007 0.007499999999999979 0.944 0.19882907232092595 0.19882907232092595
	+0.2175 0.007500000000000007 0.007500000000000007 0.723 0.22424317157942625 0.22424317157942625
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.384 0.18776847445724215 0.18776847445724215
	+0.2475 0.007500000000000007 0.007500000000000007 0.26 0.10818964830333815 0.10818964830333815
	+0.2625 0.007500000000000007 0.007500000000000007 0.247 0.10978615577567147 0.10978615577567147
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.019 0.0425205832509386 0.0425205832509386
	+0.2925 0.007500000000000007 0.007500000000000007 0.03 0.03471310991541956 0.03471310991541956
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d41-x01-y01
	+Path=/REF/L3_2004_I652683/d41-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 0.632 0.24193387526346946 0.24193387526346946
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 4.864 0.6455640944166582 0.6455640944166582
	+0.125 0.024999999999999994 0.024999999999999994 3.906 0.41236876700351593 0.41236876700351593
	+0.175 0.024999999999999994 0.025000000000000022 2.657 0.350191376250187 0.350191376250187
	+0.225 0.024999999999999994 0.024999999999999994 1.554 0.2634008352302627 0.2634008352302627
	+0.275 0.025000000000000022 0.024999999999999967 1.481 0.25468608128439213 0.25468608128439213
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 0.901 0.19945926902503178 0.19945926902503178
	+0.375 0.025000000000000022 0.025000000000000022 0.604 0.16075136080294936 0.16075136080294936
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 1.04 0.24 0.24
	+0.475 0.024999999999999967 0.025000000000000022 0.53 0.12847178678604887 0.12847178678604887
	+0.525 0.025000000000000022 0.025000000000000022 0.461 0.11860860002546189 0.11860860002546189
	+0.575 0.02499999999999991 0.025000000000000022 0.334 0.11458621208504975 0.11458621208504975
	+0.625 0.025000000000000022 0.025000000000000022 0.18 0.07669419795525603 0.07669419795525603
	+0.675 0.025000000000000022 0.02499999999999991 0.261 0.07727871634544663 0.07727871634544663
	+0.725 0.025000000000000022 0.025000000000000022 0.313 0.09211405973031478 0.09211405973031478
	+0.775 0.025000000000000022 0.025000000000000022 0.147 0.07324616030891995 0.07324616030891995
	+0.825 0.02499999999999991 0.025000000000000022 0.053 0.03801315561749642 0.03801315561749642
	+0.875 0.025000000000000022 0.025000000000000022 0.04 0.030675723300355937 0.030675723300355937
	+0.925 0.025000000000000022 0.02499999999999991 0.0 0.0 0.0
	+0.975 0.025000000000000022 0.025000000000000022 0.04 0.046141087980237305 0.046141087980237305
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d41-x01-y02
	+Path=/REF/L3_2004_I652683/d41-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 0.637 0.3439956395072472 0.3439956395072472
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 5.005 0.627873394881484 0.627873394881484
	+0.125 0.024999999999999994 0.024999999999999994 3.858 0.5434721704006563 0.5434721704006563
	+0.175 0.024999999999999994 0.025000000000000022 3.039 0.48510308182900674 0.48510308182900674
	+0.225 0.024999999999999994 0.024999999999999994 1.056 0.24617473469062578 0.24617473469062578
	+0.275 0.025000000000000022 0.024999999999999967 1.202 0.26791229908311415 0.26791229908311415
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 0.721 0.21600231480241133 0.21600231480241133
	+0.375 0.025000000000000022 0.025000000000000022 0.641 0.18398369492974098 0.18398369492974098
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.839 0.20776188293332346 0.20776188293332346
	+0.475 0.024999999999999967 0.025000000000000022 0.446 0.14928161306738347 0.14928161306738347
	+0.525 0.025000000000000022 0.025000000000000022 0.505 0.1797386992275175 0.1797386992275175
	+0.575 0.02499999999999991 0.025000000000000022 0.497 0.16670932787339765 0.16670932787339765
	+0.625 0.025000000000000022 0.025000000000000022 0.418 0.17507141400011597 0.17507141400011597
	+0.675 0.025000000000000022 0.02499999999999991 0.452 0.12304470732217619 0.12304470732217619
	+0.725 0.025000000000000022 0.025000000000000022 0.241 0.08709190547921201 0.08709190547921201
	+0.775 0.025000000000000022 0.025000000000000022 0.169 0.08405950273467004 0.08405950273467004
	+0.825 0.02499999999999991 0.025000000000000022 0.095 0.07433034373659253 0.07433034373659253
	+0.875 0.025000000000000022 0.025000000000000022 0.157 0.08987213138676528 0.08987213138676528
	+0.925 0.025000000000000022 0.02499999999999991 0.022 0.027202941017470887 0.027202941017470887
	+0.975 0.025000000000000022 0.025000000000000022 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d41-x01-y03
	+Path=/REF/L3_2004_I652683/d41-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 2.593 0.5008482804203285 0.5008482804203285
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 5.547 0.7437210498567323 0.7437210498567323
	+0.125 0.024999999999999994 0.024999999999999994 2.821 0.4931460229992735 0.4931460229992735
	+0.175 0.024999999999999994 0.025000000000000022 1.867 0.31084722935873177 0.31084722935873177
	+0.225 0.024999999999999994 0.024999999999999994 1.112 0.22968238939892627 0.22968238939892627
	+0.275 0.025000000000000022 0.024999999999999967 1.046 0.24016869071550523 0.24016869071550523
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 0.923 0.22436800128360548 0.22436800128360548
	+0.375 0.025000000000000022 0.025000000000000022 1.038 0.2306447484769597 0.2306447484769597
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.572 0.16886088949191286 0.16886088949191286
	+0.475 0.024999999999999967 0.025000000000000022 0.562 0.17018813119603846 0.17018813119603846
	+0.525 0.025000000000000022 0.025000000000000022 0.466 0.14911069713471262 0.14911069713471262
	+0.575 0.02499999999999991 0.025000000000000022 0.256 0.12336936410632908 0.12336936410632908
	+0.625 0.025000000000000022 0.025000000000000022 0.48 0.14567429423202982 0.14567429423202982
	+0.675 0.025000000000000022 0.02499999999999991 0.352 0.1274872542648872 0.1274872542648872
	+0.725 0.025000000000000022 0.025000000000000022 0.148 0.08271033792700887 0.08271033792700887
	+0.775 0.025000000000000022 0.025000000000000022 0.191 0.09884331034521253 0.09884331034521253
	+0.825 0.02499999999999991 0.025000000000000022 0.024 0.054451813560247926 0.054451813560247926
	+0.875 0.025000000000000022 0.025000000000000022 0.003 0.03214031735997639 0.03214031735997639
	+0.925 0.025000000000000022 0.02499999999999991 0.0 0.0 0.0
	+0.975 0.025000000000000022 0.025000000000000022 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d42-x01-y01
	+Path=/REF/L3_2004_I652683/d42-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 2.733 0.6958807369082722 0.6958807369082722
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 4.694 0.7608061513946901 0.7608061513946901
	+0.125 0.024999999999999994 0.024999999999999994 2.475 0.579834459134674 0.579834459134674
	+0.175 0.024999999999999994 0.025000000000000022 2.2 0.3794482836962107 0.3794482836962107
	+0.225 0.024999999999999994 0.024999999999999994 1.665 0.38111546806709384 0.38111546806709384
	+0.275 0.025000000000000022 0.024999999999999967 0.991 0.2561952380509833 0.2561952380509833
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 0.897 0.28402288640178275 0.28402288640178275
	+0.375 0.025000000000000022 0.025000000000000022 0.784 0.27051247660690253 0.27051247660690253
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.446 0.1901920082443003 0.1901920082443003
	+0.475 0.024999999999999967 0.025000000000000022 0.599 0.21653637107885595 0.21653637107885595
	+0.525 0.025000000000000022 0.025000000000000022 0.563 0.2240089283934906 0.2240089283934906
	+0.575 0.02499999999999991 0.025000000000000022 0.166 0.1323706916201619 0.1323706916201619
	+0.625 0.025000000000000022 0.025000000000000022 0.475 0.17898603297464305 0.17898603297464305
	+0.675 0.025000000000000022 0.02499999999999991 0.169 0.1343316790634287 0.1343316790634287
	+0.725 0.025000000000000022 0.025000000000000022 0.06 0.09139474820797965 0.09139474820797965
	+0.775 0.025000000000000022 0.025000000000000022 0.344 0.21461826576505552 0.21461826576505552
	+0.825 0.02499999999999991 0.025000000000000022 0.533 0.38104724116571165 0.38104724116571165
	+0.875 0.025000000000000022 0.025000000000000022 0.086 0.147648230602334 0.147648230602334
	+0.925 0.025000000000000022 0.02499999999999991 0.123 0.14671059948074644 0.14671059948074644
	+0.975 0.025000000000000022 0.025000000000000022 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d42-x01-y02
	+Path=/REF/L3_2004_I652683/d42-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 1.563 0.5471206448307356 0.5471206448307356
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 5.526 0.34176600181995864 0.34176600181995864
	+0.125 0.024999999999999994 0.024999999999999994 3.047 0.26459213896108097 0.26459213896108097
	+0.175 0.024999999999999994 0.025000000000000022 2.202 0.3118108400937979 0.3118108400937979
	+0.225 0.024999999999999994 0.024999999999999994 1.469 0.16728717822953437 0.16728717822953437
	+0.275 0.025000000000000022 0.024999999999999967 1.274 0.17620726432244502 0.17620726432244502
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 1.049 0.1636001222493431 0.1636001222493431
	+0.375 0.025000000000000022 0.025000000000000022 0.624 0.10332473082471592 0.10332473082471592
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.73 0.13091982279242514 0.13091982279242514
	+0.475 0.024999999999999967 0.025000000000000022 0.607 0.10868762579061152 0.10868762579061152
	+0.525 0.025000000000000022 0.025000000000000022 0.377 0.10371113729971339 0.10371113729971339
	+0.575 0.02499999999999991 0.025000000000000022 0.4 0.08521150157109075 0.08521150157109075
	+0.625 0.025000000000000022 0.025000000000000022 0.241 0.11440279716860073 0.11440279716860073
	+0.675 0.025000000000000022 0.02499999999999991 0.225 0.06140032573203501 0.06140032573203501
	+0.725 0.025000000000000022 0.025000000000000022 0.333 0.0885889383614004 0.0885889383614004
	+0.775 0.025000000000000022 0.025000000000000022 0.231 0.10604244433244643 0.10604244433244643
	+0.825 0.02499999999999991 0.025000000000000022 0.039 0.07200694410957877 0.07200694410957877
	+0.875 0.025000000000000022 0.025000000000000022 0.064 0.08778382538941898 0.08778382538941898
	+0.925 0.025000000000000022 0.02499999999999991 0.0 0.0 0.0
	+0.975 0.025000000000000022 0.025000000000000022 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d42-x01-y03
	+Path=/REF/L3_2004_I652683/d42-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 1.916 0.15915401345866212 0.15915401345866212
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 4.844 0.23084193726444074 0.23084193726444074
	+0.125 0.024999999999999994 0.024999999999999994 3.358 0.15842032697857938 0.15842032697857938
	+0.175 0.024999999999999994 0.025000000000000022 2.016 0.11988744721612851 0.11988744721612851
	+0.225 0.024999999999999994 0.024999999999999994 1.557 0.0976933979345585 0.0976933979345585
	+0.275 0.025000000000000022 0.024999999999999967 1.268 0.09167878707749139 0.09167878707749139
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 1.073 0.09640020746865642 0.09640020746865642
	+0.375 0.025000000000000022 0.025000000000000022 0.794 0.0686804193347711 0.0686804193347711
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.563 0.05882176467941097 0.05882176467941097
	+0.475 0.024999999999999967 0.025000000000000022 0.522 0.05629387178015028 0.05629387178015028
	+0.525 0.025000000000000022 0.025000000000000022 0.553 0.0777946013551069 0.0777946013551069
	+0.575 0.02499999999999991 0.025000000000000022 0.387 0.05507267925205746 0.05507267925205746
	+0.625 0.025000000000000022 0.025000000000000022 0.401 0.0582494635168428 0.0582494635168428
	+0.675 0.025000000000000022 0.02499999999999991 0.33 0.06576473218982952 0.06576473218982952
	+0.725 0.025000000000000022 0.025000000000000022 0.254 0.06585590330410783 0.06585590330410783
	+0.775 0.025000000000000022 0.025000000000000022 0.111 0.07201388754955533 0.07201388754955533
	+0.825 0.02499999999999991 0.025000000000000022 0.03 0.06222539674441618 0.06222539674441618
	+0.875 0.025000000000000022 0.025000000000000022 0.024 0.05830951894845301 0.05830951894845301
	+0.925 0.025000000000000022 0.02499999999999991 0.0 0.0 0.0
	+0.975 0.025000000000000022 0.025000000000000022 0.002 0.0031622776601683794 0.0031622776601683794
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d43-x01-y01
	+Path=/REF/L3_2004_I652683/d43-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 1.858 0.15347312468311838 0.15347312468311838
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 5.0 0.28271894170713074 0.28271894170713074
	+0.125 0.024999999999999994 0.024999999999999994 3.191 0.20194306128213468 0.20194306128213468
	+0.175 0.024999999999999994 0.025000000000000022 2.004 0.15430489298787645 0.15430489298787645
	+0.225 0.024999999999999994 0.024999999999999994 1.657 0.13853880322855397 0.13853880322855397
	+0.275 0.025000000000000022 0.024999999999999967 1.339 0.1554155719353759 0.1554155719353759
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 0.954 0.14424978336205568 0.14424978336205568
	+0.375 0.025000000000000022 0.025000000000000022 0.871 0.10959014554237986 0.10959014554237986
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.624 0.10023971268913334 0.10023971268913334
	+0.475 0.024999999999999967 0.025000000000000022 0.675 0.12 0.12
	+0.525 0.025000000000000022 0.025000000000000022 0.351 0.07782673062643708 0.07782673062643708
	+0.575 0.02499999999999991 0.025000000000000022 0.326 0.07424284477308235 0.07424284477308235
	+0.625 0.025000000000000022 0.025000000000000022 0.287 0.07889233169326408 0.07889233169326408
	+0.675 0.025000000000000022 0.02499999999999991 0.407 0.07839005038906405 0.07839005038906405
	+0.725 0.025000000000000022 0.025000000000000022 0.369 0.1297998459167036 0.1297998459167036
	+0.775 0.025000000000000022 0.025000000000000022 0.036 0.0561426753904728 0.0561426753904728
	+0.825 0.02499999999999991 0.025000000000000022 0.03 0.036715119501371636 0.036715119501371636
	+0.875 0.025000000000000022 0.025000000000000022 0.018 0.03573513677041128 0.03573513677041128
	+0.925 0.025000000000000022 0.02499999999999991 0.004 0.013341664064126334 0.013341664064126334
	+0.975 0.025000000000000022 0.025000000000000022 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d43-x01-y02
	+Path=/REF/L3_2004_I652683/d43-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 2.208 0.1847403583411053 0.1847403583411053
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 4.622 0.25726639889422015 0.25726639889422015
	+0.125 0.024999999999999994 0.024999999999999994 2.911 0.17252536045463 0.17252536045463
	+0.175 0.024999999999999994 0.025000000000000022 2.069 0.15564061166674975 0.15564061166674975
	+0.225 0.024999999999999994 0.024999999999999994 1.69 0.15926079241294763 0.15926079241294763
	+0.275 0.025000000000000022 0.024999999999999967 1.093 0.13148764200486676 0.13148764200486676
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 0.943 0.12983451005029442 0.12983451005029442
	+0.375 0.025000000000000022 0.025000000000000022 0.865 0.10912836478203089 0.10912836478203089
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.65 0.10934349546269317 0.10934349546269317
	+0.475 0.024999999999999967 0.025000000000000022 0.632 0.10604244433244643 0.10604244433244643
	+0.525 0.025000000000000022 0.025000000000000022 0.609 0.11042191811411356 0.11042191811411356
	+0.575 0.02499999999999991 0.025000000000000022 0.46 0.08766413177577247 0.08766413177577247
	+0.625 0.025000000000000022 0.025000000000000022 0.308 0.07373601562330312 0.07373601562330312
	+0.675 0.025000000000000022 0.02499999999999991 0.323 0.082365041127896 0.082365041127896
	+0.725 0.025000000000000022 0.025000000000000022 0.448 0.14159802258506296 0.14159802258506296
	+0.775 0.025000000000000022 0.025000000000000022 0.163 0.16410362579784762 0.16410362579784762
	+0.825 0.02499999999999991 0.025000000000000022 0.0 0.0 0.0
	+0.875 0.025000000000000022 0.025000000000000022 0.0 0.0 0.0
	+0.925 0.025000000000000022 0.02499999999999991 0.0 0.0 0.0
	+0.975 0.025000000000000022 0.025000000000000022 0.005 0.01063014581273465 0.01063014581273465
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d43-x01-y03
	+Path=/REF/L3_2004_I652683/d43-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 2.178 0.16831518053936786 0.16831518053936786
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 4.801 0.21720036832381293 0.21720036832381293
	+0.125 0.024999999999999994 0.024999999999999994 2.831 0.13601470508735444 0.13601470508735444
	+0.175 0.024999999999999994 0.025000000000000022 2.178 0.1746424919657298 0.1746424919657298
	+0.225 0.024999999999999994 0.024999999999999994 1.636 0.1175967686630887 0.1175967686630887
	+0.275 0.025000000000000022 0.024999999999999967 1.217 0.10049875621120889 0.10049875621120889
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 0.934 0.0800812087820857 0.0800812087820857
	+0.375 0.025000000000000022 0.025000000000000022 0.845 0.07984985911070851 0.07984985911070851
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.687 0.09269843580125826 0.09269843580125826
	+0.475 0.024999999999999967 0.025000000000000022 0.483 0.06896375859826667 0.06896375859826667
	+0.525 0.025000000000000022 0.025000000000000022 0.475 0.08213403679352428 0.08213403679352428
	+0.575 0.02499999999999991 0.025000000000000022 0.452 0.06809552114493286 0.06809552114493286
	+0.625 0.025000000000000022 0.025000000000000022 0.445 0.08485281374238571 0.08485281374238571
	+0.675 0.025000000000000022 0.02499999999999991 0.352 0.0696419413859206 0.0696419413859206
	+0.725 0.025000000000000022 0.025000000000000022 0.285 0.10012492197250393 0.10012492197250393
	+0.775 0.025000000000000022 0.025000000000000022 0.152 0.10431682510506154 0.10431682510506154
	+0.825 0.02499999999999991 0.025000000000000022 0.05 0.11954078801814885 0.11954078801814885
	+0.875 0.025000000000000022 0.025000000000000022 0.0 0.0 0.0
	+0.925 0.025000000000000022 0.02499999999999991 0.0 0.0 0.0
	+0.975 0.025000000000000022 0.025000000000000022 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d44-x01-y01
	+Path=/REF/L3_2004_I652683/d44-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.008 0.008 0.008 32.26 2.5610195235491666 2.5610195235491666
	+0.024 0.008 0.008 10.027 1.382043776441253 1.382043776441253
	+0.04 0.008 0.008 5.896 0.8380292357668675 0.8380292357668675
	+0.056 0.008 0.008 3.08 0.5930303533546998 0.5930303533546998
	+0.07200000000000001 0.008000000000000007 0.007999999999999993 2.224 0.47371088229003144 0.47371088229003144
	+0.088 0.007999999999999993 0.008000000000000007 1.449 0.37763077205121937 0.37763077205121937
	+0.10400000000000001 0.008000000000000007 0.007999999999999993 1.33 0.4413184791055095 0.4413184791055095
	+0.12 0.007999999999999993 0.008000000000000007 1.443 0.46150406282068634 0.46150406282068634
	+0.136 0.008000000000000007 0.00799999999999998 0.531 0.2744339629127561 0.2744339629127561
	+0.152 0.008000000000000007 0.008000000000000007 0.842 0.3821060062338722 0.3821060062338722
	+0.16799999999999998 0.00799999999999998 0.008000000000000007 1.038 0.3955477215204254 0.3955477215204254
	+0.184 0.008000000000000007 0.008000000000000007 0.397 0.1759232787325202 0.1759232787325202
	+0.2 0.008000000000000007 0.00799999999999998 0.276 0.16300306745579976 0.16300306745579976
	+0.216 0.008000000000000007 0.008000000000000007 0.07 0.07539230729988305 0.07539230729988305
	+0.23199999999999998 0.00799999999999998 0.008000000000000007 0.08 0.08000624975587844 0.08000624975587844
	+0.248 0.008000000000000007 0.008000000000000007 0.396 0.18528356645962965 0.18528356645962965
	+0.264 0.008000000000000007 0.008000000000000007 0.207 0.15626259949200894 0.15626259949200894
	+0.28 0.008000000000000007 0.007999999999999952 0.165 0.15008331019803636 0.15008331019803636
	+0.296 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.312 0.008000000000000007 0.008000000000000007 0.155 0.1344618905117729 0.1344618905117729
	+0.328 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.344 0.007999999999999952 0.008000000000000007 0.135 0.11822436297142819 0.11822436297142819
	+0.36 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.376 0.008000000000000007 0.008000000000000007 0.188 0.18054639292990596 0.18054639292990596
	+0.392 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d44-x01-y02
	+Path=/REF/L3_2004_I652683/d44-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.008 0.008 0.008 33.049 2.8043858507701827 2.8043858507701827
	+0.024 0.008 0.008 10.402 1.4043550120963002 1.4043550120963002
	+0.04 0.008 0.008 4.132 0.8567286618294032 0.8567286618294032
	+0.056 0.008 0.008 3.099 0.6839042330619105 0.6839042330619105
	+0.07200000000000001 0.008000000000000007 0.007999999999999993 1.323 0.4516558424287236 0.4516558424287236
	+0.088 0.007999999999999993 0.008000000000000007 1.266 0.477171876790743 0.477171876790743
	+0.10400000000000001 0.008000000000000007 0.007999999999999993 1.077 0.3881288445864337 0.3881288445864337
	+0.12 0.007999999999999993 0.008000000000000007 1.308 0.434336275252252 0.434336275252252
	+0.136 0.008000000000000007 0.00799999999999998 0.726 0.3736268191658623 0.3736268191658623
	+0.152 0.008000000000000007 0.008000000000000007 0.271 0.20611889772653066 0.20611889772653066
	+0.16799999999999998 0.00799999999999998 0.008000000000000007 0.217 0.15339491516996254 0.15339491516996254
	+0.184 0.008000000000000007 0.008000000000000007 0.278 0.1970101520226813 0.1970101520226813
	+0.2 0.008000000000000007 0.00799999999999998 0.0 0.0 0.0
	+0.216 0.008000000000000007 0.008000000000000007 0.358 0.249393263742227 0.249393263742227
	+0.23199999999999998 0.00799999999999998 0.008000000000000007 0.648 0.29652993103563763 0.29652993103563763
	+0.248 0.008000000000000007 0.008000000000000007 1.048 0.5075401461953527 0.5075401461953527
	+0.264 0.008000000000000007 0.008000000000000007 0.087 0.08700574693662483 0.08700574693662483
	+0.28 0.008000000000000007 0.007999999999999952 0.487 0.2644579361637688 0.2644579361637688
	+0.296 0.008000000000000007 0.008000000000000007 0.249 0.18725650856512305 0.18725650856512305
	+0.312 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.328 0.008000000000000007 0.008000000000000007 0.214 0.2006439632782407 0.2006439632782407
	+0.344 0.007999999999999952 0.008000000000000007 0.0 0.0 0.0
	+0.36 0.008000000000000007 0.008000000000000007 0.477 0.3854062791393 0.3854062791393
	+0.376 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.392 0.008000000000000007 0.008000000000000007 0.229 0.25234302050978147 0.25234302050978147
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d44-x01-y03
	+Path=/REF/L3_2004_I652683/d44-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.008 0.008 0.008 36.816 2.9324754048414454 2.9324754048414454
	+0.024 0.008 0.008 6.917 1.0664108026459598 1.0664108026459598
	+0.04 0.008 0.008 4.376 0.9320949522446735 0.9320949522446735
	+0.056 0.008 0.008 4.035 0.7679908853625803 0.7679908853625803
	+0.07200000000000001 0.008000000000000007 0.007999999999999993 3.172 0.740476198131986 0.740476198131986
	+0.088 0.007999999999999993 0.008000000000000007 1.368 0.4473175605763762 0.4473175605763762
	+0.10400000000000001 0.008000000000000007 0.007999999999999993 1.078 0.4805704943085874 0.4805704943085874
	+0.12 0.007999999999999993 0.008000000000000007 0.572 0.3038157336281319 0.3038157336281319
	+0.136 0.008000000000000007 0.00799999999999998 0.567 0.29545388811115686 0.29545388811115686
	+0.152 0.008000000000000007 0.008000000000000007 0.918 0.36938056256386853 0.36938056256386853
	+0.16799999999999998 0.00799999999999998 0.008000000000000007 0.2 0.18339302058693507 0.18339302058693507
	+0.184 0.008000000000000007 0.008000000000000007 0.34 0.2621316463153581 0.2621316463153581
	+0.2 0.008000000000000007 0.00799999999999998 0.0 0.0 0.0
	+0.216 0.008000000000000007 0.008000000000000007 0.263 0.22308070288574938 0.22308070288574938
	+0.23199999999999998 0.00799999999999998 0.008000000000000007 0.355 0.3065371103145588 0.3065371103145588
	+0.248 0.008000000000000007 0.008000000000000007 0.13 0.16835973390332976 0.16835973390332976
	+0.264 0.008000000000000007 0.008000000000000007 0.169 0.20172506041639943 0.20172506041639943
	+0.28 0.008000000000000007 0.007999999999999952 0.15 0.1621974105835232 0.1621974105835232
	+0.296 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.312 0.008000000000000007 0.008000000000000007 0.171 0.17218594600024706 0.17218594600024706
	+0.328 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.344 0.007999999999999952 0.008000000000000007 0.0 0.0 0.0
	+0.36 0.008000000000000007 0.008000000000000007 0.319 0.28560287113402766 0.28560287113402766
	+0.376 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.392 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d45-x01-y01
	+Path=/REF/L3_2004_I652683/d45-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.008 0.008 0.008 32.58 3.225517322849158 3.225517322849158
	+0.024 0.008 0.008 8.48 1.3590426777699074 1.3590426777699074
	+0.04 0.008 0.008 4.472 0.9066625612652152 0.9066625612652152
	+0.056 0.008 0.008 3.29 0.7845928880636123 0.7845928880636123
	+0.07200000000000001 0.008000000000000007 0.007999999999999993 0.91 0.4291969244996986 0.4291969244996986
	+0.088 0.007999999999999993 0.008000000000000007 2.109 0.7626231048165273 0.7626231048165273
	+0.10400000000000001 0.008000000000000007 0.007999999999999993 1.199 0.4980612412143711 0.4980612412143711
	+0.12 0.007999999999999993 0.008000000000000007 0.448 0.40285108911358297 0.40285108911358297
	+0.136 0.008000000000000007 0.00799999999999998 0.453 0.4355708897527474 0.4355708897527474
	+0.152 0.008000000000000007 0.008000000000000007 1.296 0.6248015684999518 0.6248015684999518
	+0.16799999999999998 0.00799999999999998 0.008000000000000007 0.171 0.25701750913118737 0.25701750913118737
	+0.184 0.008000000000000007 0.008000000000000007 0.207 0.33562628025826585 0.33562628025826585
	+0.2 0.008000000000000007 0.00799999999999998 0.605 0.40107480599010453 0.40107480599010453
	+0.216 0.008000000000000007 0.008000000000000007 0.29 0.34586124385365874 0.34586124385365874
	+0.23199999999999998 0.00799999999999998 0.008000000000000007 0.055 0.21359073013593077 0.21359073013593077
	+0.248 0.008000000000000007 0.008000000000000007 0.495 0.42498470560715473 0.42498470560715473
	+0.264 0.008000000000000007 0.008000000000000007 0.273 0.31369571243483707 0.31369571243483707
	+0.28 0.008000000000000007 0.007999999999999952 0.124 0.3340014970026332 0.3340014970026332
	+0.296 0.008000000000000007 0.008000000000000007 0.127 0.2380084032129958 0.2380084032129958
	+0.312 0.008000000000000007 0.008000000000000007 0.765 0.5343940493680669 0.5343940493680669
	+0.328 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.344 0.007999999999999952 0.008000000000000007 0.0 0.0 0.0
	+0.36 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.376 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.392 0.008000000000000007 0.008000000000000007 0.318 0.42197274793521916 0.42197274793521916
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d45-x01-y02
	+Path=/REF/L3_2004_I652683/d45-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.008 0.008 0.008 33.692 2.221527852627556 2.221527852627556
	+0.024 0.008 0.008 9.029 0.8345495791143868 0.8345495791143868
	+0.04 0.008 0.008 5.082 0.6153665574273597 0.6153665574273597
	+0.056 0.008 0.008 3.314 0.49343895265777304 0.49343895265777304
	+0.07200000000000001 0.008000000000000007 0.007999999999999993 2.181 0.34120375144479287 0.34120375144479287
	+0.088 0.007999999999999993 0.008000000000000007 1.622 0.3851610052951882 0.3851610052951882
	+0.10400000000000001 0.008000000000000007 0.007999999999999993 1.212 0.3671035276321926 0.3671035276321926
	+0.12 0.007999999999999993 0.008000000000000007 0.72 0.21791970998512272 0.21791970998512272
	+0.136 0.008000000000000007 0.00799999999999998 1.09 0.2675761573832766 0.2675761573832766
	+0.152 0.008000000000000007 0.008000000000000007 0.37 0.18555861607589122 0.18555861607589122
	+0.16799999999999998 0.00799999999999998 0.008000000000000007 0.999 0.3218105032468642 0.3218105032468642
	+0.184 0.008000000000000007 0.008000000000000007 0.239 0.20470710783946902 0.20470710783946902
	+0.2 0.008000000000000007 0.00799999999999998 0.082 0.1470034013211939 0.1470034013211939
	+0.216 0.008000000000000007 0.008000000000000007 0.243 0.2834025405672998 0.2834025405672998
	+0.23199999999999998 0.00799999999999998 0.008000000000000007 0.088 0.19360010330575755 0.19360010330575755
	+0.248 0.008000000000000007 0.008000000000000007 0.311 0.20591260281974 0.20591260281974
	+0.264 0.008000000000000007 0.008000000000000007 0.146 0.18627130750601392 0.18627130750601392
	+0.28 0.008000000000000007 0.007999999999999952 0.237 0.1952255106280939 0.1952255106280939
	+0.296 0.008000000000000007 0.008000000000000007 0.165 0.285175384631984 0.285175384631984
	+0.312 0.008000000000000007 0.008000000000000007 0.006 0.119 0.119
	+0.328 0.008000000000000007 0.008000000000000007 0.035 0.12808200498118383 0.12808200498118383
	+0.344 0.007999999999999952 0.008000000000000007 0.031 0.13392908571329828 0.13392908571329828
	+0.36 0.008000000000000007 0.008000000000000007 0.604 0.30411346566701053 0.30411346566701053
	+0.376 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.392 0.008000000000000007 0.008000000000000007 0.168 0.18698663053812165 0.18698663053812165
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d45-x01-y03
	+Path=/REF/L3_2004_I652683/d45-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.008 0.008 0.008 34.263 0.9781881209665143 0.9781881209665143
	+0.024 0.008 0.008 8.535 0.4275067250933019 0.4275067250933019
	+0.04 0.008 0.008 5.421 0.30466539022343836 0.30466539022343836
	+0.056 0.008 0.008 3.062 0.2828462479864281 0.2828462479864281
	+0.07200000000000001 0.008000000000000007 0.007999999999999993 2.086 0.2498039231077046 0.2498039231077046
	+0.088 0.007999999999999993 0.008000000000000007 1.662 0.2128497122384712 0.2128497122384712
	+0.10400000000000001 0.008000000000000007 0.007999999999999993 1.337 0.18738463117342363 0.18738463117342363
	+0.12 0.007999999999999993 0.008000000000000007 1.203 0.2573888109456198 0.2573888109456198
	+0.136 0.008000000000000007 0.00799999999999998 0.851 0.16138463371709216 0.16138463371709216
	+0.152 0.008000000000000007 0.008000000000000007 0.405 0.12010412149464314 0.12010412149464314
	+0.16799999999999998 0.00799999999999998 0.008000000000000007 0.721 0.19266551326067674 0.19266551326067674
	+0.184 0.008000000000000007 0.008000000000000007 0.643 0.24066989840858785 0.24066989840858785
	+0.2 0.008000000000000007 0.00799999999999998 0.359 0.13599999999999998 0.13599999999999998
	+0.216 0.008000000000000007 0.008000000000000007 0.352 0.1297112177107285 0.1297112177107285
	+0.23199999999999998 0.00799999999999998 0.008000000000000007 0.132 0.17102631376487068 0.17102631376487068
	+0.248 0.008000000000000007 0.008000000000000007 0.012 0.14239382009062052 0.14239382009062052
	+0.264 0.008000000000000007 0.008000000000000007 0.341 0.19803535037967337 0.19803535037967337
	+0.28 0.008000000000000007 0.007999999999999952 0.104 0.08935882720806042 0.08935882720806042
	+0.296 0.008000000000000007 0.008000000000000007 0.028 0.09100549433962765 0.09100549433962765
	+0.312 0.008000000000000007 0.008000000000000007 0.204 0.113017697729161 0.113017697729161
	+0.328 0.008000000000000007 0.008000000000000007 0.101 0.10600471687618433 0.10600471687618433
	+0.344 0.007999999999999952 0.008000000000000007 0.0 0.0 0.0
	+0.36 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.376 0.008000000000000007 0.008000000000000007 0.24 0.13520724832641184 0.13520724832641184
	+0.392 0.008000000000000007 0.008000000000000007 0.066 0.07808969202141855 0.07808969202141855
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d46-x01-y01
	+Path=/REF/L3_2004_I652683/d46-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.008 0.008 0.008 34.894 1.289601876549503 1.289601876549503
	+0.024 0.008 0.008 9.195 0.5957390368273678 0.5957390368273678
	+0.04 0.008 0.008 4.744 0.43549167615466544 0.43549167615466544
	+0.056 0.008 0.008 3.568 0.3762472591262294 0.3762472591262294
	+0.07200000000000001 0.008000000000000007 0.007999999999999993 1.975 0.3462080299473136 0.3462080299473136
	+0.088 0.007999999999999993 0.008000000000000007 1.683 0.4266204402041703 0.4266204402041703
	+0.10400000000000001 0.008000000000000007 0.007999999999999993 1.633 0.37283910739084225 0.37283910739084225
	+0.12 0.007999999999999993 0.008000000000000007 1.086 0.2735434152013168 0.2735434152013168
	+0.136 0.008000000000000007 0.00799999999999998 0.961 0.3118926097232828 0.3118926097232828
	+0.152 0.008000000000000007 0.008000000000000007 0.469 0.31630523233105073 0.31630523233105073
	+0.16799999999999998 0.00799999999999998 0.008000000000000007 0.437 0.2898033816227823 0.2898033816227823
	+0.184 0.008000000000000007 0.008000000000000007 0.295 0.2416464359348178 0.2416464359348178
	+0.2 0.008000000000000007 0.00799999999999998 0.171 0.176459627110566 0.176459627110566
	+0.216 0.008000000000000007 0.008000000000000007 0.288 0.19629060089571276 0.19629060089571276
	+0.23199999999999998 0.00799999999999998 0.008000000000000007 0.418 0.24095850265139016 0.24095850265139016
	+0.248 0.008000000000000007 0.008000000000000007 0.045 0.25079872407968906 0.25079872407968906
	+0.264 0.008000000000000007 0.008000000000000007 0.266 0.20278560106674243 0.20278560106674243
	+0.28 0.008000000000000007 0.007999999999999952 0.0 0.0 0.0
	+0.296 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.312 0.008000000000000007 0.008000000000000007 0.036 0.10720074626605917 0.10720074626605917
	+0.328 0.008000000000000007 0.008000000000000007 0.022 0.0841486779456457 0.0841486779456457
	+0.344 0.007999999999999952 0.008000000000000007 0.074 0.10575916035975323 0.10575916035975323
	+0.36 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.376 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.392 0.008000000000000007 0.008000000000000007 0.039 0.09752948272189287 0.09752948272189287
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d46-x01-y02
	+Path=/REF/L3_2004_I652683/d46-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.008 0.008 0.008 33.486 1.172015784876637 1.172015784876637
	+0.024 0.008 0.008 9.23 0.7405869294012689 0.7405869294012689
	+0.04 0.008 0.008 4.744 0.53804181993596 0.53804181993596
	+0.056 0.008 0.008 3.175 0.34717430780517156 0.34717430780517156
	+0.07200000000000001 0.008000000000000007 0.007999999999999993 2.321 0.32334656330321493 0.32334656330321493
	+0.088 0.007999999999999993 0.008000000000000007 2.172 0.3010398644698074 0.3010398644698074
	+0.10400000000000001 0.008000000000000007 0.007999999999999993 1.35 0.2836353292521931 0.2836353292521931
	+0.12 0.007999999999999993 0.008000000000000007 0.86 0.44627906067840556 0.44627906067840556
	+0.136 0.008000000000000007 0.00799999999999998 0.742 0.26905018119302576 0.26905018119302576
	+0.152 0.008000000000000007 0.008000000000000007 0.855 0.3002682134359213 0.3002682134359213
	+0.16799999999999998 0.00799999999999998 0.008000000000000007 0.712 0.26683515510516975 0.26683515510516975
	+0.184 0.008000000000000007 0.008000000000000007 0.855 0.3058970415025291 0.3058970415025291
	+0.2 0.008000000000000007 0.00799999999999998 0.418 0.25086251214559735 0.25086251214559735
	+0.216 0.008000000000000007 0.008000000000000007 0.308 0.23754157530840786 0.23754157530840786
	+0.23199999999999998 0.00799999999999998 0.008000000000000007 0.215 0.2200954338463204 0.2200954338463204
	+0.248 0.008000000000000007 0.008000000000000007 0.461 0.27882073093656434 0.27882073093656434
	+0.264 0.008000000000000007 0.008000000000000007 0.018 0.18965494984312958 0.18965494984312958
	+0.28 0.008000000000000007 0.007999999999999952 0.0 0.0 0.0
	+0.296 0.008000000000000007 0.008000000000000007 0.098 0.1475127113166862 0.1475127113166862
	+0.312 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.328 0.008000000000000007 0.008000000000000007 0.149 0.17892177061498132 0.17892177061498132
	+0.344 0.007999999999999952 0.008000000000000007 0.054 0.15910059710761618 0.15910059710761618
	+0.36 0.008000000000000007 0.008000000000000007 0.048 0.08407734534343957 0.08407734534343957
	+0.376 0.008000000000000007 0.008000000000000007 0.025 0.09353608929178085 0.09353608929178085
	+0.392 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d46-x01-y03
	+Path=/REF/L3_2004_I652683/d46-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.008 0.008 0.008 33.974 0.993000503524545 0.993000503524545
	+0.024 0.008 0.008 8.981 0.44417676661437394 0.44417676661437394
	+0.04 0.008 0.008 4.963 0.3197389560250674 0.3197389560250674
	+0.056 0.008 0.008 2.969 0.274781731561616 0.274781731561616
	+0.07200000000000001 0.008000000000000007 0.007999999999999993 2.618 0.2575597018168797 0.2575597018168797
	+0.088 0.007999999999999993 0.008000000000000007 1.53 0.2469817807045694 0.2469817807045694
	+0.10400000000000001 0.008000000000000007 0.007999999999999993 1.647 0.2600192300580863 0.2600192300580863
	+0.12 0.007999999999999993 0.008000000000000007 0.923 0.20854256160314133 0.20854256160314133
	+0.136 0.008000000000000007 0.00799999999999998 1.093 0.2572003110418026 0.2572003110418026
	+0.152 0.008000000000000007 0.008000000000000007 0.526 0.1945893111144597 0.1945893111144597
	+0.16799999999999998 0.00799999999999998 0.008000000000000007 0.499 0.1914262259984248 0.1914262259984248
	+0.184 0.008000000000000007 0.008000000000000007 0.667 0.238214189333885 0.238214189333885
	+0.2 0.008000000000000007 0.00799999999999998 0.234 0.175316856006489 0.175316856006489
	+0.216 0.008000000000000007 0.008000000000000007 0.547 0.24806853891616326 0.24806853891616326
	+0.23199999999999998 0.00799999999999998 0.008000000000000007 0.337 0.18738729946290386 0.18738729946290386
	+0.248 0.008000000000000007 0.008000000000000007 0.301 0.20836986346398562 0.20836986346398562
	+0.264 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.28 0.008000000000000007 0.007999999999999952 0.057 0.16429546554911367 0.16429546554911367
	+0.296 0.008000000000000007 0.008000000000000007 0.045 0.116619037896906 0.116619037896906
	+0.312 0.008000000000000007 0.008000000000000007 0.124 0.1406164997430956 0.1406164997430956
	+0.328 0.008000000000000007 0.008000000000000007 0.148 0.1523975065412817 0.1523975065412817
	+0.344 0.007999999999999952 0.008000000000000007 0.018 0.06140032573203501 0.06140032573203501
	+0.36 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.376 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+0.392 0.008000000000000007 0.008000000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d47-x01-y01
	+Path=/REF/L3_2004_I652683/d47-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.5874999999999999 0.012499999999999956 0.012500000000000067 0.001 0.0 0.0
	+0.6125 0.012500000000000067 0.012499999999999956 0.008 0.002 0.002
	+0.6375 0.012499999999999956 0.012500000000000067 0.025 0.001414213562373095 0.001414213562373095
	+0.6625000000000001 0.012500000000000067 0.012499999999999956 0.085 0.007280109889280519 0.007280109889280519
	+0.6875 0.012499999999999956 0.012499999999999956 0.155 0.004242640687119285 0.004242640687119285
	+0.7124999999999999 0.012499999999999956 0.012500000000000067 0.237 0.0058309518948453 0.0058309518948453
	+0.7375 0.012500000000000067 0.012499999999999956 0.339 0.007211102550927979 0.007211102550927979
	+0.7625 0.012499999999999956 0.012500000000000067 0.477 0.012083045973594572 0.012083045973594572
	+0.7875000000000001 0.012500000000000067 0.012499999999999956 0.627 0.01392838827718412 0.01392838827718412
	+0.8125 0.012499999999999956 0.012499999999999956 0.838 0.015231546211727818 0.015231546211727818
	+0.8374999999999999 0.012499999999999956 0.012500000000000067 1.169 0.021540659228538015 0.021540659228538015
	+0.8625 0.012500000000000067 0.012499999999999956 1.598 0.04295346318982906 0.04295346318982906
	+0.8875 0.012499999999999956 0.012500000000000067 2.329 0.039293765408777 0.039293765408777
	+0.9125000000000001 0.012500000000000067 0.012499999999999956 3.614 0.06020797289396147 0.06020797289396147
	+0.9375 0.012499999999999956 0.012499999999999956 6.186 0.10196568050084304 0.10196568050084304
	+0.9624999999999999 0.012499999999999956 0.012500000000000067 12.801 0.21199292441022646 0.21199292441022646
	+0.9875 0.012500000000000067 0.012499999999999956 9.513 0.15692354826475216 0.15692354826475216
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d47-x01-y02
	+Path=/REF/L3_2004_I652683/d47-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.5874999999999999 0.012499999999999956 0.012500000000000067 0.001 0.001 0.001
	+0.6125 0.012500000000000067 0.012499999999999956 0.005 0.001414213562373095 0.001414213562373095
	+0.6375 0.012499999999999956 0.012500000000000067 0.034 0.00282842712474619 0.00282842712474619
	+0.6625000000000001 0.012500000000000067 0.012499999999999956 0.089 0.008944271909999158 0.008944271909999158
	+0.6875 0.012499999999999956 0.012499999999999956 0.166 0.009219544457292887 0.009219544457292887
	+0.7124999999999999 0.012499999999999956 0.012500000000000067 0.25 0.013601470508735444 0.013601470508735444
	+0.7375 0.012500000000000067 0.012499999999999956 0.342 0.01345362404707371 0.01345362404707371
	+0.7625 0.012499999999999956 0.012500000000000067 0.488 0.016278820596099707 0.016278820596099707
	+0.7875000000000001 0.012500000000000067 0.012499999999999956 0.643 0.019849433241279208 0.019849433241279208
	+0.8125 0.012499999999999956 0.012499999999999956 0.859 0.022803508501982758 0.022803508501982758
	+0.8374999999999999 0.012499999999999956 0.012500000000000067 1.195 0.031064449134018134 0.031064449134018134
	+0.8625 0.012500000000000067 0.012499999999999956 1.737 0.05015974481593781 0.05015974481593781
	+0.8875 0.012499999999999956 0.012500000000000067 2.442 0.053712196007983146 0.053712196007983146
	+0.9125000000000001 0.012500000000000067 0.012499999999999956 3.855 0.08477027781009096 0.08477027781009096
	+0.9375 0.012499999999999956 0.012499999999999956 6.564 0.13417153200288057 0.13417153200288057
	+0.9624999999999999 0.012499999999999956 0.012500000000000067 13.475 0.2755358415887124 0.2755358415887124
	+0.9875 0.012500000000000067 0.012499999999999956 7.855 0.18794946129212503 0.18794946129212503
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d48-x01-y01
	+Path=/REF/L3_2004_I652683/d48-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 7.432 0.15762296786953353 0.15762296786953353
	+0.0225 0.0075 0.0075 21.946 0.7897138722347481 0.7897138722347481
	+0.0375 0.0075 0.0075 11.89 0.5557058574461853 0.5557058574461853
	+0.0525 0.0075 0.0075 7.033 0.19436563482261984 0.19436563482261984
	+0.0675 0.007500000000000007 0.007499999999999993 4.595 0.09904039579888602 0.09904039579888602
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 3.279 0.07106335201775948 0.07106335201775948
	+0.0975 0.007500000000000007 0.007499999999999993 2.433 0.05316013544000805 0.05316013544000805
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.89 0.04684015371452147 0.04684015371452147
	+0.1275 0.007500000000000007 0.007500000000000007 1.445 0.03324154027718932 0.03324154027718932
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.105 0.025079872407968905 0.025079872407968905
	+0.1575 0.007500000000000007 0.007500000000000007 0.917 0.022847319317591725 0.022847319317591725
	+0.1725 0.007499999999999979 0.007500000000000007 0.689 0.016999999999999998 0.016999999999999998
	+0.1875 0.007500000000000007 0.007500000000000007 0.55 0.013892443989449804 0.013892443989449804
	+0.2025 0.007500000000000007 0.007499999999999979 0.425 0.010816653826391968 0.010816653826391968
	+0.2175 0.007500000000000007 0.007500000000000007 0.32 0.008602325267042627 0.008602325267042627
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.256 0.007071067811865475 0.007071067811865475
	+0.2475 0.007500000000000007 0.007500000000000007 0.183 0.00565685424949238 0.00565685424949238
	+0.2625 0.007500000000000007 0.007500000000000007 0.133 0.004242640687119285 0.004242640687119285
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.086 0.005 0.005
	+0.2925 0.007500000000000007 0.007500000000000007 0.059 0.00282842712474619 0.00282842712474619
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d48-x01-y02
	+Path=/REF/L3_2004_I652683/d48-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 6.126 0.17228464818433475 0.17228464818433475
	+0.0225 0.0075 0.0075 22.363 0.872708427826843 0.872708427826843
	+0.0375 0.0075 0.0075 11.945 0.5636896309140342 0.5636896309140342
	+0.0525 0.0075 0.0075 7.214 0.2212690669750293 0.2212690669750293
	+0.0675 0.007500000000000007 0.007499999999999993 4.824 0.1252517464948094 0.1252517464948094
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 3.508 0.09442986815621422 0.09442986815621422
	+0.0975 0.007500000000000007 0.007499999999999993 2.478 0.06935416353759881 0.06935416353759881
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 1.95 0.05916924876994806 0.05916924876994806
	+0.1275 0.007500000000000007 0.007500000000000007 1.422 0.04301162633521314 0.04301162633521314
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.196 0.037643060449437424 0.037643060449437424
	+0.1575 0.007500000000000007 0.007500000000000007 0.866 0.02973213749463701 0.02973213749463701
	+0.1725 0.007499999999999979 0.007500000000000007 0.727 0.02545584412271571 0.02545584412271571
	+0.1875 0.007500000000000007 0.007500000000000007 0.564 0.022022715545545243 0.022022715545545243
	+0.2025 0.007500000000000007 0.007499999999999979 0.424 0.017204650534085254 0.017204650534085254
	+0.2175 0.007500000000000007 0.007500000000000007 0.339 0.015264337522473748 0.015264337522473748
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.235 0.0116619037896906 0.0116619037896906
	+0.2475 0.007500000000000007 0.007500000000000007 0.192 0.010295630140987 0.010295630140987
	+0.2625 0.007500000000000007 0.007500000000000007 0.131 0.00806225774829855 0.00806225774829855
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.108 0.01063014581273465 0.01063014581273465
	+0.2925 0.007500000000000007 0.007500000000000007 0.055 0.004472135954999579 0.004472135954999579
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d49-x01-y01
	+Path=/REF/L3_2004_I652683/d49-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.003 0.014 0.014
	+0.03 0.009999999999999998 0.010000000000000002 1.588 0.8110154129238236 0.8110154129238236
	+0.05 0.010000000000000002 0.009999999999999995 10.151 0.5337883475685845 0.5337883475685845
	+0.07 0.010000000000000009 0.009999999999999995 9.728 0.5116111804876824 0.5116111804876824
	+0.09 0.009999999999999995 0.010000000000000009 7.282 0.38352183770940607 0.38352183770940607
	+0.11 0.009999999999999995 0.009999999999999995 5.438 0.2865047992617226 0.2865047992617226
	+0.13 0.010000000000000009 0.010000000000000009 4.06 0.21352751579129095 0.21352751579129095
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 3.033 0.15953056133543816 0.15953056133543816
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 2.313 0.12159358535712318 0.12159358535712318
	+0.19 0.010000000000000009 0.010000000000000009 1.778 0.09353608929178085 0.09353608929178085
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 1.396 0.07355270219373317 0.07355270219373317
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 1.046 0.055578772926361014 0.055578772926361014
	+0.25 0.010000000000000009 0.010000000000000009 0.812 0.043566041821583926 0.043566041821583926
	+0.27 0.010000000000000009 0.010000000000000009 0.58 0.03157530680769389 0.03157530680769389
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.413 0.02256102834535695 0.02256102834535695
	+0.31 0.010000000000000009 0.010000000000000009 0.233 0.012369316876852983 0.012369316876852983
	+0.33 0.010000000000000009 0.010000000000000009 0.105 0.005385164807134504 0.005385164807134504
	+0.35 0.009999999999999953 0.010000000000000009 0.034 0.00608276253029822 0.00608276253029822
	+0.37 0.010000000000000009 0.010000000000000009 0.009 0.002 0.002
	+0.39 0.010000000000000009 0.010000000000000009 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d49-x01-y02
	+Path=/REF/L3_2004_I652683/d49-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.01 0.01 0.01 0.0 0.0 0.0
	+0.03 0.009999999999999998 0.010000000000000002 0.009 0.001 0.001
	+0.05 0.010000000000000002 0.009999999999999995 3.093 0.17602840679844828 0.17602840679844828
	+0.07 0.010000000000000009 0.009999999999999995 13.369 0.5128001560062165 0.5128001560062165
	+0.09 0.009999999999999995 0.010000000000000009 9.338 0.21378961621182632 0.21378961621182632
	+0.11 0.009999999999999995 0.009999999999999995 6.565 0.15183214415926555 0.15183214415926555
	+0.13 0.010000000000000009 0.010000000000000009 4.616 0.10815729286552987 0.10815729286552987
	+0.15000000000000002 0.010000000000000009 0.009999999999999981 3.445 0.08300602387778853 0.08300602387778853
	+0.16999999999999998 0.009999999999999981 0.010000000000000009 2.624 0.06488451279003334 0.06488451279003334
	+0.19 0.010000000000000009 0.010000000000000009 2.012 0.051478150704935 0.051478150704935
	+0.21000000000000002 0.010000000000000009 0.009999999999999981 1.511 0.03996248240537617 0.03996248240537617
	+0.22999999999999998 0.009999999999999981 0.010000000000000009 1.104 0.03080584360149873 0.03080584360149873
	+0.25 0.010000000000000009 0.010000000000000009 0.831 0.028017851452243798 0.028017851452243798
	+0.27 0.010000000000000009 0.010000000000000009 0.659 0.023430749027719962 0.023430749027719962
	+0.29000000000000004 0.010000000000000009 0.009999999999999953 0.415 0.0194164878389476 0.0194164878389476
	+0.31 0.010000000000000009 0.010000000000000009 0.248 0.015811388300841896 0.015811388300841896
	+0.33 0.010000000000000009 0.010000000000000009 0.126 0.009433981132056603 0.009433981132056603
	+0.35 0.009999999999999953 0.010000000000000009 0.033 0.005385164807134504 0.005385164807134504
	+0.37 0.010000000000000009 0.010000000000000009 0.003 0.002 0.002
	+0.39 0.010000000000000009 0.010000000000000009 0.001 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d50-x01-y01
	+Path=/REF/L3_2004_I652683/d50-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 0.043 0.173 0.173
	+0.0225 0.0075 0.0075 9.367 0.25454469155729803 0.25454469155729803
	+0.0375 0.0075 0.0075 15.028 0.41294188453098335 0.41294188453098335
	+0.0525 0.0075 0.0075 10.693 0.3390766874911928 0.3390766874911928
	+0.0675 0.007500000000000007 0.007499999999999993 7.827 0.11161093136427094 0.11161093136427094
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 5.721 0.08174350127074323 0.08174350127074323
	+0.0975 0.007500000000000007 0.007499999999999993 4.282 0.07324616030891994 0.07324616030891994
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 3.338 0.04870318264754368 0.04870318264754368
	+0.1275 0.007500000000000007 0.007500000000000007 2.595 0.03862641583165593 0.03862641583165593
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 2.046 0.03178049716414141 0.03178049716414141
	+0.1575 0.007500000000000007 0.007500000000000007 1.585 0.024596747752497684 0.024596747752497684
	+0.1725 0.007499999999999979 0.007500000000000007 1.273 0.021095023109728987 0.021095023109728987
	+0.1875 0.007500000000000007 0.007500000000000007 0.967 0.015811388300841896 0.015811388300841896
	+0.2025 0.007500000000000007 0.007499999999999979 0.702 0.012206555615733704 0.012206555615733704
	+0.2175 0.007500000000000007 0.007500000000000007 0.515 0.01063014581273465 0.01063014581273465
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.344 0.0078102496759066544 0.0078102496759066544
	+0.2475 0.007500000000000007 0.007500000000000007 0.211 0.006403124237432849 0.006403124237432849
	+0.2625 0.007500000000000007 0.007500000000000007 0.108 0.004242640687119285 0.004242640687119285
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.022 0.0031622776601683794 0.0031622776601683794
	+0.2925 0.007500000000000007 0.007500000000000007 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d50-x01-y02
	+Path=/REF/L3_2004_I652683/d50-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.0075 0.0075 0.0075 0.0 0.0 0.0
	+0.0225 0.0075 0.0075 1.734 0.08448076704197234 0.08448076704197234
	+0.0375 0.0075 0.0075 19.779 0.8219939172524332 0.8219939172524332
	+0.0525 0.0075 0.0075 12.239 0.4456601844455033 0.4456601844455033
	+0.0675 0.007500000000000007 0.007499999999999993 8.451 0.16292636373527766 0.16292636373527766
	+0.08249999999999999 0.007499999999999993 0.007500000000000007 5.951 0.11754573577973809 0.11754573577973809
	+0.0975 0.007500000000000007 0.007499999999999993 4.538 0.09213576938409969 0.09213576938409969
	+0.11249999999999999 0.007499999999999993 0.007500000000000007 3.433 0.07256031973468695 0.07256031973468695
	+0.1275 0.007500000000000007 0.007500000000000007 2.745 0.05990826320300064 0.05990826320300064
	+0.14250000000000002 0.007500000000000007 0.007499999999999979 1.993 0.04640043103248072 0.04640043103248072
	+0.1575 0.007500000000000007 0.007500000000000007 1.639 0.039698866482558416 0.039698866482558416
	+0.1725 0.007499999999999979 0.007500000000000007 1.278 0.03252691193458118 0.03252691193458118
	+0.1875 0.007500000000000007 0.007500000000000007 0.933 0.025495097567963924 0.025495097567963924
	+0.2025 0.007500000000000007 0.007499999999999979 0.744 0.022803508501982758 0.022803508501982758
	+0.2175 0.007500000000000007 0.007500000000000007 0.516 0.018439088914585774 0.018439088914585774
	+0.23249999999999998 0.007499999999999979 0.007500000000000007 0.347 0.015 0.015
	+0.2475 0.007500000000000007 0.007500000000000007 0.225 0.012041594578792296 0.012041594578792296
	+0.2625 0.007500000000000007 0.007500000000000007 0.1 0.006403124237432849 0.006403124237432849
	+0.27749999999999997 0.007499999999999951 0.007500000000000007 0.019 0.0022360679774997894 0.0022360679774997894
	+0.2925 0.007500000000000007 0.007500000000000007 0.001 0.001 0.001
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d51-x01-y01
	+Path=/REF/L3_2004_I652683/d51-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 0.194 0.119 0.119
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 3.04 0.08845903006477066 0.08845903006477066
	+0.125 0.024999999999999994 0.024999999999999994 4.01 0.11552488909321662 0.11552488909321662
	+0.175 0.024999999999999994 0.025000000000000022 2.849 0.06946221994724902 0.06946221994724902
	+0.225 0.024999999999999994 0.024999999999999994 2.071 0.05941380311005179 0.05941380311005179
	+0.275 0.025000000000000022 0.024999999999999967 1.567 0.02863564212655271 0.02863564212655271
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 1.232 0.02256102834535695 0.02256102834535695
	+0.375 0.025000000000000022 0.025000000000000022 0.984 0.01772004514666935 0.01772004514666935
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.804 0.01649242250247064 0.01649242250247064
	+0.475 0.024999999999999967 0.025000000000000022 0.665 0.012649110640673518 0.012649110640673518
	+0.525 0.025000000000000022 0.025000000000000022 0.56 0.010770329614269008 0.010770329614269008
	+0.575 0.02499999999999991 0.025000000000000022 0.488 0.01044030650891055 0.01044030650891055
	+0.625 0.025000000000000022 0.025000000000000022 0.419 0.007615773105863909 0.007615773105863909
	+0.675 0.025000000000000022 0.02499999999999991 0.358 0.00670820393249937 0.00670820393249937
	+0.725 0.025000000000000022 0.025000000000000022 0.31 0.009486832980505138 0.009486832980505138
	+0.775 0.025000000000000022 0.025000000000000022 0.26 0.0058309518948453 0.0058309518948453
	+0.825 0.02499999999999991 0.025000000000000022 0.124 0.00824621125123532 0.00824621125123532
	+0.875 0.025000000000000022 0.025000000000000022 0.047 0.0022360679774997894 0.0022360679774997894
	+0.925 0.025000000000000022 0.02499999999999991 0.016 0.0022360679774997894 0.0022360679774997894
	+0.975 0.025000000000000022 0.025000000000000022 0.003 0.001 0.001
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d51-x01-y02
	+Path=/REF/L3_2004_I652683/d51-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.025 0.025 0.025 0.013 0.001 0.001
	+0.07500000000000001 0.02500000000000001 0.024999999999999994 1.921 0.07200694410957877 0.07200694410957877
	+0.125 0.024999999999999994 0.024999999999999994 4.303 0.1509205088780183 0.1509205088780183
	+0.175 0.024999999999999994 0.025000000000000022 3.142 0.08452810183601665 0.08452810183601665
	+0.225 0.024999999999999994 0.024999999999999994 2.21 0.0692314957226839 0.0692314957226839
	+0.275 0.025000000000000022 0.024999999999999967 1.746 0.03921734310225515 0.03921734310225515
	+0.32499999999999996 0.024999999999999967 0.025000000000000022 1.29 0.0291547594742265 0.0291547594742265
	+0.375 0.025000000000000022 0.025000000000000022 1.076 0.025495097567963924 0.025495097567963924
	+0.42500000000000004 0.025000000000000022 0.024999999999999967 0.875 0.022360679774997897 0.022360679774997897
	+0.475 0.024999999999999967 0.025000000000000022 0.695 0.017492855684535902 0.017492855684535902
	+0.525 0.025000000000000022 0.025000000000000022 0.627 0.015811388300841896 0.015811388300841896
	+0.575 0.02499999999999991 0.025000000000000022 0.502 0.013601470508735444 0.013601470508735444
	+0.625 0.025000000000000022 0.025000000000000022 0.423 0.011401754250991379 0.011401754250991379
	+0.675 0.025000000000000022 0.02499999999999991 0.347 0.009219544457292887 0.009219544457292887
	+0.725 0.025000000000000022 0.025000000000000022 0.334 0.013038404810405297 0.013038404810405297
	+0.775 0.025000000000000022 0.025000000000000022 0.288 0.009899494936611667 0.009899494936611667
	+0.825 0.02499999999999991 0.025000000000000022 0.129 0.011704699910719625 0.011704699910719625
	+0.875 0.025000000000000022 0.025000000000000022 0.06 0.0036055512754639895 0.0036055512754639895
	+0.925 0.025000000000000022 0.02499999999999991 0.017 0.0022360679774997894 0.0022360679774997894
	+0.975 0.025000000000000022 0.025000000000000022 0.001 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d52-x01-y01
	+Path=/REF/L3_2004_I652683/d52-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.016 0.016 0.016 17.574 0.3262207841324645 0.3262207841324645
	+0.048 0.016 0.016 5.154 0.09542536350467835 0.09542536350467835
	+0.08 0.016 0.016 2.622 0.04883646178829912 0.04883646178829912
	+0.112 0.016 0.016 1.62 0.030805843601498725 0.030805843601498725
	+0.14400000000000002 0.016000000000000014 0.015999999999999986 1.111 0.025709920264364885 0.025709920264364885
	+0.176 0.015999999999999986 0.016000000000000014 0.785 0.0196468827043885 0.0196468827043885
	+0.20800000000000002 0.016000000000000014 0.015999999999999986 0.563 0.01772004514666935 0.01772004514666935
	+0.24 0.015999999999999986 0.016000000000000014 0.425 0.013601470508735444 0.013601470508735444
	+0.272 0.016000000000000014 0.01599999999999996 0.322 0.009486832980505138 0.009486832980505138
	+0.304 0.016000000000000014 0.016000000000000014 0.241 0.008544003745317531 0.008544003745317531
	+0.33599999999999997 0.01599999999999996 0.016000000000000014 0.184 0.00670820393249937 0.00670820393249937
	+0.368 0.016000000000000014 0.016000000000000014 0.15 0.007615773105863909 0.007615773105863909
	+0.4 0.016000000000000014 0.01599999999999996 0.111 0.005385164807134504 0.005385164807134504
	+0.432 0.016000000000000014 0.016000000000000014 0.087 0.006324555320336759 0.006324555320336759
	+0.46399999999999997 0.01599999999999996 0.016000000000000014 0.068 0.00282842712474619 0.00282842712474619
	+0.496 0.016000000000000014 0.016000000000000014 0.057 0.00282842712474619 0.00282842712474619
	+0.528 0.016000000000000014 0.016000000000000014 0.044 0.001414213562373095 0.001414213562373095
	+0.56 0.016000000000000014 0.015999999999999903 0.035 0.0022360679774997894 0.0022360679774997894
	+0.592 0.016000000000000014 0.016000000000000014 0.027 0.001414213562373095 0.001414213562373095
	+0.624 0.016000000000000014 0.016000000000000014 0.019 0.001414213562373095 0.001414213562373095
	+0.656 0.016000000000000014 0.016000000000000014 0.017 0.001414213562373095 0.001414213562373095
	+0.688 0.015999999999999903 0.016000000000000014 0.012 0.001 0.001
	+0.72 0.016000000000000014 0.016000000000000014 0.011 0.001414213562373095 0.001414213562373095
	+0.752 0.016000000000000014 0.016000000000000014 0.008 0.001414213562373095 0.001414213562373095
	+0.784 0.016000000000000014 0.016000000000000014 0.003 0.001 0.001
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d52-x01-y02
	+Path=/REF/L3_2004_I652683/d52-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.016 0.016 0.016 16.133 0.33852917156428336 0.33852917156428336
	+0.048 0.016 0.016 5.432 0.11278741064498289 0.11278741064498289
	+0.08 0.016 0.016 2.858 0.06168468205316454 0.06168468205316454
	+0.112 0.016 0.016 1.816 0.04071854614300466 0.04071854614300466
	+0.14400000000000002 0.016000000000000014 0.015999999999999986 1.307 0.03534119409414458 0.03534119409414458
	+0.176 0.015999999999999986 0.016000000000000014 0.944 0.028178005607210743 0.028178005607210743
	+0.20800000000000002 0.016000000000000014 0.015999999999999986 0.698 0.02683281572999748 0.02683281572999748
	+0.24 0.015999999999999986 0.016000000000000014 0.504 0.01972308292331602 0.01972308292331602
	+0.272 0.016000000000000014 0.01599999999999996 0.368 0.013601470508735444 0.013601470508735444
	+0.304 0.016000000000000014 0.016000000000000014 0.273 0.009899494936611667 0.009899494936611667
	+0.33599999999999997 0.01599999999999996 0.016000000000000014 0.227 0.009219544457292887 0.009219544457292887
	+0.368 0.016000000000000014 0.016000000000000014 0.16 0.00848528137423857 0.00848528137423857
	+0.4 0.016000000000000014 0.01599999999999996 0.116 0.007071067811865475 0.007071067811865475
	+0.432 0.016000000000000014 0.016000000000000014 0.082 0.007211102550927979 0.007211102550927979
	+0.46399999999999997 0.01599999999999996 0.016000000000000014 0.077 0.00565685424949238 0.00565685424949238
	+0.496 0.016000000000000014 0.016000000000000014 0.06 0.005 0.005
	+0.528 0.016000000000000014 0.016000000000000014 0.049 0.005 0.005
	+0.56 0.016000000000000014 0.015999999999999903 0.033 0.0036055512754639895 0.0036055512754639895
	+0.592 0.016000000000000014 0.016000000000000014 0.03 0.0036055512754639895 0.0036055512754639895
	+0.624 0.016000000000000014 0.016000000000000014 0.017 0.0022360679774997894 0.0022360679774997894
	+0.656 0.016000000000000014 0.016000000000000014 0.023 0.0031622776601683794 0.0031622776601683794
	+0.688 0.015999999999999903 0.016000000000000014 0.018 0.002 0.002
	+0.72 0.016000000000000014 0.016000000000000014 0.012 0.00282842712474619 0.00282842712474619
	+0.752 0.016000000000000014 0.016000000000000014 0.005 0.001414213562373095 0.001414213562373095
	+0.784 0.016000000000000014 0.016000000000000014 0.007 0.0031622776601683794 0.0031622776601683794
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d53-x01-y01
	+Path=/REF/L3_2004_I652683/d53-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+41.4 0.0 0.0 0.0971 0.004534313619501853 0.004534313619501853
	+55.3 0.0 0.0 0.0811 0.003962322551231789 0.003962322551231789
	+65.4 0.0 0.0 0.0796 0.005515432893255071 0.005515432893255071
	+75.7 0.0 0.0 0.0731 0.004743416490252569 0.004743416490252569
	+82.3 0.0 0.0 0.07 0.0049396356140913875 0.0049396356140913875
	+85.1 0.0 0.0 0.0691 0.009070832376358853 0.009070832376358853
	+130.1 0.0 0.0 0.0556 0.0026076809620810596 0.0026076809620810596
	+136.1 0.0 0.0 0.0614 0.0032310988842807024 0.0032310988842807024
	+161.3 0.0 0.0 0.0513 0.003104834939252005 0.003104834939252005
	+172.3 0.0 0.0 0.0542 0.004304648650006177 0.004304648650006177
	+182.8 0.0 0.0 0.0539 0.0022825424421026655 0.0022825424421026655
	+188.6 0.0 0.0 0.0548 0.0018384776310850235 0.0018384776310850235
	+194.4 0.0 0.0 0.0551 0.0025238858928247924 0.0025238858928247924
	+200.2 0.0 0.0 0.0582 0.002580697580112788 0.002580697580112788
	+206.2 0.0 0.0 0.0569 0.0023345235059857505 0.0023345235059857505
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d53-x01-y02
	+Path=/REF/L3_2004_I652683/d53-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+41.4 0.0 0.0 0.0143 0.0017492855684535901 0.0017492855684535901
	+55.3 0.0 0.0 0.0109 0.001 0.001
	+65.4 0.0 0.0 0.0109 0.00116619037896906 0.00116619037896906
	+75.7 0.0 0.0 0.0093 0.0010770329614269007 0.0010770329614269007
	+82.3 0.0 0.0 0.0086 0.0011180339887498947 0.0011180339887498947
	+85.1 0.0 0.0 0.0086 0.00208806130178211 0.00208806130178211
	+130.1 0.0 0.0 0.0064 5.385164807134503E-4 5.385164807134503E-4
	+136.1 0.0 0.0 0.008 0.0010630145812734648 0.0010630145812734648
	+161.3 0.0 0.0 0.0059 7.280109889280518E-4 7.280109889280518E-4
	+172.3 0.0 0.0 0.0064 0.0010295630140987001 0.0010295630140987001
	+182.8 0.0 0.0 0.0064 5.099019513592785E-4 5.099019513592785E-4
	+188.6 0.0 0.0 0.0064 6.403124237432849E-4 6.403124237432849E-4
	+194.4 0.0 0.0 0.0063 7.211102550927978E-4 7.211102550927978E-4
	+200.2 0.0 0.0 0.0073 7.211102550927978E-4 7.211102550927978E-4
	+206.2 0.0 0.0 0.007 7.071067811865475E-4 7.071067811865475E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d54-x01-y01
	+Path=/REF/L3_2004_I652683/d54-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+41.4 0.0 0.0 0.0747 0.0032526911934581187 0.0032526911934581187
	+55.3 0.0 0.0 0.0632 0.0031144823004794872 0.0031144823004794872
	+65.4 0.0 0.0 0.0603 0.004933558553417604 0.004933558553417604
	+75.7 0.0 0.0 0.056 0.00291547594742265 0.00291547594742265
	+82.3 0.0 0.0 0.0546 0.0038078865529319545 0.0038078865529319545
	+85.1 0.0 0.0 0.0544 0.008668333173107735 0.008668333173107735
	+130.1 0.0 0.0 0.0452 0.0019313207915827965 0.0019313207915827965
	+136.1 0.0 0.0 0.0467 0.0022561028345356956 0.0022561028345356956
	+161.3 0.0 0.0 0.0421 0.002596150997149434 0.002596150997149434
	+172.3 0.0 0.0 0.044 0.0029120439557122073 0.0029120439557122073
	+182.8 0.0 0.0 0.0424 0.0014560219778561037 0.0014560219778561037
	+188.6 0.0 0.0 0.0442 0.0012727922061357855 0.0012727922061357855
	+194.4 0.0 0.0 0.0439 0.001979898987322333 0.001979898987322333
	+200.2 0.0 0.0 0.0464 0.002051828452868319 0.002051828452868319
	+206.2 0.0 0.0 0.0455 0.0015556349186104045 0.0015556349186104045
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d54-x01-y02
	+Path=/REF/L3_2004_I652683/d54-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+41.4 0.0 0.0 0.008 7.810249675906653E-4 7.810249675906653E-4
	+55.3 0.0 0.0 0.0063 9.433981132056604E-4 9.433981132056604E-4
	+65.4 0.0 0.0 0.006 0.001140175425099138 0.001140175425099138
	+75.7 0.0 0.0 0.0053 7.280109889280518E-4 7.280109889280518E-4
	+82.3 0.0 0.0 0.0052 7.615773105863909E-4 7.615773105863909E-4
	+85.1 0.0 0.0 0.0054 0.0014560219778561037 0.0014560219778561037
	+130.1 0.0 0.0 0.0041 3.162277660168379E-4 3.162277660168379E-4
	+136.1 0.0 0.0 0.0045 4.123105625617661E-4 4.123105625617661E-4
	+161.3 0.0 0.0 0.004 4.123105625617661E-4 4.123105625617661E-4
	+172.3 0.0 0.0 0.004 5.8309518948453E-4 5.8309518948453E-4
	+182.8 0.0 0.0 0.004 3.605551275463989E-4 3.605551275463989E-4
	+188.6 0.0 0.0 0.0043 2.82842712474619E-4 2.82842712474619E-4
	+194.4 0.0 0.0 0.0042 3.605551275463989E-4 3.605551275463989E-4
	+200.2 0.0 0.0 0.0048 4.242640687119285E-4 4.242640687119285E-4
	+206.2 0.0 0.0 0.0046 3.605551275463989E-4 3.605551275463989E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d55-x01-y01
	+Path=/REF/L3_2004_I652683/d55-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+41.4 0.0 0.0 0.1399 0.003138470965295043 0.003138470965295043
	+55.3 0.0 0.0 0.1223 0.005950630218724736 0.005950630218724736
	+65.4 0.0 0.0 0.1213 0.00812526922630875 0.00812526922630875
	+75.7 0.0 0.0 0.1157 0.0050289163842720625 0.0050289163842720625
	+82.3 0.0 0.0 0.1116 0.005948108943185221 0.005948108943185221
	+85.1 0.0 0.0 0.1102 0.008852683209061532 0.008852683209061532
	+130.1 0.0 0.0 0.0976 0.002435159132377184 0.002435159132377184
	+136.1 0.0 0.0 0.0999 0.003138470965295043 0.003138470965295043
	+161.3 0.0 0.0 0.0923 0.003671511950137164 0.003671511950137164
	+172.3 0.0 0.0 0.095 0.005547071299343465 0.005547071299343465
	+182.8 0.0 0.0 0.0918 0.0025 0.0025
	+188.6 0.0 0.0 0.0918 0.002220360331117452 0.002220360331117452
	+194.4 0.0 0.0 0.092 0.003560898762952971 0.003560898762952971
	+200.2 0.0 0.0 0.095 0.0032649655434629013 0.0032649655434629013
	+206.2 0.0 0.0 0.0938 0.0022671568097509267 0.0022671568097509267
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d55-x01-y02
	+Path=/REF/L3_2004_I652683/d55-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+41.4 0.0 0.0 0.0236 0.0010295630140987001 0.0010295630140987001
	+55.3 0.0 0.0 0.0187 0.0014422205101855955 0.0014422205101855955
	+65.4 0.0 0.0 0.0187 0.002280350850198276 0.002280350850198276
	+75.7 0.0 0.0 0.0172 0.0014866068747318507 0.0014866068747318507
	+82.3 0.0 0.0 0.016 0.0016155494421403512 0.0016155494421403512
	+85.1 0.0 0.0 0.0158 0.002308679276123039 0.002308679276123039
	+130.1 0.0 0.0 0.0131 6.324555320336758E-4 6.324555320336758E-4
	+136.1 0.0 0.0 0.0141 8.944271909999159E-4 8.944271909999159E-4
	+161.3 0.0 0.0 0.0121 8.944271909999159E-4 8.944271909999159E-4
	+172.3 0.0 0.0 0.0136 0.0015231546211727817 0.0015231546211727817
	+182.8 0.0 0.0 0.0121 6.708203932499369E-4 6.708203932499369E-4
	+188.6 0.0 0.0 0.0121 6.403124237432849E-4 6.403124237432849E-4
	+194.4 0.0 0.0 0.0122 0.00116619037896906 0.00116619037896906
	+200.2 0.0 0.0 0.0131 9.219544457292887E-4 9.219544457292887E-4
	+206.2 0.0 0.0 0.0128 7.071067811865475E-4 7.071067811865475E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d56-x01-y01
	+Path=/REF/L3_2004_I652683/d56-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+41.4 0.0 0.0 0.0896 0.002765863337187866 0.002765863337187866
	+55.3 0.0 0.0 0.08 0.003944616584663204 0.003944616584663204
	+65.4 0.0 0.0 0.0806 0.006161168720299745 0.006161168720299745
	+75.7 0.0 0.0 0.0758 0.004729693436154187 0.004729693436154187
	+82.3 0.0 0.0 0.0756 0.005288667128870941 0.005288667128870941
	+85.1 0.0 0.0 0.0749 0.009355746896961246 0.009355746896961246
	+130.1 0.0 0.0 0.0681 0.0019924858845171275 0.0019924858845171275
	+136.1 0.0 0.0 0.0699 0.0025 0.0025
	+161.3 0.0 0.0 0.0666 0.002879236009777594 0.002879236009777594
	+172.3 0.0 0.0 0.0664 0.0038600518131237565 0.0038600518131237565
	+182.8 0.0 0.0 0.0654 0.0018027756377319948 0.0018027756377319948
	+188.6 0.0 0.0 0.0669 0.001345362404707371 0.001345362404707371
	+194.4 0.0 0.0 0.0663 0.0021260291625469297 0.0021260291625469297
	+200.2 0.0 0.0 0.0688 0.00206155281280883 0.00206155281280883
	+206.2 0.0 0.0 0.0682 0.0014212670403551896 0.0014212670403551896
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d56-x01-y02
	+Path=/REF/L3_2004_I652683/d56-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+41.4 0.0 0.0 0.0104 7.071067811865475E-4 7.071067811865475E-4
	+55.3 0.0 0.0 0.0086 7.810249675906653E-4 7.810249675906653E-4
	+65.4 0.0 0.0 0.0088 0.0013341664064126333 0.0013341664064126333
	+75.7 0.0 0.0 0.0081 8.544003745317531E-4 8.544003745317531E-4
	+82.3 0.0 0.0 0.0081 8.544003745317531E-4 8.544003745317531E-4
	+85.1 0.0 0.0 0.0082 0.0018439088914585775 0.0018439088914585775
	+130.1 0.0 0.0 0.0069 4.123105625617661E-4 4.123105625617661E-4
	+136.1 0.0 0.0 0.0076 5.385164807134503E-4 5.385164807134503E-4
	+161.3 0.0 0.0 0.007 5.385164807134503E-4 5.385164807134503E-4
	+172.3 0.0 0.0 0.0068 7.810249675906653E-4 7.810249675906653E-4
	+182.8 0.0 0.0 0.0067 3.605551275463989E-4 3.605551275463989E-4
	+188.6 0.0 0.0 0.0071 2.82842712474619E-4 2.82842712474619E-4
	+194.4 0.0 0.0 0.0069 4.242640687119285E-4 4.242640687119285E-4
	+200.2 0.0 0.0 0.0075 4.242640687119285E-4 4.242640687119285E-4
	+206.2 0.0 0.0 0.0074 3.162277660168379E-4 3.162277660168379E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d57-x01-y01
	+Path=/REF/L3_2004_I652683/d57-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+130.1 0.0 0.0 0.2277 0.008940357934669059 0.008940357934669059
	+136.1 0.0 0.0 0.2357 0.009716995420396163 0.009716995420396163
	+161.3 0.0 0.0 0.2052 0.010192153844992726 0.010192153844992726
	+172.3 0.0 0.0 0.2281 0.01623884232326923 0.01623884232326923
	+182.8 0.0 0.0 0.2157 0.009642613753542138 0.009642613753542138
	+188.6 0.0 0.0 0.216 0.005728001396647875 0.005728001396647875
	+194.4 0.0 0.0 0.2158 0.00698927750200262 0.00698927750200262
	+200.2 0.0 0.0 0.2244 0.00900277734924062 0.00900277734924062
	+206.2 0.0 0.0 0.2195 0.006021627686929839 0.006021627686929839
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d57-x01-y02
	+Path=/REF/L3_2004_I652683/d57-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+130.1 0.0 0.0 0.0848 0.0056824290580701495 0.0056824290580701495
	+136.1 0.0 0.0 0.0938 0.006648308055437865 0.006648308055437865
	+161.3 0.0 0.0 0.0757 0.006676076692189808 0.006676076692189808
	+172.3 0.0 0.0 0.0979 0.013612494260788506 0.013612494260788506
	+182.8 0.0 0.0 0.0804 0.006020797289396148 0.006020797289396148
	+188.6 0.0 0.0 0.0795 0.004967896939349689 0.004967896939349689
	+194.4 0.0 0.0 0.0778 0.0051478150704935 0.0051478150704935
	+200.2 0.0 0.0 0.0864 0.006859300255857006 0.006859300255857006
	+206.2 0.0 0.0 0.0828 0.005185556864985669 0.005185556864985669
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d58-x01-y01
	+Path=/REF/L3_2004_I652683/d58-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+130.1 0.0 0.0 0.0404 0.0025 0.0025
	+136.1 0.0 0.0 0.0566 0.005470831746635972 0.005470831746635972
	+161.3 0.0 0.0 0.039 0.0039051248379533272 0.0039051248379533272
	+172.3 0.0 0.0 0.0752 0.01406627171641441 0.01406627171641441
	+182.8 0.0 0.0 0.0457 0.00696419413859206 0.00696419413859206
	+188.6 0.0 0.0 0.0415 0.0034409301068170505 0.0034409301068170505
	+194.4 0.0 0.0 0.0387 0.005232590180780452 0.005232590180780452
	+200.2 0.0 0.0 0.0435 0.004640043103248072 0.004640043103248072
	+206.2 0.0 0.0 0.0429 0.004393176527297759 0.004393176527297759
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d58-x01-y02
	+Path=/REF/L3_2004_I652683/d58-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+130.1 0.0 0.0 0.0051 0.0016031219541881396 0.0016031219541881396
	+136.1 0.0 0.0 0.0138 0.0025709920264364882 0.0025709920264364882
	+161.3 0.0 0.0 0.0066 0.001711724276862369 0.001711724276862369
	+172.3 0.0 0.0 0.0277 0.0073348483283568995 0.0073348483283568995
	+182.8 0.0 0.0 0.0089 0.003935733730830886 0.003935733730830886
	+188.6 0.0 0.0 0.0067 0.0019235384061671345 0.0019235384061671345
	+194.4 0.0 0.0 0.0056 0.0018867962264113207 0.0018867962264113207
	+200.2 0.0 0.0 0.0064 0.002325940669922601 0.002325940669922601
	+206.2 0.0 0.0 0.0064 0.00233238075793812 0.00233238075793812
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d59-x01-y01
	+Path=/REF/L3_2004_I652683/d59-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.0 1.0 1.0 1.8E-5 9.486832980505138E-6 9.486832980505138E-6
	+4.0 1.0 1.0 2.68E-4 5.1971145840745135E-5 5.1971145840745135E-5
	+6.0 1.0 1.0 0.002054 1.0770329614269008E-4 1.0770329614269008E-4
	+8.0 1.0 1.0 0.009328 3.7335371968148383E-4 3.7335371968148383E-4
	+10.0 1.0 1.0 0.027621 7.626853872993765E-4 7.626853872993765E-4
	+12.0 1.0 1.0 0.058426 0.0011250444435665643 0.0011250444435665643
	+14.0 1.0 1.0 0.093836 0.0012747933165811625 0.0012747933165811625
	+16.0 1.0 1.0 0.121719 0.0012860995295854826 0.0012860995295854826
	+18.0 1.0 1.0 0.133779 9.923245436851795E-4 9.923245436851795E-4
	+20.0 1.0 1.0 0.129539 8.97024525863145E-4 8.97024525863145E-4
	+22.0 1.0 1.0 0.113598 4.443703410444941E-4 4.443703410444941E-4
	+24.0 1.0 1.0 0.092586 6.537315962992763E-4 6.537315962992763E-4
	+26.0 1.0 1.0 0.070832 8.136590194915804E-4 8.136590194915804E-4
	+28.0 1.0 1.0 0.051225 0.0010039347588364494 0.0010039347588364494
	+30.0 1.0 1.0 0.03549 9.127502396603356E-4 9.127502396603356E-4
	+32.0 1.0 1.0 0.023541 8.255059054906876E-4 8.255059054906876E-4
	+34.0 1.0 1.0 0.014928 6.369277824055094E-4 6.369277824055094E-4
	+36.0 1.0 1.0 0.00919 4.633896848226123E-4 4.633896848226123E-4
	+38.0 1.0 1.0 0.005395 3.081103698352264E-4 3.081103698352264E-4
	+40.0 1.0 1.0 0.003119 2.2264321233758734E-4 2.2264321233758734E-4
	+42.0 1.0 1.0 0.001735 1.4736349615830917E-4 1.4736349615830917E-4
	+44.0 1.0 1.0 9.03E-4 9.108238029388561E-5 9.108238029388561E-5
	+46.0 1.0 1.0 4.52E-4 5.6885850613311566E-5 5.6885850613311566E-5
	+48.0 1.0 1.0 2.28E-4 3.569313659514949E-5 3.569313659514949E-5
	+50.0 1.0 1.0 1.02E-4 1.8439088914585775E-5 1.8439088914585775E-5
	+52.0 1.0 1.0 5.1E-5 1.3341664064126333E-5 1.3341664064126333E-5
	+54.0 1.0 1.0 2.3E-5 1.0440306508910551E-5 1.0440306508910551E-5
	+56.0 1.0 1.0 1.3E-5 7.6157731058639085E-6 7.6157731058639085E-6
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d59-x01-y02
	+Path=/REF/L3_2004_I652683/d59-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.0 1.0 1.0 2.1E-5 4.472135954999579E-6 4.472135954999579E-6
	+4.0 1.0 1.0 3.31E-4 3.0413812651491098E-5 3.0413812651491098E-5
	+6.0 1.0 1.0 0.002582 1.9632880583347927E-4 1.9632880583347927E-4
	+8.0 1.0 1.0 0.011335 7.302013420968219E-4 7.302013420968219E-4
	+10.0 1.0 1.0 0.032821 0.0017721907346558384 0.0017721907346558384
	+12.0 1.0 1.0 0.066995 0.0029138033564398264 0.0029138033564398264
	+14.0 1.0 1.0 0.104305 0.0034035117158605463 0.0034035117158605463
	+16.0 1.0 1.0 0.130215 0.0028060352813177526 0.0028060352813177526
	+18.0 1.0 1.0 0.137874 0.0016210545950090637 0.0016210545950090637
	+20.0 1.0 1.0 0.128385 9.344356585661743E-4 9.344356585661743E-4
	+22.0 1.0 1.0 0.109303 0.0016625501496195536 0.0016625501496195536
	+24.0 1.0 1.0 0.086274 0.0019993261364769878 0.0019993261364769878
	+26.0 1.0 1.0 0.064172 0.002130429299460557 0.002130429299460557
	+28.0 1.0 1.0 0.045495 0.0019993621482862975 0.0019993621482862975
	+30.0 1.0 1.0 0.03075 0.001795372941758898 0.001795372941758898
	+32.0 1.0 1.0 0.019974 0.0014327669035820167 0.0014327669035820167
	+34.0 1.0 1.0 0.012434 0.0011301698987320448 0.0011301698987320448
	+36.0 1.0 1.0 0.00741 8.098024450444688E-4 8.098024450444688E-4
	+38.0 1.0 1.0 0.004343 5.525233026760048E-4 5.525233026760048E-4
	+40.0 1.0 1.0 0.002433 3.5635095060908707E-4 3.5635095060908707E-4
	+42.0 1.0 1.0 0.001284 2.379285607067802E-4 2.379285607067802E-4
	+44.0 1.0 1.0 6.51E-4 1.4268847185389575E-4 1.4268847185389575E-4
	+46.0 1.0 1.0 3.3E-4 8.670063436907483E-5 8.670063436907483E-5
	+48.0 1.0 1.0 1.49E-4 5.544366510251645E-5 5.544366510251645E-5
	+50.0 1.0 1.0 7.2E-5 3.157530680769389E-5 3.157530680769389E-5
	+52.0 1.0 1.0 3.3E-5 1.8681541692269405E-5 1.8681541692269405E-5
	+54.0 1.0 1.0 1.4E-5 2.3194827009486404E-5 2.3194827009486404E-5
	+56.0 1.0 1.0 1.1E-5 1.2649110640673518E-5 1.2649110640673518E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d59-x01-y03
	+Path=/REF/L3_2004_I652683/d59-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+
	+4.0 1.0 1.0 9.0E-6 3.0413812651491098E-5 3.0413812651491098E-5
	+6.0 1.0 1.0 2.27E-4 8.854377448471462E-5 8.854377448471462E-5
	+8.0 1.0 1.0 0.001944 4.658207809877099E-4 4.658207809877099E-4
	+10.0 1.0 1.0 0.008961 0.001324411189925546 0.001324411189925546
	+12.0 1.0 1.0 0.026978 0.00253380050517005 0.00253380050517005
	+14.0 1.0 1.0 0.057434 0.0033321183952554866 0.0033321183952554866
	+16.0 1.0 1.0 0.09283 0.0030801798648780235 0.0030801798648780235
	+18.0 1.0 1.0 0.121985 0.002098176589327028 0.002098176589327028
	+20.0 1.0 1.0 0.135052 0.0016305097362481465 0.0016305097362481465
	+22.0 1.0 1.0 0.130966 0.0018294526503848084 0.0018294526503848084
	+24.0 1.0 1.0 0.115071 0.0021937752847545713 0.0021937752847545713
	+26.0 1.0 1.0 0.093411 0.0021642321964151627 0.0021642321964151627
	+28.0 1.0 1.0 0.071269 0.002000838324303091 0.002000838324303091
	+30.0 1.0 1.0 0.051408 0.0016960212262822657 0.0016960212262822657
	+32.0 1.0 1.0 0.03516 0.0013864548315758434 0.0013864548315758434
	+34.0 1.0 1.0 0.023016 0.0010532426121269496 0.0010532426121269496
	+36.0 1.0 1.0 0.014572 7.557942841805566E-4 7.557942841805566E-4
	+38.0 1.0 1.0 0.008841 5.229732306724696E-4 5.229732306724696E-4
	+40.0 1.0 1.0 0.005114 3.747599231508086E-4 3.747599231508086E-4
	+42.0 1.0 1.0 0.002853 2.2989562849258356E-4 2.2989562849258356E-4
	+44.0 1.0 1.0 0.001503 1.3328165665236908E-4 1.3328165665236908E-4
	+46.0 1.0 1.0 7.41E-4 8.856635930193812E-5 8.856635930193812E-5
	+48.0 1.0 1.0 3.78E-4 6.539113089708726E-5 6.539113089708726E-5
	+50.0 1.0 1.0 1.65E-4 3.939543120718442E-5 3.939543120718442E-5
	+52.0 1.0 1.0 6.6E-5 2.1540659228538017E-5 2.1540659228538017E-5
	+54.0 1.0 1.0 3.3E-5 1.4866068747318506E-5 1.4866068747318506E-5
	+56.0 1.0 1.0 1.0E-5 5.830951894845301E-6 5.830951894845301E-6
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d60-x01-y01
	+Path=/REF/L3_2004_I652683/d60-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+10.0 0.0 0.0 0.009 0.00282842712474619 0.00282842712474619
	+12.0 0.0 0.0 0.026 0.00565685424949238 0.00565685424949238
	+14.0 0.0 0.0 0.054 0.00806225774829855 0.00806225774829855
	+16.0 0.0 0.0 0.085 0.009486832980505138 0.009486832980505138
	+18.0 0.0 0.0 0.109 0.012649110640673518 0.012649110640673518
	+20.0 0.0 0.0 0.12 0.013152946437965905 0.013152946437965905
	+22.0 0.0 0.0 0.116 0.013038404810405297 0.013038404810405297
	+24.0 0.0 0.0 0.107 0.013152946437965905 0.013152946437965905
	+26.0 0.0 0.0 0.098 0.013341664064126334 0.013341664064126334
	+28.0 0.0 0.0 0.079 0.013152946437965905 0.013152946437965905
	+30.0 0.0 0.0 0.063 0.013601470508735444 0.013601470508735444
	+32.0 0.0 0.0 0.043 0.01004987562112089 0.01004987562112089
	+34.0 0.0 0.0 0.033 0.0031622776601683794 0.0031622776601683794
	+36.0 0.0 0.0 0.019 0.008544003745317531 0.008544003745317531
	+38.0 0.0 0.0 0.016 0.0022360679774997894 0.0022360679774997894
	+40.0 0.0 0.0 0.009 0.001414213562373095 0.001414213562373095
	+42.0 0.0 0.0 0.006 0.001414213562373095 0.001414213562373095
	+44.0 0.0 0.0 0.003 0.001414213562373095 0.001414213562373095
	+46.0 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+48.0 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+50.0 0.0 0.0 0.0 0.0 0.0
	+52.0 0.0 0.0 0.0 0.001 0.001
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d60-x01-y02
	+Path=/REF/L3_2004_I652683/d60-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+10.0 0.0 0.0 0.011 0.00282842712474619 0.00282842712474619
	+12.0 0.0 0.0 0.032 0.006403124237432849 0.006403124237432849
	+14.0 0.0 0.0 0.056 0.00806225774829855 0.00806225774829855
	+16.0 0.0 0.0 0.086 0.01004987562112089 0.01004987562112089
	+18.0 0.0 0.0 0.099 0.013038404810405297 0.013038404810405297
	+20.0 0.0 0.0 0.099 0.0161245154965971 0.0161245154965971
	+22.0 0.0 0.0 0.096 0.01811077027627483 0.01811077027627483
	+24.0 0.0 0.0 0.094 0.01414213562373095 0.01414213562373095
	+26.0 0.0 0.0 0.09 0.015132745950421555 0.015132745950421555
	+28.0 0.0 0.0 0.081 0.015132745950421555 0.015132745950421555
	+30.0 0.0 0.0 0.071 0.012649110640673518 0.012649110640673518
	+32.0 0.0 0.0 0.05 0.01019803902718557 0.01019803902718557
	+34.0 0.0 0.0 0.041 0.009219544457292887 0.009219544457292887
	+36.0 0.0 0.0 0.034 0.005099019513592785 0.005099019513592785
	+38.0 0.0 0.0 0.024 0.0022360679774997894 0.0022360679774997894
	+40.0 0.0 0.0 0.01 0.001414213562373095 0.001414213562373095
	+42.0 0.0 0.0 0.007 0.0022360679774997894 0.0022360679774997894
	+44.0 0.0 0.0 0.005 0.001414213562373095 0.001414213562373095
	+46.0 0.0 0.0 0.005 0.001414213562373095 0.001414213562373095
	+48.0 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+50.0 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+52.0 0.0 0.0 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d60-x01-y03
	+Path=/REF/L3_2004_I652683/d60-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+10.0 0.0 0.0 0.006 0.0022360679774997894 0.0022360679774997894
	+12.0 0.0 0.0 0.018 0.0031622776601683794 0.0031622776601683794
	+14.0 0.0 0.0 0.038 0.00670820393249937 0.00670820393249937
	+16.0 0.0 0.0 0.061 0.00824621125123532 0.00824621125123532
	+18.0 0.0 0.0 0.076 0.013000000000000001 0.013000000000000001
	+20.0 0.0 0.0 0.093 0.01392838827718412 0.01392838827718412
	+22.0 0.0 0.0 0.107 0.01414213562373095 0.01414213562373095
	+24.0 0.0 0.0 0.112 0.01676305461424021 0.01676305461424021
	+26.0 0.0 0.0 0.108 0.014866068747318507 0.014866068747318507
	+28.0 0.0 0.0 0.096 0.015132745950421555 0.015132745950421555
	+30.0 0.0 0.0 0.076 0.015033296378372907 0.015033296378372907
	+32.0 0.0 0.0 0.058 0.013038404810405297 0.013038404810405297
	+34.0 0.0 0.0 0.044 0.013038404810405297 0.013038404810405297
	+36.0 0.0 0.0 0.033 0.01104536101718726 0.01104536101718726
	+38.0 0.0 0.0 0.024 0.01104536101718726 0.01104536101718726
	+40.0 0.0 0.0 0.017 0.011180339887498947 0.011180339887498947
	+42.0 0.0 0.0 0.011 0.001 0.001
	+44.0 0.0 0.0 0.007 0.001 0.001
	+46.0 0.0 0.0 0.006 0.00608276253029822 0.00608276253029822
	+48.0 0.0 0.0 0.003 0.0031622776601683794 0.0031622776601683794
	+50.0 0.0 0.0 0.002 0.006 0.006
	+52.0 0.0 0.0 0.001 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d61-x01-y01
	+Path=/REF/L3_2004_I652683/d61-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+10.0 0.0 0.0 0.005 0.001414213562373095 0.001414213562373095
	+12.0 0.0 0.0 0.013 0.001 0.001
	+14.0 0.0 0.0 0.028 0.00608276253029822 0.00608276253029822
	+16.0 0.0 0.0 0.048 0.00824621125123532 0.00824621125123532
	+18.0 0.0 0.0 0.072 0.01004987562112089 0.01004987562112089
	+20.0 0.0 0.0 0.091 0.012649110640673518 0.012649110640673518
	+22.0 0.0 0.0 0.1 0.013341664064126334 0.013341664064126334
	+24.0 0.0 0.0 0.097 0.01414213562373095 0.01414213562373095
	+26.0 0.0 0.0 0.091 0.0140356688476182 0.0140356688476182
	+28.0 0.0 0.0 0.088 0.013038404810405297 0.013038404810405297
	+30.0 0.0 0.0 0.079 0.016031219541881397 0.016031219541881397
	+32.0 0.0 0.0 0.064 0.017029386365926404 0.017029386365926404
	+34.0 0.0 0.0 0.055 0.01414213562373095 0.01414213562373095
	+36.0 0.0 0.0 0.041 0.01216552506059644 0.01216552506059644
	+38.0 0.0 0.0 0.034 0.01216552506059644 0.01216552506059644
	+40.0 0.0 0.0 0.026 0.0022360679774997894 0.0022360679774997894
	+42.0 0.0 0.0 0.018 0.018027756377319945 0.018027756377319945
	+44.0 0.0 0.0 0.019 0.019026297590440448 0.019026297590440448
	+46.0 0.0 0.0 0.016 0.011180339887498949 0.011180339887498949
	+48.0 0.0 0.0 0.007 0.001414213562373095 0.001414213562373095
	+50.0 0.0 0.0 0.005 0.0022360679774997894 0.0022360679774997894
	+52.0 0.0 0.0 0.004 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d61-x01-y02
	+Path=/REF/L3_2004_I652683/d61-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+10.0 0.0 0.0 0.004 0.001414213562373095 0.001414213562373095
	+12.0 0.0 0.0 0.013 0.0022360679774997894 0.0022360679774997894
	+14.0 0.0 0.0 0.029 0.0022360679774997894 0.0022360679774997894
	+16.0 0.0 0.0 0.051 0.005 0.005
	+18.0 0.0 0.0 0.075 0.005385164807134504 0.005385164807134504
	+20.0 0.0 0.0 0.089 0.00608276253029822 0.00608276253029822
	+22.0 0.0 0.0 0.097 0.007280109889280519 0.007280109889280519
	+24.0 0.0 0.0 0.097 0.007615773105863909 0.007615773105863909
	+26.0 0.0 0.0 0.094 0.00806225774829855 0.00806225774829855
	+28.0 0.0 0.0 0.085 0.007615773105863909 0.007615773105863909
	+30.0 0.0 0.0 0.077 0.007280109889280519 0.007280109889280519
	+32.0 0.0 0.0 0.065 0.007280109889280519 0.007280109889280519
	+34.0 0.0 0.0 0.056 0.007280109889280519 0.007280109889280519
	+36.0 0.0 0.0 0.047 0.006324555320336759 0.006324555320336759
	+38.0 0.0 0.0 0.034 0.006324555320336759 0.006324555320336759
	+40.0 0.0 0.0 0.025 0.007071067811865475 0.007071067811865475
	+42.0 0.0 0.0 0.02 0.006324555320336759 0.006324555320336759
	+44.0 0.0 0.0 0.013 0.005099019513592785 0.005099019513592785
	+46.0 0.0 0.0 0.008 0.0031622776601683794 0.0031622776601683794
	+48.0 0.0 0.0 0.007 0.0022360679774997894 0.0022360679774997894
	+50.0 0.0 0.0 0.005 0.00412310562561766 0.00412310562561766
	+52.0 0.0 0.0 0.003 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d61-x01-y03
	+Path=/REF/L3_2004_I652683/d61-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+10.0 0.0 0.0 0.004 0.001414213562373095 0.001414213562373095
	+12.0 0.0 0.0 0.013 0.001414213562373095 0.001414213562373095
	+14.0 0.0 0.0 0.028 0.00282842712474619 0.00282842712474619
	+16.0 0.0 0.0 0.048 0.0036055512754639895 0.0036055512754639895
	+18.0 0.0 0.0 0.072 0.0036055512754639895 0.0036055512754639895
	+20.0 0.0 0.0 0.087 0.0031622776601683794 0.0031622776601683794
	+22.0 0.0 0.0 0.097 0.00412310562561766 0.00412310562561766
	+24.0 0.0 0.0 0.101 0.00412310562561766 0.00412310562561766
	+26.0 0.0 0.0 0.097 0.005385164807134504 0.005385164807134504
	+28.0 0.0 0.0 0.088 0.00412310562561766 0.00412310562561766
	+30.0 0.0 0.0 0.079 0.004472135954999579 0.004472135954999579
	+32.0 0.0 0.0 0.069 0.004472135954999579 0.004472135954999579
	+34.0 0.0 0.0 0.057 0.005385164807134504 0.005385164807134504
	+36.0 0.0 0.0 0.045 0.005385164807134504 0.005385164807134504
	+38.0 0.0 0.0 0.034 0.005385164807134504 0.005385164807134504
	+40.0 0.0 0.0 0.026 0.005385164807134504 0.005385164807134504
	+42.0 0.0 0.0 0.018 0.00412310562561766 0.00412310562561766
	+44.0 0.0 0.0 0.013 0.00412310562561766 0.00412310562561766
	+46.0 0.0 0.0 0.009 0.00412310562561766 0.00412310562561766
	+48.0 0.0 0.0 0.005 0.001 0.001
	+50.0 0.0 0.0 0.004 0.00412310562561766 0.00412310562561766
	+52.0 0.0 0.0 0.002 0.0022360679774997894 0.0022360679774997894
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d62-x01-y01
	+Path=/REF/L3_2004_I652683/d62-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+10.0 0.0 0.0 0.004 0.001414213562373095 0.001414213562373095
	+12.0 0.0 0.0 0.013 0.0022360679774997894 0.0022360679774997894
	+14.0 0.0 0.0 0.028 0.0036055512754639895 0.0036055512754639895
	+16.0 0.0 0.0 0.048 0.005 0.005
	+18.0 0.0 0.0 0.069 0.00565685424949238 0.00565685424949238
	+20.0 0.0 0.0 0.086 0.005 0.005
	+22.0 0.0 0.0 0.096 0.005385164807134504 0.005385164807134504
	+24.0 0.0 0.0 0.098 0.006324555320336759 0.006324555320336759
	+26.0 0.0 0.0 0.095 0.006324555320336759 0.006324555320336759
	+28.0 0.0 0.0 0.087 0.006324555320336759 0.006324555320336759
	+30.0 0.0 0.0 0.076 0.007071067811865475 0.007071067811865475
	+32.0 0.0 0.0 0.066 0.007280109889280519 0.007280109889280519
	+34.0 0.0 0.0 0.056 0.006324555320336759 0.006324555320336759
	+36.0 0.0 0.0 0.045 0.00608276253029822 0.00608276253029822
	+38.0 0.0 0.0 0.037 0.006324555320336759 0.006324555320336759
	+40.0 0.0 0.0 0.022 0.0031622776601683794 0.0031622776601683794
	+42.0 0.0 0.0 0.021 0.006324555320336759 0.006324555320336759
	+44.0 0.0 0.0 0.018 0.00565685424949238 0.00565685424949238
	+46.0 0.0 0.0 0.012 0.00806225774829855 0.00806225774829855
	+48.0 0.0 0.0 0.012 0.00412310562561766 0.00412310562561766
	+50.0 0.0 0.0 0.006 0.001414213562373095 0.001414213562373095
	+52.0 0.0 0.0 0.002 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d62-x01-y02
	+Path=/REF/L3_2004_I652683/d62-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+10.0 0.0 0.0 0.003 0.001414213562373095 0.001414213562373095
	+12.0 0.0 0.0 0.011 0.001414213562373095 0.001414213562373095
	+14.0 0.0 0.0 0.024 0.00282842712474619 0.00282842712474619
	+16.0 0.0 0.0 0.045 0.0036055512754639895 0.0036055512754639895
	+18.0 0.0 0.0 0.066 0.004472135954999579 0.004472135954999579
	+20.0 0.0 0.0 0.083 0.004472135954999579 0.004472135954999579
	+22.0 0.0 0.0 0.095 0.005385164807134504 0.005385164807134504
	+24.0 0.0 0.0 0.098 0.00670820393249937 0.00670820393249937
	+26.0 0.0 0.0 0.097 0.00670820393249937 0.00670820393249937
	+28.0 0.0 0.0 0.089 0.006324555320336759 0.006324555320336759
	+30.0 0.0 0.0 0.076 0.006324555320336759 0.006324555320336759
	+32.0 0.0 0.0 0.065 0.006324555320336759 0.006324555320336759
	+34.0 0.0 0.0 0.054 0.006324555320336759 0.006324555320336759
	+36.0 0.0 0.0 0.045 0.006324555320336759 0.006324555320336759
	+38.0 0.0 0.0 0.035 0.007280109889280519 0.007280109889280519
	+40.0 0.0 0.0 0.028 0.006324555320336759 0.006324555320336759
	+42.0 0.0 0.0 0.023 0.005099019513592785 0.005099019513592785
	+44.0 0.0 0.0 0.019 0.007280109889280519 0.007280109889280519
	+46.0 0.0 0.0 0.014 0.005099019513592785 0.005099019513592785
	+48.0 0.0 0.0 0.015 0.0036055512754639895 0.0036055512754639895
	+50.0 0.0 0.0 0.006 0.0031622776601683794 0.0031622776601683794
	+52.0 0.0 0.0 0.003 0.00282842712474619 0.00282842712474619
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d62-x01-y03
	+Path=/REF/L3_2004_I652683/d62-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+10.0 0.0 0.0 0.003 0.001414213562373095 0.001414213562373095
	+12.0 0.0 0.0 0.01 0.001414213562373095 0.001414213562373095
	+14.0 0.0 0.0 0.022 0.0022360679774997894 0.0022360679774997894
	+16.0 0.0 0.0 0.04 0.0036055512754639895 0.0036055512754639895
	+18.0 0.0 0.0 0.062 0.0036055512754639895 0.0036055512754639895
	+20.0 0.0 0.0 0.083 0.0031622776601683794 0.0031622776601683794
	+22.0 0.0 0.0 0.093 0.00412310562561766 0.00412310562561766
	+24.0 0.0 0.0 0.097 0.00412310562561766 0.00412310562561766
	+26.0 0.0 0.0 0.094 0.004472135954999579 0.004472135954999579
	+28.0 0.0 0.0 0.088 0.005385164807134504 0.005385164807134504
	+30.0 0.0 0.0 0.077 0.005099019513592785 0.005099019513592785
	+32.0 0.0 0.0 0.068 0.005385164807134504 0.005385164807134504
	+34.0 0.0 0.0 0.058 0.005099019513592785 0.005099019513592785
	+36.0 0.0 0.0 0.047 0.005385164807134504 0.005385164807134504
	+38.0 0.0 0.0 0.038 0.005385164807134504 0.005385164807134504
	+40.0 0.0 0.0 0.031 0.005385164807134504 0.005385164807134504
	+42.0 0.0 0.0 0.024 0.005385164807134504 0.005385164807134504
	+44.0 0.0 0.0 0.018 0.00412310562561766 0.00412310562561766
	+46.0 0.0 0.0 0.014 0.00412310562561766 0.00412310562561766
	+48.0 0.0 0.0 0.012 0.0031622776601683794 0.0031622776601683794
	+50.0 0.0 0.0 0.008 0.005099019513592785 0.005099019513592785
	+52.0 0.0 0.0 0.006 0.0031622776601683794 0.0031622776601683794
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d63-x01-y01
	+Path=/REF/L3_2004_I652683/d63-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+ 0.0 0.0 20.46 0.11045361017187261 0.11045361017187261
	+ 0.0 0.0 19.88 0.21023796041628637 0.21023796041628637
	+ 0.0 0.0 22.45 0.19235384061671346 0.19235384061671346
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d63-x01-y02
	+Path=/REF/L3_2004_I652683/d63-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+ 0.0 0.0 457.7 4.909175083453431 4.909175083453431
	+ 0.0 0.0 432.4 9.20869154657707 9.20869154657707
	+ 0.0 0.0 542.0 3.2310988842807022 3.2310988842807022
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d64-x01-y01
	+Path=/REF/L3_2004_I652683/d64-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+130.1 0.0 0.0 23.28 0.26 0.26
	+136.1 0.0 0.0 24.13 0.2879236009777594 0.2879236009777594
	+161.3 0.0 0.0 25.4 0.38275318418009274 0.38275318418009274
	+172.3 0.0 0.0 27.0 0.5909314681077663 0.5909314681077663
	+182.8 0.0 0.0 26.84 0.34058772731852804 0.34058772731852804
	+188.6 0.0 0.0 26.84 0.32015621187164245 0.32015621187164245
	+194.4 0.0 0.0 27.14 0.4244997055358225 0.4244997055358225
	+200.2 0.0 0.0 27.73 0.47434164902525694 0.47434164902525694
	+206.2 0.0 0.0 28.09 0.33241540277189324 0.33241540277189324
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d64-x01-y02
	+Path=/REF/L3_2004_I652683/d64-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+130.1 0.0 0.0 587.5 12.3664869708418 12.3664869708418
	+136.1 0.0 0.0 643.3 15.216109883935513 15.216109883935513
	+161.3 0.0 0.0 700.3 23.166354913969528 23.166354913969528
	+172.3 0.0 0.0 798.4 36.489176477415874 36.489176477415874
	+182.8 0.0 0.0 788.5 21.365392577717827 21.365392577717827
	+188.6 0.0 0.0 785.2 20.717142660125695 20.717142660125695
	+194.4 0.0 0.0 810.6 24.580073230159424 24.580073230159424
	+200.2 0.0 0.0 843.5 31.648380685273615 31.648380685273615
	+206.2 0.0 0.0 865.4 20.382835916525455 20.382835916525455
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d65-x01-y01
	+Path=/REF/L3_2004_I652683/d65-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.015 0.001414213562373095 0.001414213562373095
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.084 0.005099019513592785 0.005099019513592785
	+0.5 0.09999999999999998 0.09999999999999998 0.22 0.01216552506059644 0.01216552506059644
	+0.7 0.09999999999999998 0.10000000000000009 0.417 0.009219544457292887 0.009219544457292887
	+0.9 0.09999999999999998 0.09999999999999998 0.69 0.012369316876852983 0.012369316876852983
	+1.1 0.10000000000000009 0.09999999999999987 1.047 0.015524174696260024 0.015524174696260024
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.481 0.012083045973594572 0.012083045973594572
	+1.5 0.10000000000000009 0.10000000000000009 1.986 0.01676305461424021 0.01676305461424021
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.55 0.010816653826391968 0.010816653826391968
	+1.9 0.09999999999999987 0.10000000000000009 3.104 0.02213594362117866 0.02213594362117866
	+2.1 0.10000000000000009 0.10000000000000009 3.642 0.04751841748206689 0.04751841748206689
	+2.3 0.09999999999999964 0.10000000000000009 4.211 0.04472135954999579 0.04472135954999579
	+2.5 0.10000000000000009 0.10000000000000009 4.697 0.0388329756778952 0.0388329756778952
	+2.7 0.10000000000000009 0.09999999999999964 5.156 0.03492849839314596 0.03492849839314596
	+2.9 0.10000000000000009 0.10000000000000009 5.555 0.06166036003787198 0.06166036003787198
	+3.1 0.10000000000000009 0.10000000000000009 5.896 0.021931712199461308 0.021931712199461308
	+3.3 0.09999999999999964 0.10000000000000009 6.104 0.0517880295048962 0.0517880295048962
	+3.5 0.10000000000000009 0.10000000000000009 6.253 0.06661080993352356 0.06661080993352356
	+3.7 0.10000000000000009 0.09999999999999964 6.278 0.06675327707311456 0.06675327707311456
	+3.9 0.10000000000000009 0.10000000000000009 6.201 0.04903060268852505 0.04903060268852505
	+4.1 0.09999999999999964 0.10000000000000053 6.0 0.05375872022286245 0.05375872022286245
	+4.300000000000001 0.10000000000000053 0.09999999999999964 5.681 0.049819674828324605 0.049819674828324605
	+4.5 0.09999999999999964 0.09999999999999964 5.237 0.05968249324550709 0.05968249324550709
	+4.699999999999999 0.09999999999999964 0.10000000000000053 4.629 0.0517880295048962 0.0517880295048962
	+4.9 0.10000000000000053 0.09999999999999964 3.89 0.07343704787094862 0.07343704787094862
	+5.1 0.09999999999999964 0.10000000000000053 3.239 0.04373785545725807 0.04373785545725807
	+5.300000000000001 0.10000000000000053 0.09999999999999964 2.615 0.06946221994724902 0.06946221994724902
	+5.5 0.09999999999999964 0.09999999999999964 1.967 0.07632168761236874 0.07632168761236874
	+5.699999999999999 0.09999999999999964 0.10000000000000053 1.433 0.21627991122617005 0.21627991122617005
	+5.9 0.10000000000000053 0.09999999999999964 0.804 0.08704596486914255 0.08704596486914255
	+6.1 0.09999999999999964 0.10000000000000053 0.495 0.07045565981523415 0.07045565981523415
	+6.300000000000001 0.10000000000000053 0.09999999999999964 0.323 0.045398237851264664 0.045398237851264664
	+6.5 0.09999999999999964 0.09999999999999964 0.208 0.04393176527297759 0.04393176527297759
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.134 0.04522167621838005 0.04522167621838005
	+6.9 0.10000000000000053 0.09999999999999964 0.089 0.042190046219457975 0.042190046219457975
	+7.1 0.09999999999999964 0.10000000000000053 0.062 0.09470480452437458 0.09470480452437458
	+7.300000000000001 0.10000000000000053 0.09999999999999964 0.046 0.02630589287593181 0.02630589287593181
	+7.5 0.09999999999999964 0.09999999999999964 0.034 0.020223748416156685 0.020223748416156685
	+7.699999999999999 0.09999999999999964 0.10000000000000053 0.026 0.0439089968002003 0.0439089968002003
	+7.9 0.10000000000000053 0.09999999999999964 0.022 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d65-x01-y02
	+Path=/REF/L3_2004_I652683/d65-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.018 0.001414213562373095 0.001414213562373095
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.101 0.00608276253029822 0.00608276253029822
	+0.5 0.09999999999999998 0.09999999999999998 0.256 0.015132745950421555 0.015132745950421555
	+0.7 0.09999999999999998 0.10000000000000009 0.471 0.018248287590894658 0.018248287590894658
	+0.9 0.09999999999999998 0.09999999999999998 0.767 0.02531797780234433 0.02531797780234433
	+1.1 0.10000000000000009 0.09999999999999987 1.142 0.0304138126514911 0.0304138126514911
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.582 0.028442925306655785 0.028442925306655785
	+1.5 0.10000000000000009 0.10000000000000009 2.077 0.026683328128252668 0.026683328128252668
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.599 0.0147648230602334 0.0147648230602334
	+1.9 0.09999999999999987 0.10000000000000009 3.092 0.027202941017470887 0.027202941017470887
	+2.1 0.10000000000000009 0.10000000000000009 3.536 0.0565685424949238 0.0565685424949238
	+2.3 0.09999999999999964 0.10000000000000009 4.035 0.06661080993352356 0.06661080993352356
	+2.5 0.10000000000000009 0.10000000000000009 4.458 0.07553806987208503 0.07553806987208503
	+2.7 0.10000000000000009 0.09999999999999964 4.884 0.08558621384311846 0.08558621384311846
	+2.9 0.10000000000000009 0.10000000000000009 5.261 0.10945775440780794 0.10945775440780794
	+3.1 0.10000000000000009 0.10000000000000009 5.61 0.09751410154434076 0.09751410154434076
	+3.3 0.09999999999999964 0.10000000000000009 5.829 0.11154371340420759 0.11154371340420759
	+3.5 0.10000000000000009 0.10000000000000009 5.965 0.122494897852931 0.122494897852931
	+3.7 0.10000000000000009 0.09999999999999964 6.024 0.11851160280748885 0.11851160280748885
	+3.9 0.10000000000000009 0.10000000000000009 5.976 0.10756393447619884 0.10756393447619884
	+4.1 0.09999999999999964 0.10000000000000053 5.805 0.10060318086422516 0.10060318086422516
	+4.300000000000001 0.10000000000000053 0.09999999999999964 5.519 0.0916624241442479 0.0916624241442479
	+4.5 0.09999999999999964 0.09999999999999964 5.1 0.08161494961096281 0.08161494961096281
	+4.699999999999999 0.09999999999999964 0.10000000000000053 4.534 0.06576473218982953 0.06576473218982953
	+4.9 0.10000000000000053 0.09999999999999964 3.817 0.08050465825031494 0.08050465825031494
	+5.1 0.09999999999999964 0.10000000000000053 3.18 0.049819674828324605 0.049819674828324605
	+5.300000000000001 0.10000000000000053 0.09999999999999964 2.579 0.07156814934033155 0.07156814934033155
	+5.5 0.09999999999999964 0.09999999999999964 1.927 0.08050465825031494 0.08050465825031494
	+5.699999999999999 0.09999999999999964 0.10000000000000053 1.406 0.21539266468475662 0.21539266468475662
	+5.9 0.10000000000000053 0.09999999999999964 0.795 0.12 0.12
	+6.1 0.09999999999999964 0.10000000000000053 0.489 0.10489041900955492 0.10489041900955492
	+6.300000000000001 0.10000000000000053 0.09999999999999964 0.318 0.07778174593052023 0.07778174593052023
	+6.5 0.09999999999999964 0.09999999999999964 0.204 0.07212489168102784 0.07212489168102784
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.132 0.07355270219373317 0.07355270219373317
	+6.9 0.10000000000000053 0.09999999999999964 0.086 0.07071067811865477 0.07071067811865477
	+7.1 0.09999999999999964 0.10000000000000053 0.06 0.10492378186092989 0.10492378186092989
	+7.300000000000001 0.10000000000000053 0.09999999999999964 0.044 0.054451813560247926 0.054451813560247926
	+7.5 0.09999999999999964 0.09999999999999964 0.034 0.0304138126514911 0.0304138126514911
	+7.699999999999999 0.09999999999999964 0.10000000000000053 0.019 0.05556977595779922 0.05556977595779922
	+7.9 0.10000000000000053 0.09999999999999964 0.021 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d65-x01-y03
	+Path=/REF/L3_2004_I652683/d65-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.001 0.001414213562373095 0.001414213562373095
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.015 0.004472135954999579 0.004472135954999579
	+0.5 0.09999999999999998 0.09999999999999998 0.083 0.013341664064126334 0.013341664064126334
	+0.7 0.09999999999999998 0.10000000000000009 0.215 0.013000000000000001 0.013000000000000001
	+0.9 0.09999999999999998 0.09999999999999998 0.411 0.01655294535724685 0.01655294535724685
	+1.1 0.10000000000000009 0.09999999999999987 0.706 0.02102379604162864 0.02102379604162864
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.124 0.020248456731316585 0.020248456731316585
	+1.5 0.10000000000000009 0.10000000000000009 1.687 0.03220248437620924 0.03220248437620924
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.384 0.033999999999999996 0.033999999999999996
	+1.9 0.09999999999999987 0.10000000000000009 3.155 0.0648459713474939 0.0648459713474939
	+2.1 0.10000000000000009 0.10000000000000009 4.088 0.09556673061269806 0.09556673061269806
	+2.3 0.09999999999999964 0.10000000000000009 4.905 0.1086830253535482 0.1086830253535482
	+2.5 0.10000000000000009 0.10000000000000009 5.619 0.11985407794480754 0.11985407794480754
	+2.7 0.10000000000000009 0.09999999999999964 6.221 0.12397580409095962 0.12397580409095962
	+2.9 0.10000000000000009 0.10000000000000009 6.598 0.1310267148332736 0.1310267148332736
	+3.1 0.10000000000000009 0.10000000000000009 6.998 0.09265527507918801 0.09265527507918801
	+3.3 0.09999999999999964 0.10000000000000009 7.128 0.09486832980505137 0.09486832980505137
	+3.5 0.10000000000000009 0.10000000000000009 7.336 0.0942443632266673 0.0942443632266673
	+3.7 0.10000000000000009 0.09999999999999964 7.162 0.0873155198117723 0.0873155198117723
	+3.9 0.10000000000000009 0.10000000000000009 7.052 0.07201388754955533 0.07201388754955533
	+4.1 0.09999999999999964 0.10000000000000053 6.699 0.07432361670424818 0.07432361670424818
	+4.300000000000001 0.10000000000000053 0.09999999999999964 6.275 0.07249827584156743 0.07249827584156743
	+4.5 0.09999999999999964 0.09999999999999964 5.716 0.08415461959987698 0.08415461959987698
	+4.699999999999999 0.09999999999999964 0.10000000000000053 4.995 0.07725283166331186 0.07725283166331186
	+4.9 0.10000000000000053 0.09999999999999964 4.164 0.09080198235721508 0.09080198235721508
	+5.1 0.09999999999999964 0.10000000000000053 3.41 0.065 0.065
	+5.300000000000001 0.10000000000000053 0.09999999999999964 2.846 0.09533624704172071 0.09533624704172071
	+5.5 0.09999999999999964 0.09999999999999964 2.113 0.09920181449953423 0.09920181449953423
	+5.699999999999999 0.09999999999999964 0.10000000000000053 1.483 0.2244147945212169 0.2244147945212169
	+5.9 0.10000000000000053 0.09999999999999964 0.82 0.2773157045679166 0.2773157045679166
	+6.1 0.09999999999999964 0.10000000000000053 0.518 0.35285266046892716 0.35285266046892716
	+6.300000000000001 0.10000000000000053 0.09999999999999964 0.384 0.2729761894378336 0.2729761894378336
	+6.5 0.09999999999999964 0.09999999999999964 0.211 0.18809040379562167 0.18809040379562167
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.115 0.16759773268156106 0.16759773268156106
	+6.9 0.10000000000000053 0.09999999999999964 0.08 0.1633431969810803 0.1633431969810803
	+7.1 0.09999999999999964 0.10000000000000053 0.0 0.088 0.088
	+7.300000000000001 0.10000000000000053 0.09999999999999964 0.038 0.08207313811473277 0.08207313811473277
	+7.5 0.09999999999999964 0.09999999999999964 0.01 0.040816663263917106 0.040816663263917106
	+7.699999999999999 0.09999999999999964 0.10000000000000053 0.023 0.07543208866258444 0.07543208866258444
	+7.9 0.10000000000000053 0.09999999999999964 0.024 0.001414213562373095 0.001414213562373095
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d66-x01-y01
	+Path=/REF/L3_2004_I652683/d66-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.04 0.019849433241279208 0.019849433241279208
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.055 0.03488552708502481 0.03488552708502481
	+0.5 0.09999999999999998 0.09999999999999998 0.147 0.09838699100999074 0.09838699100999074
	+0.7 0.09999999999999998 0.10000000000000009 0.349 0.10682696288858914 0.10682696288858914
	+0.9 0.09999999999999998 0.09999999999999998 0.638 0.10600471687618433 0.10600471687618433
	+1.1 0.10000000000000009 0.09999999999999987 0.823 0.12394353553130553 0.12394353553130553
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.289 0.17 0.17
	+1.5 0.10000000000000009 0.10000000000000009 2.148 0.21726711670199886 0.21726711670199886
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.689 0.2526915115313532 0.2526915115313532
	+1.9 0.09999999999999987 0.10000000000000009 2.662 0.2400520776831561 0.2400520776831561
	+2.1 0.10000000000000009 0.10000000000000009 3.691 0.27761844319137013 0.27761844319137013
	+2.3 0.09999999999999964 0.10000000000000009 4.462 0.3880940607636247 0.3880940607636247
	+2.5 0.10000000000000009 0.10000000000000009 4.581 0.29783552508053834 0.29783552508053834
	+2.7 0.10000000000000009 0.09999999999999964 5.299 0.32062750973676607 0.32062750973676607
	+2.9 0.10000000000000009 0.10000000000000009 5.924 0.37903298009540015 0.37903298009540015
	+3.1 0.10000000000000009 0.10000000000000009 5.874 0.36702179771779225 0.36702179771779225
	+3.3 0.09999999999999964 0.10000000000000009 6.764 0.33686792664188137 0.33686792664188137
	+3.5 0.10000000000000009 0.10000000000000009 6.605 0.37377132046212425 0.37377132046212425
	+3.7 0.10000000000000009 0.09999999999999964 6.918 0.3280868787379343 0.3280868787379343
	+3.9 0.10000000000000009 0.10000000000000009 6.903 0.32796341259353917 0.32796341259353917
	+4.1 0.09999999999999964 0.10000000000000053 6.746 0.3531359511576243 0.3531359511576243
	+4.300000000000001 0.10000000000000053 0.09999999999999964 6.118 0.34281190177705323 0.34281190177705323
	+4.5 0.09999999999999964 0.09999999999999964 6.588 0.4153516582367284 0.4153516582367284
	+4.699999999999999 0.09999999999999964 0.10000000000000053 5.756 0.3773711700699989 0.3773711700699989
	+4.9 0.10000000000000053 0.09999999999999964 5.416 0.3996060560101661 0.3996060560101661
	+5.1 0.09999999999999964 0.10000000000000053 4.484 0.27644348427843257 0.27644348427843257
	+5.300000000000001 0.10000000000000053 0.09999999999999964 3.799 0.29597972903562164 0.29597972903562164
	+5.5 0.09999999999999964 0.09999999999999964 2.942 0.20099751242241778 0.20099751242241778
	+5.699999999999999 0.09999999999999964 0.10000000000000053 2.409 0.2156965461012299 0.2156965461012299
	+5.9 0.10000000000000053 0.09999999999999964 1.783 0.17351080657987847 0.17351080657987847
	+6.1 0.09999999999999964 0.10000000000000053 1.179 0.12529964086141668 0.12529964086141668
	+6.300000000000001 0.10000000000000053 0.09999999999999964 0.785 0.14018559127100044 0.14018559127100044
	+6.5 0.09999999999999964 0.09999999999999964 0.181 0.06536818798161687 0.06536818798161687
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d66-x01-y02
	+Path=/REF/L3_2004_I652683/d66-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.067 0.02118962010041709 0.02118962010041709
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.084 0.056859475903317996 0.056859475903317996
	+0.5 0.09999999999999998 0.09999999999999998 0.17 0.08070935509592429 0.08070935509592429
	+0.7 0.09999999999999998 0.10000000000000009 0.475 0.11536463929644994 0.11536463929644994
	+0.9 0.09999999999999998 0.09999999999999998 0.713 0.13360014970051493 0.13360014970051493
	+1.1 0.10000000000000009 0.09999999999999987 1.075 0.18080099557248017 0.18080099557248017
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.244 0.18555053220079967 0.18555053220079967
	+1.5 0.10000000000000009 0.10000000000000009 1.849 0.23365786954434042 0.23365786954434042
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.433 0.2782265264132807 0.2782265264132807
	+1.9 0.09999999999999987 0.10000000000000009 2.448 0.31280025575437115 0.31280025575437115
	+2.1 0.10000000000000009 0.10000000000000009 3.101 0.31532998588779976 0.31532998588779976
	+2.3 0.09999999999999964 0.10000000000000009 4.007 0.33181018670318124 0.33181018670318124
	+2.5 0.10000000000000009 0.10000000000000009 4.365 0.37582575749940295 0.37582575749940295
	+2.7 0.10000000000000009 0.09999999999999964 4.945 0.393315395071182 0.393315395071182
	+2.9 0.10000000000000009 0.10000000000000009 5.538 0.4349172335054108 0.4349172335054108
	+3.1 0.10000000000000009 0.10000000000000009 6.075 0.41401690786729956 0.41401690786729956
	+3.3 0.09999999999999964 0.10000000000000009 6.337 0.4385179585832261 0.4385179585832261
	+3.5 0.10000000000000009 0.10000000000000009 7.308 0.5170541557709405 0.5170541557709405
	+3.7 0.10000000000000009 0.09999999999999964 6.575 0.39642906048875887 0.39642906048875887
	+3.9 0.10000000000000009 0.10000000000000009 6.911 0.4011795109424209 0.4011795109424209
	+4.1 0.09999999999999964 0.10000000000000053 6.97 0.4730591929135296 0.4730591929135296
	+4.300000000000001 0.10000000000000053 0.09999999999999964 6.855 0.500695516257136 0.500695516257136
	+4.5 0.09999999999999964 0.09999999999999964 6.623 0.4609913231287548 0.4609913231287548
	+4.699999999999999 0.09999999999999964 0.10000000000000053 6.541 0.48091267398562076 0.48091267398562076
	+4.9 0.10000000000000053 0.09999999999999964 4.831 0.29624989451474915 0.29624989451474915
	+5.1 0.09999999999999964 0.10000000000000053 5.002 0.3223553939365681 0.3223553939365681
	+5.300000000000001 0.10000000000000053 0.09999999999999964 3.817 0.3360014880919428 0.3360014880919428
	+5.5 0.09999999999999964 0.09999999999999964 3.182 0.2526756814574762 0.2526756814574762
	+5.699999999999999 0.09999999999999964 0.10000000000000053 2.574 0.2140840956259946 0.2140840956259946
	+5.9 0.10000000000000053 0.09999999999999964 1.804 0.16938713056191726 0.16938713056191726
	+6.1 0.09999999999999964 0.10000000000000053 1.189 0.14978985279383916 0.14978985279383916
	+6.300000000000001 0.10000000000000053 0.09999999999999964 1.055 0.17799157283422157 0.17799157283422157
	+6.5 0.09999999999999964 0.09999999999999964 0.429 0.1167304587500623 0.1167304587500623
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d66-x01-y03
	+Path=/REF/L3_2004_I652683/d66-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.028 0.016155494421403512 0.016155494421403512
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.099 0.03753664875824692 0.03753664875824692
	+0.5 0.09999999999999998 0.09999999999999998 0.144 0.06940461079784253 0.06940461079784253
	+0.7 0.09999999999999998 0.10000000000000009 0.35 0.12480785231707178 0.12480785231707178
	+0.9 0.09999999999999998 0.09999999999999998 0.502 0.14778700890132393 0.14778700890132393
	+1.1 0.10000000000000009 0.09999999999999987 1.074 0.18183509012289129 0.18183509012289129
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.614 0.22242751628339513 0.22242751628339513
	+1.5 0.10000000000000009 0.10000000000000009 1.737 0.2078845833629805 0.2078845833629805
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.379 0.26343310346271975 0.26343310346271975
	+1.9 0.09999999999999987 0.10000000000000009 2.619 0.2618434646883515 0.2618434646883515
	+2.1 0.10000000000000009 0.10000000000000009 4.119 0.368982384403375 0.368982384403375
	+2.3 0.09999999999999964 0.10000000000000009 4.337 0.3637925232876564 0.3637925232876564
	+2.5 0.10000000000000009 0.10000000000000009 5.176 0.424792890712639 0.424792890712639
	+2.7 0.10000000000000009 0.09999999999999964 5.944 0.40645294930655873 0.40645294930655873
	+2.9 0.10000000000000009 0.10000000000000009 5.877 0.49576708240866496 0.49576708240866496
	+3.1 0.10000000000000009 0.10000000000000009 7.071 0.4780972704377217 0.4780972704377217
	+3.3 0.09999999999999964 0.10000000000000009 6.333 0.5492986437267071 0.5492986437267071
	+3.5 0.10000000000000009 0.10000000000000009 6.696 0.4207445780993499 0.4207445780993499
	+3.7 0.10000000000000009 0.09999999999999964 7.279 0.48984079046155393 0.48984079046155393
	+3.9 0.10000000000000009 0.10000000000000009 7.349 0.4674719242906466 0.4674719242906466
	+4.1 0.09999999999999964 0.10000000000000053 7.448 0.49937961512260387 0.49937961512260387
	+4.300000000000001 0.10000000000000053 0.09999999999999964 7.142 0.38862964374838926 0.38862964374838926
	+4.5 0.09999999999999964 0.09999999999999964 6.789 0.4574997267758747 0.4574997267758747
	+4.699999999999999 0.09999999999999964 0.10000000000000053 6.323 0.5643837347053864 0.5643837347053864
	+4.9 0.10000000000000053 0.09999999999999964 6.167 0.4235327614246624 0.4235327614246624
	+5.1 0.09999999999999964 0.10000000000000053 5.288 0.3825767896775757 0.3825767896775757
	+5.300000000000001 0.10000000000000053 0.09999999999999964 5.347 0.35922694776422326 0.35922694776422326
	+5.5 0.09999999999999964 0.09999999999999964 4.147 0.35296600402871664 0.35296600402871664
	+5.699999999999999 0.09999999999999964 0.10000000000000053 2.904 0.2497218452598811 0.2497218452598811
	+5.9 0.10000000000000053 0.09999999999999964 2.431 0.2501999200639361 0.2501999200639361
	+6.1 0.09999999999999964 0.10000000000000053 1.529 0.16949926253526887 0.16949926253526887
	+6.300000000000001 0.10000000000000053 0.09999999999999964 1.312 0.15368799562750501 0.15368799562750501
	+6.5 0.09999999999999964 0.09999999999999964 0.88 0.15504837954651446 0.15504837954651446
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.248 0.10623088063270492 0.10623088063270492
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d67-x01-y01
	+Path=/REF/L3_2004_I652683/d67-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.056 0.03047950130825634 0.03047950130825634
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.089 0.03889730067755345 0.03889730067755345
	+0.5 0.09999999999999998 0.09999999999999998 0.227 0.10377379245262264 0.10377379245262264
	+0.7 0.09999999999999998 0.10000000000000009 0.385 0.15640012787718557 0.15640012787718557
	+0.9 0.09999999999999998 0.09999999999999998 0.64 0.22280035906613796 0.22280035906613796
	+1.1 0.10000000000000009 0.09999999999999987 1.082 0.21294130646729864 0.21294130646729864
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.384 0.28428858577157123 0.28428858577157123
	+1.5 0.10000000000000009 0.10000000000000009 2.105 0.3216022387981775 0.3216022387981775
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 1.913 0.2990401310861136 0.2990401310861136
	+1.9 0.09999999999999987 0.10000000000000009 2.847 0.41188590653237944 0.41188590653237944
	+2.1 0.10000000000000009 0.10000000000000009 3.841 0.42686414700698394 0.42686414700698394
	+2.3 0.09999999999999964 0.10000000000000009 4.515 0.6098106263423096 0.6098106263423096
	+2.5 0.10000000000000009 0.10000000000000009 4.665 0.6377366227526846 0.6377366227526846
	+2.7 0.10000000000000009 0.09999999999999964 4.951 0.5097528813062266 0.5097528813062266
	+2.9 0.10000000000000009 0.10000000000000009 5.472 0.5445181356024793 0.5445181356024793
	+3.1 0.10000000000000009 0.10000000000000009 6.489 0.5744649684706632 0.5744649684706632
	+3.3 0.09999999999999964 0.10000000000000009 6.838 0.7635561537961697 0.7635561537961697
	+3.5 0.10000000000000009 0.10000000000000009 7.378 0.7116544105111693 0.7116544105111693
	+3.7 0.10000000000000009 0.09999999999999964 7.182 0.9679116695236193 0.9679116695236193
	+3.9 0.10000000000000009 0.10000000000000009 7.583 1.00743635034676 1.00743635034676
	+4.1 0.09999999999999964 0.10000000000000053 7.838 0.752814054066474 0.752814054066474
	+4.300000000000001 0.10000000000000053 0.09999999999999964 7.918 0.8781713955715024 0.8781713955715024
	+4.5 0.09999999999999964 0.09999999999999964 6.706 0.7166791471781497 0.7166791471781497
	+4.699999999999999 0.09999999999999964 0.10000000000000053 6.582 0.7599243383390217 0.7599243383390217
	+4.9 0.10000000000000053 0.09999999999999964 6.411 0.7482626544202243 0.7482626544202243
	+5.1 0.09999999999999964 0.10000000000000053 6.069 0.6377726867779774 0.6377726867779774
	+5.300000000000001 0.10000000000000053 0.09999999999999964 5.055 0.5882176467941097 0.5882176467941097
	+5.5 0.09999999999999964 0.09999999999999964 4.189 0.5279138187242307 0.5279138187242307
	+5.699999999999999 0.09999999999999964 0.10000000000000053 3.531 0.39682867839912983 0.39682867839912983
	+5.9 0.10000000000000053 0.09999999999999964 2.791 0.2998216136305053 0.2998216136305053
	+6.1 0.09999999999999964 0.10000000000000053 2.155 0.27022398117117585 0.27022398117117585
	+6.300000000000001 0.10000000000000053 0.09999999999999964 1.721 0.22579636843846715 0.22579636843846715
	+6.5 0.09999999999999964 0.09999999999999964 1.062 0.21727632176562636 0.21727632176562636
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.29 0.14317821063276354 0.14317821063276354
	+6.9 0.10000000000000053 0.09999999999999964 0.0 0.0 0.0
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d67-x01-y02
	+Path=/REF/L3_2004_I652683/d67-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.081 0.0191049731745428 0.0191049731745428
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.091 0.02996664812754339 0.02996664812754339
	+0.5 0.09999999999999998 0.09999999999999998 0.127 0.0696419413859206 0.0696419413859206
	+0.7 0.09999999999999998 0.10000000000000009 0.316 0.05303772242470447 0.05303772242470447
	+0.9 0.09999999999999998 0.09999999999999998 0.593 0.09323625904121206 0.09323625904121206
	+1.1 0.10000000000000009 0.09999999999999987 0.892 0.08276472678623424 0.08276472678623424
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.387 0.10791200118615167 0.10791200118615167
	+1.5 0.10000000000000009 0.10000000000000009 1.881 0.12389108119634762 0.12389108119634762
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.556 0.18676188047886003 0.18676188047886003
	+1.9 0.09999999999999987 0.10000000000000009 2.917 0.15728000508646992 0.15728000508646992
	+2.1 0.10000000000000009 0.10000000000000009 3.522 0.18402445489662508 0.18402445489662508
	+2.3 0.09999999999999964 0.10000000000000009 4.118 0.18384776310850234 0.18384776310850234
	+2.5 0.10000000000000009 0.10000000000000009 4.775 0.18784301956687133 0.18784301956687133
	+2.7 0.10000000000000009 0.09999999999999964 5.536 0.22262299971027252 0.22262299971027252
	+2.9 0.10000000000000009 0.10000000000000009 5.625 0.2524618783103698 0.2524618783103698
	+3.1 0.10000000000000009 0.10000000000000009 6.146 0.30267639485100256 0.30267639485100256
	+3.3 0.09999999999999964 0.10000000000000009 6.938 0.23171750041807374 0.23171750041807374
	+3.5 0.10000000000000009 0.10000000000000009 6.839 0.300892007205243 0.300892007205243
	+3.7 0.10000000000000009 0.09999999999999964 7.296 0.3027292519727818 0.3027292519727818
	+3.9 0.10000000000000009 0.10000000000000009 7.43 0.29149614062625256 0.29149614062625256
	+4.1 0.09999999999999964 0.10000000000000053 7.415 0.2923439754809392 0.2923439754809392
	+4.300000000000001 0.10000000000000053 0.09999999999999964 7.231 0.2779658252375641 0.2779658252375641
	+4.5 0.09999999999999964 0.09999999999999964 7.202 0.30205463082032036 0.30205463082032036
	+4.699999999999999 0.09999999999999964 0.10000000000000053 7.07 0.44064725121121545 0.44064725121121545
	+4.9 0.10000000000000053 0.09999999999999964 6.354 0.2782265264132807 0.2782265264132807
	+5.1 0.09999999999999964 0.10000000000000053 5.646 0.33378136556734256 0.33378136556734256
	+5.300000000000001 0.10000000000000053 0.09999999999999964 5.442 0.25505489605181075 0.25505489605181075
	+5.5 0.09999999999999964 0.09999999999999964 4.427 0.2800660636349931 0.2800660636349931
	+5.699999999999999 0.09999999999999964 0.10000000000000053 3.845 0.20247468977627797 0.20247468977627797
	+5.9 0.10000000000000053 0.09999999999999964 2.89 0.15391231269784755 0.15391231269784755
	+6.1 0.09999999999999964 0.10000000000000053 2.241 0.12806248474865697 0.12806248474865697
	+6.300000000000001 0.10000000000000053 0.09999999999999964 1.659 0.11819052415485769 0.11819052415485769
	+6.5 0.09999999999999964 0.09999999999999964 1.086 0.10607544484940894 0.10607544484940894
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.657 0.0909065454189081 0.0909065454189081
	+6.9 0.10000000000000053 0.09999999999999964 0.02 0.0191049731745428 0.0191049731745428
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d67-x01-y03
	+Path=/REF/L3_2004_I652683/d67-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.065 0.01063014581273465 0.01063014581273465
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.089 0.016999999999999998 0.016999999999999998
	+0.5 0.09999999999999998 0.09999999999999998 0.163 0.0449221548904324 0.0449221548904324
	+0.7 0.09999999999999998 0.10000000000000009 0.346 0.06041522986797286 0.06041522986797286
	+0.9 0.09999999999999998 0.09999999999999998 0.586 0.07605918747922567 0.07605918747922567
	+1.1 0.10000000000000009 0.09999999999999987 1.05 0.05220153254455275 0.05220153254455275
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.338 0.05946427498927403 0.05946427498927403
	+1.5 0.10000000000000009 0.10000000000000009 1.922 0.09626006440887104 0.09626006440887104
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.395 0.08407734534343957 0.08407734534343957
	+1.9 0.09999999999999987 0.10000000000000009 3.027 0.09818350166906863 0.09818350166906863
	+2.1 0.10000000000000009 0.10000000000000009 3.603 0.10288342918079665 0.10288342918079665
	+2.3 0.09999999999999964 0.10000000000000009 4.388 0.13238202294873727 0.13238202294873727
	+2.5 0.10000000000000009 0.10000000000000009 4.651 0.12381033882515628 0.12381033882515628
	+2.7 0.10000000000000009 0.09999999999999964 5.487 0.17664087862100325 0.17664087862100325
	+2.9 0.10000000000000009 0.10000000000000009 5.629 0.1676007159889241 0.1676007159889241
	+3.1 0.10000000000000009 0.10000000000000009 6.394 0.18272657168567466 0.18272657168567466
	+3.3 0.09999999999999964 0.10000000000000009 6.982 0.18233211456021675 0.18233211456021675
	+3.5 0.10000000000000009 0.10000000000000009 7.271 0.17996110690924302 0.17996110690924302
	+3.7 0.10000000000000009 0.09999999999999964 7.08 0.22005681084665388 0.22005681084665388
	+3.9 0.10000000000000009 0.10000000000000009 7.339 0.18912958520548814 0.18912958520548814
	+4.1 0.09999999999999964 0.10000000000000053 7.516 0.2408817137102773 0.2408817137102773
	+4.300000000000001 0.10000000000000053 0.09999999999999964 7.45 0.22792323269030737 0.22792323269030737
	+4.5 0.09999999999999964 0.09999999999999964 7.029 0.20468512403201167 0.20468512403201167
	+4.699999999999999 0.09999999999999964 0.10000000000000053 6.938 0.22786399452304879 0.22786399452304879
	+4.9 0.10000000000000053 0.09999999999999964 6.427 0.1725949014310678 0.1725949014310678
	+5.1 0.09999999999999964 0.10000000000000053 5.89 0.13727709204379293 0.13727709204379293
	+5.300000000000001 0.10000000000000053 0.09999999999999964 5.22 0.14375326083258078 0.14375326083258078
	+5.5 0.09999999999999964 0.09999999999999964 4.559 0.15811388300841897 0.15811388300841897
	+5.699999999999999 0.09999999999999964 0.10000000000000053 3.77 0.10771258050942796 0.10771258050942796
	+5.9 0.10000000000000053 0.09999999999999964 2.987 0.08324061508662703 0.08324061508662703
	+6.1 0.09999999999999964 0.10000000000000053 2.363 0.09935793878699375 0.09935793878699375
	+6.300000000000001 0.10000000000000053 0.09999999999999964 1.73 0.08072174428244226 0.08072174428244226
	+6.5 0.09999999999999964 0.09999999999999964 1.209 0.06935416353759881 0.06935416353759881
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.749 0.046097722286464436 0.046097722286464436
	+6.9 0.10000000000000053 0.09999999999999964 0.088 0.028017851452243798 0.028017851452243798
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d68-x01-y01
	+Path=/REF/L3_2004_I652683/d68-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.068 0.017204650534085254 0.017204650534085254
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.087 0.021095023109728987 0.021095023109728987
	+0.5 0.09999999999999998 0.09999999999999998 0.18 0.06072890580275591 0.06072890580275591
	+0.7 0.09999999999999998 0.10000000000000009 0.31 0.06723094525588645 0.06723094525588645
	+0.9 0.09999999999999998 0.09999999999999998 0.679 0.08987213138676527 0.08987213138676527
	+1.1 0.10000000000000009 0.09999999999999987 0.937 0.09902019995940221 0.09902019995940221
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.233 0.12140016474453402 0.12140016474453402
	+1.5 0.10000000000000009 0.10000000000000009 1.842 0.1140175425099138 0.1140175425099138
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.319 0.13931618714277247 0.13931618714277247
	+1.9 0.09999999999999987 0.10000000000000009 2.828 0.1790111728356641 0.1790111728356641
	+2.1 0.10000000000000009 0.10000000000000009 3.466 0.16086329600005092 0.16086329600005092
	+2.3 0.09999999999999964 0.10000000000000009 4.09 0.1700823330037544 0.1700823330037544
	+2.5 0.10000000000000009 0.10000000000000009 4.726 0.24495101551126505 0.24495101551126505
	+2.7 0.10000000000000009 0.09999999999999964 5.398 0.2247420743875076 0.2247420743875076
	+2.9 0.10000000000000009 0.10000000000000009 5.418 0.2960709374457412 0.2960709374457412
	+3.1 0.10000000000000009 0.10000000000000009 6.227 0.19990247622278218 0.19990247622278218
	+3.3 0.09999999999999964 0.10000000000000009 6.729 0.2754087870784082 0.2754087870784082
	+3.5 0.10000000000000009 0.10000000000000009 7.163 0.23125094594401124 0.23125094594401124
	+3.7 0.10000000000000009 0.09999999999999964 7.138 0.2993476240092779 0.2993476240092779
	+3.9 0.10000000000000009 0.10000000000000009 7.496 0.32739120330271554 0.32739120330271554
	+4.1 0.09999999999999964 0.10000000000000053 7.565 0.2547508586835381 0.2547508586835381
	+4.300000000000001 0.10000000000000053 0.09999999999999964 7.133 0.3260874115938853 0.3260874115938853
	+4.5 0.09999999999999964 0.09999999999999964 7.103 0.3066463761403353 0.3066463761403353
	+4.699999999999999 0.09999999999999964 0.10000000000000053 7.048 0.3025359482772254 0.3025359482772254
	+4.9 0.10000000000000053 0.09999999999999964 6.482 0.2526202683871585 0.2526202683871585
	+5.1 0.09999999999999964 0.10000000000000053 6.154 0.24342966129870042 0.24342966129870042
	+5.300000000000001 0.10000000000000053 0.09999999999999964 5.547 0.21833231551925614 0.21833231551925614
	+5.5 0.09999999999999964 0.09999999999999964 4.587 0.2398207664069148 0.2398207664069148
	+5.699999999999999 0.09999999999999964 0.10000000000000053 3.807 0.15839823231336894 0.15839823231336894
	+5.9 0.10000000000000053 0.09999999999999964 3.129 0.16226521500309302 0.16226521500309302
	+6.1 0.09999999999999964 0.10000000000000053 2.342 0.1680773631397161 0.1680773631397161
	+6.300000000000001 0.10000000000000053 0.09999999999999964 1.902 0.17755280904564702 0.17755280904564702
	+6.5 0.09999999999999964 0.09999999999999964 1.306 0.12624579200908045 0.12624579200908045
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.99 0.1128007092176286 0.1128007092176286
	+6.9 0.10000000000000053 0.09999999999999964 0.162 0.04031128874149275 0.04031128874149275
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d68-x01-y02
	+Path=/REF/L3_2004_I652683/d68-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.078 0.022360679774997897 0.022360679774997897
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.084 0.021213203435596427 0.021213203435596427
	+0.5 0.09999999999999998 0.09999999999999998 0.15 0.06140032573203501 0.06140032573203501
	+0.7 0.09999999999999998 0.10000000000000009 0.318 0.07023531875061151 0.07023531875061151
	+0.9 0.09999999999999998 0.09999999999999998 0.527 0.08405950273467004 0.08405950273467004
	+1.1 0.10000000000000009 0.09999999999999987 0.858 0.07621679604916491 0.07621679604916491
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.295 0.1103902169578446 0.1103902169578446
	+1.5 0.10000000000000009 0.10000000000000009 1.751 0.17695479648769058 0.17695479648769058
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.368 0.18374166647769363 0.18374166647769363
	+1.9 0.09999999999999987 0.10000000000000009 2.572 0.19360010330575755 0.19360010330575755
	+2.1 0.10000000000000009 0.10000000000000009 3.566 0.28383269720030496 0.28383269720030496
	+2.3 0.09999999999999964 0.10000000000000009 4.239 0.25738104048278304 0.25738104048278304
	+2.5 0.10000000000000009 0.10000000000000009 4.998 0.45125270082294244 0.45125270082294244
	+2.7 0.10000000000000009 0.09999999999999964 4.759 0.2632052431088712 0.2632052431088712
	+2.9 0.10000000000000009 0.10000000000000009 5.637 0.24461602564018572 0.24461602564018572
	+3.1 0.10000000000000009 0.10000000000000009 6.133 0.2941513216016546 0.2941513216016546
	+3.3 0.09999999999999964 0.10000000000000009 6.24 0.2638825496314601 0.2638825496314601
	+3.5 0.10000000000000009 0.10000000000000009 7.096 0.2628554735971842 0.2628554735971842
	+3.7 0.10000000000000009 0.09999999999999964 7.308 0.24357750306627252 0.24357750306627252
	+3.9 0.10000000000000009 0.10000000000000009 7.453 0.3195262117573455 0.3195262117573455
	+4.1 0.09999999999999964 0.10000000000000053 7.32 0.33490297102295163 0.33490297102295163
	+4.300000000000001 0.10000000000000053 0.09999999999999964 7.353 0.27020362691866295 0.27020362691866295
	+4.5 0.09999999999999964 0.09999999999999964 7.409 0.3185231545743574 0.3185231545743574
	+4.699999999999999 0.09999999999999964 0.10000000000000053 7.264 0.3139681512510465 0.3139681512510465
	+4.9 0.10000000000000053 0.09999999999999964 6.764 0.27790825824361537 0.27790825824361537
	+5.1 0.09999999999999964 0.10000000000000053 6.424 0.2615836386320826 0.2615836386320826
	+5.300000000000001 0.10000000000000053 0.09999999999999964 5.628 0.3823937760999779 0.3823937760999779
	+5.5 0.09999999999999964 0.09999999999999964 5.03 0.31813519138881824 0.31813519138881824
	+5.699999999999999 0.09999999999999964 0.10000000000000053 4.071 0.18287974190707945 0.18287974190707945
	+5.9 0.10000000000000053 0.09999999999999964 3.393 0.18610212250267325 0.18610212250267325
	+6.1 0.09999999999999964 0.10000000000000053 2.751 0.17459095051004217 0.17459095051004217
	+6.300000000000001 0.10000000000000053 0.09999999999999964 1.957 0.18969449122207 0.18969449122207
	+6.5 0.09999999999999964 0.09999999999999964 1.407 0.14054536634126363 0.14054536634126363
	+6.699999999999999 0.09999999999999964 0.10000000000000053 0.948 0.12929423807734047 0.12929423807734047
	+6.9 0.10000000000000053 0.09999999999999964 0.35 0.07789736837660179 0.07789736837660179
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/L3_2004_I652683/d68-x01-y03
	+Path=/REF/L3_2004_I652683/d68-x01-y03
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1 0.1 0.1 0.078 0.014422205101855958 0.014422205101855958
	+0.30000000000000004 0.10000000000000003 0.09999999999999998 0.1 0.015811388300841896 0.015811388300841896
	+0.5 0.09999999999999998 0.09999999999999998 0.173 0.06087692502089769 0.06087692502089769
	+0.7 0.09999999999999998 0.10000000000000009 0.316 0.07400000000000001 0.07400000000000001
	+0.9 0.09999999999999998 0.09999999999999998 0.632 0.07702596964660685 0.07702596964660685
	+1.1 0.10000000000000009 0.09999999999999987 0.908 0.08683893136145793 0.08683893136145793
	+1.2999999999999998 0.09999999999999987 0.10000000000000009 1.314 0.0990858213873206 0.0990858213873206
	+1.5 0.10000000000000009 0.10000000000000009 1.715 0.08809086218218097 0.08809086218218097
	+1.7000000000000002 0.10000000000000009 0.09999999999999987 2.339 0.10244998779892558 0.10244998779892558
	+1.9 0.09999999999999987 0.10000000000000009 2.873 0.12876334882255897 0.12876334882255897
	+2.1 0.10000000000000009 0.10000000000000009 3.444 0.1467548977036201 0.1467548977036201
	+2.3 0.09999999999999964 0.10000000000000009 4.189 0.18367362358270173 0.18367362358270173
	+2.5 0.10000000000000009 0.10000000000000009 4.776 0.16924833824885846 0.16924833824885846
	+2.7 0.10000000000000009 0.09999999999999964 5.356 0.19340372281835735 0.19340372281835735
	+2.9 0.10000000000000009 0.10000000000000009 5.82 0.17705366418123067 0.17705366418123067
	+3.1 0.10000000000000009 0.10000000000000009 6.245 0.19525624189766635 0.19525624189766635
	+3.3 0.09999999999999964 0.10000000000000009 6.884 0.22080081521588638 0.22080081521588638
	+3.5 0.10000000000000009 0.10000000000000009 7.197 0.2822428032740605 0.2822428032740605
	+3.7 0.10000000000000009 0.09999999999999964 7.5 0.3123395588138012 0.3123395588138012
	+3.9 0.10000000000000009 0.10000000000000009 7.692 0.20652602741543258 0.20652602741543258
	+4.1 0.09999999999999964 0.10000000000000053 7.829 0.27188416651213804 0.27188416651213804
	+4.300000000000001 0.10000000000000053 0.09999999999999964 7.439 0.254678228358845 0.254678228358845
	+4.5 0.09999999999999964 0.09999999999999964 7.535 0.2282673870705143 0.2282673870705143
	+4.699999999999999 0.09999999999999964 0.10000000000000053 7.149 0.24987396823198688 0.24987396823198688
	+4.9 0.10000000000000053 0.09999999999999964 6.953 0.24337008854828482 0.24337008854828482
	+5.1 0.09999999999999964 0.10000000000000053 6.436 0.26969983314789053 0.26969983314789053
	+5.300000000000001 0.10000000000000053 0.09999999999999964 5.713 0.20498048687619025 0.20498048687619025
	+5.5 0.09999999999999964 0.09999999999999964 4.918 0.20096019506359958 0.20096019506359958
	+5.699999999999999 0.09999999999999964 0.10000000000000053 4.35 0.20842504647954382 0.20842504647954382
	+5.9 0.10000000000000053 0.09999999999999964 3.443 0.17577542490348302 0.17577542490348302
	+6.1 0.09999999999999964 0.10000000000000053 2.627 0.16174362429474617 0.16174362429474617
	+6.300000000000001 0.10000000000000053 0.09999999999999964 2.014 0.12006664815842907 0.12006664815842907
	+6.5 0.09999999999999964 0.09999999999999964 1.466 0.09604686356149274 0.09604686356149274
	+6.699999999999999 0.09999999999999964 0.10000000000000053 1.02 0.11636150566231085 0.11636150566231085
	+6.9 0.10000000000000053 0.09999999999999964 0.451 0.08324061508662703 0.08324061508662703
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/LHCB_2014_I1262703.yoda b/data/refdata/LHCB_2014_I1262703.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/LHCB_2014_I1262703.yoda
	@@ -0,0 +1,167 @@
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d01-x01-y01
	+Path=/REF/LHCB_2014_I1262703/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7000.0 0.5 0.5 6.3 0.5477225575051662 0.5477225575051662
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d01-x01-y02
	+Path=/REF/LHCB_2014_I1262703/d01-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7000.0 0.5 0.5 16.0 1.3564659966250536 1.3564659966250536
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d02-x01-y01
	+Path=/REF/LHCB_2014_I1262703/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7000.0 0.5 0.5 0.083 0.007071067811865475 0.007071067811865475
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d02-x01-y02
	+Path=/REF/LHCB_2014_I1262703/d02-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+7000.0 0.5 0.5 0.209 0.015132745950421555 0.015132745950421555
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d03-x01-y01
	+Path=/REF/LHCB_2014_I1262703/d03-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+15.0 5.0 5.0 0.0608 0.0025700165369117764 0.0025700165369117764
	+25.0 5.0 5.0 0.0194 0.0012797601337750759 0.0012797601337750759
	+40.0 10.0 10.0 0.0068 7.751877192009687E-4 7.751877192009687E-4
	+62.5 12.5 12.5 0.001728 2.4983994876720577E-4 2.4983994876720577E-4
	+87.5 12.5 12.5 5.08E-4 8.438009243891595E-5 8.438009243891595E-5
	+125.0 25.0 25.0 1.162E-4 2.778488797889961E-5 2.778488797889961E-5
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d04-x01-y01
	+Path=/REF/LHCB_2014_I1262703/d04-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.25 0.25 0.25 0.788 0.05536180994151113 0.05536180994151113
	+2.75 0.25 0.25 0.618 0.04981284974783114 0.04981284974783114
	+3.25 0.25 0.25 0.392 0.0437978309965231 0.0437978309965231
	+3.75 0.25 0.25 0.166 0.02263846284534354 0.02263846284534354
	+4.25 0.25 0.25 0.036 0.007738862965578341 0.007738862965578341
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d04-x01-y02
	+Path=/REF/LHCB_2014_I1262703/d04-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.25 0.25 0.25 0.688 0.04018084120572888 0.04018084120572888
	+2.75 0.25 0.25 0.57 0.03762406145008802 0.03762406145008802
	+3.25 0.25 0.25 0.43 0.032760494501762334 0.032760494501762334
	+3.75 0.25 0.25 0.222 0.026048608408128063 0.026048608408128063
	+4.25 0.25 0.25 0.093 0.010756393447619885 0.010756393447619885
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d05-x01-y01
	+Path=/REF/LHCB_2014_I1262703/d05-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.25 0.25 0.25 0.462 0.02262741699796952 0.02262741699796952
	+2.75 0.25 0.25 0.858 0.025560125195311544 0.025560125195311544
	+3.25 0.25 0.25 0.588 0.022287440409342656 0.022287440409342656
	+3.75 0.25 0.25 0.092 0.008421995013059555 0.008421995013059555
	+4.25 0.25 0.25 3.46E-4 9.219544457292888E-4 9.219544457292888E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d05-x01-y02
	+Path=/REF/LHCB_2014_I1262703/d05-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+2.25 0.25 0.25 0.408 0.015520631430454112 0.015520631430454112
	+2.75 0.25 0.25 0.844 0.02279824554653274 0.02279824554653274
	+3.25 0.25 0.25 0.63 0.01927615106809448 0.01927615106809448
	+3.75 0.25 0.25 0.11674 0.006293647591023825 0.006293647591023825
	+4.25 0.25 0.25 9.66E-4 0.0014795945390545346 0.0014795945390545346
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d06-x01-y01
	+Path=/REF/LHCB_2014_I1262703/d06-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 5.0 5.0 0.00692 0.001370000203520058 0.001370000203520058
	+13.75 3.75 3.75 0.014267 0.0019199995999741484 0.0019199995999741484
	+21.25 3.75 3.75 0.021867 0.002413333267333793 0.002413333267333793
	+30.0 5.0 5.0 0.0239 0.0017499998844014246 0.0017499998844014246
	+42.5 7.5 7.5 0.015267 0.0012333298468714686 0.0012333298468714686
	+75.0 25.0 25.0 0.00382 4.219996864167555E-4 4.219996864167555E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d06-x01-y02
	+Path=/REF/LHCB_2014_I1262703/d06-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+5.0 5.0 5.0 0.018 0.0022200043356716674 0.0022200043356716674
	+13.75 3.75 3.75 0.03186667 0.0015200019273017022 0.0015200019273017022
	+21.25 3.75 3.75 0.02666667 0.001066667025554034 0.001066667025554034
	+30.0 5.0 5.0 0.017 9.499997319168043E-4 9.499997319168043E-4
	+42.5 7.5 7.5 0.008266667 6.399995607638258E-4 6.399995607638258E-4
	+75.0 25.0 25.0 0.0018 1.5600025581209796E-4 1.5600025581209796E-4
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d07-x01-y01
	+Path=/REF/LHCB_2014_I1262703/d07-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.785 0.785 0.785 0.06557184 0.006287892948049052 0.006287892948049052
	+1.83 0.26 0.2599999999999998 0.1401837 0.0165240845772699 0.0165240845772699
	+2.355 0.2650000000000001 0.2650000000000001 0.3208564 0.018086369532830517 0.018086369532830517
	+2.88 0.2599999999999998 0.26000000000000023 1.250958 0.042207896343338415 0.042207896343338415
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d07-x01-y02
	+Path=/REF/LHCB_2014_I1262703/d07-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.785 0.785 0.785 0.100586 0.009230982777028674 0.009230982777028674
	+1.83 0.26 0.2599999999999998 0.184492 0.014209310754223794 0.014209310754223794
	+2.355 0.2650000000000001 0.2650000000000001 0.374332 0.016711299877211826 0.016711299877211826
	+2.88 0.2599999999999998 0.26000000000000023 1.05042 0.04182595641811434 0.04182595641811434
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d08-x01-y01
	+Path=/REF/LHCB_2014_I1262703/d08-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-1.75 0.75 0.75 0.0378 0.004826668614375758 0.004826668614375758
	+-0.75 0.25 0.25 0.23 0.017859984112534928 0.017859984112534928
	+-0.25 0.25 0.25 0.458 0.02319999099698101 0.02319999099698101
	+0.25 0.25 0.25 0.626 0.025000024669787825 0.025000024669787825
	+0.75 0.25 0.25 0.418 0.024999973709786176 0.024999973709786176
	+1.75 0.75 0.75 0.0516667 0.0045333294645106045 0.0045333294645106045
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/LHCB_2014_I1262703/d08-x01-y02
	+Path=/REF/LHCB_2014_I1262703/d08-x01-y02
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+-1.75 0.75 0.75 0.0573333 0.004400001261931637 0.004400001261931637
	+-0.75 0.25 0.25 0.256 0.017699957161767373 0.017699957161767373
	+-0.25 0.25 0.25 0.446 0.019999995354739463 0.019999995354739463
	+0.25 0.25 0.25 0.554 0.0215999700428033 0.0215999700428033
	+0.75 0.25 0.25 0.406 0.01851998249454896 0.01851998249454896
	+1.75 0.75 0.75 0.055 0.0038866616978841884 0.0038866616978841884
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/Makefile.am b/data/refdata/Makefile.am
	--- a/data/refdata/Makefile.am
	+++ b/data/refdata/Makefile.am
	@@ -1,303 +1,346 @@
	dist_pkgdata_DATA = \
	ALEPH_1991_S2435284.yoda \
	+ ALEPH_1995_I382179.yoda \
	ALEPH_1996_S3486095.yoda \
	ALEPH_1996_S3196992.yoda \
	ALEPH_1999_S4193598.yoda \
	ALEPH_2001_S4656318.yoda \
	ALEPH_2002_S4823664.yoda \
	ALEPH_2004_S5765862.yoda \
	ALICE_2010_S8624100.yoda \
	ALICE_2010_S8625980.yoda \
	ALICE_2010_S8706239.yoda \
	ALICE_2011_S8909580.yoda \
	ALICE_2011_S8945144.yoda \
	+ ALICE_2012_I1116147.yoda \
	ALICE_2012_I1181770.yoda \
	ALICE_2014_I1300380.yoda \
	ALICE_2015_I1357424.yoda \
	ARGUS_1993_S2653028.yoda \
	ARGUS_1993_S2669951.yoda \
	ARGUS_1993_S2789213.yoda \
	ATLAS_2010_S8591806.yoda \
	ATLAS_2010_S8817804.yoda \
	ATLAS_2010_S8894728.yoda \
	ATLAS_2010_S8914702.yoda \
	ATLAS_2010_S8918562.yoda \
	ATLAS_2010_S8919674.yoda \
	ATLAS_2011_S8924791.yoda \
	ATLAS_2011_S8971293.yoda \
	ATLAS_2011_S8994773.yoda \
	ATLAS_2011_S9002537.yoda \
	ATLAS_2010_CONF_2010_049.yoda \
	ATLAS_2011_S9120807.yoda \
	ATLAS_2011_S9126244.yoda \
	ATLAS_2011_S9128077.yoda \
	ATLAS_2011_S9131140.yoda \
	+ ATLAS_2011_S9035664.yoda \
	ATLAS_2011_I894867.yoda \
	- ATLAS_2011_S9035664.yoda \
	+ ATLAS_2011_I928289_W.yoda \
	+ ATLAS_2011_I928289_Z.yoda \
	ATLAS_2011_I919017.yoda \
	ATLAS_2011_I921594.yoda \
	ATLAS_2011_I925932.yoda \
	ATLAS_2011_I926145.yoda \
	+ ATLAS_2011_I929691.yoda \
	ATLAS_2011_I930220.yoda \
	ATLAS_2011_I944826.yoda \
	ATLAS_2011_I945498.yoda \
	ATLAS_2011_I954993.yoda \
	ATLAS_2011_S9225137.yoda \
	ATLAS_2011_S9212183.yoda \
	ATLAS_2012_I1082936.yoda \
	ATLAS_2012_I1083318.yoda \
	ATLAS_2012_I1084540.yoda \
	ATLAS_2012_I1091481.yoda \
	ATLAS_2012_I1093734.yoda \
	ATLAS_2012_I1093738.yoda \
	ATLAS_2012_I1094061.yoda \
	ATLAS_2012_I1094564.yoda \
	ATLAS_2012_I1094568.yoda \
	ATLAS_2012_I943401.yoda \
	ATLAS_2012_I1082009.yoda \
	ATLAS_2012_I1118269.yoda \
	ATLAS_2012_I1119557.yoda \
	ATLAS_2012_I1124167.yoda \
	ATLAS_2012_I1125575.yoda \
	ATLAS_2012_I1183818.yoda \
	ATLAS_2012_I1188891.yoda \
	ATLAS_2012_I1199269.yoda \
	ATLAS_2012_CONF_2012_001.yoda \
	ATLAS_2012_I1203852.yoda \
	ATLAS_2012_I1204784.yoda \
	ATLAS_2013_I1190187.yoda \
	ATLAS_2013_I1217863_W.yoda \
	ATLAS_2013_I1217863_W_EL.yoda \
	ATLAS_2013_I1217863_W_MU.yoda \
	ATLAS_2013_I1217863_Z.yoda \
	ATLAS_2013_I1217863_Z_EL.yoda \
	ATLAS_2013_I1217863_Z_MU.yoda \
	ATLAS_2013_I1217867.yoda \
	ATLAS_2013_I1219109.yoda \
	ATLAS_2013_I1219109_EL.yoda \
	ATLAS_2013_I1219109_MU.yoda \
	ATLAS_2013_I1230812.yoda \
	ATLAS_2013_I1230812_EL.yoda \
	ATLAS_2013_I1230812_MU.yoda \
	ATLAS_2013_I1243871.yoda \
	ATLAS_2013_I1263495.yoda \
	+ ATLAS_2013_I1216670.yoda \
	+ ATLAS_2013_I1244522.yoda \
	+ ATLAS_2014_I1282447.yoda \
	+ ATLAS_2014_I1298023.yoda \
	+ ATLAS_2014_I1319490.yoda \
	+ ATLAS_2014_I1319490_EL.yoda \
	+ ATLAS_2014_I1319490_MU.yoda \
	+ ATLAS_2014_I1326641.yoda \
	ATLAS_2014_I1268975.yoda \
	ATLAS_2014_I1279489.yoda \
	ATLAS_2014_I1282441.yoda \
	ATLAS_2014_I1298811.yoda \
	ATLAS_2014_I1304688.yoda \
	ATLAS_2014_I1307756.yoda \
	ATLAS_2014_I1306294.yoda \
	ATLAS_2014_I1306294_EL.yoda \
	ATLAS_2014_I1306294_MU.yoda \
	ATLAS_2014_I1315949.yoda \
	ATLAS_2014_I1325553.yoda \
	ATLAS_2014_I1300647.yoda \
	ATLAS_2014_I1288706.yoda \
	ATLAS_2014_I1307243.yoda \
	ATLAS_2014_I1312627.yoda \
	ATLAS_2014_I1312627_EL.yoda \
	ATLAS_2014_I1312627_MU.yoda \
	ATLAS_2014_I1306615.yoda \
	+ ATLAS_2015_I1393758.yoda \
	ATLAS_2015_I1364361.yoda \
	+ ATLAS_2015_I1351916.yoda \
	+ ATLAS_2015_I1351916_EL.yoda \
	+ ATLAS_2015_I1351916_MU.yoda \
	ATLAS_2015_I1345452.yoda \
	- ATLAS_2013_I1216670.yoda \
	- ATLAS_2013_I1244522.yoda \
	- ATLAS_2011_I928289_W.yoda \
	- ATLAS_2011_I928289_Z.yoda \
	- ATLAS_2014_I1282447.yoda \
	- ATLAS_2014_I1298023.yoda \
	- ATLAS_2014_I1319490.yoda \
	- ATLAS_2014_I1319490_EL.yoda \
	- ATLAS_2014_I1319490_MU.yoda \
	- ATLAS_2014_I1326641.yoda \
	ATLAS_2015_I1387176.yoda \
	ATLAS_2015_I1376945.yoda \
	+ ATLAS_2015_I1390114.yoda \
	ATLAS_2015_I1394679.yoda \
	+ ATLAS_2015_I1397635.yoda \
	+ ATLAS_2015_I1397637.yoda \
	ATLAS_2015_CONF_2015_041.yoda \
	ATLAS_2015_CONF_2015_041_EL.yoda \
	ATLAS_2015_CONF_2015_041_MU.yoda \
	+ ATLAS_2015_I1408516.yoda \
	+ ATLAS_2015_I1408516_EL.yoda \
	+ ATLAS_2015_I1408516_MU.yoda \
	+ ATLAS_2015_I1404878.yoda \
	+ ATLAS_2016_I1419070.yoda \
	+ ATLAS_2016_I1419652.yoda \
	ATLAS_2016_I1424838.yoda \
	+ ATLAS_2016_I1426695.yoda \
	+ ATLAS_2016_I1444991.yoda \
	+ ATLAS_2016_I1457605.yoda \
	+ ATLAS_2016_I1468168.yoda \
	+ ATLAS_2016_I1467230.yoda \
	+ ATLAS_2016_I1467454.yoda \
	+ ATLAS_2016_I1468167.yoda \
	+ ATLAS_2016_I1479760.yoda \
	BABAR_2003_I593379.yoda \
	BABAR_2005_S6181155.yoda \
	BABAR_2006_S6511112.yoda \
	BABAR_2007_S6895344.yoda \
	BABAR_2007_S7266081.yoda \
	+ BABAR_2013_I1116411.yoda \
	+ BABAR_2013_I1238276.yoda \
	+ BABAR_2015_I1334693.yoda \
	BELLE_2001_S4598261.yoda \
	BELLE_2008_I786560.yoda \
	+ BELLE_2011_I878990.yoda \
	BELLE_2013_I1216515.yoda \
	- BABAR_2013_I1238276.yoda \
	+ BELLE_2013_I1238273.yoda \
	+ BELLE_2015_I1397632.yoda \
	CLEO_2001_S4557530.yoda \
	CLEO_2004_S5809304.yoda \
	CMS_2010_S8547297.yoda \
	CMS_2010_S8656010.yoda \
	CMS_2011_S8884919.yoda \
	CMS_2011_S8941262.yoda \
	CMS_2011_S8950903.yoda \
	CMS_2011_S8957746.yoda \
	CMS_2011_S8968497.yoda \
	CMS_2011_S8973270.yoda \
	CMS_2011_S8978280.yoda \
	CMS_2011_S9086218.yoda \
	CMS_2011_S9088458.yoda \
	CMS_2011_S9120041.yoda \
	CMS_2011_S9215166.yoda \
	CMS_2012_I941555.yoda \
	CMS_2011_I954992.yoda \
	CMS_2012_I1087342.yoda \
	CMS_2012_I1090423.yoda \
	CMS_2012_I1102908.yoda \
	CMS_2012_I1107658.yoda \
	CMS_2012_I1184941.yoda \
	CMS_2012_I1193338.yoda \
	+ CMS_2012_I1298807.yoda \
	CMS_2013_I1122847.yoda \
	CMS_2013_I1208923.yoda \
	CMS_2013_I1209721.yoda \
	CMS_2013_I1218372.yoda \
	CMS_2013_I1224539_DIJET.yoda \
	CMS_2013_I1224539_WJET.yoda \
	CMS_2013_I1224539_ZJET.yoda \
	CMS_2013_I1256943.yoda \
	CMS_2013_I1258128.yoda \
	CMS_2013_I1261026.yoda \
	CMS_2013_I1265659.yoda \
	CMS_2013_I1272853.yoda \
	CMS_2013_I1273574.yoda \
	+ CMSTOTEM_2014_I1294140.yoda \
	CMS_2014_I1298810.yoda \
	CMS_2014_I1303894.yoda \
	+ CMS_2014_I1305624.yoda \
	CMS_2015_I1310737.yoda \
	+ CMS_2015_I1327224.yoda \
	+ CMS_2015_I1346843.yoda \
	CMS_2015_I1356998.yoda \
	CMS_2015_I1370682.yoda \
	CMS_2015_I1384119.yoda \
	CMS_2015_I1385107.yoda \
	+ CMS_2015_I1397174.yoda \
	+ CMS_2016_I1459051.yoda \
	+ CMS_2016_I1473674.yoda \
	+ CMS_2010_PAS_QCD_10_024.yoda \
	CMS_2012_PAS_QCD_11_010.yoda \
	- CMS_QCD_10_024.yoda \
	- CMS_2015_I1346843.yoda \
	- CMS_2015_I1327224.yoda \
	- CMSTOTEM_2014_I1294140.yoda \
	- TOTEM_2014_I1328627.yoda \
	+ CMS_2012_PAS_FSQ_12_020.yoda \
	LHCB_2010_S8758301.yoda \
	LHCB_2010_I867355.yoda \
	LHCB_2011_I917009.yoda \
	LHCB_2011_I919315.yoda \
	LHCB_2012_I1119400.yoda \
	LHCB_2012_I1208102.yoda \
	LHCB_2013_I1208105.yoda \
	LHCB_2013_I1218996.yoda \
	+ LHCB_2014_I1262703.yoda \
	LHCB_2014_I1281685.yoda \
	LHCB_2015_I1333223.yoda \
	LHCF_2012_I1115479.yoda \
	DELPHI_1994_S3021912.yoda \
	DELPHI_1995_S3137023.yoda \
	DELPHI_1996_S3430090.yoda \
	DELPHI_1999_S3960137.yoda \
	DELPHI_2000_S4328825.yoda \
	DELPHI_2002_069_CONF_603.yoda \
	+ DELPHI_2011_I890503.yoda \
	+ L3_1992_I336180.yoda \
	+ L3_2004_I652683.yoda \
	OPAL_1993_S2692198.yoda \
	+ OPAL_1993_I342766.yoda \
	OPAL_1994_S2927284.yoda \
	OPAL_1995_S3198391.yoda \
	OPAL_1996_S3257789.yoda \
	OPAL_1997_S3396100.yoda \
	OPAL_1997_S3608263.yoda \
	OPAL_1998_S3702294.yoda \
	OPAL_1998_S3780481.yoda \
	OPAL_1998_S3749908.yoda \
	OPAL_2000_S4418603.yoda \
	OPAL_2001_S4553896.yoda \
	OPAL_2002_S5361494.yoda \
	+ OPAL_2003_I599181.yoda \
	OPAL_2004_S6132243.yoda \
	JADE_OPAL_2000_S4300807.yoda \
	JADE_1998_S3612880.yoda \
	TASSO_1990_S2148048.yoda \
	H1_1994_S2919893.yoda \
	H1_1995_S3167097.yoda \
	H1_2000_S4129130.yoda \
	H1_2007_S7223935.yoda \
	ZEUS_2001_S4815815.yoda \
	PHENIX_2003_S5538505.yoda \
	STAR_2006_S6500200.yoda \
	STAR_2006_S6860818.yoda \
	STAR_2006_S6870392.yoda \
	STAR_2008_S7993412.yoda \
	STAR_2009_UE_HELEN.yoda \
	BRAHMS_2007_S7052448.yoda \
	UA1_1990_S2044935.yoda \
	UA5_1982_S875503.yoda \
	UA5_1986_S1583476.yoda \
	UA5_1989_S1926373.yoda \
	UA5_1988_S1867512.yoda \
	UA5_1987_S1640666.yoda \
	CDF_1988_S1865951.yoda \
	CDF_1990_S2089246.yoda \
	CDF_1993_S2742446.yoda \
	CDF_1994_S2952106.yoda \
	CDF_1996_S3108457.yoda \
	CDF_1996_S3349578.yoda \
	CDF_1996_S3418421.yoda \
	CDF_1997_S3541940.yoda \
	CDF_1998_S3618439.yoda \
	CDF_2000_S4155203.yoda \
	CDF_2000_S4266730.yoda \
	CDF_2001_S4517016.yoda \
	CDF_2001_S4563131.yoda \
	CDF_2001_S4751469.yoda \
	CDF_2002_S4796047.yoda \
	CDF_2004_S5839831.yoda \
	CDF_2005_S6080774.yoda \
	CDF_2005_S6217184.yoda \
	CDF_2006_S6450792.yoda \
	CDF_2006_S6653332.yoda \
	CDF_2007_S7057202.yoda \
	CDF_2008_S7541902.yoda \
	CDF_2008_S7554427.yoda \
	CDF_2008_S7540469.yoda \
	CDF_2008_S7782535.yoda \
	CDF_2008_S7828950.yoda \
	CDF_2008_S8093652.yoda \
	CDF_2008_S8095620.yoda \
	CDF_2009_S8233977.yoda \
	CDF_2009_NOTE_9936.yoda \
	- CDF_2009_S8383952.yoda \
	+ CDF_2009_I856131.yoda \
	CDF_2009_S8436959.yoda \
	CDF_2010_S8591881_DY.yoda \
	CDF_2010_S8591881_QCD.yoda \
	CDF_2012_NOTE10874.yoda \
	CDF_2012_I1124333.yoda \
	+ CDF_2015_1388868.yoda \
	+ D0_1995_I398175.yoda \
	D0_1996_S3214044.yoda \
	D0_1996_S3324664.yoda \
	D0_2000_S4480767.yoda \
	D0_2000_I499943.yoda \
	D0_2001_S4674421.yoda \
	D0_2004_S5992206.yoda \
	D0_2006_S6438750.yoda \
	D0_2007_S7075677.yoda \
	D0_2008_S6879055.yoda \
	D0_2008_S7554427.yoda \
	D0_2008_S7662670.yoda \
	D0_2008_S7719523.yoda \
	D0_2008_S7837160.yoda \
	D0_2008_S7863608.yoda \
	D0_2009_S8202443.yoda \
	D0_2009_S8320160.yoda \
	D0_2009_S8349509.yoda \
	D0_2010_S8566488.yoda \
	D0_2010_S8570965.yoda \
	D0_2010_S8671338.yoda \
	D0_2010_S8821313.yoda \
	D0_2011_I895662.yoda \
	D0_2015_I1324946.yoda \
	D0_2000_I503361.yoda \
	E735_1992_S2485869.yoda \
	E735_1993_S2896508.yoda \
	E735_1998_S3905616.yoda \
	SFM_1984_S1178091.yoda \
	SLD_1996_S3398250.yoda \
	SLD_1999_S3743934.yoda \
	SLD_2002_S4869273.yoda \
	SLD_2004_S5693039.yoda \
	STAR_2008_S7869363.yoda \
	TOTEM_2012_I1115294.yoda \
	- TOTEM_2012_002.yoda \
	+ TOTEM_2012_I1220862.yoda \
	+ TOTEM_2014_I1328627.yoda \
	PDG_HADRON_MULTIPLICITIES.yoda \
	PDG_HADRON_MULTIPLICITIES_RATIOS.yoda \
	PDG_TAUS.yoda
	diff --git a/data/refdata/OPAL_1993_I342766.yoda b/data/refdata/OPAL_1993_I342766.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/OPAL_1993_I342766.yoda
	@@ -0,0 +1,21 @@
	+# BEGIN YODA_SCATTER2D /REF/OPAL_1993_I342766/d01-x01-y01
	+Path=/REF/OPAL_1993_I342766/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.037 0.017 0.027 8.2 1.6 1.6
	+0.076 0.012 0.014 3.3 0.7 0.7
	+0.11 0.020 0.023 2.3 0.6 0.6
	+0.154 0.021 0.023 1.7 0.4 0.4
	+0.221 0.044 0.054 0.89 0.23 0.23
	+0.417 0.142 0.462 0.11 0.03 0.03
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/OPAL_1993_I342766/d02-x01-y01
	+Path=/REF/OPAL_1993_I342766/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+91.2 0.2 0.2 0.72 0.08246211251235322 0.08246211251235322
	+# END YODA_SCATTER2D
	+
	+
	diff --git a/data/refdata/OPAL_2003_I599181.yoda b/data/refdata/OPAL_2003_I599181.yoda
	new file mode 100644
	--- /dev/null
	+++ b/data/refdata/OPAL_2003_I599181.yoda
	@@ -0,0 +1,33 @@
	+# BEGIN YODA_SCATTER2D /REF/OPAL_2003_I599181/d01-x01-y01
	+Path=/REF/OPAL_2003_I599181/d01-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1225 0.0225 0.0225 0.0315555555556 0.00253372316689 0.00318173801406
	+0.1675 0.0225 0.0225 0.116888888889 0.010027123709 0.0115491435202
	+0.2125 0.0225 0.0225 0.174666666667 0.0139079868696 0.0187049871214
	+0.2575 0.0225 0.0225 0.219333333333 0.0107703296143 0.0214867171142
	+0.3025 0.0225 0.0225 0.268444444444 0.01093188789 0.0221030135926
	+0.3475 0.0225 0.0225 0.333777777778 0.0179230178235 0.0249542791798
	+0.3925 0.0225 0.0225 0.421111111111 0.0190256487049 0.0319637139949
	+0.4375 0.0225 0.0225 0.524 0.0197777777778 0.0361649171791
	+0.4825 0.0225 0.0225 0.630888888889 0.0302173198638 0.0272836042657
	+0.5275 0.0225 0.0225 0.747555555556 0.0605020150669 0.0265813449854
	+0.5725 0.0225 0.0225 0.923111111111 0.084983368017 0.0502502380069
	+0.6175 0.0225 0.0225 1.21533333333 0.0762740348681 0.0565288083444
	+0.6625 0.0225 0.0225 1.62955555556 0.0566126103825 0.0539981709795
	+0.7075 0.0225 0.0225 2.10888888889 0.0509780877642 0.0602029489454
	+0.7525 0.0225 0.0225 2.63177777778 0.0505930264067 0.0503861631016
	+0.7975 0.0225 0.0225 3.11266666667 0.191725240647 0.0608523815941
	+0.8425 0.0225 0.0225 3.20555555556 0.306078098643 0.126727081109
	+0.8875 0.0225 0.0225 2.504 0.125279933463 0.0852328691017
	+0.9325 0.0225 0.0225 1.216 0.234676977888 0.0875143727173
	+0.9775 0.0225 0.0225 0.207333333333 0.0716052277559 0.0274631065654
	+# END YODA_SCATTER2D
	+
	+
	+# BEGIN YODA_SCATTER2D /REF/OPAL_2003_I599181/d02-x01-y01
	+Path=/REF/OPAL_2003_I599181/d02-x01-y01
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.1225 0.0225 0.0225 0.79193 0.004123 0.003667
	+# END YODA_SCATTER2D
	diff --git a/data/refdata/SLD_2002_S4869273.yoda b/data/refdata/SLD_2002_S4869273.yoda
	--- a/data/refdata/SLD_2002_S4869273.yoda
	+++ b/data/refdata/SLD_2002_S4869273.yoda
	@@ -1,30 +1,62 @@
	BEGIN YODA_SCATTER2D /REF/SLD_2002_S4869273/d01-x01-y01
	+#/REF/SLD_2002_I582951/d01-x01-y01
	IsRef=1
	Path=/REF/SLD_2002_S4869273/d01-x01-y01
	Title=
	Type=Scatter2D
	-# xval xerr- xerr+ yval yerr- yerr+
	-1.400000e-01 2.000000e-02 2.000000e-02 1.100000e-01 3.244996e-02 3.244996e-02
	-1.800000e-01 2.000000e-02 2.000000e-02 1.880000e-01 4.330127e-02 4.330127e-02
	-2.200000e-01 2.000000e-02 2.000000e-02 2.040000e-01 3.505710e-02 3.505710e-02
	-2.600000e-01 2.000000e-02 2.000000e-02 2.130000e-01 2.988311e-02 2.988311e-02
	-3.000000e-01 2.000000e-02 2.000000e-02 2.680000e-01 3.559494e-02 3.559494e-02
	-3.400000e-01 2.000000e-02 2.000000e-02 3.400000e-01 3.921734e-02 3.921734e-02
	-3.800000e-01 2.000000e-02 2.000000e-02 3.980000e-01 4.016217e-02 4.016217e-02
	-4.200000e-01 2.000000e-02 2.000000e-02 5.050000e-01 4.618441e-02 4.618441e-02
	-4.600000e-01 2.000000e-02 2.000000e-02 5.870000e-01 4.705316e-02 4.705316e-02
	-5.000000e-01 2.000000e-02 2.000000e-02 6.770000e-01 4.809366e-02 4.809366e-02
	-5.400000e-01 2.000000e-02 2.000000e-02 7.960000e-01 5.829237e-02 5.829237e-02
	-5.800000e-01 2.000000e-02 2.000000e-02 9.910000e-01 7.851115e-02 7.851115e-02
	-6.200000e-01 2.000000e-02 2.000000e-02 1.241000e+00 9.267146e-02 9.267146e-02
	-6.600000e-01 2.000000e-02 2.000000e-02 1.622000e+00 9.417006e-02 9.417006e-02
	-7.000000e-01 2.000000e-02 2.000000e-02 2.092000e+00 9.549869e-02 9.549869e-02
	-7.400000e-01 2.000000e-02 2.000000e-02 2.671000e+00 1.287517e-01 1.287517e-01
	-7.800000e-01 2.000000e-02 2.000000e-02 3.102000e+00 1.883003e-01 1.883003e-01
	-8.200000e-01 2.000000e-02 2.000000e-02 3.290000e+00 2.444954e-01 2.444954e-01
	-8.600000e-01 2.000000e-02 2.000000e-02 2.953000e+00 1.902551e-01 1.902551e-01
	-9.000000e-01 2.000000e-02 2.000000e-02 1.897000e+00 1.668712e-01 1.668712e-01
	-9.400000e-01 2.000000e-02 2.000000e-02 7.530000e-01 2.153834e-01 2.153834e-01
	-9.800000e-01 2.000000e-02 2.000000e-02 9.000000e-02 6.211280e-02 6.211280e-02
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.14 0.020000000000000018 0.01999999999999999 0.116 0.030675723300355933 0.030675723300355933
	+0.18 0.01999999999999999 0.020000000000000018 0.198 0.03713488925525428 0.03713488925525428
	+0.22 0.01999999999999999 0.01999999999999999 0.247 0.03056141357987225 0.03056141357987225
	+0.26 0.020000000000000018 0.020000000000000018 0.264 0.028982753492378877 0.028982753492378877
	+0.30000000000000004 0.020000000000000018 0.019999999999999962 0.308 0.03217141588429082 0.03217141588429082
	+0.33999999999999997 0.019999999999999962 0.020000000000000018 0.37 0.03290896534380867 0.03290896534380867
	+0.38 0.020000000000000018 0.020000000000000018 0.426 0.03471310991541956 0.03471310991541956
	+0.42000000000000004 0.020000000000000018 0.019999999999999962 0.501 0.03841874542459709 0.03841874542459709
	+0.45999999999999996 0.019999999999999962 0.020000000000000018 0.577 0.04092676385936225 0.04092676385936225
	+0.5 0.020000000000000018 0.020000000000000018 0.685 0.041785164831552354 0.041785164831552354
	+0.54 0.020000000000000018 0.020000000000000018 0.833 0.05281098370604358 0.05281098370604358
	+0.5800000000000001 0.020000000000000018 0.019999999999999907 1.055 0.0740607858451421 0.0740607858451421
	+0.62 0.020000000000000018 0.020000000000000018 1.311 0.08903931715820827 0.08903931715820827
	+0.66 0.020000000000000018 0.020000000000000018 1.667 0.08789197915623473 0.08789197915623473
	+0.7 0.019999999999999907 0.020000000000000018 2.08 0.08411896337925237 0.08411896337925237
	+0.74 0.020000000000000018 0.020000000000000018 2.566 0.1162626337221035 0.1162626337221035
	+0.78 0.020000000000000018 0.020000000000000018 2.934 0.17803651310896876 0.17803651310896876
	+0.8200000000000001 0.020000000000000018 0.019999999999999907 3.104 0.23494893062110328 0.23494893062110328
	+0.86 0.020000000000000018 0.020000000000000018 2.856 0.179404570733301 0.179404570733301
	+0.9 0.020000000000000018 0.020000000000000018 1.954 0.16153637361288015 0.16153637361288015
	+0.94 0.019999999999999907 0.020000000000000018 0.841 0.21500232556881796 0.21500232556881796
	+0.98 0.020000000000000018 0.020000000000000018 0.108 0.06229767250869008 0.06229767250869008
	END YODA_SCATTER2D

	+
	+BEGIN YODA_SCATTER2D /REF/SLD_2002_S4869273/d02-x01-y01
	+#/REF/SLD_2002_I582951/d02-x01-y01
	+IsRef=1
	+Path=/REF/SLD_2002_S4869273/d02-x01-y01
	+Title=
	+Type=Scatter2D
	+# xval xerr- xerr+ yval yerr- yerr+
	+0.14 0.020000000000000018 0.01999999999999999 0.11 0.03244996147917591 0.03244996147917591
	+0.18 0.01999999999999999 0.020000000000000018 0.188 0.04330127018922194 0.04330127018922194
	+0.22 0.01999999999999999 0.01999999999999999 0.204 0.03505709628591621 0.03505709628591621
	+0.26 0.020000000000000018 0.020000000000000018 0.213 0.02988310559496787 0.02988310559496787
	+0.30000000000000004 0.020000000000000018 0.019999999999999962 0.268 0.03559494346111537 0.03559494346111537
	+0.33999999999999997 0.019999999999999962 0.020000000000000018 0.34 0.03921734310225515 0.03921734310225515
	+0.38 0.020000000000000018 0.020000000000000018 0.398 0.0401621712560464 0.0401621712560464
	+0.42000000000000004 0.020000000000000018 0.019999999999999962 0.505 0.04618441295502196 0.04618441295502196
	+0.45999999999999996 0.019999999999999962 0.020000000000000018 0.587 0.04705316142407437 0.04705316142407437
	+0.5 0.020000000000000018 0.020000000000000018 0.677 0.048093658625644194 0.048093658625644194
	+0.54 0.020000000000000018 0.020000000000000018 0.796 0.058292366567158686 0.058292366567158686
	+0.5800000000000001 0.020000000000000018 0.019999999999999907 0.991 0.07851114570556209 0.07851114570556209
	+0.62 0.020000000000000018 0.020000000000000018 1.241 0.09267146270562476 0.09267146270562476
	+0.66 0.020000000000000018 0.020000000000000018 1.622 0.09417005893594843 0.09417005893594843
	+0.7 0.019999999999999907 0.020000000000000018 2.092 0.09549869109050657 0.09549869109050657
	+0.74 0.020000000000000018 0.020000000000000018 2.671 0.1287516990179159 0.1287516990179159
	+0.78 0.020000000000000018 0.020000000000000018 3.102 0.18830029208686852 0.18830029208686852
	+0.8200000000000001 0.020000000000000018 0.019999999999999907 3.29 0.24449539872971027 0.24449539872971027
	+0.86 0.020000000000000018 0.020000000000000018 2.953 0.19025509191609036 0.19025509191609036
	+0.9 0.020000000000000018 0.020000000000000018 1.897 0.16687120782208056 0.16687120782208056
	+0.94 0.019999999999999907 0.020000000000000018 0.753 0.21538337911733113 0.21538337911733113
	+0.98 0.020000000000000018 0.020000000000000018 0.09 0.06211280061307814 0.06211280061307814
	+END YODA_SCATTER2D
	diff --git a/data/refdata/TOTEM_2012_002.yoda b/data/refdata/TOTEM_2012_I1220862.yoda
	rename from data/refdata/TOTEM_2012_002.yoda
	rename to data/refdata/TOTEM_2012_I1220862.yoda
	diff --git a/doc/Makefile.am b/doc/Makefile.am
	--- a/doc/Makefile.am
	+++ b/doc/Makefile.am
	@@ -1,106 +1,105 @@
	dist_noinst_SCRIPTS = mk-analysis-html mk-analysis-latex

	LATEXSUBSOURCES = preamble.tex intro.tex gettingstarted.tex writinganalyses.tex agilerunmc.tex acknowledgements.tex
	DOCSOURCES = compare-histos.txt slip.eps thinker.eps cone.eps bend.eps \
	h-physrev3.bst hepnames.sty JHEP3.cls JHEP.bst make-plots.txt rivet-manual.tex \
	$(LATEXSUBSOURCES) heppennames.sty hepnicenames.sty hepparticles.sty maybemath.sty \
	hepunits.sty underscore.sty microtype.sty

	-EXTRA_DIST = $(DOCSOURCES)
	+EXTRA_DIST = $(DOCSOURCES) refs.bib
	DOCS =

	if ENABLE_PDFMANUAL

	if ENABLE_PYEXT
	DOCS += analyses.html
	analyses.html: $(top_srcdir)/src/Analyses mk-analysis-html
	LD_LIBRARY_PATH=$(top_builddir)/src/.libs:$(YAML_CPPLIBPATH):$(FASTJETLIBPATH):$(HEPMCLIBPATH):$(YODALIBPATH):$(LD_LIBRARY_PATH) \
	DYLD_LIBRARY_PATH=$(top_builddir)/src/.libs:$(YAML_CPPLIBPATH):$(FASTJETLIBPATH):$(HEPMCLIBPATH):$(YODALIBPATH):$(DYLD_LIBRARY_PATH) \
	PYTHONPATH=$(YODA_PYTHONPATH):$(RIVET_PYTHONPATH):$(PYTHONPATH) \
	$(PYTHON) mk-analysis-html
	endif


	if WITH_PDFLATEX

	DOCS += rivet-manual.pdf
	-EXTRA_DIST += refs.bib

	if ENABLE_PYEXT
	analyses.bib analyses.tex: $(top_srcdir)/src/Analyses $(top_srcdir)/data/plotinfo $(top_srcdir)/data/anainfo mk-analysis-latex
	LD_LIBRARY_PATH=$(top_builddir)/src/.libs:$(YAML_CPPLIBPATH):$(FASTJETLIBPATH):$(HEPMCLIBPATH):$(YODALIBPATH):$(LD_LIBRARY_PATH) \
	DYLD_LIBRARY_PATH=$(top_builddir)/src/.libs:$(YAML_CPPLIBPATH):$(FASTJETLIBPATH):$(HEPMCLIBPATH):$(YODALIBPATH):$(DYLD_LIBRARY_PATH) \
	PYTHONPATH=$(YODA_PYTHONPATH):$(RIVET_PYTHONPATH):$(PYTHONPATH) \
	$(PYTHON) mk-analysis-latex
	else
	analyses.bib analyses.tex:
	> analyses.tex
	> analyses.bib
	endif

	LATEX = pdflatex --interaction=batchmode
	RERUN = "(There were undefined references\|Rerun to get (cross-references\|the bars) right)"
	RERUNBIB = "No file.\.bbl\|Citation.undefined"
	MAKEIDX = "^[^%]*\\makeindex"

	rivet-manual.pdf : rivet-manual.tex $(LATEXSUBSOURCES) analyses.tex refs.bib analyses.bib
	$(LATEX) $<; true
	egrep -c $(RERUNBIB) rivet-manual.log && (bibtex rivet-manual && cp rivet-manual.toc rivet-manual.toc.bak && $(LATEX) $<); true
	for i in `seq 5`; do if egrep $(RERUN) rivet-manual.log; then echo "LaTeX re-run $i"; cp rivet-manual.toc rivet-manual.toc.bak; $(LATEX) $<; else break; fi; done; true
	if cmp -s rivet-manual.toc rivet-manual.toc.bak; then true; else $(LATEX) $<; true; fi
	rm -f rivet-manual.toc.bak; true

	paper.pdf : paper.tex $(LATEXSUBSOURCES) analyses.tex refs.bib analyses.bib
	$(LATEX) $<; true
	egrep -c $(RERUNBIB) paper.log && (bibtex paper && cp paper.toc paper.toc.bak && $(LATEX) $<); true
	for i in `seq 5`; do if egrep $(RERUN) paper.log; then echo "LaTeX re-run $i"; cp paper.toc paper.toc.bak; $(LATEX) $<; else break; fi; done; true
	if cmp -s paper.toc paper.toc.bak; then true; else $(LATEX) $<; true; fi
	rm -f paper.toc.bak; true

	endif
	endif


	if WITH_ASCIIDOC

	DOCS += compare-histos.html make-plots.html
	EXTRA_DIST += compare-histos.html make-plots.html

	compare-histos.html: compare-histos.txt
	asciidoc -a toc compare-histos.txt

	make-plots.html: make-plots.txt
	asciidoc -a toc make-plots.txt

	endif


	################


	.PHONY = all doc upload arxivtar

	doc: $(DOCS)
	@true

	RSH=rsync
	DEST=login.hepforge.org:rivet/public_html/
	upload: $(DOCS)
	$(RSH) $? $(DEST)

	arxivtar: $(DOCSOURCES) rivet-manual.bbl
	for i in *.png; do convert $$i $${i/.png/.eps}; done
	tar czf rivet-manual.tar.gz \
	rivet-manual.tex $(LATEXSUBSOURCES) analyses.tex refs.bib analyses.bib rivetversion.sty rivet-manual.bbl \
	hepnames.sty hepnicenames.sty hepparticles.sty heppennames.sty hepunits.sty maybemath.sty microtype.sty underscore.sty \
	bend.eps cone.eps thinker.eps slip.eps \
	h-physrev3.bst JHEP3.cls JHEP.bst

	mostlyclean-local:
	rm -rf .aux .log *.toc

	clean-local:
	rm -rf $(DOCS)

	## Install!
	pkgdata_DATA = $(DOCS)
	diff --git a/doc/diffanas.in b/doc/diffanas.in
	old mode 100644
	new mode 100755
	diff --git a/doc/gettingstarted.tex b/doc/gettingstarted.tex
	--- a/doc/gettingstarted.tex
	+++ b/doc/gettingstarted.tex
	@@ -1,523 +1,530 @@
	As with many things, Rivet may be meaningfully approached at several distinct
	levels of detail:

	\begin{itemize}
	\item The simplest, and we hope the most common, is to use the analyses which
	are already in the library to study events from a variety of generators and
	tunes: this is enormously valuable in itself and we encourage all manner of
	experimentalists and phenomenologists alike to use Rivet in this mode.
	\item A more involved level of usage is to write your own Rivet analyses ---
	this may be done without affecting the installed standard analyses by use of a
	``plugin'' system (although we encourage users who develop analyses to submit
	them to the Rivet developers for inclusion into a future release of the main
	package). This approach requires some understanding of programming within
	Rivet but you don't \emph{need} to know about exactly what the system is doing
	with the objects that you have defined.
	\item Finally, Rivet developers and people who want to do non-standard things
	with their analyses will need to know something about the messy details of
	what Rivet's infrastructure is doing behind the scenes. But you'd probably
	rather be doing some physics!
	\end{itemize}

	The current part of this manual is for the first sort of user, who wants to get
	on with studying some observables with a generator or tune, or comparing several
	such models. Since everyone will fall into this category at some point, our
	present interest is to get you to that all-important ``physics plots'' stage as
	quickly as possible. Analysis authors and Rivet service-mechanics will find the
	more detailed information that they crave in Part~\ref{part:writinganalyses}.


	\section{Quickstart}

	The point of this section is to get you up and running with Rivet as soon as
	possible. Doing this by hand may be rather frustrating, as Rivet depends on
	several external libraries --- you'll get bored downloading and building them by
	hand in the right order. Here we recommend a much simpler way --- for the
	full details of how to build Rivet by hand, please consult the Rivet Web page.


	\paragraph{Bootstrap script}

	We have written a bootstrapping
	-script which will download tarballs of Rivet, AGILe and the other required
	+script which will download tarballs of Rivet and the other required
	libraries, expand them and build them in the right order with the correct build
	flags. This is generally nicer than doing it all by hand, and virtually
	essential if you want to use the existing versions of FastJet, HepMC, generator
	libraries, and so on from CERN AFS: there are issues with these versions which
	the script works around, which you won't find easy to do yourself.

	To run the script, we recommend that you choose a personal installation
	directory, i.e.\ make a \kbd{\home/local} directory for this purpose, to
	avoid polluting your home directory with a lot of files. If you already use a
	directory of the same name, you might want to use a separate one, say
	\kbd{\home/rivetlocal}, such that if you need to delete everything in the
	installation area you can do so without difficulties.

	Now, change directory to your build area (you may also want to make this,
	e.g. \kbd{\home/build}), and download the script:\\
	-\inp{wget \url{http://rivet.hepforge.org/svn/bootstrap/rivet-bootstrap}}\\
	+%\inp{wget \url{http://rivet.hepforge.org/svn/bootstrap/rivet-bootstrap}}\\
	+\inp{wget \url{http://rivet.hepforge.org/hg/bootstrap/raw-file/X.Y.Z/rivet-bootstrap}}\\
	+(where X.Y.Z is the release that you want to install)\\
	\inp{chmod +x rivet-bootstrap}\\
	Now run it to get some help:
	\inp{./rivet-bootstrap --help}\\
	-Now to actually do the install: for example, to bootstrap Rivet and AGILe
	+Now to actually do the install: for example, to bootstrap Rivet %and AGILe
	to the install area specified as the prefix argument, run this:\\
	-\inp{./rivet-bootstrap --install-agile --prefix=\val{localdir}}
	+\inp{./rivet-bootstrap --prefix=\val{localdir}}

	If you are running on a system where the CERN AFS area is mounted as
	\path{/afs/cern.ch}, then the bootstrap script will attempt to use the pre-built
	HepMC\cite{Dobbs:2001ck}, LHAPDF\cite{Whalley:2005nh},
	FastJet\cite{Cacciari:2005hq,fastjetweb} and GSL libraries from the LCG software area.
	Either way, finally the bootstrap script will write out a file containing the
	environment settings which will make the system useable. You can source this
	file, e.g. \kbd{source rivetenv.sh} to make your current shell ready-to-go
	for a Rivet run (use \kbd{rivetenv.csh} if you are a C shell user).

	-You now have a working, installed copy of the Rivet and AGILe libraries, and the
	-\kbd{rivet} and \kbd{agile-runmc} executables: respectively these are the
	+You now have a working, installed copy of the Rivet library, and the
	+\kbd{rivet}, \kbd{rivet-}, and \kbd{yoda} executables: respectively these are the
	command-line frontend to the Rivet analysis library, and a convenient steering
	command for generators which do not provide their own main program with HepMC
	output. To test that they work as expected, source the setup scripts as above,
	if you've not already done so, and run this:\\
	\inp{rivet --help}\\
	%
	This should print a quick-reference user guide for the \kbd{rivet} command to
	-the terminal. Similarly, for \kbd{agile-runmc},\\
	-\inp{agile-runmc --help}\\
	-\inp{agile-runmc --list-gens}\\
	-\inp{agile-runmc --beams=pp:14000 Pythia6:425}\\
	-which should respectively print the help, list the available generators and make
	-10 LHC-type events using the Fortran Pythia\cite{Sjostrand:2006za} 6.423 generator. You're on your
	-way! If no generators are listed, you probably need to install a local
	-Genser-type generator repository: see \SectionRef{sec:genser}.
	+the terminal.
	+%
	+% Similarly, for \kbd{agile-runmc},\\
	+% \inp{agile-runmc --help}\\
	+% \inp{agile-runmc --list-gens}\\
	+% \inp{agile-runmc --beams=pp:14000 Pythia6:425}\\
	+% which should respectively print the help, list the available generators and make
	+% 10 LHC-type events using the Fortran Pythia\cite{Sjostrand:2006za} 6.423 generator. You're on your
	+% way! If no generators are listed, you probably need to install a local
	+% Genser-type generator repository: see \SectionRef{sec:genser}.

	-In this manual, because of its convenience, we will use \kbd{agile-runmc} as our
	-canonical way of producing a stream of HepMC event data; if your interest is in
	-running a generator like Sherpa\cite{Gleisberg:2008ta},
	-Pythia~8\cite{Sjostrand:2007gs,Sjostrand:2008vc}, or Herwig++\cite{Bahr:2008pv}
	-which provides their own native way to make HepMC output, or a generator like
	-PHOJET which is not currently supported by AGILe, then substitute the
	-appropriate command in what follows. We'll discuss using these commands in
	-detail in \SectionRef{sec:agile-runmc}.
	+In this manual we will use a dummy \kbd{generator} command as our way of
	+producing a stream of HepMC event data. In practice you should run a generator
	+like Pythia~8\cite{Sjostrand:2007gs,Sjostrand:2008vc},
	+Herwig++\cite{Bahr:2008pv} or Sherpa\cite{Gleisberg:2008ta} which provide their
	+own native way to make HepMC output -- and the latter two can also call the
	+Rivet library directly via their own configuration interfaces. To use these, or
	+perhaps older Fortran generators via the AGILe interface, substitute the
	+appropriate command in what follows.\footnote{For largely historical reference,
	+ use of the AGILe commands is documented in
	+\SectionRef{app:agilerunrunmc}.}


	-\subsection{Getting generators for AGILe}
	-\label{sec:genser}
	+% \subsection{Getting generators for AGILe}
	+% \label{sec:genser}

	-One last thing before continuing, though: the generators themselves. Again, if
	-you're running on a system with the CERN LCG AFS area mounted, then
	-\kbd{agile-runmc} will attempt to automatically use the generators packaged by the
	-LCG Genser team.
	+% One last thing before continuing, though: the generators themselves. Again, if
	+% you're running on a system with the CERN LCG AFS area mounted, then
	+% \kbd{agile-runmc} will attempt to automatically use the generators packaged by the
	+% LCG Genser team.

	-Otherwise, you'll have to build your own mirror of the LCG generators. This
	-process is evolving with time, and so, rather than provide information in this
	-manual which will be outdated by the time you read it, we simply refer you to
	-the relevant page on the Rivet wiki:
	-\url{http://rivet.hepforge.org/trac/wiki/GenserMirror}.
	+% Otherwise, you'll have to build your own mirror of the LCG generators. This
	+% process is evolving with time, and so, rather than provide information in this
	+% manual which will be outdated by the time you read it, we simply refer you to
	+% the relevant page on the Rivet wiki:
	+% \url{http://rivet.hepforge.org/trac/wiki/GenserMirror}.

	-If you are interested in using a generator not currently supported by AGILe,
	-which does not output HepMC events in its native state, then please contact the
	-authors (via the Rivet developer contact email address) and hopefully we can
	-help.
	+% If you are interested in using a generator not currently supported by AGILe,
	+% which does not output HepMC events in its native state, then please contact the
	+% authors (via the Rivet developer contact email address) and hopefully we can
	+% help.


	\subsection{Command completion}

	A final installation point worth considering is using the supplied bash-shell
	-programmable completion setup for the \kbd{rivet} and \kbd{agile-runmc}
	+programmable completion setup for the \kbd{rivet} and generator %\kbd{agile-runmc}
	commands. Despite being cosmetic and semi-trivial, programmable completion makes
	using \kbd{rivet} positively pleasant, especially since you no longer need to
	remember the somewhat cryptic analysis names\footnote{Standard Rivet analyses
	have names which, as well as the publication date and experiment name,
	incorporate the 8-digit Spires/Inspire ID code.}!

	To use programmable completion, source the appropriate files from the install
	location:\\
	\inp{. \val{localdir}/share/Rivet/rivet-completion}\\
	-\inp{. \val{localdir}/share/AGILe/agile-completion}\\
	+% \inp{. \val{localdir}/share/AGILe/agile-completion}\\
	(if you are using the setup script \kbd{rivetenv.sh} this is automatically
	done for you).
	If there is already a \kbd{\val{localdir}/etc/bash_completion.d} directory in
	-your install path, Rivet and AGILe's installation scripts will install extra
	-copies into that location, since automatically sourcing all completion files in
	+your install path, Rivet's installation script will install an extra
	+copy into that location, since automatically sourcing all completion files in
	such a path is quite standard.

	% Apologies to \{C,k,z,\dots\}-shell users, but this feature is currently only
	% available for the \kbd{bash} shell. Anyone who feels like supplying fixes or
	% additions for their favourite shell is very welcome to get in touch with the
	% developers.



	\section{Running Rivet analyses}
	\label{sec:agile-runmc}

	The \kbd{rivet} executable is the easiest way to use Rivet, and will be our
	example throughout this manual. This command reads HepMC events in the standard
	ASCII format, either from file or from a text stream.

	\subsection{The FIFO idiom}
	\label{sec:fifo-idiom}

	Since you rarely want to store simulated HepMC events and they are
	computationally cheap to produce (at least when compared to the remainder of
	experiment simulation chains), we recommend using a Unix \emph{named pipe} (or
	``FIFO'' --- first-in, first-out) to stream the events. While this may seem
	unusual at first, it is just a nice way of ``pretending'' that we are writing to
	and reading from a file, without actually involving any slow disk access or
	building of huge files: a 1M event LHC run would occupy $\sim 60 GB$ on disk,
	and typically it takes twice as long to make and analyse the events when the
	filesystem is involved! Here is an example:\\
	\inp{mkfifo fifo.hepmc}\\
	-\inp{agile-runmc Pythia6:425 -o fifo.hepmc \&}\\
	+\inp{generator -o fifo.hepmc \&}\\
	\inp{rivet -a EXAMPLE fifo.hepmc}\\
	%
	-Note that the generator process (\kbd{agile-runmc} in this case) is
	+Note that the generator process (\kbd{generator} in this case) is
	\emph{backgrounded} before \kbd{rivet} is run.

	Notably, \kbd{mkfifo} will not work if applied to a directory mounted via the
	AFS distributed filesystem, as widely used in HEP. This is not a big problem:
	just make your FIFO object somewhere not mounted via AFS, e.g. \kbd{/tmp}. There
	is no performance penalty, as the filesystem object is not written to during the
	streaming process.

	In the following command examples, we will assume that a generator has been set
	up to write to the \kbd{fifo.hepmc} FIFO, and just list the \kbd{rivet} command
	-that reads from that location. Some typical \kbd{agile-runmc} commands are
	-listed in \ref{app:agilerunmc}.
	+that reads from that location. % Some typical \kbd{agile-runmc} commands are
	+% listed in \ref{app:agilerunmc}.


	\subsection{Analysis status}

	The standard Rivet analyses are divided into four status classes: validated,
	preliminary, obsolete, and unvalidated (in roughly decreasing order of academic
	acceptability).

	The Rivet ``validation procedure'' is not formally
	defined, but generally implies that an analysis has been checked to ensure
	reproduction of MC points shown in the paper where possible, and is believed to
	have no outstanding issues with analysis procedure or cuts. Additionally,
	analyses marked as ``validated'' and distributed with Rivet should normally have
	been code-checked by an experienced developer to ensure that the code is a good
	example of Rivet usage and is not more complex than required or otherwise
	difficult to read or maintain. Such analyses are regarded as fully ready for use
	in any MC validation or tuning studies.

	Validated analyses which implement an unfinished piece of experimental work are
	considered to be trustworthy in their implementation of a conference note or
	similar ``informal'' publication, but do not have the magic stamp of approval
	that comes from a journal publication. This remains the standard mark of
	experimental respectability and accordingly we do not include such analyses in
	the Rivet standard analysis libraries, but in a special ``preliminary''
	library. While preliminary analyses may be used for physics studies, please be
	aware of the incomplete status of the corresponding experimental study, and also
	be aware that the histograms in such analyses may be renamed or removed
	entirely, as may the analysis itself.

	Preliminary analyses will not have a Spires/Inspire ID, and hence on their
	move into the standard Rivet analysis library they will normally undergo a name
	change: please ensure when you upgrade between Rivet versions that any scripts
	or programs which were using preliminary analyses are not broken by the
	disappearance or change of that analysis in the newer version. The minor perils
	of using preliminary analyses can be avoided by the cautious by building Rivet
	with the \kbd{-{}-disable-preliminary} configuration flag, in which case their
	temptation will not even be offered.

	To make transitions between Rivet versions more smooth and predictable for users
	of preliminary analyses, preliminary analyses which are superseded by a
	validated version will be reclassified as obsolete and will be retained for one
	major version of Rivet with a status of "obsolete" before being removed, to give
	users time to migrate their run scripts, i.e. if an analysis is marked as
	obsolete in version 1.4.2, it will remain in Rivet's distribution until version
	1.5.0. Obsolete analyses may have different reference histograms from the final
	version and will not be maintained. Obsolete analyses will not be built if
	either the \kbd{-{}-disable-obsolete} configuration flag is specified at build
	time: for convenience, the default value of this flag is the value of the
	\kbd{-{}-disable-preliminary} flag.

	Finally, unvalidated analyses are those whose implementation is incomplete,
	flawed or just troubled by doubts. Running such analyses is not a good idea if
	you aren't trying to fix them, and Rivet's command line tools will print copious
	warning messages if you do. Unvalidated analyses in the Rivet distribution are
	not built by default, as they are only of interest to developers and would be
	distracting clutter for the majority of users: if you \emph{really} need them,
	building Rivet with the \kbd{-{}-enable-unvalidated} configuration flag will
	slake your thirst for danger.


	\subsection{Example \kbd{rivet} commands}

	\begin{itemize}

	\item \textbf{Getting help: }{\kbd{rivet --help} will print a (hopefully)
	helpful list of options which may be used with the \kbd{rivet} command, as
	well as other information such as environment variables which may affect the
	run.}

	\item \textbf{Choosing analyses: }{\kbd{rivet --list-analyses} will list the
	available analyses, including both those in the Rivet distribution and any
	plugins which are found at runtime. \kbd{rivet --show-analysis \val{patt}}
	will show a lot of details about any analyses whose name match the
	\val{patt} regular expression pattern --- simple bits of analysis name are a
	perfectly valid subset of this. For example, \kbd{rivet --show-analysis
	CDF_200} exploits the standard Rivet analysis naming scheme to show
	details of all available CDF experiment analyses published in the
	``noughties.''}

	\item \textbf{Running analyses: }{\kbd{rivet -a~DELPHI_1996_S3430090
	fifo.hepmc} will run the Rivet
	\kbd{DELPHI_1996_S3430090}\cite{Abreu:1996na} analysis on the events in the
	\kbd{fifo.hepmc} file (which, from the name, is probably a filesystem named
	pipe rather than a normal \emph{file}). This analysis is the one originally
	used for the \Delphi ``\textsc{Professor}'' generator tuning. If the first
	event in the data file does not have appropriate beam particles, the
	analysis will be disabled; since there is only one analysis in this case,
	the command will exit immediately with a warning if the first event is not
	an $\Ppositron\Pelectron$ event.}

	% \item \paragraph{Using all analyses:}{\kbd{rivet -n~50000 -A -} will read up to
	% 50k events from standard input (specified by the special ``-'' input
	% filename) and analyse them with \emph{all} the Rivet library analyses. As
	% above, incompatible analyses will be removed before the main analysis run
	% begins.}

	\item \textbf{Histogramming: }{\kbd{rivet fifo.hepmc -H~foo.yoda} will read all the
	events in the \kbd{fifo.hepmc} file. The \kbd{-H} switch is used to
	specify that the output histogram file will be named \kbd{foo.yoda}. By
	default the output file is called \kbd{Rivet.yoda}.}

	\item \textbf{Fine-grained logging: }

	{\kbd{rivet fifo.hepmc -A
	-l~Rivet.Analysis=DEBUG~\cmdbreak -l~Rivet.Projection=DEBUG
	-l~Rivet.Projection.FinalState=TRACE~\cmdbreak -l~NEvt=WARN}
	will analyse events as before, but will print different status
	information as the run progresses. Hierarchical logging control is possible
	down to the level of individual analyses and projections as shown above;
	this is useful for debugging without getting overloaded with debug
	information from \emph{all} the components at once. The default level is
	``\textsc{info}'', which lies between ``\textsc{debug}'' and
	``\textsc{warning}''; the ``\textsc{trace}'' level is for very low level
	information, and probably isn't needed by normal users.}

	\end{itemize}



	\section{Using analysis data}

	In this section, we summarise how to use the data files which Rivet produces for
	plotting, validation and tuning.

	\subsection{Histogram formats}

	-Rivet produces output data in the YODA text-based format. This is a significant
	-change from versions of Rivet before 2.0.0, which used the AIDA programming
	-interface and XML format. If you do not want to use the plotting tools that come
	-with Rivet (cf.\ Sec.~\ref{sec:plotting}), you might wish to convert the YODA
	-files to a different format for plotting: the YODA package itself provides
	-several scripts for this purpose.
	+Rivet produces output data in the YODA text-based format -- see
	+\url{http://yoda.hepforge.org}. This is a significant change from versions of
	+Rivet before 2.0.0, which used the AIDA programming interface and XML format. If
	+you do not want to use the plotting tools that come with Rivet (cf.\
	+Sec.~\ref{sec:plotting}), you might wish to convert the YODA files to a
	+different format for plotting: the YODA package itself provides several scripts
	+for this purpose.

	\paragraph{Conversion to ROOT}

	For many people, the first question will be ``how do I plot my Rivet histograms
	using ROOT?''\,\cite{Antcheva:2009zz}. Setting aside the suggestion of masochism
	that this raises, be assured that the \kbd{yoda2root} script (installed by YODA
	if built with ROOT support enabled) will do a direct conversion of a \kbd{.yoda}
	file into an equivalent \kbd{.root} file. Equivalent, that is, as far as ROOT
	can represent the information in a YODA histogram: YODA stores far more
	information about weights and distribution moments within bins than ROOT can
	handle. For programmatic conversion, both the C++ and Python interfaces to YODA
	can convert YODA objects into their ROOT equivalents (and vice~versa).

	% Rivet installs an
	% \kbd{aida2root} script, which converts the AIDA records to a \kbd{.root} file
	% full of ROOT \texttt{TGraph}s. One word of warning: a bug in ROOT means that
	% \texttt{TGraph}s do not render properly from file because the axis is not drawn by
	% default. To display the plots correctly in ROOT you will need to pass the
	% \kbd{"AP"} drawing option string to either the \kbd{TGraph::Draw()} method, or
	% in the options box in the \kbd{TBrowser} GUI interface.
	% Alternatively you can also use the \kbd{-t} option with which \kbd{aida2root}
	% produces \texttt{TH1}s instead.

	\paragraph{Conversion to ``flat format''}

	Most of our histogramming is based around a ``flat'' plain text format,
	which can easily be read (and written) by hand. YODA provides a script called
	\kbd{yoda2flat} to do this conversion. Run \kbd{yoda2flat -h} to get usage
	instructions. Aside from anything else, this is useful for simply
	checking the contents of an YODA file, with \kbd{yoda2flat Rivet.yoda - \| less}.

	\vspace{1.8em}

	\begin{detail}
	We're aften asked why we don't use ROOT internally. It's a natural question,
	given how dominant ROOT is in (experimental) particle physics data analysis
	and plotting. Rivet's not using ROOT was originally historical, but is now a
	matter of our requirements. ROOT is a very monolithic system, and when we
	started writing Rivet, many theorists (who we needed to be on-side) were
	- unhappy about introducing such a large dependency -- so we settled on using
	- the AIDA/LWH system, which could be fully embedded in the Rivet code.
	+ unhappy about introducing such a large dependency -- so we at first settled on
	+ using the AIDA/LWH system, which could be fully embedded in the Rivet code.

	Eventually we decided that AIDA had run its course, due to such things as the
	awkwardness of histogram addition and division, confusion between bin heights
	and areas, and lack of support for gaps in binning (needed by several
	analyses). ROOT was the obvious replacement, but after detailed consideration
	we decided that it wouldn't solve the problems: we would re-encounter many of
	the same weighted statistics issues we had already dealt with in AIDA (as well
	as weight-handling not being enabled by default), binning gaps still wouldn't
	be supported, and we would block future development thanks to ROOT's notorious
	thread-unsafety and object ownership issues. Plus, how hard can histogramming
	be? Having thought a lot about histogramming over the years, we decided to
	write YODA.

	It's taken several years (admittedly with very low manpower fractions on that
	task!) to iterate to a design that we're really happy with, but we think YODA
	is a \emph{really} pleasant way to do histogramming. It's object oriented but
	without the global state issues of ROOT, or the factory-based weirdnesses of
	AIDA. Weights are handled naturally, bins store enough distribution moments to
	do some pretty advanced stuff, overflows are handled by default, scalings (of
	weights or axes) and histogram arithmetic are easy and natural, and it's
	computationally efficient. It's also not finished -- completed 2D
	histogramming and abstract binning ideas are still to be implemented -- but
	that means that your desired enhancements stand a chance of getting
	implemented. So let us know your thoughts!
	\end{detail}


	\subsection{Plotting and comparing data}
	\label{sec:plotting}
	Rivet comes with three commands --- \kbd{rivet-mkhtml}, \kbd{rivet-cmphistos} and
	\kbd{make-plots} --- for comparing and plotting data files. These commands
	produce nice comparison plots of publication quality from the YODA format text
	files.

	The high level program \kbd{rivet-mkhtml} will automatically create a plot
	webpage from the given YODA files. It searches for reference data automatically
	and uses the other two commands internally. Example:\\
	\inp{rivet-mkhtml withUE.yoda:'Title=With UE' withoutUE.yoda:'LineColor=blue'}\\
	Run \kbd{rivet-mkhtml --help} to find out about all features and options.

	You can also run the other two commands separately:
	%
	\begin{itemize}
	\item \kbd{rivet-cmphistos} will accept a number of YODA files as input (ending in
	\kbd{.yoda}), identify which plots are available in them, and combine the MC
	and reference plots appropriately into a set of plot data files ending with
	\kbd{.dat}. More options are described by running \kbd{rivet-cmphistos --help}.

	Incidentally, the reference files for each Rivet analysis are to be found in the
	installed Rivet shared data directory, \kbd{\val{installdir}/share/Rivet}. You
	can find the location of this by using the \kbd{rivet-config} command:\\
	\inp{rivet-config --datadir}

	\item You can plot the created data files using the \kbd{make-plots} command:\\
	\inp{make-plots --pdf *.dat}\\
	The \kbd{--pdf} flag makes the output plots in PDF format: by default the output
	is in PostScript (\kbd{.ps}), and flags for conversion to EPS and PNG are also
	available.
	\end{itemize}


	\subsection{Merging histograms from different Rivet runs}
	The \kbd{yodamerge} script will take several YODA files and merge them together
	into a single one. If a histogram path only occurs in one of the input files, it
	is copied directly to the output. If it occurs more than once, the statistics of
	those histograms will be merged with full accuracy, producing the same output as
	would have been obtained from a single long run containing all the same
	events. Run \kbd{yodamerge -h} to get instructions on using the script.

	\begin{warning}
	This exact merging only applies for \emph{histograms}, of either normal or
	profile type. There are heuristics in the merging script to detect whether or
	not there should be a common normalization, but as with all heuristics they
	are not 100\% guaranteed. Also, more complex objects such as histogrammed
	asymmetries, of the form $H_1 - H_2 / H_1 + H_2$, are not really histograms:
	in YODA the division operation will automatically convert them to the
	\kbd{Scatter2D} type, for which no moments are stored. It's not possible to
	combine the statistics of such objects in a straightforward way -- so for now
	only one of the input copies will be output. Watch Rivet 2.x for developments
	which will finally \emph{properly} solve the run combination problem, by
	allowing the \kbd{finalize()} step to be re-run on combined Rivet run outputs!
	\end{warning}


	-\section{Outdated information for AIDA in Rivet 1.x}
	+% \section{Outdated information for AIDA in Rivet~1.x}

	-\begin{change}
	- The following information applies to the Rivet 1.x series and the tools
	- provided for AIDA histogramming. YODA should make many of these features
	- unnecessary, since its Python interface is far more powerful and precise\dots
	- but this is subject to evolution.
	-\end{change}
	+% \begin{change}
	+% The following information applies to the Rivet~1.x series and the tools
	+% provided for AIDA histogramming. YODA should make many of these features
	+% unnecessary, since its Python interface is far more powerful and precise\dots
	+% but this is subject to evolution.
	+% \end{change}

	-\subsection{Chopping histograms}
	-\newcommand{\chophisto}{\kbd{rivet-chopbins}\xspace} In some cases you don't
	-want to keep the complete histograms produced by Rivet. For generator tuning
	-purposes, for example, you want to get rid of the bins you already know your
	-generator is incapable of describing. You can use the script \chophisto to
	-specify those bin-ranges you want to keep individually for each histogram in a
	-Rivet output-file. The bin-ranges have to be specified using the corresponding
	-x-values of that histogram. The usage is very simple. You can specify bin
	-ranges of histograms to keep on the command-line via the \kbd{-b}
	-switch, which can be given multiple times, e.g.\\
	-\kbd{\chophisto -b /CDF\_2001\_S4751469/d03-x01-y01:5:13 Rivet.aida}\\
	-%
	-will chop all bins with $x<5$ and $x>13$ from the histogram
	-\kbd{/CDF\_2001\_S4751469/d03\-x01\-y01} in the file \kbd{Rivet.aida}. (In
	-this particular case, $x$ would be a leading jet \pT.)
	+% \subsection{Chopping histograms}
	+% \newcommand{\chophisto}{\kbd{rivet-chopbins}\xspace} In some cases you don't
	+% want to keep the complete histograms produced by Rivet. For generator tuning
	+% purposes, for example, you want to get rid of the bins you already know your
	+% generator is incapable of describing. You can use the script \chophisto to
	+% specify those bin-ranges you want to keep individually for each histogram in a
	+% Rivet output-file. The bin-ranges have to be specified using the corresponding
	+% x-values of that histogram. The usage is very simple. You can specify bin
	+% ranges of histograms to keep on the command-line via the \kbd{-b}
	+% switch, which can be given multiple times, e.g.\\
	+% \kbd{\chophisto -b /CDF\_2001\_S4751469/d03-x01-y01:5:13 Rivet.aida}\\
	+% %
	+% will chop all bins with $x<5$ and $x>13$ from the histogram
	+% \kbd{/CDF\_2001\_S4751469/d03\-x01\-y01} in the file \kbd{Rivet.aida}. (In
	+% this particular case, $x$ would be a leading jet \pT.)

	-\subsection{Normalising histograms}
	-\newcommand{\normhisto}{\kbd{rivet-rescale }} Sometimes you want to
	-use histograms normalised to, e.g., the generator cross-section or the area of
	-a reference-data histogram. The script \normhisto was designed for these
	-purposes. The usage is the following:\\
	-\kbd{\normhisto -O observables -r RIVETDATA -o normalised Rivet.aida}\\
	-%
	-By default, the normalised histograms are written to file in the AIDA-XML
	-format. You can also give the \kbd{-f} switch on the command line to produce
	-flat histograms.
	+% \subsection{Normalising histograms}
	+% \newcommand{\normhisto}{\kbd{rivet-rescale }} Sometimes you want to
	+% use histograms normalised to, e.g., the generator cross-section or the area of
	+% a reference-data histogram. The script \normhisto was designed for these
	+% purposes. The usage is the following:\\
	+% \kbd{\normhisto -O observables -r RIVETDATA -o normalised Rivet.aida}\\
	+% %
	+% By default, the normalised histograms are written to file in the AIDA-XML
	+% format. You can also give the \kbd{-f} switch on the command line to produce
	+% flat histograms.

	-\paragraph{Normalising to reference data} You will need an output-file of
	-Rivet, \kbd{Rivet.aida}, a folder that contains the reference-data histograms
	-(e.g. \kbd{rivet-config --datadir}) and optionally, a text-file,
	-\kbd{observables} that contains the names of the histograms you would like to
	-normalise - those not given in the file will remain un-normalised. These
	-are examples of how your \kbd{observables} file might look like:
	-%
	-\begin{snippet}
	-/CDF_2000_S4155203/d01-x01-y01
	-\end{snippet}
	+% \paragraph{Normalising to reference data} You will need an output-file of
	+% Rivet, \kbd{Rivet.aida}, a folder that contains the reference-data histograms
	+% (e.g. \kbd{rivet-config --datadir}) and optionally, a text-file,
	+% \kbd{observables} that contains the names of the histograms you would like to
	+% normalise - those not given in the file will remain un-normalised. These
	+% are examples of how your \kbd{observables} file might look like:
	+% %
	+% \begin{snippet}
	+% /CDF_2000_S4155203/d01-x01-y01
	+% \end{snippet}

	-If a histogram \kbd{/CDF\_2000\_S4155203/d01-x01-y01} is found in one of the
	-reference-data files in the folder specified via the \kbd{-r} switch, then this
	-will result in a histogram \kbd{/CDF\_2000\_S4155203/d01-x01-y01} being
	-normalised to the area of the corresponding reference-data histogram. You can
	-further specify a certain range of bins to normalise:
	-%
	-\begin{snippet}
	-/CDF_2000_S4155203/d01-x01-y01:2:35
	-\end{snippet}
	-%
	-\noindent will chop off the bins
	-with $x<2$ and $x>35$ of both, the histogram in your \kbd{Rivet.aida} and the
	-reference-data histogram. The remaining MC histogram is then normalised to the
	-remaining area of the reference-data histogram.
	+% If a histogram \kbd{/CDF\_2000\_S4155203/d01-x01-y01} is found in one of the
	+% reference-data files in the folder specified via the \kbd{-r} switch, then this
	+% will result in a histogram \kbd{/CDF\_2000\_S4155203/d01-x01-y01} being
	+% normalised to the area of the corresponding reference-data histogram. You can
	+% further specify a certain range of bins to normalise:
	+% %
	+% \begin{snippet}
	+% /CDF_2000_S4155203/d01-x01-y01:2:35
	+% \end{snippet}
	+% %
	+% \noindent will chop off the bins
	+% with $x<2$ and $x>35$ of both, the histogram in your \kbd{Rivet.aida} and the
	+% reference-data histogram. The remaining MC histogram is then normalised to the
	+% remaining area of the reference-data histogram.

	-\paragraph{Normalising to arbitrary areas}%
	-In the file \kbd{observables} you
	-can further specify an arbitrary number, e.g. a generator cross-section, as
	-follows:
	-%
	-\begin{snippet}
	-/CDF_2000_S4155203/d01-x01-y01 1.0
	-\end{snippet}
	-\noindent will result in the histogram \kbd{/CDF\_2000\_S4155203/d01-x01-y01} being
	-normalised to 1.0, and
	-%
	-\begin{snippet}
	-/CDF_2000_S4155203/d01-x01-y01:2:35 1.0
	-\end{snippet}
	-%
	-\noindent will chop off the bins with $x<2$ and $x>35$ of the histogram\\
	-\kbd{/CDF\_2000\_S4155203/d01-x01-y01} first and normalise the remaining
	-histogram to one.
	+% \paragraph{Normalising to arbitrary areas}%
	+% In the file \kbd{observables} you
	+% can further specify an arbitrary number, e.g. a generator cross-section, as
	+% follows:
	+% %
	+% \begin{snippet}
	+% /CDF_2000_S4155203/d01-x01-y01 1.0
	+% \end{snippet}
	+% \noindent will result in the histogram \kbd{/CDF\_2000\_S4155203/d01-x01-y01} being
	+% normalised to 1.0, and
	+% %
	+% \begin{snippet}
	+% /CDF_2000_S4155203/d01-x01-y01:2:35 1.0
	+% \end{snippet}
	+% %
	+% \noindent will chop off the bins with $x<2$ and $x>35$ of the histogram\\
	+% \kbd{/CDF\_2000\_S4155203/d01-x01-y01} first and normalise the remaining
	+% histogram to one.
	diff --git a/doc/intro.tex b/doc/intro.tex
	--- a/doc/intro.tex
	+++ b/doc/intro.tex
	@@ -1,61 +1,61 @@
	This manual is a users' guide to using the Rivet generator validation
	system. Rivet is a C++ class library, which provides the infrastructure and
	calculational tools for particle-level analyses for high energy collider
	experiments, enabling physicists to
	validate event generator models and tunings with minimal effort and maximum
	portability. Rivet is designed to scale effectively to large numbers of analyses
	for truly global validation, by transparent use of an automated result caching
	system.

	The Rivet ethos, if it may be expressed succinctly, is that user analysis code
	should be extremely clean and easy to write --- ideally it should be
	sufficiently self-explanatory to in itself be a reference to the experimental
	analysis algorithm --- without sacrificing power or extensibility. The machinery
	to make this possible is intentionally hidden from the view of all but the most
	prying users. Generator independence is explicitly required by virtue of all
	analyses operating on the generic ``HepMC'' event record.

	The simplest way to use Rivet is via the \kbd{rivet} command line tool, which
	analyses textual HepMC event records as they are generated and produces output
	distributions in a structured textual format. The input events are generated
	-using the generator's own steering program, if one is provided; for generators
	-which provide no default way to produce HepMC output, the AGILe generator
	-interface library, and in particular the \kbd{agile-runmc} command which it
	-provides, may be useful. For those who wish to embed their analyses in some
	-larger framework, Rivet can also be used as a library to run programmatically
	-on HepMC event objects with no special executable being required.
	+using the generator's own steering program, which is typically provided for
	+modern codes; for older generators which have no default way to produce HepMC
	+output, the AGILe generator interface library and \kbd{agile-runmc} command may
	+be useful. For those who wish to embed their analyses in some larger framework,
	+Rivet can also be used as a library to run programmatically on HepMC event
	+objects with no special executable being required.

	Before we get started, a declaration of intent: this manual is intended to be a
	guide to using Rivet, rather than a comprehensive and painstakingly maintained
	reference to the application programming interface (API) of the Rivet
	library. For that purpose the online documentation at
	\url{http://rivet.hepforge.org} should be sufficient -- in case of confusion
	please contact the authors at \url{rivet@projects.hepforge.org}. Similar API
	documentation is maintained for AGILe at \url{http://agile.hepforge.org}.


	\subsection{Typographic conventions}
	As is normal in computer user manuals, the typography in this manual is used to
	indicate whether we are describing source code elements, commands to be run in a
	terminal, the output of a command etc.

	The main such clue will be the use of \kbd{typewriter-style} text: this
	indicates the name of a command or code element --- class names, function names
	etc. Typewriter font is also used for commands to be run in a terminal, but in
	this case it will be prefixed by a dollar sign, as in \inp{echo "Hello" \|
	cat}. The output of such a command on the terminal will be typeset in
	\outp{sans-serif} font. When we are documenting a code feature in detail (which
	is not the main point of this manual), we will use square brackets to indicate
	optional arguments, and italic font between angle brackets to represent an
	argument name which should be replaced by a value,
	e.g. \code{Event::applyProjection(\val{proj})}.

	% Following the example of Donald Knuth in his books on \TeX{}, in this document
	% we will indicate paragraphs of particular technicality or esoteric nature with a
	% ``dangerous bend''\marginpar{\bendimg\\Dangerous bend} sign. These will
	% typically describe internals of Rivet of which most people will be fortunate
	% enough to remain happily ignorant without adverse effects. However they may be
	% of interest to detail obsessives, the inordinately curious and Rivet
	% hackers. You can certainly skip them on a first reading. Similarly, you may see
	% double bend signs \marginpar{\dblbendimg\\Double bend} --- the same rules apply
	% for these, but even more strongly.
	diff --git a/doc/make-plots.txt b/doc/make-plots.txt
	--- a/doc/make-plots.txt
	+++ b/doc/make-plots.txt
	@@ -1,686 +1,688 @@
	make-plots
	============

	About
	-----

	`make-plots` reads histogram files in a simple text format and converts
	them into PostScript or PDF files. This is done by creating a LaTeX file
	and running `latex`, `dvips`, and maybe `ps2pdf`.

	Usage
	-----

	To run `make-plots` call

	--------------------
	make-plots [options] file.dat [file2.dat ...]
	--------------------

	All available options can be listed by running

	--------------------
	make-plots --help
	--------------------

	Configuration files
	~~~~~~~~~~~~~~~~~~~

	`make-plots` typically takes the plotting instructions and settings from the
	input ascii files as described in the "Input Format" chapter.
	It is also possible though to pass a global configuration file to `make-plots`
	(cf. `--help`) which allows to specify/overwrite settings for certain plots or
	histograms in a plot on top of what the input files specify. This could be
	useful if the ascii files are generated automatically (e.g. with `rivet-mkhtml`
	or `compare-histos`) and you still want to apply custom plotting options.

	An example for this looks like:

	--------------------
	# BEGIN PLOT figures/MC_WJETS/W_mass.dat
	XMin=60.0
	XMax=100.0
	LegendXPos=0.65
	# END PLOT

	.*myLOrun.aida/D0_2008_S7554427/d01-x01-y01::Scale=1.0
	--------------------

	Here first the options in the `PLOT` section of a specific ascii file are
	being amended/overwritten. The second part shows how to overwrite the `Scale`
	property of one specific histogram line using the ID of the histogram.


	Input Format
	------------

	The ascii files which can be read by `make-plots` are divided into sections.
	There are four types of sections which are called `PLOT`, `HISTOGRAM`,
	`FUNCTION`, and `SPECIAL`. Every file must contain exactly one `PLOT` section
	and at least one section of the other three types. There may be multiple
	`HISTOGRAM`, `FUNCTION`, and `SPECIAL` sections.

	Empty lines and lines starting with `#` are ignored, except for the section
	delimiters described below.

	PLOT
	~~~~

	The `PLOT` section starts with

	--------------------
	# BEGIN PLOT
	--------------------

	and ends with

	--------------------
	# END PLOT
	--------------------

	Every file must have exactly one `PLOT` section. In this section global
	parameters are specified, like the axis labels, the plot title, size, ...
	An empty `PLOT` section is perfectly legal, though.

	In this section the following parameters can be set:

	Titles, Labels
	^^^^^^^^^^^^^^

	--------------------
	Title=<title>
	--------------------
	The title of the plot.

	--------------------
	XLabel=<label>
	YLabel=<label>
	ZLabel=<label>
	--------------------
	Axis labels for the x-, y-, and z-axis.

	--------------------
	XLabelSep=<distance>
	YLabelSep=<distance>
	ZLabelSep=<distance>
	--------------------
	Distance between the axis label and the plot in units of `\labelsep`.

	--------------------
	XMajorTickMarks=<last_digit>
	YMajorTickMarks=<last_digit>
	ZMajorTickMarks=<last_digit>
	XMinorTickMarks=<nticks>
	YMinorTickMarks=<nticks>
	ZMinorTickMarks=<nticks>
	--------------------
	`make-plots` tries to guess the distance between tickmarks automatically.
	If you are not satisfied with its result, you can override this by setting
	`<last_digit>` to 1, 2, 5, or 10, and `<nticks>` to the number of minor ticks
	you like.
	_Note_: These options are not available for logarithmic axes.

	--------------------
	XTwosidedTicks=<0\|1>
	YTwosidedTicks=<0\|1>
	--------------------
	Draw tickmarks also on the upper and/or right side of the plot.

	--------------------
	XCustomMajorTicks=<list>
	YCustomMajorTicks=<list>
	ZCustomMajorTicks=<list>
	--------------------
	To specify major ticks at arbitrary positions and/or with arbitrary labels.
	-`<list>` is a tab separated list of format `value1 <tab> label1 <tab> value2
	-<tab> label2 ...`.
	+`<list>` is a whitespace-separated list of format `value1 <spaces_or_tabs> label1 <spaces_or_tabs> value2
	+<spaces_or_tabs> label2 ...`.
	+
	+TODO: allow use of YAML-style list syntax to clarify delimiters?

	--------------------
	XCustomMinorTicks=<list>
	YCustomMinorTicks=<list>
	ZCustomMinorTicks=<list>
	--------------------
	To specify minor ticks at arbitrary positions. `<list>` is a tab separated
	list of format `value1 <tab> value2 <tab> value3 ...`.

	--------------------
	-PlotTickLabels=<0\|1>
	+PlotXTickLabels=<0\|1>
	RatioPlotTickLabels=<0\|1>
	--------------------
	Disable/enable plotting of the tick labels in the plot and ratio plot (useful
	if multiple plots are to be combined manually later).

	Axes
	^^^^

	--------------------
	LogX=<0\|1>
	LogY=<0\|1>
	LogZ=<0\|1>
	--------------------
	Use a logarithmic x-, y-, or z-axis. Default is linear.

	--------------------
	XMin=<value>
	XMax=<value>
	YMin=<value>
	YMax=<value>
	ZMin=<value>
	ZMax=<value>
	FullRange=<0\|1>
	ShowZero=<0\|1>
	--------------------
	Specify the plot range. By default the range is chosen such that all data
	is visible in linear plots, and the zero is visible. `ShowZero=0` suppresses
	plotting the zero in linear plots and thus zooms into the actual y-value range
	of the distribution. In logarithmic plots the automatic choice of `YMin`
	is limited to be not smaller than 2e-4*`YMax`, but manually you can specify
	any value. `FullRange=1` also overrides the 2e-4*`YMax` limit and plots the
	full range in y.


	Normalization, Rebinning
	^^^^^^^^^^^^^^^^^^^^^^^^

	--------------------
	NormalizeToIntegral=<1\|0>
	NormalizeToSum=<1\|0>
	Scale=<factor>
	--------------------
	Normalize all histograms to their integral, to their sum of entries, or scale
	them by some arbitrary factor. Normalization and scale options in the `PLOT`
	section override the corresponding option in the `HISTOGRAM` section.
	The scale factor is applied after normalization.

	--------------------
	Rebin=<nbins>
	--------------------
	Rebin all histograms in this plot. Syntax and functionality is the same as for
	the Rebin option in the `HISTOGRAM` section.


	Sizes and Margins
	^^^^^^^^^^^^^^^^^

	--------------------
	PlotSize=<xsize,ysize>
	--------------------
	Size in x and y direction of the plot. This can be specified in any unit
	LaTeX understands.

	--------------------
	LeftMargin=<size>
	RightMargin=<size>
	TopMargin=<size>
	BottomMargin=<size>
	--------------------
	Distance between the plot and the paper edge.

	--------------------
	FrameColor=<color>
	--------------------
	Background color for the margin around the plot.


	Legends
	^^^^^^^

	--------------------
	Legend=<0\|1>
	--------------------
	Display a legend in the plot.

	--------------------
	CustomLegend=<text>
	--------------------
	Custom text that is added to the legend.

	--------------------
	LegendXPos=<pos>
	LegendYPos=<pos>
	--------------------
	Position of the legend within the plot. Anchor point is the top left corner of
	the legend, so units typically range between 0.0 and 1.0.

	--------------------
	LegendAlign=<align>
	--------------------
	Horizontal alignment of the legend: `LegendAlign=l` is the default and will
	create a left-aligned legend, while `LegendAlign=r` is right-aligned with
	the keys on the right hand side.

	--------------------
	LegendOnly=<list>
	--------------------
	Whitespace separated list of IDs. These can be histograms or functions. The
	legend is only shown for the listed objects. Without this option, all plotted
	objects which have a title enter the legend. The legend titles
	are plotted in the given order, so there are cases in which it makes
	sense to use `LegendOnly` together with all histogram IDs.
	It is also possible to specify the legend order on an entry-by-entry basis
	using the `LegendOrder=<int>` setting for each histogram or function.


	Plotting Options
	^^^^^^^^^^^^^^^^

	--------------------
	DrawOnly=<list>
	--------------------
	Whitespace separated list of histogram IDs. Only the histograms in this list
	are plotted, even if there are more histograms defined in the file. The
	histograms are plotted in the given order, so there are cases in which it makes
	sense to use `DrawOnly` together with all histogram IDs. This is especially
	useful for the `Stack` option. It is also possible to specify the plotting order
	on a histogram-by-histogram basis using the `PlotOrder=<int>` setting for each
	histogram.

	--------------------
	Stack=<list>
	--------------------
	Whitespace separated list of histogram IDs. The histograms will be added on top
	of each other. This is useful for example to compare data with background if
	the background has contributions from several histograms.

	--------------------
	DrawSpecialFirst=<0\|1>
	DrawFunctionFirst=<0\|1>
	--------------------
	By default the `SPECIAL` and `FUNCTION` sections are plotted after the
	histograms. With these options you can override that behaviour.

	--------------------
	ConnectGaps=<0\|1>
	--------------------
	If error bars are disabled and you want to bridge gaps in a histogram, you
	can set this parameter. By default it is off. Setting it in the `PLOT` section
	affects all histograms, but you can also set it in the `HISTOGRAM` section for
	individual histograms. The local setting overrides the global setting.


	Comparison Plots
	^^^^^^^^^^^^^^^^

	With the

	--------------------
	RatioPlot=1
	RatioPlotReference=<histogram_ID>
	--------------------
	options you can create ratio plots for two or more histograms. Note that you
	must specify your reference data ID. This option is used by the
	link:compare-histos.html[`compare-histos`] script.

	--------------------
	RatioPlotMode=<default\|deviation\|datamc>
	--------------------
	By default, the ratio plot displays MC/Data. You can switch to
	(MC-data)/uncertainty (`deviation`) or Data/MC (`datamc`) with this
	option.

	In ratio plots the following additional options are available and work in
	a similar way as their regular counterparts:

	--------------------
	RatioPlotYLabel=<label>
	RatioPlotYMin=<value>
	RatioPlotYMax=<value>
	RatioPlotYSize=<size>
	RatioPlotErrorBandColor=<color>
	--------------------

	By default, the reference data is plotted using a yellow error band around the
	central value of the ratio plot. If you would rather have it plotted in the
	same style as in the main plot (e.g. with black errorbars), you can specify:

	--------------------
	RatioPlotSameStyle=1
	--------------------

	If you only want the ratio plot without showing the actual data distribution,
	you can switch off the main plot. This option implies `RatioPlot=1`:

	--------------------
	MainPlot=0
	--------------------


	Goodness of Fit
	^^^^^^^^^^^^^^^

	`make-plots` can calculate the goodness of fit between histograms and display the
	result in the legend. It is also possible to change the color of the margin around
	the plot depending on the GoF. This is useful to provide a quick overview when
	looking at many plots.

	--------------------
	GofType=chi2
	--------------------

	The type of GoF. The default is `chi2` and currently that's the only option.

	--------------------
	GofReference=<histogram_ID>
	--------------------

	specifies the reference histogram to be used for the GoF calculation. If this
	option is omitted, the fallback is `RatioPlotReference`.

	The GoF calculation is activated by two options:

	--------------------
	GofLegend=<0\|1>
	GofFrame=<histogram_ID>
	--------------------

	`GofLegend` calculates the GoF for all histograms and displays the results in
	the legend. With `GofFrame` you can specify a single histogram for which the
	GoF result will be shown in the legend and used to assign a color to the plot
	margins. Note that `FrameColor` overrides the color choice for the margin.
	You can use

	--------------------
	GofFrameColor=<colorthresholds>
	--------------------

	to specify the thresholds for the frame color. This option takes a list of
	`<threshold>:<color>` pairs, separated by whitespace. The default is
	`GofFrameColor=0:green 3:yellow 6:red!70`. Again, if you use `FrameColor`,
	this option is disabled.


	Color Palettes for 2-dim Plots
	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

	With the option `ColorSeries` you can define a custom color palette for
	2-dimensional plots. The syntax is the same as for the `\definecolorseries`
	command in the `xcolor` LaTeX package after the color series name, i.e.
	`{core-model}{method}[begin-model]{begin-spec}[end-model]{end-spec}`. For more
	information you can consult the
	http://www.ctan.org/tex-archive/macros/latex/contrib/xcolor/xcolor.pdf[xcolor documentation].
	Here is an example:

	--------------------
	ColorSeries={rgb}{last}[rgb]{1,0.97,0.94}[rgb]{0.6,0.0,0.05}
	--------------------


	HISTOGRAM
	~~~~~~~~~

	The `HISTOGRAM` section starts with

	--------------------
	# BEGIN HISTOGRAM <ID>
	--------------------

	and ends with

	--------------------
	# END HISTOGRAM
	--------------------

	There can be more than one `HISTOGRAM` section in a file. Histograms are
	identified by `<ID>` which can be any string _not_ containing whitespace.


	Data Format
	^^^^^^^^^^^

	Lines starting with a number (positive or negative) are interpreted as data.
	Each line specifies one bin. The fields in each line must be separated by tabs,
	not spaces (this needs to be fixes some day). For 1-dimensional histograms the
	format can be

	--------------------
	<lowerbinedge> <upperbinedge> <value> <error>
	<lowerbinedge> <upperbinedge> <value> <minuserror> <pluserror>
	--------------------

	2-dimensional histograms are supported, too. They are plotted as colormap
	(errors are ignored) and specified as

	--------------------
	<lowerxbinedge> <upperxbinedge> <lowerybinedge> <upperybinedge> <value> <error>
	--------------------


	Titles
	^^^^^^

	--------------------
	Title=<title>
	--------------------
	Title of the histogram. This is used for the legend.


	Linestyles
	^^^^^^^^^^

	--------------------
	LineStyle=<style>
	--------------------
	Any linestyle that is understood by the LaTeX pstricks package, e.g. `solid`,
	`dotted`, `dashed`, `none`, as well as a special `dashdotted` (or `dotdashed`)
	linestyle which does what you might expect.

	--------------------
	LineColor=<color>
	--------------------
	Color of the line. Default is black, but any color that pstricks understands
	can be used, including constructions like `red!70!blue!20` (for mixing colors),
	`{[rgb]{0.8,0,0.7}}` (for RGB-colors), `{[wave]{580}}` (for wavelengths in
	nm), `LineColor={[cmyk]{1,1,0,0}}` for CMYK-colors, or `[hsb]{0.5,1,1}` for
	HSB-colors.

	--------------------
	LineOpacity=<opacity>
	--------------------
	Set the opacity of the line. Default is 1.0. This might not work for ps output.

	--------------------
	LineWidth=<width>
	--------------------
	Width of the line.

	--------------------
	LineDash=<dashstyle>
	--------------------
	If `LineStyle` is set to `dashed`, you can specify the dash style with this
	option. Anything that is understood by pstrick's `dash=...` option is valid.
	An example for a dash-dotted line is `LineDash=3pt 3pt .8pt 3pt`. You can use
	`LineStyle=dashdotted` or `LineStyle=dotdashed` as an abbreviation for
	`LineStyle=dashed` with `LineDash=3pt 3pt .8pt 3pt`.

	--------------------
	ConnectBins=<0\|1>
	--------------------
	Choose whether to connect adjacent bins' horizontal lines together by a vertical
	line on the bin edge. This is enabled by default, but you may wish to disable
	it when plotting reference data with error bars and point markers.

	--------------------
	ConnectGaps=<0\|1>
	--------------------
	If ConnectBins is enabled and you want to bridge gaps in a histogram, you
	can set this parameter. By default it is off. Setting it in the `PLOT` section
	affects all histograms, but you can also set it in the `HISTOGRAM` section for
	individual histograms. The local setting overrides the global setting.

	--------------------
	SmoothLine=<0\|1>
	--------------------
	Draw a smooth curve rather than a histogram


	Fillstyles
	^^^^^^^^^^

	--------------------
	FillStyle=<style>
	FillColor=<color>
	--------------------
	To fill the area below a histogram, set `FillStyle` and `FillColor` to
	something pstricks understands. Examples for the style are `solid` or `vlines`.
	See `LineColor` for examples of color definitions.

	--------------------
	FillOpacity=<opacity>
	--------------------
	Set the opacity of the solid fillcolor. Default is 1.0. This might not work for
	ps output.

	--------------------
	HatchColor=<color>
	--------------------
	The color of a hatch pattern used for filling the area below a histogram. This
	is used for example when you use `vlines` as style.


	Data Points
	^^^^^^^^^^^

	--------------------
	ErrorBars=<0\|1>
	--------------------
	Turn on error bars.

	--------------------
	ErrorBands=<0\|1>
	ErrorBandColor=<color>
	--------------------
	Turn on error bands and set their color (see `LineColor` for a description
	of color definitions).

	--------------------
	ErrorBandOpacity=<opacity>
	--------------------
	Set the opacity of the error band. Default is 1.0. This might not work for ps
	output.

	--------------------
	PolyMarker=<dotstyle>
	--------------------
	The marker style of the points. Any dot style which is understood by pstricks
	is valid, e.g. `*`, `o`, `triangle`, `diamond`, ...

	--------------------
	DotSize=<size>
	DotScale=<factor>
	--------------------
	The size of the markers. With `DotSize` you can specify the absolute size, e.g.
	in units of `pt`, while `DotScale` is a relative measure with respect to the
	default size.


	Normalization, Rebinning
	^^^^^^^^^^^^^^^^^^^^^^^^

	--------------------
	NormalizeToIntegral=<1\|0>
	NormalizeToSum=<1\|0>
	Scale=<factor>
	--------------------
	Normalize the histogram to the integral, to the sum of entries, or scale it by
	some arbitrary factor. If normalization and a scale factor are given, the scale
	factor is applied after normalization. This is useful for stacking histograms
	when the ratios are known.

	--------------------
	Rebin=<nbins>
	ErrorType=<stat\|env>
	--------------------
	Rebin the histogram. Starting with the lowest bin <nbins> bins are combined
	into a new bin. If the number of bins in the histogram is not a multiple of
	<nbins>, the remaining bins at the upper histogram end are silently ignored
	(i.e. if the original histogram has 10 bins and <nbins> is 3, the plotted
	histogram shows three bins combining the bins 1--9 of the original histogram).
	The treatment of the errors is determined by the given ErrorType:
	`stat` (default) assumes the errors are of statistical nature and combines
	them in quadrature sum, while `env` allows to treat errors as envelope of
	various uncertainty runs which are combined linearly.


	FUNCTION
	~~~~~~~~

	`make-plots` can draw arbitrary functions. These functions are defined as
	python code sniplets which are evaluated by `make-plots`. The code sniplet
	must come after all other options in a `FUNCTION` section and are preceded by
	`Code=` on a single line. An example `FUNCTION` section might look like this:

	--------------------
	# BEGIN FUNCTION f_cc
	LineColor=red
	Code=
	p0=16.4
	p1=1.25
	p2=0.9832
	from scipy.special import erf
	x-=0.5
	if x<=0:
	return 0
	else:
	return .5p2(1.+erf( (x-p0)/sqrt(x*p1) ))
	# END FUNCTION
	--------------------

	Common Options with HISTOGRAM
	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

	The following options have the same meaning as in the `HISTOGRAM` section:

	--------------------
	Title=<title>
	LineStyle=<style>
	LineColor=<color>
	LineWidth=<width>
	LineDash=<dashstyle>
	FillStyle=<style>
	FillColor=<color>
	HatchColor=<color>
	--------------------

	Function Range
	^^^^^^^^^^^^^^

	You can limit the plot range of functions by specifying

	--------------------
	XMin=<value>
	XMax=<value>
	--------------------


	SPECIAL
	~~~~~~~

	The `SPECIAL` sections are used to include any custom pstricks code. This is
	useful for drawing arrows and lines, put text at any position into the plot,
	etc. The default coordinate system is defined to be `(0,0)` at the lower left
	and `(1,1)` at the upper right corner of the plot. By putting the
	`\physicscoor` command in front of a coordinate pair, these coordinates are
	interpreted not in the pstricks coordinate system, but in the physics
	coordinate system of the plot, which is useful e.g. for marking cut values in a
	plot. Similar `\physicsxcoor` and `\physicsycoor` commands exist which will only
	treat the x or y coordinate respectively as being in physics units.

	Hint: If you want to clip your `SPECIAL` code to the plot area, you can use
	--------------------
	\psclip{\psframe[linewidth=0, linestyle=none](0,0)(1,1)}
	...
	\endpsclip
	--------------------

	An example of a `SPECIAL` section might look like this:

	--------------------
	# BEGIN SPECIAL
	\psclip{\psframe[linewidth=0, linestyle=none](0,0)(1,1)}
	\psline[linewidth=1.2pt,linecolor=red]{<-}\physicscoor(2.83,2)\physicscoor(2.83,18)
	\uput{4pt}[180]{0}\physicscoor(2.83,12){observed}
	\psline[linewidth=0.8pt,linecolor=red,linestyle=dashed]\physicscoor( 3.17,0)\physicscoor( 3.17,28.14)
	\psline[linewidth=0.8pt,linecolor=red,linestyle=dashed]\physicscoor(-3.59,0)\physicscoor(-3.59,28.14)
	\endpsclip
	# END SPECIAL
	--------------------
	diff --git a/doc/rivet-manual.tex b/doc/rivet-manual.tex
	--- a/doc/rivet-manual.tex
	+++ b/doc/rivet-manual.tex
	@@ -1,85 +1,86 @@
	\documentclass{JHEP3}
	%\JHEP{00(2007)000}

	\include{preamble}

	\title{Rivet user manual\\ {\smaller \textsc{version \RivetVersion}}}

	\author{Andy Buckley\\ PPE Group, School of Physics, University of Glasgow, UK.\\ E-mail: \email{andy.buckley@cern.ch}}
	\author{Jonathan Butterworth\\ HEP Group, Dept. of Physics and Astronomy, UCL, London, UK.\\ E-mail: \email{J.Butterworth@ucl.ac.uk}}
	\author{David Grellscheid\\ IPPP, Durham University, UK.\\ E-mail: \email{david.grellscheid@durham.ac.uk}}
	\author{Hendrik Hoeth\\ IPPP, Durham University, UK.\\ E-mail: \email{hendrik.hoeth@cern.ch}}
	\author{Leif L\"onnblad\\ Theoretical Physics, Lund University, Sweden.\\ E-mail: \email{lonnblad@thep.lu.se}}
	\author{James Monk\\ Experimental Particle Physics, Niels Bohr Institute, Copenhagen, Denmark.\\ E-mail: \email{jmonk@cern.ch}}
	\author{Chris Pollard\\ PPE Group, School of Physics, University of Glasgow, UK.\\ E-mail: \email{cpollard@cern.ch}}
	\author{Holger Schulz\\ IPPP, Durham University, UK.\\ E-mail: \email{holger.schulz@durham.ac.uk}}
	%% \author{Jan Eike von Seggern\\ Institut f\"ur Physik, Berlin Humboldt University, Germany.\\ E-mail: \email{vseggern@physik.hu-berlin.de}}
	\author{Frank Siegert\\ Technische Universit\"at Dresden, Germany.\\ E-mail: \email{frank.siegert@cern.ch}}


	\preprint{}

	\abstract{This is the manual and user guide for the Rivet system for the
	validation and tuning of Monte Carlo event generators. As well as the core
	- Rivet library, this manual describes the usage of the \kbd{rivet} program and
	- the AGILe generator interface library. The depth and level of description is
	+ Rivet library, this manual describes the usage of the \kbd{rivet} program.
	+ % and the AGILe generator interface library
	+ The depth and level of description is
	chosen for users of the system, starting with the basics of using validation
	code written by others, and then covering sufficient details to write new
	Rivet analyses and calculational components.}

	\keywords{Event generator, simulation, validation, tuning, QCD}


	\begin{document}

	\section{Introduction}
	\label{sec:intro}
	\input{intro}

	\cleardoublepage

	\part{Getting started with Rivet}
	\label{part:gettingstarted}
	\input{gettingstarted}

	\cleardoublepage

	\part{Standard Rivet analyses}
	\label{part:analyses}
	In this section we describe the standard experimental analyses included with the
	Rivet library. To maintain synchronisation with the code, these descriptions are
	generated automatically from the metadata in the analysis objects
	themselves.
	\input{analyses}

	\cleardoublepage

	\part{How Rivet works}
	\label{part:writinganalyses}
	\input{writinganalyses}

	\cleardoublepage

	\part{Appendices}
	\appendix

	-\section{Typical \kbd{agile-runmc} commands}
	+\section{The \kbd{agile-runmc} Fortran generator interface (deprecated)}
	\label{app:agilerunmc}
	\input{agilerunmc}


	\section{Acknowledgements}
	\label{app:acknowledgements}
	\input{acknowledgements}


	\cleardoublepage

	\part{Bibliography}
	\bibliographystyle{h-physrev3}
	{\raggedright
	\bibliography{refs,analyses}
	}


	\end{document}
	diff --git a/doc/writinganalyses.tex b/doc/writinganalyses.tex
	--- a/doc/writinganalyses.tex
	+++ b/doc/writinganalyses.tex
	@@ -1,884 +1,880 @@
	Hopefully by now you've run Rivet a few times and got the hang of the command
	line interface and viewing the resulting analysis data files. Maybe you've got
	some ideas of analyses that you would like to see in Rivet's library. If so,
	then you'll need to know a little about Rivet's internal workings before you can
	start coding: with any luck by the end of this section that won't seem
	particularly intimidating.

	The core objects in Rivet are ``projections'' and ``analyses''. Hopefully
	``analyses'' isn't a surprise --- that's just the collection of routines that
	will make histograms to compare with reference data, and the only things that
	might differ there from experiences with HZTool\cite{Bromley:1995np} are the new histogramming system
	and the fact that we've used some object orientation concepts to make life a bit
	easier. The meaning of ``projections'', as applied to event analysis, will
	probably be less obvious. We'll discuss them soon, but first a
	semi-philosophical aside on the ``right way'' to do physics analyses on and
	involving simulated data.


	\section{The science and art of physically valid MC analysis}

	The world of MC event generators is a wonderfully convenient one for
	experimentalists: we are provided with fully exclusive events whose most complex
	correlations can be explored and used to optimise analysis algorithms and some
	kinds of detector correction effects. It is absolutely true that the majority of
	data analyses and detector designs in modern collider physics would be very
	different without MC simulation.

	But it is very important to remember that it is just simulation: event
	generators encode much of known physics and phenomenologically explore the
	non-perturbative areas of QCD, but only unadulterated experiment can really tell
	us about how the world behaves. The richness and convenience of MC simulation
	can be seductive, and it is important that experimental use of MC strives to
	understand and minimise systematic biases which may result from use of simulated
	data, and to not ``unfold'' imperfect models when measuring the real world. The
	canonical example of the latter effect is the unfolding of hadronisation (a
	deeply non-perturbative and imperfectly-understood process) at the Tevatron (Run
	I), based on MC models. Publishing ``measured quarks'' is not physics --- much
	of the data thus published has proven of little use to either theory or
	experiment in the following years. In the future we must be alert to such
	temptation and avoid such gaffes --- and much more subtle ones.

	These concerns on how MC can be abused in treating measured data also apply to
	MC validation studies. A key observable in QCD tunings is the \pT of the \PZ
	boson, which has no phase space at exactly $\pT = 0$ but a very sharp peak at
	$\mathcal{O}(\unit{1-2}{\GeV})$. The exact location of this peak is mostly
	sensitive to the width parameter of a nucleon ``intrinsic \pT'' in MC
	generators, plus some soft initial state radiation and QED
	bremsstrahlung. Unfortunately, all the published Tevatron measurements of this
	observable have either ``unfolded'' the QED effects to the ``\PZ \pT'' as
	attached to the object in the HepMC/HEPEVT event record with a PDG ID code of
	23, or have used MC data to fill regions of phase space where the detector could
	not measure. Accordingly, it is very hard to make an accurate and portable MC
	analysis to fit this data, without similarly delving into the event record in
	search of ``the boson''. While common practice, this approach intrinsically
	limits the precision of measured data to the calculational order of the
	generator --- often not analytically well-defined. We can do better.

	Away from this philosophical propaganda (which nevertheless we hope strikes some
	chords in influential places\dots), there are also excellent pragmatic reasons
	for MC analyses to avoid treating the MC ``truth'' record as genuine truth. The
	key argument is portability: there is no MC generator which is the ideal choice
	for all scenarios, and an essential tool for understanding sub-leading
	variability in theoretical approaches to various areas of physics is to use
	several generators with similar leading accuracies but different sub-leading
	formalisms. While the HEPEVT record as written by HERWIG and PYTHIA has become
	familiar to many, there are many ambiguities in how it is filled, from the
	allowed graph structures to the particle content. Notably, the Sherpa event
	generator explicitly elides Feynman diagram propagators from the event record,
	perhaps driven by a desire to protect us from our baser analytical
	instincts. The Herwig++ event generator takes the almost antipodal approach of
	expressing different contributing Feynman diagram topologies in different ways
	(\emph{not} physically meaningful!) and seamlessly integrating shower emissions
	with the hard process particles. The general trend in MC simulation is to blur
	the practically-induced line between the sampled matrix element and the
	Markovian parton cascade, challenging many established assumptions about ``how
	MC works''. In short, if you want to ``find'' the \PZ to see what its \pT or
	$\eta$ spectrum looks like, many new generators may break your honed PYTHIA
	code\dots or silently give systematically wrong results. The unfortunate truth
	is that most of the event record is intended for generator debugging rather than
	physics interpretation.

	Fortunately, the situation is not altogether negative: in practice it is usually
	as easy to write a highly functional MC analysis using only final state
	particles and their physically meaningful on-shell decay parents. These are,
	since the release of HepMC 2.5, standardised to have status codes of 1 and 2
	respectively. \PZ-finding is then a matter of choosing decay lepton candidates,
	windowing their invariant mass around the known \PZ mass, and choosing the best
	\PZ candidate: effectively a simplified version of an experimental analysis of
	the same quantity. This is a generally good heuristic for a safe MC analysis!
	Note that since it's known that you will be running the analysis on signal
	events, and there are no detector effects to deal with, almost all the details
	that make a real analysis hard can be ignored. The one detail that is worth
	including is summing momentum from photons around the charged leptons, before
	mass-windowing: this physically corresponds to the indistinguishability of
	collinear energy deposits in trackers and calorimeters and would be the ideal
	published experimental measurement of Drell-Yan \pT for MC tuning. Note that
	similar analyses for \PW bosons have the luxury over a true experiment of being
	able to exactly identify the decay neutrino rather than having to mess around
	with missing energy. Similarly, detailed unstable hadron (or tau) reconstruction
	is unnecessary, due to the presence of these particles in the event record with
	status code 2. In short, writing an effective analysis which is automatically
	portable between generators is no harder than trying to decipher the variable
	structures and multiple particle copies of the debugging-level event
	objects. And of course Rivet provides lots of tools to do almost all the
	standard fiddly bits for you, so there's no excuse!\\[\lineskip]

	\noindent
	Good luck, and be careful!

	% While the event record "truth" structure may look very
	% compellingly like a history of the event processes, it is extremely important to
	% understand that this is not the case. For starters, such a picture is not
	% quantum mechanically robust: it is impossible to reconcile such a concept of a
	% single history with the true picture of contributing and interfering
	% amplitudes. A good example of this is in parton showers, where QM interference
	% leads to colour coherence. In the HERWIG-type parton showers, this colour
	% coherence is implemented as an angular-ordered series of emissions, while in
	% PYTHIA-type showers, an angular veto is instead applied. The exact history of
	% which particles are emitted in which order is not physically meaningful but
	% rather an artefact of the model used by the generator --- and is primarily
	% useful for generator authors' debugging rather than physics analysis. This is in
	% general true for all particles in the event without status codes of 1, 2 or 4.

	% Another problem is that the way in which the event internals is documented is
	% not well defined: it is for authors' use and as such they can do anything they
	% like with the "non-physics" entities stored within. Some examples:

	% * Sherpa does not write matrix element particles (i.e. W, Z, Higgs, ...) into the event record in most processes
	% * Herwig++ uses very low-mass Ws in its event record to represent very off-shell weak decay currents of B and D mesons (among others)
	% * In Drell-Yan events, Herwig++ sometimes calls the propagating boson a Z, and sometimes a photon, probabilistically depending on the no-mixing admixture terms
	% * Sherpa events (and maybe others) can have "bottleneck" particles through which everything flows. Asking if a particle has e.g. a b-quark (NB. an unphysical degree of freedom!) ancestor might always give the answer "yes", depending on the way that the event graph has been implemented
	% * Different generators do not even use the same status codes for "documentation" event record entries: newer ones tend to represent all internals as generator-specific particles, and emphasise their lack of physical meaning
	% * The generator-level barcodes do not have any reliable meaning: any use of them is based on HEPEVT conventions whihc may break, especially for new generators which have never used HEPEVT
	% * Many (all?) generators contain multiple copies of single internal particles, as a bookkeeping tools for various stages of event processing. Determining which (if any) is physically meaningful (e.g. which boosts were or weren't applied, whether QED radiation was included, etc.) is not defined in a cross-generator way.
	% * The distinction between "matrix element" and "parton shower" is ill-defined: ideally everything would be emitted from the parton shower and indeed the trend is to head at least partially in this direction (cf. CKKW/POWHEG). You probably can't make a physically useful interpretation of the "hard process", even if particular event records allow you to identify such a thing.
	% * Quark and gluon jets aren't as simple as the names imply on the "truth" level: to perform colour neutralisation, jets must include more contributions than a single hard process parton. When you look at event graphs, it becomes hard to define these things on a truth level. Use an observable-based heuristic definition instead.

	% Hence, any truth-structure assumptions need to checked and probably modified
	% when moving from one generator to another: clearly this can lead to
	% prohibitively large maintenance and development hurdles. The best approach,
	% whenever possible, is to only use truth information to access the particles
	% with status code 1 (and those with status = 2, if decays of physically
	% meaningful particles (i.e. hadrons) are being studied. In practice, this
	% adds relatively little to most analyses, and the portability of the analyses
	% is massively improved, allowing for wider and more reliable physics
	% studies. If you need to dig deeper, be very careful!

	% A final point of warning, more physical than the technicalities above, is that
	% the bosons or similar that are written in the event record are imperfect
	% calculational objects, rather than genuine truth. MC techniques are improving
	% all the time, and you should be extremely careful if planning to do something
	% like "unfolding" of QED radiation or initial state QCD radiation on data, based
	% on event record internals: the published end result must be meaningfully
	% comparable to future fixed order or N^kLL resummation calculations, particularly
	% in precision measurements. If not handled with obsessive care, you may end up
	% publishing a measurement of the internals of an MC generator rather than
	% physical truth! Again, this is not an absolute prohibition --- there are only
	% shades of grey in this area --- but just be very careful and stick to statuses
	% 1, 2 and 4 whenever possible.


	\section{Projections}

	\begin{figure}[p]
	\centering
	\includegraphics[height=0.98\textheight]{projections.png}
	\caption{List of available projections and their inheritance structure.}
	\label{fig:projections}
	\end{figure}

	The name ``projection'' is meant to evoke thoughts of projection operators,
	low-dimensional slices/views of high-dimensional spaces, and other things that
	might appeal to physicists who view the world through quantum-tinted lenses. A
	more mundane, but equally applicable, name would be ``observable calculators'',
	but since that's a long name, the things they return aren't \emph{necessarily}
	observable, and they all inherit from the \kbd{Projection} base class, we'll
	stick to that name. It doesn't take long to get used to using the name as a
	synonym for ``calculator'', without being intimidated by ideas that they might
	be some sort of high-powered deep magic. 90\% of them is simple and
	self-explanatory, as a peek under the bonnet of e.g. the all-important
	\kbd{FinalState} projection will reveal.

	Projections can be relatively simple things like event shapes (i.e. scalar,
	vector or tensor quantities), or arbitrarily complex things like lossy or
	selective views of the event final state. Most users will see them attached to
	analyses by declarations in each analysis' initialisation, but they can also be
	recursively ``nested'' inside other projections\footnote{Provided there are no
	dependency loops in the projection chains! Strictly, only acyclic graphs of
	projection dependencies are valid, but there is currently no code in Rivet
	that will attempt to verify this restriction.} (provided there are no infinite
	loops in the nesting chain.) Calling a complex projection in an analysis may
	actually transparently execute many projections on each event.

	You can find a list of all existing projections and their inheritance structure
	in Fig.~\ref{fig:projections}. An up-to-date version of this listing can always
	be found in the code documentation at \url{http://rivet.hepforge.org}.


	\subsection{Projection caching}

	Aside from semantic issues of how the class design assigns the process of
	analysing events, projections are important computationally because they live in
	a framework which automatically stores (``caches'') their results between
	events. This is a crucial feature for the long-term scalability of Rivet, as the
	previous experience with HZTool was that HERA validation code ran very slowly
	due to repeated calculation of the same $k_\perp$ clustering algorithm (at that
	time notorious for scaling as the 3rd power of the number of particles.)

	A concrete example may help in understanding how this works. Let's say we have
	two analyses which have the same run conditions, i.e. incoming beam types, beam
	energies, etc. Each also uses the thrust event shape measure to define a set of
	basis vectors for their analysis. For each event that gets passed to Rivet,
	whichever analysis gets called first will immediately (although maybe
	indirectly) call a \kbd{FinalState} projection to get a list of stable, physical
	particles (filtering out the intermediate and book-keeping entries in the HepMC
	event record). That FS projection is then ``attached'' to the event. Next, the
	first analysis will call a \kbd{Thrust} projection which internally uses the
	same final state projection to define the momentum vectors used in calculating
	the thrust. Once finished, the thrust projection will also be attached to the
	event.

	So far, projections have offered no benefits. However, when the second analysis
	runs it will similarly try to apply its final state and thrust projections to
	the event. Rather than repeat the calculations, Rivet's infrastructure will
	detect that an equivalent calculation has already been run and will just return
	references to the already-run projections. Since projections can also contain
	and use other projections, this model allows some substantial computational
	savings, without the analysis author even needing to be particularly aware of
	what is going on.

	Observant readers may have noticed a problem with all this projection caching
	cleverness: what if the final states aren't defined the same way? One might
	provide charged final state particles only, or the acceptances (defined in
	pseudorapidity range and a IR \pT cutoff) might differ. Rivet handles this by
	making each projection provide a comparison operator which is used to decide
	whether the cached version is acceptable or if the calculation must be re-run
	with different settings. Because projections can be nested, applying a top-level
	projection to an event can spark off a cascade of comparisons, calculations and
	cache accesses, making use of existing results wherever possible.


	\subsection{Using projection caching}
	So far this is all theory --- how does one actually use projections in Rivet?
	First, you should understand that projections, while semantically stored within
	each other, are actually all registered with a central \code{ProjectionHandler}
	object.\footnote{As of version 1.1 onwards --- previously, they were stored as
	class members inside other \code{Projection}s and \code{Analysis} classes.}
	The reason for this central registration is to ensure that all projections'
	lifespans are managed in a consistent way, and to protect projection and
	analysis authors from some technical subtleties in how C++ polymorphism works.

	Inside the constructor of a \code{Projection} or the \code{init} method of an
	\code{Analysis} class, you must
	call the \code{addProjection} function. This takes two arguments, the projection
	to be registered (by \code{const} reference), and a name. The name is local to
	the parent object, so you need not worry about name clashes between objects. A
	very important point is that the passed \code{Projection} is not the one that is
	actually centrally registered --- that distinction belongs to a newly created
	heap object which is created within the \code{addProjection} method by means of
	the overloaded \code{Projection::clone()} method. Hence it is completely safe
	--- and recommended --- to use only local (stack) objects in \code{Projection}
	and \code{Analysis} constructors.


	\begin{philosophy}
	At this point, if you have rightly bought into C++ ideas like super-strong
	type-safety, this proliferation of dynamic casting may worry you: the compiler
	can't possibly check if a projection of the requested name has been
	registered, nor whether the downcast to the requested concrete type is
	legal. These are very legitimate concerns!

	In truth, we'd like to have this level of extra safety: who wouldn't? But in
	the past, when projections were held as members of \code{ProjectionApplier}
	classes rather than in the central \code{ProjectionHandler} repository, the
	benefits of the strong typing were outweighed by more serious and subtle bugs
	relating to projection lifetime and object ``slicing''. At least when the
	current approach goes wrong it will throw an unmissable \emph{runtime} error
	--- until it's fixed, of course! --- rather than silently do the wrong thing.

	Our problems here are a microcosm of the perpetual language battle between
	strict and dynamic typing, runtime versus compile time errors. In practice,
	this manifests itself as a trade-off between the benefits of static type
	safety and the inconvenience of the type-system gymnastics that it engenders.
	We take some comfort from the number of very good programs have been and are
	still written in dynamically typed, interpreted languages like Python, where
	virtually all error checking (barring first-scan parsing errors) must be done
	at runtime. By pushing \emph{some} checking to the domain of runtime errors,
	Rivet's code is (we believe) in practice safer, and certainly more clear and
	elegant. However, we believe that with runtime checking should come a culture
	of unit testing, which is not yet in place in Rivet.

	As a final thought, one reason for Rivet's internal complexity is that C++ is
	just not a very good language for this sort of thing: we are operating on the
	boundary between event generator codes, number crunching routines (including
	third party libraries like FastJet) and user routines. The former set
	unavoidably require native interfaces and benefit from static typing; the
	latter benefit from interface flexibility, fast prototyping and syntactic
	clarity. Maybe a future version of Rivet will break through the technical
	barriers to a hybrid approach and allow users to run compiled projections from
	interpreted analysis code. For now, however, we hope that our brand of
	``slightly less safe C++'' will be a pleasant compromise.
	\end{philosophy}


	% \begin{detail}
	% \TODO{How projection caching \emph{really} works}
	% (skippable, but useful as a reference)
	% \end{detail}

	% \subsection{Standard projection summary}
	% \TODO{foo}

	% \subsection{Example projection}
	% \TODO{bar}

	% \subsection{Cuts and constraints}
	% \TODO{baz}


	\section{Analyses}

	\subsection{Writing a new analysis}

	This section provides a recipe that can be followed to write a new analysis
	using the Rivet projections.

	Every analysis must inherit from \code{Rivet::Analysis} and, in addition to the
	constructor, must implement a minimum of three methods. Those methods are
	\code{init()}, \code{analyze(const Rivet::Event\&)} and \code{finalize()}, which
	are called once at the beginning of the analysis, once per event and once at the
	end of the analysis respectively.

	The new analysis should include the header for the base analysis class plus
	whichever Rivet projections are to be used, and should work under the
	\code{Rivet} namespace. Since analyses are hardly ever intended to be inherited
	from, they are usually implemented within a single \kbd{.cc} file with no
	corresponding header. The skeleton of a new analysis named \code{UserAnalysis}
	that uses the \code{FinalState} projection might therefore start off looking
	like this, in a file named \kbd{UserAnalysis.cc}:
	%
	\begin{snippet}
	#include "Rivet/Analysis.hh"

	namespace Rivet {

	class UserAnalysis : public Analysis {
	public:
	UserAnalysis() : Analysis("USERANA") { }
	void init() { ... }
	void analyze(const Event& event) { ... }
	void finalize() { ... }
	};

	}
	\end{snippet}

	The constructor body is usually left empty, as all event loop setup is done in
	the \code{init()} method: the one \emph{required} constructor feature is to make
	a call to its base \code{Analysis} constructor, passing a string by which the
	analysis will \emph{register} itself with the Rivet framework. This name is the
	one exposed to a command-line or API user of this analysis: usually it is the
	same as the class name, which for official analyses is always in upper case.

	\begin{warning}
	Early versions of Rivet required the user to declare allowed beam types,
	energies, whether a cross-section is required, etc. in the analysis
	constructor via methods like \code{setBeams(...)} and
	\code{setNeedsCrossSection(...)}. This information is now \emph{much}
	preferred to be taken from the \kbd{.info} file for the analysis, and
	\emph{must} be done this way in analyses submitted for inclusion in future
	Rivet releases.
	\end{warning}

	% for the \code{UserAnalysis} may impose certain
	% requirements upon the events that the analysis will work with. A call to the
	% \code{setBeams} method declares that the analysis may only be run on events with
	% specific types of beam particles, for example adding the line
	% %
	% \begin{snippet}
	% setBeams(PROTON, PROTON);
	% \end{snippet}
	% %
	% \noindent ensures that the analysis can only be run on events from proton-proton
	% collisions. Other types of beam particles that may be used include
	% \code{ANTIPROTON}, \code{ELECTRON}, \code{POSITRON}, \code{MUON} and \code{ALL}.
	% The latter of these declares that the analysis is suitable for use with any type
	% of collision and is the default.

	% Some analyses need to know the interaction cross section that was generated by
	% the Monte Carlo generator, typically in order to normalise histograms.
	% Depending on the Monte Carlo that is used and its interface to Rivet, the cross
	% section may or may not be known. An analysis can therefore declare at the
	% beginning of a run that it will need the cross section information during the
	% finalisation stages. Such a declaration can be used to prevent what would
	% otherwise be fruitless analyses from running. An analysis sets itself as
	% requiring the cross section by calling inside the constructor
	% %
	% \begin{snippet}
	% setNeedsCrossSection(true);
	% \end{snippet}
	% %
	% \noindent In the absence of this call the default is to assume that the analysis
	% does not need to know the cross section.

	The \code{init()} method for the \code{UserAnalysis} class should add to the analysis all
	of the projections that will be used. Projections can be added to an analysis
	with a call to \code{addProjection(Projection, std::string)}, which takes as
	argument the projection to be added and a name by which that projection can
	later be referenced. For this example the \code{FinalState} projection is to be
	referenced by the string \code{"FS"} to provide access to all of the final state
	particles inside a detector pseudorapidity coverage of $\pm 5.0$. The syntax to
	create and add that projection is as follows:
	%
	\begin{snippet}
	init() {
	const FinalState fs(-5.0, 5.0);
	addProjection(fs, "FS");
	}
	\end{snippet}
	%
	A second task of the \code{init()} method is the booking of all histograms which
	are later to be filled in the analysis code. Information about the histogramming
	system can be found in Section~\ref{section:histogramming}.

	% It is often the case that an analysis is only appropriate for a limited range of
	% Monte Carlo kinematic settings. For example, an analysis may only be suitable
	% if the minimum \pT in the hard scatter is above a certain value. A mechanism
	% exists with the \code{Analysis} object to declare the existence of such a cut.
	% However, the relevant information must be made available by the Monte Carlo
	% generator and, given the potentially large number of such generator-dependent
	% cuts, this information is not currently checked by the AGILe generator
	% interface. Nevertheless, an analysis can add a cut in the constructor with a
	% call to \code{addCut(const string\&, const Comparison\&, const double)}, which
	% takes as its arguments the name of the cut, the comparison operator and a value
	% to compare the cut quantity with. For example, to add a cut stating that the
	% hard scatter \pT must be above \unit{3}{\GeV} one should call

	% \begin{snippet}
	% addCut("PT", MORE_EQ, 3.0*GeV);
	% \end{snippet}


	\subsection{Utility classes}

	Rivet provides quite a few object types for physics purposes, such as three- and
	four-vectors, matrices and Lorentz boosts, and convenience proxy objects for
	e.g. particles and jets. We now briefly summarise the most important features of
	some of these objects; more complete interface descriptions can be found in the
	generated Doxygen web pages on the Rivet web site, or simply by browsing the
	relevant header files.

	\subsubsection{\code{FourMomentum}}

	The \code{FourMomentum} class is the main physics vector that you will encounter
	when writing Rivet analyses. Its functionality and interface are similar to the
	CLHEP \code{HepLorentzVector} with which many users will be familiar, but
	without some of the historical baggage.

	\paragraph{Vector components}%
	The \code{FourMomentum} \code{E()}, \code{px()}, \code{py()}, \code{pz()} \&
	\code{mass()} methods are (unsurprisingly) accessors for the vector's energy,
	momentum components and mass. The \code{vector3()} method returns a spatial
	\code{Vector3} object, i.e. the 3 spatial components of the 4-vector.

	\paragraph{Useful properties}%
	The \code{pT()} and \code{Et()} methods are used to calculate the transverse
	momentum and transverse energy. Angular variables are accessed via the
	\code{eta()}, \code{phi()} and \code{theta()} for the pseudorapidity, azimuthal
	angle and polar angle respectively. More explicitly named versions of these also
	exist, named \code{pseudorapidity()}, \code{azimuthalAngle()} and
	\code{polarAngle()}. Finally, the true rapidity is accessed via the
	\code{rapidity()} method. Many of these functions are also available as external
	functions, as are algebraic functions such as \code{cross(vec3a, vec3b)}, which
	is perhaps more palatable than \code{vec3a.cross(vec3b)}.

	\paragraph{Distances}%
	The $\eta$--$\phi$ distance between any two four-vectors (and/or three-vectors)
	can be computed using a range of overloaded external functions of the type
	\code{deltaR(vec1, vec2)}. Angles between such vectors can be calculated via the
	similar \code{angle(vec1, vec2)} functions.

	\subsubsection{\code{Particle}}
	This class is a wrapper around the HepMC \code{GenParticle}
	class. \code{Particle} objects are usually obtained as a vector from the
	\code{particles()} method of a \code{FinalState} projection. Rather than having
	to directly use the HepMC objects, and e.g. translate HepMC four-vectors into
	the Rivet equivalent, several key properties are accessed directly via the
	\code{Particle} interface (and more may be added). The main methods of interest
	are \code{momentum()}, which returns a \code{FourMomentum}, and \code{pdgId()},
	which returns the PDG particle ID code. The PDG code can be used to access
	particle properties by using functions such as \code{PID::isHadron()},
	\code{PID::threeCharge()}, etc. (these are defined in
	\kbd{Rivet/Tools/ParticleIDMethods.hh}.)

	\subsubsection{\code{Jet}}
	Jets are obtained from one of the jet accessor methods of a projection that
	implements the \code{JetAlg} interface, e.g. \code{FastJets::jetsByPt()} (this
	returns the jets sorted by \pT, such that the first element in the vector is the
	hardest jet --- usually what you want.) The most useful methods are
	\code{particles()}, \code{momenta()}, \code{momentum()} (a representative
	\code{FourMomentum}), and some checks on the jet contents such as
	\code{containsParticleId(pid)}, \code{containsCharm()} and
	\code{containsBottom()}.


	\subsubsection{Mathematical utilities}
	The \kbd{Rivet/Math/MathUtils.hh} header defines a variety of mathematical
	utility functions. These include testing functions such as \code{isZero(a)},
	\code{fuzzyEquals(a, b)} and \code{inRange(a, low, high)}, whose purpose is
	hopefully self-evident, and angular range-mapping functions such as
	\code{mapAngle0To2Pi(a)}, \code{mapAngleMPiToPi(a)}, etc.


	\subsection{Histogramming}
	\label{section:histogramming}

	-Rivet's histogramming uses the AIDA interfaces, composed of abstract classes
	-\code{IHistogram1D}, \code{IProfile1D}, \code{IDataPointSet} etc. which are
	-built by a factories system. Since it's our feeling that much of the factory
	-infrastructure constitutes an abstraction overload, we provide histogram booking
	-functions as part of the \code{Analysis} class, so that in the \code{init}
	-method of your analysis you should book histograms with function calls like:
	-%
	-% Should this be recommended without titles/labels, or is this what we want for
	-% plugin analyses?
	+Rivet's histogramming uses the YODA system, composed of ``analysis object''
	+classes \code{Histo1D}, \code{Profile1D}, \code{Scatter2D}, and less-used 2D
	+histograms and profiles, and 1D and 3D scatter plots. These can be created
	+directly in the analysis code, but to hook fully into the multiple-event-weight
	+and other machinery in Rivet it's normal to book them through \code{Analysis} class methods, to be called in the \code{init}
	+step of your analysis routine:
	%
	\begin{snippet}
	void init() {
	- _h_one = bookHistogram1D(2,1,1);
	- _h_two = bookProfile1D(3,1,2);
	- _h_three = bookHistogram1D("d00-x00-y00", 50, 0.0, 1.0);
	+ _h_one = bookHisto1D(2, 1, 1);
	+ _h_two = bookProfile1D(3, 1, 2);
	+ _h_three = bookHisto1D("d00-x00-y00", logscale(50, 1.0, 100.0));
	}
	\end{snippet}
	%
	Here the first two bookings have a rather cryptic 3-integer sequence as the
	-first arguments. This is the recommended scheme, as it makes use of the exported
	-data files from HepData, in which 1D histograms are constructed from a
	-combination of $x$ and $y$ axes in a dataset $d$, corresponding to names of the
	-form \kbd{d\val{d}-x\val{x}-y\val{y}}. This auto-booking of histograms saves you
	-from having to copy out reams of bin edges and values into your code, and makes
	-sure that any data fixes in HepData are easily propagated to Rivet. The
	-reference data files which are used for these booking methods are distributed
	-and installed with Rivet, you can find them in the
	-\kbd{\val{installdir}/share/Rivet} directory of your installation. The third
	+first arguments. This is the recommended scheme, which corresponds to the
	+HepData structure of 1D histograms as a combination of $x$ and $y$ axes in a
	+dataset $d$, giving names of the form \kbd{d\val{d}-x\val{x}-y\val{y}}. This
	+auto-booking of histograms saves you from having to copy out reams of bin edges
	+and values into your code, and makes sure that any data bug-fixes in HepData are
	+easily propagated to Rivet. The reference data files which are used for these
	+booking methods are distributed and installed with Rivet, you can find them in
	+the \kbd{\val{installdir}/share/Rivet} directory of your installation. The third
	booking is for a histogram for which there is no such HepData entry: it uses the
	usual scheme of specifying the name, number of bins and the min/max $x$-axis
	limits manually.

	Filling the histograms is done in the \code{MyAnalysis::analyse()}
	function. Remember to specify the event weight as you fill:
	%
	\begin{snippet}
	void analyze(const Event& e) {
	[projections, cuts, etc.]
	...
	_h_one->fill(pT, event.weight());
	_h_two->fill(pT, Nch, event.weight());
	_h_three->fill(fabs(eta), event.weight());
	}
	\end{snippet}

	Finally, histogram normalisations, scalings, divisions etc. are done in the
	\code{MyAnalysis::\-finalize()} method. For normalisations and scalings you will
	find appropriate convenience methods \code{Analysis::normalize(histo, norm)} and
	\code{Analysis::scale(histo, scalefactor)}. Many analyses need to be scaled to
	the generator cross-section, with the number of event weights to pass cuts being
	included in the normalisation factor: for this you will have to track the
	passed-cuts weight sum yourself via a member variable, but the analysis class
	provides \code{Analysis::crossSection()} and \code{Analysis::sumOfWeights()}
	methods to access the pre-cuts cross-section and weight sum respectively.


	\subsection{Analysis metadata}

	To keep the analysis source code uncluttered, and to allow for iteration of data
	plot presentation without re-compilation and/or re-running, Rivet prefers that
	analysis metadata is provided via separate files rather than hard-coded into the
	analysis library. There are two such files: an \emph{analysis info} file, with
	the suffix \kbd{.info}, and a \emph{plot styling} file, with the suffix
	\kbd{.plot}.

	\subsubsection{Analysis info files}

	The analysis info files are in YAML format: a simple data format intended to be
	cleaner and more human-readable/writeable than XML. As well as the analysis name
	(which must coincide with the filename and the name provided to the
	\kbd{Analysis} constructor, this file stores details of the collider,
	experiment, date of the analysis, Rivet/data analysis authors and contact email
	addresses, one-line and more complete descriptions of the analysis, advice on
	how to run it, suggested generator-level cuts, and BibTeX keys and entries for
	this user manual. It is also where the validation status of the analysis is declared:

	See the standard analyses' info files for guidance on how to populate this
	file. Info files are searched for in the paths known to the
	\kbd{Rivet::getAnalysisInfoPaths()} function, which many be prepended to using
	the \var{RIVET_INFO_PATH} environment variable: the first matching file to be
	found will be used.


	\subsubsection{Plot styling files}

	The \kbd{.plot} files are in the header format for the \kbd{make-plots} plotting
	system and are picked up and merged with the plot data by the Rivet
	\kbd{compare-histos} script which produces the \kbd{make-plots} input data
	files. All the analysis' plots should have a \kbd{BEGIN PLOT ... END PLOT}
	section in this file, specifying the title and $x$/$y$-axis labels (the
	\kbd{Title}, and \kbd{XLabel}/\kbd{YLabel} directives). In addition, you can use
	this file to choose whether the $x$ and/or $y$ axes should be shown with a log
	scale (\kbd{LogX}, \kbd{LogY}), to position the legend box to minimise clashes
	with the data points and MC lines (\kbd{LegendXPos}, \kbd{LegendYPos}) and any
	other valid \kbd{make-plots} directives including special text labels or forced
	plot range boundaries. Regular expressions may be used to apply a directive to
	all analysis names matching a pattern rather than having to specify the same
	directive repeatedly for many plots.

	See the standard analyses' plot files and the \kbd{make-plots} documentation
	(e.g. on the Rivet website) for guidance on how to write these files. Plot info
	files are searched for in the paths known to the
	\kbd{Rivet::getAnalysisPlotPaths()} function, which many be prepended to using
	the \var{RIVET_PLOT_PATH} environment variable. As usual, the first matching
	file to be found will be used.



	\subsection{Pluggable analyses}

	Rivet's standard analyses are not actually built into the main \kbd{libRivet}
	library: they are loaded dynamically at runtime as an analysis \emph{plugin
	library}. While you don't need to worry too much about the technicalities of
	this, it does mean that you can similarly write analyses of your own, compile
	them into a similar plugin library and run them from \kbd{rivet} without ever
	having to modify any of the main Rivet sources or build system. This means that
	you can write and run your own analyses with a system-installed copy of Rivet,
	and not have to re-patch the main library when a newer version comes out
	(although chances are you will have to recompile, since the binary interface usually
	change between releases.)

	To get started writing your analysis and understand the plugin system better,
	you should check out the documentation in the wiki on the Rivet website:
	\url{http://rivet.hepforge.org/trac/wiki/}. The standard
	\kbd{rivet-mkanalysis} and \kbd{rivet-buildplugin} scripts can respectively be
	used to make an analysis template with many ``boilerplate'' details filled in
	(including bibliographic information from Inspire if available), and to build a
	plugin library with the appropriate compiler options.


	\subsubsection{Plugin paths}

	To load pluggable analyses you will need to set the \var{RIVET_ANALYSIS_PATH}
	environment variable: this is a standard colon-separated UNIX path, specifying
	directories in which analysis plugin libraries may be found. If it is
	unspecified, the Rivet loader system will assume that the only entry is the
	\kbd{lib} directory in the Rivet installation area. Specifying the variable adds
	new paths for searching \emph{before} the standard library area, and they will
	be searched in the left-to-right order in the path variable.

	If analyses with duplicate names are found, a warning message is issued and the
	first version to have been found will be used. This allows you to override
	standard analyses with same-named variants of your own, provided they are loaded
	from different directories.

	\begin{change}
	In Rivet 2.1.0 and later, this \var{RIVET_ANALYSIS_PATH} variable (and the
	others described below) have an special extra syntax feature: if the
	environment variable ends with a double separator, i.e. \kbd{::}, then the
	default path will not be appended at all. This can be useful if you want to
	make absolutely certain not to fall back to the default locations, for example
	to avoid the ``duplicate analysis'' warnings if you are getting a lot of them.
	\end{change}

	Several further environment variables are used to load analysis reference data
	and metadata files:
	\begin{description}
	\item[\var{RIVET_REF_PATH}:] A standard colon-separated path list, whose
	elements are searched in order for reference histogram files. If the required
	file is not found in this path, Rivet will fall back to looking in the
	analysis library paths (for convenience, as it is normal for plugin analysis
	developers to put analysis library and data files in the same directory and it
	would be annoying to have to set several variables to make this work), and
	then the standard Rivet installation data directory.
	\item[\var{RIVET_INFO_PATH}:] The path list searched first for analysis
	\kbd{.info} metadata files. The search fallback mechanism works as for
	\var{RIVET_REF_PATH}.
	\item[\var{RIVET_PLOT_PATH}:] The path list searched first for analysis
	\kbd{.plot} presentation style files. The search fallbacks again work as for
	\var{RIVET_REF_PATH}.
	\end{description}
	%

	These paths can be accessed from the API using the
	\kbd{Rivet::getAnalysisLibPaths()} etc. functions, and can be searched for files
	using the Rivet lookup rules via the
	\kbd{Rivet::find\-Analysis\-LibFile(filename)} etc. functions. See the Doxygen
	documentation for more details. In the lookups using these paths, if the
	variable ends with a double separator, i.e. \kbd{::}, then the default path will
	not be appended: this may be useful in some situations. These functions are also
	available in the Python \kbd{rivet} module, with the same behaviours.



	\section{Using Rivet as a library}

	You don't have to use Rivet via the provided command-line programmes: for some
	applications you may want to have more direct control of how Rivet processes
	events. Here are some possible reasons:
	%
	\begin{itemize}
	\item You need to not waste CPU cycles and I/O resources on rendering HepMC
	events to a string representation which is immediately read back in. The FIFO
	idiom (Section~\ref{sec:fifo-idiom}) is not perfect: we use it in circumstances
	where the convenience and decoupling outweighs the CPU cost.
	\item You don't want to write out histograms to file, preferring to use them as
	code objects. Perhaps for applications which want to manipulate histogram data
	periodically before the end of the run.
	\item You enjoy tormenting Rivet developers who know their API is far from
	perfect, by complaining if it changes!
	\item \dots and many more!
	\end{itemize}

	The Rivet API (application programming interface) has been designed in the hope
	of very simple integration into other applications: all you have to do is create
	a \code{Rivet::Analysis\-Handler} object, tell it which analyses to apply on the
	events, and then call its \code{analyse(evt)} method for each HepMC event --
	wherever they come from. The API is (we hope) stable, with the exception of the
	histogramming parts.

	\begin{warning}
	The histogramming interfaces in Rivet have long been advertised as marked for
	replacement, and while progress in that area has lagger far behind our
	ambitions, it \emph{will} happen with the 2.0.0 release, with unavoidable
	impact on the related parts of the API. You have been warned!
	\end{warning}

	The API is available for C++ and, in a more restricted form, Python. We will
	explain the C++ version here; if you wish to operate Rivet (or e.g. use its
	path-searching capabilities to find Rivet-related files in the standard way)
	from Python then take a look inside the \kbd{rivet} and \kbd{rivet-*} Python
	scripts (e.g. \kbd{less `which rivet`}) or use the module documentation cf.
	%
	\begin{snippet}
	> python
	>>> import rivet
	>>> help(rivet)
	\end{snippet}

	And now the C++ API. The best way to explain is, of course, by example. Here is
	a simple C++ example based on the \kbd{test/testApi.cc} source which we use in
	development to ensure continuing API functionality:
	%
	\begin{snippet}
	#include "Rivet/AnalysisHandler.hh"
	#include "HepMC/GenEvent.h"
	#include "HepMC/IO_GenEvent.h"

	using namespace std;

	int main() {

	// Create analysis handler
	Rivet::AnalysisHandler rivet;

	// Specify the analyses to be used
	rivet.addAnalysis("D0_2008_S7554427");
	vector<string> moreanalyses(1, "D0_2007_S7075677");
	rivet.addAnalyses(moreanalyses);

	// The usual mess of reading from a HepMC file!
	std::istream* file = new std::fstream("testApi.hepmc", std::ios::in);
	HepMC::IO_GenEvent hepmcio(*file);
	HepMC::GenEvent* evt = hepmcio.read_next_event();
	double sum_of_weights = 0.0;
	while (evt) {
	// Analyse the current event
	rivet.analyze(*evt);
	sum_of_weights += evt->weights()[0];

	// Clean up and get next event
	delete evt; evt = 0;
	hepmcio >> evt;
	}
	delete file; file = 0;

	rivet.setCrossSection(1.0);
	rivet.setSumOfWeights(sum_of_weights); // not necessary, but allowed
	rivet.finalize();
	rivet.writeData("out");

	return 0;
	}
	\end{snippet}

	Compilation of this, if placed in a file called \kbd{myrivet.cc}, into an
	executable called \kbd{myrivet} is simplest and most robust with use of the
	\kbd{rivet-config} script:
	%
	\begin{snippet}
	g++ myrivet.cc -o myrivet `rivet-config --cppflags --ldflags --libs`
	\end{snippet}
	%
	It \emph{should} just work!

	If you are doing something a bit more advanced, for example using the AGILe
	package's similar API to generate Fortran generator Pythia events and pass them
	directly to the Rivet analysis handler, you will need to also add the various
	compiler and linker flags for the extra libraries, e.g.
	%
	\begin{snippet}
	g++ myrivet.cc -o myrivet \
	`rivet-config --cppflags --ldflags --libs` \
	`agile-config --cppflags --ldflags --libs`
	\end{snippet}
	%
	would be needed to compile the following AGILe+Rivet code:
	%
	\goodbreak
	\begin{snippet}
	#include "AGILe/Loader.hh"
	#include "AGILe/Generator.hh"
	#include "Rivet/AnalysisHandler.hh"
	#include "HepMC/GenEvent.h"
	#include "HepMC/IO_GenEvent.h"

	using namespace std;

	int main() {
	// Have a look what generators are available
	AGILe::Loader::initialize();
	const vector<string> gens = AGILe::Loader::getAvailableGens();
	foreach (const string& gen, gens) {
	cout << gen << endl;
	}

	// Load libraries for a specific generator and instantiate it
	AGILe::Loader::loadGenLibs("Pythia6:425");
	AGILe::Generator* generator = AGILe::Loader::createGen();
	cout << "Running " << generator->getName()
	<< " version " << generator->getVersion() << endl;

	// Set generator initial state for LEP
	const int particle1 = AGILe::ELECTRON;
	const int particle2 = AGILe::POSITRON;
	const double sqrts = 91;
	generator->setInitialState(particle1, energy1, sqrts/2.0, sqrts/2.0);
	generator->setSeed(14283);

	// Set some parameters
	generator->setParam("MSTP(5)", "320"); //< PYTHIA tune
	// ...

	// Set up Rivet with a LEP analysis
	Rivet::AnalysisHandler rivet;
	rivet.addAnalysis("DELPHI_1996_S3430090");

	// Run events
	const int EVTMAX = 10000;
	HepMC::GenEvent evt;
	for (int i = 0; i < EVTMAX; ++i) {
	generator->makeEvent(evt);
	rivet.analyze(evt);
	}

	// Finalize Rivet and generator
	rivet.finalize();
	- rivet.writeData("out.aida");
	+ rivet.writeData("out.yoda");
	generator->finalize();

	return 0;
	}
	\end{snippet}


	% \cleardoublepage
	% \part{How Rivet \emph{really} works}
	% \label{part:internals}
	%
	% In time this will be the place to look for all the nitty gritty on what Rivet is
	% doing internally. Not very many people need to know that, and the few that do
	% currently don't need a manual for it!
	%
	% \section{Projection caching}
	% \TODO{TODO}
	%
	% \subsection{Writing a Projection comparison operator}
	% \TODO{TODO}
	diff --git a/include/Rivet/Analyses/MC_JetAnalysis.hh b/include/Rivet/Analyses/MC_JetAnalysis.hh
	--- a/include/Rivet/Analyses/MC_JetAnalysis.hh
	+++ b/include/Rivet/Analyses/MC_JetAnalysis.hh
	@@ -1,66 +1,66 @@
	// -- C++ --
	#ifndef RIVET_MC_JetAnalysis_HH
	#define RIVET_MC_JetAnalysis_HH

	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Base class providing common functionality for MC jet validation analyses
	/// @todo Could reduce duplication by inheriting this from MC_ParticleAnalysis, with minor tweaking
	class MC_JetAnalysis : public Analysis {
	public:

	/// Default constructor.
	MC_JetAnalysis(const string& name,
	size_t njet,
	const string& jetpro_name,
	double jetptcut=20*GeV);


	/// @name Analysis methods
	//@{
	virtual void init();
	virtual void analyze(const Event& event);
	virtual void finalize();
	//@}


	protected:

	/// The number of jets for which histograms are to be initialised
	size_t _njet;

	/// The name of the jet projection to be used for this analysis
	/// (this projection has to be registered by the derived analysis!)
	const std::string _jetpro_name;

	/// Jet pT cutoff
	double _jetptcut;

	/// @todo Add jet masses and d(rap)

	/// @name Histograms
	//@{
	std::vector<Histo1DPtr> _h_pT_jet;
	std::vector<Histo1DPtr> _h_eta_jet;
	std::vector<Histo1DPtr> _h_eta_jet_plus, _h_eta_jet_minus;
	std::vector<Histo1DPtr> _h_rap_jet;
	std::vector<Histo1DPtr> _h_rap_jet_plus, _h_rap_jet_minus;
	std::vector<Histo1DPtr> _h_mass_jet;
	std::map<std::pair<size_t, size_t>, Histo1DPtr> _h_deta_jets;
	std::map<std::pair<size_t, size_t>, Histo1DPtr> _h_dphi_jets;
	std::map<std::pair<size_t, size_t>, Histo1DPtr> _h_dR_jets;
	Histo1DPtr _h_jet_multi_exclusive;
	Histo1DPtr _h_jet_multi_inclusive;
	Scatter2DPtr _h_jet_multi_ratio;
	- Histo1DPtr _h_jet_HT;
	+ Histo1DPtr _h_jet_HT, _h_mjj_jets;
	//@}

	};

	}

	#endif
	diff --git a/include/Rivet/Analysis.hh b/include/Rivet/Analysis.hh
	--- a/include/Rivet/Analysis.hh
	+++ b/include/Rivet/Analysis.hh
	@@ -1,947 +1,1040 @@
	// -- C++ --
	#ifndef RIVET_Analysis_HH
	#define RIVET_Analysis_HH

	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/AnalysisInfo.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/ProjectionApplier.hh"
	#include "Rivet/ProjectionHandler.hh"
	#include "Rivet/AnalysisLoader.hh"
	#include "Rivet/Tools/RivetYODA.hh"
	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Tools/ParticleUtils.hh"
	+#include "Rivet/Tools/Cuts.hh"


	/// @def vetoEvent
	/// Preprocessor define for vetoing events, including the log message and return.
	#define vetoEvent \
	do { MSG_DEBUG("Vetoing event on line " << __LINE__ << " of " << __FILE__); return; } while(0)


	namespace Rivet {


	// Forward declaration
	class AnalysisHandler;

	/// @brief This is the base class of all analysis classes in Rivet.
	///
	/// There are
	/// three virtual functions which should be implemented in base classes:
	///
	/// void init() is called by Rivet before a run is started. Here the
	/// analysis class should book necessary histograms. The needed
	/// projections should probably rather be constructed in the
	/// constructor.
	///
	/// void analyze(const Event&) is called once for each event. Here the
	/// analysis class should apply the necessary Projections and fill the
	/// histograms.
	///
	/// void finalize() is called after a run is finished. Here the analysis
	/// class should do whatever manipulations are necessary on the
	/// histograms. Writing the histograms to a file is, however, done by
	/// the Rivet class.
	class Analysis : public ProjectionApplier {

	/// The AnalysisHandler is a friend.
	friend class AnalysisHandler;


	public:

	/// @name Standard constructors and destructors.
	//@{

	// /// The default constructor.
	// Analysis();

	/// Constructor
	Analysis(const std::string& name);

	/// The destructor.
	virtual ~Analysis() {}

	//@}


	public:

	/// @name Main analysis methods
	//@{

	/// Initialize this analysis object. A concrete class should here
	/// book all necessary histograms. An overridden function must make
	/// sure it first calls the base class function.
	virtual void init() { }

	/// Analyze one event. A concrete class should here apply the
	/// necessary projections on the \a event and fill the relevant
	/// histograms. An overridden function must make sure it first calls
	/// the base class function.
	virtual void analyze(const Event& event) = 0;

	/// Finalize this analysis object. A concrete class should here make
	/// all necessary operations on the histograms. Writing the
	/// histograms to a file is, however, done by the Rivet class. An
	/// overridden function must make sure it first calls the base class
	/// function.
	virtual void finalize() { }

	//@}


	public:

	/// @name Metadata
	/// Metadata is used for querying from the command line and also for
	/// building web pages and the analysis pages in the Rivet manual.
	//@{

	/// Get the actual AnalysisInfo object in which all this metadata is stored.
	const AnalysisInfo& info() const {
	assert(_info && "No AnalysisInfo object :O");
	return *_info;
	}

	/// @brief Get the name of the analysis.
	///
	/// By default this is computed by combining the results of the experiment,
	/// year and Spires ID metadata methods and you should only override it if
	/// there's a good reason why those won't work.
	virtual std::string name() const {
	return (info().name().empty()) ? _defaultname : info().name();
	}

	/// Get the Inspire ID code for this analysis.
	virtual std::string inspireId() const {
	return info().inspireId();
	}

	/// Get the SPIRES ID code for this analysis (~deprecated).
	virtual std::string spiresId() const {
	return info().spiresId();
	}

	/// @brief Names & emails of paper/analysis authors.
	///
	/// Names and email of authors in 'NAME \<EMAIL\>' format. The first
	/// name in the list should be the primary contact person.
	virtual std::vector<std::string> authors() const {
	return info().authors();
	}

	/// @brief Get a short description of the analysis.
	///
	/// Short (one sentence) description used as an index entry.
	/// Use @a description() to provide full descriptive paragraphs
	/// of analysis details.
	virtual std::string summary() const {
	return info().summary();
	}

	/// @brief Get a full description of the analysis.
	///
	/// Full textual description of this analysis, what it is useful for,
	/// what experimental techniques are applied, etc. Should be treated
	/// as a chunk of restructuredText (http://docutils.sourceforge.net/rst.html),
	/// with equations to be rendered as LaTeX with amsmath operators.
	virtual std::string description() const {
	return info().description();
	}

	/// @brief Information about the events needed as input for this analysis.
	///
	/// Event types, energies, kinematic cuts, particles to be considered
	/// stable, etc. etc. Should be treated as a restructuredText bullet list
	/// (http://docutils.sourceforge.net/rst.html)
	virtual std::string runInfo() const {
	return info().runInfo();
	}

	/// Experiment which performed and published this analysis.
	virtual std::string experiment() const {
	return info().experiment();
	}

	/// Collider on which the experiment ran.
	virtual std::string collider() const {
	return info().collider();
	}

	/// When the original experimental analysis was published.
	virtual std::string year() const {
	return info().year();
	}

	+ /// The luminosity in inverse femtobarn
	+ virtual std::string luminosityfb() const {
	+ return info().luminosityfb();
	+ }
	+
	/// Journal, and preprint references.
	virtual std::vector<std::string> references() const {
	return info().references();
	}

	/// BibTeX citation key for this article.
	virtual std::string bibKey() const {
	return info().bibKey();
	}

	/// BibTeX citation entry for this article.
	virtual std::string bibTeX() const {
	return info().bibTeX();
	}

	/// Whether this analysis is trusted (in any way!)
	virtual std::string status() const {
	return (info().status().empty()) ? "UNVALIDATED" : info().status();
	}

	/// Any work to be done on this analysis.
	virtual std::vector<std::string> todos() const {
	return info().todos();
	}


	/// Return the allowed pairs of incoming beams required by this analysis.
	virtual const std::vector<PdgIdPair>& requiredBeams() const {
	return info().beams();
	}
	/// Declare the allowed pairs of incoming beams required by this analysis.
	virtual Analysis& setRequiredBeams(const std::vector<PdgIdPair>& requiredBeams) {
	info().setBeams(requiredBeams);
	return *this;
	}


	/// Sets of valid beam energy pairs, in GeV
	virtual const std::vector<std::pair<double, double> >& requiredEnergies() const {
	return info().energies();
	}
	+
	+ /// Get vector of analysis keywords
	+ virtual const std::vector<std::string> & keywords() const {
	+ return info().keywords();
	+ }
	+
	/// Declare the list of valid beam energy pairs, in GeV
	virtual Analysis& setRequiredEnergies(const std::vector<std::pair<double, double> >& requiredEnergies) {
	info().setEnergies(requiredEnergies);
	return *this;
	}


	/// Return true if this analysis needs to know the process cross-section.
	/// @todo Remove this and require HepMC >= 2.06
	bool needsCrossSection() const {
	return info().needsCrossSection();
	}
	/// Declare whether this analysis needs to know the process cross-section from the generator.
	/// @todo Remove this and require HepMC >= 2.06
	Analysis& setNeedsCrossSection(bool needed=true) {
	info().setNeedsCrossSection(needed);
	return *this;
	}

	//@}


	/// @name Internal metadata modifying methods
	//@{

	/// Get the actual AnalysisInfo object in which all this metadata is stored (non-const).
	AnalysisInfo& info() {
	assert(_info && "No AnalysisInfo object :O");
	return *_info;
	}

	//@}


	/// @name Run conditions
	//@{

	/// Incoming beams for this run
	const ParticlePair& beams() const;

	/// Incoming beam IDs for this run
	const PdgIdPair beamIds() const;

	/// Centre of mass energy for this run
	double sqrtS() const;

	//@}


	/// @name Analysis / beam compatibility testing
	//@{

	/// Check if analysis is compatible with the provided beam particle IDs and energies
	bool isCompatible(const ParticlePair& beams) const;

	/// Check if analysis is compatible with the provided beam particle IDs and energies
	bool isCompatible(PdgId beam1, PdgId beam2, double e1, double e2) const;

	/// Check if analysis is compatible with the provided beam particle IDs and energies
	bool isCompatible(const PdgIdPair& beams, const std::pair<double,double>& energies) const;

	//@}


	/// Set the cross section from the generator
	Analysis& setCrossSection(double xs);

	/// Access the controlling AnalysisHandler object.
	AnalysisHandler& handler() const { return *_analysishandler; }


	protected:

	/// Get a Log object based on the name() property of the calling analysis object.
	Log& getLog() const;

	/// Get the process cross-section in pb. Throws if this hasn't been set.
	double crossSection() const;

	/// Get the process cross-section per generated event in pb. Throws if this
	/// hasn't been set.
	double crossSectionPerEvent() const;

	/// Get the number of events seen (via the analysis handler). Use in the
	/// finalize phase only.
	size_t numEvents() const;

	/// Get the sum of event weights seen (via the analysis handler). Use in the
	/// finalize phase only.
	double sumOfWeights() const;


	protected:

	/// @name Histogram paths
	//@{

	/// Get the canonical histogram "directory" path for this analysis.
	const std::string histoDir() const;

	/// Get the canonical histogram path for the named histogram in this analysis.
	const std::string histoPath(const std::string& hname) const;

	/// Get the canonical histogram path for the numbered histogram in this analysis.
	const std::string histoPath(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const;

	/// Get the internal histogram name for given d, x and y (cf. HepData)
	const std::string makeAxisCode(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const;

	//@}


	/// @name Histogram reference data
	//@{

	/// Get reference data for a named histo
	/// @todo Move to the templated version when we have C++11 and can have a default fn template type
	const YODA::Scatter2D& refData(const string& hname) const;

	/// Get reference data for a numbered histo
	/// @todo Move to the templated version when we have C++11 and can have a default fn template type
	const YODA::Scatter2D& refData(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const;

	/// Get reference data for a named histo
	/// @todo Would be nice to just use these and ditch the S2D no-template version,
	/// but we need C++11 for default args in function templates
	// template <typename T=Scatter2D>
	/// @todo SFINAE to ensure that the type inherits from YODA::AnalysisObject?
	template <typename T>
	const T& refData(const string& hname) const {
	_cacheRefData();
	MSG_TRACE("Using histo bin edges for " << name() << ":" << hname);
	if (!_refdata[hname]) {
	MSG_ERROR("Can't find reference histogram " << hname);
	throw Exception("Reference data " + hname + " not found.");
	}
	return dynamic_cast<T&>(*_refdata[hname]);
	}

	/// Get reference data for a numbered histo
	/// @todo Would be nice to just use these and ditch the S2D no-template version,
	/// but we need C++11 for default args in function templates
	// template <typename T=Scatter2D>
	/// @todo SFINAE to ensure that the type inherits from YODA::AnalysisObject?
	template <typename T>
	const T& refData(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const {
	const string hname = makeAxisCode(datasetId, xAxisId, yAxisId);
	return refData(hname);
	}

	//@}


	/// @name Counter booking
	//@{

	/// Book a counter.
	CounterPtr bookCounter(const std::string& name,
	const std::string& title="");
	- // const std::string& xtitle="",
	- // const std::string& ytitle="");
	+ // const std::string& valtitle=""
	+
	+ /// Book a counter, using a path generated from the dataset and axis ID codes
	+ ///
	+ /// The paper, dataset and x/y-axis IDs will be used to build the histo name in the HepData standard way.
	+ CounterPtr bookCounter(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	+ const std::string& title="");
	+ // const std::string& valtitle=""

	//@}


	/// @name 1D histogram booking
	//@{

	/// Book a 1D histogram with @a nbins uniformly distributed across the range @a lower - @a upper .
	Histo1DPtr bookHisto1D(const std::string& name,
	size_t nbins, double lower, double upper,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// Book a 1D histogram with non-uniform bins defined by the vector of bin edges @a binedges .
	Histo1DPtr bookHisto1D(const std::string& name,
	const std::vector<double>& binedges,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// Book a 1D histogram with binning from a reference scatter.
	Histo1DPtr bookHisto1D(const std::string& name,
	const Scatter2D& refscatter,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// Book a 1D histogram, using the binnings in the reference data histogram.
	Histo1DPtr bookHisto1D(const std::string& name,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// Book a 1D histogram, using the binnings in the reference data histogram.
	///
	/// The paper, dataset and x/y-axis IDs will be used to build the histo name in the HepData standard way.
	Histo1DPtr bookHisto1D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	//@}


	/// @name 2D histogram booking
	//@{

	/// Book a 2D histogram with @a nxbins and @a nybins uniformly
	/// distributed across the ranges @a xlower - @a xupper and @a
	/// ylower - @a yupper respectively along the x- and y-axis.
	Histo2DPtr bookHisto2D(const std::string& name,
	size_t nxbins, double xlower, double xupper,
	size_t nybins, double ylower, double yupper,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="",
	const std::string& ztitle="");

	/// Book a 2D histogram with non-uniform bins defined by the
	/// vectorx of bin edges @a xbinedges and @a ybinedges.
	Histo2DPtr bookHisto2D(const std::string& name,
	const std::vector<double>& xbinedges,
	const std::vector<double>& ybinedges,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="",
	const std::string& ztitle="");

	// /// Book a 2D histogram with binning from a reference scatter.
	// Histo2DPtr bookHisto2D(const std::string& name,
	// const Scatter3D& refscatter,
	// const std::string& title="",
	// const std::string& xtitle="",
	// const std::string& ytitle="",
	// const std::string& ztitle="");

	// /// Book a 2D histogram, using the binnings in the reference data histogram.
	// Histo2DPtr bookHisto2D(const std::string& name,
	// const std::string& title="",
	// const std::string& xtitle="",
	// const std::string& ytitle="",
	// const std::string& ztitle="");

	// /// Book a 2D histogram, using the binnings in the reference data histogram.
	// ///
	// /// The paper, dataset and x/y-axis IDs will be used to build the histo name in the HepData standard way.
	// Histo2DPtr bookHisto2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	// const std::string& title="",
	// const std::string& xtitle="",
	// const std::string& ytitle="",
	// const std::string& ztitle="");

	//@}


	/// @name 1D profile histogram booking
	//@{

	/// Book a 1D profile histogram with @a nbins uniformly distributed across the range @a lower - @a upper .
	Profile1DPtr bookProfile1D(const std::string& name,
	size_t nbins, double lower, double upper,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// Book a 1D profile histogram with non-uniform bins defined by the vector of bin edges @a binedges .
	Profile1DPtr bookProfile1D(const std::string& name,
	const std::vector<double>& binedges,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// Book a 1D profile histogram with binning from a reference scatter.
	Profile1DPtr bookProfile1D(const std::string& name,
	const Scatter2D& refscatter,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// Book a 1D profile histogram, using the binnings in the reference data histogram.
	Profile1DPtr bookProfile1D(const std::string& name,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// Book a 1D profile histogram, using the binnings in the reference data histogram.
	///
	/// The paper, dataset and x/y-axis IDs will be used to build the histo name in the HepData standard way.
	Profile1DPtr bookProfile1D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	//@}


	/// @name 2D profile histogram booking
	//@{

	/// Book a 2D profile histogram with @a nxbins and @a nybins uniformly
	/// distributed across the ranges @a xlower - @a xupper and @a ylower - @a
	/// yupper respectively along the x- and y-axis.
	Profile2DPtr bookProfile2D(const std::string& name,
	size_t nxbins, double xlower, double xupper,
	size_t nybins, double ylower, double yupper,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="",
	const std::string& ztitle="");

	/// Book a 2D profile histogram with non-uniform bins defined by the vectorx
	/// of bin edges @a xbinedges and @a ybinedges.
	Profile2DPtr bookProfile2D(const std::string& name,
	const std::vector<double>& xbinedges,
	const std::vector<double>& ybinedges,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="",
	const std::string& ztitle="");

	/// Book a 2D profile histogram with binning from a reference scatter.
	// Profile2DPtr bookProfile2D(const std::string& name,
	// const Scatter3D& refscatter,
	// const std::string& title="",
	// const std::string& xtitle="",
	// const std::string& ytitle="",
	// const std::string& ztitle="");

	// /// Book a 2D profile histogram, using the binnings in the reference data histogram.
	// Profile2DPtr bookProfile2D(const std::string& name,
	// const std::string& title="",
	// const std::string& xtitle="",
	// const std::string& ytitle="",
	// const std::string& ztitle="");

	// /// Book a 2D profile histogram, using the binnings in the reference data histogram.
	// ///
	// /// The paper, dataset and x/y-axis IDs will be used to build the histo name in the HepData standard way.
	// Profile2DPtr bookProfile2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	// const std::string& title="",
	// const std::string& xtitle="",
	// const std::string& ytitle="",
	// const std::string& ztitle="");

	//@}


	/// @name 2D scatter booking
	//@{

	/// @brief Book a 2-dimensional data point set with the given name.
	///
	/// @note Unlike histogram booking, scatter booking by default makes no
	/// attempt to use reference data to pre-fill the data object. If you want
	/// this, which is sometimes useful e.g. when the x-position is not really
	/// meaningful and can't be extracted from the data, then set the @a
	/// copy_pts parameter to true. This creates points to match the reference
	/// data's x values and errors, but with the y values and errors zeroed...
	/// assuming that there is a reference histo with the same name: if there
	/// isn't, an exception will be thrown.
	Scatter2DPtr bookScatter2D(const std::string& name,
	bool copy_pts=false,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// @brief Book a 2-dimensional data point set, using the binnings in the reference data histogram.
	///
	/// The paper, dataset and x/y-axis IDs will be used to build the histo name in the HepData standard way.
	///
	/// @note Unlike histogram booking, scatter booking by default makes no
	/// attempt to use reference data to pre-fill the data object. If you want
	/// this, which is sometimes useful e.g. when the x-position is not really
	/// meaningful and can't be extracted from the data, then set the @a
	/// copy_pts parameter to true. This creates points to match the reference
	/// data's x values and errors, but with the y values and errors zeroed.
	Scatter2DPtr bookScatter2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	bool copy_pts=false,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// @brief Book a 2-dimensional data point set with equally spaced x-points in a range.
	///
	/// The y values and errors will be set to 0.
	Scatter2DPtr bookScatter2D(const std::string& name,
	size_t npts, double lower, double upper,
	const std::string& title="",
	const std::string& xtitle="",
	const std::string& ytitle="");

	/// @brief Book a 2-dimensional data point set based on provided contiguous "bin edges".
	///
	/// The y values and errors will be set to 0.
	Scatter2DPtr bookScatter2D(const std::string& hname,
	const std::vector<double>& binedges,
	const std::string& title,
	const std::string& xtitle,
	const std::string& ytitle);

	//@}


	- /// @todo What follows should really be protected: only public to keep BinnedHistogram happy for now...
	public:

	- /// @name Histogram manipulation
	+
	+ /// @name Analysis object manipulation
	+ /// @todo Should really be protected: only public to keep BinnedHistogram happy for now...
	//@{

	+ /// Multiplicatively scale the given counter, @a cnt, by factor @s factor.
	+ void scale(CounterPtr cnt, double factor);
	+
	+ /// Multiplicatively scale the given counters, @a cnts, by factor @s factor.
	+ /// @note Constness intentional, if weird, to allow passing rvalue refs of smart ptrs (argh)
	+ /// @todo Use SFINAE for a generic iterable of CounterPtrs
	+ void scale(const std::vector<CounterPtr>& cnts, double factor) {
	+ for (auto& c : cnts) scale(c, factor);
	+ }
	+ /// @todo YUCK!
	+ template <std::size_t array_size>
	+ void scale(const CounterPtr (&cnts)[array_size], double factor) {
	+ // for (size_t i = 0; i < std::extent<decltype(cnts)>::value; ++i) scale(cnts[i], factor);
	+ for (auto& c : cnts) scale(c, factor);
	+ }
	+
	+
	/// Normalize the given histogram, @a histo, to area = @a norm.
	- ///
	- /// @note The histogram is no longer invalidated by this procedure.
	void normalize(Histo1DPtr histo, double norm=1.0, bool includeoverflows=true);

	- /// Multiplicatively scale the given histogram, @a histo, by factor @s scale.
	- ///
	- /// @note The histogram is no longer invalidated by this procedure.
	- void scale(Histo1DPtr histo, double scale);
	+ /// Normalize the given histograms, @a histos, to area = @a norm.
	+ /// @note Constness intentional, if weird, to allow passing rvalue refs of smart ptrs (argh)
	+ /// @todo Use SFINAE for a generic iterable of Histo1DPtrs
	+ void normalize(const std::vector<Histo1DPtr>& histos, double norm=1.0, bool includeoverflows=true) {
	+ for (auto& h : histos) normalize(h, norm, includeoverflows);
	+ }
	+ /// @todo YUCK!
	+ template <std::size_t array_size>
	+ void normalize(const Histo1DPtr (&histos)[array_size], double norm=1.0, bool includeoverflows=true) {
	+ for (auto& h : histos) normalize(h, norm, includeoverflows);
	+ }
	+
	+ /// Multiplicatively scale the given histogram, @a histo, by factor @s factor.
	+ void scale(Histo1DPtr histo, double factor);
	+
	+ /// Multiplicatively scale the given histograms, @a histos, by factor @s factor.
	+ /// @note Constness intentional, if weird, to allow passing rvalue refs of smart ptrs (argh)
	+ /// @todo Use SFINAE for a generic iterable of Histo1DPtrs
	+ void scale(const std::vector<Histo1DPtr>& histos, double factor) {
	+ for (auto& h : histos) scale(h, factor);
	+ }
	+ /// @todo YUCK!
	+ template <std::size_t array_size>
	+ void scale(const Histo1DPtr (&histos)[array_size], double factor) {
	+ for (auto& h : histos) scale(h, factor);
	+ }
	+

	/// Normalize the given histogram, @a histo, to area = @a norm.
	- ///
	- /// @note The histogram is no longer invalidated by this procedure.
	void normalize(Histo2DPtr histo, double norm=1.0, bool includeoverflows=true);

	- /// Multiplicatively scale the given histogram, @a histo, by factor @s scale.
	+ /// Normalize the given histograms, @a histos, to area = @a norm.
	+ /// @note Constness intentional, if weird, to allow passing rvalue refs of smart ptrs (argh)
	+ /// @todo Use SFINAE for a generic iterable of Histo2DPtrs
	+ void normalize(const std::vector<Histo2DPtr>& histos, double norm=1.0, bool includeoverflows=true) {
	+ for (auto& h : histos) normalize(h, norm, includeoverflows);
	+ }
	+ /// @todo YUCK!
	+ template <std::size_t array_size>
	+ void normalize(const Histo2DPtr (&histos)[array_size], double norm=1.0, bool includeoverflows=true) {
	+ for (auto& h : histos) normalize(h, norm, includeoverflows);
	+ }
	+
	+ /// Multiplicatively scale the given histogram, @a histo, by factor @s factor.
	+ void scale(Histo2DPtr histo, double factor);
	+
	+ /// Multiplicatively scale the given histograms, @a histos, by factor @s factor.
	+ /// @note Constness intentional, if weird, to allow passing rvalue refs of smart ptrs (argh)
	+ /// @todo Use SFINAE for a generic iterable of Histo2DPtrs
	+ void scale(const std::vector<Histo2DPtr>& histos, double factor) {
	+ for (auto& h : histos) scale(h, factor);
	+ }
	+ /// @todo YUCK!
	+ template <std::size_t array_size>
	+ void scale(const Histo2DPtr (&histos)[array_size], double factor) {
	+ for (auto& h : histos) scale(h, factor);
	+ }
	+
	+
	+ /// Helper for counter division.
	///
	- /// @note The histogram is no longer invalidated by this procedure.
	- void scale(Histo2DPtr histo, double scale);
	+ /// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	+ void divide(CounterPtr c1, CounterPtr c2, Scatter1DPtr s) const;
	+
	+ /// Helper for histogram division with raw YODA objects.
	+ ///
	+ /// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	+ void divide(const YODA::Counter& c1, const YODA::Counter& c2, Scatter1DPtr s) const;


	/// Helper for histogram division.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void divide(Histo1DPtr h1, Histo1DPtr h2, Scatter2DPtr s) const;

	/// Helper for histogram division with raw YODA objects.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void divide(const YODA::Histo1D& h1, const YODA::Histo1D& h2, Scatter2DPtr s) const;


	/// Helper for profile histogram division.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void divide(Profile1DPtr p1, Profile1DPtr p2, Scatter2DPtr s) const;

	/// Helper for profile histogram division with raw YODA objects.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void divide(const YODA::Profile1D& p1, const YODA::Profile1D& p2, Scatter2DPtr s) const;


	/// Helper for 2D histogram division.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void divide(Histo2DPtr h1, Histo2DPtr h2, Scatter3DPtr s) const;

	/// Helper for 2D histogram division with raw YODA objects.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void divide(const YODA::Histo2D& h1, const YODA::Histo2D& h2, Scatter3DPtr s) const;


	/// Helper for 2D profile histogram division.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void divide(Profile2DPtr p1, Profile2DPtr p2, Scatter3DPtr s) const;

	/// Helper for 2D profile histogram division with raw YODA objects
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void divide(const YODA::Profile2D& p1, const YODA::Profile2D& p2, Scatter3DPtr s) const;


	/// Helper for histogram efficiency calculation.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void efficiency(Histo1DPtr h1, Histo1DPtr h2, Scatter2DPtr s) const;

	/// Helper for histogram efficiency calculation.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void efficiency(const YODA::Histo1D& h1, const YODA::Histo1D& h2, Scatter2DPtr s) const;


	/// Helper for histogram asymmetry calculation.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void asymm(Histo1DPtr h1, Histo1DPtr h2, Scatter2DPtr s) const;

	/// Helper for histogram asymmetry calculation.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void asymm(const YODA::Histo1D& h1, const YODA::Histo1D& h2, Scatter2DPtr s) const;


	/// Helper for converting a differential histo to an integral one.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void integrate(Histo1DPtr h, Scatter2DPtr s) const;

	/// Helper for converting a differential histo to an integral one.
	///
	/// @note Assigns to the (already registered) output scatter, @a s. Preserves the path information of the target.
	void integrate(const Histo1D& h, Scatter2DPtr s) const;

	//@}


	public:

	/// List of registered analysis data objects
	const vector<AnalysisObjectPtr>& analysisObjects() const {
	return _analysisobjects;
	}


	protected:

	/// @name Data object registration, retrieval, and removal
	//@{

	/// Register a data object in the histogram system
	void addAnalysisObject(AnalysisObjectPtr ao);

	/// Get a data object from the histogram system
	/// @todo Use this default function template arg in C++11
	// template <typename AO=AnalysisObjectPtr>
	template <typename AO>
	const std::shared_ptr<AO> getAnalysisObject(const std::string& name) const {
	foreach (const AnalysisObjectPtr& ao, analysisObjects()) {
	if (ao->path() == histoPath(name)) return dynamic_pointer_cast<AO>(ao);
	}
	throw Exception("Data object " + histoPath(name) + " not found");
	}

	/// Get a data object from the histogram system (non-const)
	/// @todo Use this default function template arg in C++11
	// template <typename AO=AnalysisObjectPtr>
	template <typename AO>
	std::shared_ptr<AO> getAnalysisObject(const std::string& name) {
	foreach (const AnalysisObjectPtr& ao, analysisObjects()) {
	if (ao->path() == histoPath(name)) return dynamic_pointer_cast<AO>(ao);
	}
	throw Exception("Data object " + histoPath(name) + " not found");
	}

	/// Unregister a data object from the histogram system (by name)
	void removeAnalysisObject(const std::string& path);

	/// Unregister a data object from the histogram system (by pointer)
	void removeAnalysisObject(AnalysisObjectPtr ao);


	/// Get a named Histo1D object from the histogram system
	const Histo1DPtr getHisto1D(const std::string& name) const {
	return getAnalysisObject<Histo1D>(name);
	}

	/// Get a named Histo1D object from the histogram system (non-const)
	Histo1DPtr getHisto1D(const std::string& name) {
	return getAnalysisObject<Histo1D>(name);
	}

	/// Get a Histo1D object from the histogram system by axis ID codes (non-const)
	const Histo1DPtr getHisto1D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const {
	return getAnalysisObject<Histo1D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	}

	/// Get a Histo1D object from the histogram system by axis ID codes (non-const)
	Histo1DPtr getHisto1D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) {
	return getAnalysisObject<Histo1D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	}


	// /// Get a named Histo2D object from the histogram system
	// const Histo2DPtr getHisto2D(const std::string& name) const {
	// return getAnalysisObject<Histo2D>(name);
	// }

	// /// Get a named Histo2D object from the histogram system (non-const)
	// Histo2DPtr getHisto2D(const std::string& name) {
	// return getAnalysisObject<Histo2D>(name);
	// }

	// /// Get a Histo2D object from the histogram system by axis ID codes (non-const)
	// const Histo2DPtr getHisto2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const {
	// return getAnalysisObject<Histo2D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	// }

	// /// Get a Histo2D object from the histogram system by axis ID codes (non-const)
	// Histo2DPtr getHisto2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) {
	// return getAnalysisObject<Histo2D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	// }


	/// Get a named Profile1D object from the histogram system
	const Profile1DPtr getProfile1D(const std::string& name) const {
	return getAnalysisObject<Profile1D>(name);
	}

	/// Get a named Profile1D object from the histogram system (non-const)
	Profile1DPtr getProfile1D(const std::string& name) {
	return getAnalysisObject<Profile1D>(name);
	}

	/// Get a Profile1D object from the histogram system by axis ID codes (non-const)
	const Profile1DPtr getProfile1D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const {
	return getAnalysisObject<Profile1D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	}

	/// Get a Profile1D object from the histogram system by axis ID codes (non-const)
	Profile1DPtr getProfile1D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) {
	return getAnalysisObject<Profile1D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	}


	// /// Get a named Profile2D object from the histogram system
	// const Profile2DPtr getProfile2D(const std::string& name) const {
	// return getAnalysisObject<Profile2D>(name);
	// }

	// /// Get a named Profile2D object from the histogram system (non-const)
	// Profile2DPtr getProfile2D(const std::string& name) {
	// return getAnalysisObject<Profile2D>(name);
	// }

	// /// Get a Profile2D object from the histogram system by axis ID codes (non-const)
	// const Profile2DPtr getProfile2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const {
	// return getAnalysisObject<Profile2D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	// }

	// /// Get a Profile2D object from the histogram system by axis ID codes (non-const)
	// Profile2DPtr getProfile2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) {
	// return getAnalysisObject<Profile2D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	// }


	/// Get a named Scatter2D object from the histogram system
	const Scatter2DPtr getScatter2D(const std::string& name) const {
	return getAnalysisObject<Scatter2D>(name);
	}

	/// Get a named Scatter2D object from the histogram system (non-const)
	Scatter2DPtr getScatter2D(const std::string& name) {
	return getAnalysisObject<Scatter2D>(name);
	}

	/// Get a Scatter2D object from the histogram system by axis ID codes (non-const)
	const Scatter2DPtr getScatter2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const {
	return getAnalysisObject<Scatter2D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	}

	/// Get a Scatter2D object from the histogram system by axis ID codes (non-const)
	Scatter2DPtr getScatter2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) {
	return getAnalysisObject<Scatter2D>(makeAxisCode(datasetId, xAxisId, yAxisId));
	}

	//@}


	private:

	/// Name passed to constructor (used to find .info analysis data file, and as a fallback)
	string _defaultname;

	/// Pointer to analysis metadata object
	unique_ptr<AnalysisInfo> _info;

	/// Storage of all plot objects
	/// @todo Make this a map for fast lookup by path?
	vector<AnalysisObjectPtr> _analysisobjects;

	/// @name Cross-section variables
	//@{
	double _crossSection;
	bool _gotCrossSection;
	//@}

	/// The controlling AnalysisHandler object.
	AnalysisHandler* _analysishandler;

	/// Collection of cached refdata to speed up many autobookings: the
	/// reference data file should only be read once.
	mutable std::map<std::string, AnalysisObjectPtr> _refdata;


	private:

	/// @name Utility functions
	//@{

	/// Get the reference data for this paper and cache it.
	void _cacheRefData() const;

	//@}


	/// The assignment operator is private and must never be called.
	/// In fact, it should not even be implemented.
	Analysis& operator=(const Analysis&);

	};


	}


	// Include definition of analysis plugin system so that analyses automatically see it when including Analysis.hh
	#include "Rivet/AnalysisBuilder.hh"

	/// @def DECLARE_RIVET_PLUGIN
	/// Preprocessor define to prettify the global-object plugin hook mechanism.
	#define DECLARE_RIVET_PLUGIN(clsname) Rivet::AnalysisBuilder<clsname> plugin_ ## clsname

	/// @def DECLARE_ALIASED_RIVET_PLUGIN
	/// Preprocessor define to prettify the global-object plugin hook mechanism, with an extra alias name for this analysis.
	// #define DECLARE_ALIASED_RIVET_PLUGIN(clsname, alias) Rivet::AnalysisBuilder<clsname> plugin_ ## clsname ## ( ## #alias ## )
	#define DECLARE_ALIASED_RIVET_PLUGIN(clsname, alias) DECLARE_RIVET_PLUGIN(clsname)( #alias )

	-/// @def DEFAULT_RIVET_ANA_CONSTRUCTOR
	+/// @def DEFAULT_RIVET_ANALYSIS_CONSTRUCTOR
	/// Preprocessor define to prettify the manky constructor with name string argument
	-#define DEFAULT_RIVET_ANA_CONSTRUCTOR(clsname) clsname() : Analysis(# clsname) {}
	+#define DEFAULT_RIVET_ANALYSIS_CONSTRUCTOR(clsname) clsname() : Analysis(# clsname) {}
	+
	+/// @def DEFAULT_RIVET_ANALYSIS_CTOR
	+/// Slight abbreviation for DEFAULT_RIVET_ANALYSIS_CONSTRUCTOR
	+#define DEFAULT_RIVET_ANALYSIS_CTOR(clsname) DEFAULT_RIVET_ANALYSIS_CONSTRUCTOR(clsname)
	+


	#endif
	diff --git a/include/Rivet/AnalysisInfo.hh b/include/Rivet/AnalysisInfo.hh
	--- a/include/Rivet/AnalysisInfo.hh
	+++ b/include/Rivet/AnalysisInfo.hh
	@@ -1,247 +1,258 @@
	// -- C++ --
	#ifndef RIVET_AnalysisInfo_HH
	#define RIVET_AnalysisInfo_HH

	#include "Rivet/Config/RivetCommon.hh"
	#include <ostream>

	namespace Rivet {


	class AnalysisInfo {
	public:

	/// Static factory method: returns null pointer if no metadata found
	static unique_ptr<AnalysisInfo> make(const std::string& name);

	/// @name Standard constructors and destructors.
	//@{

	/// The default constructor.
	AnalysisInfo() { clear(); }

	/// The destructor.
	~AnalysisInfo() { }

	//@}


	public:

	/// @name Metadata
	/// Metadata is used for querying from the command line and also for
	/// building web pages and the analysis pages in the Rivet manual.
	//@{

	/// Get the name of the analysis. By default this is computed using the
	/// experiment, year and Inspire/Spires ID metadata methods.
	std::string name() const {
	if (!_name.empty()) return _name;
	if (!experiment().empty() && !year().empty()) {
	if (!inspireId().empty()) {
	return experiment() + "_" + year() + "_I" + inspireId();
	} else if (!spiresId().empty()) {
	return experiment() + "_" + year() + "_S" + spiresId();
	}
	}
	return "";
	}

	/// Set the name of the analysis.
	void setName(const std::string& name) { _name = name; }


	/// Get the Inspire (SPIRES replacement) ID code for this analysis.
	const std::string& inspireId() const { return _inspireId; }

	/// Set the Inspire (SPIRES replacement) ID code for this analysis.
	void setInspireId(const std::string& inspireId) { _inspireId = inspireId; }


	/// Get the SPIRES ID code for this analysis.
	const std::string& spiresId() const { return _spiresId; }

	/// Set the SPIRES ID code for this analysis.
	void setSpiresId(const std::string& spiresId) { _spiresId = spiresId; }


	/// @brief Names & emails of paper/analysis authors.
	/// Names and email of authors in 'NAME \<EMAIL\>' format. The first
	/// name in the list should be the primary contact person.
	const std::vector<std::string>& authors() const { return _authors; }

	/// Set the author list.
	void setAuthors(const std::vector<std::string>& authors) { _authors = authors; }


	/// @brief Get a short description of the analysis.
	/// Short (one sentence) description used as an index entry.
	/// Use @a description() to provide full descriptive paragraphs
	/// of analysis details.
	const std::string& summary() const { return _summary; }

	/// Set the short description for this analysis.
	void setSummary(const std::string& summary) { _summary = summary; }


	/// @brief Get a full description of the analysis.
	/// Full textual description of this analysis, what it is useful for,
	/// what experimental techniques are applied, etc. Should be treated
	/// as a chunk of restructuredText (http://docutils.sourceforge.net/rst.html),
	/// with equations to be rendered as LaTeX with amsmath operators.
	const std::string& description() const { return _description; }

	/// Set the full description for this analysis.
	void setDescription(const std::string& description) { _description = description; }


	/// @brief Information about the events needed as input for this analysis.
	/// Event types, energies, kinematic cuts, particles to be considered
	/// stable, etc. etc. Should be treated as a restructuredText bullet list
	/// (http://docutils.sourceforge.net/rst.html)
	const std::string& runInfo() const { return _runInfo; }

	/// Set the full description for this analysis.
	void setRunInfo(const std::string& runInfo) { _runInfo = runInfo; }


	/// Beam particle types
	const std::vector<PdgIdPair>& beams() const { return _beams; }

	/// Set beam particle types
	void setBeams(const std::vector<PdgIdPair>& beams) { _beams = beams; }


	/// Sets of valid beam energies
	const std::vector<std::pair<double,double> >& energies() const { return _energies; }

	/// Set the valid beam energies
	void setEnergies(const std::vector<std::pair<double, double> >& energies) { _energies = energies; }


	/// Experiment which performed and published this analysis.
	const std::string& experiment() const { return _experiment; }

	/// Set the experiment which performed and published this analysis.
	void setExperiment(const std::string& experiment) { _experiment = experiment; }


	/// Collider on which the experiment ran.
	const std::string& collider() const { return _collider; }

	/// Set the collider on which the experiment ran.
	void setCollider(const std::string& collider) { _collider = collider; }


	/// @brief When the original experimental analysis was published.
	/// When the refereed paper on which this is based was published,
	/// according to SPIRES.
	const std::string& year() const { return _year; }

	/// Set the year in which the original experimental analysis was published.
	void setYear(const std::string& year) { _year = year; }

	+ /// The integrated data luminosity of the data set
	+ const std::string& luminosityfb() const { return _luminosityfb; }
	+
	+ /// Set the integrated data luminosity of the data set
	+ void setLuminosityfb(const std::string& luminosityfb) { _luminosityfb = luminosityfb; }

	/// Journal and preprint references.
	const std::vector<std::string>& references() const { return _references; }

	/// Set the journal and preprint reference list.
	void setReferences(const std::vector<std::string>& references) { _references = references; }

	+ /// Analysis Keywords for grouping etc
	+ const std::vector<std::string>& keywords() const { return _keywords; }

	/// BibTeX citation key for this article.
	const std::string& bibKey() const { return _bibKey;}

	/// Set the BibTeX citation key for this article.
	void setBibKey(const std::string& bibKey) { _bibKey = bibKey; }


	/// BibTeX citation entry for this article.
	const std::string& bibTeX() const { return _bibTeX; }

	/// Set the BibTeX citation entry for this article.
	void setBibTeX(const std::string& bibTeX) { _bibTeX = bibTeX; }


	/// Whether this analysis is trusted (in any way!)
	const std::string& status() const { return _status; }

	/// Set the analysis code status.
	void setStatus(const std::string& status) { _status = status; }


	/// Any work to be done on this analysis.
	const std::vector<std::string>& todos() const { return _todos; }

	/// Set the to-do list.
	void setTodos(const std::vector<std::string>& todos) { _todos = todos; }


	/// Return true if this analysis needs to know the process cross-section.
	bool needsCrossSection() const { return _needsCrossSection; }

	/// Return true if this analysis needs to know the process cross-section.
	void setNeedsCrossSection(bool needXsec) { _needsCrossSection = needXsec; }

	//@}


	private:

	std::string _name;
	std::string _spiresId, _inspireId;
	std::vector<std::string> _authors;
	std::string _summary;
	std::string _description;
	std::string _runInfo;
	std::string _experiment;
	std::string _collider;
	std::vector<std::pair<PdgId, PdgId> > _beams;
	std::vector<std::pair<double, double> > _energies;
	std::string _year;
	+ std::string _luminosityfb;
	std::vector<std::string> _references;
	+ std::vector<std::string> _keywords;
	std::string _bibKey;
	std::string _bibTeX;
	//std::string _bibTeXBody; ///< Was thinking of avoiding duplication of BibKey...
	std::string _status;
	std::vector<std::string> _todos;
	bool _needsCrossSection;

	void clear() {
	_name = "";
	_spiresId = "";
	_inspireId = "";
	_authors.clear();
	_summary = "";
	_description = "";
	_runInfo = "";
	_experiment = "";
	_collider = "";
	_beams.clear();
	_energies.clear();
	_year = "";
	+ _luminosityfb = "";
	_references.clear();
	+ _keywords.clear();
	_bibKey = "";
	_bibTeX = "";
	//_bibTeXBody = "";
	_status = "";
	_todos.clear();
	_needsCrossSection = false;
	}

	};


	/// String representation
	std::string toString(const AnalysisInfo& ai);

	/// Stream an AnalysisInfo as a text description
	inline std::ostream& operator<<(std::ostream& os, const AnalysisInfo& ai) {
	os << toString(ai);
	return os;
	}


	}

	#endif
	diff --git a/include/Rivet/Config/RivetCommon.hh b/include/Rivet/Config/RivetCommon.hh
	--- a/include/Rivet/Config/RivetCommon.hh
	+++ b/include/Rivet/Config/RivetCommon.hh
	@@ -1,59 +1,29 @@
	#ifndef RIVET_RivetCommon_HH
	#define RIVET_RivetCommon_HH

	// Convenience build-setup header for Rivet internal use


	// Automatic build info from autoconf
	#include "Rivet/Config/RivetConfig.hh"
	#include "Rivet/Config/BuildOptions.hh"

	-
	-/// Macro to help with overzealous compiler warnings
	-/// @note It's easier and better to just not give an arg name to args which won't be used, when possible.
	-#ifdef UNUSED
	-#elif defined(__GNUC__)
	-# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
	-#elif defined(__LCLINT__)
	-# define UNUSED(x) /@unused@/ x
	-#else
	-# define UNUSED(x) x
	-#endif
	-
	-
	-/// Macro to help mark code as deprecated to produce compiler warnings
	-#ifndef DEPRECATED
	-#if __GNUC__ && __cplusplus && RIVET_NO_DEPRECATION_WARNINGS == 0
	-#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
	-#if GCC_VERSION >= 40500
	- #if __cplusplus > 201103L
	- #define DEPRECATED(x) [[deprecated(x)]]
	- #else
	- #define DEPRECATED(x) __attribute__((deprecated(x)))
	- #endif
	-#else
	- #define DEPRECATED(x) __attribute__((deprecated))
	-#endif
	-#else
	- #define DEPRECATED(x)
	-#endif
	-#endif
	-
	-
	-#include "Rivet/Exceptions.hh"
	-
	#include "Rivet/Tools/RivetSTL.hh"
	#include "Rivet/Tools/RivetHepMC.hh"

	+#include "Rivet/Tools/Exceptions.hh"
	+#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Tools/Utils.hh"
	-#include "Rivet/Tools/Logging.hh"

	#include "Rivet/Math/Units.hh"
	-#include "Rivet/ParticleName.hh"
	+#include "Rivet/Math/Constants.hh"
	+#include "Rivet/Tools/ParticleName.hh"
	#include "Rivet/Tools/ParticleIdUtils.hh"

	-#include "Rivet/Math/MathUtils.hh"
	+#include "Rivet/Math/Math.hh"
	#include "Rivet/Math/Vectors.hh"
	-#include "Rivet/Math/Constants.hh"
	+
	+// #include "Rivet/Tools/Cmp.hh"
	+// #include "Rivet/Tools/Cuts.hh"

	#endif
	diff --git a/include/Rivet/Event.hh b/include/Rivet/Event.hh
	--- a/include/Rivet/Event.hh
	+++ b/include/Rivet/Event.hh
	@@ -1,156 +1,174 @@
	// -- C++ --
	#ifndef RIVET_Event_HH
	#define RIVET_Event_HH

	#include "Rivet/Config/RivetCommon.hh"
	+#include "Rivet/Particle.hh"
	#include "Rivet/Projection.hh"
	-// #include "Rivet/Particle.hh"
	-// #include "Rivet/Math/Vector3.hh"
	-// #include "Rivet/Math/LorentzTrans.hh"

	namespace Rivet {


	/// Rivet wrapper for HepMC event and Projection references.
	///
	/// Event is a concrete class representing an generated event in Rivet. It is
	/// constructed given a HepMC::GenEvent, a pointer to which is kept by the
	/// Event object throughout its lifetime. The user must therefore make sure
	/// that the corresponding HepMC::GenEvent will persist at least as long as
	/// the Event object.
	///
	/// In addition to the HepMC::GenEvent object the Event also keeps track of
	/// all Projection objects which have been applied to the Event so far.
	class Event {
	public:

	/// @name Constructors and destructors.
	//@{

	/// Constructor from a HepMC GenEvent pointer
	Event(const GenEvent* ge)
	- : _originalGenEvent(ge), _genEvent(*ge)
	+ : _genevent_original(ge), _genevent(*ge)
	{ assert(ge); _init(*ge); }

	/// Constructor from a HepMC GenEvent reference
	/// @deprecated HepMC uses pointers, so we should talk to HepMC via pointers
	Event(const GenEvent& ge)
	- : _originalGenEvent(&ge), _genEvent(ge)
	+ : _genevent_original(&ge), _genevent(ge)
	{ _init(ge); }

	/// Copy constructor
	Event(const Event& e)
	- : _originalGenEvent(e._originalGenEvent), _genEvent(e._genEvent)
	+ : _genevent_original(e._genevent_original), _genevent(e._genevent)
	{ }

	//@}


	/// @name Major event properties
	//@{

	- // /// Get the beam particles
	- // ParticlePair beams() const;
	+ /// Get the beam particles
	+ ParticlePair beams() const;

	- // /// Get the beam centre-of-mass energy
	- // double sqrtS() const;
	+ /// Get the beam centre-of-mass energy
	+ double sqrtS() const;

	- // /// Get the beam centre-of-mass energy per nucleon
	- // double asqrtS() const;
	+ /// Get the beam centre-of-mass energy per nucleon
	+ double asqrtS() const;

	// /// Get the boost to the beam centre-of-mass
	// Vector3 beamCMSBoost() const;

	// /// Get the boost to the beam centre-of-mass
	// LorentzTransform beamCMSTransform();

	/// The generated event obtained from an external event generator
	- const GenEvent* genEvent() const { return &_genEvent; }
	+ const GenEvent* genEvent() const { return &_genevent; }
	+
	+ /// All the raw GenEvent particles, wrapped in Rivet::Particle objects
	+ const Particles& allParticles() const;
	+
	+ /// @brief All the raw GenEvent particles, wrapped in Rivet::Particle objects, but with a Cut applied
	+ ///
	+ /// @note Due to the cut, this returns by value, i.e. involves an expensive copy
	+ inline Particles allParticles(const Cut& c) const {
	+ return filter_select(allParticles(), c);
	+ }
	+
	+ /// @brief All the raw GenEvent particles, wrapped in Rivet::Particle objects, but with a selection function applied
	+ ///
	+ /// @note Due to the cut, this returns by value, i.e. involves an expensive copy
	+ template <typename FN>
	+ inline Particles allParticles(const FN& f) const {
	+ return filter_select(allParticles(), f);
	+ }

	/// @brief The generation weight associated with the event
	///
	/// @todo This needs to be revisited when we finally add the mechanism to
	/// support NLO counter-events and weight vectors.
	- double weight() const {
	- return (!_genEvent.weights().empty()) ? _genEvent.weights()[0] : 1.0;
	- }
	+ double weight() const;

	//@}


	/// @name Projection running
	//@{

	/// @brief Add a projection @a p to this Event.
	///
	/// If an equivalent Projection has been applied before, the
	/// Projection::project(const Event&) of @a p is not called and a reference
	/// to the previous equivalent projection is returned. If no previous
	/// Projection was found, the Projection::project(const Event&) of @a p is
	/// called and a reference to @a p is returned.
	template <typename PROJ>
	const PROJ& applyProjection(PROJ& p) const {
	const Projection* cpp(&p);
	std::set<const Projection*>::const_iterator old = _projections.find(cpp);
	if (old != _projections.end()) {
	const Projection& pRef = **old;
	return pcast<PROJ>(pRef);
	}
	// Add the projection via the Projection base class (only
	// possible because Event is a friend of Projection)
	Projection* pp = const_cast<Projection*>(cpp);
	pp->project(*this);
	_projections.insert(pp);
	return p;
	}

	/// @brief Add a projection @a p to this Event by pointer.
	template <typename PROJ>
	const PROJ& applyProjection(PROJ* pp) const {
	if (!pp) throw Error("Event::applyProjection(PROJ*): Projection pointer is null.");
	return applyProjection(*pp);
	}

	//@}


	private:

	/// @brief Actual (shared) implementation of the constructors from GenEvents
	void _init(const GenEvent& ge);

	// /// @brief Convert the GenEvent to use conventional alignment
	// ///
	// /// For example, FHerwig only produces DIS events in the unconventional
	// /// hadron-lepton orientation and has to be corrected for DIS analysis
	// /// portability.
	// void _geNormAlignment();

	/// @brief The generated event, as obtained from an external generator.
	///
	/// This is the original GenEvent. In practise the version seen by users
	/// will often/always be a modified one.
	///
	/// @todo Provide access to this via an Event::originalGenEvent() method? If requested...
	- const GenEvent* _originalGenEvent;
	+ const GenEvent* _genevent_original;

	/// @brief The GenEvent used by Rivet analysis projections etc.
	///
	/// This version may be rotated to a "normal" alignment, have
	/// generator-specific particles stripped out, etc. If an analysis is
	/// affected by these modifications, it is probably an unphysical analysis!
	///
	/// Stored as a non-pointer since it may get overwritten, and memory for
	/// copying and cleanup is neater this way.
	/// @todo Change needed for HepMC3?
	- GenEvent _genEvent;
	+ mutable GenEvent _genevent;

	- /// The set of Projection objects applied so far.
	+ /// All the GenEvent particles, wrapped as Rivet::Particles
	+ /// @note To be populated lazily, hence mutability
	+ mutable Particles _particles;
	+
	+ /// The set of Projection objects applied so far
	mutable std::set<ConstProjectionPtr> _projections;

	};


	}

	#endif
	diff --git a/include/Rivet/Jet.hh b/include/Rivet/Jet.hh
	--- a/include/Rivet/Jet.hh
	+++ b/include/Rivet/Jet.hh
	@@ -1,271 +1,274 @@
	// -- C++ --
	#ifndef RIVET_Jet_HH
	#define RIVET_Jet_HH

	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Jet.fhh"
	#include "Rivet/Particle.hh"
	-#include "Rivet/Cuts.hh"
	-#include "Rivet/Tools/ParticleUtils.hh"
	+#include "Rivet/Tools/Cuts.hh"
	+#include "Rivet/Tools/Utils.hh"
	#include "Rivet/Tools/RivetFastJet.hh"
	-// #include "fastjet/PseudoJet.hh"
	+#include "Rivet/Math/LorentzTrans.hh"
	#include <numeric>

	namespace Rivet {


	/// @brief Representation of a clustered jet of particles.
	class Jet : public ParticleBase {
	public:

	/// @name Constructors
	//@{

	/// Constructor from a FastJet PseudoJet, with optional full particle constituents information.
	Jet(const fastjet::PseudoJet& pj, const Particles& particles=Particles(), const Particles& tags=Particles()) {
	setState(pj, particles, tags);
	}

	/// Set the jet data, with optional full particle information.
	Jet(const FourMomentum& pjet, const Particles& particles=Particles(), const Particles& tags=Particles()) {
	setState(pjet, particles, tags);
	}

	- /// Set all the jet data, with full particle information.
	- /// @deprecated Prefer the form where the 4-vec comes first and the particles list is optional.
	- DEPRECATED("Prefer the form where the 4-vec comes first and the particles list is optional.")
	- Jet(const Particles& particles, const FourMomentum& pjet) {
	- setState(pjet, particles);
	- }
	-
	/// Default constructor -- only for STL storability
	Jet() { clear(); }

	//@}


	/// @name Access jet constituents
	//@{

	/// Number of particles in this jet.
	size_t size() const { return _particles.size(); }

	/// Get the particles in this jet.
	- vector<Particle>& particles() { return _particles; }
	+ Particles& particles() { return _particles; }
	/// Get the particles in this jet (const version)
	- const vector<Particle>& particles() const { return _particles; }
	+ const Particles& particles() const { return _particles; }
	+ /// Get the particles in this jet which pass a cut (const)
	+ const Particles particles(const Cut& c) const { return filterBy(_particles, c); }

	/// Get the particles in this jet (FastJet-like alias)
	- vector<Particle>& constituents() { return particles(); }
	+ Particles& constituents() { return particles(); }
	/// Get the particles in this jet (FastJet-like alias, const version)
	- const vector<Particle>& constituents() const { return particles(); }
	+ const Particles& constituents() const { return particles(); }
	+ /// Get the particles in this jet which pass a cut (FastJet-like alias, const)
	+ const Particles constituents(const Cut& c) const { return particles(c); }

	/// Check whether this jet contains a particular particle.
	bool containsParticle(const Particle& particle) const;
	/// Nicer alias for containsParticleId
	bool containsPID(const Particle& particle) const { return containsParticle(particle); }

	/// Check whether this jet contains a certain particle type.
	bool containsParticleId(PdgId pid) const;
	/// Nicer alias for containsParticleId
	bool containsPID(PdgId pid) const { return containsParticleId(pid); }

	/// Check whether this jet contains at least one of certain particle types.
	bool containsParticleId(const vector<PdgId>& pids) const;
	/// Nicer alias for containsParticleId
	bool containsPID(const vector<PdgId>& pids) const { return containsParticleId(pids); }

	//@}


	/// @name Tagging
	///
	/// @note General sources of tag particles are planned. The default jet finding
	/// adds b-hadron, c-hadron, and tau tags by ghost association.
	//@{

	/// @brief Particles which have been tag-matched to this jet
	Particles& tags() { return _tags; }
	/// @brief Particles which have been tag-matched to this jet (const version)
	const Particles& tags() const { return _tags; }
	+ /// @brief Particles which have been tag-matched to this jet _and_ pass a selector function
	+ ///
	+ /// @note Note the less efficient return by value, due to the filtering.
	+ template <typename FN>
	+ Particles tags(const FN& f) const { return filter_select(tags(), f); }
	/// @brief Particles which have been tag-matched to this jet _and_ pass a Cut
	///
	/// @note Note the less efficient return by value, due to the cut-pass filtering.
	Particles tags(const Cut& c) const;


	/// @brief b particles which have been tag-matched to this jet (and pass an optional Cut)
	///
	/// The default jet finding adds b-hadron tags by ghost association.
	Particles bTags(const Cut& c=Cuts::open()) const;
	+ /// @brief b particles which have been tag-matched to this jet _and_ pass a selector function
	+ template <typename FN>
	+ Particles bTags(const FN& f) const { return filter_select(bTags(), f); }
	+
	/// Does this jet have at least one b-tag (that passes an optional Cut)?
	bool bTagged(const Cut& c=Cuts::open()) const { return !bTags(c).empty(); }
	+ /// Does this jet have at least one b-tag (that passes the supplied selector function)?
	+ template <typename FN>
	+ bool bTagged(const FN& f) const { return !bTags(f).empty(); }


	/// @brief c (and not b) particles which have been tag-matched to this jet (and pass an optional Cut)
	///
	/// The default jet finding adds c-hadron tags by ghost association.
	Particles cTags(const Cut& c=Cuts::open()) const;
	+ /// @brief c (and not b) particles which have been tag-matched to this jet and pass a selector function
	+ template <typename FN>
	+ Particles cTags(const FN& f) const { return filter_select(cTags(), f); }
	+
	/// Does this jet have at least one c-tag (that passes an optional Cut)?
	bool cTagged(const Cut& c=Cuts::open()) const { return !cTags(c).empty(); }
	+ /// Does this jet have at least one c-tag (that passes the supplied selector function)?
	+ template <typename FN>
	+ bool cTagged(const FN& f) const { return !cTags(f).empty(); }


	/// @brief Tau particles which have been tag-matched to this jet (and pass an optional Cut)
	///
	/// The default jet finding adds tau tags by ghost association.
	Particles tauTags(const Cut& c=Cuts::open()) const;
	+ /// @brief Tau particles which have been tag-matched to this jet and pass a selector function
	+ template <typename FN>
	+ Particles tauTags(const FN& f) const { return filter_select(tauTags(), f); }
	+
	/// Does this jet have at least one tau-tag (that passes an optional Cut)?
	bool tauTagged(const Cut& c=Cuts::open()) const { return !tauTags(c).empty(); }
	+ /// Does this jet have at least one tau-tag (that passes the supplied selector function)?
	+ template <typename FN>
	+ bool tauTagged(const FN& f) const { return !tauTags(f).empty(); }


	/// @brief Check whether this jet contains a bottom-flavoured hadron.
	///
	/// @deprecated The bTags() or bTagged() function is probably what you want
	/// for tagging. This one ignores the tags() list and draws conclusions
	/// based directly on the jet constituents; the other gives a much better match
	/// to typical experimental methods.
	///
	/// @note The decision is made by first trying to find a bottom-flavoured particle
	/// in the particles list. Most likely this will fail unless bottom hadrons
	/// are set stable. If @a include_decay_products is true (the default), a
	/// fallback is attempted, using the post-hadronization ancestor history of
	/// all constituents.
	- //DEPRECATED("Prefer the bTags() or bTagged() function")
	+ DEPRECATED("Prefer the bTags() or bTagged() function")
	bool containsBottom(bool include_decay_products=true) const;

	/// @brief Check whether this jet contains a charm-flavoured hadron.
	///
	/// @deprecated The cTags() or cTagged() function is probably what you want
	/// for tagging. This one ignores the tags() list and draws conclusions
	/// based directly on the jet constituents; the other gives a much better match
	/// to typical experimental methods.
	///
	/// @note The decision is made by first trying to find a charm-flavoured particle
	/// in the particles list. Most likely this will fail unless charmed hadrons
	/// are set stable. If @a include_decay_products is true (the default), a
	/// fallback is attempted, using the post-hadronization ancestor history of
	/// all constituents.
	- //DEPRECATED("Prefer the cTags() or cTagged() function")
	+ DEPRECATED("Prefer the cTags() or cTagged() function")
	bool containsCharm(bool include_decay_products=true) const;

	//@}


	- /// @name Access additional effective jet 4-vector properties
	+ /// @name Effective jet 4-vector properties
	//@{

	/// Get equivalent single momentum four-vector.
	const FourMomentum& momentum() const { return _momentum; }

	+ /// Apply an active Lorentz transform to this jet
	+ /// @note The Rivet jet momentum, constituent particles, and tag particles will be modified.
	+ /// @warning The FastJet cluster sequence and pseudojets will not be modified: don't use them after transformation!
	+ Jet& transformBy(const LorentzTransform& lt);
	+
	/// Get the total energy of this jet.
	double totalEnergy() const { return momentum().E(); }

	/// Get the energy carried in this jet by neutral particles.
	double neutralEnergy() const;

	/// Get the energy carried in this jet by hadrons.
	double hadronicEnergy() const;

	//@}


	/// @name Interaction with FastJet
	//@{

	/// Access the internal FastJet3 PseudoJet (as a const reference)
	const fastjet::PseudoJet& pseudojet() const { return _pseudojet; }

	/// Cast operator to FastJet3 PseudoJet (as a const reference)
	operator const fastjet::PseudoJet& () const { return pseudojet(); }

	//@}


	/// @name Set the jet constituents and properties
	//@{

	/// @brief Set the jet data from a FastJet PseudoJet, with optional particle constituents and tags lists.
	///
	/// @note The particles() list will be extracted from PseudoJet constituents
	/// by default, making use of an attached user info if one is found.
	Jet& setState(const fastjet::PseudoJet& pj, const Particles& particles=Particles(), const Particles& tags=Particles());

	/// Set all the jet data, with optional full particle constituent and tag information.
	Jet& setState(const FourMomentum& mom, const Particles& particles, const Particles& tags=Particles());

	- /// @deprecated Prefer the 4-mom first-arg versions. Remove in Rivet v3
	- DEPRECATED("Prefer the 4-mom first-arg versions")
	- Jet& setState(const Particles& particles, const FourMomentum& mom) { return setState(mom, particles); }
	-
	/// @brief Set the particles collection with full particle information.
	///
	/// If set, this overrides particle info extracted from the PseudoJet
	Jet& setParticles(const Particles& particles);
	Jet& setConstituents(const Particles& particles) { return setParticles(particles); }

	/// Reset this jet as empty.
	Jet& clear();

	//@}


	private:

	/// FJ3 PseudoJet member to unify PseudoJet and Jet
	fastjet::PseudoJet _pseudojet;

	/// Full constituent particle information. (Filled from PseudoJet if possible.)
	/// @todo Make these mutable or similar? Add a flag to force a cache rebuild?
	Particles _particles;

	/// Particles used to tag this jet (can be anything, but c and b hadrons are the most common)
	Particles _tags;

	/// Effective jet 4-vector (just for caching)
	mutable FourMomentum _momentum;

	};


	- /// @name Unbound functions for filtering jets
	+ /// @name String representation and streaming support
	//@{

	- /// Filter a jet collection in-place to the subset that passes the supplied Cut
	- Jets& filterBy(Jets& jets, const Cut& c);
	+ /// Represent a Jet as a string.
	+ std::string to_str(const Jet& j);

	- /// Get a subset of the supplied jets that passes the supplied Cut
	- Jets filterBy(const Jets& jets, const Cut& c);
	-
	- //@}
	-
	-
	- /// @name Unbound functions for converting between Jets, Particles and PseudoJets
	- //@{
	-
	- inline PseudoJets mkPseudoJets(const Particles& ps) {
	- PseudoJets rtn; rtn.reserve(ps.size());
	- for (const Particle& p : ps)
	- rtn.push_back(p);
	- return rtn;
	- }
	-
	- inline PseudoJets mkPseudoJets(const Jets& js) {
	- PseudoJets rtn; rtn.reserve(js.size());
	- for (const Jet& j : js)
	- rtn.push_back(j);
	- return rtn;
	- }
	-
	- inline Jets mkJets(const PseudoJets& pjs) {
	- Jets rtn; rtn.reserve(pjs.size());
	- for (const PseudoJet& pj : pjs)
	- rtn.push_back(pj);
	- return rtn;
	+ /// Allow a Jet to be passed to an ostream.
	+ inline std::ostream& operator<<(std::ostream& os, const Jet& j) {
	+ os << to_str(j);
	+ return os;
	}

	//@}


	}

	+
	+#include "Rivet/Tools/JetUtils.hh"
	+
	#endif
	diff --git a/include/Rivet/Makefile.am b/include/Rivet/Makefile.am
	--- a/include/Rivet/Makefile.am
	+++ b/include/Rivet/Makefile.am
	@@ -1,134 +1,157 @@
	## Internal headers - not to be installed
	nobase_dist_noinst_HEADERS =
	## Public headers - to be installed
	nobase_pkginclude_HEADERS =


	## Rivet interface
	nobase_pkginclude_HEADERS += \
	- Rivet.hh Exceptions.hh \
	- Event.hh Run.hh \
	- ParticleBase.hh ParticleName.hh \
	- Particle.fhh Particle.hh \
	- Jet.fhh Jet.hh \
	- ProjectionApplier.hh ProjectionHandler.hh \
	- Projection.fhh Projection.hh \
	- Cmp.fhh Cmp.hh \
	- BeamConstraint.hh AnalysisHandler.hh \
	- Analysis.hh AnalysisInfo.hh \
	- AnalysisBuilder.hh AnalysisLoader.hh \
	- Cuts.fhh Cuts.hh
	+ Rivet.hh \
	+ Run.hh \
	+ Event.hh \
	+ ParticleBase.hh \
	+ Particle.fhh Particle.hh \
	+ Jet.fhh Jet.hh \
	+ Projection.fhh Projection.hh \
	+ ProjectionApplier.hh \
	+ ProjectionHandler.hh \
	+ Analysis.hh \
	+ AnalysisHandler.hh \
	+ AnalysisInfo.hh \
	+ AnalysisBuilder.hh \
	+ AnalysisLoader.hh
	+

	## Build config stuff
	nobase_pkginclude_HEADERS += \
	Config/RivetCommon.hh \
	Config/RivetConfig.hh \
	Config/BuildOptions.hh


	## Projections
	-nobase_pkginclude_HEADERS += \
	+nobase_pkginclude_HEADERS += \
	Projections/AxesDefinition.hh \
	- Projections/Beam.hh \
	- Projections/BeamThrust.hh \
	- Projections/CentralEtHCM.hh \
	+ Projections/Beam.hh \
	+ Projections/BeamThrust.hh \
	+ Projections/CentralEtHCM.hh \
	+ Projections/CentralityEstimator.hh \
	Projections/ChargedFinalState.hh \
	Projections/ChargedLeptons.hh \
	Projections/ConstLossyFinalState.hh \
	- Projections/DISFinalState.hh \
	- Projections/DISKinematics.hh \
	- Projections/DISLepton.hh \
	+ Projections/DISFinalState.hh \
	+ Projections/DISKinematics.hh \
	+ Projections/DISLepton.hh \
	Projections/DressedLeptons.hh \
	- Projections/FastJets.hh \
	- Projections/FinalPartons.hh \
	- Projections/FinalState.hh \
	+ Projections/FastJets.hh \
	+ Projections/FinalPartons.hh \
	+ Projections/FinalState.hh \
	Projections/FoxWolframMoments.hh \
	Projections/FParameter.hh \
	Projections/HadronicFinalState.hh \
	Projections/HeavyHadrons.hh \
	- Projections/Hemispheres.hh \
	+ Projections/Hemispheres.hh \
	Projections/IdentifiedFinalState.hh \
	Projections/InitialQuarks.hh \
	Projections/InvMassFinalState.hh \
	- Projections/JetAlg.hh \
	- Projections/JetShape.hh \
	+ Projections/JetAlg.hh \
	+ Projections/JetShape.hh \
	Projections/LeadingParticlesFinalState.hh \
	Projections/LossyFinalState.hh \
	Projections/MergedFinalState.hh \
	Projections/MissingMomentum.hh \
	Projections/NeutralFinalState.hh \
	Projections/NonHadronicFinalState.hh \
	- Projections/ParticleFinder.hh \
	- Projections/ParisiTensor.hh \
	+ Projections/NonPromptFinalState.hh \
	+ Projections/ParisiTensor.hh \
	+ Projections/ParticleFinder.hh \
	+ Projections/PartonicTops.hh \
	Projections/PrimaryHadrons.hh \
	Projections/PromptFinalState.hh \
	Projections/SmearedParticles.hh \
	Projections/SmearedJets.hh \
	+ Projections/SmearedMET.hh \
	Projections/Sphericity.hh \
	Projections/Spherocity.hh \
	Projections/TauFinder.hh \
	Projections/Thrust.hh \
	Projections/TriggerCDFRun0Run1.hh \
	Projections/TriggerCDFRun2.hh \
	Projections/TriggerUA5.hh \
	Projections/UnstableFinalState.hh \
	Projections/VetoedFinalState.hh \
	Projections/VisibleFinalState.hh \
	Projections/WFinder.hh \
	Projections/ZFinder.hh
	+## Meta-projection convenience headers
	+nobase_pkginclude_HEADERS += \
	+ Projections/FinalStates.hh \
	+ Projections/Smearing.hh


	## Analysis base class headers
	nobase_pkginclude_HEADERS += \
	Analyses/MC_ParticleAnalysis.hh \
	Analyses/MC_JetAnalysis.hh \
	Analyses/MC_JetSplittings.hh


	## Tools
	nobase_pkginclude_HEADERS += \
	+ Tools/BeamConstraint.hh \
	+ Tools/BinnedHistogram.hh \
	+ Tools/CentralityHistogram.hh \
	+ Tools/Cmp.fhh \
	+ Tools/Cmp.hh \
	+ Tools/Cutflow.hh \
	+ Tools/Cuts.fhh \
	+ Tools/Cuts.hh \
	+ Tools/Exceptions.hh \
	+ Tools/JetUtils.hh \
	Tools/Logging.hh \
	- Tools/Utils.hh \
	+ Tools/ParticleBaseUtils.hh \
	+ Tools/ParticleIdUtils.hh \
	+ Tools/ParticleUtils.hh \
	+ Tools/ParticleName.hh \
	+ Tools/PrettyPrint.hh \
	Tools/RivetPaths.hh \
	Tools/RivetSTL.hh \
	Tools/RivetFastJet.hh \
	Tools/RivetHepMC.hh \
	Tools/RivetYODA.hh \
	Tools/RivetMT2.hh \
	- Tools/BinnedHistogram.hh \
	- Tools/ParticleUtils.hh \
	- Tools/ParticleIdUtils.hh \
	Tools/SmearingFunctions.hh \
	- Tools/TypeTraits.hh
	+ Tools/TypeTraits.hh \
	+ Tools/Utils.hh
	nobase_dist_noinst_HEADERS += \
	Tools/osdir.hh


	## Maths
	nobase_pkginclude_HEADERS += \
	Math/Matrices.hh \
	Math/Vector3.hh \
	Math/VectorN.hh \
	Math/MatrixN.hh \
	Math/MatrixDiag.hh \
	Math/MathHeader.hh \
	Math/Vectors.hh \
	Math/LorentzTrans.hh \
	Math/Matrix3.hh \
	Math/MathUtils.hh \
	Math/Vector4.hh \
	Math/Math.hh \
	Math/Units.hh \
	Math/Constants.hh \
	Math/eigen/util.h \
	Math/eigen/regressioninternal.h \
	Math/eigen/regression.h \
	Math/eigen/vector.h \
	Math/eigen/ludecompositionbase.h \
	Math/eigen/ludecomposition.h \
	Math/eigen/linearsolver.h \
	Math/eigen/linearsolverbase.h \
	Math/eigen/matrix.h \
	Math/eigen/vectorbase.h \
	Math/eigen/projective.h \
	Math/eigen/matrixbase.h
	diff --git a/include/Rivet/Math/LorentzTrans.hh b/include/Rivet/Math/LorentzTrans.hh
	--- a/include/Rivet/Math/LorentzTrans.hh
	+++ b/include/Rivet/Math/LorentzTrans.hh
	@@ -1,199 +1,270 @@
	#ifndef RIVET_MATH_LORENTZTRANS
	#define RIVET_MATH_LORENTZTRANS

	#include "Rivet/Math/MathHeader.hh"
	#include "Rivet/Math/MathUtils.hh"
	#include "Rivet/Math/MatrixN.hh"
	#include "Rivet/Math/Matrix3.hh"
	#include "Rivet/Math/Vector4.hh"
	#include <iostream>

	namespace Rivet {


	- /// @name Simple Lorentz factor conversions
	- //@{
	-
	- /// Calculate the gamma factor from beta
	- inline double lorentzBeta2Gamma(double beta) {
	- return 1.0 / sqrt(1 - sqr(beta));
	- }
	-
	- /// Calculate beta from the gamma factor
	- inline double lorentzGamma2Beta(double gamma) {
	- return sqrt(1 - sqr(1/gamma));
	- }
	-
	- //@}
	-
	-
	/// @brief Object implementing Lorentz transform calculations and boosts.
	///
	/// @note These boosts are defined actively, i.e. as modifications of vectors
	/// rather than frame transformations. So the boost vector is the opposite of
	/// what you might expect.
	///
	/// @todo Review the active/passive convention choice. Seems counterintuitive now...
	class LorentzTransform {
	public:

	- // friend string toString(const LorentzTransform& lt); ///< @todo Ick!
	+ /// @name Simple Lorentz factor conversions
	+ //@{

	+ /// Calculate the \f$ \gamma \f$ factor from \f$ \beta \f$
	+ static double beta2gamma(double beta) {
	+ return 1.0 / sqrt(1 - sqr(beta));
	+ }
	+
	+ /// Calculate \f$ \beta \f$ from the \f$ \gamma \f$ factor
	+ static double gamma2beta(double gamma) {
	+ return sqrt(1 - sqr(1/gamma));
	+ }
	+
	+ // /// Calculate the \f$ \gamma \f$ factor from \f$ \bar{\beta}^2 = 1-\beta^2 \f$
	+ // static double betabarsq2gamma(double betabarsq) {
	+ // return 1.0 / sqrt(betabarsq);
	+ // }
	+
	+ // /// Calculate \f$ \bar{\beta}^2 = 1-\beta^2 \f$ from the \f$ \gamma \f$ factor
	+ // static double gamma2betabarsq(double gamma) {
	+ // return 1.0 / sqr(gamma);
	+ // }
	+
	+ //@}
	+
	+
	+ /// @name Construction
	+ //@{
	+
	+ /// Default (identity) constructor
	LorentzTransform() {
	_boostMatrix = Matrix<4>::mkIdentity();
	}

	- LorentzTransform(const Vector3& boost) {
	- setBoost(boost);
	+
	+ /// Make an LT for an active boost (i.e. object velocity += in boost direction)
	+ static LorentzTransform mkObjTransformFromBeta(const Vector3& vbeta) {
	+ LorentzTransform rtn;
	+ return rtn.setBetaVec(vbeta);
	}

	- LorentzTransform(double betaX, double betaY, double betaZ) {
	- setBoost(betaX, betaY, betaZ);
	+ /// Make an LT for a passive boost (i.e. object velocity -= in boost direction)
	+ static LorentzTransform mkFrameTransformFromBeta(const Vector3& vbeta) {
	+ LorentzTransform rtn;
	+ return rtn.setBetaVec(-vbeta);
	}

	- /// Set the \f$ \vec\beta \f$ vector for an active Lorentz boost
	- LorentzTransform& setBoost(const Vector3& boost) {
	- assert(boost.mod2() < 1);
	- const double beta = boost.mod();
	- const double gamma = lorentzBeta2Gamma(beta);
	+ /// Make an LT for an active boost (i.e. object velocity += in boost direction)
	+ static LorentzTransform mkObjTransformFromGamma(const Vector3& vgamma) {
	+ LorentzTransform rtn;
	+ if (!vgamma.isZero()) rtn.setGammaVec(vgamma);
	+ return rtn;
	+ }
	+
	+ /// Make an LT for a passive boost (i.e. object velocity -= in boost direction)
	+ static LorentzTransform mkFrameTransformFromGamma(const Vector3& vgamma) {
	+ LorentzTransform rtn;
	+ if (!vgamma.isZero()) rtn.setGammaVec(-vgamma);
	+ return rtn;
	+ }
	+
	+ //@}
	+
	+
	+ /// @name Boost vector and beta/gamma factors
	+ //@{
	+
	+ /// Set up an active Lorentz boost from the \f$ \vec\beta \f$ vector
	+ LorentzTransform& setBetaVec(const Vector3& vbeta) {
	+ assert(vbeta.mod2() < 1);
	+ const double beta = vbeta.mod();
	+ const double gamma = beta2gamma(beta);
	_boostMatrix = Matrix<4>::mkIdentity();
	_boostMatrix.set(0, 0, gamma);
	_boostMatrix.set(1, 1, gamma);
	- // Positive coeff since these are active boosts
	- _boostMatrix.set(0, 1, +beta*gamma);
	- _boostMatrix.set(1, 0, +beta*gamma);
	- if (beta > 0) _boostMatrix = rotate(Vector3::mkX(), boost)._boostMatrix;
	+ _boostMatrix.set(0, 1, +beta*gamma); //< +ve coeff since active boost
	+ _boostMatrix.set(1, 0, +beta*gamma); //< +ve coeff since active boost
	+ if (beta > 0) _boostMatrix = rotate(Vector3::mkX(), vbeta)._boostMatrix;
	return *this;
	}

	- /// Set the \f$ \vec\beta \f$ vector for an active Lorentz boost, as 3-components
	- LorentzTransform& setBoost(double betaX, double betaY, double betaZ) {
	- return setBoost(Vector3(betaX, betaY, betaZ));
	- }
	-
	/// Get the \f$ \vec\beta \f$ vector for an active Lorentz boost
	- Vector3 boost() const {
	- FourMomentum boost(_boostMatrix.getColumn(0));
	+ Vector3 betaVec() const {
	+ FourMomentum boost(_boostMatrix.getColumn(0)); //< @todo WRONG?!
	//cout << "!!!" << boost << endl;
	- if (boost.isZero()) return boost;
	+ if (boost.isZero()) return Vector3();
	assert(boost.E() > 0);
	const double beta = boost.p3().mod() / boost.E();
	return boost.p3().unit() * beta;
	}

	/// Get the \f$ \beta \f$ factor
	double beta() const {
	- return boost().mod();
	+ return betaVec().mod();
	+ }
	+
	+
	+ /// Set up an active Lorentz boost from the \f$ \vec\gamma \f$ vector
	+ LorentzTransform& setGammaVec(const Vector3& vgamma) {
	+ const double gamma = vgamma.mod();
	+ const double beta = gamma2beta(gamma);
	+ _boostMatrix = Matrix<4>::mkIdentity();
	+ _boostMatrix.set(0, 0, gamma);
	+ _boostMatrix.set(1, 1, gamma);
	+ _boostMatrix.set(0, 1, +beta*gamma); //< +ve coeff since active boost
	+ _boostMatrix.set(1, 0, +beta*gamma); //< +ve coeff since active boost
	+ if (beta > 0) _boostMatrix = rotate(Vector3::mkX(), vgamma)._boostMatrix;
	+ return *this;
	+ }
	+
	+ /// Get the \f$ \vec\gamma \f$ vector for an active Lorentz boost
	+ Vector3 gammaVec() const {
	+ FourMomentum boost(_boostMatrix.getColumn(0)); //< @todo WRONG?!
	+ if (boost.isZero()) return Vector3();
	+ assert(boost.E() > 0);
	+ const double beta = boost.p3().mod() / boost.E();
	+ return boost.p3().unit() * beta;
	}

	/// Get the \f$ \gamma \f$ factor
	double gamma() const {
	- return lorentzBeta2Gamma(beta());
	+ return beta2gamma(beta());
	}

	+ //@}
	+
	+
	+ /// Apply this transformation to the given 4-vector
	+ FourVector transform(const FourVector& v4) const {
	+ return multiply(_boostMatrix, v4);
	+ }
	+
	+ /// Apply this transformation to the given 4-mometum
	+ FourMomentum transform(const FourMomentum& v4) const {
	+ return multiply(_boostMatrix, v4);
	+ }
	+
	+
	+ /// @name Transform modifications
	+ //@{
	+
	+ /// Rotate the transformation cf. the difference between vectors @a from and @a to
	LorentzTransform rotate(const Vector3& from, const Vector3& to) const {
	return rotate(Matrix3(from, to));
	}

	+ /// Rotate the transformation by @a angle radians about @a axis
	LorentzTransform rotate(const Vector3& axis, double angle) const {
	return rotate(Matrix3(axis, angle));
	}

	+ /// Rotate the transformation by the 3D rotation matrix @a rot
	LorentzTransform rotate(const Matrix3& rot) const {
	LorentzTransform lt = *this;
	const Matrix4 rot4 = _mkMatrix4(rot);
	const Matrix4 newlt = rot4 * _boostMatrix * rot4.inverse();
	lt._boostMatrix = newlt;
	return lt;
	}

	- /// Apply this transformation to the given 4-vector
	- FourVector transform(const FourVector& v4) const {
	- return multiply(_boostMatrix, v4);
	- }
	-
	/// Calculate the inverse transform
	LorentzTransform inverse() const {
	LorentzTransform rtn;
	rtn._boostMatrix = _boostMatrix.inverse();
	return rtn;
	}

	-
	/// Combine LTs, treating @a this as the LH matrix.
	LorentzTransform combine(const LorentzTransform& lt) const {
	LorentzTransform rtn;
	rtn._boostMatrix = _boostMatrix * lt._boostMatrix;
	return rtn;
	}

	- /// Return the matrix form
	- Matrix4 toMatrix() const {
	- return _boostMatrix;
	- }
	-
	/// Operator combination of two LTs
	LorentzTransform operator*(const LorentzTransform& lt) const {
	return combine(lt);
	}

	/// Pre-multiply m3 by this LT
	LorentzTransform preMult(const Matrix3& m3) {
	_boostMatrix = multiply(_mkMatrix4(m3),_boostMatrix);
	return *this;
	}

	/// Post-multiply m3 by this LT
	LorentzTransform postMult(const Matrix3& m3) {
	_boostMatrix *= _mkMatrix4(m3);
	return *this;
	}

	+ //@}
	+
	+
	+ /// Return the matrix form
	+ Matrix4 toMatrix() const {
	+ return _boostMatrix;
	+ }
	+

	private:

	Matrix4 _mkMatrix4(const Matrix3& m3) const {
	Matrix4 m4 = Matrix4::mkIdentity();
	for (size_t i = 0; i < 3; ++i) {
	for (size_t j = 0; j < 3; ++j) {
	m4.set(i+1, j+1, m3.get(i, j));
	}
	}
	return m4;
	}

	Matrix4 _boostMatrix;

	};



	inline LorentzTransform inverse(const LorentzTransform& lt) {
	return lt.inverse();
	}

	inline LorentzTransform combine(const LorentzTransform& a, const LorentzTransform& b) {
	return a.combine(b);
	}

	inline FourVector transform(const LorentzTransform& lt, const FourVector& v4) {
	return lt.transform(v4);
	}


	//////////////////////////


	inline string toString(const LorentzTransform& lt) {
	return toString(lt.toMatrix());
	}

	inline ostream& operator<<(std::ostream& out, const LorentzTransform& lt) {
	out << toString(lt);
	return out;
	}


	}

	#endif
	diff --git a/include/Rivet/Math/MathHeader.hh b/include/Rivet/Math/MathHeader.hh
	--- a/include/Rivet/Math/MathHeader.hh
	+++ b/include/Rivet/Math/MathHeader.hh
	@@ -1,91 +1,35 @@
	#ifndef RIVET_Math_MathHeader
	#define RIVET_Math_MathHeader

	-#include "Rivet/Exceptions.hh"
	-#include <stdexcept>
	-#include <string>
	-#include <ostream>
	-#include <sstream>
	-#include <iostream>
	-#include <limits>
	-#include <climits>
	-#include <cfloat>
	-#include <cmath>
	-#include <map>
	-#include <vector>
	-#include <algorithm>
	-
	-
	-// Macro to help with overzealous compiler warnings
	-/// @note It's easier and better to just not give an arg name to args which won't be used, when possible.
	-#ifdef UNUSED
	-#elif defined(__GNUC__)
	-# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
	-#elif defined(__LCLINT__)
	-# define UNUSED(x) /@unused@/ x
	-#else
	-# define UNUSED(x) x
	-#endif
	-
	-
	-/// Macro to help mark code as deprecated to produce compiler warnings
	-#ifndef DEPRECATED
	-#if __GNUC__ && __cplusplus && RIVET_NO_DEPRECATION_WARNINGS == 0
	-#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
	-#if GCC_VERSION >= 40500
	- #if __cplusplus > 201103L
	- #define DEPRECATED(x) [[deprecated(x)]]
	- #else
	- #define DEPRECATED(x) __attribute__((deprecated(x)))
	- #endif
	-#else
	- #define DEPRECATED(x) __attribute__((deprecated))
	-#endif
	-#else
	- #define DEPRECATED(x)
	-#endif
	-#endif
	-
	+#include "Rivet/Tools/Exceptions.hh"
	+#include "Rivet/Tools/Utils.hh"

	namespace Rivet {

	- using std::string;
	- using std::ostream;
	- using std::ostringstream;
	- using std::cout;
	- using std::endl;
	- using std::pair;
	- using std::vector;
	- using std::transform;
	- using std::min;
	- using std::max;
	- using std::abs;
	- using std::isnan;
	- using std::isinf;

	/// Pre-defined numeric type limits
	/// @deprecated Prefer the standard DBL/INT_MAX
	static const double MAXDOUBLE = DBL_MAX; // was std::numeric_limits<double>::max(); -- warns in GCC5
	static const double MAXINT = INT_MAX; // was std::numeric_limits<int>::max(); -- warns in GCC5

	/// A pre-defined value of \f$ \pi \f$.
	static const double PI = M_PI;

	/// A pre-defined value of \f$ 2\pi \f$.
	static const double TWOPI = 2*M_PI;

	/// A pre-defined value of \f$ \pi/2 \f$.
	static const double HALFPI = M_PI_2;

	/// Enum for signs of numbers.
	enum Sign { MINUS = -1, ZERO = 0, PLUS = 1 };

	/// Enum for rapidity variable to be used in calculating \f$ R \f$, applying rapidity cuts, etc.
	enum RapScheme { PSEUDORAPIDITY = 0, ETARAP = 0, RAPIDITY = 1, YRAP = 1 };

	/// Enum for range of \f$ \phi \f$ to be mapped into
	enum PhiMapping { MINUSPI_PLUSPI, ZERO_2PI, ZERO_PI };

	}

	#endif
	diff --git a/include/Rivet/Math/MathUtils.hh b/include/Rivet/Math/MathUtils.hh
	--- a/include/Rivet/Math/MathUtils.hh
	+++ b/include/Rivet/Math/MathUtils.hh
	@@ -1,579 +1,597 @@
	// -- C++ --
	#ifndef RIVET_MathUtils_HH
	#define RIVET_MathUtils_HH

	#include "Rivet/Math/MathHeader.hh"
	#include <type_traits>
	#include <cassert>

	namespace Rivet {


	/// @name Comparison functions for safe (floating point) equality tests
	//@{

	/// @brief Compare a number to zero
	///
	/// This version for floating point types has a degree of fuzziness expressed
	/// by the absolute @a tolerance parameter, for floating point safety.
	template <typename NUM>
	inline typename std::enable_if<std::is_floating_point<NUM>::value, bool>::type
	isZero(NUM val, double tolerance=1e-8) {
	return fabs(val) < tolerance;
	}

	/// @brief Compare a number to zero
	///
	/// SFINAE template specialisation for integers, since there is no FP
	/// precision issue.
	template <typename NUM>
	inline typename std::enable_if<std::is_integral<NUM>::value, bool>::type
	isZero(NUM val, double UNUSED(tolerance)=1e-8) {
	return val == 0;
	}


	/// @brief Compare two numbers for equality with a degree of fuzziness
	///
	/// This version for floating point types (if any argument is FP) has a degree
	/// of fuzziness expressed by the fractional @a tolerance parameter, for
	/// floating point safety.
	template <typename N1, typename N2>
	inline typename std::enable_if<
	std::is_arithmetic<N1>::value && std::is_arithmetic<N2>::value &&
	(std::is_floating_point<N1>::value \|\| std::is_floating_point<N2>::value), bool>::type
	fuzzyEquals(N1 a, N2 b, double tolerance=1e-5) {
	const double absavg = (std::abs(a) + std::abs(b))/2.0;
	const double absdiff = std::abs(a - b);
	const bool rtn = (isZero(a) && isZero(b)) \|\| absdiff < tolerance*absavg;
	return rtn;
	}

	/// @brief Compare two numbers for equality with a degree of fuzziness
	///
	/// Simpler SFINAE template specialisation for integers, since there is no FP
	/// precision issue.
	template <typename N1, typename N2>
	inline typename std::enable_if<
	std::is_integral<N1>::value && std::is_integral<N2>::value, bool>::type
	fuzzyEquals(N1 a, N2 b, double UNUSED(tolerance)=1e-5) {
	return a == b;
	}


	/// @brief Compare two numbers for >= with a degree of fuzziness
	///
	/// The @a tolerance parameter on the equality test is as for @c fuzzyEquals.
	template <typename N1, typename N2>
	inline typename std::enable_if<
	std::is_arithmetic<N1>::value && std::is_arithmetic<N2>::value, bool>::type
	fuzzyGtrEquals(N1 a, N2 b, double tolerance=1e-5) {
	return a > b \|\| fuzzyEquals(a, b, tolerance);
	}


	/// @brief Compare two floating point numbers for <= with a degree of fuzziness
	///
	/// The @a tolerance parameter on the equality test is as for @c fuzzyEquals.
	template <typename N1, typename N2>
	inline typename std::enable_if<
	std::is_arithmetic<N1>::value && std::is_arithmetic<N2>::value, bool>::type
	fuzzyLessEquals(N1 a, N2 b, double tolerance=1e-5) {
	return a < b \|\| fuzzyEquals(a, b, tolerance);
	}

	//@}


	/// @name Ranges and intervals
	//@{

	/// Represents whether an interval is open (non-inclusive) or closed (inclusive).
	///
	/// For example, the interval \f$ [0, \pi) \f$ is closed (an inclusive
	/// boundary) at 0, and open (a non-inclusive boundary) at \f$ \pi \f$.
	enum RangeBoundary { OPEN=0, SOFT=0, CLOSED=1, HARD=1 };

	/// @brief Determine if @a value is in the range @a low to @a high, for floating point numbers
	///
	/// Interval boundary types are defined by @a lowbound and @a highbound.
	template <typename N1, typename N2, typename N3>
	inline typename std::enable_if<
	std::is_arithmetic<N1>::value && std::is_arithmetic<N2>::value && std::is_arithmetic<N3>::value, bool>::type
	inRange(N1 value, N2 low, N3 high,
	RangeBoundary lowbound=CLOSED, RangeBoundary highbound=OPEN) {
	if (lowbound == OPEN && highbound == OPEN) {
	return (value > low && value < high);
	} else if (lowbound == OPEN && highbound == CLOSED) {
	return (value > low && value <= high);
	} else if (lowbound == CLOSED && highbound == OPEN) {
	return (value >= low && value < high);
	} else { // if (lowbound == CLOSED && highbound == CLOSED) {
	return (value >= low && value <= high);
	}
	}

	/// @brief Determine if @a value is in the range @a low to @a high, for floating point numbers
	///
	/// Interval boundary types are defined by @a lowbound and @a highbound.
	/// Closed intervals are compared fuzzily.
	template <typename N1, typename N2, typename N3>
	inline typename std::enable_if<
	std::is_arithmetic<N1>::value && std::is_arithmetic<N2>::value && std::is_arithmetic<N3>::value, bool>::type
	fuzzyInRange(N1 value, N2 low, N3 high,
	RangeBoundary lowbound=CLOSED, RangeBoundary highbound=OPEN) {
	if (lowbound == OPEN && highbound == OPEN) {
	return (value > low && value < high);
	} else if (lowbound == OPEN && highbound == CLOSED) {
	return (value > low && fuzzyLessEquals(value, high));
	} else if (lowbound == CLOSED && highbound == OPEN) {
	return (fuzzyGtrEquals(value, low) && value < high);
	} else { // if (lowbound == CLOSED && highbound == CLOSED) {
	return (fuzzyGtrEquals(value, low) && fuzzyLessEquals(value, high));
	}
	}

	/// Alternative version of inRange which accepts a pair for the range arguments.
	template <typename N1, typename N2, typename N3>
	inline typename std::enable_if<
	std::is_arithmetic<N1>::value && std::is_arithmetic<N2>::value && std::is_arithmetic<N3>::value, bool>::type
	inRange(N1 value, pair<N2, N3> lowhigh,
	RangeBoundary lowbound=CLOSED, RangeBoundary highbound=OPEN) {
	return inRange(value, lowhigh.first, lowhigh.second, lowbound, highbound);
	}


	// Alternative forms, with snake_case names and boundary types in names rather than as args -- from MCUtils

	/// @brief Boolean function to determine if @a value is within the given range
	///
	/// @note The interval is closed (inclusive) at the low end, and open (exclusive) at the high end.
	template <typename N1, typename N2, typename N3>
	inline typename std::enable_if<
	std::is_arithmetic<N1>::value && std::is_arithmetic<N2>::value && std::is_arithmetic<N3>::value, bool>::type
	in_range(N1 val, N2 low, N3 high) {
	return inRange(val, low, high, CLOSED, OPEN);
	}

	/// @brief Boolean function to determine if @a value is within the given range
	///
	/// @note The interval is closed at both ends.
	template <typename N1, typename N2, typename N3>
	inline typename std::enable_if<
	std::is_arithmetic<N1>::value && std::is_arithmetic<N2>::value && std::is_arithmetic<N3>::value, bool>::type
	in_closed_range(N1 val, N2 low, N3 high) {
	return inRange(val, low, high, CLOSED, CLOSED);
	}

	/// @brief Boolean function to determine if @a value is within the given range
	///
	/// @note The interval is open at both ends.
	template <typename N1, typename N2, typename N3>
	inline typename std::enable_if<
	std::is_arithmetic<N1>::value && std::is_arithmetic<N2>::value && std::is_arithmetic<N3>::value, bool>::type
	in_open_range(N1 val, N2 low, N3 high) {
	return inRange(val, low, high, OPEN, OPEN);
	}

	/// @todo Add pair-based versions of the named range-boundary functions

	//@}


	/// @name Miscellaneous numerical helpers
	//@{

	/// Named number-type squaring operation.
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, NUM>::type
	sqr(NUM a) {
	return a*a;
	}

	/// @brief Named number-type addition in quadrature operation.
	///
	/// @note Result has the sqrt operation applied.
	/// @todo When std::common_type can be used, generalise to multiple numeric types with appropriate return type.
	// template <typename N1, typename N2>
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, NUM>::type
	//std::common_type<N1, N2>::type
	add_quad(NUM a, NUM b) {
	return sqrt(aa + bb);
	}

	/// Named number-type addition in quadrature operation.
	///
	/// @note Result has the sqrt operation applied.
	/// @todo When std::common_type can be used, generalise to multiple numeric types with appropriate return type.
	// template <typename N1, typename N2>
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, NUM>::type
	//std::common_type<N1, N2, N3>::type
	add_quad(NUM a, NUM b, NUM c) {
	return sqrt(aa + bb + c*c);
	}

	/// Return a/b, or @a fail if b = 0
	/// @todo When std::common_type can be used, generalise to multiple numeric types with appropriate return type.
	inline double safediv(double num, double den, double fail=0.0) {
	return (!isZero(den)) ? num/den : fail;
	}

	/// A more efficient version of pow for raising numbers to integer powers.
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, NUM>::type
	intpow(NUM val, unsigned int exp) {
	assert(exp >= 0);
	if (exp == 0) return (NUM) 1;
	else if (exp == 1) return val;
	return val * intpow(val, exp-1);
	}

	/// Find the sign of a number
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, int>::type
	sign(NUM val) {
	if (isZero(val)) return ZERO;
	const int valsign = (val > 0) ? PLUS : MINUS;
	return valsign;
	}

	//@}


	/// @name Physics statistical distributions
	//@{

	/// @brief CDF for the Breit-Wigner distribution
	inline double cdfBW(double x, double mu, double gamma) {
	// normalize to (0;1) distribution
	const double xn = (x - mu)/gamma;
	return std::atan(xn)/M_PI + 0.5;
	}

	/// @brief Inverse CDF for the Breit-Wigner distribution
	inline double invcdfBW(double p, double mu, double gamma) {
	const double xn = std::tan(M_PI*(p-0.5));
	return gamma*xn + mu;
	}

	//@}


	/// @name Binning helper functions
	//@{

	/// @brief Make a list of @a nbins + 1 values equally spaced between @a start and @a end inclusive.
	///
	/// NB. The arg ordering and the meaning of the nbins variable is "histogram-like",
	/// as opposed to the Numpy/Matlab version.
	inline vector<double> linspace(size_t nbins, double start, double end, bool include_end=true) {
	assert(end >= start);
	assert(nbins > 0);
	vector<double> rtn;
	const double interval = (end-start)/static_cast<double>(nbins);
	for (size_t i = 0; i < nbins; ++i) {
	rtn.push_back(start + i*interval);
	}
	assert(rtn.size() == nbins);
	if (include_end) rtn.push_back(end); //< exact end, not result of n * interval
	return rtn;
	}


	/// @brief Make a list of @a nbins + 1 values exponentially spaced between @a start and @a end inclusive.
	///
	/// NB. The arg ordering and the meaning of the nbins variable is "histogram-like",
	/// as opposed to the Numpy/Matlab version, and the start and end arguments are expressed
	/// in "normal" space, rather than as the logarithms of the start/end values as in Numpy/Matlab.
	inline vector<double> logspace(size_t nbins, double start, double end, bool include_end=true) {
	assert(end >= start);
	assert(start > 0);
	assert(nbins > 0);
	const double logstart = std::log(start);
	const double logend = std::log(end);
	const vector<double> logvals = linspace(nbins, logstart, logend, false);
	assert(logvals.size() == nbins);
	vector<double> rtn; rtn.reserve(nbins+1);
	rtn.push_back(start); //< exact start, not exp(log(start))
	for (size_t i = 1; i < logvals.size(); ++i) {
	rtn.push_back(std::exp(logvals[i]));
	}
	assert(rtn.size() == nbins);
	if (include_end) rtn.push_back(end); //< exact end, not exp(n * loginterval)
	return rtn;
	}


	/// @brief Make a list of @a nbins + 1 values spaced for equal area
	/// Breit-Wigner binning between @a start and @a end inclusive. @a
	/// mu and @a gamma are the Breit-Wigner parameters.
	///
	/// @note The arg ordering and the meaning of the nbins variable is "histogram-like",
	/// as opposed to the Numpy/Matlab version, and the start and end arguments are expressed
	/// in "normal" space.
	inline vector<double> bwspace(size_t nbins, double start, double end, double mu, double gamma) {
	assert(end >= start);
	assert(nbins > 0);
	const double pmin = cdfBW(start, mu, gamma);
	const double pmax = cdfBW(end, mu, gamma);
	const vector<double> edges = linspace(nbins, pmin, pmax);
	assert(edges.size() == nbins+1);
	vector<double> rtn;
	for (double edge : edges) {
	rtn.push_back(invcdfBW(edge, mu, gamma));
	}
	assert(rtn.size() == nbins+1);
	return rtn;
	}


	/// @brief Return the bin index of the given value, @a val, given a vector of bin edges
	///
	+ /// An underflow always returns -1. If allow_overflow is false (default) an overflow
	+ /// also returns -1, otherwise it returns the Nedge-1, the index of an inclusive bin
	+ /// starting at the last edge.
	+ ///
	/// @note The @a binedges vector must be sorted
	/// @todo Use std::common_type<NUM1, NUM2>::type x = val; ?
	template <typename NUM1, typename NUM2>
	- inline typename std::enable_if<std::is_arithmetic<NUM1>::value && std::is_floating_point<NUM2>::value, int>::type
	- binIndex(NUM1 val, const vector<NUM2>& binedges, bool allow_overflow=false) {
	+ inline typename std::enable_if<std::is_arithmetic<NUM1>::value && std::is_arithmetic<NUM2>::value, int>::type
	+ binIndex(NUM1 val, const vector<NUM2>& binedges, bool allow_overflow=false) {
	if (val < binedges.front()) return -1; ///< Below/out of histo range
	if (val >= binedges.back()) return allow_overflow ? int(binedges.size())-1 : -1; ///< Above/out of histo range
	return std::distance(binedges.begin(), --std::upper_bound(binedges.begin(), binedges.end(), val));
	//
	// int index = -1;
	// for (size_t i = 1; i < binedges.size(); ++i) {
	// if (val < binedges[i]) {
	// index = i-1;
	// break;
	// }
	// }
	// assert(inRange(index, -1, int(binedges.size())-1));
	// return index;
	}

	//@}


	/// @name Discrete statistics functions
	//@{

	/// Calculate the median of a sample
	+ /// @todo Support multiple container types via SFINAE
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, NUM>::type
	median(const vector<NUM>& sample) {
	+ if (sample.empty()) throw RangeError("Can't compute median of an empty set");
	vector<NUM> tmp = sample;
	std::sort(tmp.begin(), tmp.end());
	const size_t imid = tmp.size()/2; // len1->idx0, len2->idx1, len3->idx1, len4->idx2, ...
	if (sample.size() % 2 == 0) return (tmp.at(imid-1) + tmp.at(imid)) / 2.0;
	else return tmp.at(imid);
	}


	/// Calculate the mean of a sample
	+ /// @todo Support multiple container types via SFINAE
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, double>::type
	mean(const vector<NUM>& sample) {
	+ if (sample.empty()) throw RangeError("Can't compute mean of an empty set");
	double mean = 0.0;
	for (size_t i = 0; i < sample.size(); ++i) {
	mean += sample[i];
	}
	return mean/sample.size();
	}

	// Calculate the error on the mean, assuming Poissonian errors
	+ /// @todo Support multiple container types via SFINAE
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, double>::type
	mean_err(const vector<NUM>& sample) {
	+ if (sample.empty()) throw RangeError("Can't compute mean_err of an empty set");
	double mean_e = 0.0;
	for (size_t i = 0; i < sample.size(); ++i) {
	mean_e += sqrt(sample[i]);
	}
	return mean_e/sample.size();
	}


	/// Calculate the covariance (variance) between two samples
	+ /// @todo Support multiple container types via SFINAE
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, double>::type
	covariance(const vector<NUM>& sample1, const vector<NUM>& sample2) {
	+ if (sample1.empty() \|\| sample2.empty()) throw RangeError("Can't compute covariance of an empty set");
	+ if (sample1.size() != sample2.size()) throw RangeError("Sizes of samples must be equal for covariance calculation");
	const double mean1 = mean(sample1);
	const double mean2 = mean(sample2);
	const size_t N = sample1.size();
	double cov = 0.0;
	for (size_t i = 0; i < N; i++) {
	const double cov_i = (sample1[i] - mean1)*(sample2[i] - mean2);
	cov += cov_i;
	}
	if (N > 1) return cov/(N-1);
	else return 0.0;
	}

	/// Calculate the error on the covariance (variance) of two samples, assuming poissonian errors
	+ /// @todo Support multiple container types via SFINAE
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, double>::type
	covariance_err(const vector<NUM>& sample1, const vector<NUM>& sample2) {
	+ if (sample1.empty() \|\| sample2.empty()) throw RangeError("Can't compute covariance_err of an empty set");
	+ if (sample1.size() != sample2.size()) throw RangeError("Sizes of samples must be equal for covariance_err calculation");
	const double mean1 = mean(sample1);
	const double mean2 = mean(sample2);
	const double mean1_e = mean_err(sample1);
	const double mean2_e = mean_err(sample2);
	const size_t N = sample1.size();
	double cov_e = 0.0;
	for (size_t i = 0; i < N; i++) {
	const double cov_i = (sqrt(sample1[i]) - mean1_e)*(sample2[i] - mean2) +
	(sample1[i] - mean1)*(sqrt(sample2[i]) - mean2_e);
	cov_e += cov_i;
	}
	if (N > 1) return cov_e/(N-1);
	else return 0.0;
	}


	/// Calculate the correlation strength between two samples
	+ /// @todo Support multiple container types via SFINAE
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, double>::type
	correlation(const vector<NUM>& sample1, const vector<NUM>& sample2) {
	const double cov = covariance(sample1, sample2);
	const double var1 = covariance(sample1, sample1);
	const double var2 = covariance(sample2, sample2);
	const double correlation = cov/sqrt(var1*var2);
	const double corr_strength = correlation*sqrt(var2/var1);
	return corr_strength;
	}

	/// Calculate the error of the correlation strength between two samples assuming Poissonian errors
	+ /// @todo Support multiple container types via SFINAE
	template <typename NUM>
	inline typename std::enable_if<std::is_arithmetic<NUM>::value, double>::type
	correlation_err(const vector<NUM>& sample1, const vector<NUM>& sample2) {
	const double cov = covariance(sample1, sample2);
	const double var1 = covariance(sample1, sample1);
	const double var2 = covariance(sample2, sample2);
	const double cov_e = covariance_err(sample1, sample2);
	const double var1_e = covariance_err(sample1, sample1);
	const double var2_e = covariance_err(sample2, sample2);

	// Calculate the correlation
	const double correlation = cov/sqrt(var1*var2);
	// Calculate the error on the correlation
	const double correlation_err = cov_e/sqrt(var1*var2) -
	cov/(2pow(3./2., var1var2)) * (var1_e * var2 + var1 * var2_e);

	// Calculate the error on the correlation strength
	const double corr_strength_err = correlation_err*sqrt(var2/var1) +
	correlation/(2sqrt(var2/var1)) (var2_e/var1 - var2*var1_e/pow(2, var2));

	return corr_strength_err;
	}

	//@}


	/// @name Angle range mappings
	//@{

	/// @brief Reduce any number to the range [-2PI, 2PI]
	///
	/// Achieved by repeated addition or subtraction of 2PI as required. Used to
	/// normalise angular measures.
	inline double _mapAngleM2PITo2Pi(double angle) {
	double rtn = fmod(angle, TWOPI);
	if (isZero(rtn)) return 0;
	assert(rtn >= -TWOPI && rtn <= TWOPI);
	return rtn;
	}

	/// Map an angle into the range (-PI, PI].
	inline double mapAngleMPiToPi(double angle) {
	double rtn = _mapAngleM2PITo2Pi(angle);
	if (isZero(rtn)) return 0;
	if (rtn > PI) rtn -= TWOPI;
	if (rtn <= -PI) rtn += TWOPI;
	assert(rtn > -PI && rtn <= PI);
	return rtn;
	}

	/// Map an angle into the range [0, 2PI).
	inline double mapAngle0To2Pi(double angle) {
	double rtn = _mapAngleM2PITo2Pi(angle);
	if (isZero(rtn)) return 0;
	if (rtn < 0) rtn += TWOPI;
	if (rtn == TWOPI) rtn = 0;
	assert(rtn >= 0 && rtn < TWOPI);
	return rtn;
	}

	/// Map an angle into the range [0, PI].
	inline double mapAngle0ToPi(double angle) {
	double rtn = fabs(mapAngleMPiToPi(angle));
	if (isZero(rtn)) return 0;
	assert(rtn > 0 && rtn <= PI);
	return rtn;
	}

	/// Map an angle into the enum-specified range.
	inline double mapAngle(double angle, PhiMapping mapping) {
	switch (mapping) {
	case MINUSPI_PLUSPI:
	return mapAngleMPiToPi(angle);
	case ZERO_2PI:
	return mapAngle0To2Pi(angle);
	case ZERO_PI:
	return mapAngle0To2Pi(angle);
	default:
	throw Rivet::UserError("The specified phi mapping scheme is not implemented");
	}
	}

	//@}


	/// @name Phase space measure helpers
	//@{

	/// @brief Calculate the difference between two angles in radians
	///
	/// Returns in the range [0, PI].
	inline double deltaPhi(double phi1, double phi2) {
	return mapAngle0ToPi(phi1 - phi2);
	}

	/// Calculate the abs difference between two pseudorapidities
	///
	/// @note Just a cosmetic name for analysis code clarity.
	inline double deltaEta(double eta1, double eta2) {
	return fabs(eta1 - eta2);
	}

	/// Calculate the abs difference between two rapidities
	///
	/// @note Just a cosmetic name for analysis code clarity.
	inline double deltaRap(double y1, double y2) {
	return fabs(y1 - y2);
	}

	/// Calculate the distance between two points in 2D rapidity-azimuthal
	/// ("\f$ \eta-\phi \f$") space. The phi values are given in radians.
	inline double deltaR(double rap1, double phi1, double rap2, double phi2) {
	const double dphi = deltaPhi(phi1, phi2);
	return sqrt( sqr(rap1-rap2) + sqr(dphi) );
	}

	/// Calculate a rapidity value from the supplied energy @a E and longitudinal momentum @a pz.
	inline double rapidity(double E, double pz) {
	if (isZero(E - pz)) {
	throw std::runtime_error("Divergent positive rapidity");
	return MAXDOUBLE;
	}
	if (isZero(E + pz)) {
	throw std::runtime_error("Divergent negative rapidity");
	return -MAXDOUBLE;
	}
	return 0.5*log((E+pz)/(E-pz));
	}

	//@}


	}


	#endif
	diff --git a/include/Rivet/Math/Matrix3.hh b/include/Rivet/Math/Matrix3.hh
	--- a/include/Rivet/Math/Matrix3.hh
	+++ b/include/Rivet/Math/Matrix3.hh
	@@ -1,58 +1,56 @@
	#ifndef RIVET_MATH_MATRIX3
	#define RIVET_MATH_MATRIX3

	#include "Rivet/Math/MathHeader.hh"
	#include "Rivet/Math/MathUtils.hh"
	#include "Rivet/Math/MatrixN.hh"
	#include "Rivet/Math/Vector3.hh"

	namespace Rivet {


	/// @brief Specialisation of MatrixN to aid 3 dimensional rotations.
	class Matrix3 : public Matrix<3> {
	public:
	Matrix3() { }

	Matrix3(const Matrix<3>& m3) : Matrix<3>::Matrix(m3) { }

	Matrix3(const Vector3& axis, const double angle) {
	const Vector3 normaxis = axis.unit();
	_matrix.loadRotation3(angle, normaxis._vec);
	}

	Matrix3(const Vector3& from, const Vector3& to) {
	setAsRotation(from, to);
	}

	- public:
	static Matrix3 mkXRotation(const double angle) {
	return Matrix3(Vector3(1,0,0), angle);
	}

	static Matrix3 mkYRotation(const double angle) {
	return Matrix3(Vector3(0,1,0), angle);
	}

	static Matrix3 mkZRotation(const double angle) {
	return Matrix3(Vector3(0,0,1), angle);
	}

	- public:
	Matrix3& setAsRotation(const Vector3& from, const Vector3& to) {
	const double theta = angle(from, to);
	if (Rivet::isZero(theta)) {
	_matrix.loadIdentity();
	} else {
	const Vector3 normaxis = cross(from, to).unit();
	_matrix.loadRotation3(theta, normaxis._vec);
	}
	return *this;
	}

	};


	}

	#endif
	diff --git a/include/Rivet/Math/MatrixN.hh b/include/Rivet/Math/MatrixN.hh
	--- a/include/Rivet/Math/MatrixN.hh
	+++ b/include/Rivet/Math/MatrixN.hh
	@@ -1,418 +1,420 @@
	#ifndef RIVET_MATH_MATRIXN
	#define RIVET_MATH_MATRIXN

	#include "Rivet/Math/MathHeader.hh"
	#include "Rivet/Math/MathUtils.hh"
	#include "Rivet/Math/Vectors.hh"

	#include "Rivet/Math/eigen/matrix.h"

	namespace Rivet {


	template <size_t N>
	class Matrix;
	typedef Matrix<4> Matrix4;

	template <size_t N>
	Matrix<N> multiply(const Matrix<N>& a, const Matrix<N>& b);
	template <size_t N>
	Matrix<N> divide(const Matrix<N>&, const double);
	template <size_t N>
	Matrix<N> operator*(const Matrix<N>& a, const Matrix<N>& b);


	///////////////////////////////////


	/// @brief General \f$ N \f$-dimensional mathematical matrix object.
	template <size_t N>
	class Matrix {
	template <size_t M>
	friend Matrix<M> add(const Matrix<M>&, const Matrix<M>&);
	template <size_t M>
	friend Matrix<M> multiply(const double, const Matrix<M>&);
	template <size_t M>
	friend Matrix<M> multiply(const Matrix<M>&, const Matrix<M>&);
	template <size_t M>
	friend Vector<M> multiply(const Matrix<M>&, const Vector<M>&);
	template <size_t M>
	friend Matrix<M> divide(const Matrix<M>&, const double);

	public:
	static Matrix<N> mkZero() {
	Matrix<N> rtn;
	return rtn;
	}

	static Matrix<N> mkDiag(Vector<N> diag) {
	Matrix<N> rtn;
	for (size_t i = 0; i < N; ++i) {
	rtn.set(i, i, diag[i]);
	}
	return rtn;
	}

	static Matrix<N> mkIdentity() {
	Matrix<N> rtn;
	for (size_t i = 0; i < N; ++i) {
	rtn.set(i, i, 1);
	}
	return rtn;
	}


	public:

	Matrix() {
	_matrix.loadZero();
	}

	Matrix(const Matrix<N>& other) {
	_matrix = other._matrix;
	}

	Matrix& set(const size_t i, const size_t j, const double value) {
	if (i < N && j < N) {
	_matrix(i, j) = value;
	} else {
	throw std::runtime_error("Attempted set access outside matrix bounds.");
	}
	return *this;
	}

	double get(const size_t i, const size_t j) const {
	if (i < N && j < N) {
	return _matrix(i, j);
	} else {
	throw std::runtime_error("Attempted get access outside matrix bounds.");
	}
	}

	Vector<N> getRow(const size_t row) const {
	Vector<N> rtn;
	for (size_t i = 0; i < N; ++i) {
	rtn.set(i, _matrix(row,i));
	}
	return rtn;
	}

	Matrix<N>& setRow(const size_t row, const Vector<N>& r) {
	for (size_t i = 0; i < N; ++i) {
	_matrix(row,i) = r.get(i);
	}
	return *this;
	}

	Vector<N> getColumn(const size_t col) const {
	Vector<N> rtn;
	for (size_t i = 0; i < N; ++i) {
	rtn.set(i, _matrix(i,col));
	}
	return rtn;
	}

	Matrix<N>& setColumn(const size_t col, const Vector<N>& c) {
	for (size_t i = 0; i < N; ++i) {
	_matrix(i,col) = c.get(i);
	}
	return *this;
	}

	Matrix<N> transpose() const {
	Matrix<N> tmp = *this;
	tmp._matrix.replaceWithAdjoint();
	return tmp;
	}

	// Matrix<N>& transposeInPlace() {
	// _matrix.replaceWithAdjoint();
	// return *this;
	// }

	/// Calculate inverse
	Matrix<N> inverse() const {
	Matrix<N> tmp;
	tmp._matrix = _matrix.inverse();
	return tmp;
	}

	/// Calculate determinant
	double det() const {
	return _matrix.determinant();
	}

	/// Calculate trace
	double trace() const {
	double tr = 0.0;
	for (size_t i = 0; i < N; ++i) {
	tr += _matrix(i,i);
	}
	return tr;
	// return _matrix.trace();
	}

	/// Negate
	Matrix<N> operator-() const {
	Matrix<N> rtn;
	rtn._matrix = -_matrix;
	return rtn;
	}

	/// Get dimensionality
	size_t size() const {
	return N;
	}

	/// Index-wise check for nullness, allowing for numerical precision
	bool isZero(double tolerance=1E-5) const {
	for (size_t i=0; i < N; ++i) {
	for (size_t j=0; j < N; ++j) {
	if (! Rivet::isZero(_matrix(i,j), tolerance) ) return false;
	}
	}
	return true;
	}

	/// Check for index-wise equality, allowing for numerical precision
	bool isEqual(Matrix<N> other) const {
	for (size_t i=0; i < N; ++i) {
	for (size_t j=i; j < N; ++j) {
	if (! Rivet::isZero(_matrix(i,j) - other._matrix(i,j)) ) return false;
	}
	}
	return true;
	}

	/// Check for symmetry under transposition
	bool isSymm() const {
	return isEqual(this->transpose());
	}

	/// Check that all off-diagonal elements are zero, allowing for numerical precision
	bool isDiag() const {
	for (size_t i=0; i < N; ++i) {
	for (size_t j=0; j < N; ++j) {
	if (i == j) continue;
	if (! Rivet::isZero(_matrix(i,j)) ) return false;
	}
	}
	return true;
	}

	- bool operator==(const Matrix<N>& a) const {
	+ bool operator == (const Matrix<N>& a) const {
	return _matrix == a._matrix;
	}

	- bool operator!=(const Matrix<N>& a) const {
	+ bool operator != (const Matrix<N>& a) const {
	return _matrix != a._matrix;
	}

	- bool operator<(const Matrix<N>& a) const {
	+ bool operator < (const Matrix<N>& a) const {
	return _matrix < a._matrix;
	}

	- bool operator<=(const Matrix<N>& a) const {
	+ bool operator <= (const Matrix<N>& a) const {
	return _matrix <= a._matrix;
	}

	- bool operator>(const Matrix<N>& a) const {
	+ bool operator > (const Matrix<N>& a) const {
	return _matrix > a._matrix;
	}

	- bool operator>=(const Matrix<N>& a) const {
	+ bool operator >= (const Matrix<N>& a) const {
	return _matrix >= a._matrix;
	}

	- Matrix<N>& operator*=(const Matrix<N>& m) {
	+ Matrix<N>& operator *= (const Matrix<N>& m) {
	_matrix = _matrix * m._matrix;
	return *this;
	}

	- Matrix<N>& operator*=(const double a) {
	+ Matrix<N>& operator *= (const double a) {
	_matrix *= a;
	return *this;
	}

	- Matrix<N>& operator/=(const double a) {
	+ Matrix<N>& operator /= (const double a) {
	_matrix /= a;
	return *this;
	}

	- Matrix<N>& operator+=(const Matrix<N>& m) {
	+ Matrix<N>& operator += (const Matrix<N>& m) {
	_matrix += m._matrix;
	return *this;
	}

	- Matrix<N>& operator-=(const Matrix<N>& m) {
	+ Matrix<N>& operator -= (const Matrix<N>& m) {
	_matrix -= m._matrix;
	return *this;
	}

	protected:
	+
	typedef Eigen::Matrix<double,N> EMatrix;
	EMatrix _matrix;
	+
	};


	/////////////////////////////////


	template <size_t N>
	inline Matrix<N> add(const Matrix<N>& a, const Matrix<N>& b) {
	Matrix<N> result;
	result._matrix = a._matrix + b._matrix;
	return result;
	}

	template <size_t N>
	inline Matrix<N> subtract(const Matrix<N>& a, const Matrix<N>& b) {
	return add(a, -b);
	}

	template <size_t N>
	- inline Matrix<N> operator+(const Matrix<N> a, const Matrix<N>& b) {
	+ inline Matrix<N> operator + (const Matrix<N> a, const Matrix<N>& b) {
	return add(a, b);
	}

	template <size_t N>
	- inline Matrix<N> operator-(const Matrix<N> a, const Matrix<N>& b) {
	+ inline Matrix<N> operator - (const Matrix<N> a, const Matrix<N>& b) {
	return subtract(a, b);
	}

	template <size_t N>
	inline Matrix<N> multiply(const double a, const Matrix<N>& m) {
	Matrix<N> rtn;
	rtn._matrix = a * m._matrix;
	return rtn;
	}

	template <size_t N>
	inline Matrix<N> multiply(const Matrix<N>& m, const double a) {
	return multiply(a, m);
	}

	template <size_t N>
	inline Matrix<N> divide(const Matrix<N>& m, const double a) {
	return multiply(1/a, m);
	}

	template <size_t N>
	- inline Matrix<N> operator*(const double a, const Matrix<N>& m) {
	+ inline Matrix<N> operator * (const double a, const Matrix<N>& m) {
	return multiply(a, m);
	}

	template <size_t N>
	- inline Matrix<N> operator*(const Matrix<N>& m, const double a) {
	+ inline Matrix<N> operator * (const Matrix<N>& m, const double a) {
	return multiply(a, m);
	}

	template <size_t N>
	inline Matrix<N> multiply(const Matrix<N>& a, const Matrix<N>& b) {
	Matrix<N> tmp;
	tmp._matrix = a._matrix * b._matrix;
	return tmp;
	}

	template <size_t N>
	- inline Matrix<N> operator*(const Matrix<N>& a, const Matrix<N>& b) {
	+ inline Matrix<N> operator * (const Matrix<N>& a, const Matrix<N>& b) {
	return multiply(a, b);
	}


	template <size_t N>
	inline Vector<N> multiply(const Matrix<N>& a, const Vector<N>& b) {
	Vector<N> tmp;
	tmp._vec = a._matrix * b._vec;
	return tmp;
	}

	template <size_t N>
	- inline Vector<N> operator*(const Matrix<N>& a, const Vector<N>& b) {
	+ inline Vector<N> operator * (const Matrix<N>& a, const Vector<N>& b) {
	return multiply(a, b);
	}

	template <size_t N>
	inline Matrix<N> transpose(const Matrix<N>& m) {
	// Matrix<N> tmp;
	// for (size_t i = 0; i < N; ++i) {
	// for (size_t j = 0; j < N; ++j) {
	// tmp.set(i, j, m.get(j, i));
	// }
	// }
	// return tmp;
	return m.transpose();
	}

	template <size_t N>
	inline Matrix<N> inverse(const Matrix<N>& m) {
	return m.inverse();
	}

	template <size_t N>
	inline double det(const Matrix<N>& m) {
	return m.determinant();
	}

	template <size_t N>
	inline double trace(const Matrix<N>& m) {
	return m.trace();
	}


	/////////////////////////////////


	/// Make string representation
	template <size_t N>
	inline string toString(const Matrix<N>& m) {
	ostringstream ss;
	ss << "[ ";
	for (size_t i = 0; i < m.size(); ++i) {
	ss << "( ";
	for (size_t j = 0; j < m.size(); ++j) {
	const double e = m.get(i, j);
	ss << (Rivet::isZero(e) ? 0.0 : e) << " ";
	}
	ss << ") ";
	}
	ss << "]";
	return ss.str();
	}


	/// Stream out string representation
	template <size_t N>
	- inline ostream& operator<<(std::ostream& out, const Matrix<N>& m) {
	+ inline ostream& operator << (std::ostream& out, const Matrix<N>& m) {
	out << toString(m);
	return out;
	}


	/////////////////////////////////////////////////


	/// Compare two matrices by index, allowing for numerical precision
	template <size_t N>
	inline bool fuzzyEquals(const Matrix<N>& ma, const Matrix<N>& mb, double tolerance=1E-5) {
	for (size_t i = 0; i < N; ++i) {
	for (size_t j = 0; j < N; ++j) {
	const double a = ma.get(i, j);
	const double b = mb.get(i, j);
	if (!Rivet::fuzzyEquals(a, b, tolerance)) return false;
	}
	}
	return true;
	}


	/// External form of numerically safe nullness check
	template <size_t N>
	inline bool isZero(const Matrix<N>& m, double tolerance=1E-5) {
	return m.isZero(tolerance);
	}


	}

	#endif
	diff --git a/include/Rivet/Math/Vector3.hh b/include/Rivet/Math/Vector3.hh
	--- a/include/Rivet/Math/Vector3.hh
	+++ b/include/Rivet/Math/Vector3.hh
	@@ -1,331 +1,366 @@
	#ifndef RIVET_MATH_VECTOR3
	#define RIVET_MATH_VECTOR3

	#include "Rivet/Math/MathHeader.hh"
	#include "Rivet/Math/MathUtils.hh"
	#include "Rivet/Math/VectorN.hh"
	-#include <cfloat>

	namespace Rivet {


	class Vector3;
	typedef Vector3 ThreeVector;
	class Matrix3;

	Vector3 multiply(const double, const Vector3&);
	Vector3 multiply(const Vector3&, const double);
	Vector3 add(const Vector3&, const Vector3&);
	Vector3 operator*(const double, const Vector3&);
	Vector3 operator*(const Vector3&, const double);
	Vector3 operator/(const Vector3&, const double);
	Vector3 operator+(const Vector3&, const Vector3&);
	Vector3 operator-(const Vector3&, const Vector3&);


	/// @brief Three-dimensional specialisation of Vector.
	class Vector3 : public Vector<3> {

	friend class Matrix3;
	friend Vector3 multiply(const double, const Vector3&);
	friend Vector3 multiply(const Vector3&, const double);
	friend Vector3 add(const Vector3&, const Vector3&);
	friend Vector3 subtract(const Vector3&, const Vector3&);

	public:
	Vector3() : Vector<3>() { }

	template<typename V3>
	Vector3(const V3& other) {
	this->setX(other.x());
	this->setY(other.y());
	this->setZ(other.z());
	}

	Vector3(const Vector<3>& other) {
	this->setX(other.get(0));
	this->setY(other.get(1));
	this->setZ(other.get(2));
	}

	Vector3(double x, double y, double z) {
	this->setX(x);
	this->setY(y);
	this->setZ(z);
	}

	~Vector3() { }

	+
	public:
	+
	static Vector3 mkX() { return Vector3(1,0,0); }
	static Vector3 mkY() { return Vector3(0,1,0); }
	static Vector3 mkZ() { return Vector3(0,0,1); }

	+
	public:
	+
	double x() const { return get(0); }
	double y() const { return get(1); }
	double z() const { return get(2); }
	Vector3& setX(double x) { set(0, x); return *this; }
	Vector3& setY(double y) { set(1, y); return *this; }
	Vector3& setZ(double z) { set(2, z); return *this; }

	+
	+ /// Dot-product with another vector
	double dot(const Vector3& v) const {
	return _vec.dot(v._vec);
	}

	+ /// Cross-product with another vector
	Vector3 cross(const Vector3& v) const {
	Vector3 result;
	result._vec = _vec.cross(v._vec);
	return result;
	}

	+ /// Angle in radians to another vector
	double angle(const Vector3& v) const {
	const double localDotOther = unit().dot(v.unit());
	if (localDotOther > 1.0) return 0.0;
	if (localDotOther < -1.0) return M_PI;
	return acos(localDotOther);
	}

	- Vector3 unit() const {
	+
	+ /// Unit-normalized version of this vector
	+ Vector3 unitVec() const {
	/// @todo What to do in this situation?
	if (isZero()) return *this;
	else return this 1.0/this->mod();
	}

	+ /// Synonym for unitVec
	+ Vector3 unit() const {
	+ return unitVec();
	+ }
	+
	+
	+ /// Polar projection of this vector into the x-y plane
	+ Vector3 polarVec() const {
	+ Vector3 rtn = *this;
	+ rtn.setZ(0.);
	+ return rtn;
	+ }
	+ /// Synonym for polarVec
	+ Vector3 perpVec() const {
	+ return polarVec();
	+ }
	+ /// Synonym for polarVec
	+ Vector3 rhoVec() const {
	+ return polarVec();
	+ }
	+
	+ /// Square of the polar radius (
	double polarRadius2() const {
	return x()x() + y()y();
	}
	-
	/// Synonym for polarRadius2
	double perp2() const {
	return polarRadius2();
	}
	-
	/// Synonym for polarRadius2
	double rho2() const {
	return polarRadius2();
	}

	+ /// Polar radius
	double polarRadius() const {
	return sqrt(polarRadius2());
	}
	-
	/// Synonym for polarRadius
	double perp() const {
	return polarRadius();
	}
	-
	/// Synonym for polarRadius
	double rho() const {
	return polarRadius();
	}

	/// Angle subtended by the vector's projection in x-y and the x-axis.
	double azimuthalAngle(const PhiMapping mapping = ZERO_2PI) const {
	// If this is a null vector, return zero rather than let atan2 set an error state
	if (Rivet::isZero(mod2())) return 0.0;

	// Calculate the arctan and return in the requested range
	const double value = atan2( y(), x() );
	return mapAngle(value, mapping);
	}
	-
	/// Synonym for azimuthalAngle.
	double phi(const PhiMapping mapping = ZERO_2PI) const {
	return azimuthalAngle(mapping);
	}

	/// Angle subtended by the vector and the z-axis.
	double polarAngle() const {
	// Get number beween [0,PI]
	const double polarangle = atan2(polarRadius(), z());
	return mapAngle0ToPi(polarangle);
	}

	/// Synonym for polarAngle
	double theta() const {
	return polarAngle();
	}

	- /// Purely geometric approximation to rapidity; exact for massless particles
	- /// and in the central region.
	- // cut-off such that \|eta\| < log(2/DBL_EPSILON)
	+ /// Purely geometric approximation to rapidity
	+ ///
	+ /// Also invariant under z-boosts, equal to y for massless particles.
	+ ///
	+ /// @note A cut-off is applied such that \|eta\| < log(2/DBL_EPSILON)
	double pseudorapidity() const {
	const double epsilon = DBL_EPSILON;
	double m = mod();
	if ( m == 0.0 ) return 0.0;
	double pt = max(epsilon*m, perp());
	double rap = std::log((m + fabs(z()))/pt);
	return z() > 0.0 ? rap: -rap;
	}

	- /// Synonym for pseudorapidity.
	+ /// Synonym for pseudorapidity
	double eta() const {
	return pseudorapidity();
	}

	+ /// Convenience shortcut for fabs(eta())
	+ double abseta() const {
	+ return fabs(eta());
	+ }
	+
	+
	public:
	Vector3& operator*=(const double a) {
	_vec = multiply(a, *this)._vec;
	return *this;
	}

	Vector3& operator/=(const double a) {
	_vec = multiply(1.0/a, *this)._vec;
	return *this;
	}

	Vector3& operator+=(const Vector3& v) {
	_vec = add(*this, v)._vec;
	return *this;
	}

	Vector3& operator-=(const Vector3& v) {
	_vec = subtract(*this, v)._vec;
	return *this;
	}

	Vector3 operator-() const {
	Vector3 rtn;
	rtn._vec = -_vec;
	return rtn;
	}

	};



	inline double dot(const Vector3& a, const Vector3& b) {
	return a.dot(b);
	}

	inline Vector3 cross(const Vector3& a, const Vector3& b) {
	return a.cross(b);
	}

	inline Vector3 multiply(const double a, const Vector3& v) {
	Vector3 result;
	result._vec = a * v._vec;
	return result;
	}

	inline Vector3 multiply(const Vector3& v, const double a) {
	return multiply(a, v);
	}

	inline Vector3 operator*(const double a, const Vector3& v) {
	return multiply(a, v);
	}

	inline Vector3 operator*(const Vector3& v, const double a) {
	return multiply(a, v);
	}

	inline Vector3 operator/(const Vector3& v, const double a) {
	return multiply(1.0/a, v);
	}

	inline Vector3 add(const Vector3& a, const Vector3& b) {
	Vector3 result;
	result._vec = a._vec + b._vec;
	return result;
	}

	inline Vector3 subtract(const Vector3& a, const Vector3& b) {
	Vector3 result;
	result._vec = a._vec - b._vec;
	return result;
	}

	inline Vector3 operator+(const Vector3& a, const Vector3& b) {
	return add(a, b);
	}

	inline Vector3 operator-(const Vector3& a, const Vector3& b) {
	return subtract(a, b);
	}

	// More physicsy coordinates etc.

	/// Angle (in radians) between two 3-vectors.
	inline double angle(const Vector3& a, const Vector3& b) {
	return a.angle(b);
	}

	/////////////////////////////////////////////////////

	/// @name \f$ \|\Delta eta\| \f$ calculations from 3-vectors
	//@{

	/// Calculate the difference in pseudorapidity between two spatial vectors.
	inline double deltaEta(const Vector3& a, const Vector3& b) {
	return deltaEta(a.pseudorapidity(), b.pseudorapidity());
	}

	/// Calculate the difference in pseudorapidity between two spatial vectors.
	inline double deltaEta(const Vector3& v, double eta2) {
	return deltaEta(v.pseudorapidity(), eta2);
	}

	/// Calculate the difference in pseudorapidity between two spatial vectors.
	inline double deltaEta(double eta1, const Vector3& v) {
	return deltaEta(eta1, v.pseudorapidity());
	}

	//@}


	/// @name \f$ \Delta phi \f$ calculations from 3-vectors
	//@{

	/// Calculate the difference in azimuthal angle between two spatial vectors.
	inline double deltaPhi(const Vector3& a, const Vector3& b) {
	return deltaPhi(a.azimuthalAngle(), b.azimuthalAngle());
	}

	/// Calculate the difference in azimuthal angle between two spatial vectors.
	inline double deltaPhi(const Vector3& v, double phi2) {
	return deltaPhi(v.azimuthalAngle(), phi2);
	}

	/// Calculate the difference in azimuthal angle between two spatial vectors.
	inline double deltaPhi(double phi1, const Vector3& v) {
	return deltaPhi(phi1, v.azimuthalAngle());
	}

	//@}


	/// @name \f$ \Delta R \f$ calculations from 3-vectors
	//@{

	/// Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two spatial vectors.
	inline double deltaR(const Vector3& a, const Vector3& b) {
	return deltaR(a.pseudorapidity(), a.azimuthalAngle(),
	b.pseudorapidity(), b.azimuthalAngle());
	}

	/// Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two spatial vectors.
	inline double deltaR(const Vector3& v, double eta2, double phi2) {
	return deltaR(v.pseudorapidity(), v.azimuthalAngle(), eta2, phi2);
	}

	/// Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two spatial vectors.
	inline double deltaR(double eta1, double phi1, const Vector3& v) {
	return deltaR(eta1, phi1, v.pseudorapidity(), v.azimuthalAngle());
	}

	//@}


	/// @name Typedefs of vector types to short names
	/// @todo Switch canonical and alias names
	//@{
	//typedef Vector3 V3; //< generic
	typedef Vector3 X3; //< spatial
	//@}


	}

	#endif
	diff --git a/include/Rivet/Math/Vector4.hh b/include/Rivet/Math/Vector4.hh
	--- a/include/Rivet/Math/Vector4.hh
	+++ b/include/Rivet/Math/Vector4.hh
	@@ -1,1395 +1,1390 @@
	#ifndef RIVET_MATH_VECTOR4
	#define RIVET_MATH_VECTOR4

	#include "Rivet/Math/MathHeader.hh"
	#include "Rivet/Math/MathUtils.hh"
	#include "Rivet/Math/VectorN.hh"
	#include "Rivet/Math/Vector3.hh"

	namespace Rivet {


	class FourVector;
	class FourMomentum;
	class LorentzTransform;
	typedef FourVector Vector4;
	FourVector transform(const LorentzTransform& lt, const FourVector& v4);


	/// @brief Specialisation of VectorN to a general (non-momentum) Lorentz 4-vector.
	///
	/// @todo Add composite set/mk methods from different coord systems
	class FourVector : public Vector<4> {
	friend FourVector multiply(const double a, const FourVector& v);
	friend FourVector multiply(const FourVector& v, const double a);
	friend FourVector add(const FourVector& a, const FourVector& b);
	friend FourVector transform(const LorentzTransform& lt, const FourVector& v4);

	public:

	FourVector() : Vector<4>() { }

	template<typename V4>
	FourVector(const V4& other) {
	this->setT(other.t());
	this->setX(other.x());
	this->setY(other.y());
	this->setZ(other.z());
	}

	FourVector(const Vector<4>& other)
	: Vector<4>(other) { }

	FourVector(const double t, const double x, const double y, const double z) {
	this->setT(t);
	this->setX(x);
	this->setY(y);
	this->setZ(z);
	}

	virtual ~FourVector() { }

	public:

	double t() const { return get(0); }
	double t2() const { return sqr(t()); }
	FourVector& setT(const double t) { set(0, t); return *this; }

	double x() const { return get(1); }
	double x2() const { return sqr(x()); }
	FourVector& setX(const double x) { set(1, x); return *this; }

	double y() const { return get(2); }
	double y2() const { return sqr(y()); }
	FourVector& setY(const double y) { set(2, y); return *this; }

	double z() const { return get(3); }
	double z2() const { return sqr(z()); }
	FourVector& setZ(const double z) { set(3, z); return *this; }

	double invariant() const {
	// Done this way for numerical precision
	return (t() + z())(t() - z()) - x()x() - y()*y();
	}

	+ bool isNull() const {
	+ return Rivet::isZero(invariant());
	+ }
	+
	/// Angle between this vector and another
	double angle(const FourVector& v) const {
	return vector3().angle( v.vector3() );
	}
	/// Angle between this vector and another (3-vector)
	double angle(const Vector3& v3) const {
	return vector3().angle(v3);
	}

	- /// @brief Square of the projection of the 3-vector on to the \f$ x-y \f$ plane
	+ /// @brief Mod-square of the projection of the 3-vector on to the \f$ x-y \f$ plane
	/// This is a more efficient function than @c polarRadius, as it avoids the square root.
	/// Use it if you only need the squared value, or e.g. an ordering by magnitude.
	double polarRadius2() const {
	return vector3().polarRadius2();
	}
	/// Synonym for polarRadius2
	double perp2() const {
	return vector3().perp2();
	}
	/// Synonym for polarRadius2
	double rho2() const {
	return vector3().rho2();
	}

	- /// Projection of 3-vector on to the \f$ x-y \f$ plane
	+ /// Magnitude of projection of 3-vector on to the \f$ x-y \f$ plane
	double polarRadius() const {
	return vector3().polarRadius();
	}
	/// Synonym for polarRadius
	double perp() const {
	return vector3().perp();
	}
	/// Synonym for polarRadius
	double rho() const {
	return vector3().rho();
	}

	+ /// Projection of 3-vector on to the \f$ x-y \f$ plane
	+ Vector3 polarVec() const {
	+ return vector3().polarVec();
	+ }
	+ /// Synonym for polarVec
	+ Vector3 perpVec() const {
	+ return vector3().perpVec();
	+ }
	+ /// Synonym for polarVec
	+ Vector3 rhoVec() const {
	+ return vector3().rhoVec();
	+ }
	+
	/// Angle subtended by the 3-vector's projection in x-y and the x-axis.
	double azimuthalAngle(const PhiMapping mapping=ZERO_2PI) const {
	return vector3().azimuthalAngle(mapping);
	}
	/// Synonym for azimuthalAngle.
	double phi(const PhiMapping mapping=ZERO_2PI) const {
	return vector3().phi(mapping);
	}

	/// Angle subtended by the 3-vector and the z-axis.
	double polarAngle() const {
	return vector3().polarAngle();
	}
	/// Synonym for polarAngle.
	double theta() const {
	return vector3().theta();
	}

	/// Pseudorapidity (defined purely by the 3-vector components)
	double pseudorapidity() const {
	return vector3().pseudorapidity();
	}
	/// Synonym for pseudorapidity.
	double eta() const {
	return vector3().eta();
	}

	/// Get the \f$ \|\eta\| \f$ directly.
	double abspseudorapidity() const { return fabs(eta()); }
	/// Get the \f$ \|\eta\| \f$ directly (alias).
	double abseta() const { return fabs(eta()); }

	/// Get the spatial part of the 4-vector as a 3-vector.
	Vector3 vector3() const {
	return Vector3(get(1), get(2), get(3));
	}


	public:

	/// Contract two 4-vectors, with metric signature (+ - - -).
	double contract(const FourVector& v) const {
	const double result = t()v.t() - x()v.x() - y()v.y() - z()v.z();
	return result;
	}

	/// Contract two 4-vectors, with metric signature (+ - - -).
	double dot(const FourVector& v) const {
	return contract(v);
	}

	/// Contract two 4-vectors, with metric signature (+ - - -).
	double operator*(const FourVector& v) const {
	return contract(v);
	}

	/// Multiply by a scalar.
	FourVector& operator*=(double a) {
	_vec = multiply(a, *this)._vec;
	return *this;
	}

	/// Divide by a scalar.
	FourVector& operator/=(double a) {
	_vec = multiply(1.0/a, *this)._vec;
	return *this;
	}

	/// Add to this 4-vector.
	FourVector& operator+=(const FourVector& v) {
	_vec = add(*this, v)._vec;
	return *this;
	}

	/// Subtract from this 4-vector. NB time as well as space components are subtracted.
	FourVector& operator-=(const FourVector& v) {
	_vec = add(*this, -v)._vec;
	return *this;
	}

	/// Multiply all components (space and time) by -1.
	FourVector operator-() const {
	FourVector result;
	result._vec = -_vec;
	return result;
	}

	/// Multiply space components only by -1.
	FourVector reverse() const {
	FourVector result = -*this;
	result.setT(-result.t());
	return result;
	}

	};


	/// Contract two 4-vectors, with metric signature (+ - - -).
	inline double contract(const FourVector& a, const FourVector& b) {
	return a.contract(b);
	}

	/// Contract two 4-vectors, with metric signature (+ - - -).
	inline double dot(const FourVector& a, const FourVector& b) {
	return contract(a, b);
	}

	inline FourVector multiply(const double a, const FourVector& v) {
	FourVector result;
	result._vec = a * v._vec;
	return result;
	}

	inline FourVector multiply(const FourVector& v, const double a) {
	return multiply(a, v);
	}

	inline FourVector operator*(const double a, const FourVector& v) {
	return multiply(a, v);
	}

	inline FourVector operator*(const FourVector& v, const double a) {
	return multiply(a, v);
	}

	inline FourVector operator/(const FourVector& v, const double a) {
	return multiply(1.0/a, v);
	}

	inline FourVector add(const FourVector& a, const FourVector& b) {
	FourVector result;
	result._vec = a._vec + b._vec;
	return result;
	}

	inline FourVector operator+(const FourVector& a, const FourVector& b) {
	return add(a, b);
	}

	inline FourVector operator-(const FourVector& a, const FourVector& b) {
	return add(a, -b);
	}

	/// Calculate the Lorentz self-invariant of a 4-vector.
	/// \f$ v_\mu v^\mu = g_{\mu\nu} x^\mu x^\nu \f$.
	inline double invariant(const FourVector& lv) {
	return lv.invariant();
	}

	/// Angle (in radians) between spatial parts of two Lorentz vectors.
	inline double angle(const FourVector& a, const FourVector& b) {
	return a.angle(b);
	}

	/// Angle (in radians) between spatial parts of two Lorentz vectors.
	inline double angle(const Vector3& a, const FourVector& b) {
	return angle( a, b.vector3() );
	}

	/// Angle (in radians) between spatial parts of two Lorentz vectors.
	inline double angle(const FourVector& a, const Vector3& b) {
	return a.angle(b);
	}


	////////////////////////////////////////////////


	/// Specialized version of the FourVector with momentum/energy functionality.
	class FourMomentum : public FourVector {
	friend FourMomentum multiply(const double a, const FourMomentum& v);
	friend FourMomentum multiply(const FourMomentum& v, const double a);
	friend FourMomentum add(const FourMomentum& a, const FourMomentum& b);
	friend FourMomentum transform(const LorentzTransform& lt, const FourMomentum& v4);

	public:
	FourMomentum() { }

	template<typename V4>
	FourMomentum(const V4& other) {
	this->setE(other.t());
	this->setPx(other.x());
	this->setPy(other.y());
	this->setPz(other.z());
	}

	FourMomentum(const Vector<4>& other)
	: FourVector(other) { }

	FourMomentum(const double E, const double px, const double py, const double pz) {
	this->setE(E);
	this->setPx(px);
	this->setPy(py);
	this->setPz(pz);
	}

	~FourMomentum() {}

	public:


	/// @name Coordinate setters
	//@{

	/// Set energy \f$ E \f$ (time component of momentum).
	FourMomentum& setE(double E) {
	setT(E);
	return *this;
	}

	/// Set x-component of momentum \f$ p_x \f$.
	FourMomentum& setPx(double px) {
	setX(px);
	return *this;
	}

	/// Set y-component of momentum \f$ p_y \f$.
	FourMomentum& setPy(double py) {
	setY(py);
	return *this;
	}

	/// Set z-component of momentum \f$ p_z \f$.
	FourMomentum& setPz(double pz) {
	setZ(pz);
	return *this;
	}


	/// Set the p coordinates and energy simultaneously
	FourMomentum& setPE(double px, double py, double pz, double E) {
	if (E < 0)
	- throw std::invalid_argument("Negative energy given as argument");
	+ throw std::invalid_argument("Negative energy given as argument: " + to_str(E));
	setPx(px); setPy(py); setPz(pz); setE(E);
	return *this;
	}
	/// Alias for setPE
	FourMomentum& setXYZE(double px, double py, double pz, double E) {
	return setPE(px, py, pz, E);
	}
	// /// Near-alias with switched arg order
	// FourMomentum& setEP(double E, double px, double py, double pz) {
	// return setPE(px, py, pz, E);
	// }
	// /// Alias for setEP
	// FourMomentum& setEXYZ(double E, double px, double py, double pz) {
	// return setEP(E, px, py, pz);
	// }


	/// Set the p coordinates and mass simultaneously
	FourMomentum& setPM(double px, double py, double pz, double mass) {
	if (mass < 0)
	- throw std::invalid_argument("Negative mass given as argument");
	- setPx(px); setPy(py); setPz(pz);
	- const double E = sqrt( sqr(mass) + p2() );
	- setE(E);
	- return *this;
	+ throw std::invalid_argument("Negative mass given as argument: " + to_str(mass));
	+ const double E = sqrt( sqr(mass) + sqr(px) + sqr(py) + sqr(pz) );
	+ // setPx(px); setPy(py); setPz(pz); setE(E);
	+ return setPE(px, py, pz, E);
	}
	/// Alias for setPM
	FourMomentum& setXYZM(double px, double py, double pz, double mass) {
	return setPM(px, py, pz, mass);
	}


	/// Set the vector state from (eta,phi,energy) coordinates and the mass
	///
	/// eta = -ln(tan(theta/2))
	/// -> theta = 2 atan(exp(-eta))
	FourMomentum& setEtaPhiME(double eta, double phi, double mass, double E) {
	if (mass < 0)
	throw std::invalid_argument("Negative mass given as argument");
	if (E < 0)
	throw std::invalid_argument("Negative energy given as argument");
	const double theta = 2 * atan(exp(-eta));
	if (theta < 0 \|\| theta > M_PI)
	throw std::domain_error("Polar angle outside 0..pi in calculation");
	setThetaPhiME(theta, phi, mass, E);
	return *this;
	}

	/// Set the vector state from (eta,phi,pT) coordinates and the mass
	///
	/// eta = -ln(tan(theta/2))
	/// -> theta = 2 atan(exp(-eta))
	FourMomentum& setEtaPhiMPt(double eta, double phi, double mass, double pt) {
	if (mass < 0)
	throw std::invalid_argument("Negative mass given as argument");
	if (pt < 0)
	throw std::invalid_argument("Negative transverse momentum given as argument");
	const double theta = 2 * atan(exp(-eta));
	if (theta < 0 \|\| theta > M_PI)
	throw std::domain_error("Polar angle outside 0..pi in calculation");
	const double p = pt / sin(theta);
	const double E = sqrt( sqr(p) + sqr(mass) );
	setThetaPhiME(theta, phi, mass, E);
	return *this;
	}

	/// Set the vector state from (y,phi,energy) coordinates and the mass
	///
	/// y = 0.5 * ln((E+pz)/(E-pz))
	/// -> (E^2 - pz^2) exp(2y) = (E+pz)^2
	/// & (E^2 - pz^2) exp(-2y) = (E-pz)^2
	/// -> E = sqrt(pt^2 + m^2) cosh(y)
	/// -> pz = sqrt(pt^2 + m^2) sinh(y)
	/// -> sqrt(pt^2 + m^2) = E / cosh(y)
	FourMomentum& setRapPhiME(double y, double phi, double mass, double E) {
	if (mass < 0)
	throw std::invalid_argument("Negative mass given as argument");
	if (E < 0)
	throw std::invalid_argument("Negative energy given as argument");
	const double sqrt_pt2_m2 = E / cosh(y);
	const double pt = sqrt( sqr(sqrt_pt2_m2) - sqr(mass) );
	if (pt < 0)
	throw std::domain_error("Negative transverse momentum in calculation");
	const double pz = sqrt_pt2_m2 * sinh(y);
	const double px = pt * cos(phi);
	const double py = pt * sin(phi);
	setPE(px, py, pz, E);
	return *this;
	}

	/// Set the vector state from (y,phi,pT) coordinates and the mass
	///
	/// y = 0.5 * ln((E+pz)/(E-pz))
	/// -> E = sqrt(pt^2 + m^2) cosh(y) [see above]
	FourMomentum& setRapPhiMPt(double y, double phi, double mass, double pt) {
	if (mass < 0)
	throw std::invalid_argument("Negative mass given as argument");
	if (pt < 0)
	throw std::invalid_argument("Negative transverse mass given as argument");
	const double E = sqrt( sqr(pt) + sqr(mass) ) * cosh(y);
	if (E < 0)
	throw std::domain_error("Negative energy in calculation");
	setRapPhiME(y, phi, mass, E);
	return *this;
	}

	/// Set the vector state from (theta,phi,energy) coordinates and the mass
	///
	/// p = sqrt(E^2 - mass^2)
	/// pz = p cos(theta)
	/// pt = p sin(theta)
	FourMomentum& setThetaPhiME(double theta, double phi, double mass, double E) {
	if (theta < 0 \|\| theta > M_PI)
	throw std::invalid_argument("Polar angle outside 0..pi given as argument");
	if (mass < 0)
	throw std::invalid_argument("Negative mass given as argument");
	if (E < 0)
	throw std::invalid_argument("Negative energy given as argument");
	const double p = sqrt( sqr(E) - sqr(mass) );
	const double pz = p * cos(theta);
	const double pt = p * sin(theta);
	if (pt < 0)
	throw std::invalid_argument("Negative transverse momentum in calculation");
	const double px = pt * cos(phi);
	const double py = pt * sin(phi);
	setPE(px, py, pz, E);
	return *this;
	}

	/// Set the vector state from (theta,phi,pT) coordinates and the mass
	///
	/// p = pt / sin(theta)
	/// pz = p cos(theta)
	/// E = sqrt(p^2 + mass^2)
	FourMomentum& setThetaPhiMPt(double theta, double phi, double mass, double pt) {
	if (theta < 0 \|\| theta > M_PI)
	throw std::invalid_argument("Polar angle outside 0..pi given as argument");
	if (mass < 0)
	throw std::invalid_argument("Negative mass given as argument");
	if (pt < 0)
	throw std::invalid_argument("Negative transverse momentum given as argument");
	const double p = pt / sin(theta);
	const double px = pt * cos(phi);
	const double py = pt * sin(phi);
	const double pz = p * cos(theta);
	const double E = sqrt( sqr(p) + sqr(mass) );
	setPE(px, py, pz, E);
	return *this;
	}

	/// Set the vector state from (pT,phi,energy) coordinates and the mass
	///
	/// pz = sqrt(E^2 - mass^2 - pt^2)
	FourMomentum& setPtPhiME(double pt, double phi, double mass, double E) {
	if (pt < 0)
	throw std::invalid_argument("Negative transverse momentum given as argument");
	if (mass < 0)
	throw std::invalid_argument("Negative mass given as argument");
	if (E < 0)
	throw std::invalid_argument("Negative energy given as argument");
	const double px = pt * cos(phi);
	const double py = pt * sin(phi);
	const double pz = sqrt(sqr(E) - sqr(mass) - sqr(pt));
	setPE(px, py, pz, E);
	return *this;
	}

	//@}


	/// @name Accessors
	//@{

	/// Get energy \f$ E \f$ (time component of momentum).
	double E() const { return t(); }
	/// Get energy-squared \f$ E^2 \f$.
	double E2() const { return t2(); }

	/// Get x-component of momentum \f$ p_x \f$.
	double px() const { return x(); }
	/// Get x-squared \f$ p_x^2 \f$.
	double px2() const { return x2(); }

	/// Get y-component of momentum \f$ p_y \f$.
	double py() const { return y(); }
	/// Get y-squared \f$ p_y^2 \f$.
	double py2() const { return y2(); }

	/// Get z-component of momentum \f$ p_z \f$.
	double pz() const { return z(); }
	/// Get z-squared \f$ p_z^2 \f$.
	double pz2() const { return z2(); }


	/// @brief Get the mass \f$ m = \sqrt{E^2 - p^2} \f$ (the Lorentz self-invariant).
	///
	/// For spacelike momenta, the mass will be -sqrt(\|mass2\|).
	double mass() const {
	// assert(Rivet::isZero(mass2()) \|\| mass2() > 0);
	// if (Rivet::isZero(mass2())) {
	// return 0.0;
	// } else {
	// return sqrt(mass2());
	// }
	return sign(mass2()) * sqrt(fabs(mass2()));
	}

	/// Get the squared mass \f$ m^2 = E^2 - p^2 \f$ (the Lorentz self-invariant).
	double mass2() const {
	return invariant();
	}


	/// Get 3-momentum part, \f$ p \f$.
	Vector3 p3() const { return vector3(); }

	/// Get the modulus of the 3-momentum
	double p() const {
	return p3().mod();
	}

	/// Get the modulus-squared of the 3-momentum
	double p2() const {
	return p3().mod2();
	}


	/// Calculate the rapidity.
	double rapidity() const {
	return 0.5 * std::log( (E() + pz()) / (E() - pz()) );
	}
	/// Alias for rapidity.
	double rap() const {
	return rapidity();
	}

	/// Absolute rapidity.
	double absrapidity() const {
	return fabs(rapidity());
	}
	/// Absolute rapidity.
	double absrap() const {
	return fabs(rap());
	}

	+ /// Calculate the transverse momentum vector \f$ \vec{p}_T \f$.
	+ Vector3 pTvec() const {
	+ return p3().polarVec();
	+ }
	+ /// Synonym for pTvec
	+ Vector3 ptvec() const {
	+ return pTvec();
	+ }
	+
	/// Calculate the squared transverse momentum \f$ p_T^2 \f$.
	double pT2() const {
	return vector3().polarRadius2();
	}
	/// Calculate the squared transverse momentum \f$ p_T^2 \f$.
	double pt2() const {
	return vector3().polarRadius2();
	}

	/// Calculate the transverse momentum \f$ p_T \f$.
	double pT() const {
	return sqrt(pT2());
	}
	/// Calculate the transverse momentum \f$ p_T \f$.
	double pt() const {
	return sqrt(pT2());
	}

	/// Calculate the transverse energy \f$ E_T^2 = E^2 \sin^2{\theta} \f$.
	double Et2() const {
	return Et() * Et();
	}
	/// Calculate the transverse energy \f$ E_T = E \sin{\theta} \f$.
	double Et() const {
	return E() * sin(polarAngle());
	}

	+ //@}

	- /// Calculate the boost vector (in units of \f$ \beta \f$).
	- Vector3 boostVector() const {
	- // const Vector3 p3 = vector3();
	- // const double m2 = mass2();
	- // if (Rivet::isZero(m2)) return p3.unit();
	- // else {
	- // // Could also do this via beta = tanh(rapidity), but that's
	- // // probably more messy from a numerical hygiene point of view.
	- // const double p2 = p3.mod2();
	- // const double beta = sqrt( p2 / (m2 + p2) );
	- // return beta * p3.unit();
	- // }
	- /// @todo Be careful about c=1 convention...
	- return Vector3(px()/E(), py()/E(), pz()/E());
	+
	+ /// @name Lorentz boost factors and vectors
	+ //@{
	+
	+ /// Calculate the boost factor \f$ \gamma \f$.
	+ /// @note \f$ \gamma = E/mc^2 \f$ so we rely on the c=1 convention
	+ double gamma() const {
	+ return sqrt(E2()/mass2());
	}

	+ /// Calculate the boost vector \f$ \vec{\gamma} \f$.
	+ /// @note \f$ \gamma = E/mc^2 \f$ so we rely on the c=1 convention
	+ Vector3 gammaVec() const {
	+ return gamma() * p3().unit();
	+ }
	+
	+ /// Calculate the boost factor \f$ \beta \f$.
	+ /// @note \f$ \beta = pc/E \f$ so we rely on the c=1 convention
	+ double beta() const {
	+ return p()/E();
	+ }
	+
	+ /// Calculate the boost vector \f$ \vec{\beta} \f$.
	+ /// @note \f$ \beta = pc/E \f$ so we rely on the c=1 convention
	+ Vector3 betaVec() const {
	+ // return Vector3(px()/E(), py()/E(), pz()/E());
	+ return p3()/E();
	+ }
	+
	+ /// @brief Deprecated alias for betaVec
	+ /// @deprecated This will be removed; use betaVec() instead
	+ Vector3 boostVector() const { return betaVec(); }
	+
	//@}


	////////////////////////////////////////


	/// @name Sorting helpers
	//@{

	/// Struct for sorting by increasing energy
	struct byEAscending {
	bool operator()(const FourMomentum& left, const FourMomentum& right) const{
	const double pt2left = left.E();
	const double pt2right = right.E();
	return pt2left < pt2right;
	}

	bool operator()(const FourMomentum* left, const FourMomentum* right) const{
	return (this)(left, *right);
	}
	};


	/// Struct for sorting by decreasing energy
	struct byEDescending {
	bool operator()(const FourMomentum& left, const FourMomentum& right) const{
	return byEAscending()(right, left);
	}

	bool operator()(const FourMomentum* left, const FourVector* right) const{
	return (this)(left, *right);
	}
	};

	//@}


	////////////////////////////////////////


	/// @name Arithmetic operators
	//@{

	/// Multiply by a scalar
	FourMomentum& operator*=(double a) {
	_vec = multiply(a, *this)._vec;
	return *this;
	}

	/// Divide by a scalar
	FourMomentum& operator/=(double a) {
	_vec = multiply(1.0/a, *this)._vec;
	return *this;
	}

	/// Add to this 4-vector. NB time as well as space components are added.
	FourMomentum& operator+=(const FourMomentum& v) {
	_vec = add(*this, v)._vec;
	return *this;
	}

	/// Subtract from this 4-vector. NB time as well as space components are subtracted.
	FourMomentum& operator-=(const FourMomentum& v) {
	_vec = add(*this, -v)._vec;
	return *this;
	}

	/// Multiply all components (time and space) by -1.
	FourMomentum operator-() const {
	FourMomentum result;
	result._vec = -_vec;
	return result;
	}

	/// Multiply space components only by -1.
	FourMomentum reverse() const {
	FourMomentum result = -*this;
	result.setE(-result.E());
	return result;
	}

	//@}


	////////////////////////////////////////


	/// @name Factory functions
	//@{

	/// Make a vector from (px,py,pz,E) coordinates
	static FourMomentum mkXYZE(double px, double py, double pz, double E) {
	return FourMomentum().setPE(px, py, pz, E);
	}

	/// Make a vector from (px,py,pz) coordinates and the mass
	static FourMomentum mkXYZM(double px, double py, double pz, double mass) {
	return FourMomentum().setPM(px, py, pz, mass);
	}

	/// Make a vector from (eta,phi,energy) coordinates and the mass
	static FourMomentum mkEtaPhiME(double eta, double phi, double mass, double E) {
	return FourMomentum().setEtaPhiME(eta, phi, mass, E);
	}

	/// Make a vector from (eta,phi,pT) coordinates and the mass
	static FourMomentum mkEtaPhiMPt(double eta, double phi, double mass, double pt) {
	return FourMomentum().setEtaPhiMPt(eta, phi, mass, pt);
	}

	/// Make a vector from (y,phi,energy) coordinates and the mass
	static FourMomentum mkRapPhiME(double y, double phi, double mass, double E) {
	return FourMomentum().setRapPhiME(y, phi, mass, E);
	}

	/// Make a vector from (y,phi,pT) coordinates and the mass
	static FourMomentum mkRapPhiMPt(double y, double phi, double mass, double pt) {
	return FourMomentum().setRapPhiMPt(y, phi, mass, pt);
	}

	/// Make a vector from (theta,phi,energy) coordinates and the mass
	static FourMomentum mkThetaPhiME(double theta, double phi, double mass, double E) {
	return FourMomentum().setThetaPhiME(theta, phi, mass, E);
	}

	/// Make a vector from (theta,phi,pT) coordinates and the mass
	static FourMomentum mkThetaPhiMPt(double theta, double phi, double mass, double pt) {
	return FourMomentum().setThetaPhiMPt(theta, phi, mass, pt);
	}

	/// Make a vector from (pT,phi,energy) coordinates and the mass
	static FourMomentum mkPtPhiME(double pt, double phi, double mass, double E) {
	return FourMomentum().setPtPhiME(pt, phi, mass, E);
	}

	//@}


	};



	inline FourMomentum multiply(const double a, const FourMomentum& v) {
	FourMomentum result;
	result._vec = a * v._vec;
	return result;
	}

	inline FourMomentum multiply(const FourMomentum& v, const double a) {
	return multiply(a, v);
	}

	inline FourMomentum operator*(const double a, const FourMomentum& v) {
	return multiply(a, v);
	}

	inline FourMomentum operator*(const FourMomentum& v, const double a) {
	return multiply(a, v);
	}

	inline FourMomentum operator/(const FourMomentum& v, const double a) {
	return multiply(1.0/a, v);
	}

	inline FourMomentum add(const FourMomentum& a, const FourMomentum& b) {
	FourMomentum result;
	result._vec = a._vec + b._vec;
	return result;
	}

	inline FourMomentum operator+(const FourMomentum& a, const FourMomentum& b) {
	return add(a, b);
	}

	inline FourMomentum operator-(const FourMomentum& a, const FourMomentum& b) {
	return add(a, -b);
	}


	//////////////////////////////////////////////////////


	/// @name \f$ \Delta R \f$ calculations from 4-vectors
	//@{

	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two four-vectors.
	/// There is a scheme ambiguity for momentum-type four vectors as to whether
	/// the pseudorapidity (a purely geometric concept) or the rapidity (a
	/// relativistic energy-momentum quantity) is to be used: this can be chosen
	/// via the optional scheme parameter. Use of this scheme option is
	/// discouraged in this case since @c RAPIDITY is only a valid option for
	/// vectors whose type is really the FourMomentum derived class.
	inline double deltaR(const FourVector& a, const FourVector& b,
	RapScheme scheme = PSEUDORAPIDITY) {
	switch (scheme) {
	case PSEUDORAPIDITY :
	return deltaR(a.vector3(), b.vector3());
	case RAPIDITY:
	{
	const FourMomentum* ma = dynamic_cast<const FourMomentum*>(&a);
	const FourMomentum* mb = dynamic_cast<const FourMomentum*>(&b);
	if (!ma \|\| !mb) {
	string err = "deltaR with scheme RAPIDITY can only be called with FourMomentum objects, not FourVectors";
	throw std::runtime_error(err);
	}
	return deltaR(ma, mb, scheme);
	}
	default:
	throw std::runtime_error("The specified deltaR scheme is not yet implemented");
	}
	}


	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two four-vectors.
	/// There is a scheme ambiguity for momentum-type four vectors
	/// as to whether the pseudorapidity (a purely geometric concept) or the
	/// rapidity (a relativistic energy-momentum quantity) is to be used: this can
	/// be chosen via the optional scheme parameter.
	inline double deltaR(const FourVector& v,
	double eta2, double phi2,
	RapScheme scheme = PSEUDORAPIDITY) {
	switch (scheme) {
	case PSEUDORAPIDITY :
	return deltaR(v.vector3(), eta2, phi2);
	case RAPIDITY:
	{
	const FourMomentum* mv = dynamic_cast<const FourMomentum*>(&v);
	if (!mv) {
	string err = "deltaR with scheme RAPIDITY can only be called with FourMomentum objects, not FourVectors";
	throw std::runtime_error(err);
	}
	return deltaR(*mv, eta2, phi2, scheme);
	}
	default:
	throw std::runtime_error("The specified deltaR scheme is not yet implemented");
	}
	}


	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two four-vectors.
	/// There is a scheme ambiguity for momentum-type four vectors
	/// as to whether the pseudorapidity (a purely geometric concept) or the
	/// rapidity (a relativistic energy-momentum quantity) is to be used: this can
	/// be chosen via the optional scheme parameter.
	inline double deltaR(double eta1, double phi1,
	const FourVector& v,
	RapScheme scheme = PSEUDORAPIDITY) {
	switch (scheme) {
	case PSEUDORAPIDITY :
	return deltaR(eta1, phi1, v.vector3());
	case RAPIDITY:
	{
	const FourMomentum* mv = dynamic_cast<const FourMomentum*>(&v);
	if (!mv) {
	string err = "deltaR with scheme RAPIDITY can only be called with FourMomentum objects, not FourVectors";
	throw std::runtime_error(err);
	}
	return deltaR(eta1, phi1, *mv, scheme);
	}
	default:
	throw std::runtime_error("The specified deltaR scheme is not yet implemented");
	}
	}


	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two four-vectors.
	/// There is a scheme ambiguity for momentum-type four vectors
	/// as to whether the pseudorapidity (a purely geometric concept) or the
	/// rapidity (a relativistic energy-momentum quantity) is to be used: this can
	/// be chosen via the optional scheme parameter.
	inline double deltaR(const FourMomentum& a, const FourMomentum& b,
	RapScheme scheme = PSEUDORAPIDITY) {
	switch (scheme) {
	case PSEUDORAPIDITY:
	return deltaR(a.vector3(), b.vector3());
	case RAPIDITY:
	return deltaR(a.rapidity(), a.azimuthalAngle(), b.rapidity(), b.azimuthalAngle());
	default:
	throw std::runtime_error("The specified deltaR scheme is not yet implemented");
	}
	}

	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two four-vectors.
	/// There is a scheme ambiguity for momentum-type four vectors
	/// as to whether the pseudorapidity (a purely geometric concept) or the
	/// rapidity (a relativistic energy-momentum quantity) is to be used: this can
	/// be chosen via the optional scheme parameter.
	inline double deltaR(const FourMomentum& v,
	double eta2, double phi2,
	RapScheme scheme = PSEUDORAPIDITY) {
	switch (scheme) {
	case PSEUDORAPIDITY:
	return deltaR(v.vector3(), eta2, phi2);
	case RAPIDITY:
	return deltaR(v.rapidity(), v.azimuthalAngle(), eta2, phi2);
	default:
	throw std::runtime_error("The specified deltaR scheme is not yet implemented");
	}
	}


	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two four-vectors.
	/// There is a scheme ambiguity for momentum-type four vectors
	/// as to whether the pseudorapidity (a purely geometric concept) or the
	/// rapidity (a relativistic energy-momentum quantity) is to be used: this can
	/// be chosen via the optional scheme parameter.
	inline double deltaR(double eta1, double phi1,
	const FourMomentum& v,
	RapScheme scheme = PSEUDORAPIDITY) {
	switch (scheme) {
	case PSEUDORAPIDITY:
	return deltaR(eta1, phi1, v.vector3());
	case RAPIDITY:
	return deltaR(eta1, phi1, v.rapidity(), v.azimuthalAngle());
	default:
	throw std::runtime_error("The specified deltaR scheme is not yet implemented");
	}
	}

	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two four-vectors.
	/// There is a scheme ambiguity for momentum-type four vectors
	/// as to whether the pseudorapidity (a purely geometric concept) or the
	/// rapidity (a relativistic energy-momentum quantity) is to be used: this can
	/// be chosen via the optional scheme parameter.
	inline double deltaR(const FourMomentum& a, const FourVector& b,
	RapScheme scheme = PSEUDORAPIDITY) {
	switch (scheme) {
	case PSEUDORAPIDITY:
	return deltaR(a.vector3(), b.vector3());
	case RAPIDITY:
	return deltaR(a.rapidity(), a.azimuthalAngle(), FourMomentum(b).rapidity(), b.azimuthalAngle());
	default:
	throw std::runtime_error("The specified deltaR scheme is not yet implemented");
	}
	}

	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between two four-vectors.
	/// There is a scheme ambiguity for momentum-type four vectors
	/// as to whether the pseudorapidity (a purely geometric concept) or the
	/// rapidity (a relativistic energy-momentum quantity) is to be used: this can
	/// be chosen via the optional scheme parameter.
	inline double deltaR(const FourVector& a, const FourMomentum& b,
	RapScheme scheme = PSEUDORAPIDITY) {
	return deltaR(b, a, scheme);
	}

	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between a
	/// three-vector and a four-vector.
	inline double deltaR(const FourMomentum& a, const Vector3& b) {
	return deltaR(a.vector3(), b);
	}

	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between a
	/// three-vector and a four-vector.
	inline double deltaR(const Vector3& a, const FourMomentum& b) {
	return deltaR(a, b.vector3());
	}

	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between a
	/// three-vector and a four-vector.
	inline double deltaR(const FourVector& a, const Vector3& b) {
	return deltaR(a.vector3(), b);
	}

	/// @brief Calculate the 2D rapidity-azimuthal ("eta-phi") distance between a
	/// three-vector and a four-vector.
	inline double deltaR(const Vector3& a, const FourVector& b) {
	return deltaR(a, b.vector3());
	}

	//@}


	//////////////////////////////////////////////////////


	/// @name \f$ \Delta phi \f$ calculations from 4-vectors
	//@{

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const FourMomentum& a, const FourMomentum& b) {
	return deltaPhi(a.vector3(), b.vector3());
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const FourMomentum& v, double phi2) {
	return deltaPhi(v.vector3(), phi2);
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(double phi1, const FourMomentum& v) {
	return deltaPhi(phi1, v.vector3());
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const FourVector& a, const FourVector& b) {
	return deltaPhi(a.vector3(), b.vector3());
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const FourVector& v, double phi2) {
	return deltaPhi(v.vector3(), phi2);
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(double phi1, const FourVector& v) {
	return deltaPhi(phi1, v.vector3());
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const FourVector& a, const FourMomentum& b) {
	return deltaPhi(a.vector3(), b.vector3());
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const FourMomentum& a, const FourVector& b) {
	return deltaPhi(a.vector3(), b.vector3());
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const FourVector& a, const Vector3& b) {
	return deltaPhi(a.vector3(), b);
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const Vector3& a, const FourVector& b) {
	return deltaPhi(a, b.vector3());
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const FourMomentum& a, const Vector3& b) {
	return deltaPhi(a.vector3(), b);
	}

	/// Calculate the difference in azimuthal angle between two vectors.
	inline double deltaPhi(const Vector3& a, const FourMomentum& b) {
	return deltaPhi(a, b.vector3());
	}

	//@}


	//////////////////////////////////////////////////////


	/// @name \f$ \|\Delta eta\| \f$ calculations from 4-vectors
	//@{

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const FourMomentum& a, const FourMomentum& b) {
	return deltaEta(a.vector3(), b.vector3());
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const FourMomentum& v, double eta2) {
	return deltaEta(v.vector3(), eta2);
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(double eta1, const FourMomentum& v) {
	return deltaEta(eta1, v.vector3());
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const FourVector& a, const FourVector& b) {
	return deltaEta(a.vector3(), b.vector3());
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const FourVector& v, double eta2) {
	return deltaEta(v.vector3(), eta2);
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(double eta1, const FourVector& v) {
	return deltaEta(eta1, v.vector3());
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const FourVector& a, const FourMomentum& b) {
	return deltaEta(a.vector3(), b.vector3());
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const FourMomentum& a, const FourVector& b) {
	return deltaEta(a.vector3(), b.vector3());
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const FourVector& a, const Vector3& b) {
	return deltaEta(a.vector3(), b);
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const Vector3& a, const FourVector& b) {
	return deltaEta(a, b.vector3());
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const FourMomentum& a, const Vector3& b) {
	return deltaEta(a.vector3(), b);
	}

	/// Calculate the difference in pseudorapidity between two vectors.
	inline double deltaEta(const Vector3& a, const FourMomentum& b) {
	return deltaEta(a, b.vector3());
	}

	//@}


	/// @name \f$ \|\Delta y\| \f$ calculations from 4-momentum vectors
	//@{

	/// Calculate the difference in rapidity between two 4-momentum vectors.
	inline double deltaRap(const FourMomentum& a, const FourMomentum& b) {
	return deltaRap(a.rapidity(), b.rapidity());
	}

	/// Calculate the difference in rapidity between two 4-momentum vectors.
	inline double deltaRap(const FourMomentum& v, double y2) {
	return deltaRap(v.rapidity(), y2);
	}

	/// Calculate the difference in rapidity between two 4-momentum vectors.
	inline double deltaRap(double y1, const FourMomentum& v) {
	return deltaRap(y1, v.rapidity());
	}

	//@}


	//////////////////////////////////////////////////////


	/// @name 4-vector comparison functions (for sorting)
	//@{

	/// Comparison to give a sorting by decreasing pT
	inline bool cmpMomByPt(const FourMomentum& a, const FourMomentum& b) {
	return a.pt() > b.pt();
	}
	/// Comparison to give a sorting by increasing pT
	inline bool cmpMomByAscPt(const FourMomentum& a, const FourMomentum& b) {
	return a.pt() < b.pt();
	}

	/// Comparison to give a sorting by decreasing 3-momentum magnitude \|p\|
	inline bool cmpMomByP(const FourMomentum& a, const FourMomentum& b) {
	return a.vector3().mod() > b.vector3().mod();
	}
	/// Comparison to give a sorting by increasing 3-momentum magnitude \|p\|
	inline bool cmpMomByAscP(const FourMomentum& a, const FourMomentum& b) {
	return a.vector3().mod() < b.vector3().mod();
	}

	/// Comparison to give a sorting by decreasing transverse energy
	inline bool cmpMomByEt(const FourMomentum& a, const FourMomentum& b) {
	return a.Et() > b.Et();
	}
	/// Comparison to give a sorting by increasing transverse energy
	inline bool cmpMomByAscEt(const FourMomentum& a, const FourMomentum& b) {
	return a.Et() < b.Et();
	}

	/// Comparison to give a sorting by decreasing energy
	inline bool cmpMomByE(const FourMomentum& a, const FourMomentum& b) {
	return a.E() > b.E();
	}
	/// Comparison to give a sorting by increasing energy
	inline bool cmpMomByAscE(const FourMomentum& a, const FourMomentum& b) {
	return a.E() < b.E();
	}

	/// Comparison to give a sorting by decreasing mass
	inline bool cmpMomByMass(const FourMomentum& a, const FourMomentum& b) {
	return a.mass() > b.mass();
	}
	/// Comparison to give a sorting by increasing mass
	inline bool cmpMomByAscMass(const FourMomentum& a, const FourMomentum& b) {
	return a.mass() < b.mass();
	}

	/// Comparison to give a sorting by increasing eta (pseudorapidity)
	inline bool cmpMomByEta(const FourMomentum& a, const FourMomentum& b) {
	return a.eta() < b.eta();
	}
	- /// Comparison to give a sorting by increasing eta (pseudorapidity)
	- /// @deprecated Use cmpMomByEta
	- DEPRECATED("Use cmpMomByEta")
	- inline bool cmpMomByAscPseudorapidity(const FourMomentum& a, const FourMomentum& b) {
	- return cmpMomByEta(a,b);
	- }

	/// Comparison to give a sorting by decreasing eta (pseudorapidity)
	inline bool cmpMomByDescEta(const FourMomentum& a, const FourMomentum& b) {
	return a.pseudorapidity() > b.pseudorapidity();
	}
	- /// Comparison to give a sorting by decreasing eta (pseudorapidity)
	- /// @deprecated Use cmpMomByDescEta
	- DEPRECATED("Use cmpMomByDescEta")
	- inline bool cmpMomByDescPseudorapidity(const FourMomentum& a, const FourMomentum& b) {
	- return cmpMomByDescEta(a,b);
	- }

	/// Comparison to give a sorting by increasing absolute eta (pseudorapidity)
	inline bool cmpMomByAbsEta(const FourMomentum& a, const FourMomentum& b) {
	return fabs(a.eta()) < fabs(b.eta());
	}
	- /// Comparison to give a sorting by increasing absolute eta (pseudorapidity)
	- /// @deprecated Use cmpMomByAbsEta
	- DEPRECATED("Use cmpMomByAbsEta")
	- inline bool cmpMomByAscAbsPseudorapidity(const FourMomentum& a, const FourMomentum& b) {
	- return cmpMomByAbsEta(a,b);
	- }

	/// Comparison to give a sorting by increasing absolute eta (pseudorapidity)
	inline bool cmpMomByDescAbsEta(const FourMomentum& a, const FourMomentum& b) {
	return fabs(a.eta()) > fabs(b.eta());
	}
	- /// Comparison to give a sorting by increasing absolute eta (pseudorapidity)
	- /// @deprecated Use cmpMomByDescAbsEta
	- DEPRECATED("Use cmpMomByDescAbsEta")
	- inline bool cmpMomByDescAbsPseudorapidity(const FourMomentum& a, const FourMomentum& b) {
	- return cmpMomByDescAbsEta(a,b);
	- }

	/// Comparison to give a sorting by increasing rapidity
	inline bool cmpMomByRap(const FourMomentum& a, const FourMomentum& b) {
	return a.rapidity() < b.rapidity();
	}
	- /// Comparison to give a sorting by increasing rapidity
	- /// @deprecated Use cmpMomByRap
	- DEPRECATED("Use cmpMomByRap")
	- inline bool cmpMomByAscRapidity(const FourMomentum& a, const FourMomentum& b) {
	- return cmpMomByRap(a,b);
	- }

	/// Comparison to give a sorting by decreasing rapidity
	inline bool cmpMomByDescRap(const FourMomentum& a, const FourMomentum& b) {
	return a.rapidity() > b.rapidity();
	}
	- /// Comparison to give a sorting by decreasing rapidity
	- /// @deprecated Use cmpMomByDescRap
	- DEPRECATED("Use cmpMomByDescRap")
	- inline bool cmpMomByDescRapidity(const FourMomentum& a, const FourMomentum& b) {
	- return cmpMomByDescRap(a,b);
	- }

	/// Comparison to give a sorting by increasing absolute rapidity
	inline bool cmpMomByAbsRap(const FourMomentum& a, const FourMomentum& b) {
	return fabs(a.rapidity()) < fabs(b.rapidity());
	}
	- /// Comparison to give a sorting by increasing absolute rapidity
	- /// @deprecated Use cmpMomByAbsRap
	- DEPRECATED("Use cmpMomByAbsRap")
	- inline bool cmpMomByAscAbsRapidity(const FourMomentum& a, const FourMomentum& b) {
	- return cmpMomByAbsRap(a,b);
	- }

	/// Comparison to give a sorting by decreasing absolute rapidity
	inline bool cmpMomByDescAbsRap(const FourMomentum& a, const FourMomentum& b) {
	return fabs(a.rapidity()) > fabs(b.rapidity());
	}
	- /// Comparison to give a sorting by decreasing absolute rapidity
	- /// @deprecated Use cmpMomByDescAbsRap
	- DEPRECATED("Use cmpMomByDescAbsRap")
	- inline bool cmpMomByDescAbsRapidity(const FourMomentum& a, const FourMomentum& b) {
	- return cmpMomByDescAbsRap(a,b);
	- }

	/// @todo Add sorting by phi [0..2PI]


	/// Sort a container of momenta by cmp and return by reference for non-const inputs
	template<typename MOMS, typename CMP>
	inline MOMS& sortBy(MOMS& pbs, const CMP& cmp) {
	std::sort(pbs.begin(), pbs.end(), cmp);
	return pbs;
	}
	/// Sort a container of momenta by cmp and return by value for const inputs
	template<typename MOMS, typename CMP>
	inline MOMS sortBy(const MOMS& pbs, const CMP& cmp) {
	MOMS rtn = pbs;
	std::sort(rtn.begin(), rtn.end(), cmp);
	return rtn;
	}

	/// Sort a container of momenta by pT (decreasing) and return by reference for non-const inputs
	template<typename MOMS>
	inline MOMS& sortByPt(MOMS& pbs) {
	return sortBy(pbs, cmpMomByPt);
	}
	/// Sort a container of momenta by pT (decreasing) and return by value for const inputs
	template<typename MOMS>
	inline MOMS sortByPt(const MOMS& pbs) {
	return sortBy(pbs, cmpMomByPt);
	}

	/// Sort a container of momenta by E (decreasing) and return by reference for non-const inputs
	template<typename MOMS>
	inline MOMS& sortByE(MOMS& pbs) {
	return sortBy(pbs, cmpMomByE);
	}
	/// Sort a container of momenta by E (decreasing) and return by value for const inputs
	template<typename MOMS>
	inline MOMS sortByE(const MOMS& pbs) {
	return sortBy(pbs, cmpMomByE);
	}

	/// Sort a container of momenta by Et (decreasing) and return by reference for non-const inputs
	template<typename MOMS>
	inline MOMS& sortByEt(MOMS& pbs) {
	return sortBy(pbs, cmpMomByEt);
	}
	/// Sort a container of momenta by Et (decreasing) and return by value for const inputs
	template<typename MOMS>
	inline MOMS sortByEt(const MOMS& pbs) {
	return sortBy(pbs, cmpMomByEt);
	}

	//@}


	//////////////////////////////////////////////////////


	/// @name 4-vector string representations
	//@{

	/// Render a 4-vector as a string.
	inline std::string toString(const FourVector& lv) {
	ostringstream out;
	out << "(" << (fabs(lv.t()) < 1E-30 ? 0.0 : lv.t())
	<< "; " << (fabs(lv.x()) < 1E-30 ? 0.0 : lv.x())
	<< ", " << (fabs(lv.y()) < 1E-30 ? 0.0 : lv.y())
	<< ", " << (fabs(lv.z()) < 1E-30 ? 0.0 : lv.z())
	<< ")";
	return out.str();
	}

	/// Write a 4-vector to an ostream.
	inline std::ostream& operator<<(std::ostream& out, const FourVector& lv) {
	out << toString(lv);
	return out;
	}

	//@}


	/// @name Typedefs of vector types to short names
	/// @todo Switch canonical and alias names
	//@{
	//typedef FourVector V4; //< generic
	typedef FourVector X4; //< spatial
	typedef FourMomentum P4; //< momentum
	//@}


	}

	#endif
	diff --git a/include/Rivet/Math/VectorN.hh b/include/Rivet/Math/VectorN.hh
	--- a/include/Rivet/Math/VectorN.hh
	+++ b/include/Rivet/Math/VectorN.hh
	@@ -1,192 +1,191 @@
	#ifndef RIVET_MATH_VECTORN
	#define RIVET_MATH_VECTORN

	#include "Rivet/Math/MathHeader.hh"
	#include "Rivet/Math/MathUtils.hh"

	#include "Rivet/Math/eigen/vector.h"

	namespace Rivet {


	template <size_t N>
	class Vector;
	template <size_t N>
	class Matrix;

	template <size_t N>
	Vector<N> multiply(const Matrix<N>& a, const Vector<N>& b);


	/// A minimal base class for \f$ N \f$-dimensional vectors.
	template <size_t N>
	class Vector {
	template <size_t M>
	friend Vector<M> multiply(const Matrix<M>& a, const Vector<M>& b);

	public:
	Vector() { _vec.loadZero(); }

	Vector(const Vector<N>& other)
	: _vec(other._vec) { }

	const double& get(const size_t index) const {
	if (index >= N) {
	throw std::runtime_error("Tried to access an invalid vector index.");
	} else {
	return _vec(index);
	}
	}

	+ double& get(const size_t index) {
	+ if (index >= N) {
	+ throw std::runtime_error("Tried to access an invalid vector index.");
	+ } else {
	+ return _vec(index);
	+ }
	+ }
	+
	/// Direct access to vector elements by index.
	const double& operator[](const size_t index) const {
	return get(index);
	}

	/// Direct access to vector elements by index.
	double& operator[](const size_t index) {
	return get(index);
	}

	/// Set indexed value
	Vector<N>& set(const size_t index, const double value) {
	if (index >= N) {
	throw std::runtime_error("Tried to access an invalid vector index.");
	} else {
	_vec[index] = value;
	}
	return *this;
	}

	/// Vector dimensionality
	size_t size() const {
	return N;
	}

	/// Check for nullness, allowing for numerical precision
	bool isZero(double tolerance=1E-5) const {
	for (size_t i=0; i < N; ++i) {
	if (! Rivet::isZero(_vec[i], tolerance) ) return false;
	}
	return true;
	}

	/// @brief Calculate the modulus-squared of a vector.
	/// \f$ \sum_{i=1}^N x_i^2 \f$.
	double mod2() const {
	double mod2 = 0.0;
	for (size_t i = 0; i < size(); ++i) {
	const double element = get(i);
	mod2 += element*element;
	}
	return mod2;
	}

	/// @brief Calculate the modulus of a vector.
	/// \f$ \sqrt{\sum_{i=1}^N x_i^2} \f$.
	double mod() const {
	const double norm = mod2();
	assert(norm >= 0);
	return sqrt(norm);
	}

	/// Invert the vector
	Vector<N> operator-() const {
	Vector<N> rtn;
	rtn._vec = -_vec;
	return rtn;
	}

	bool operator==(const Vector<N>& a) const {
	return _vec == a._vec;
	}

	bool operator!=(const Vector<N>& a) const {
	return _vec != a._vec;
	}

	bool operator<(const Vector<N>& a) const {
	return _vec < a._vec;
	}

	bool operator<=(const Vector<N>& a) const {
	return _vec <= a._vec;
	}

	bool operator>(const Vector<N>& a) const {
	return _vec > a._vec;
	}

	bool operator>=(const Vector<N>& a) const {
	return _vec >= a._vec;
	}

	-
	- protected:
	- double& get(const size_t index) {
	- if (index >= N) {
	- throw std::runtime_error("Tried to access an invalid vector index.");
	- } else {
	- return _vec(index);
	- }
	- }
	-
	/// Vector
	Eigen::Vector<double,N> _vec;
	+
	};


	/////////////////////////////////////////////////


	/// @name String representations of vectors
	//@{

	/// Make string representation
	template <size_t N>
	inline const string toString(const Vector<N>& v) {
	ostringstream out;
	out << "(";
	for (size_t i = 0; i < v.size(); ++i) {
	out << (fabs(v[i]) < 1E-30 ? 0.0 : v[i]);
	if (i < v.size()-1) out << ", ";
	}
	out << ")";
	return out.str();
	}

	/// Stream out string representation
	template <size_t N>
	inline std::ostream& operator<<(std::ostream& out, const Vector<N>& v) {
	out << toString(v);
	return out;
	}

	//@}


	/////////////////////////////////////////////////


	/// Compare two vectors by index, allowing for numerical precision
	template <size_t N>
	inline bool fuzzyEquals(const Vector<N>& va, const Vector<N>& vb, double tolerance=1E-5) {
	for (size_t i = 0; i < N; ++i) {
	const double a = va.get(i);
	const double b = vb.get(i);
	if (!Rivet::fuzzyEquals(a, b, tolerance)) return false;
	}
	return true;
	}


	/// External form of numerically safe nullness check
	template <size_t N>
	inline bool isZero(const Vector<N>& v, double tolerance=1E-5) {
	return v.isZero(tolerance);
	}


	}

	#endif
	diff --git a/include/Rivet/Math/Vectors.hh b/include/Rivet/Math/Vectors.hh
	--- a/include/Rivet/Math/Vectors.hh
	+++ b/include/Rivet/Math/Vectors.hh
	@@ -1,9 +1,13 @@
	#ifndef RIVET_MATH_VECTORS
	#define RIVET_MATH_VECTORS

	#include "Rivet/Math/MathHeader.hh"
	#include "Rivet/Math/VectorN.hh"
	#include "Rivet/Math/Vector3.hh"
	#include "Rivet/Math/Vector4.hh"

	+// typedef std::vector<FourMomentum> FourMomenta;
	+// typedef std::vector<FourVector> FourVectors;
	+// typedef std::vector<Vector3> Vector3s;
	+
	#endif
	diff --git a/include/Rivet/Particle.fhh b/include/Rivet/Particle.fhh
	--- a/include/Rivet/Particle.fhh
	+++ b/include/Rivet/Particle.fhh
	@@ -1,41 +1,42 @@
	// -- C++ --
	#ifndef RIVET_Particle_FHH
	#define RIVET_Particle_FHH

	#include "Rivet/Tools/RivetSTL.hh"

	namespace Rivet {


	/// @name Particle declarations
	//@{

	// Forward declaration
	class Particle;

	/// Typedefs for a vector of Particle objects.
	typedef std::vector<Particle> Particles; //< New form, cf. Jets
	/// @deprecated Use Particles instead. Will be removed
	typedef std::vector<Particle> ParticleVector; //< Old form

	/// Typedef for a pair of Particle objects.
	typedef std::pair<Particle, Particle> ParticlePair;

	//@}


	/// @name PdgId declarations
	//@{

	- /// Typedef for a PDG ID code.
	+ /// Typedefs for a PDG ID code.
	typedef int PdgId;
	+ //typedef PdgId PID; //< can't do this, because it's also a (sub)namespace

	/// Typedef for a pair of particle names.
	typedef std::pair<PdgId, PdgId> PdgIdPair;

	//@}


	}

	#endif
	diff --git a/include/Rivet/Particle.hh b/include/Rivet/Particle.hh
	--- a/include/Rivet/Particle.hh
	+++ b/include/Rivet/Particle.hh
	@@ -1,384 +1,423 @@
	// -- C++ --
	#ifndef RIVET_Particle_HH
	#define RIVET_Particle_HH

	#include "Rivet/Particle.fhh"
	#include "Rivet/ParticleBase.hh"
	#include "Rivet/Config/RivetCommon.hh"
	+#include "Rivet/Tools/Cuts.hh"
	#include "Rivet/Tools/Utils.hh"
	+#include "Rivet/Math/LorentzTrans.hh"
	// NOTE: Rivet/Tools/ParticleUtils.hh included at the end
	#include "fastjet/PseudoJet.hh"

	namespace Rivet {


	/// Particle representation, either from a HepMC::GenEvent or reconstructed.
	class Particle : public ParticleBase {
	public:

	+ /// @name Constructors
	+ //@{
	+
	/// Default constructor.
	/// @note A particle without info is useless. This only exists to keep STL containers happy.
	Particle()
	: ParticleBase(),
	_original(0), _id(0)
	{ }

	/// Constructor without GenParticle.
	Particle(PdgId pid, const FourMomentum& mom, const FourVector& pos=FourVector())
	: ParticleBase(),
	_original(0), _id(pid), _momentum(mom), _origin(pos)
	{ }

	+ /// Constructor from a HepMC GenParticle pointer.
	+ Particle(const GenParticle* gp)
	+ : ParticleBase(),
	+ _original(gp), _id(gp->pdg_id()),
	+ _momentum(gp->momentum())
	+ {
	+ const GenVertex* vprod = gp->production_vertex();
	+ if (vprod != NULL)
	+ setOrigin(vprod->position().t(), vprod->position().x(), vprod->position().y(), vprod->position().z());
	+ }
	+
	/// Constructor from a HepMC GenParticle.
	Particle(const GenParticle& gp)
	: ParticleBase(),
	_original(&gp), _id(gp.pdg_id()),
	_momentum(gp.momentum())
	{
	const GenVertex* vprod = gp.production_vertex();
	if (vprod != NULL)
	setOrigin(vprod->position().t(), vprod->position().x(), vprod->position().y(), vprod->position().z());
	}

	- /// Constructor from a HepMC GenParticle pointer.
	- Particle(const GenParticle* gp)
	- : ParticleBase(),
	- _original(gp), _id(gp->pdg_id()),
	- _momentum(gp->momentum())
	- {
	- const GenVertex* vprod = gp->production_vertex();
	- if (vprod != NULL)
	- setOrigin(vprod->position().t(), vprod->position().x(), vprod->position().y(), vprod->position().z());
	- }
	+ //@}


	- public:
	+ /// @name Other representations and implicit casts
	+ //@{

	/// Converter to FastJet3 PseudoJet
	virtual fastjet::PseudoJet pseudojet() const {
	return fastjet::PseudoJet(mom().px(), mom().py(), mom().pz(), mom().E());
	}

	/// Cast operator to FastJet3 PseudoJet
	operator PseudoJet () const { return pseudojet(); }


	- public:
	-
	- /// @name Basic particle specific properties
	- //@{
	-
	/// Get a const pointer to the original GenParticle.
	const GenParticle* genParticle() const {
	return _original;
	}

	/// Cast operator for conversion to GenParticle*
	operator const GenParticle* () const { return genParticle(); }

	+ //@}
	+
	+
	+ /// @name Kinematic properties
	+ //@{
	+
	/// The momentum.
	const FourMomentum& momentum() const {
	return _momentum;
	}
	+
	/// Set the momentum.
	Particle& setMomentum(const FourMomentum& momentum) {
	_momentum = momentum;
	return *this;
	}
	+
	/// Set the momentum via components.
	Particle& setMomentum(double E, double px, double py, double pz) {
	_momentum = FourMomentum(E, px, py, pz);
	return *this;
	}

	+ /// Apply an active Lorentz transform to this particle
	+ Particle& transformBy(const LorentzTransform& lt);
	+
	+ //@
	+
	+
	+ /// @name Positional properties
	+ //@{
	+
	/// The origin position.
	const FourVector& origin() const {
	return _origin;
	}
	/// Set the origin position.
	Particle& setOrigin(const FourVector& position) {
	_origin = position;
	return *this;
	}
	/// Set the origin position via components.
	Particle& setOrigin(double t, double x, double y, double z) {
	_origin = FourMomentum(t, x, y, z);
	return *this;
	}

	//@}


	/// @name Particle ID code accessors
	//@{

	/// This Particle's PDG ID code.
	PdgId pid() const { return _id; }
	/// Absolute value of the PDG ID code.
	PdgId abspid() const { return std::abs(_id); }
	/// This Particle's PDG ID code (alias).
	/// @deprecated Prefer the pid/abspid form
	PdgId pdgId() const { return _id; }

	//@}


	/// @name Particle species properties
	//@{

	/// The charge of this Particle.
	double charge() const { return PID::charge(pid()); }

	+ /// The absolute charge of this Particle.
	+ double abscharge() const { return PID::abscharge(pid()); }
	+
	/// Three times the charge of this Particle (i.e. integer multiple of smallest quark charge).
	int charge3() const { return PID::charge3(pid()); }

	- /// The abs charge of this Particle.
	- double abscharge() const { return PID::abscharge(pid()); }
	-
	- /// Three times the abs charge of this Particle (i.e. integer multiple of smallest quark charge).
	- int abscharge3() const { return PID::abscharge3(pid()); }
	-
	/// Alias for charge3
	/// @deprecated Use charge3
	- int threeCharge() const { return charge3(); }
	+ int threeCharge() const { return PID::threeCharge(pid()); }

	+ /// Three times the absolute charge of this Particle (i.e. integer multiple of smallest quark charge).
	+ int abscharge3() const { return PID::abscharge3(pid()); }

	/// Is this a hadron?
	bool isHadron() const { return PID::isHadron(pid()); }

	/// Is this a meson?
	bool isMeson() const { return PID::isMeson(pid()); }

	/// Is this a baryon?
	bool isBaryon() const { return PID::isBaryon(pid()); }

	/// Is this a lepton?
	bool isLepton() const { return PID::isLepton(pid()); }

	/// Is this a neutrino?
	bool isNeutrino() const { return PID::isNeutrino(pid()); }

	/// Does this (hadron) contain a b quark?
	bool hasBottom() const { return PID::hasBottom(pid()); }

	/// Does this (hadron) contain a c quark?
	bool hasCharm() const { return PID::hasCharm(pid()); }

	- /// Is this particle potentially visible in a detector?
	- bool isVisible() const {
	- // Charged particles are visible
	- if ( PID::threeCharge(pid()) != 0 ) return true;
	- // Neutral hadrons are visible
	- if ( PID::isHadron(pid()) ) return true;
	- // Photons are visible
	- if ( pid() == PID::PHOTON ) return true;
	- // Gluons are visible (for parton level analyses)
	- if ( pid() == PID::GLUON ) return true;
	- // Everything else is invisible
	- return false;
	- }
	-
	// /// Does this (hadron) contain an s quark?
	// bool hasStrange() const { return PID::hasStrange(pid()); }

	+ /// Is this particle potentially visible in a detector?
	+ bool isVisible() const;
	+
	//@}


	/// @name Ancestry properties
	//@{

	- /// Check whether a given PID is found in the GenParticle's ancestor list
	+ /// @todo Add physicalAncestors, allAncestors?
	+
	+ /// Get a list of the direct parents of the current particle (with optional selection Cut)
	+ ///
	+ /// @note This is valid in MC, but may not be answerable
	+ /// experimentally -- use this function with care when replicating
	+ /// experimental analyses!
	+ Particles parents(const Cut& c=Cuts::OPEN) const;
	+
	+ /// Get a list of the direct parents of the current particle (with selector function)
	+ ///
	+ /// @note This is valid in MC, but may not be answerable
	+ /// experimentally -- use this function with care when replicating
	+ /// experimental analyses!
	+ template <typename FN>
	+ Particles parents(const FN& f) const {
	+ return filter_select(parents(), f);
	+ }
	+
	+ /// Check whether a given PID is found in the particle's parent list
	///
	/// @note This question is valid in MC, but may not be answerable
	/// experimentally -- use this function with care when replicating
	/// experimental analyses!
	- bool hasAncestor(PdgId pdg_id) const;
	+ ///
	+ /// @deprecated Prefer e.g. parents(Cut::pid == 123).size()
	+ bool hasParent(PdgId pid) const;
	+
	+ /// Check whether a particle in the particle's parent list has the requested property
	+ ///
	+ /// @note This question is valid in MC, but may not be answerable
	+ /// experimentally -- use this function with care when replicating
	+ /// experimental analyses!
	+ ///
	+ /// @deprecated Prefer parents(Cut) or parents(FN) methods and .empty()
	+ template <typename FN>
	+ bool hasParentWith(const FN& f) const {
	+ return _hasRelativeWith(HepMC::parents, f);
	+ }
	+ bool hasParentWith(const Cut& c) const;
	+
	+ /// Check whether a given PID is found in the particle's ancestor list
	+ ///
	+ /// @note This question is valid in MC, but may not be answerable
	+ /// experimentally -- use this function with care when replicating
	+ /// experimental analyses!
	+ bool hasAncestor(PdgId pid) const;
	+
	+ /// Check whether a particle in the particle's ancestor list has the requested property
	+ ///
	+ /// @note This question is valid in MC, but may not be answerable
	+ /// experimentally -- use this function with care when replicating
	+ /// experimental analyses!
	+ template <typename FN>
	+ bool hasAncestorWith(const FN& f) const {
	+ return _hasRelativeWith(HepMC::ancestors, f);
	+ }
	+ bool hasAncestorWith(const Cut& c) const;

	/// @brief Determine whether the particle is from a b-hadron decay
	///
	/// @note This question is valid in MC, but may not be perfectly answerable
	/// experimentally -- use this function with care when replicating
	/// experimental analyses!
	bool fromBottom() const;

	/// @brief Determine whether the particle is from a c-hadron decay
	///
	/// @note If a hadron contains b and c quarks it is considered a bottom
	/// hadron and NOT a charm hadron.
	///
	/// @note This question is valid in MC, but may not be perfectly answerable
	/// experimentally -- use this function with care when replicating
	/// experimental analyses!
	bool fromCharm() const;

	// /// @brief Determine whether the particle is from a s-hadron decay
	// ///
	// /// @note If a hadron contains b or c quarks as well as strange it is
	// /// considered a b or c hadron, but NOT a strange hadron.
	// ///
	// /// @note This question is valid in MC, but may not be perfectly answerable
	// /// experimentally -- use this function with care when replicating
	// /// experimental analyses!
	// bool fromStrange() const;

	/// @brief Determine whether the particle is from a hadron decay
	///
	/// @note This question is valid in MC, but may not be perfectly answerable
	/// experimentally -- use this function with care when replicating
	/// experimental analyses!
	bool fromHadron() const;

	/// @brief Determine whether the particle is from a tau decay
	///
	/// @note This question is valid in MC, but may not be perfectly answerable
	/// experimentally -- use this function with care when replicating
	/// experimental analyses!
	bool fromTau(bool prompt_taus_only=false) const;

	/// @brief Determine whether the particle is from a prompt tau decay
	///
	/// @note This question is valid in MC, but may not be perfectly answerable
	/// experimentally -- use this function with care when replicating
	/// experimental analyses!
	bool fromPromptTau() const { return fromTau(true); }

	/// @brief Determine whether the particle is from a hadron or tau decay
	///
	/// Specifically, walk up the ancestor chain until a status 2 hadron or
	/// tau is found, if at all.
	///
	/// @note This question is valid in MC, but may not be perfectly answerable
	/// experimentally -- use this function with care when replicating
	/// experimental analyses!
	bool fromDecay() const { return fromHadron() \|\| fromPromptTau(); }

	+ /// @brief Shorthand definition of 'promptness' based on set definition flags
	+ ///
	+ /// The boolean arguments allow a decay lepton to be considered prompt if
	+ /// its parent was a "real" prompt lepton.
	+ ///
	+ /// @note This one doesn't make any judgements about final-stateness
	+ bool isPrompt(bool allow_from_prompt_tau=false, bool allow_from_prompt_mu=false) const;
	+
	//@}


	/// @name Decay info
	//@{

	/// Whether this particle is stable according to the generator
	- bool isStable() const {
	- return genParticle() != NULL && genParticle()->status() == 1 && genParticle()->end_vertex() == NULL;
	+ bool isStable() const;
	+
	+ /// Get a list of the direct descendants from the current particle (with optional selection Cut)
	+ Particles children(const Cut& c=Cuts::OPEN) const;
	+
	+ /// Get a list of the direct descendants from the current particle (with selector function)
	+ template <typename FN>
	+ Particles children(const FN& f) const {
	+ return filter_select(children(), f);
	}

	- /// Get a list of the direct descendants from the current particle
	- vector<Particle> children() const {
	- vector<Particle> rtn;
	- if (isStable()) return rtn;
	- /// @todo Remove this const mess crap when HepMC doesn't suck
	- HepMC::GenVertex* gv = const_cast<HepMC::GenVertex*>( genParticle()->end_vertex() );
	- /// @todo Would like to do this, but the range objects are broken
	- // foreach (const GenParticle* gp, gv->particles(HepMC::children))
	- // rtn += Particle(gp);
	- for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::children); it != gv->particles_end(HepMC::children); ++it)
	- rtn += Particle(*it);
	- return rtn;
	+ /// Get a list of all the descendants from the current particle (with optional selection Cut)
	+ Particles allDescendants(const Cut& c=Cuts::OPEN, bool remove_duplicates=true) const;
	+
	+ /// Get a list of all the descendants from the current particle (with selector function)
	+ template <typename FN>
	+ Particles allDescendants(const FN& f, bool remove_duplicates=true) const {
	+ return filter_select(allDescendants(Cuts::OPEN, remove_duplicates), f);
	}

	- /// Get a list of all the descendants (including duplication of parents and children) from the current particle
	+ /// Get a list of all the stable descendants from the current particle (with optional selection Cut)
	+ ///
	/// @todo Use recursion through replica-avoiding MCUtils functions to avoid bookkeeping duplicates
	/// @todo Insist that the current particle is post-hadronization, otherwise throw an exception?
	- vector<Particle> allDescendants() const {
	- vector<Particle> rtn;
	- if (isStable()) return rtn;
	- /// @todo Remove this const mess crap when HepMC doesn't suck
	- HepMC::GenVertex* gv = const_cast<HepMC::GenVertex*>( genParticle()->end_vertex() );
	- /// @todo Would like to do this, but the range objects are broken
	- // foreach (const GenParticle* gp, gv->particles(HepMC::descendants))
	- // rtn += Particle(gp);
	- for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::descendants); it != gv->particles_end(HepMC::descendants); ++it)
	- rtn += Particle(*it);
	- return rtn;
	- }
	+ Particles stableDescendants(const Cut& c=Cuts::OPEN) const;

	- /// Get a list of all the stable descendants from the current particle
	- /// @todo Use recursion through replica-avoiding MCUtils functions to avoid bookkeeping duplicates
	- /// @todo Insist that the current particle is post-hadronization, otherwise throw an exception?
	- vector<Particle> stableDescendants() const {
	- vector<Particle> rtn;
	- if (isStable()) return rtn;
	- /// @todo Remove this const mess crap when HepMC doesn't suck
	- HepMC::GenVertex* gv = const_cast<HepMC::GenVertex*>( genParticle()->end_vertex() );
	- /// @todo Would like to do this, but the range objects are broken
	- // foreach (const GenParticle* gp, gv->particles(HepMC::descendants))
	- // if (gp->status() == 1 && gp->end_vertex() == NULL)
	- // rtn += Particle(gp);
	- for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::descendants); it != gv->particles_end(HepMC::descendants); ++it)
	- if ((it)->status() == 1 && (it)->end_vertex() == NULL)
	- rtn += Particle(*it);
	- return rtn;
	+ /// Get a list of all the stable descendants from the current particle (with selector function)
	+ template <typename FN>
	+ Particles stableDescendants(const FN& f) const {
	+ return filter_select(stableDescendants(), f);
	}

	/// Flight length (divide by mm or cm to get the appropriate units)
	- double flightLength() const {
	- if (isStable()) return -1;
	- if (genParticle() == NULL) return 0;
	- if (genParticle()->production_vertex() == NULL) return 0;
	- const HepMC::FourVector v1 = genParticle()->production_vertex()->position();
	- const HepMC::FourVector v2 = genParticle()->end_vertex()->position();
	- return sqrt(sqr(v2.x()-v1.x()) + sqr(v2.y()-v1.y()) + sqr(v2.z()-v1.z()));
	- }
	+ double flightLength() const;

	//@}


	- private:
	+ protected:
	+
	+ template <typename FN>
	+ bool _hasRelativeWith(HepMC::IteratorRange relation, const FN& f) const {
	+ for (const GenParticle* ancestor : particles(genParticle(), relation)) {
	+ if (f(Particle(ancestor))) return true;
	+ }
	+ return false;
	+ }

	/// A pointer to the original GenParticle from which this Particle is projected.
	const GenParticle* _original;

	/// The PDG ID code for this Particle.
	PdgId _id;

	/// The momentum of this particle.
	FourMomentum _momentum;

	/// The creation position of this particle.
	FourVector _origin;

	};


	- /// @name Unbound functions for filtering particles
	+ /// @name String representation and streaming support
	//@{

	- /// Filter a jet collection in-place to the subset that passes the supplied Cut
	- Particles& filterBy(Particles& particles, const Cut& c);
	+ /// Represent a Particle as a string.
	+ std::string to_str(const Particle& p);

	- /// Get a subset of the supplied particles that passes the supplied Cut
	- Particles filterBy(const Particles& particles, const Cut& c);
	+ /// Allow a Particle to be passed to an ostream.
	+ inline std::ostream& operator<<(std::ostream& os, const Particle& p) {
	+ os << to_str(p);
	+ return os;
	+ }

	- //@}

	-
	- /// @name String representation
	- //@{
	-
	- /// Print a ParticlePair as a string.
	- inline std::string to_str(const ParticlePair& pair) {
	- stringstream out;
	- out << "["
	- << PID::toParticleName(pair.first.pid()) << " @ "
	- << pair.first.momentum().E()/GeV << " GeV, "
	- << PID::toParticleName(pair.second.pid()) << " @ "
	- << pair.second.momentum().E()/GeV << " GeV]";
	- return out.str();
	- }
	+ /// Represent a ParticlePair as a string.
	+ std::string to_str(const ParticlePair& pair);

	/// Allow ParticlePair to be passed to an ostream.
	inline std::ostream& operator<<(std::ostream& os, const ParticlePair& pp) {
	os << to_str(pp);
	return os;
	}

	//@}


	}


	#include "Rivet/Tools/ParticleUtils.hh"

	#endif
	diff --git a/include/Rivet/ParticleBase.hh b/include/Rivet/ParticleBase.hh
	--- a/include/Rivet/ParticleBase.hh
	+++ b/include/Rivet/ParticleBase.hh
	@@ -1,280 +1,284 @@
	#ifndef RIVET_ParticleBase_HH
	#define RIVET_ParticleBase_HH

	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Jet.fhh"
	-#include "Rivet/Cuts.fhh"
	+#include "Rivet/Tools/Cuts.fhh"
	#include "Rivet/Math/Vectors.hh"

	namespace Rivet {


	/// @brief Base class for particle-like things like Particle and Jet
	class ParticleBase {
	public:

	/// Default constructor
	ParticleBase() { }

	/// Virtual destructor
	virtual ~ParticleBase() { }


	/// @name Effective momentum accessors
	//@{

	/// Get equivalent single momentum four-vector (const).
	virtual const FourMomentum& momentum() const = 0;
	/// Get equivalent single momentum four-vector (const) (alias).
	const FourMomentum& mom() const { return momentum(); };

	/// Cast operator for conversion to FourMomentum
	operator const FourMomentum& () const { return momentum(); }

	//@}


	/// @name Convenience access to the effective 4-vector properties
	//@{

	/// Get the energy directly.
	double E() const { return momentum().E(); }
	/// Get the energy directly (alias).
	double energy() const { return momentum().E(); }

	/// Get the energy-squared.
	double E2() const { return momentum().E2(); }
	/// Get the energy-squared (alias).
	double energy2() const { return momentum().E2(); }

	/// Get the \f$ p_T \f$ directly.
	double pt() const { return momentum().pt(); }
	/// Get the \f$ p_T \f$ directly (alias).
	double pT() const { return pt(); }
	/// Get the \f$ p_T \f$ directly (alias).
	double perp() const { return pt(); }

	/// Get the \f$ p_T^2 \f$ directly.
	double pt2() const { return momentum().pt2(); }
	/// Get the \f$ p_T^2 \f$ directly (alias).
	double pT2() const { return pt2(); }
	/// Get the \f$ p_T^2 \f$ directly (alias).
	double perp2() const { return pt2(); }

	/// Get the \f$ E_T \f$ directly.
	double Et() const { return momentum().Et(); }
	/// Get the \f$ E_T^2 \f$ directly.
	double Et2() const { return momentum().Et2(); }

	/// Get the mass directly.
	double mass() const { return momentum().mass(); }
	/// Get the mass**2 directly.
	double mass2() const { return momentum().mass2(); }

	/// Get the \f$ \eta \f$ directly.
	double pseudorapidity() const { return momentum().eta(); }
	/// Get the \f$ \eta \f$ directly (alias).
	double eta() const { return momentum().eta(); }
	/// Get the \f$ \|\eta\| \f$ directly.
	double abspseudorapidity() const { return momentum().abspseudorapidity(); }
	/// Get the \f$ \|\eta\| \f$ directly (alias).
	double abseta() const { return momentum().abseta(); }

	/// Get the \f$ y \f$ directly.
	double rapidity() const { return momentum().rapidity(); }
	/// Get the \f$ y \f$ directly (alias).
	double rap() const { return momentum().rapidity(); }
	/// Get the \f$ \|y\| \f$ directly.
	double absrapidity() const { return momentum().absrapidity(); }
	/// Get the \f$ \|y\| \f$ directly (alias).
	double absrap() const { return momentum().absrap(); }

	/// Azimuthal angle \f$ \phi \f$.
	double azimuthalAngle(const PhiMapping mapping=ZERO_2PI) const { return momentum().azimuthalAngle(mapping); }
	/// Get the \f$ \phi \f$ directly.
	double phi(const PhiMapping mapping=ZERO_2PI) const { return momentum().phi(mapping); }

	-
	/// Get the 3-momentum directly.
	Vector3 p3() const { return momentum().vector3(); }
	/// Get the 3-momentum magnitude directly.
	double p() const { return momentum().p(); }
	/// Get the 3-momentum magnitude-squared directly.
	double p2() const { return momentum().p2(); }

	+ /// Get the transverse 3-momentum directly.
	+ Vector3 ptvec() const { return momentum().ptvec(); }
	+ /// Get the transverse 3-momentum directly.
	+ Vector3 pTvec() const { return momentum().pTvec(); }
	+
	/// x component of momentum.
	double px() const { return momentum().x(); }
	/// y component of momentum.
	double py() const { return momentum().y(); }
	/// z component of momentum.
	double pz() const { return momentum().z(); }

	/// x component of momentum, squared.
	double px2() const { return momentum().x2(); }
	/// y component of momentum, squared.
	double py2() const { return momentum().y2(); }
	/// z component of momentum, squared.
	double pz2() const { return momentum().z2(); }

	/// Angle subtended by the 3-vector and the z-axis.
	double polarAngle() const { return momentum().polarAngle(); }
	/// Synonym for polarAngle.
	double theta() const { return momentum().theta(); }

	/// Angle between this vector and another
	double angle(const ParticleBase& v) const { return momentum().angle(v.momentum()); }
	/// Angle between this vector and another
	double angle(const FourVector& v) const { return momentum().angle(v); }
	/// Angle between this vector and another (3-vector)
	double angle(const Vector3& v3) const { return momentum().angle(v3); }

	//@}

	};


	/// @name deltaR, deltaEta, deltaPhi functions specifically for Particle/Jet arguments
	//@{

	inline double deltaR(const ParticleBase& p1, const ParticleBase& p2,
	RapScheme scheme = PSEUDORAPIDITY) {
	return deltaR(p1.momentum(), p2.momentum(), scheme);
	}

	inline double deltaR(const ParticleBase& p, const FourMomentum& v,
	RapScheme scheme = PSEUDORAPIDITY) {
	return deltaR(p.momentum(), v, scheme);
	}

	inline double deltaR(const ParticleBase& p, const FourVector& v,
	RapScheme scheme = PSEUDORAPIDITY) {
	return deltaR(p.momentum(), v, scheme);
	}

	inline double deltaR(const ParticleBase& p, const Vector3& v) {
	return deltaR(p.momentum(), v);
	}

	inline double deltaR(const ParticleBase& p, double eta, double phi) {
	return deltaR(p.momentum(), eta, phi);
	}

	inline double deltaR(const FourMomentum& v, const ParticleBase& p,
	RapScheme scheme = PSEUDORAPIDITY) {
	return deltaR(v, p.momentum(), scheme);
	}

	inline double deltaR(const FourVector& v, const ParticleBase& p,
	RapScheme scheme = PSEUDORAPIDITY) {
	return deltaR(v, p.momentum(), scheme);
	}

	inline double deltaR(const Vector3& v, const ParticleBase& p) {
	return deltaR(v, p.momentum());
	}

	inline double deltaR(double eta, double phi, const ParticleBase& p) {
	return deltaR(eta, phi, p.momentum());
	}


	inline double deltaPhi(const ParticleBase& p1, const ParticleBase& p2) {
	return deltaPhi(p1.momentum(), p2.momentum());
	}

	inline double deltaPhi(const ParticleBase& p, const FourMomentum& v) {
	return deltaPhi(p.momentum(), v);
	}

	inline double deltaPhi(const ParticleBase& p, const FourVector& v) {
	return deltaPhi(p.momentum(), v);
	}

	inline double deltaPhi(const ParticleBase& p, const Vector3& v) {
	return deltaPhi(p.momentum(), v);
	}

	inline double deltaPhi(const ParticleBase& p, double phi) {
	return deltaPhi(p.momentum(), phi);
	}

	inline double deltaPhi(const FourMomentum& v, const ParticleBase& p) {
	return deltaPhi(v, p.momentum());
	}

	inline double deltaPhi(const FourVector& v, const ParticleBase& p) {
	return deltaPhi(v, p.momentum());
	}

	inline double deltaPhi(const Vector3& v, const ParticleBase& p) {
	return deltaPhi(v, p.momentum());
	}

	inline double deltaPhi(double phi, const ParticleBase& p) {
	return deltaPhi(phi, p.momentum());
	}


	inline double deltaEta(const ParticleBase& p1, const ParticleBase& p2) {
	return deltaEta(p1.momentum(), p2.momentum());
	}

	inline double deltaEta(const ParticleBase& p, const FourMomentum& v) {
	return deltaEta(p.momentum(), v);
	}

	inline double deltaEta(const ParticleBase& p, const FourVector& v) {
	return deltaEta(p.momentum(), v);
	}

	inline double deltaEta(const ParticleBase& p, const Vector3& v) {
	return deltaEta(p.momentum(), v);
	}

	inline double deltaEta(const ParticleBase& p, double eta) {
	return deltaEta(p.momentum(), eta);
	}

	inline double deltaEta(const FourMomentum& v, const ParticleBase& p) {
	return deltaEta(v, p.momentum());
	}

	inline double deltaEta(const FourVector& v, const ParticleBase& p) {
	return deltaEta(v, p.momentum());
	}

	inline double deltaEta(const Vector3& v, const ParticleBase& p) {
	return deltaEta(v, p.momentum());
	}

	inline double deltaEta(double eta, const ParticleBase& p) {
	return deltaEta(eta, p.momentum());
	}


	inline double deltaRap(const ParticleBase& p1, const ParticleBase& p2) {
	return deltaRap(p1.momentum(), p2.momentum());
	}

	inline double deltaRap(const ParticleBase& p, const FourMomentum& v) {
	return deltaRap(p.momentum(), v);
	}

	inline double deltaRap(const ParticleBase& p, double y) {
	return deltaRap(p.momentum(), y);
	}

	inline double deltaRap(const FourMomentum& v, const ParticleBase& p) {
	return deltaRap(v, p.momentum());
	}

	inline double deltaRap(double y, const ParticleBase& p) {
	return deltaRap(y, p.momentum());
	}

	//@}


	}

	#endif
	diff --git a/include/Rivet/Projection.fhh b/include/Rivet/Projection.fhh
	--- a/include/Rivet/Projection.fhh
	+++ b/include/Rivet/Projection.fhh
	@@ -1,47 +1,47 @@
	// -- C++ --
	#ifndef Rivet_Projection_FHH
	#define Rivet_Projection_FHH

	/// @todo Is there a reason that this stuff can't go into Projection.hh?

	#include "Rivet/Config/RivetCommon.hh"
	-#include "Rivet/Cmp.fhh"
	+#include "Rivet/Tools/Cmp.fhh"


	namespace Rivet {
	class Projection;
	typedef Projection* ProjectionPtr;
	typedef const Projection* ConstProjectionPtr;
	}


	namespace std {

	/// This is the function called when comparing two (const) pointers to Rivet::Projection.
	template <>
	struct less<const Rivet::Projection*>
	: public binary_function<const Rivet::Projection, const Rivet::Projection, bool> {
	bool operator()(const Rivet::Projection* x, const Rivet::Projection* y) const;
	};

	}


	namespace Rivet {

	/// Convenience method for casting to a const Projection reference.
	template <typename PROJ>
	inline const PROJ& pcast(const Projection& p) {
	return dynamic_cast<const PROJ&>(p);
	}


	/// Convenience method for casting to a const Projection pointer.
	template <typename PROJ>
	inline const PROJ* pcast(const Projection* p) {
	return dynamic_cast<const PROJ*>(p);
	}

	}

	#endif
	diff --git a/include/Rivet/Projection.hh b/include/Rivet/Projection.hh
	--- a/include/Rivet/Projection.hh
	+++ b/include/Rivet/Projection.hh
	@@ -1,166 +1,175 @@
	// -- C++ --
	#ifndef RIVET_Projection_HH
	#define RIVET_Projection_HH

	#include "Rivet/Projection.fhh"
	#include "Rivet/ProjectionApplier.hh"
	#include "Rivet/ProjectionHandler.hh"
	#include "Rivet/Config/RivetCommon.hh"
	+#include "Rivet/Tools/Cuts.hh"
	// NOTE: Cmp.hh, Event.hh and Particle.hh included at the bottom

	namespace Rivet {


	// Forward declaration
	class Event;


	/// @brief Base class for all Rivet projections.
	///
	/// Projection is the base class of all Projections to be used by
	/// Rivet. A Projection object can be assigned to an Event object and
	/// will then define a processed part of the information available in
	/// the Event, which then can be used by other Projection objects
	/// and/or Analysis objects.
	///
	/// The main virtual functions to be overridden by concrete sub-classes
	/// are project(const Event &) and compare(const Projection &).
	class Projection : public ProjectionApplier {
	public:

	/// Event is a friend.
	friend class Event;

	/// The Cmp specialization for Projection is a friend.
	friend class Cmp<Projection>;

	public:

	/// @name Standard constructors and destructors.
	//@{
	/// The default constructor.
	Projection();

	/// Clone on the heap.
	virtual unique_ptr<Projection> clone() const = 0;

	/// The destructor.
	virtual ~Projection();
	//@}


	public:

	/// Take the information available in the Event and make the
	/// calculations necessary to obtain the projection. Note that this
	/// function must never be called except inside the
	/// Event::applyProjection(Projection *) function.
	virtual void project(const Event& e) = 0;


	protected:

	/// This function is used to define a unique ordering between
	/// different Projection objects of the same class. If this is
	/// considered to be equivalent to the Projector object, \a p, in the
	/// argument the function should return 0. If this object should be
	/// ordered before \a p a negative value should be returned,
	/// otherwise a positive value should be returned. This function must
	/// never be called explicitly, but should only be called from the
	/// operator<(const Projection &). When implementing the function in
	/// concrete sub-classes, it is then guaranteed that the Projection
	/// object \a p in the argument is of the same class as the sub-class
	/// and can be safely dynamically casted to that class.
	///
	/// When implementing this function in a sub-class, the immediate
	/// base class version of the function should be called first. If the
	/// base class function returns a non-zero value, that value should
	/// be returned immediately. Only if zero is returned should this
	/// function check the member variables of the sub-class to determine
	/// whether this should be ordered before or after \a p, or if it is
	/// equivalent with \a p.
	virtual int compare(const Projection& p) const = 0;

	public:

	/// Determine whether this object should be ordered before the object
	/// \a p given as argument. If \a p is of a different class than
	/// this, the before() function of the corresponding type_info
	/// objects is used. Otherwise, if the objects are of the same class,
	/// the virtual compare(const Projection &) will be returned.
	bool before(const Projection& p) const;

	/// Return the allowed beam pairs on which this projection can operate, not
	/// including recursion. Derived classes should ensure that all contained
	/// projections are registered in the @a _projections set for the beam
	/// constraint chaining to work.
	/// @todo Remove the beam constraints system from projections.
	virtual const std::set<PdgIdPair> beamPairs() const;

	/// Get the name of the projection.
	virtual std::string name() const {
	return _name;
	}


	/// Add a colliding beam pair.
	Projection& addPdgIdPair(PdgId beam1, PdgId beam2) {
	_beamPairs.insert(PdgIdPair(beam1, beam2));
	return *this;
	}


	/// Get a Log object based on the getName() property of the calling projection object.
	Log& getLog() const {
	string logname = "Rivet.Projection." + name();
	return Log::getLog(logname);
	}

	/// Used by derived classes to set their name.
	void setName(const std::string& name) {
	_name = name;
	}


	protected:

	/// Shortcut to make a named Cmp<Projection> comparison with the @c *this
	/// object automatically passed as one of the parent projections.
	Cmp<Projection> mkNamedPCmp(const Projection& otherparent, const std::string& pname) const;

	/// Shortcut to make a named Cmp<Projection> comparison with the @c *this
	/// object automatically passed as one of the parent projections.
	+ ///
	+ /// @note Alias for mkNamedPCmp
	Cmp<Projection> mkPCmp(const Projection& otherparent, const std::string& pname) const;

	/// Block Projection copying
	virtual Projection& operator = (const Projection&);


	private:

	/// Name variable is used by the base class messages to identify
	/// which derived class is being handled.
	string _name;

	/// Beam-type constraint.
	set<PdgIdPair> _beamPairs;

	};


	}


	/// Define "less" operator for Projection* containers in terms of the Projection::before virtual method.
	inline bool std::less<const Rivet::Projection >::operator()(const Rivet::Projection x,
	const Rivet::Projection* y) const {
	return x->before(*y);
	}


	#endif


	-#include "Rivet/Cmp.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Particle.hh"
	+#include "Rivet/Tools/Cmp.hh"
	+
	+
	+/// @def DEFAULT_RIVET_PROJ_CLONE
	+/// Preprocessor define to prettify the manky constructor with name string argument
	+#define DEFAULT_RIVET_PROJ_CLONE(clsname) \
	+ virtual unique_ptr<Projection> clone() const { return unique_ptr<Projection>(new clsname(*this)); }
	diff --git a/include/Rivet/ProjectionApplier.hh b/include/Rivet/ProjectionApplier.hh
	--- a/include/Rivet/ProjectionApplier.hh
	+++ b/include/Rivet/ProjectionApplier.hh
	@@ -1,160 +1,200 @@
	// -- C++ --
	#ifndef RIVET_ProjectionApplier_HH
	#define RIVET_ProjectionApplier_HH

	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Projection.fhh"
	#include "Rivet/ProjectionHandler.hh"
	#include "Rivet/Tools/Logging.hh"

	namespace Rivet {


	// Forward declarations
	class Event;


	/// @brief Common base class for Projection and Analysis, used for internal polymorphism
	///
	/// Empty interface used for storing Projection and Analysis pointers in the
	/// same container (used by the ProjectionHandler)
	class ProjectionApplier {
	public:

	// The proj handler needs access to reset the _allowProjReg flag before calling a.init()
	// friend class ProjectionHandler;

	/// Constructor
	ProjectionApplier();

	// Virtual destructor: ensure that inheritance is possible.
	virtual ~ProjectionApplier();


	- public:
	-
	/// @name Metadata functions
	//@{
	/// Get the name of this Projection or Analysis class
	virtual std::string name() const = 0;
	//@}

	/// @name Projection "getting" functions
	//@{
	/// Get the contained projections, including recursion.
	std::set<ConstProjectionPtr> getProjections() const {
	return getProjHandler().getChildProjections(*this, ProjectionHandler::DEEP);
	}

	-
	/// Get the named projection, specifying return type via a template argument.
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	template <typename PROJ>
	const PROJ& getProjection(const std::string& name) const {
	const Projection& p = getProjHandler().getProjection(*this, name);
	return pcast<PROJ>(p);
	}
	-
	+ /// Get the named projection, specifying return type via a template argument (user-facing alias).
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	+ template <typename PROJ>
	+ const PROJ& get(const std::string& name) const { return getProjection<PROJ>(name); }

	/// Get the named projection (non-templated, so returns as a reference to a
	/// Projection base class).
	const Projection& getProjection(const std::string& name) const {
	return getProjHandler().getProjection(*this, name);
	}
	+
	//@}


	/// @name Projection applying functions
	//@{
	- /// Apply the supplied projection on @a event.
	+
	+ /// Apply the supplied projection on event @a evt.
	template <typename PROJ>
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	+ const PROJ& applyProjection(const Event& evt, const Projection& proj) const {
	+ return pcast<PROJ>(_applyProjection(evt, proj));
	+ }
	+ /// Apply the supplied projection on event @a evt (user-facing alias).
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	+ template <typename PROJ>
	+ const PROJ& apply(const Event& evt, const Projection& proj) const { return applyProjection<PROJ>(evt, proj); }
	+
	+
	+ /// Apply the supplied projection on event @a evt.
	+ template <typename PROJ>
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	const PROJ& applyProjection(const Event& evt, const PROJ& proj) const {
	return pcast<PROJ>(_applyProjection(evt, proj));
	}
	+ /// Apply the supplied projection on event @a evt (user-facing alias).
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	+ template <typename PROJ>
	+ const PROJ& apply(const Event& evt, const PROJ& proj) const { return applyProjection<PROJ>(evt, proj); }


	- /// Apply the supplied projection on @a event.
	- template <typename PROJ>
	- const PROJ& applyProjection(const Event& evt, const Projection& proj) const {
	- return pcast<PROJ>(_applyProjection(evt, proj));
	- }
	-
	-
	- /// Apply the named projection on @a event.
	+ /// Apply the named projection on event @a evt.
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	template <typename PROJ>
	const PROJ& applyProjection(const Event& evt, const std::string& name) const {
	return pcast<PROJ>(_applyProjection(evt, name));
	}
	+ /// Apply the supplied projection on event @a evt (user-facing alias).
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	+ template <typename PROJ>
	+ const PROJ& apply(const Event& evt, const std::string& name) const { return applyProjection<PROJ>(evt, name); }
	+ /// Apply the supplied projection on event @a evt (convenience arg-reordering alias).
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	+ template <typename PROJ>
	+ const PROJ& apply(const std::string& name, const Event& evt) const { return applyProjection<PROJ>(evt, name); }
	+
	//@}


	+ /// Mark object as owned by the _projhandler
	+ /// @todo Huh? What's this for?
	+ void markAsOwned() const { _owned = true; }
	+
	+
	protected:

	Log& getLog() const {
	return Log::getLog("Rivet.ProjectionHandler");
	}

	+
	/// Get a reference to the ProjectionHandler for this thread.
	ProjectionHandler& getProjHandler() const {
	return _projhandler;
	}


	- protected:
	-
	-
	/// @name Projection registration functions
	//@{

	- /// Register a contained projection. The type of the argument is used to
	- /// instantiate a new projection internally: this new object is applied to
	- /// events rather than the argument object. Hence you are advised to only use
	- /// locally-scoped Projection objects in your Projection and Analysis
	- /// constructors, and to avoid polymorphism (e.g. handling @c ConcreteProjection
	- /// via a pointer or reference to type @c Projection) since this will screw
	- /// up the internal type management.
	+ /// @brief Register a contained projection
	+ ///
	+ /// The type of the argument is used to instantiate a new projection
	+ /// internally: this new object is applied to events rather than the
	+ /// argument object. Hence you are advised to only use locally-scoped
	+ /// Projection objects in your Projection and Analysis constructors, and to
	+ /// avoid polymorphism (e.g. handling @c ConcreteProjection via a pointer or
	+ /// reference to type @c Projection) since this will screw up the internal
	+ /// type management.
	+ ///
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	template <typename PROJ>
	- const PROJ& addProjection(const PROJ& proj, const std::string& name) {
	- const Projection& reg = _addProjection(proj, name);
	+ const PROJ& declareProjection(const PROJ& proj, const std::string& name) {
	+ const Projection& reg = _declareProjection(proj, name);
	const PROJ& rtn = dynamic_cast<const PROJ&>(reg);
	return rtn;
	}

	+ /// @brief Register a contained projection (user-facing version)
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	+ template <typename PROJ>
	+ const PROJ& declare(const PROJ& proj, const std::string& name) { return declareProjection(proj, name); }
	+ /// @brief Register a contained projection (user-facing, arg-reordered version)
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	+ template <typename PROJ>
	+ const PROJ& declare(const std::string& name, const PROJ& proj) { return declareProjection(proj, name); }
	+
	+ /// @brief Register a contained projection (user-facing version)
	+ /// @deprecated Use declareProjection() or declare()
	+ /// @todo Add SFINAE to require that PROJ inherit from Projection
	+ template <typename PROJ>
	+ const PROJ& addProjection(const PROJ& proj, const std::string& name) { return declareProjection(proj, name); }
	+

	/// Untemplated function to do the work...
	- const Projection& _addProjection(const Projection& proj, const std::string& name);
	+ const Projection& _declareProjection(const Projection& proj, const std::string& name);

	//@}


	- private:
	-
	/// Non-templated version of string-based applyProjection, to work around
	/// header dependency issue.
	const Projection& _applyProjection(const Event& evt, const std::string& name) const;

	/// Non-templated version of proj-based applyProjection, to work around
	/// header dependency issue.
	const Projection& _applyProjection(const Event& evt, const Projection& proj) const;


	- protected:
	-
	/// Flag to forbid projection registration in analyses until the init phase
	bool _allowProjReg;

	- public:
	- void markAsOwned() const { _owned = true; }

	private:

	- /// mark object as owned by the projhandler
	+ /// Mark object as owned by the _projhandler
	mutable bool _owned;

	/// Pointer to projection handler.
	ProjectionHandler& _projhandler;

	};

	+
	}

	#endif
	diff --git a/include/Rivet/Projections/AxesDefinition.hh b/include/Rivet/Projections/AxesDefinition.hh
	--- a/include/Rivet/Projections/AxesDefinition.hh
	+++ b/include/Rivet/Projections/AxesDefinition.hh
	@@ -1,42 +1,42 @@
	// -- C++ --
	#ifndef RIVET_AxesDefinition_HH
	#define RIVET_AxesDefinition_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {

	- /**
	- @brief Base class for projections which define a spatial basis.

	- A pure virtual interface for projections which define a set of 3
	- basis vectors. This allows e.g. Thrust and Sphericity to be used
	- interchangeably as defining bases for e.g. hemisphere mass and broadening
	- calculations.
	-
	- @author Andy Buckley
	- */
	+ /// @brief Base class for projections which define a spatial basis.
	+ ///
	+ /// A pure virtual interface for projections which define a set of 3
	+ /// basis vectors. This allows e.g. Thrust and Sphericity to be used
	+ /// interchangeably as defining bases for e.g. hemisphere mass and broadening
	+ /// calculations.
	+ ///
	+ /// @author Andy Buckley
	class AxesDefinition : public Projection {
	public:

	/// Virtual destructor.
	virtual ~AxesDefinition() { }

	/// Clone on the heap.
	virtual unique_ptr<Projection> clone() const = 0;

	///@{ Axis accessors, in decreasing order of significance.
	/// The main axis.
	virtual const Vector3& axis1() const = 0;
	/// The 2nd most significant ("major") axis.
	virtual const Vector3& axis2() const = 0;
	/// The least significant ("minor") axis.
	virtual const Vector3& axis3() const = 0;
	///@}

	};

	+
	}

	#endif
	diff --git a/include/Rivet/Projections/Beam.hh b/include/Rivet/Projections/Beam.hh
	--- a/include/Rivet/Projections/Beam.hh
	+++ b/include/Rivet/Projections/Beam.hh
	@@ -1,147 +1,206 @@
	// -- C++ --
	#ifndef RIVET_Beam_HH
	#define RIVET_Beam_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Math/LorentzTrans.hh"

	namespace Rivet {


	/// @name Standalone beam kinematics functions
	//@{

	/// Get beam particles from an event
	ParticlePair beams(const Event& e);

	-
	/// Get beam particle IDs from a pair of Particles
	- inline PdgIdPair beamIds(const ParticlePair& beams) {
	- return make_pair(beams.first.pid(), beams.second.pid());
	- }
	+ /// @deprecated Use pids(beams)
	+ inline PdgIdPair beamIds(const ParticlePair& beams) { return pids(beams); }

	/// Get beam particle IDs from an event
	- inline PdgIdPair beamIds(const Event& e) {
	- return beamIds(beams(e));
	- }
	+ /// @deprecated Use pids(e.beams())
	+ inline PdgIdPair beamIds(const Event& e) { return pids(beams(e)); }


	/// Get beam centre-of-mass energy from a pair of beam momenta
	double sqrtS(const FourMomentum& pa, const FourMomentum& pb);

	/// Get beam centre-of-mass energy from a pair of Particles
	inline double sqrtS(const ParticlePair& beams) {
	return sqrtS(beams.first.momentum(), beams.second.momentum());
	}

	/// Get beam centre-of-mass energy from an Event
	- inline double sqrtS(const Event& e) {
	- return sqrtS(beams(e));
	- }
	+ inline double sqrtS(const Event& e) { return sqrtS(beams(e)); }


	/// Get per-nucleon beam centre-of-mass energy from a pair of beam momenta
	/// @note Uses a nominal nucleon mass of 0.939 GeV to convert masses to A
	double asqrtS(const FourMomentum& pa, const FourMomentum& pb);

	/// Get per-nucleon beam centre-of-mass energy from a pair of Particles
	/// @note Uses the sum of nuclear mass numbers A for each beam
	double asqrtS(const ParticlePair& beams);

	/// Get per-nucleon beam centre-of-mass energy from an Event
	- inline double asqrtS(const Event& e) {
	- return asqrtS(beams(e));
	+ /// @note Uses the sum of nuclear mass numbers A for each beam
	+ inline double asqrtS(const Event& e) { return asqrtS(beams(e)); }
	+
	+
	+ /// Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of beam momenta
	+ inline FourMomentum cmsBoostVec(const FourMomentum& pa, const FourMomentum& pb) {
	+ return pa + pb;
	}

	+ /// Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of Particles
	+ inline FourMomentum cmsBoostVec(const ParticlePair& beams) {
	+ return cmsBoostVec(beams.first, beams.second);
	+ }

	/// Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of beam momenta
	- Vector3 cmsBoost(const FourMomentum& pa, const FourMomentum& pb);
	+ FourMomentum acmsBoostVec(const FourMomentum& pa, const FourMomentum& pb);

	/// Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of Particles
	- inline Vector3 cmsBoost(const ParticlePair& beams) {
	- return cmsBoost(beams.first, beams.second);
	+ FourMomentum acmsBoostVec(const ParticlePair& beams);
	+
	+
	+ /// Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of beam momenta
	+ Vector3 cmsBetaVec(const FourMomentum& pa, const FourMomentum& pb);
	+
	+ /// Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of Particles
	+ inline Vector3 cmsBetaVec(const ParticlePair& beams) {
	+ return cmsBetaVec(beams.first, beams.second);
	}

	- /// Get the Lorentz boost to the beam centre-of-mass system (CMS) from an Event
	- inline Vector3 beamCMSBoost(const Event& e) {
	- return cmsBoost(beams(e));
	+
	+ /// Get the Lorentz boost to the per-nucleon beam centre-of-mass system (ACMS) from a pair of beam momenta
	+ /// @note Uses a nominal nucleon mass of 0.939 GeV to convert masses to A
	+ Vector3 acmsBetaVec(const FourMomentum& pa, const FourMomentum& pb);
	+
	+ /// Get the Lorentz boost to the per-nucleon beam centre-of-mass system (ACMS) from a pair of Particles
	+ /// @note Uses the sum of nuclear mass numbers A for each beam
	+ Vector3 acmsBetaVec(const ParticlePair& beams);
	+
	+
	+ /// Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of beam momenta
	+ Vector3 cmsGammaVec(const FourMomentum& pa, const FourMomentum& pb);
	+
	+ /// Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of Particles
	+ inline Vector3 cmsGammaVec(const ParticlePair& beams) {
	+ return cmsGammaVec(beams.first, beams.second);
	}


	+ /// Get the Lorentz boost to the per-nucleon beam centre-of-mass system (ACMS) from a pair of beam momenta
	+ /// @note Uses a nominal nucleon mass of 0.939 GeV to convert masses to A
	+ Vector3 acmsGammaVec(const FourMomentum& pa, const FourMomentum& pb);
	+
	+ /// Get the Lorentz boost to the per-nucleon beam centre-of-mass system (ACMS) from a pair of Particles
	+ /// @note Uses the sum of nuclear mass numbers A for each beam
	+ Vector3 acmsGammaVec(const ParticlePair& beams);
	+
	+
	/// Get the Lorentz transformation to the beam centre-of-mass system (CMS) from a pair of beam momenta
	LorentzTransform cmsTransform(const FourMomentum& pa, const FourMomentum& pb);

	/// Get the Lorentz transformation to the beam centre-of-mass system (CMS) from a pair of Particles
	inline LorentzTransform cmsTransform(const ParticlePair& beams) {
	return cmsTransform(beams.first, beams.second);
	}

	- /// Get the Lorentz transformation to the beam centre-of-mass system (CMS) from an Event
	- inline LorentzTransform beamCMSTransform(const Event& e) {
	- return cmsTransform(beams(e));
	- }
	+
	+ /// Get the Lorentz transformation to the per-nucleon beam centre-of-mass system (CMS) from a pair of beam momenta
	+ /// @note Uses a nominal nucleon mass of 0.939 GeV to convert masses to A
	+ LorentzTransform acmsTransform(const FourMomentum& pa, const FourMomentum& pb);
	+
	+ /// Get the Lorentz transformation to the per-nucleon beam centre-of-mass system (CMS) from a pair of Particles
	+ /// @note Uses the sum of nuclear mass numbers A for each beam
	+ LorentzTransform acmsTransform(const ParticlePair& beams);

	//@}




	/// @brief Project out the incoming beams
	class Beam : public Projection {
	public:

	- /// The default constructor
	- Beam() {
	- setName("Beam");
	- }
	+ /// Default (and only) constructor
	+ Beam() { setName("Beam"); }

	/// Clone on the heap
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new Beam(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(Beam);


	- public:
	+ /// @name Beam particles and kinematics
	+ //@{

	/// The pair of beam particles in the current collision
	const ParticlePair& beams() const { return _theBeams; }

	/// The pair of beam particle PDG codes in the current collision
	- const PdgIdPair beamIds() const { return Rivet::beamIds(beams()); }
	+ /// @deprecated Use pids(beams())
	+ PdgIdPair beamIds() const { return pids(beams()); }

	/// Get centre of mass energy, \f$ \sqrt{s} \f$
	double sqrtS() const { return Rivet::sqrtS(beams()); }

	+ /// Get the Lorentz boost to the beam centre-of-mass
	+ FourMomentum cmsBoostVec() const { return Rivet::cmsBoostVec(beams()); }
	+
	+ /// Get the Lorentz transform to the beam centre-of-mass
	+ LorentzTransform cmsTransform() const { return Rivet::cmsTransform(beams()); }
	+
	+ /// Get the beta factor vector for the Lorentz boost to the beam centre-of-mass
	+ Vector3 cmsBetaVec() const { return Rivet::cmsBetaVec(beams()); }
	+
	+ /// Get the gamma factor vector for the Lorentz boost to the beam centre-of-mass
	+ Vector3 cmsGammaVec() const { return Rivet::cmsGammaVec(beams()); }
	+
	+ //@}
	+
	+
	+ /// @name Per-nucleon beam kinematics
	+ //@{
	+
	/// Get per-nucleon centre of mass energy, \f$ \sqrt{s}/(A_1 + A_2) \f$
	double asqrtS() const { return Rivet::asqrtS(beams()); }

	- /// Get the Lorentz boost to the beam centre-of-mass
	- Vector3 cmsBoost() const { return Rivet::cmsBoost(beams()); }
	+ /// Get the Lorentz boost to the per-nucleon beam centre-of-mass
	+ Vector3 acmsBetaVec() const { return Rivet::acmsBetaVec(beams()); }

	- /// Get the Lorentz transform to the beam centre-of-mass
	- LorentzTransform cmsTransform() const { return Rivet::cmsTransform(beams()); }
	+ /// Get the Lorentz boost to the per-nucleon beam centre-of-mass
	+ Vector3 acmsGammaVec() const { return Rivet::acmsGammaVec(beams()); }
	+
	+ /// Get the Lorentz transform to the per-nucleon beam centre-of-mass
	+ LorentzTransform acmsTransform() const { return Rivet::acmsTransform(beams()); }
	+
	+ //@}
	+

	/// Get the beam interaction primary vertex (PV) position
	FourVector pv() const;


	/// Project on to the Event
	virtual void project(const Event& e);


	private:

	/// Compare with other projections -- it's always the same, since there are no params
	virtual int compare(const Projection& UNUSED(p)) const { return EQUIVALENT; }

	/// The beam particles in the current collision
	ParticlePair _theBeams;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/BeamThrust.hh b/include/Rivet/Projections/BeamThrust.hh
	--- a/include/Rivet/Projections/BeamThrust.hh
	+++ b/include/Rivet/Projections/BeamThrust.hh
	@@ -1,78 +1,78 @@
	// -- C++ --
	#ifndef RIVET_BeamThrust_HH
	#define RIVET_BeamThrust_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {

	+
	class BeamThrust : public Projection {
	public:

	/// Constructor.
	BeamThrust() {}

	BeamThrust(const FinalState& fsp) {
	setName("BeamThrust");
	addProjection(fsp, "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new BeamThrust(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(BeamThrust);
	+

	protected:

	/// Perform the projection on the Event
	void project(const Event& e) {
	const vector<Particle> ps
	= applyProjection<FinalState>(e, "FS").particles();
	calc(ps);
	}

	/// Compare projections
	int compare(const Projection& p) const {
	return mkNamedPCmp(p, "FS");
	}


	public:

	double beamthrust() const { return _beamthrust; }

	public:

	/// @name Direct methods
	/// Ways to do the calculation directly, without engaging the caching system
	//@{

	/// Manually calculate the beamthrust, without engaging the caching system
	void calc(const FinalState& fs);

	/// Manually calculate the beamthrust, without engaging the caching system
	void calc(const vector<Particle>& fsparticles);

	/// Manually calculate the beamthrust, without engaging the caching system
	void calc(const vector<FourMomentum>& fsmomenta);

	//@}


	private:

	/// The beamthrust scalar.
	double _beamthrust;

	private:

	/// Explicitly calculate the beamthrust values.
	void _calcBeamThrust(const vector<FourMomentum>& fsmomenta);

	};

	}

	#endif
	diff --git a/include/Rivet/Projections/CentralEtHCM.hh b/include/Rivet/Projections/CentralEtHCM.hh
	--- a/include/Rivet/Projections/CentralEtHCM.hh
	+++ b/include/Rivet/Projections/CentralEtHCM.hh
	@@ -1,60 +1,58 @@
	// -- C++ --
	#ifndef RIVET_CentralEtHCM_HH
	#define RIVET_CentralEtHCM_HH

	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Projections/DISFinalState.hh"

	namespace Rivet {


	/// @brief Summed \f$ E_\perp \f$ of central particles in HCM system.
	///
	/// Sum up \f$ E_\perp \f$ of all particles in the hadronic final state in the
	/// central rapidity bin of the HCM system.
	class CentralEtHCM : public Projection {
	public:

	/// The default constructor. Must specify a FinalStateHCM projection
	/// object which is guaranteed to live throughout the run.
	CentralEtHCM(const DISFinalState& fs)
	{
	setName("CentralEtHCM");
	addProjection(fs, "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new CentralEtHCM(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(CentralEtHCM);


	protected:

	/// Apply the projection on to the Event.
	void project(const Event& e);

	/// Compare with other projections
	int compare(const Projection& p) const {
	return mkNamedPCmp(p, "FS");
	}


	public:

	/// The sum of the Et in the central rapidity bin.
	double sumEt() const { return _sumet; }


	private:

	/// The sum of the Et in the central rapidity bin.
	double _sumet;

	};

	}


	#endif
	diff --git a/include/Rivet/Projections/CentralityEstimator.hh b/include/Rivet/Projections/CentralityEstimator.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Projections/CentralityEstimator.hh
	@@ -0,0 +1,80 @@
	+// -- C++ --
	+#ifndef RIVET_CentralityEstimator_HH
	+#define RIVET_CentralityEstimator_HH
	+
	+#include "Rivet/Projection.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Event.hh"
	+#include "HepMC/GenEvent.h"
	+
	+namespace Rivet {
	+
	+
	+ /**
	+ @brief Base class for projections giving the value of an
	+ observable sensitive to the centrality of a collision.
	+
	+ @author Leif LÃ¶nnblad
	+
	+ The centrality of a collision is not really an observable, but the
	+ concept is anyway often used in the heavy ion community as if it
	+ were just that.
	+
	+ This base class can be used to provide a an estimator for the
	+ centrality by projecting down to a single number which then canbe
	+ used by a CentralityGroup object to select a histogram to be
	+ filled with another observable depending on centrality percentile.
	+
	+ The eztimate() should be a non-negative number with large values
	+ indicating a higher overlap than small ones. A negative value
	+ indicates that the centrality estimate could not be calculated.
	+
	+ In the best of all worlds the centrality estimator should be a
	+ proper hadron-level observable corrected for detector effects,
	+ however, this base class only returns the inverse of the
	+ impact_parameter member of the GenHeavyIon object in an GenEvent
	+ if present and zero otherwise.
	+ */
	+ class CentralityEstimator : public Projection {
	+ public:
	+
	+ /// Constructor.
	+ CentralityEstimator()
	+ : _estimate(-1.0) {}
	+
	+ /// Clone on the heap.
	+ DEFAULT_RIVET_PROJ_CLONE(CentralityEstimator);
	+
	+ protected:
	+
	+ /// Perform the projection on the Event
	+ void project(const Event& e) {
	+ _estimate = -1.0;
	+ const HepMC::HeavyIon * hi = e.genEvent()->heavy_ion();
	+ if ( hi ) _estimate = hi->impact_parameter() > 0.0?
	+ 1.0/hi->impact_parameter(): numeric_limits<double>::max();
	+ }
	+
	+ /// Compare projections
	+ int compare(const Projection& p) const {
	+ return mkNamedPCmp(p, "CentEst");
	+ }
	+
	+
	+ public:
	+
	+ /// The value of the centrality estimate.
	+ double estimate() const { return _estimate; }
	+
	+
	+ protected:
	+
	+ /// The value of the centrality estimate.
	+ double _estimate;
	+
	+ };
	+
	+}
	+
	+#endif
	+
	diff --git a/include/Rivet/Projections/ChargedFinalState.hh b/include/Rivet/Projections/ChargedFinalState.hh
	--- a/include/Rivet/Projections/ChargedFinalState.hh
	+++ b/include/Rivet/Projections/ChargedFinalState.hh
	@@ -1,47 +1,45 @@
	// -- C++ --
	#ifndef RIVET_ChargedFinalState_HH
	#define RIVET_ChargedFinalState_HH

	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Project only charged final state particles.
	class ChargedFinalState : public FinalState {
	public:

	/// @name Constructors
	//@{

	/// Construction from another FinalState
	ChargedFinalState(const FinalState& fsp);

	/// Construction using Cuts object
	ChargedFinalState(const Cut& c=Cuts::open());

	/// Single eta-range constructor.
	ChargedFinalState(double mineta, double maxeta, double minpt=0*GeV);

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new ChargedFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(ChargedFinalState);

	//@}


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;
	};


	}


	#endif
	diff --git a/include/Rivet/Projections/ChargedLeptons.hh b/include/Rivet/Projections/ChargedLeptons.hh
	--- a/include/Rivet/Projections/ChargedLeptons.hh
	+++ b/include/Rivet/Projections/ChargedLeptons.hh
	@@ -1,51 +1,50 @@
	// -- C++ --
	#ifndef RIVET_ChargedLeptons_HH
	#define RIVET_ChargedLeptons_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	/// @brief Get charged final-state leptons
	///
	- /// NB. This is just electrons and muons, unless you set taus stable!
	+ /// @todo This is just electrons and muons, unless you set taus stable!
	class ChargedLeptons : public FinalState {
	public:

	/// Constructor
	ChargedLeptons(const FinalState& fsp)
	{
	setName("ChargedLeptons");
	addProjection(ChargedFinalState(fsp), "ChFS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new ChargedLeptons(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(ChargedLeptons);
	+

	protected:

	/// Apply the projection to the event.
	void project(const Event& evt);

	/// Compare projections.
	int compare(const Projection& other) const;

	public:

	/// Access the projected leptons.
	const Particles& chargedLeptons() const {
	return _theParticles;
	}

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/ConstLossyFinalState.hh b/include/Rivet/Projections/ConstLossyFinalState.hh
	--- a/include/Rivet/Projections/ConstLossyFinalState.hh
	+++ b/include/Rivet/Projections/ConstLossyFinalState.hh
	@@ -1,80 +1,78 @@
	// -- C++ --
	#ifndef RIVET_ConstLossyFinalState_HH
	#define RIVET_ConstLossyFinalState_HH

	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/LossyFinalState.hh"

	namespace Rivet {


	/// Functor used to implement constant random lossiness.
	class ConstRandomFilter {
	public:

	ConstRandomFilter(double lossFraction)
	: _lossFraction(lossFraction)
	{
	assert(_lossFraction >= 0);
	}

	// If operator() returns true, particle is deleted ("lost")
	bool operator()(const Particle&) {
	/// @todo Use a better RNG
	return (rand()/static_cast<double>(RAND_MAX) < _lossFraction);
	}

	int compare(const ConstRandomFilter& other) const {
	return cmp(_lossFraction, other._lossFraction);
	}

	private:

	double _lossFraction;

	};



	/// @brief Randomly lose a constant fraction of particles.
	class ConstLossyFinalState : public LossyFinalState<ConstRandomFilter> {
	public:

	/// @name Constructors
	//@{

	/// Constructor from a FinalState.
	ConstLossyFinalState(const FinalState& fsp, double lossfraction)
	: LossyFinalState<ConstRandomFilter>(fsp, ConstRandomFilter(lossfraction))
	{
	setName("ConstLossyFinalState");
	}

	/// Stand-alone constructor. Initialises the base FinalState projection.
	ConstLossyFinalState(double lossfraction,
	double mineta = -MAXDOUBLE,
	double maxeta = MAXDOUBLE,
	double minpt = 0.0)
	: LossyFinalState<ConstRandomFilter>(ConstRandomFilter(lossfraction), mineta, maxeta, minpt)
	{
	setName("ConstLossyFinalState");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new ConstLossyFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(ConstLossyFinalState);

	//@}

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/DISFinalState.hh b/include/Rivet/Projections/DISFinalState.hh
	--- a/include/Rivet/Projections/DISFinalState.hh
	+++ b/include/Rivet/Projections/DISFinalState.hh
	@@ -1,61 +1,59 @@
	// -- C++ --
	#ifndef RIVET_DISFinalState_HH
	#define RIVET_DISFinalState_HH

	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/DISKinematics.hh"

	namespace Rivet {


	/// @brief Final state particles boosted to the hadronic center of mass system.
	///
	/// NB. The DIS scattered lepton is not included in the final state particles.
	class DISFinalState: public FinalState {
	public:

	/// Type of DIS boost to apply
	enum BoostType { HCM, BREIT };


	/// @name Constructors
	//@{

	/// Constructor
	DISFinalState(const DISKinematics& kinematicsp, BoostType boosttype)
	: _boosttype(boosttype)
	{
	setName("DISFinalState");
	addProjection(kinematicsp, "Kinematics");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new DISFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(DISFinalState);

	//@}


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const {
	const DISFinalState& other = dynamic_cast<const DISFinalState&>(p);
	return mkNamedPCmp(p, "Kinematics") \|\| cmp(_boosttype, other._boosttype);
	}


	private:

	BoostType _boosttype;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/DISKinematics.hh b/include/Rivet/Projections/DISKinematics.hh
	--- a/include/Rivet/Projections/DISKinematics.hh
	+++ b/include/Rivet/Projections/DISKinematics.hh
	@@ -1,107 +1,105 @@
	// -- C++ --
	#ifndef RIVET_DISKinematics_HH
	#define RIVET_DISKinematics_HH

	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/DISLepton.hh"
	#include "Rivet/Projections/Beam.hh"

	namespace Rivet {


	/// @brief Get the DIS kinematic variables and relevant boosts for an event.
	class DISKinematics : public Projection {

	public:

	/// The default constructor.
	DISKinematics()
	: _theQ2(-1.0), _theW2(-1.0), _theX(-1.0), _theY(-1.0), _theS(-1.0)
	{
	setName("DISKinematics");
	//addPdgIdPair(ANY, hadid);
	addProjection(Beam(), "Beam");
	addProjection(DISLepton(), "Lepton");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new DISKinematics(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(DISKinematics);


	protected:

	/// Perform the projection operation on the supplied event.
	virtual void project(const Event& e);

	/// Compare with other projections.
	virtual int compare(const Projection& p) const;


	public:

	/// The \f$Q^2\f$.
	double Q2() const { return _theQ2; }

	/// The \f$W^2\f$.
	double W2() const { return _theW2; }

	/// The Bjorken \f$x\f$.
	double x() const { return _theX; }

	/// The Inelasticity \f$y\f$
	double y() const { return _theY; }

	/// The centre of mass energy \f$s\f$
	double s() const { return _theS; }



	/// The LorentzRotation needed to boost a particle to the hadronic CM frame.
	const LorentzTransform& boostHCM() const {
	return _hcm;
	}

	/// The LorentzRotation needed to boost a particle to the hadronic Breit frame.
	const LorentzTransform& boostBreit() const {
	return _breit;
	}

	/// The incoming Hadron beam particle
	const Particle& beamHadron() const {
	return _inHadron;
	}

	private:

	/// The \f$Q^2\f$.
	double _theQ2;

	/// The \f$W^2\f$.
	double _theW2;

	/// The Bjorken \f$x\f$.
	double _theX;

	/// The Inelasticity \f$y\f$
	double _theY;

	/// The centre of mass energy \f$s\f$
	double _theS;

	Particle _inHadron;

	/// The LorentzRotation needed to boost a particle to the hadronic CM frame.
	LorentzTransform _hcm;

	/// The LorentzRotation needed to boost a particle to the hadronic Breit frame.
	LorentzTransform _breit;
	};


	}

	#endif
	diff --git a/include/Rivet/Projections/DISLepton.hh b/include/Rivet/Projections/DISLepton.hh
	--- a/include/Rivet/Projections/DISLepton.hh
	+++ b/include/Rivet/Projections/DISLepton.hh
	@@ -1,68 +1,67 @@
	// -- C++ --
	#ifndef RIVET_DISLepton_HH
	#define RIVET_DISLepton_HH

	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	/// @brief Get the incoming and outgoing leptons in a DIS event.
	class DISLepton : public Projection {

	public:

	/// @name Constructors.
	//@{

	DISLepton(){
	setName("DISLepton");
	addProjection(Beam(), "Beam");
	addProjection(FinalState(), "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new DISLepton(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(DISLepton);
	+
	//@}


	protected:

	/// Perform the projection operation on the supplied event.
	virtual void project(const Event& e);

	/// Compare with other projections.
	virtual int compare(const Projection& p) const;

	public:

	/// The incoming lepton.
	const Particle& in() const { return _incoming; }

	/// The outgoing lepton.
	const Particle& out() const { return _outgoing; }

	const double &pzSign() const { return _sign; }

	private:

	/// The incoming lepton.
	Particle _incoming;

	/// The outgoing lepton.
	Particle _outgoing;

	/// The sign of the PZ of the incoming lepton
	double _sign;

	};

	}


	#endif
	diff --git a/include/Rivet/Projections/DressedLeptons.hh b/include/Rivet/Projections/DressedLeptons.hh
	--- a/include/Rivet/Projections/DressedLeptons.hh
	+++ b/include/Rivet/Projections/DressedLeptons.hh
	@@ -1,119 +1,92 @@
	// -- C++ --
	#ifndef RIVET_DressedLeptons_HH
	#define RIVET_DressedLeptons_HH

	-#include "Rivet/Tools/Logging.hh"
	-#include "Rivet/Config/RivetCommon.hh"
	-#include "Rivet/Particle.hh"
	-#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	-#include "Rivet/Cuts.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Config/RivetCommon.hh"

	namespace Rivet {


	/// A charged lepton meta-particle created by clustering photons close to the bare lepton
	class DressedLepton : public Particle {
	public:

	DressedLepton(const Particle& lepton) :
	Particle(lepton.pid(), lepton.momentum()),
	_constituentLepton(lepton) {}

	void addPhoton(const Particle& p, bool cluster) {
	_constituentPhotons.push_back(p);
	if (cluster) setMomentum(momentum() + p.momentum());
	}

	const Particle& constituentLepton() const { return _constituentLepton; }
	const Particles& constituentPhotons() const { return _constituentPhotons; }

	private:

	Particles _constituentPhotons;
	Particle _constituentLepton;
	};


	/// @brief Cluster photons from a given FS to all charged particles (typically leptons)
	///
	/// This stores the original (bare) charged particles and photons as particles()
	/// while the newly created clustered lepton objects are accessible as
	/// dressedLeptons(). The clustering is done by a delta(R) cone around each bare
	/// lepton, with double counting being avoided by only adding a photon to the _closest_
	/// bare lepton if it happens to be within the capture radius of more than one.
	class DressedLeptons : public FinalState {
	public:

	/// @brief Constructor with a general (and optional) Cut argument
	///
	/// Provide final state projections used to select the photons and bare
	/// leptons (wish we had put the first two args the other way around...),
	/// a clustering delta(R) cone size around each bare lepton, and an optional
	/// cut on the _dressed_ leptons (i.e. the momenta after clustering.)
	/// The final two arguments are rarely used.
	DressedLeptons(const FinalState& photons, const FinalState& bareleptons,
	double dRmax, const Cut& cut=Cuts::open(),
	bool cluster=true, bool useDecayPhotons=false);

	- /// Constructor with a general (and optional) Cut argument
	- /// @deprecated Use the version with Cut c before cluster (i.e. with the most common non-default args first)
	- DEPRECATED("Use the version with Cut c before cluster")
	- DressedLeptons(const FinalState& photons, const FinalState& bareleptons,
	- double dRmax, bool cluster=true, const Cut& cut=Cuts::open(),
	- bool useDecayPhotons=false);
	-
	- /// Constructor with numerical eta and pT cuts
	- /// @deprecated Use the Cut version
	- DEPRECATED("Use the Cut version")
	- DressedLeptons(const FinalState& photons, const FinalState& bareleptons,
	- double dRmax, bool cluster,
	- double etaMin, double etaMax,
	- double pTmin, bool useDecayPhotons=false);
	-
	-
	/// Clone this projection
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new DressedLeptons(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(DressedLeptons);

	/// Retrieve the dressed leptons
	const vector<DressedLepton>& dressedLeptons() const { return _clusteredLeptons; }

	- /// Retrieve the dressed leptons (synonym)
	- /// @deprecated Use dressedLeptons()
	- DEPRECATED("Use dressedLeptons()")
	- const vector<DressedLepton>& clusteredLeptons() const { return _clusteredLeptons; }
	-

	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;


	private:

	/// Maximum cone radius to find photons in
	double _dRmax;
	/// Whether to actually add the photon momenta to clusteredLeptons
	bool _cluster;
	/// Whether to include photons from hadron (particularly pi0) decays
	bool _fromDecay;

	/// Container which stores the clustered lepton objects
	vector<DressedLepton> _clusteredLeptons;

	};



	}


	#endif
	diff --git a/include/Rivet/Projections/FParameter.hh b/include/Rivet/Projections/FParameter.hh
	--- a/include/Rivet/Projections/FParameter.hh
	+++ b/include/Rivet/Projections/FParameter.hh
	@@ -1,89 +1,86 @@
	// -- C++ --
	#ifndef RIVET_FParameter_HH
	#define RIVET_FParameter_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Event.hh"

	-
	namespace Rivet {

	+
	class FParameter : public Projection {
	-
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	FParameter(const FinalState& fsp);

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new FParameter(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(FParameter);

	//@}


	protected:

	/// Perform the projection on the Event
	void project(const Event& e);

	/// Compare with other projections
	//int compare(const Projection& p) const;
	// Taken from Thrust.hh
	int compare(const Projection& p) const {
	return mkNamedPCmp(p, "FS");
	}
	public:

	/// Reset the projection
	void clear();

	/// @name Access the event shapes by name
	/// @{
	/// F-Parametr
	double F() const { return lambda1() >= lambda2() ? lambda2()/lambda1() : lambda1()/lambda2(); }
	/// @}

	/// @name Access the linearised transverse momentum tensor eigenvalues
	/// @{
	double lambda1() const { return _lambdas[0]; }
	double lambda2() const { return _lambdas[1]; }
	/// @}


	/// @name Direct methods
	/// Ways to do the calculation directly, without engaging the caching system
	//@{
	-
	+
	/// Manually calculate the sphericity, without engaging the caching system
	void calc(const FinalState& fs);

	/// Manually calculate the sphericity, without engaging the caching system
	void calc(const vector<Particle>& fsparticles);

	/// Manually calculate the sphericity, without engaging the caching system
	void calc(const vector<FourMomentum>& fsmomenta);

	/// Manually calculate the sphericity, without engaging the caching system
	void calc(const vector<Vector3>& fsmomenta);

	//@}
	private:
	/// Eigenvalues.
	vector<double> _lambdas;

	private:

	/// Actually do the calculation
	void _calcFParameter(const vector<Vector3>& fsmomenta);

	};
	}


	#endif
	diff --git a/include/Rivet/Projections/FastJets.hh b/include/Rivet/Projections/FastJets.hh
	--- a/include/Rivet/Projections/FastJets.hh
	+++ b/include/Rivet/Projections/FastJets.hh
	@@ -1,300 +1,296 @@
	// -- C++ --
	#ifndef RIVET_FastJets_HH
	#define RIVET_FastJets_HH

	#include "Rivet/Jet.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/JetAlg.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Tools/RivetFastJet.hh"

	#include "fastjet/SISConePlugin.hh"
	#include "fastjet/ATLASConePlugin.hh"
	#include "fastjet/CMSIterativeConePlugin.hh"
	#include "fastjet/CDFJetCluPlugin.hh"
	#include "fastjet/CDFMidPointPlugin.hh"
	#include "fastjet/D0RunIIConePlugin.hh"
	#include "fastjet/TrackJetPlugin.hh"
	#include "fastjet/JadePlugin.hh"
	//#include "fastjet/PxConePlugin.hh"

	namespace Rivet {


	/// Project out jets found using the FastJet package jet algorithms.
	class FastJets : public JetAlg {
	public:

	/// Wrapper enum for selected FastJet jet algorithms.
	/// @todo Move to JetAlg and alias here?
	enum JetAlgName { KT, CAM, SISCONE, ANTIKT,
	// PXCONE,
	ATLASCONE, CMSCONE,
	CDFJETCLU, CDFMIDPOINT, D0ILCONE,
	JADE, DURHAM, TRACKJET };


	/// @name Constructors etc.
	//@{

	/// Constructor from a FastJet JetDefinition
	///
	/// @warning The AreaDefinition pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.
	FastJets(const FinalState& fsp,
	const fastjet::JetDefinition& jdef,
	JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS,
	JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES,
	fastjet::AreaDefinition* adef=nullptr)
	: JetAlg(fsp, usemuons, useinvis), _jdef(jdef), _adef(adef)
	{
	_initBase();
	}

	/// JetDefinition-based constructor with reordered args for easier specification of jet area definition
	///
	/// @warning The AreaDefinition pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.
	FastJets(const FinalState& fsp,
	const fastjet::JetDefinition& jdef,
	fastjet::AreaDefinition* adef,
	JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS,
	JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES)
	: FastJets(fsp, jdef, usemuons, useinvis, adef)
	{ }

	/// Native argument constructor, using FastJet alg/scheme enums.
	///
	/// @warning The AreaDefinition pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.
	FastJets(const FinalState& fsp,
	fastjet::JetAlgorithm type,
	fastjet::RecombinationScheme recom, double rparameter,
	JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS,
	JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES,
	fastjet::AreaDefinition* adef=nullptr)
	: FastJets(fsp, fastjet::JetDefinition(type, rparameter, recom), usemuons, useinvis, adef)
	{ }

	/// Native argument constructor with reordered args for easier specification of jet area definition
	///
	/// @warning The AreaDefinition pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.
	FastJets(const FinalState& fsp,
	fastjet::JetAlgorithm type,
	fastjet::RecombinationScheme recom, double rparameter,
	fastjet::AreaDefinition* adef,
	JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS,
	JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES)
	: FastJets(fsp, type, recom, rparameter, usemuons, useinvis, adef)
	{ }

	/// @brief Explicitly pass in an externally-constructed plugin
	///
	/// @warning Provided plugin and area definition pointers must be heap-allocated; Rivet will store/delete via a shared_ptr
	FastJets(const FinalState& fsp,
	fastjet::JetDefinition::Plugin* plugin,
	JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS,
	JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES,
	fastjet::AreaDefinition* adef=nullptr)
	: FastJets(fsp, fastjet::JetDefinition(plugin), usemuons, useinvis, adef)
	{
	_plugin.reset(plugin);
	}

	/// @brief Explicitly pass in an externally-constructed plugin, with reordered args for easier specification of jet area definition
	///
	/// @warning Provided plugin and area definition pointers must be heap-allocated; Rivet will store/delete via a shared_ptr
	FastJets(const FinalState& fsp,
	fastjet::JetDefinition::Plugin* plugin,
	fastjet::AreaDefinition* adef,
	JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS,
	JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES)
	: FastJets(fsp, plugin, usemuons, useinvis, adef)
	{ }

	/// @brief Convenience constructor using Rivet enums for most common jet algs (including some plugins).
	///
	/// For the built-in algs, E-scheme recombination is used. For full control
	/// of FastJet built-in jet algs, use the constructors from native-args or a
	/// plugin pointer.
	///
	/// @warning Provided area definition pointer must be heap-allocated; Rivet will store/delete via a shared_ptr
	FastJets(const FinalState& fsp,
	JetAlgName alg, double rparameter,
	JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS,
	JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES,
	fastjet::AreaDefinition* adef=nullptr,
	double seed_threshold=1.0)
	: JetAlg(fsp, usemuons, useinvis)
	{
	_initBase();
	_initJdef(alg, rparameter, seed_threshold);
	}


	// /// Same thing as above, but without an FS (for when we want to pass the particles directly to the calc method)
	// /// @todo Does this work properly, without internal HeavyQuarks etc.?
	// FastJets(JetAlgName alg, double rparameter, double seed_threshold=1.0) { _initJdef(alg, rparameter, seed_threshold); }
	// /// Same thing as above, but without an FS (for when we want to pass the particles directly to the calc method)
	// /// @todo Does this work properly, without internal HeavyQuarks etc.?
	// FastJets(fastjet::JetAlgorithm type, fastjet::RecombinationScheme recom, double rparameter) { _initJdef(type, recom, rparameter); }
	// /// Same thing as above, but without an FS (for when we want to pass the particles directly to the calc method)
	// /// @todo Does this work properly, without internal HeavyQuarks etc.?
	// FastJets(fastjet::JetDefinition::Plugin* plugin) : _jdef(plugin), _plugin(plugin) {
	// // _plugin.reset(plugin);
	// // _jdef = fastjet::JetDefinition(plugin);
	// }


	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new FastJets(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(FastJets);

	//@}


	- public:
	-
	/// Reset the projection. Jet def, etc. are unchanged.
	void reset();


	/// @brief Use provided jet area definition
	///
	/// @warning The provided pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.
	/// @note Provide an adef null pointer to re-disable jet area calculation
	void useJetArea(fastjet::AreaDefinition* adef) {
	_adef.reset(adef);
	}


	/// @name Access to the jets
	//@{

	/// Get the jets (unordered) with pT > ptmin.
	Jets _jets() const;

	/// Get the pseudo jets (unordered).
	PseudoJets pseudoJets(double ptmin=0.0) const;
	/// Alias
	PseudoJets pseudojets(double ptmin=0.0) const { return pseudoJets(ptmin); }

	/// Get the pseudo jets, ordered by \f$ p_T \f$.
	PseudoJets pseudoJetsByPt(double ptmin=0.0) const {
	return sorted_by_pt(pseudoJets(ptmin));
	}
	/// Alias
	PseudoJets pseudojetsByPt(double ptmin=0.0) const { return pseudoJetsByPt(ptmin); }

	/// Get the pseudo jets, ordered by \f$ E \f$.
	PseudoJets pseudoJetsByE(double ptmin=0.0) const {
	return sorted_by_E(pseudoJets(ptmin));
	}
	/// Alias
	PseudoJets pseudojetsByE(double ptmin=0.0) const { return pseudoJetsByE(ptmin); }

	/// Get the pseudo jets, ordered by rapidity.
	PseudoJets pseudoJetsByRapidity(double ptmin=0.0) const {
	return sorted_by_rapidity(pseudoJets(ptmin));
	}
	/// Alias
	PseudoJets pseudojetsByRapidity(double ptmin=0.0) const { return pseudoJetsByRapidity(ptmin); }

	/// Trim (filter) a jet, keeping tag and constituent info in the resulting jet
	Jet trimJet(const Jet& input, const fastjet::Filter& trimmer) const;

	//@}


	/// @name Access to the FastJet clustering objects such as jet def, area def, and cluster
	//@{

	/// Return the cluster sequence.
	/// @todo Care needed re. const shared_ptr<T> vs. shared_ptr<const T>
	const shared_ptr<fastjet::ClusterSequence> clusterSeq() const {
	return _cseq;
	}
	// const fastjet::ClusterSequence* clusterSeq() const {
	// return _cseq.get();
	// }

	/// Return the area-enabled cluster sequence (if an area defn exists, otherwise returns a null ptr).
	/// @todo Care needed re. const shared_ptr<T> vs. shared_ptr<const T>
	const shared_ptr<fastjet::ClusterSequenceArea> clusterSeqArea() const {
	return areaDef() ? dynamic_pointer_cast<fastjet::ClusterSequenceArea>(_cseq) : nullptr;
	}
	// const fastjet::ClusterSequenceArea* clusterSeqArea() const {
	// return areaDef() ? dynamic_cast<fastjet::ClusterSequenceArea*>(_cseq.get()) : nullptr;
	// }

	/// Return the jet definition.
	const fastjet::JetDefinition& jetDef() const {
	return _jdef;
	}

	/// @brief Return the area definition.
	///
	/// @warning May be null!
	/// @todo Care needed re. const shared_ptr<T> vs. shared_ptr<const T>
	const shared_ptr<fastjet::AreaDefinition> areaDef() const {
	return _adef;
	}
	// const fastjet::AreaDefinition* areaDef() const {
	// return _adef.get();
	// }

	//@}


	private:

	/// Shared utility functions to implement constructor behaviour
	/// @todo Replace with calls between constructors when C++11 available?
	void _initBase();
	void _initJdef(JetAlgName alg, double rparameter, double seed_threshold);
	// void _init2(fastjet::JetAlgorithm type, fastjet::RecombinationScheme recom, double rparameter);
	// void _init3(const fastjet::JetDefinition& plugin);
	// void _init4(fastjet::JetDefinition::Plugin* plugin);

	/// Function to make Rivet::Jet from fastjet::PseudoJet, including constituent and tag info
	Jet _mkJet(const PseudoJet& pj) const;

	protected:

	/// Perform the projection on the Event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;

	public:

	/// Do the calculation locally (no caching).
	void calc(const Particles& fsparticles, const Particles& tagparticles=Particles());


	private:

	/// Jet definition
	fastjet::JetDefinition _jdef;

	/// Pointer to user-handled area definition
	std::shared_ptr<fastjet::AreaDefinition> _adef;

	/// Cluster sequence
	std::shared_ptr<fastjet::ClusterSequence> _cseq;

	/// FastJet external plugin
	std::shared_ptr<fastjet::JetDefinition::Plugin> _plugin;

	/// Map of vectors of y scales. This is mutable so we can use caching/lazy evaluation.
	mutable std::map<int, vector<double> > _yscales;

	/// set of particles sorted by their PT2
	//set<Particle, ParticleBase::byPTAscending> _particles;
	std::map<int, Particle> _particles;

	};

	}

	#endif
	diff --git a/include/Rivet/Projections/FinalPartons.hh b/include/Rivet/Projections/FinalPartons.hh
	--- a/include/Rivet/Projections/FinalPartons.hh
	+++ b/include/Rivet/Projections/FinalPartons.hh
	@@ -1,36 +1,34 @@
	// -- C++ --
	#ifndef RIVET_FinalPartons_HH
	#define RIVET_FinalPartons_HH

	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	class FinalPartons : public FinalState {
	public:

	/// Constructor
	FinalPartons(const Cut& c=Cuts::open())
	: FinalState(c) { }

	/// Clone method
	- unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new FinalPartons(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(FinalPartons);

	/// Do the calculation
	void project(const Event& e);


	protected:

	/// Cut-applying method overload
	bool accept(const Particle& p) const;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/FinalState.hh b/include/Rivet/Projections/FinalState.hh
	--- a/include/Rivet/Projections/FinalState.hh
	+++ b/include/Rivet/Projections/FinalState.hh
	@@ -1,54 +1,55 @@
	// -- C++ --
	#ifndef RIVET_FinalState_HH
	#define RIVET_FinalState_HH

	#include "Rivet/Projections/ParticleFinder.hh"
	-#include "Rivet/Cuts.hh"

	namespace Rivet {

	+
	/// @brief Project out all final-state particles in an event.
	/// Probably the most important projection in Rivet!
	class FinalState : public ParticleFinder {
	private:
	// hide lossy copy constructors for all classes derived from FinalState
	template<typename T> FinalState(const T& rhs);
	template<typename T> FinalState const& operator=(T const& rhs);

	+
	public:

	/// @name Standard constructors etc.
	//@{

	/// Construction using Cuts object
	FinalState(const Cut& c=Cuts::open());

	+ // /// Construction using Cuts object and another FinalState
	+ // FinalState(const Cut& c=Cuts::open(), const FinalState& fsp=FinalState());
	+
	/// Old constructor with numeric cut arguments, retained for compatibility
	/// @deprecated Use the versions with Cut arguments
	- //DEPRECATED("Use the versions with Cut arguments")
	FinalState(double mineta, double maxeta, double minpt=0.0*GeV);

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new FinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(FinalState);

	//@}


	/// Apply the projection to the event.
	virtual void project(const Event& e);

	/// Compare projections.
	virtual int compare(const Projection& p) const;

	/// Decide if a particle is to be accepted or not.
	/// @todo Rename to _accept or acceptFinal?
	virtual bool accept(const Particle& p) const;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/FinalStates.hh b/include/Rivet/Projections/FinalStates.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Projections/FinalStates.hh
	@@ -0,0 +1,17 @@
	+// -- C++ --
	+#ifndef RIVET_FinalStates_HH
	+#define RIVET_FinalStates_HH
	+
	+/// @file FinalStates.hh Convenience include of all FinalState projection headers
	+
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+#include "Rivet/Projections/NeutralFinalState.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/VetoedFinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/NonPromptFinalState.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+#include "Rivet/Projections/VisibleFinalState.hh"
	+
	+#endif
	diff --git a/include/Rivet/Projections/FoxWolframMoments.hh b/include/Rivet/Projections/FoxWolframMoments.hh
	--- a/include/Rivet/Projections/FoxWolframMoments.hh
	+++ b/include/Rivet/Projections/FoxWolframMoments.hh
	@@ -1,78 +1,72 @@
	// -- C++ --
	#ifndef RIVET_FoxWolframMoments_HH
	#define RIVET_FoxWolframMoments_HH

	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"

	#include <gsl/gsl_sf_legendre.h>

	#define MAXMOMENT 5

	namespace Rivet {


	/// @brief Calculate Fox-Wolfram moments
	class FoxWolframMoments : public Projection {
	public:

	/// Constructor.
	- FoxWolframMoments(const FinalState& fsp)
	- {
	+ FoxWolframMoments(const FinalState& fsp) {
	setName("FoxWolframMoments");
	addProjection(fsp, "FS");

	/// @todo Let the user supply any projection they like?
	VisibleFinalState vfs(fsp);
	addProjection(vfs, "VFS");

	// Initialize moments vector
	for (int i = 0; i < MAXMOMENT ; ++i) {
	_fwmoments.push_back(0.0);
	}
	}

	+ /// Clone on the heap.
	+ DEFAULT_RIVET_PROJ_CLONE(FoxWolframMoments);

	- /// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new FoxWolframMoments(*this));
	- }
	-
	-
	- public:

	/// The projected Fox-Wolfram Moment of order l
	double getFoxWolframMoment(unsigned int l) const {
	if (l < MAXMOMENT) {
	return _fwmoments[l];
	}
	/// @todo What?!?
	return -666.0;
	}


	protected:

	/// Apply the projection to the event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;


	private:

	vector<double> _fwmoments;

	};


	}


	#endif
	diff --git a/include/Rivet/Projections/HadronicFinalState.hh b/include/Rivet/Projections/HadronicFinalState.hh
	--- a/include/Rivet/Projections/HadronicFinalState.hh
	+++ b/include/Rivet/Projections/HadronicFinalState.hh
	@@ -1,54 +1,51 @@
	// -- C++ --
	#ifndef RIVET_HadronicFinalState_HH
	#define RIVET_HadronicFinalState_HH

	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"

	+namespace Rivet {

	-namespace Rivet {

	/// @brief Project only hadronic final state particles.
	class HadronicFinalState : public FinalState {
	-
	public:

	/// Constructor: the supplied FinalState projection is assumed to live through the run.
	HadronicFinalState(const FinalState& fsp)
	{
	setName("HadronicFinalState");
	addProjection(fsp, "FS");
	}

	HadronicFinalState(double mineta = -MAXDOUBLE,
	double maxeta = MAXDOUBLE,
	double minpt = 0.0*GeV)
	{
	setName("HadronicFinalState");
	addProjection(FinalState(mineta, maxeta, minpt), "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new HadronicFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(HadronicFinalState);

	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;

	};


	}


	#endif
	diff --git a/include/Rivet/Projections/HeavyHadrons.hh b/include/Rivet/Projections/HeavyHadrons.hh
	--- a/include/Rivet/Projections/HeavyHadrons.hh
	+++ b/include/Rivet/Projections/HeavyHadrons.hh
	@@ -1,99 +1,89 @@
	// -- C++ --
	#ifndef RIVET_HeavyHadrons_HH
	#define RIVET_HeavyHadrons_HH

	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	/// @brief Project out the last pre-decay b and c hadrons.
	///
	/// This currently defines a c-hadron as one which contains a @a c quark and
	/// @a{not} a @a b quark.
	///
	/// @todo This assumes that the heavy hadrons are unstable... should we also look for stable ones in case the decays are disabled?
	class HeavyHadrons : public FinalState {
	public:

	/// @name Constructors and destructors.
	//@{

	/// Constructor with specification of the minimum and maximum pseudorapidity
	/// \f$ \eta \f$ and the min \f$ p_T \f$ (in GeV).
	HeavyHadrons(const Cut& c=Cuts::open()) {
	setName("HeavyHadrons");
	addProjection(UnstableFinalState(c), "UFS");
	}

	- /// Constructor with specification of the minimum and maximum pseudorapidity
	- /// \f$ \eta \f$ and the min \f$ p_T \f$ (in GeV).
	- DEPRECATED("Use the version with a Cut argument")
	- HeavyHadrons(double mineta, double maxeta, double minpt=0.0*GeV) {
	- setName("HeavyHadrons");
	- addProjection(UnstableFinalState(Cuts::etaIn(mineta, maxeta) && Cuts::pT > minpt), "UFS");
	- }
	-
	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new HeavyHadrons(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(HeavyHadrons);

	//@}


	/// @name Particle accessors
	//@{

	/// Get all weakly decaying b hadrons (return by reference)
	const Particles& bHadrons() const {
	return _theBs;
	}

	/// Get weakly decaying b hadrons with a pTmin cut (return by value)
	Particles bHadrons(double pTmin) const {
	Particles rtn;
	foreach (const Particle& p, bHadrons())
	if (p.pT() > pTmin) rtn += p;
	return rtn;
	}

	/// Get all weakly decaying c hadrons (return by reference)
	const Particles& cHadrons() const {
	return _theCs;
	}

	/// Get weakly decaying c hadrons with a pTmin cut (return by value)
	const Particles cHadrons(double pTmin) const {
	Particles rtn;
	foreach (const Particle& p, cHadrons())
	if (p.pT() > pTmin) rtn += p;
	return rtn;
	}

	//@}


	protected:

	/// Apply the projection to the event.
	virtual void project(const Event& e);

	/// Compare projections (only difference is in UFS definition)
	virtual int compare(const Projection& p) const {
	return mkNamedPCmp(p, "UFS");
	}

	/// b and c hadron containers
	Particles _theBs, _theCs;

	};


	}


	#endif
	diff --git a/include/Rivet/Projections/Hemispheres.hh b/include/Rivet/Projections/Hemispheres.hh
	--- a/include/Rivet/Projections/Hemispheres.hh
	+++ b/include/Rivet/Projections/Hemispheres.hh
	@@ -1,177 +1,175 @@
	// -- C++ --
	#ifndef RIVET_Hemispheres_HH
	#define RIVET_Hemispheres_HH

	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/AxesDefinition.hh"

	+namespace Rivet {

	-namespace Rivet {

	/// @brief Calculate the hemisphere masses and broadenings.
	///
	/// Calculate the hemisphere masses and broadenings, with event hemispheres
	/// defined by the plane normal to the thrust vector, \f$ \vec{n}_\mathrm{T} \f$.
	///
	/// The "high" hemisphere mass,
	/// \f$ M^2_\mathrm{high} / E^2_\mathrm{vis} \f$, is defined as
	/// \f[
	/// \frac{M^2_\mathrm{high}}{E^2_\mathrm{vis}} =
	/// \frac{1}{E^2_\mathrm{vis}} \max
	/// \left(
	/// \left\| \sum_{\vec{p}_k \cdot \vec{n}_\mathrm{T} > 0} p_k \right\|^2 ,
	/// \left\| \sum_{\vec{p}_k \cdot \vec{n}_\mathrm{T} < 0} p_k \right\|^2
	/// \right)
	/// \f]
	/// and the corresponding "low" hemisphere mass,
	/// \f$ M^2_\mathrm{low} / E^2_\mathrm{vis} \f$,
	/// is the sum of momentum vectors in the opposite hemisphere, i.e.
	/// \f$ \max \rightarrow \min \f$ in the formula above.
	///
	/// Finally, we define a hemisphere mass difference:
	/// \f[
	/// \frac{M^2_\mathrm{diff} }{ E^2_\mathrm{vis}} =
	/// \frac{ M^2_\mathrm{high} - M^2_\mathrm{low} }{ E^2_\mathrm{vis}} .
	/// \f]
	///
	/// Similarly to the masses, we also define hemisphere broadenings, using the
	/// momenta transverse to the thrust axis:
	/// \f[
	/// B_\pm =
	/// \frac{
	/// \sum{\pm \vec{p}_i \cdot \vec{n}_\mathrm{T} > 0}
	/// \|\vec{p}_i \times \vec{n}_\mathrm{T} \|
	/// }{
	/// 2 \sum_i \| \vec{p}_i \|
	/// }
	/// \f]
	/// and then a set of the broadening maximum, minimum, sum and difference as follows:
	/// \f[ B_\mathrm{max} = \max(B_+, B_-) \f]
	/// \f[ B_\mathrm{min} = \min(B_+, B_-) \f]
	/// \f[ B_\mathrm{sum} = B_+ + B_- \f]
	/// \f[ B_\mathrm{diff} = \|B_+ - B_-\| \f]
	///
	/// Internally, this projection uses a Thrust or Sphericity projection to
	/// determine the hemisphere orientation.
	class Hemispheres : public Projection {
	public:

	/// Constructor.
	Hemispheres(const AxesDefinition& ax) {
	setName("Hemispheres");
	addProjection(ax, "Axes");
	clear();
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new Hemispheres(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(Hemispheres);

	/// Reset the projection
	void clear() {
	_E2vis = -1;
	_M2high = -1;
	_M2low = -1;
	_Bmax = -1;
	_Bmin = -1;
	_highMassEqMaxBroad = true;
	}

	/// Use the projection manually (i.e. outside the projection mechanism) with raw 4-momentum inputs.
	void calc(const Vector3& n, const std::vector<FourMomentum>& p4s);
	/// Use the projection manually (i.e. outside the projection mechanism) with particle inputs.
	void calc(const Vector3& n, const Particles& particles);
	/// Use the projection manually (i.e. outside the projection mechanism) with jet inputs.
	void calc(const Vector3& n, const Jets& jets);


	protected:

	/// Perform the projection on the Event.
	void project(const Event& e);

	/// Compare with other projections.
	int compare(const Projection& p) const {
	return mkNamedPCmp(p, "Axes");
	}


	public:

	/// @name Hemisphere masses (scaled by \f$ 1 / E^2_\mathrm{vis} \f$).
	//@{

	double E2vis() const { return _E2vis; }
	double Evis() const { return sqrt(_E2vis); }

	double M2high() const { return _M2high; }
	double Mhigh() const { return sqrt(M2high()); }

	double M2low() const { return _M2low; }
	double Mlow() const { return sqrt(M2low()); }

	double M2diff() const { return _M2high -_M2low; }
	double Mdiff() const { return sqrt(M2diff()); }

	double M2sum() const { return _M2high +_M2low; }
	double Msum() const { return sqrt(M2sum()); }

	double scaledM2high() const {
	if (isZero(_M2high)) return 0.0;
	if (!isZero(_E2vis)) return _M2high/_E2vis;
	else return std::numeric_limits<double>::max();
	}
	double scaledMhigh() const { return sqrt(scaledM2high()); }

	double scaledM2low() const {
	if (isZero(_M2low)) return 0.0;
	if (!isZero(_E2vis)) return _M2low/_E2vis;
	else return std::numeric_limits<double>::max();
	}
	double scaledMlow() const { return sqrt(scaledM2low()); }

	double scaledM2diff() const {
	if (M2diff() == 0.0) return 0.0;
	if (_E2vis != 0.0) return M2diff()/_E2vis;
	else return std::numeric_limits<double>::max();
	}
	double scaledMdiff() const { return sqrt(scaledM2diff()); }
	//@}


	/// @name Hemisphere broadenings.
	//@{
	double Bmax() const { return _Bmax; }
	double Bmin() const { return _Bmin; }
	double Bsum() const { return _Bmax + _Bmin; }
	double Bdiff() const { return fabs(_Bmax - _Bmin); } // <- fabs(), just in case...
	//@}


	/// Is the hemisphere with the max mass the same as the one with the max broadening?
	bool massMatchesBroadening() {
	return _highMassEqMaxBroad;
	}


	private:

	/// Visible energy-squared, \f$ E^2_\mathrm{vis} \f$.
	double _E2vis;

	/// Hemisphere mass variables.
	double _M2high, _M2low;

	/// Hemisphere broadening variables.
	double _Bmax, _Bmin;

	/// Is the hemisphere with the max mass the same as the one with the max broadening?
	bool _highMassEqMaxBroad;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/IdentifiedFinalState.hh b/include/Rivet/Projections/IdentifiedFinalState.hh
	--- a/include/Rivet/Projections/IdentifiedFinalState.hh
	+++ b/include/Rivet/Projections/IdentifiedFinalState.hh
	@@ -1,144 +1,138 @@
	// -- C++ --
	#ifndef RIVET_IdentifiedFinalState_HH
	#define RIVET_IdentifiedFinalState_HH

	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Produce a final state which only contains specified particle IDs.
	class IdentifiedFinalState : public FinalState {
	public:

	/// @name Constructors
	//@{

	/// Constructor with a FinalState and optional list of PDG ID codes.
	IdentifiedFinalState(const FinalState& fsp, const vector<PdgId>& pids=vector<PdgId>());

	- /// Constructor with a list of PDG ID codes and a FinalState.
	+ /// Constructor with a list of PDG ID codes and a FinalState
	+ /// @deprecated Use the version with FinalState as 1st arg
	+ DEPRECATED("Use the version with FinalState as 1st arg")
	IdentifiedFinalState(const vector<PdgId>& pids, const FinalState& fsp);

	/// Constructor with a FinalState and a single of PDG ID code.
	IdentifiedFinalState(const FinalState& fsp, PdgId pid);

	/// Constructor with a single PDG ID code and a FinalState.
	+ /// @deprecated Use the version with FinalState as 1st arg
	+ DEPRECATED("Use the version with FinalState as 1st arg")
	IdentifiedFinalState(PdgId pid, const FinalState& fsp);


	/// Construction using optional Cuts object and optional list of PDG ID codes
	IdentifiedFinalState(const Cut& c=Cuts::open(), const vector<PdgId>& pids=vector<PdgId>());

	/// Construction using list of PDG ID codes and an optional Cuts object
	IdentifiedFinalState(const vector<PdgId>& pids, const Cut& c=Cuts::open());

	/// Construction using Cuts object and a single PDG ID code
	IdentifiedFinalState(const Cut& c, PdgId pid);

	/// Construction using a single PDG ID code and an optional Cuts object
	IdentifiedFinalState(PdgId pid, const Cut& c=Cuts::open());


	- /// Constructor with eta range and pT_min arguments and optional list of PDG ID codes.
	- /// @deprecated Use the versions with Cut or FinalState arguments
	- DEPRECATED("Use the versions with Cut or FinalState arguments.")
	- IdentifiedFinalState(double etamin, double etamax, double ptMin=0.0*GeV);
	-
	-
	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new IdentifiedFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(IdentifiedFinalState);

	//@}


	- public:
	-
	/// Get the list of particle IDs to accept.
	const set<PdgId>& acceptedIds() const {
	return _pids;
	}

	/// Add an accepted particle ID.
	IdentifiedFinalState& acceptId(PdgId pid) {
	_pids.insert(pid);
	return *this;
	}

	/// Add a set of accepted particle IDs.
	IdentifiedFinalState& acceptIds(const vector<PdgId>& pids) {
	foreach (const PdgId pid, pids) {
	_pids.insert(pid);
	}
	return *this;
	}

	/// Add an accepted particle ID and its antiparticle.
	IdentifiedFinalState& acceptIdPair(PdgId pid) {
	_pids.insert(pid);
	_pids.insert(-pid);
	return *this;
	}

	/// Add a set of accepted particle IDs and their antiparticles.
	IdentifiedFinalState& acceptIdPairs(const vector<PdgId>& pids) {
	foreach (const PdgId pid, pids) {
	_pids.insert(pid);
	_pids.insert(-pid);
	}
	return *this;
	}

	/// Accept all neutrinos (convenience method).
	IdentifiedFinalState& acceptNeutrinos() {
	acceptIdPair(PID::NU_E);
	acceptIdPair(PID::NU_MU);
	acceptIdPair(PID::NU_TAU);
	return *this;
	}

	/// Accept all charged leptons (convenience method).
	IdentifiedFinalState& acceptChLeptons() {
	acceptIdPair(PID::ELECTRON);
	acceptIdPair(PID::MUON);
	acceptIdPair(PID::TAU);
	return *this;
	}

	/// Reset the list of particle IDs to accept.
	void reset() {
	_pids.clear();
	}

	// The remaining particles
	virtual const Particles& remainingParticles() const {
	return _remainingParticles;
	}


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;


	private:

	/// The final-state particles.
	set<PdgId> _pids;

	// A vector of all other particles in the final state
	Particles _remainingParticles;

	};


	}


	#endif
	diff --git a/include/Rivet/Projections/InitialQuarks.hh b/include/Rivet/Projections/InitialQuarks.hh
	--- a/include/Rivet/Projections/InitialQuarks.hh
	+++ b/include/Rivet/Projections/InitialQuarks.hh
	@@ -1,60 +1,59 @@
	// -- C++ --
	#ifndef RIVET_InitialQuarks_HH
	#define RIVET_InitialQuarks_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	/// @brief Project out quarks from the hard process in \f$ e^+ e^- \to Z^0 \f$ events
	///
	- /// @warning This is a very dangerous and specific projection! Use
	- /// e.g. PID::hasBottom and friends instead whenever possible
	+ /// @deprecated We're not sure exactly when we'lll get rid of this, but it's going to happen...
	+ ///
	+ /// @warning This is a very dangerous and specific projection!
	class InitialQuarks : public Projection {
	public:

	/// @name Standard constructors and destructors.
	//@{
	/// The default constructor. May specify the minimum and maximum
	/// pseudorapidity \f$ \eta \f$ and the min \f$ p_T \f$ (in GeV).
	InitialQuarks() {
	setName("InitialQuarks");
	}

	+ /// Clone on the heap.
	+ DEFAULT_RIVET_PROJ_CLONE(InitialQuarks);

	- /// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new InitialQuarks(*this));
	- }
	//@}

	/// Access the projected final-state particles.
	virtual const Particles& particles() const { return _theParticles; }

	/// Is this final state empty?
	virtual bool empty() const { return _theParticles.empty(); }


	protected:

	/// Apply the projection to the event.
	virtual void project(const Event& e);

	/// Compare projections.
	virtual int compare(const Projection& p) const;


	protected:

	/// The final-state particles.
	Particles _theParticles;

	};

	}


	#endif
	diff --git a/include/Rivet/Projections/InvMassFinalState.hh b/include/Rivet/Projections/InvMassFinalState.hh
	--- a/include/Rivet/Projections/InvMassFinalState.hh
	+++ b/include/Rivet/Projections/InvMassFinalState.hh
	@@ -1,103 +1,99 @@
	// -- C++ --
	#ifndef RIVET_InvMassFinalState_HH
	#define RIVET_InvMassFinalState_HH

	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Identify particles which can be paired to fit within a given invariant mass window
	class InvMassFinalState : public FinalState {
	public:

	/// Constructor for a single inv-mass pair.
	InvMassFinalState(const FinalState& fsp,
	const std::pair<PdgId, PdgId>& idpair, // pair of decay products
	double minmass, // min inv mass
	double maxmass, // max inv mass
	double masstarget=-1.0);


	/// Constructor for multiple inv-mass pairs.
	InvMassFinalState(const FinalState& fsp,
	const std::vector<std::pair<PdgId, PdgId> >& idpairs, // vector of pairs of decay products
	double minmass, // min inv mass
	double maxmass, // max inv mass
	double masstarget=-1.0);


	/// Same thing as above, but we want to pass the particles directly to the calc method
	InvMassFinalState(const std::pair<PdgId, PdgId>& idpair, // pair of decay products
	double minmass, // min inv mass
	double maxmass, // max inv mass
	double masstarget=-1.0);
	InvMassFinalState(const std::vector<std::pair<PdgId, PdgId> >& idpairs, // vector of pairs of decay products
	double minmass, // min inv mass
	double maxmass, // max inv mass
	double masstarget=-1.0);


	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new InvMassFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(InvMassFinalState);


	- public:
	-
	/// Constituent pairs.
	const std::vector<std::pair<Particle, Particle> >& particlePairs() const;


	/// Choose whether to use the full inv mass or just the transverse mass.
	void useTransverseMass(bool usetrans=true) {
	_useTransverseMass = usetrans;
	}

	/// Operate on a given particle vector directly instead of through project (no caching)
	void calc(const Particles& inparticles);

	private:

	/// Transverse Mass
	inline double massT( FourMomentum v1, FourMomentum v2) {
	return sqrt( (v1.Et() + v2.Et())*(v1.Et() + v2.Et()) -
	(v1+v2).perp()*(v1+v2).perp() );
	}

	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;


	private:

	/// IDs of the decay products.
	std::vector<PdgIdPair> _decayids;

	/// Constituent pairs.
	std::vector<std::pair<Particle, Particle> > _particlePairs;

	/// Min inv mass.
	double _minmass;

	/// Max inv mass.
	double _maxmass;

	/// Target mass if only one pair should be returned.
	double _masstarget;

	/// Flag to decide whether to use the full inv mass or just the transverse mass.
	bool _useTransverseMass;
	};


	}


	#endif
	diff --git a/include/Rivet/Projections/JetAlg.hh b/include/Rivet/Projections/JetAlg.hh
	--- a/include/Rivet/Projections/JetAlg.hh
	+++ b/include/Rivet/Projections/JetAlg.hh
	@@ -1,246 +1,227 @@
	// -- C++ --
	#ifndef RIVET_JetAlg_HH
	#define RIVET_JetAlg_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Jet.hh"

	namespace Rivet {


	/// Abstract base class for projections which can return a set of {@link Jet}s.
	class JetAlg : public Projection {
	public:

	/// Enum for the treatment of muons: whether to include all, some, or none in jet-finding
	enum MuonsStrategy { NO_MUONS, DECAY_MUONS, ALL_MUONS };

	/// Enum for the treatment of invisible particles: whether to include all, some, or none in jet-finding
	enum InvisiblesStrategy { NO_INVISIBLES, DECAY_INVISIBLES, ALL_INVISIBLES };



	/// Constructor
	JetAlg(const FinalState& fs, MuonsStrategy usemuons=JetAlg::ALL_MUONS, InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES);

	/// Default constructor
	JetAlg() {};

	/// Clone on the heap.
	virtual unique_ptr<Projection> clone() const = 0;

	/// Destructor
	virtual ~JetAlg() { }


	/// @name Control the treatment of muons and invisible particles
	///
	/// Since MC-based jet calibration (and/or particle flow) can add back in
	/// particles that weren't seen in calorimeters/trackers.
	//@{

	/// @brief Include (some) muons in jet construction.
	///
	/// The default behaviour is that jets are only constructed from visible
	/// particles. Some jet studies, including those from ATLAS, use a definition
	/// in which neutrinos from hadron decays are included via MC-based calibrations.
	/// Setting this flag to true avoids the automatic restriction to a VisibleFinalState.
	void useMuons(MuonsStrategy usemuons=ALL_MUONS) {
	_useMuons = usemuons;
	}

	/// @brief Include (some) invisible particles in jet construction.
	///
	/// The default behaviour is that jets are only constructed from visible
	/// particles. Some jet studies, including those from ATLAS, use a definition
	/// in which neutrinos from hadron decays are included via MC-based calibrations.
	/// Setting this flag to true avoids the automatic restriction to a VisibleFinalState.
	void useInvisibles(InvisiblesStrategy useinvis=DECAY_INVISIBLES) {
	_useInvisibles = useinvis;
	}

	/// @brief Include (some) invisible particles in jet construction.
	///
	/// The default behaviour is that jets are only constructed from visible
	/// particles. Some jet studies, including those from ATLAS, use a definition
	/// in which neutrinos from hadron decays are included via MC-based calibrations.
	/// Setting this flag to true avoids the automatic restriction to a VisibleFinalState.
	///
	/// @deprecated Use the enum-arg version instead. Will be removed in Rivet v3
	void useInvisibles(bool useinvis) {
	_useInvisibles = useinvis ? DECAY_INVISIBLES : NO_INVISIBLES;
	}

	//@}


	/// @name Access to jet objects
	//@{

	- /// Get jets in no guaranteed order, with optional cuts on \f$ p_\perp \f$ and rapidity.
	+ /// Get jets in no guaranteed order, with an optional Cut
	/// @note Returns a copy rather than a reference, due to cuts
	virtual Jets jets(const Cut& c=Cuts::open()) const {
	- return filterBy(_jets(), c);
	+ return filter_select(_jets(), c);
	// const Jets rawjets = _jets();
	// // Just return a copy of rawjets if the cut is open
	// if (c == Cuts::open()) return rawjets;
	// // If there is a non-trivial cut...
	// /// @todo Use an STL erase(remove_if) and lambda function for this
	// Jets rtn;
	// rtn.reserve(size());
	// foreach (const Jet& j, rawjets)
	// if (c->accept(j)) rtn.push_back(j);
	// return rtn;
	}

	- /// Get the jets, ordered by supplied sorting function object, with optional cuts on \f$ p_\perp \f$ and rapidity.
	+ /// Get jets in no guaranteed order, with a selection functor
	+ /// @note Returns a copy rather than a reference, due to cuts
	+ virtual Jets jets(const JetSelector& selector) const {
	+ return filter_select(_jets(), selector);
	+ }
	+
	+
	+ /// Get the jets with a Cut applied, and ordered by supplied sorting functor
	/// @note Returns a copy rather than a reference, due to cuts and sorting
	- template <typename F>
	- Jets jets(F sorter, const Cut& c=Cuts::open()) const {
	+ Jets jets(const Cut& c, const JetSorter& sorter) const {
	/// @todo Will the vector be efficiently std::move'd by value through this function chain?
	return sortBy(jets(c), sorter);
	}

	+ /// Get the jets, ordered by supplied sorting functor, with an optional Cut
	+ /// @note Returns a copy rather than a reference, due to cuts and sorting
	+ Jets jets(const JetSorter& sorter, const Cut& c=Cuts::open()) const {
	+ /// @todo Will the vector be efficiently std::move'd by value through this function chain?
	+ return jets(c, sorter);
	+ }
	+
	/// Get the jets, ordered by supplied sorting function object, with optional cuts on \f$ p_\perp \f$ and rapidity.
	/// @note Returns a copy rather than a reference, due to cuts and sorting
	- template <typename F>
	- Jets jets(const Cut& c, F sorter) const {
	+ Jets jets(const JetSelector& selector, const JetSorter& sorter) const {
	/// @todo Will the vector be efficiently std::move'd by value through this function chain?
	- return sortBy(jets(c), sorter);
	+ return sortBy(jets(selector), sorter);
	+ }
	+
	+ /// Get the jets, ordered by supplied sorting functor and with a selection functor applied
	+ /// @note Returns a copy rather than a reference, due to cuts and sorting
	+ Jets jets(const JetSorter& sorter, const JetSelector selector) const {
	+ /// @todo Will the vector be efficiently std::move'd by value through this function chain?
	+ return jets(selector, sorter);
	}


	/// Get the jets, ordered by \f$ p_T \f$, with optional cuts.
	///
	/// @note Returns a copy rather than a reference, due to cuts and sorting
	///
	/// This is a very common use-case, so is available as syntatic sugar for jets(c, cmpMomByPt).
	/// @todo The other sorted accessors should be removed in a cleanup.
	Jets jetsByPt(const Cut& c=Cuts::open()) const {
	return jets(c, cmpMomByPt);
	}

	- //@}
	-
	-
	- /// @name Old sorted jet accessors
	- /// @deprecated Use the versions with sorter function arguments. These will be removed in Rivet v3
	- //@{
	-
	- /// Get the jets, ordered by \f$ \|p\| \f$, with optional cuts on \f$ p_\perp \f$ and rapidity.
	+ /// Get the jets, ordered by \f$ p_T \f$, with cuts via a selection functor.
	+ ///
	/// @note Returns a copy rather than a reference, due to cuts and sorting
	- /// @deprecated Use the version with a sorter function argument.
	- DEPRECATED("Use the version with a sorter function argument.")
	- Jets jetsByP(const Cut& c=Cuts::open()) const {
	- return jets(c, cmpMomByP);
	- }
	-
	- /// Get the jets, ordered by \f$ E \f$, with optional cuts on \f$ p_\perp \f$ and rapidity.
	- /// @note Returns a copy rather than a reference, due to cuts and sorting
	- /// @deprecated Use the version with a sorter function argument.
	- DEPRECATED("Use the version with a sorter function argument.")
	- Jets jetsByE(const Cut &c=Cuts::open()) const {
	- return jets(c, cmpMomByE);
	- }
	-
	- /// Get the jets, ordered by \f$ E_T \f$, with optional cuts on \f$ p_\perp \f$ and rapidity.
	- /// @note Returns a copy rather than a reference, due to cuts and sorting
	- /// @deprecated Use the version with a sorter function argument.
	- DEPRECATED("Use the version with a sorter function argument.")
	- Jets jetsByEt(const Cut& c=Cuts::open()) const {
	- return jets(c, cmpMomByEt);
	- }
	-
	- //@}
	-
	-
	- /// @name Old jet accessors
	- /// @deprecated Use the versions with Cut arguments
	- //@{
	-
	- /// Get jets in no guaranteed order, with optional cuts on \f$ p_\perp \f$ and rapidity.
	///
	- /// @deprecated Use the version with a Cut argument
	- /// @note Returns a copy rather than a reference, due to cuts
	- DEPRECATED("Use the version with a Cut argument.")
	- Jets jets(double ptmin, double ptmax=MAXDOUBLE,
	- double rapmin=-MAXDOUBLE, double rapmax=MAXDOUBLE,
	- RapScheme rapscheme=PSEUDORAPIDITY) const {
	- if (rapscheme == PSEUDORAPIDITY) {
	- return jets((Cuts::pT >= ptmin) & (Cuts::pT < ptmax) & (Cuts::rapIn(rapmin, rapmax)));
	- } else if (rapscheme == RAPIDITY) {
	- return jets((Cuts::pT >= ptmin) & (Cuts::pT < ptmax) & (Cuts::etaIn(rapmin, rapmax)));
	- }
	- throw LogicError("Unknown rapidity scheme. This shouldn't be possible!");
	+ /// This is a very common use-case, so is available as syntatic sugar for jets(c, cmpMomByPt).
	+ /// @todo The other sorted accessors should be removed in a cleanup.
	+ Jets jetsByPt(const JetSelector& selector) const {
	+ return jets(selector, cmpMomByPt);
	}

	/// Get the jets, ordered by \f$ p_T \f$, with a cut on \f$ p_\perp \f$.
	///
	/// @deprecated Use the version with a Cut argument
	/// @note Returns a copy rather than a reference, due to cuts and sorting
	///
	/// This is a very common use-case, so is available as syntatic sugar for jets(Cuts::pT >= ptmin, cmpMomByPt).
	/// @todo The other sorted accessors should be removed in a cleanup.
	Jets jetsByPt(double ptmin) const {
	return jets(Cuts::pT >= ptmin, cmpMomByPt);
	}

	//@}


	protected:

	/// @brief Internal pure virtual method for getting jets in no guaranteed order.
	virtual Jets _jets() const = 0;


	public:

	- /// Number of jets passing the provided Cut.
	- size_t numJets(const Cut& c=Cuts::open()) const { return jets(c).size(); }
	+ /// Count the jets
	+ size_t size() const { return jets().size(); }
	+ /// Count the jets after a Cut is applied.
	+ size_t size(const Cut& c) const { return jets(c).size(); }
	+ /// Count the jets after a selection functor is applied.
	+ size_t size(const JetSelector& s) const { return jets(s).size(); }

	- /// Number of jets (without cuts).
	- size_t size() const { return jets().size(); }
	- /// Whether the inclusive jet collection is empty.
	- bool empty() const { return size() != 0; }
	+ /// Is this jet finder empty?
	+ bool empty() const { return size() == 0; }
	+ /// Is this jet finder empty after a Cut is applied?
	+ bool empty(const Cut& c) const { return size(c) == 0; }
	+ /// Is this jet finder empty after a selection functor is applied?
	+ bool empty(const JetSelector& s) const { return size(s) == 0; }

	/// Clear the projection.
	virtual void reset() = 0;

	typedef Jet entity_type;
	typedef Jets collection_type;

	/// Template-usable interface common to FinalState.
	collection_type entities() const { return jets(); }

	// /// Do the calculation locally (no caching).
	// virtual void calc(const Particles& constituents, const Particles& tagparticles=Particles()) = 0;


	protected:

	/// Perform the projection on the Event.
	virtual void project(const Event& e) = 0;

	/// Compare projections.
	virtual int compare(const Projection& p) const = 0;


	protected:

	/// Flag to determine whether or not to exclude (some) muons from the would-be constituents.
	MuonsStrategy _useMuons;

	/// Flag to determine whether or not to exclude (some) invisible particles from the would-be constituents.
	InvisiblesStrategy _useInvisibles;


	};


	}

	#endif
	diff --git a/include/Rivet/Projections/JetShape.hh b/include/Rivet/Projections/JetShape.hh
	--- a/include/Rivet/Projections/JetShape.hh
	+++ b/include/Rivet/Projections/JetShape.hh
	@@ -1,201 +1,199 @@
	// -- C++ --
	#ifndef RIVET_JetShape_HH
	#define RIVET_JetShape_HH

	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/JetAlg.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Tools/Utils.hh"

	namespace Rivet {


	- /**
	- @brief Calculate the jet shape.
	-
	- Calculate the differential and integral jet shapes in \f$P_{\perp}\f$ for a given
	- set of jets. This particular jet shape projection calculates jet shapes relative
	- to jet centroids, using only the particles associated to each jet, for the hardest
	- \f$ n \f$ jets.
	-
	- The rapidity scheme (\f$ \eta \f$ or \f$ y \f$) has to be specified when
	- invoking the constructor.
	-
	- The differential jet shape around a given jet axis at distance interval
	- \f$ r \pm \delta{r}/2 \f$ is defined as
	- \f[
	- \rho(r) =
	- \frac{1}{\delta r} \frac{1}{N_\mathrm{jets}}
	- \sum_\mathrm{jets} \frac{P_\perp(r - \delta r/2, r+\delta r/2)}{p_\perp(0, R)}
	- \f]
	- with \f$ 0 \le r \le R \f$ and \f$ P_\perp(r_1, r_2) = \sum_{\in [r_1, r_2)} p_\perp \f$.
	-
	- The integral jet shape around a given jet axes until distance \f$ r \f$ is defined as
	- \f[
	- \Psi(r) =
	- \frac{1}{N_\mathrm{jets}}
	- \sum_\mathrm{jets} \frac{P_\perp(0, r)}{p_\perp(0, R)}
	- \f]
	- with \f$ 0 \le r \le R \f$ and \f$ P_\perp(r_1, r_2) = \sum_{\in [r_1, r_2)} p_\perp \f$.
	-
	- The constructor expects also the binning in radius \f$ r \f$ to be supplied.
	- */
	+ ///*
	+ /// @brief Calculate the jet shape.
	+ ///
	+ /// Calculate the differential and integral jet shapes in \f$P_{\perp}\f$ for a given
	+ /// set of jets. This particular jet shape projection calculates jet shapes relative
	+ /// to jet centroids, using only the particles associated to each jet, for the hardest
	+ /// \f$ n \f$ jets.
	+ ///
	+ /// The rapidity scheme (\f$ \eta \f$ or \f$ y \f$) has to be specified when
	+ /// invoking the constructor.
	+ ///
	+ /// The differential jet shape around a given jet axis at distance interval
	+ /// \f$ r \pm \delta{r}/2 \f$ is defined as
	+ /// \f[
	+ /// \rho(r) =
	+ /// \frac{1}{\delta r} \frac{1}{N_\mathrm{jets}}
	+ /// \sum_\mathrm{jets} \frac{P_\perp(r - \delta r/2, r+\delta r/2)}{p_\perp(0, R)}
	+ /// \f]
	+ /// with \f$ 0 \le r \le R \f$ and \f$ P_\perp(r_1, r_2) = \sum_{\in [r_1, r_2)} p_\perp \f$.
	+ ///
	+ /// The integral jet shape around a given jet axes until distance \f$ r \f$ is defined as
	+ /// \f[
	+ /// \Psi(r) =
	+ /// \frac{1}{N_\mathrm{jets}}
	+ /// \sum_\mathrm{jets} \frac{P_\perp(0, r)}{p_\perp(0, R)}
	+ /// \f]
	+ /// with \f$ 0 \le r \le R \f$ and \f$ P_\perp(r_1, r_2) = \sum_{\in [r_1, r_2)} p_\perp \f$.
	+ ///
	+ /// The constructor expects also the binning in radius \f$ r \f$ to be supplied.
	+ ///
	class JetShape : public Projection {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor from histo range and number of bins.
	JetShape(const JetAlg& jetalg,
	double rmin, double rmax, size_t nbins,
	double ptmin=0, double ptmax=MAXDOUBLE,
	double absrapmin=-MAXDOUBLE, double absrapmax=-MAXDOUBLE,
	RapScheme rapscheme=RAPIDITY);

	/// Constructor from vector of bin edges.
	JetShape(const JetAlg& jetalg, vector<double> binedges,
	double ptmin=0, double ptmax=MAXDOUBLE,
	double absrapmin=-MAXDOUBLE, double absrapmax=-MAXDOUBLE,
	RapScheme rapscheme=RAPIDITY);

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new JetShape(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(JetShape);

	//@}


	/// Reset projection between events.
	void clear();


	/// Do the calculation directly on a supplied collection of Jet objects.
	void calc(const Jets& jets);


	public:


	/// Number of equidistant radius bins.
	size_t numBins() const {
	return _binedges.size() - 1;
	}

	/// Number of jets which passed cuts.
	size_t numJets() const {
	return _diffjetshapes.size();
	}

	/// \f$ r_\text{min} \f$ value.
	double rMin() const {
	return _binedges.front();
	}

	/// \f$ r_\text{max} \f$ value.
	double rMax() const {
	return _binedges.back();
	}

	/// \f$ p_\perp^\text{min} \f$ value.
	double ptMin() const {
	return _ptcuts.first;
	}

	/// \f$ p_\perp^\text{max} \f$ value.
	double ptMax() const {
	return _ptcuts.second;
	}

	/// Central \f$ r \f$ value for bin @a rbin.
	double rBinMin(size_t rbin) const {
	assert(inRange(rbin, 0u, numBins()));
	return _binedges[rbin];
	}

	/// Central \f$ r \f$ value for bin @a rbin.
	double rBinMax(size_t rbin) const {
	assert(inRange(rbin, 0u, numBins()));
	return _binedges[rbin+1];
	}

	/// Central \f$ r \f$ value for bin @a rbin.
	double rBinMid(size_t rbin) const {
	assert(inRange(rbin, 0u, numBins()));
	//cout << _binedges << endl;
	return (_binedges[rbin] + _binedges[rbin+1])/2.0;
	}

	/// Return value of differential jet shape profile histo bin.
	double diffJetShape(size_t ijet, size_t rbin) const {
	assert(inRange(ijet, 0u, numJets()));
	assert(inRange(rbin, 0u, numBins()));
	return _diffjetshapes[ijet][rbin];
	}

	/// Return value of integrated jet shape profile histo bin.
	double intJetShape(size_t ijet, size_t rbin) const {
	assert(inRange(ijet, 0u, numJets()));
	assert(inRange(rbin, 0u, numBins()));
	double rtn = 0;
	for (size_t i = 0; i <= rbin; ++i) {
	rtn += _diffjetshapes[ijet][i];
	}
	return rtn;
	}

	/// @todo Provide int and diff jet shapes with some sort of area normalisation?

	// /// Return value of \f$ \Psi \f$ (integrated jet shape) at given radius for a \f$ p_T \f$ bin.
	// /// @todo Remove this external indexing thing
	// double psi(size_t pTbin) const {
	// return _PsiSlot[pTbin];
	// }


	protected:

	/// Apply the projection to the event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;


	private:

	/// @name Jet shape parameters
	//@{

	/// Vector of radius bin edges
	vector<double> _binedges;

	/// Lower and upper cuts on contributing jet \f$ p_\perp \f$.
	pair<double, double> _ptcuts;

	/// Lower and upper cuts on contributing jet (pseudo)rapidity.
	pair<double, double> _rapcuts;

	/// Rapidity scheme
	RapScheme _rapscheme;

	//@}


	/// @name The projected jet shapes
	//@{

	/// Jet shape histo -- first index is jet number, second is r bin
	vector< vector<double> > _diffjetshapes;

	//@}

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/LeadingParticlesFinalState.hh b/include/Rivet/Projections/LeadingParticlesFinalState.hh
	--- a/include/Rivet/Projections/LeadingParticlesFinalState.hh
	+++ b/include/Rivet/Projections/LeadingParticlesFinalState.hh
	@@ -1,79 +1,76 @@
	// -- C++ --
	#ifndef RIVET_LeadingParticlesFinalState_HH
	#define RIVET_LeadingParticlesFinalState_HH

	#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {

	- class Particle;

	/// @brief Get the highest-pT occurrences of FS particles with the specified PDG IDs.
	class LeadingParticlesFinalState : public FinalState {

	public:

	/// Constructor: the supplied FinalState projection is assumed to live through the run.
	LeadingParticlesFinalState(const FinalState& fsp)
	: FinalState(), _leading_only(false)
	{
	setName("LeadingParticlesFinalState");
	addProjection(fsp, "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new LeadingParticlesFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(LeadingParticlesFinalState);

	/// Add a particle ID to the list of leading particles selected
	LeadingParticlesFinalState& addParticleId(long id) {
	_ids.insert(id);
	return *this;
	}

	/// Add a particle ID to the list of leading particles selected
	LeadingParticlesFinalState& addParticleIdPair(long id) {
	_ids.insert(id);
	_ids.insert(-id);
	return *this;
	}

	/// Toggle whether to keep track only of the leading particle of any ID,
	/// or the leading particle of all IDs separately
	/// Default is the latter (=false)
	void setLeadingOnly(const bool& leadingonly) {
	_leading_only = leadingonly;
	}

	// /// Check if a particle of a particular ID was found in the current event
	// bool hasParticleId(const PdgId pid) const;

	// /// Get a particle of a particular ID (check it exists first)
	// bool get(const PdgId pid) const;


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;

	/// Check if the particle's ID is in the list
	bool inList(const Particle& particle) const;

	private:

	/// IDs of the leading particles to be selected
	std::set<long>_ids;
	bool _leading_only;

	};

	}

	#endif
	diff --git a/include/Rivet/Projections/LossyFinalState.hh b/include/Rivet/Projections/LossyFinalState.hh
	--- a/include/Rivet/Projections/LossyFinalState.hh
	+++ b/include/Rivet/Projections/LossyFinalState.hh
	@@ -1,85 +1,83 @@
	// -- C++ --
	#ifndef RIVET_LossyFinalState_HH
	#define RIVET_LossyFinalState_HH

	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Templated FS projection which can lose some of the supplied particles.
	template <typename FILTER>
	class LossyFinalState : public FinalState {
	public:

	/// @name Constructors
	//@{

	/// Constructor from FinalState.
	LossyFinalState(const FinalState& fsp, FILTER filter)
	: _filter(filter)
	{
	setName("LossyFinalState");
	addProjection(fsp, "FS");
	}

	/// Stand-alone constructor. Initialises the base FinalState projection.
	LossyFinalState(FILTER filter,
	double mineta = -MAXDOUBLE,
	double maxeta = MAXDOUBLE,
	double minpt = 0.0)
	: _filter(filter)
	{
	setName("LossyFinalState");
	addProjection(FinalState(mineta, maxeta, minpt), "FS");
	}

	/// Virtual destructor, to allow subclassing
	virtual ~LossyFinalState() { }

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new LossyFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(LossyFinalState);

	//@}


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e) {
	const FinalState& fs = applyProjection<FinalState>(e, "FS");
	getLog() << Log::DEBUG << "Pre-loss number of FS particles = " << fs.particles().size() << endl;
	_theParticles.clear();
	std::remove_copy_if(fs.particles().begin(), fs.particles().end(),
	std::back_inserter(_theParticles), _filter);
	getLog() << Log::DEBUG << "Filtered number of FS particles = " << _theParticles.size() << endl;
	}


	/// Compare projections.
	int compare(const Projection& p) const {
	const LossyFinalState<FILTER>& other = pcast< LossyFinalState<FILTER> >(p);
	const int fscmp = mkNamedPCmp(other, "FS");
	if (fscmp) return fscmp;
	return _filter.compare(other._filter);
	}


	protected:

	/// Filtering object: must support operator(const Particle&) and compare(const Filter&)
	FILTER _filter;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/MergedFinalState.hh b/include/Rivet/Projections/MergedFinalState.hh
	--- a/include/Rivet/Projections/MergedFinalState.hh
	+++ b/include/Rivet/Projections/MergedFinalState.hh
	@@ -1,47 +1,46 @@
	// -- C++ --
	#ifndef RIVET_MergedFinalState_HH
	#define RIVET_MergedFinalState_HH

	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Get final state particles merged from two FinalState projections.
	class MergedFinalState : public FinalState {

	public:

	/// @name Constructors
	//@{
	MergedFinalState(const FinalState& fspa, const FinalState& fspb) {
	setName("MergedFinalState");
	addProjection(fspa, "FSA");
	addProjection(fspb, "FSB");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new MergedFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(MergedFinalState);
	+
	//@}

	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;
	};


	}


	#endif
	diff --git a/include/Rivet/Projections/MissingMomentum.hh b/include/Rivet/Projections/MissingMomentum.hh
	--- a/include/Rivet/Projections/MissingMomentum.hh
	+++ b/include/Rivet/Projections/MissingMomentum.hh
	@@ -1,113 +1,142 @@
	// -- C++ --
	#ifndef RIVET_MissingMomentum_HH
	#define RIVET_MissingMomentum_HH

	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	/// @brief Calculate missing \f$ E \f$, \f$ E_\perp \f$ etc.
	///
	/// Project out the total visible energy vector, allowing missing
	/// \f$ E \f$, \f$ E_\perp \f$ etc. to be calculated. Final state
	/// visibility restrictions are automatic.
	class MissingMomentum : public Projection {
	public:

	/// Default constructor with optional cut.
	MissingMomentum(const Cut& c=Cuts::open()) {
	setName("MissingMomentum");
	FinalState fs(c);
	addProjection(fs, "FS");
	addProjection(VisibleFinalState(fs), "VisibleFS");
	}


	/// Constructor.
	MissingMomentum(const FinalState& fs) {
	setName("MissingMomentum");
	addProjection(fs, "FS");
	addProjection(VisibleFinalState(fs), "VisibleFS");
	}


	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new MissingMomentum(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(MissingMomentum);


	- public:
	+ /// @name Visible/missing four-momentum functions
	+ //@{

	/// The vector-summed visible four-momentum in the event.
	///
	/// @note Reverse this vector with .reverse() to get the missing momentum vector.
	///
	/// @note The optional @a mass argument is used to set a mass on the 4-vector. By
	/// default it is zero (since missing momentum is really a 3-momentum quantity:
	/// adding the E components of visible momenta just gives a huge mass)
	const FourMomentum visibleMomentum(double mass=0*GeV) const;
	/// Alias for visibleMomentum
	const FourMomentum visibleMom(double mass=0*GeV) const { return visibleMomentum(mass); }

	/// The missing four-momentum in the event, required to balance the final state.
	///
	/// @note The optional @a mass argument is used to set a mass on the 4-vector. By
	/// default it is zero (since missing momentum is really a 3-momentum quantity:
	/// adding the E components of visible momenta just gives a huge mass)
	const FourMomentum missingMomentum(double mass=0*GeV) const { return visibleMomentum(mass).reverse(); }
	/// Alias for missingMomentum
	const FourMomentum missingMom(double mass=0*GeV) const { return missingMomentum(mass); }

	+ //@}
	+
	+
	+ /// @name Transverse momentum functions
	+ /// @note This may be what you want, even if the paper calls it "missing Et"!
	+ //@{
	+
	+ /// The vector-summed visible transverse momentum in the event, as a 3-vector with z=0
	+ /// @note Reverse this vector with operator- to get the missing pT vector.
	+ const Vector3& vectorPt() const { return _vpt; }
	+
	+ /// The vector-summed missing transverse momentum in the event.
	+ double missingPt() const { return vectorPt().mod(); }
	+ // /// Alias for missingPt
	+ // double mpt() const { return missingPt(); }
	+
	+ /// The scalar-summed visible transverse momentum in the event.
	+ double scalarPt() const { return _spt; }
	+ // /// Alias for scalarPt
	+ // double spt() const { return scalarPt(); }
	+
	+ //@}
	+
	+
	+ /// @name Transverse energy functions
	+ /// @warning Despite the common names "MET" and "SET", what's often meant is the pT functions above!
	+ //@{
	+
	/// The vector-summed visible transverse energy in the event, as a 3-vector with z=0
	/// @note Reverse this vector with operator- to get the missing ET vector.
	const Vector3& vectorEt() const { return _vet; }

	/// The vector-summed missing transverse energy in the event.
	double missingEt() const { return vectorEt().mod(); }
	/// Alias for missingEt
	double met() const { return missingEt(); }

	/// The scalar-summed visible transverse energy in the event.
	double scalarEt() const { return _set; }
	/// Alias for scalarEt
	double set() const { return scalarEt(); }

	+ //@}
	+
	+
	+ public:
	+
	+ /// Clear the projection results.
	+ void clear();
	+

	protected:

	/// Apply the projection to the event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;


	- public:
	-
	- /// Clear the projection results.
	- void clear();
	-
	-
	private:

	/// The total visible momentum
	FourMomentum _momentum;

	/// Scalar transverse energy
	- double _set;
	+ double _set, _spt;

	/// Vector transverse energy
	- Vector3 _vet;
	+ Vector3 _vet, _vpt;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/NeutralFinalState.hh b/include/Rivet/Projections/NeutralFinalState.hh
	--- a/include/Rivet/Projections/NeutralFinalState.hh
	+++ b/include/Rivet/Projections/NeutralFinalState.hh
	@@ -1,64 +1,62 @@
	// -- C++ --
	#ifndef RIVET_NeutralFinalState_HH
	#define RIVET_NeutralFinalState_HH

	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Project only neutral final state particles.
	class NeutralFinalState : public FinalState {

	public:

	/// @name Constructors
	//@{

	/// Construction from another FinalState
	NeutralFinalState(const FinalState& fsp, double etmin=0*GeV)
	: _Etmin(etmin)
	{
	setName("NeutralFinalState");
	addProjection(fsp, "FS");
	}

	/// Construction using Cuts object
	NeutralFinalState(const Cut& c=Cuts::open()) : _Etmin(0.0*GeV) {
	setName("NeutralFinalState");
	addProjection(FinalState(c), "FS");
	}

	/// Construction from explicit eta range and min ET cut values
	NeutralFinalState(double mineta, double maxeta, double etmin=0*GeV)
	: _Etmin(etmin)
	{
	setName("NeutralFinalState");
	addProjection(FinalState(mineta, maxeta, 0.0*GeV), "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new NeutralFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(NeutralFinalState);

	//@}


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// The minimum allowed transverse energy.
	double _Etmin;

	/// Compare projections.
	int compare(const Projection& p) const;
	};


	}


	#endif
	diff --git a/include/Rivet/Projections/NonHadronicFinalState.hh b/include/Rivet/Projections/NonHadronicFinalState.hh
	--- a/include/Rivet/Projections/NonHadronicFinalState.hh
	+++ b/include/Rivet/Projections/NonHadronicFinalState.hh
	@@ -1,54 +1,52 @@
	// -- C++ --
	#ifndef RIVET_NonHadronicFinalState_HH
	#define RIVET_NonHadronicFinalState_HH

	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"

	+namespace Rivet {

	-namespace Rivet {

	/// @brief Project only hadronic final state particles.
	class NonHadronicFinalState : public FinalState {
	-
	public:

	/// Constructor: the supplied FinalState projection is assumed to live through the run.
	NonHadronicFinalState(FinalState& fsp)
	{
	setName("NonHadronicFinalState");
	addProjection(fsp, "FS");
	}

	NonHadronicFinalState(double mineta = -MAXDOUBLE,
	double maxeta = MAXDOUBLE,
	double minpt = 0.0*GeV)
	{
	setName("NonHadronicFinalState");
	addProjection(FinalState(mineta, maxeta, minpt), "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new NonHadronicFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(NonHadronicFinalState);
	+

	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;

	};


	}


	#endif
	diff --git a/include/Rivet/Projections/NonPromptFinalState.hh b/include/Rivet/Projections/NonPromptFinalState.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Projections/NonPromptFinalState.hh
	@@ -0,0 +1,57 @@
	+// -- C++ --
	+#ifndef RIVET_NonPromptFinalState_HH
	+#define RIVET_NonPromptFinalState_HH
	+
	+#include "Rivet/Projections/FinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Find final state particles NOT directly connected to the hard process.
	+ ///
	+ /// See PromptFinalState for details.
	+ class NonPromptFinalState : public FinalState {
	+ public:
	+
	+ /// @name Constructors
	+ //@{
	+
	+ // Constructor from a final state.
	+ NonPromptFinalState(const FinalState& fsp, bool accepttaudecays=false, bool acceptmudecays=false);
	+
	+ /// Constructor from a Cut (and implicit general FS).
	+ NonPromptFinalState(const Cut& c, bool accepttaudecays=false, bool acceptmudecays=false);
	+
	+ // /// Constructor from a Cut and optional FinalState.
	+ // NonPromptFinalState(const Cut& c, const FinalState& fsp=FinalState(),
	+ // bool accepttaudecays=false, bool acceptmudecays=false);
	+
	+ /// Clone on the heap.
	+ DEFAULT_RIVET_PROJ_CLONE(NonPromptFinalState);
	+
	+ //@}
	+
	+ /// Treat particles from decays of prompt muons as non-prompt?
	+ void acceptMuonDecays(bool acc=true) { _acceptMuDecays = acc; }
	+ /// Treat particles from decays of prompt taus as non-prompt?
	+ void acceptTauDecays(bool acc=true) { _acceptTauDecays = acc; }
	+
	+
	+ protected:
	+
	+ /// Apply the projection on the supplied event.
	+ void project(const Event& e);
	+
	+ /// Compare projections.
	+ int compare(const Projection& p) const;
	+
	+ private:
	+
	+ bool _acceptMuDecays, _acceptTauDecays;
	+
	+ };
	+
	+}
	+
	+
	+#endif
	diff --git a/include/Rivet/Projections/ParisiTensor.hh b/include/Rivet/Projections/ParisiTensor.hh
	--- a/include/Rivet/Projections/ParisiTensor.hh
	+++ b/include/Rivet/Projections/ParisiTensor.hh
	@@ -1,103 +1,100 @@
	// -- C++ --
	#ifndef RIVET_ParisiTensor_HH
	#define RIVET_ParisiTensor_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/Sphericity.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	- /**
	- @brief Calculate the Parisi event shape tensor (or linear momentum tensor).
	-
	- The Parisi event shape C and D variables are derived from the eigenvalues of
	- the linear momentum tensor
	- \f[
	- \theta^{\alpha \beta} =
	- \frac{\sum_i \frac{p_i^\alpha p_i^\beta}{\|\mathbf{p}_i\|}}
	- {\sum_i \|\mathbf{p}_i\|}
	- \f]
	- which is actually a linearized (and hence infra-red safe) version of the
	- {@link Sphericity} tensor.
	-
	- Defining the three eigenvalues of \f$\theta\f$
	- \f$ \lambda_1 \ge \lambda_2 \ge \lambda_3 \f$, with \f$ \lambda_1 + \lambda_2 + \lambda_3 = 1 \f$,
	- the C and D parameters are defined as
	- \f[
	- C = 3(\lambda_1\lambda_2 + \lambda_1\lambda_3 + \lambda_2\lambda_3)
	- \f]
	- and
	- \f[
	- D = 27 \lambda_1\lambda_2\lambda_3
	- \f]
	-
	- Internally, this Projection uses the Sphericity projection with the generalising
	- \f$r\f$ parameter set to 1.
	- */
	+ /// @brief Calculate the Parisi event shape tensor (or linear momentum tensor).
	+ ///
	+ /// The Parisi event shape C and D variables are derived from the eigenvalues of
	+ /// the linear momentum tensor
	+ /// \f[
	+ /// \theta^{\alpha \beta} =
	+ /// \frac{\sum_i \frac{p_i^\alpha p_i^\beta}{\|\mathbf{p}_i\|}}
	+ /// {\sum_i \|\mathbf{p}_i\|}
	+ /// \f]
	+ /// which is actually a linearized (and hence infra-red safe) version of the
	+ /// {@link Sphericity} tensor.
	+ ///
	+ /// Defining the three eigenvalues of \f$\theta\f$
	+ /// \f$ \lambda_1 \ge \lambda_2 \ge \lambda_3 \f$, with \f$ \lambda_1 + \lambda_2 + \lambda_3 = 1 \f$,
	+ /// the C and D parameters are defined as
	+ /// \f[
	+ /// C = 3(\lambda_1\lambda_2 + \lambda_1\lambda_3 + \lambda_2\lambda_3)
	+ /// \f]
	+ /// and
	+ /// \f[
	+ /// D = 27 \lambda_1\lambda_2\lambda_3
	+ /// \f]
	+ ///
	+ /// Internally, this Projection uses the Sphericity projection with the generalising
	+ /// \f$r\f$ parameter set to 1.
	+ ///
	class ParisiTensor : public Projection {
	public:

	/// Constructor. The provided FinalState projection must live throughout the run.
	ParisiTensor(const FinalState& fsp)
	{
	setName("ParisiTensor");
	addProjection(fsp, "FS");
	addProjection(Sphericity(fsp, 1.0), "Sphericity");
	clear();
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new ParisiTensor(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(ParisiTensor);


	protected:

	/// Perform the projection on the Event.
	void project(const Event& e);

	/// Compare with other projections.
	int compare(const Projection& p) const;


	public:

	/// Clear the projection.
	void clear();


	public:

	/// @name Access the C and D params.
	///@{
	double C() const { return _C; }
	double D() const { return _D; }
	///@}

	/// @name Access the eigenvalues of \f$\theta\f$.
	///@{
	double lambda1() const { return _lambda[0]; }
	double lambda2() const { return _lambda[1]; }
	double lambda3() const { return _lambda[2]; }
	///@}

	-
	+
	private:
	-
	+
	/// The Parisi event shape variables.
	double _C, _D;

	/// Eigenvalues.
	double _lambda[3];

	};


	}


	#endif
	diff --git a/include/Rivet/Projections/ParticleFinder.hh b/include/Rivet/Projections/ParticleFinder.hh
	--- a/include/Rivet/Projections/ParticleFinder.hh
	+++ b/include/Rivet/Projections/ParticleFinder.hh
	@@ -1,199 +1,165 @@
	// -- C++ --
	#ifndef RIVET_ParticleFinder_HH
	#define RIVET_ParticleFinder_HH

	#include "Rivet/Projection.hh"
	-#include "Rivet/Cuts.hh"

	namespace Rivet {


	/// @brief Base class for projections which return subsets of an event's particles
	class ParticleFinder : public Projection {
	public:

	/// @name Object lifetime management
	//@{

	/// Construction using Cuts object
	- ParticleFinder(const Cut& c=Cuts::open())
	+ ParticleFinder(const Cut& c=Cuts::OPEN)
	: _cuts(c), _theParticles()
	{ }

	/// Virtual destructor for inheritance
	virtual ~ParticleFinder() {}

	/// Clone on the heap.
	virtual unique_ptr<Projection> clone() const = 0;

	//@}


	/// @name Particle accessors
	//@{

	+ /// Count the final-state particles
	+ size_t size() const { return particles().size(); }
	+ /// Count the final-state particles after a Cut is applied
	+ size_t size(const Cut& c) const { return particles(c).size(); }
	+ /// Count the final-state particles after a selection functor is applied
	+ size_t size(const ParticleSelector& s) const { return particles(s).size(); }
	+
	+ /// Is this final state empty?
	+ bool empty() const { return size() == 0; }
	+ /// Is this final state empty after a Cut is applied?
	+ bool empty(const Cut& c) const { return size(c) == 0; }
	+ /// Is this final state empty after a selection functor is applied?
	+ bool empty(const ParticleSelector& s) const { return size(s) == 0; }
	+
	/// Get the final-state particles in no particular order, with no cuts.
	virtual const Particles& particles() const { return _theParticles; }

	- /// Access the projected final-state particles.
	- size_t size() const { return particles().size(); }
	+ /// @brief Get the final-state particles with selection cuts.
	+ /// @note Returns a copy rather than a reference, due to the cuts
	+ Particles particles(const Cut& c) const {
	+ return filter_select(particles(), c);
	+ // // Just return a copy of particles() if the cut is open
	+ // if (c == Cuts::open()) return particles();
	+ // // If there is a non-trivial cut...
	+ // Particles rtn;
	+ // rtn.reserve(size());
	+ // for (const Particle& p : particles())
	+ // if (c->accept(p)) rtn.push_back(p);
	+ // return rtn;
	+ }

	- /// Is this final state empty?
	- bool empty() const { return particles().empty(); }
	- /// @deprecated Is this final state empty?
	- DEPRECATED("Use empty()")
	- bool isEmpty() const { return particles().empty(); }
	-
	-
	- /// @brief Get the final-state particles, with optional cuts.
	- /// @note Returns a copy rather than a reference, due to cuts
	- /// @todo Can't this be a const Cut& arg?
	- Particles particles(const Cut& c) const {
	- // Just return a copy of particles() if the cut is open
	- if (c == Cuts::open()) return particles();
	- // If there is a non-trivial cut...
	- Particles rtn;
	- rtn.reserve(size());
	- foreach (const Particle& p, particles())
	- if (c->accept(p)) rtn.push_back(p);
	- return rtn;
	+ /// @brief Get the final-state particles with selection cuts via a functor.
	+ /// @note Returns a copy rather than a reference, due to the cuts
	+ Particles particles(const ParticleSelector& selector) const {
	+ return filter_select(particles(), selector);
	+ // Particles rtn;
	+ // rtn.reserve(size());
	+ // for (const Particle& p : particles())
	+ // if (selector(p)) rtn.push_back(p);
	+ // return rtn;
	}

	/// Get the final-state particles, ordered by supplied sorting function object.
	/// @note Returns a copy rather than a reference, due to cuts and sorting
	- /// @todo Can't this be a const Cut& arg?
	- /// @todo Use a std::function instead of typename F?
	- template <typename F>
	- Particles particles(F sorter, const Cut & c=Cuts::open()) const {
	+ Particles particles(const ParticleSorter& sorter, const Cut& c=Cuts::open()) const {
	/// @todo Will the vector be efficiently std::move'd by value through this function chain?
	return sortBy(particles(c), sorter);
	}

	/// Get the final-state particles, ordered by supplied sorting function object.
	/// @note Returns a copy rather than a reference, due to cuts and sorting
	- /// @todo Can't this be a const Cut& arg?
	- /// @todo Use a std::function instead of typename F?
	- template <typename F>
	- Particles particles(const Cut & c, F sorter) const {
	+ Particles particles(const Cut& c, const ParticleSorter& sorter) const {
	/// @todo Will the vector be efficiently std::move'd by value through this function chain?
	return sortBy(particles(c), sorter);
	}

	+ /// Get the final-state particles, ordered by a sorting functor and filtered by a selection functor.
	+ /// @note Returns a copy rather than a reference, due to cuts and sorting
	+ Particles particles(const ParticleSelector& selector, const ParticleSorter& sorter) const {
	+ /// @todo Will the vector be efficiently std::move'd by value through this function chain?
	+ return sortBy(particles(selector), sorter);
	+ }
	+
	+ /// Get the final-state particles, ordered by a sorting functor and filtered by a selection functor.
	+ /// @note Returns a copy rather than a reference, due to cuts and sorting
	+ Particles particles(const ParticleSorter& sorter, const ParticleSelector& selector) const {
	+ /// @todo Will the vector be efficiently std::move'd by value through this function chain?
	+ return sortBy(particles(selector), sorter);
	+ }
	+
	/// Get the final-state particles, ordered by decreasing \f$ p_T \f$ and with optional cuts.
	///
	/// This is a very common use-case, so is available as syntatic sugar for particles(c, cmpMomByPt).
	- Particles particlesByPt(const Cut & c=Cuts::open()) const {
	+ Particles particlesByPt(const Cut& c=Cuts::open()) const {
	return particles(c, cmpMomByPt);
	}

	+ /// Get the final-state particles, ordered by decreasing \f$ p_T \f$ and with optional cuts.
	+ ///
	+ /// This is a very common use-case, so is available as syntatic sugar for particles(f, cmpMomByPt).
	+ Particles particlesByPt(const ParticleSelector& selector) const {
	+ return particles(selector, cmpMomByPt);
	+ }
	+
	/// Get the final-state particles, ordered by decreasing \f$ p_T \f$ and with a cut on minimum \f$ p_T \f$.
	///
	/// This is a very common use-case, so is available as syntatic sugar for particles(Cuts::pT >= ptmin, cmpMomByPt).
	Particles particlesByPt(double ptmin) const {
	return particles(Cuts::pT >= ptmin, cmpMomByPt);
	}

	-
	- /// @name Little-used sorted accessors
	- /// @deprecated Use the versions with a sorter function argument
	- //@{
	-
	- /// Get the final-state particles, ordered by decreasing \f$ p \f$.
	- /// @todo Remove, since there is the templated method or sortByX methods available for these unusual cases?
	- /// @deprecated Use the version with a sorter function argument
	- DEPRECATED("Use the version with a sorter function argument")
	- Particles particlesByP(const Cut & c=Cuts::open()) const {
	- return particles(c, cmpMomByP);
	- }
	-
	- /// Get the final-state particles, ordered by decreasing \f$ E \f$.
	- /// @todo Remove, since there is the templated method or sortByX methods available for these unusual cases?
	- /// @deprecated Use the version with a sorter function argument
	- DEPRECATED("Use the version with a sorter function argument")
	- Particles particlesByE(const Cut & c=Cuts::open()) const {
	- return particles(c, cmpMomByE);
	- }
	-
	- /// Get the final-state particles, ordered by decreasing \f$ E_T \f$.
	- /// @todo Remove, since there is the templated method or sortByX methods available for these unusual cases?
	- /// @deprecated Use the version with a sorter function argument
	- DEPRECATED("Use the version with a sorter function argument")
	- Particles particlesByEt(const Cut & c=Cuts::open()) const {
	- return particles(c, cmpMomByEt);
	- }
	-
	- /// Get the final-state particles, ordered by increasing \f$ \eta \f$.
	- /// @todo Remove, since there is the templated method or sortByX methods available for these unusual cases?
	- /// @deprecated Use the version with a sorter function argument
	- DEPRECATED("Use the version with a sorter function argument")
	- Particles particlesByEta(const Cut & c=Cuts::open()) const {
	- return particles(c, cmpMomByEta);
	- }
	-
	- /// Get the final-state particles, ordered by increasing \f$ \|\eta\| \f$.
	- /// @todo Remove, since there is the templated method or sortByX methods available for these unusual cases?
	- /// @deprecated Use the version with a sorter function argument
	- DEPRECATED("Use the version with a sorter function argument")
	- Particles particlesByModEta(const Cut & c=Cuts::open()) const {
	- return particles(c, cmpMomByAbsEta);
	- }
	-
	- /// Get the final-state particles, ordered by increasing \f$ y \f$.
	- /// @todo Remove, since there is the templated method or sortByX methods available for these unusual cases?
	- /// @deprecated Use the version with a sorter function argument
	- DEPRECATED("Use the version with a sorter function argument")
	- Particles particlesByRapidity(const Cut & c=Cuts::open()) const {
	- return particles(c, cmpMomByRap);
	- }
	-
	- /// Get the final-state particles, ordered by increasing \f$ \|y\| \f$.
	- /// @todo Remove, since there is the templated method or sortByX methods available for these unusual cases?
	- /// @deprecated Use the version with a sorter function argument
	- DEPRECATED("Use the version with a sorter function argument")
	- Particles particlesByModRapidity(const Cut & c=Cuts::open()) const {
	- return particles(c, cmpMomByAbsRap);
	- }
	-
	- //@}
	-
	//@}


	/// @todo Replace with cuts() accessor
	///virtual Cut cuts() const { return _cuts; }


	/// @name For JetAlg compatibility
	//@{

	typedef Particle entity_type;
	typedef Particles collection_type;

	/// Template-usable interface common to JetAlg
	const collection_type& entities() const {
	return particles();
	}

	//@}


	protected:

	/// Apply the projection to the event
	virtual void project(const Event& e) = 0;

	/// Compare projections
	virtual int compare(const Projection& p) const;

	/// The kinematic cuts cuts
	Cut _cuts;

	/// The found particles returned by the particles() methods
	Particles _theParticles;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/PartonicTops.hh b/include/Rivet/Projections/PartonicTops.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Projections/PartonicTops.hh
	@@ -0,0 +1,107 @@
	+// -- C++ --
	+#ifndef RIVET_PartonicTops_HH
	+#define RIVET_PartonicTops_HH
	+
	+#include "Rivet/Projections/ParticleFinder.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Convenience finder of partonic top quarks
	+ ///
	+ /// @warning Requires there to be tops in the event record. A fiducial pseudo-top
	+ /// analysis approach is strongly recommended instead of this.
	+ class PartonicTops : public ParticleFinder {
	+ public:
	+
	+
	+ /// @brief Enum for categorising top quark decay modes
	+ ///
	+ /// More specifically, the decay mode of the W from the top. We presume top decay to a W and b quark.
	+ enum DecayMode { ELECTRON, MUON, TAU, E_MU, E_MU_TAU, HADRONIC, ALL };
	+
	+
	+ /// @name Constructors
	+ //@{
	+
	+ /// Constructor optionally taking cuts object
	+ PartonicTops(const Cut& c=Cuts::OPEN)
	+ : ParticleFinder(c), _decaymode(ALL), _emu_from_prompt_tau(true), _include_hadronic_taus(false)
	+ { }
	+
	+ /// Constructor taking decay mode details (and an optional cuts object)
	+ PartonicTops(DecayMode decaymode, bool emu_from_prompt_tau=true, bool include_hadronic_taus=false, const Cut& c=Cuts::OPEN)
	+ : ParticleFinder(c), _decaymode(decaymode),
	+ _emu_from_prompt_tau(emu_from_prompt_tau), _include_hadronic_taus(include_hadronic_taus)
	+ { }
	+
	+ /// Constructor taking decay mode details (and an optional cuts object)
	+ PartonicTops(DecayMode decaymode, const Cut& c, bool emu_from_prompt_tau=true, bool include_hadronic_taus=false)
	+ : ParticleFinder(c), _decaymode(decaymode),
	+ _emu_from_prompt_tau(emu_from_prompt_tau), _include_hadronic_taus(include_hadronic_taus)
	+ { }
	+
	+
	+ /// Clone on the heap.
	+ DEFAULT_RIVET_PROJ_CLONE(PartonicTops);
	+
	+ //@}
	+
	+
	+ /// Access to the found partonic tops
	+ const Particles& tops() const { return _theParticles; }
	+
	+
	+ /// Clear the projection
	+ void clear() {
	+ _theParticles.clear();
	+ }
	+
	+
	+ protected:
	+
	+ /// Apply the projection on the supplied event.
	+ void project(const Event& event) {
	+ // Find partonic tops
	+ _theParticles = filter_select(event.allParticles(_cuts), lastParticleWith(isTop));
	+ // Filtering by decay mode
	+ if (_decaymode != ALL) {
	+ const auto fn = [&](const Particle& t) {
	+ const Particles descendants = t.allDescendants();
	+ const bool prompt_e = any(descendants, [&](const Particle& p){ return p.abspid() == PID::ELECTRON && p.isPrompt(_emu_from_prompt_tau); });
	+ const bool prompt_mu = any(descendants, [&](const Particle& p){ return p.abspid() == PID::MUON && p.isPrompt(_emu_from_prompt_tau); });
	+ if (prompt_e && (_decaymode == ELECTRON \|\| _decaymode == E_MU \|\| _decaymode == E_MU_TAU)) return true;
	+ if (prompt_mu && (_decaymode == MUON \|\| _decaymode == E_MU \|\| _decaymode == E_MU_TAU)) return true;
	+ const bool prompt_tau = any(descendants, [&](const Particle& p){ return p.abspid() == PID::TAU && p.isPrompt(); });
	+ const bool prompt_hadronic_tau = any(descendants, [&](const Particle& p){ return p.abspid() == PID::TAU && p.isPrompt() && none(p.children(), isChargedLepton); });
	+ if (prompt_tau && (_decaymode == TAU \|\| _decaymode == E_MU_TAU)) return (_include_hadronic_taus \|\| !prompt_hadronic_tau);
	+ if (_decaymode == HADRONIC && (!prompt_e && !prompt_mu && (!prompt_tau \|\| (_include_hadronic_taus && prompt_hadronic_tau)))) return true; //< logical hairiness...
	+ return false;
	+ };
	+ ifilter_select(_theParticles, fn);
	+ }
	+ }
	+
	+
	+ /// Compare projections.
	+ int compare(const Projection& p) const {
	+ const PartonicTops& other = dynamic_cast<const PartonicTops&>(p);
	+ return cmp(_cuts, other._cuts) \|\| cmp(_decaymode, other._decaymode) \|\|
	+ cmp(_emu_from_prompt_tau, other._emu_from_prompt_tau) \|\|
	+ cmp(_include_hadronic_taus, other._include_hadronic_taus);
	+ }
	+
	+
	+ private:
	+
	+ DecayMode _decaymode;
	+
	+ bool _emu_from_prompt_tau, _include_hadronic_taus;
	+
	+ };
	+
	+
	+}
	+
	+
	+#endif
	diff --git a/include/Rivet/Projections/PrimaryHadrons.hh b/include/Rivet/Projections/PrimaryHadrons.hh
	--- a/include/Rivet/Projections/PrimaryHadrons.hh
	+++ b/include/Rivet/Projections/PrimaryHadrons.hh
	@@ -1,56 +1,54 @@
	// -- C++ --
	#ifndef RIVET_PrimaryHadrons_HH
	#define RIVET_PrimaryHadrons_HH

	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	/// @brief Project out the first hadrons from hadronisation.
	///
	/// @todo Also be able to return taus? Prefer a separate tau finder.
	/// @todo This assumes that the primary hadrons are unstable... should we also look for stable primary hadrons?
	class PrimaryHadrons : public FinalState {
	public:

	/// @name Constructors and destructors.
	//@{

	/// Constructor with cuts argument
	PrimaryHadrons(const Cut& c=Cuts::open()) {
	setName("PrimaryHadrons");
	addProjection(UnstableFinalState(c), "UFS");
	}

	/// Constructor with specification of the minimum and maximum pseudorapidity
	/// \f$ \eta \f$ and the min \f$ p_T \f$ (in GeV).
	PrimaryHadrons(double mineta, double maxeta, double minpt=0.0*GeV) {
	setName("PrimaryHadrons");
	addProjection(UnstableFinalState(Cuts::etaIn(mineta, maxeta) && Cuts::pT > minpt), "UFS");
	}


	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new PrimaryHadrons(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(PrimaryHadrons);

	//@}


	protected:

	/// Apply the projection to the event.
	virtual void project(const Event& e);

	};


	}


	#endif
	diff --git a/include/Rivet/Projections/PromptFinalState.hh b/include/Rivet/Projections/PromptFinalState.hh
	--- a/include/Rivet/Projections/PromptFinalState.hh
	+++ b/include/Rivet/Projections/PromptFinalState.hh
	@@ -1,66 +1,66 @@
	// -- C++ --
	#ifndef RIVET_PromptFinalState_HH
	#define RIVET_PromptFinalState_HH

	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Find final state particles directly connected to the hard process.
	///
	/// The definition of "prompt" used in Rivet is that from high-scale physics, i.e.
	/// particles directly connected to the hard process in an interaction, regardless
	/// of realistic reconstructibility of displaced vertices, etc. By construction
	/// hadrons cannot be considered prompt as they will be colour connected to other
	/// parts of the event through non-perturbative effects: this projection can
	/// return electrons, muons, photons, and exotic particles which do not have a
	/// hadron in their post-hadronization ancestor chain. Flags exist to choose
	/// whether intermediate tau or muon decays invalidate a particle's promptness.
	///
	/// @todo Decide how to treat brem photons off prompt leptons -- are they also prompt? "Decay" does not change the lepton PID...
	class PromptFinalState : public FinalState {
	public:

	/// @name Constructors
	//@{
	- // Final State
	- PromptFinalState(const FinalState& fsp);

	- /// Cut constructor.
	- PromptFinalState(const Cut & c);
	+ // Constructor from a final state.
	+ PromptFinalState(const FinalState& fsp, bool accepttaudecays=false, bool acceptmudecays=false);
	+
	+ /// Constructor from a Cut.
	+ PromptFinalState(const Cut& c, bool accepttaudecays=false, bool acceptmudecays=false);
	+
	+ // /// Constructor from a Cut and optional FinalState.
	+ // PromptFinalState(const Cut& c, const FinalState& fsp=FinalState(), bool accepttaudecays, bool acceptmudecays);

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new PromptFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(PromptFinalState);
	+
	//@}

	/// Accept particles from decays of prompt muons as themselves being prompt?
	void acceptMuonDecays(bool acc=true) { _acceptMuDecays = acc; }
	/// Accept particles from decays of prompt taus as themselves being prompt?
	void acceptTauDecays(bool acc=true) { _acceptTauDecays = acc; }

	- /// Decide if a given particle is prompt based on set definition flags
	- /// @todo Move into ParticleUtils / MCUtils
	- /// @note This one doesn't make any judgements about final-stateness
	- bool isPrompt(const Particle& p) const;

	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;

	+
	private:

	bool _acceptMuDecays, _acceptTauDecays;

	};

	}


	#endif
	diff --git a/include/Rivet/Projections/SmearedJets.hh b/include/Rivet/Projections/SmearedJets.hh
	--- a/include/Rivet/Projections/SmearedJets.hh
	+++ b/include/Rivet/Projections/SmearedJets.hh
	@@ -1,155 +1,156 @@
	// -- C++ --
	#ifndef RIVET_SmearedJets_HH
	#define RIVET_SmearedJets_HH

	#include "Rivet/Jet.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/JetAlg.hh"
	#include "Rivet/Tools/SmearingFunctions.hh"
	#include <functional>

	namespace Rivet {


	/// Wrapper projection for smearing {@link Jet}s with detector resolutions and efficiencies
	/// @todo Chain constructors?
	class SmearedJets : public JetAlg {
	public:

	/// @name Constructors etc.
	//@{

	/// @brief Constructor with efficiency and smearing function args
	/// The jet reconstruction efficiency is mandatory; the smearing and tagging functions are optional
	template <typename J2JFN>
	SmearedJets(const JetAlg& ja,
	const J2JFN& jetSmearFn)
	: SmearedJets(ja, jetSmearFn, JET_BTAG_PERFECT, JET_CTAG_PERFECT, JET_EFF_ONE)
	{ }


	/// @brief Constructor with efficiency and smearing function args
	/// The jet reconstruction efficiency is mandatory; the smearing and tagging functions are optional
	template <typename J2JFN, typename J2DFN>
	SmearedJets(const JetAlg& ja,
	const J2JFN& jetSmearFn,
	const J2DFN& bTagEffFn)
	: SmearedJets(ja, jetSmearFn, bTagEffFn, JET_CTAG_PERFECT, JET_EFF_ONE)
	{ }


	/// @brief Constructor with efficiency and smearing function args
	/// The jet reconstruction efficiency is mandatory; the smearing and tagging functions are optional
	template <typename J2JFN, typename J2DFNa, typename J2DFNb>
	SmearedJets(const JetAlg& ja,
	const J2JFN& jetSmearFn,
	const J2DFNa& bTagEffFn,
	const J2DFNb& cTagEffFn)
	: SmearedJets(ja, jetSmearFn, bTagEffFn, cTagEffFn, JET_EFF_ONE)
	{ }


	/// @brief Constructor with efficiency and smearing function args
	/// The jet reconstruction efficiency is mandatory; the smearing and tagging functions are optional
	template <typename J2JFN, typename J2DFNa, typename J2DFNb, typename J2DFNc>
	SmearedJets(const JetAlg& ja,
	const J2JFN& jetSmearFn,
	const J2DFNa& bTagEffFn,
	const J2DFNb& cTagEffFn,
	const J2DFNc& jetEffFn)
	: _jetEffFn(jetEffFn), _bTagEffFn(bTagEffFn), _cTagEffFn(cTagEffFn), _jetSmearFn(jetSmearFn)
	{
	setName("SmearedJets");
	addProjection(ja, "TruthJets");
	}


	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new SmearedJets(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(SmearedJets);

	//@}


	/// Compare to another SmearedJets
	int compare(const Projection& p) const {
	const SmearedJets& other = dynamic_cast<const SmearedJets&>(p);
	- if (_mkhash(_jetEffFn) == 0) return UNDEFINED;
	- if (_mkhash(_bTagEffFn) == 0) return UNDEFINED;
	- if (_mkhash(_cTagEffFn) == 0) return UNDEFINED;
	- if (_mkhash(_jetSmearFn) == 0) return UNDEFINED;
	+ if (get_address(_jetEffFn) == 0) return UNDEFINED;
	+ if (get_address(_bTagEffFn) == 0) return UNDEFINED;
	+ if (get_address(_cTagEffFn) == 0) return UNDEFINED;
	+ if (get_address(_jetSmearFn) == 0) return UNDEFINED;
	+ MSG_TRACE("Eff hashes = " << get_address(_jetEffFn) << "," << get_address(other._jetEffFn) << "; " <<
	+ "smear hashes = " << get_address(_jetSmearFn) << "," << get_address(other._jetSmearFn) << "; " <<
	+ "b-tag hashes = " << get_address(_bTagEffFn) << "," << get_address(other._bTagEffFn) << "; " <<
	+ "c-tag hashes = " << get_address(_cTagEffFn) << "," << get_address(other._cTagEffFn));
	return
	- cmp(_mkhash(_jetEffFn), _mkhash(other._jetEffFn)) \|\| cmp(_mkhash(_jetSmearFn), _mkhash(other._jetSmearFn)) \|\|
	- cmp(_mkhash(_bTagEffFn), _mkhash(other._bTagEffFn)) \|\| cmp(_mkhash(_cTagEffFn), _mkhash(other._cTagEffFn));
	+ mkPCmp(other, "TruthJets") \|\|
	+ cmp(get_address(_jetEffFn), get_address(other._jetEffFn)) \|\|
	+ cmp(get_address(_jetSmearFn), get_address(other._jetSmearFn)) \|\|
	+ cmp(get_address(_bTagEffFn), get_address(other._bTagEffFn)) \|\|
	+ cmp(get_address(_cTagEffFn), get_address(other._cTagEffFn));
	}


	/// Perform the jet finding & smearing calculation
	void project(const Event& e) {
	// Copying and filtering
	- const Jets& truthjets = applyProjection<JetAlg>(e, "TruthJets").jetsByPt();
	+ const Jets& truthjets = apply<JetAlg>(e, "TruthJets").jetsByPt();
	_recojets.clear(); _recojets.reserve(truthjets.size());
	- foreach (const Jet& j, truthjets) {
	- const double jeff = (_jetEffFn) ? _jetEffFn(j) : 1;
	+ for (const Jet& j : truthjets) {
	+ // Efficiency sampling
	+ const double jeff = _jetEffFn ? _jetEffFn(j) : 1;
	MSG_DEBUG("Efficiency of jet " << j.mom() << " = " << 100*jeff << "%");
	- if (jeff == 0) continue; //< no need to roll expensive dice
	- if (jeff == 1 \|\| jeff < rand01()) {
	- _recojets.push_back(_jetSmearFn ? _jetSmearFn(j) : j); //< smearing
	- }
	+ MSG_DEBUG("Efficiency of jet with mom=" << j.mom()/GeV << " GeV, "
	+ << "pT=" << j.pT()/GeV << ", eta=" << j.eta() << " : " << 100*jeff << "%");
	+ if (jeff <= 0) continue; //< no need to roll expensive dice (and we deal with -ve probabilities, just in case)
	+ if (jeff < 1 && rand01() > jeff) continue; //< roll dice (and deal with >1 probabilities, just in case)
	+ // Kinematic smearing
	+ Jet sj = _jetSmearFn ? _jetSmearFn(j) : j;
	+ MSG_DEBUG("Jet smearing from " << j.mom() << " to " << sj.mom());
	+ // Re-add constituents & tags if (we assume accidentally) they were lost by the smearing function
	+ if (sj.particles().empty() && !j.particles().empty()) sj.particles() = j.particles();
	+ if (sj.tags().empty() && !j.tags().empty()) sj.tags() = j.tags();
	+ _recojets.push_back(sj);
	}
	- // Tagging efficiencies
	- foreach (Jet& j, _recojets) {
	- const double beff = (_bTagEffFn) ? _bTagEffFn(j) : 1;
	- const bool btag = beff == 1 \|\| (beff != 0 && beff < rand01());
	+ // Apply tagging efficiencies, using smeared kinematics as input to the tag eff functions
	+ for (Jet& j : _recojets) {
	+ // Decide whether or not there should be a b-tag on this jet
	+ const double beff = _bTagEffFn ? _bTagEffFn(j) : j.bTagged();
	+ const bool btag = beff == 1 \|\| (beff != 0 && rand01() < beff);
	// Remove b-tags if needed, and add a dummy one if needed
	if (!btag && j.bTagged()) j.tags().erase(std::remove_if(j.tags().begin(), j.tags().end(), hasBottom), j.tags().end());
	- if (btag && !j.bTagged()) j.tags().push_back(Particle(PID::BQUARK, j.mom()));
	- const double ceff = (_cTagEffFn) ? _cTagEffFn(j) : 1;
	- const bool ctag = ceff == 1 \|\| (ceff != 0 && ceff < rand01());
	+ if (btag && !j.bTagged()) j.tags().push_back(Particle(PID::BQUARK, j.mom())); ///< @todo Or could use the/an actual clustered b-quark momentum?
	+ // Decide whether or not there should be a c-tag on this jet
	+ const double ceff = _cTagEffFn ? _cTagEffFn(j) : j.cTagged();
	+ const bool ctag = ceff == 1 \|\| (ceff != 0 && rand01() < beff);
	// Remove c-tags if needed, and add a dummy one if needed
	if (!ctag && j.cTagged()) j.tags().erase(std::remove_if(j.tags().begin(), j.tags().end(), hasCharm), j.tags().end());
	- if (ctag && !j.cTagged()) j.tags().push_back(Particle(PID::CQUARK, j.mom()));
	+ if (ctag && !j.cTagged()) j.tags().push_back(Particle(PID::CQUARK, j.mom())); ///< @todo As above... ?
	}
	}


	/// Return the full jet list for the JetAlg methods to use
	Jets _jets() const { return _recojets; }


	/// Reset the projection. Smearing functions will be unchanged.
	void reset() { _recojets.clear(); }


	private:

	- /// Make a hash integer from the provided wrapped Jet -> double function
	- size_t _mkhash(const std::function<double(const Jet&)>& fn) const {
	- const size_t rtn = reinterpret_cast<size_t>(fn.target<double(*)(const Jet&)>());
	- MSG_TRACE("J2D hash = " << rtn);
	- return rtn;
	- }
	-
	- /// Make a hash integer from the provided wrapped Jet -> Jet function
	- size_t _mkhash(const std::function<Jet(const Jet&)>& fn) const {
	- const size_t rtn = reinterpret_cast<size_t>(fn.target<Jet(*)(const Jet&)>());
	- MSG_TRACE("J2J hash = " << rtn);
	- return rtn;
	- }
	-
	-
	Jets _recojets;

	/// Stored efficiency functions
	std::function<double(const Jet&)> _jetEffFn, _bTagEffFn, _cTagEffFn;
	+
	/// Stored smearing function
	std::function<Jet(const Jet&)> _jetSmearFn;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/SmearedMET.hh b/include/Rivet/Projections/SmearedMET.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Projections/SmearedMET.hh
	@@ -0,0 +1,90 @@
	+// -- C++ --
	+#ifndef RIVET_SmearedMET_HH
	+#define RIVET_SmearedMET_HH
	+
	+#include "Rivet/Projection.hh"
	+#include "Rivet/Projections/MissingMomentum.hh"
	+#include "Rivet/Tools/SmearingFunctions.hh"
	+#include <functional>
	+
	+namespace Rivet {
	+
	+
	+ /// Wrapper projection for smearing missing (transverse) energy/momentum with detector resolutions
	+ class SmearedMET : public Projection {
	+ public:
	+
	+ /// @name Constructors etc.
	+ //@{
	+
	+ /// @brief Constructor from a MissingMomentum projection and a smearing function
	+ ///
	+ /// Smearing function maps a 3-vector MET and scalar SET to a new MET 3-vector: f(V3, double) -> V3
	+ template <typename V2VFN>
	+ SmearedMET(const MissingMomentum& mm, const V2VFN& metSmearFn)
	+ : _metSmearFn(metSmearFn)
	+ {
	+ setName("SmearedMET");
	+ addProjection(mm, "TruthMET");
	+ }
	+
	+ /// @brief Constructor from a Cut (on the particles used to determine missing momentum) and a smearing function
	+ template <typename V2VFN>
	+ SmearedMET(const V2VFN& metSmearFn, const Cut& cut)
	+ : _metSmearFn(metSmearFn)
	+ {
	+ setName("SmearedMET");
	+ addProjection(MissingMomentum(cut), "TruthMET");
	+ }
	+
	+
	+ /// Clone on the heap.
	+ DEFAULT_RIVET_PROJ_CLONE(SmearedMET);
	+
	+ //@}
	+
	+
	+ /// Compare to another SmearedMET
	+ int compare(const Projection& p) const {
	+ const SmearedMET& other = dynamic_cast<const SmearedMET&>(p);
	+ if (get_address(_metSmearFn) == 0) return UNDEFINED;
	+ MSG_TRACE("Smear hashes = " << get_address(_metSmearFn) << "," << get_address(other._metSmearFn));
	+ return mkPCmp(other, "TruthMET") \|\| cmp(get_address(_metSmearFn), get_address(other._metSmearFn));
	+ }
	+
	+
	+ /// Perform the MET finding & smearing calculation
	+ void project(const Event& e) {
	+ const auto& mm = apply<MissingMomentum>(e, "TruthMET");
	+ _vet = mm.vectorEt();
	+ if (_metSmearFn) _vet = _metSmearFn(_vet, mm.scalarEt()); //< smearing
	+ }
	+
	+
	+ /// The vector-summed visible transverse energy in the event, as a 3-vector with z=0
	+ /// @note Reverse this vector with operator- to get the missing ET vector.
	+ const Vector3& vectorEt() const { return _vet; }
	+
	+ /// The vector-summed missing transverse energy in the event.
	+ double missingEt() const { return vectorEt().mod(); }
	+ /// Alias for missingEt
	+ double met() const { return missingEt(); }
	+
	+
	+ /// Reset the projection. Smearing functions will be unchanged.
	+ void reset() { }
	+
	+
	+ private:
	+
	+ Vector3 _vet;
	+
	+ /// Stored smearing function
	+ std::function<Vector3(const Vector3&, double)> _metSmearFn;
	+
	+ };
	+
	+
	+}
	+
	+#endif
	diff --git a/include/Rivet/Projections/SmearedParticles.hh b/include/Rivet/Projections/SmearedParticles.hh
	--- a/include/Rivet/Projections/SmearedParticles.hh
	+++ b/include/Rivet/Projections/SmearedParticles.hh
	@@ -1,106 +1,97 @@
	// -- C++ --
	#ifndef RIVET_SmearedParticles_HH
	#define RIVET_SmearedParticles_HH

	#include "Rivet/Particle.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/ParticleFinder.hh"
	#include "Rivet/Tools/SmearingFunctions.hh"
	#include <functional>

	namespace Rivet {


	/// Wrapper projection for smearing {@link Jet}s with detector resolutions and efficiencies
	class SmearedParticles : public ParticleFinder {
	public:

	/// @name Constructors etc.
	//@{

	/// @brief Constructor with efficiency and smearing function args
	template <typename P2DFN>
	SmearedParticles(const ParticleFinder& pf,
	const P2DFN& effFn,
	const Cut& c=Cuts::open())
	: SmearedParticles(pf, effFn, PARTICLE_SMEAR_IDENTITY, c)
	{ }


	/// @brief Constructor with efficiency and smearing function args
	template <typename P2DFN, typename P2PFN>
	SmearedParticles(const ParticleFinder& pf,
	const P2DFN& effFn, const P2PFN& smearFn,
	const Cut& c=Cuts::open())
	: ParticleFinder(c),
	_effFn(effFn), _smearFn(smearFn)
	{
	setName("SmearedParticles");
	addProjection(pf, "TruthParticles");
	}


	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new SmearedParticles(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(SmearedParticles);

	//@}


	/// Compare to another SmearedParticles
	int compare(const Projection& p) const {
	const SmearedParticles& other = dynamic_cast<const SmearedParticles&>(p);
	- if (_mkhash(_effFn) == 0) return UNDEFINED;
	- if (_mkhash(_smearFn) == 0) return UNDEFINED;
	- return cmp(_mkhash(_effFn), _mkhash(other._effFn)) \|\| cmp(_mkhash(_smearFn), _mkhash(other._smearFn));
	+ if (get_address(_effFn) == 0) return UNDEFINED;
	+ if (get_address(_smearFn) == 0) return UNDEFINED;
	+ MSG_TRACE("Eff hashes = " << get_address(_effFn) << "," << get_address(other._effFn) << "; " <<
	+ "smear hashes = " << get_address(_smearFn) << "," << get_address(other._smearFn));
	+ return mkPCmp(other, "TruthParticles") \|\|
	+ cmp(get_address(_effFn), get_address(other._effFn)) \|\|
	+ cmp(get_address(_smearFn), get_address(other._smearFn));
	}


	/// Perform the particle finding & smearing calculation
	void project(const Event& e) {
	// Copying and filtering
	- const Particles& truthparticles = applyProjection<ParticleFinder>(e, "TruthParticles").particlesByPt();
	+ const Particles& truthparticles = apply<ParticleFinder>(e, "TruthParticles").particlesByPt();
	_theParticles.clear(); _theParticles.reserve(truthparticles.size());
	- foreach (const Particle& p, truthparticles) {
	- const double peff = (_effFn) ? _effFn(p) : 1;
	- MSG_DEBUG("Efficiency of particle " << p.mom() << " = " << 100*peff << "%");
	- if (peff == 0) continue; //< no need to roll expensive dice
	- if (peff == 1 \|\| peff < rand01()) {
	- _theParticles.push_back(_smearFn ? _smearFn(p) : p); //< smearing
	- }
	+ for (const Particle& p : truthparticles) {
	+ const double peff = _effFn ? _effFn(p) : 1;
	+ MSG_DEBUG("Efficiency of particle with pid=" << p.pid()
	+ << ", mom=" << p.mom()/GeV << " GeV, "
	+ << "pT=" << p.pT()/GeV << ", eta=" << p.eta()
	+ << " : " << 100*peff << "%");
	+ if (peff <= 0) continue; //< no need to roll expensive dice (and we deal with -ve probabilities, just in case)
	+ if (peff < 1 && rand01() > peff) continue; //< roll dice (and deal with >1 probabilities, just in case)
	+ _theParticles.push_back(_smearFn ? _smearFn(p) : p); //< smearing
	}
	}


	/// Reset the projection. Smearing functions will be unchanged.
	void reset() { _theParticles.clear(); }


	private:

	- /// Make a hash integer from the provided wrapped Particle -> double function
	- size_t _mkhash(const std::function<double(const Particle&)>& fn) const {
	- const size_t rtn = reinterpret_cast<size_t>(fn.target<double(*)(const Particle&)>());
	- MSG_TRACE("P2D hash = " << rtn);
	- return rtn;
	- }
	-
	- /// Make a hash integer from the provided wrapped Particle -> Particle function
	- size_t _mkhash(const std::function<Particle(const Particle&)>& fn) const {
	- const size_t rtn = reinterpret_cast<size_t>(fn.target<Particle(*)(const Particle&)>());
	- MSG_TRACE("P2P hash = " << rtn);
	- return rtn;
	- }
	-
	/// Stored efficiency function
	std::function<double(const Particle&)> _effFn;
	+
	/// Stored smearing function
	std::function<Particle(const Particle&)> _smearFn;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/Smearing.hh b/include/Rivet/Projections/Smearing.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Projections/Smearing.hh
	@@ -0,0 +1,11 @@
	+// -- C++ --
	+#ifndef RIVET_Smearing_HH
	+#define RIVET_Smearing_HH
	+
	+/// @file Smearing.hh Convenience include of all Smearing projection headers
	+
	+#include "Rivet/Projections/SmearedParticles.hh"
	+#include "Rivet/Projections/SmearedJets.hh"
	+#include "Rivet/Projections/SmearedMET.hh"
	+
	+#endif
	diff --git a/include/Rivet/Projections/Sphericity.hh b/include/Rivet/Projections/Sphericity.hh
	--- a/include/Rivet/Projections/Sphericity.hh
	+++ b/include/Rivet/Projections/Sphericity.hh
	@@ -1,161 +1,163 @@
	// -- C++ --
	#ifndef RIVET_Sphericity_HH
	#define RIVET_Sphericity_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/AxesDefinition.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Event.hh"
	-
	+#include "Rivet/Jet.fhh"

	namespace Rivet {

	- /**
	- @brief Calculate the sphericity event shape.
	-
	- The sphericity tensor (or quadratic momentum tensor) is defined as
	- \f[
	- S^{\alpha \beta} = \frac{\sum_i p_i^\alpha p_i^\beta}{\sum_i \|\mathbf{p}_i\|^2}
	- \f],
	- where the Greek indices are spatial components and the Latin indices are used
	- for sums over particles. From this, the sphericity, aplanarity and planarity can be
	- calculated by combinations of eigenvalues.
	-
	- Defining the three eigenvalues
	- \f$ \lambda_1 \ge \lambda_2 \ge \lambda_3 \f$, with \f$ \lambda_1 + \lambda_2 + \lambda_3 = 1 \f$,
	- the sphericity is
	- \f[
	- S = \frac{3}{2} (\lambda_2 + \lambda_3)
	- \f]
	-
	- The aplanarity is \f$ A = \frac{3}{2}\lambda_3 \f$ and the planarity
	- is \f$ P = \frac{2}{3}(S-2A) = \lambda_2 - \lambda_3 \f$. The eigenvectors define a
	- set of spatial axes comparable with the thrust axes, but more sensitive to
	- high momentum particles due to the quadratic sensitivity of the tensor to
	- the particle momenta.
	-
	- Since the sphericity is quadratic in the particle momenta, it is not an
	- infrared safe observable in perturbative QCD. This can be fixed by adding
	- a regularizing power of \f$r\f$ to the definition:
	- \f[
	- S^{\alpha \beta} =
	- \frac{\sum_i \|\mathbf{p}_i\|^{r-2} p_i^\alpha p_i^\beta}
	- {\sum_i \|\mathbf{p}_i\|^r}
	- \f]
	-
	- \f$r\f$ is available as a constructor argument on this class and will be
	- taken into account by the Cmp<Projection> operation, so a single analysis
	- can use several sphericity projections with different \f$r\f$ values without
	- fear of a clash.
	- */
	+
	+
	+ /// @brief Calculate the sphericity event shape.
	+ ///
	+ /// The sphericity tensor (or quadratic momentum tensor) is defined as
	+ /// \f[
	+ /// S^{\alpha \beta} = \frac{\sum_i p_i^\alpha p_i^\beta}{\sum_i \|\mathbf{p}_i\|^2}
	+ /// \f],
	+ /// where the Greek indices are spatial components and the Latin indices are used
	+ /// for sums over particles. From this, the sphericity, aplanarity and planarity can be
	+ /// calculated by combinations of eigenvalues.
	+ ///
	+ /// Defining the three eigenvalues
	+ /// \f$ \lambda_1 \ge \lambda_2 \ge \lambda_3 \f$, with \f$ \lambda_1 + \lambda_2 + \lambda_3 = 1 \f$,
	+ /// the sphericity is
	+ /// \f[
	+ /// S = \frac{3}{2} (\lambda_2 + \lambda_3)
	+ /// \f]
	+ ///
	+ /// The aplanarity is \f$ A = \frac{3}{2}\lambda_3 \f$ and the planarity
	+ /// is \f$ P = \frac{2}{3}(S-2A) = \lambda_2 - \lambda_3 \f$. The eigenvectors define a
	+ /// set of spatial axes comparable with the thrust axes, but more sensitive to
	+ /// high momentum particles due to the quadratic sensitivity of the tensor to
	+ /// the particle momenta.
	+ ///
	+ /// Since the sphericity is quadratic in the particle momenta, it is not an
	+ /// infrared safe observable in perturbative QCD. This can be fixed by adding
	+ /// a regularizing power of \f$r\f$ to the definition:
	+ /// \f[
	+ /// S^{\alpha \beta} =
	+ /// \frac{\sum_i \|\mathbf{p}_i\|^{r-2} p_i^\alpha p_i^\beta}
	+ /// {\sum_i \|\mathbf{p}_i\|^r}
	+ /// \f]
	+ ///
	+ /// \f$r\f$ is available as a constructor argument on this class and will be
	+ /// taken into account by the Cmp<Projection> operation, so a single analysis
	+ /// can use several sphericity projections with different \f$r\f$ values without
	+ /// fear of a clash.
	+ ///
	class Sphericity : public AxesDefinition {
	-
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	Sphericity(double rparam=2.0): _regparam(rparam){}

	Sphericity(const FinalState& fsp, double rparam=2.0);

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new Sphericity(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(Sphericity);

	//@}


	protected:

	/// Perform the projection on the Event
	void project(const Event& e);

	/// Compare with other projections
	int compare(const Projection& p) const;

	+
	public:

	/// Reset the projection
	void clear();

	/// @name Access the event shapes by name
	- /// @{
	+ //@{
	/// Sphericity
	double sphericity() const { return 3.0 / 2.0 * (lambda2() + lambda3()); }
	- /// Transverse Sphericity
	+ /// Transverse sphericity
	double transSphericity() const { return 2.0 * lambda2() / ( lambda1() + lambda2() ); }
	/// Planarity
	double planarity() const { return 2 * (sphericity() - 2 * aplanarity()) / 3.0; }
	/// Aplanarity
	double aplanarity() const { return 3 / 2.0 * lambda3(); }
	- /// @}
	+ //@}
	+

	/// @name Access the sphericity basis vectors
	- /// @{
	+ //@{
	/// Sphericity axis
	const Vector3& sphericityAxis() const { return _sphAxes[0]; }
	/// Sphericity major axis
	const Vector3& sphericityMajorAxis() const { return _sphAxes[1]; }
	/// Sphericity minor axis
	const Vector3& sphericityMinorAxis() const { return _sphAxes[2]; }
	- /// @}
	+ //@}

	- ///@{ AxesDefinition axis accessors.
	+
	+ /// @name AxesDefinition axis accessors
	+ //@{
	const Vector3& axis1() const { return sphericityAxis(); }
	const Vector3& axis2() const { return sphericityMajorAxis(); }
	const Vector3& axis3() const { return sphericityMinorAxis(); }
	- ///@}
	+ //@}


	/// @name Access the momentum tensor eigenvalues
	- /// @{
	+ //@{
	double lambda1() const { return _lambdas[0]; }
	double lambda2() const { return _lambdas[1]; }
	double lambda3() const { return _lambdas[2]; }
	- /// @}
	+ //@}


	/// @name Direct methods
	/// Ways to do the calculation directly, without engaging the caching system
	//@{
	-
	+
	/// Manually calculate the sphericity, without engaging the caching system
	void calc(const FinalState& fs);

	/// Manually calculate the sphericity, without engaging the caching system
	- void calc(const vector<Particle>& fsparticles);
	+ void calc(const Particles& particles);

	/// Manually calculate the sphericity, without engaging the caching system
	- void calc(const vector<FourMomentum>& fsmomenta);
	+ void calc(const Jets& jets);

	/// Manually calculate the sphericity, without engaging the caching system
	- void calc(const vector<Vector3>& fsmomenta);
	+ void calc(const vector<FourMomentum>& momenta);
	+
	+ /// @brief Manually calculate the sphericity, without engaging the caching system
	+ ///
	+ /// This one actually does the calculation
	+ void calc(const vector<Vector3>& momenta);

	//@}


	+ private:

	- private:
	/// Eigenvalues.
	vector<double> _lambdas;

	/// Sphericity axes.
	vector<Vector3> _sphAxes;

	/// Regularizing parameter, used to force infra-red safety.
	const double _regparam;

	- private:
	+ };

	- /// Actually do the calculation
	- void _calcSphericity(const vector<Vector3>& fsmomenta);
	-
	- };

	}

	-
	#endif
	diff --git a/include/Rivet/Projections/Spherocity.hh b/include/Rivet/Projections/Spherocity.hh
	--- a/include/Rivet/Projections/Spherocity.hh
	+++ b/include/Rivet/Projections/Spherocity.hh
	@@ -1,136 +1,134 @@
	// -- C++ --
	#ifndef RIVET_Spherocity_HH
	#define RIVET_Spherocity_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/AxesDefinition.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	/// @brief Get the transverse spherocity scalars for hadron-colliders.
	///
	/// @author Holger Schulz
	///
	/// The scalar (minimum) transverse spherocity is defined as
	/// \f[
	/// S = \frac{\pi^2}{4} \mathrm{min}_{\vec{n}_\perp} \left( \frac{\sum_i \left\|\vec{p}_{\perp,i} \times \vec{n}_\perp \right\|}{\sum_i \|\vec{p}_{\perp,i}\|} \right)^2
	/// \f],
	/// with the direction of the unit vector \f$ \vec{n_\perp} \f$ which minimises \f$ T \f$
	/// being identified as the spherocity axis. The unit vector which maximises the spherocity
	/// scalar in the plane perpendicular to \f$ \vec{n} \f$ is the "spherocity major"
	/// direction, and the vector perpendicular to both the spherocity and spherocity major directions
	/// is the spherocity minor. Both the major and minor directions have associated spherocity
	/// scalars.
	///
	/// Care must be taken in the case of Drell-Yan processes - there we should use the
	/// newly proposed observable \f$ a_T \f$.
	class Spherocity : public AxesDefinition {
	public:

	// Default Constructor
	Spherocity() {}

	/// Constructor.
	Spherocity(const FinalState& fsp)
	: _calculatedSpherocity(false)
	{
	setName("Spherocity");
	addProjection(fsp, "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new Spherocity(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(Spherocity);


	protected:

	/// Perform the projection on the Event
	void project(const Event& e) {
	const vector<Particle> ps
	= applyProjection<FinalState>(e, "FS").particles();
	calc(ps);
	}


	/// Compare projections
	int compare(const Projection& p) const {
	return mkNamedPCmp(p, "FS");
	}


	public:

	/// @name Spherocity scalar accessors
	//@{
	/// The spherocity scalar, \f$ S \f$, (minimum spherocity).
	double spherocity() const { return _spherocities[0]; }
	//@}


	/// @name Spherocity axis accessors
	//@{
	/// The spherocity axis.
	const Vector3& spherocityAxis() const { return _spherocityAxes[0]; }
	/// The spherocity major axis (axis of max spherocity perpendicular to spherocity axis).
	const Vector3& spherocityMajorAxis() const { return _spherocityAxes[1]; }
	/// The spherocity minor axis (axis perpendicular to spherocity and spherocity major).
	const Vector3& spherocityMinorAxis() const { return _spherocityAxes[2]; }
	//@}


	/// @name AxesDefinition axis accessors.
	//@{
	const Vector3& axis1() const { return spherocityAxis(); }
	const Vector3& axis2() const { return spherocityMajorAxis(); }
	const Vector3& axis3() const { return spherocityMinorAxis(); }
	///@}


	public:

	/// @name Direct methods
	/// Ways to do the calculation directly, without engaging the caching system
	//@{

	/// Manually calculate the spherocity, without engaging the caching system
	void calc(const FinalState& fs);

	/// Manually calculate the spherocity, without engaging the caching system
	void calc(const vector<Particle>& fsparticles);

	/// Manually calculate the spherocity, without engaging the caching system
	void calc(const vector<FourMomentum>& fsmomenta);

	/// Manually calculate the spherocity, without engaging the caching system
	void calc(const vector<Vector3>& threeMomenta);

	//@}


	private:

	/// The spherocity scalars.
	vector<double> _spherocities;

	/// The spherocity axes.
	vector<Vector3> _spherocityAxes;

	/// Caching flag to avoid costly recalculations.
	bool _calculatedSpherocity;


	private:

	/// Explicitly calculate the spherocity values.
	void _calcSpherocity(const vector<Vector3>& fsmomenta);

	};

	}

	#endif
	diff --git a/include/Rivet/Projections/TauFinder.hh b/include/Rivet/Projections/TauFinder.hh
	--- a/include/Rivet/Projections/TauFinder.hh
	+++ b/include/Rivet/Projections/TauFinder.hh
	@@ -1,67 +1,67 @@
	-
	#ifndef RIVET_TauFinder_HH
	#define RIVET_TauFinder_HH

	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	-
	/// @brief Convenience finder of unstable taus
	/// @todo Inherit directly from ParticleFinder, not FinalState
	class TauFinder : public FinalState {
	public:

	enum DecayType { ANY=0, LEPTONIC=1, HADRONIC };
	-
	+
	static bool isHadronic(const Particle& tau) {
	assert(tau.abspid() == PID::TAU);
	return any(tau.stableDescendants(), isHadron);
	}
	-
	+
	static bool isLeptonic(const Particle& tau) {
	return !isHadronic(tau);
	}


	TauFinder(DecayType decaytype, const Cut& cut=Cuts::open()) {
	setName("TauFinder");
	//_theParticles.clear();
	_dectype=decaytype;
	//cout << "Init tf with "<< _dectype << endl;
	addProjection(UnstableFinalState(cut), "UFS");
	}


	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new TauFinder(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(TauFinder);


	const Particles& taus() const { return _theParticles; }


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare with other projections.
	virtual int compare(const Projection& p) const;


	private:

	/// The decaytype enum
	DecayType _dectype;
	-
	+
	};


	+ /// @todo Make this the canonical name in future
	+ using Taus = TauFinder;
	+
	+
	}


	#endif
	diff --git a/include/Rivet/Projections/Thrust.hh b/include/Rivet/Projections/Thrust.hh
	--- a/include/Rivet/Projections/Thrust.hh
	+++ b/include/Rivet/Projections/Thrust.hh
	@@ -1,142 +1,140 @@
	// -- C++ --
	#ifndef RIVET_Thrust_HH
	#define RIVET_Thrust_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/AxesDefinition.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	/**
	@brief Get the e+ e- thrust basis and the thrust, thrust major and thrust minor scalars.

	@author Andy Buckley

	The scalar (maximum) thrust is defined as
	\f[
	T = \mathrm{max}_{\vec{n}} \frac{\sum_i \left\|\vec{p}_i \cdot \vec{n} \right\|}{\sum_i \|\vec{p}_i\|}
	\f],
	with the direction of the unit vector \f$ \vec{n} \f$ which maximises \f$ T \f$
	being identified as the thrust axis. The unit vector which maximises the thrust
	scalar in the plane perpendicular to \f$ \vec{n} \f$ is the "thrust major"
	direction, and the vector perpendicular to both the thrust and thrust major directions
	is the thrust minor. Both the major and minor directions have associated thrust
	scalars.

	Thrust calculations have particularly simple forms for less than 4 particles, and
	in those cases this projection is computationally minimal. For 4 or more particles,
	a more general calculation must be carried out, based on the Brandt/Dahmen method
	from Z. Phys. C1 (1978). While a polynomial improvement on the exponential scaling
	of the naive method, this algorithm scales asymptotically as
	\f$ \mathcal{O}\left( n^3 \right) \f$. Be aware that the thrust may easily be the
	most computationally demanding projection in Rivet for large events!

	The Rivet implementation of thrust is based heavily on Stefan Gieseke's Herwig++
	re-coding of the 'tasso' code from HERWIG.

	NB. special case with >= 4 coplanar particles will still fail.
	NB. Thrust assumes all momenta are in the CoM system: no explicit boost is performed.
	This can be dealt with by appropriate choice of the supplied FinalState.
	*/
	class Thrust : public AxesDefinition {
	public:

	/// Constructor.
	Thrust() {}

	Thrust(const FinalState& fsp) {
	setName("Thrust");
	addProjection(fsp, "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new Thrust(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(Thrust);

	protected:

	/// Perform the projection on the Event
	void project(const Event& e) {
	const vector<Particle> ps
	= applyProjection<FinalState>(e, "FS").particles();
	calc(ps);
	}

	/// Compare projections
	int compare(const Projection& p) const {
	return mkNamedPCmp(p, "FS");
	}


	public:

	///@{ Thrust scalar accessors
	/// The thrust scalar, \f$ T \f$, (maximum thrust).
	double thrust() const { return _thrusts[0]; }
	/// The thrust major scalar, \f$ M \f$, (thrust along thrust major axis).
	double thrustMajor() const { return _thrusts[1]; }
	/// The thrust minor scalar, \f$ m \f$, (thrust along thrust minor axis).
	double thrustMinor() const { return _thrusts[2]; }
	/// The oblateness, \f$ O = M - m \f$ .
	double oblateness() const { return _thrusts[1] - _thrusts[2]; }
	///@}

	///@{ Thrust axis accessors
	/// The thrust axis.
	const Vector3& thrustAxis() const { return _thrustAxes[0]; }
	/// The thrust major axis (axis of max thrust perpendicular to thrust axis).
	const Vector3& thrustMajorAxis() const { return _thrustAxes[1]; }
	/// The thrust minor axis (axis perpendicular to thrust and thrust major).
	const Vector3& thrustMinorAxis() const { return _thrustAxes[2]; }
	///@}

	///@{ AxesDefinition axis accessors.
	const Vector3& axis1() const { return thrustAxis(); }
	const Vector3& axis2() const { return thrustMajorAxis(); }
	const Vector3& axis3() const { return thrustMinorAxis(); }
	///@}


	public:

	/// @name Direct methods
	/// Ways to do the calculation directly, without engaging the caching system
	//@{

	/// Manually calculate the thrust, without engaging the caching system
	void calc(const FinalState& fs);

	/// Manually calculate the thrust, without engaging the caching system
	void calc(const vector<Particle>& fsparticles);

	/// Manually calculate the thrust, without engaging the caching system
	void calc(const vector<FourMomentum>& fsmomenta);

	/// Manually calculate the thrust, without engaging the caching system
	void calc(const vector<Vector3>& threeMomenta);

	//@}


	private:

	/// The thrust scalars.
	vector<double> _thrusts;

	/// The thrust axes.
	vector<Vector3> _thrustAxes;

	private:

	/// Explicitly calculate the thrust values.
	void _calcThrust(const vector<Vector3>& fsmomenta);

	};

	}

	#endif
	diff --git a/include/Rivet/Projections/TriggerCDFRun0Run1.hh b/include/Rivet/Projections/TriggerCDFRun0Run1.hh
	--- a/include/Rivet/Projections/TriggerCDFRun0Run1.hh
	+++ b/include/Rivet/Projections/TriggerCDFRun0Run1.hh
	@@ -1,59 +1,55 @@
	// -- C++ --
	#ifndef RIVET_TriggerCDFRun0Run1_HH
	#define RIVET_TriggerCDFRun0Run1_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Projections/Beam.hh"

	namespace Rivet {


	/// @brief Access to the min bias triggers used by CDF in Run 0 and Run 1
	class TriggerCDFRun0Run1 : public Projection {
	public:

	/// Default constructor.
	TriggerCDFRun0Run1() {
	setName("TriggerCDFRun0Run1");

	addProjection(ChargedFinalState(-5.9, 5.9), "CFS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new TriggerCDFRun0Run1(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(TriggerCDFRun0Run1);


	- public:
	-
	/// The trigger result
	bool minBiasDecision() const {
	return _decision_mb;
	}

	/// Project on to the Event
	void project(const Event& evt);


	protected:

	/// Compare with other projections.
	virtual int compare(const Projection& UNUSED(p)) const {
	return EQUIVALENT;
	}


	private:

	/// The min bias trigger decision
	bool _decision_mb;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/TriggerCDFRun2.hh b/include/Rivet/Projections/TriggerCDFRun2.hh
	--- a/include/Rivet/Projections/TriggerCDFRun2.hh
	+++ b/include/Rivet/Projections/TriggerCDFRun2.hh
	@@ -1,59 +1,55 @@
	// -- C++ --
	#ifndef RIVET_TriggerCDFRun2_HH
	#define RIVET_TriggerCDFRun2_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Projections/Beam.hh"

	namespace Rivet {


	/// @brief Access to the min bias triggers used by CDF in Run 0 and Run 1
	class TriggerCDFRun2 : public Projection {
	public:

	/// Default constructor.
	TriggerCDFRun2() {
	setName("TriggerCDFRun2");

	addProjection(ChargedFinalState(-4.7, 4.7), "CFS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new TriggerCDFRun2(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(TriggerCDFRun2);


	- public:
	-
	/// The trigger result
	bool minBiasDecision() const {
	return _decision_mb;
	}

	/// Project on to the Event
	void project(const Event& evt);


	protected:

	/// Compare with other projections.
	virtual int compare(const Projection& UNUSED(p)) const {
	return EQUIVALENT;
	}


	private:

	/// The min bias trigger decision
	bool _decision_mb;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/TriggerUA5.hh b/include/Rivet/Projections/TriggerUA5.hh
	--- a/include/Rivet/Projections/TriggerUA5.hh
	+++ b/include/Rivet/Projections/TriggerUA5.hh
	@@ -1,82 +1,78 @@
	// -- C++ --
	#ifndef RIVET_TriggerUA5_HH
	#define RIVET_TriggerUA5_HH

	#include "Rivet/Projection.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Projections/Beam.hh"

	namespace Rivet {


	/// @brief Access to the min bias triggers used by UA5
	class TriggerUA5 : public Projection {
	public:

	/// Default constructor.
	TriggerUA5();

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new TriggerUA5(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(TriggerUA5);


	- public:
	-
	/// The trigger result for non-single diffractive (2 arm) trigger
	bool sdDecision() const {
	return _decision_sd;
	}

	/// The trigger result for non-single diffractive (2 arm) trigger
	bool nsdDecision() const {
	return _decision_nsd_1;
	}

	/// The trigger result for non-single diffractive (2 arm) trigger
	/// with special ">= 2" trigger for ppbar bg rejection
	bool nsd2Decision() const {
	return _decision_nsd_2;
	}

	/// The trigger result
	bool samebeams() const {
	return _samebeams;
	}

	/// Number of hits in <-,+> eta hodoscopes
	pair<unsigned int, unsigned int> numHits() {
	return make_pair(_n_plus, _n_minus);
	}

	/// Project on to the event
	void project(const Event& evt);


	protected:

	/// Compare with other projections.
	virtual int compare(const Projection& UNUSED(p)) const {
	return EQUIVALENT;
	}


	private:

	/// The min bias trigger decisions
	bool _decision_sd, _decision_nsd_1, _decision_nsd_2;

	/// Is it a pp collision?
	bool _samebeams;

	/// Number of hits in hodoscopes
	unsigned int _n_plus, _n_minus;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/UnstableFinalState.hh b/include/Rivet/Projections/UnstableFinalState.hh
	--- a/include/Rivet/Projections/UnstableFinalState.hh
	+++ b/include/Rivet/Projections/UnstableFinalState.hh
	@@ -1,67 +1,57 @@
	// -- C++ --
	#ifndef RIVET_UnstableFinalState_HH
	#define RIVET_UnstableFinalState_HH

	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Project out all physical-but-decayed particles in an event.
	///
	/// The particles returned by the UFS are unique unstable particles, such as
	/// hadrons which are decayed by the generator. If, for example, you set Ks
	/// and Lambda particles stable in the generator, they will not be returned by
	/// the UFS. Also, you should be aware that all unstable particles in a decay
	/// chain are returned: if you are looking for something like the number of B
	/// hadrons in an event and there is a decay chain from e.g. B** -> B, you
	/// will count both B mesons unless you are careful to check for
	/// ancestor/descendent relations between the particles. Duplicate particles
	/// in the event record, i.e. those which differ only in bookkeeping details
	/// or photon emissions, are stripped from the returned particles collection.
	///
	- /// @todo Inherit directly from ParticleFinder, rename as UnstableFinder, and make TauFinder inherit/use
	+ /// @todo Inherit directly from ParticleFinder, rename as Unstables, and make TauFinder inherit/use
	class UnstableFinalState : public FinalState {
	public:

	/// @name Standard constructors and destructors.
	//@{

	/// Cut-based / default constructor
	UnstableFinalState(const Cut& c=Cuts::open())
	: FinalState(c)
	{
	setName("UnstableFinalState");
	}

	- /// Constructor from cuts.
	- ///
	- /// May specify the minimum and maximum pseudorapidity \f$ \eta \f$ and the
	- /// min \f$ p_T \f$
	- DEPRECATED("Use the version with a Cut argument")
	- UnstableFinalState(double mineta, double maxeta, double minpt=0.0*GeV)
	- : FinalState(Cuts::etaIn(mineta, maxeta) && Cuts::pT > minpt)
	- {
	- setName("UnstableFinalState");
	- }
	-
	-
	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new UnstableFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(UnstableFinalState);

	//@}

	protected:

	/// Apply the projection to the event.
	virtual void project(const Event& e);

	};


	+ /// @todo Make this the canonical name in future
	+ using Unstables = UnstableFinalState;
	+
	+
	}


	#endif
	diff --git a/include/Rivet/Projections/VetoedFinalState.hh b/include/Rivet/Projections/VetoedFinalState.hh
	--- a/include/Rivet/Projections/VetoedFinalState.hh
	+++ b/include/Rivet/Projections/VetoedFinalState.hh
	@@ -1,186 +1,185 @@
	// -- C++ --
	#ifndef RIVET_VetoedFinalState_HH
	#define RIVET_VetoedFinalState_HH

	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief FS modifier to exclude classes of particles from the final state.
	class VetoedFinalState : public FinalState {

	public:

	/// Typedef for a pair of back-to-back cuts.
	typedef pair<double, double> BinaryCut;

	/// Typedef for a vetoing entry.
	typedef map<long, BinaryCut> VetoDetails;

	/// Typedef for a veto on a composite particle mass.
	typedef multimap<int, BinaryCut> CompositeVeto;


	/// @name Constructors
	//@{
	/// Default constructor.
	VetoedFinalState() {
	setName("VetoedFinalState");
	addProjection(FinalState(), "FS");
	}

	/// Constructor with specific FinalState.
	VetoedFinalState(const FinalState& fsp)
	{
	setName("VetoedFinalState");
	addProjection(fsp, "FS");
	}

	/// You can add a map of ID plus a pair containing \f$ p_{Tmin} \f$ and
	/// \f$ p_{Tmax} \f$ - these define the range of particles to be vetoed.
	VetoedFinalState(const VetoDetails& vetocodes)
	: _vetoCodes(vetocodes)
	{
	setName("VetoedFinalState");
	addProjection(FinalState(), "FS");
	}

	/// You can add a map of ID plus a pair containing \f$ p_{Tmin} \f$ and
	/// \f$ p_{Tmax} \f$ - these define the range of particles to be vetoed.
	/// This version also supplies a specifi FinalState to be used.
	VetoedFinalState(const FinalState& fsp, const VetoDetails& vetocodes)
	: _vetoCodes(vetocodes)
	{
	setName("VetoedFinalState");
	addProjection(fsp, "FS");
	}


	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new VetoedFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(VetoedFinalState);
	+
	//@}


	public:

	/// Get the list of particle IDs and \f$ p_T \f$ ranges to veto.
	const VetoDetails& vetoDetails() const {
	return _vetoCodes;
	}

	/// Add a particle ID and \f$ p_T \f$ range to veto. Particles with \f$ p_T \f$
	/// IN the given range will be rejected.
	VetoedFinalState& addVetoDetail(const long id, const double ptmin, const double ptmax) {
	BinaryCut ptrange(ptmin, ptmax);
	_vetoCodes.insert(make_pair(id, ptrange));
	return *this;
	}

	/// Add a particle/antiparticle pair to veto in a given \f$ p_T \f$ range. Given a single ID, both
	/// the particle and its conjugate antiparticle will be rejected if their \f$ p_T \f$ is IN the given range.
	VetoedFinalState& addVetoPairDetail(const long id, const double ptmin, const double ptmax) {
	addVetoDetail(id, ptmin, ptmax);
	addVetoDetail(-id, ptmin, ptmax);
	return *this;
	}

	/// Add a particle/antiparticle pair to veto. Given a single ID, both the particle and its corresponding
	/// antiparticle (for all \f$ p_T \f$ values) will be vetoed.
	VetoedFinalState& addVetoPairId(const long id) {
	addVetoId(id);
	addVetoId(-id);
	return *this;
	}

	/// Add a particle ID to veto (all \f$ p_T \f$ range will be vetoed).
	VetoedFinalState& addVetoId(const long id) {
	BinaryCut ptrange(0.0, numeric_limits<double>::max());
	_vetoCodes.insert(make_pair(id, ptrange));
	return *this;
	}

	/// Veto all neutrinos (convenience method)
	VetoedFinalState& vetoNeutrinos() {
	addVetoPairId(PID::NU_E);
	addVetoPairId(PID::NU_MU);
	addVetoPairId(PID::NU_TAU);
	return *this;
	}

	/// Add a veto on composite masses within a given width.
	/// The composite mass is composed of nProducts decay products
	/// @ todo might we want to specify a range of pdg ids for the decay products?
	VetoedFinalState& addCompositeMassVeto(const double &mass, const double &width, int nProducts=2){
	double halfWidth = 0.5*width;
	BinaryCut massRange(mass - halfWidth, mass + halfWidth);
	_compositeVetoes.insert(make_pair(nProducts, massRange));
	_nCompositeDecays.insert(nProducts);
	return *this;
	}

	/// Veto the decay products of particle with pdg id
	/// @todo Need HepMC to sort themselves out and keep vector bosons from
	/// the hard vtx in the event record before this will work reliably for all pdg ids
	VetoedFinalState& addDecayProductsVeto(const long id){
	_parentVetoes.insert(id);
	return *this;
	}

	/// Set the list of particle IDs and \f$ p_T \f$ ranges to veto.
	VetoedFinalState& setVetoDetails(const VetoDetails& ids) {
	_vetoCodes = ids;
	return *this;
	}

	/// Clear the list of particle IDs and ranges to veto.
	VetoedFinalState& reset() {
	_vetoCodes.clear();
	return *this;
	}


	/// Veto particles from a supplied final state.
	VetoedFinalState& addVetoOnThisFinalState(const FinalState& fs) {
	const string name = "FS_" + to_str(_vetofsnames.size());
	addProjection(fs, name);
	_vetofsnames.insert(name);
	return *this;
	}


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;


	private:

	/// The final-state particles.
	VetoDetails _vetoCodes;

	/// Composite particle masses to veto
	CompositeVeto _compositeVetoes;
	set<int> _nCompositeDecays;

	typedef set<long> ParentVetos;

	/// Set of decaying particle IDs to veto
	ParentVetos _parentVetoes;

	/// Set of finalstate to be vetoed
	set<string> _vetofsnames;

	};


	}


	#endif
	diff --git a/include/Rivet/Projections/VisibleFinalState.hh b/include/Rivet/Projections/VisibleFinalState.hh
	--- a/include/Rivet/Projections/VisibleFinalState.hh
	+++ b/include/Rivet/Projections/VisibleFinalState.hh
	@@ -1,59 +1,57 @@
	// -- C++ --
	#ifndef RIVET_VisibleFinalState_HH
	#define RIVET_VisibleFinalState_HH

	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Particle.hh"
	#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Final state modifier excluding particles which are not experimentally visible
	class VisibleFinalState : public FinalState {
	public:

	/// @name Constructors
	//@{

	/// Constructor with min and max pseudorapidity \f$ \eta \f$ and min \f$ p_T \f$ (in GeV).
	VisibleFinalState(double mineta = -MAXDOUBLE,
	double maxeta = MAXDOUBLE,
	double minpt = 0.0*GeV)
	{
	setName("VisibleFinalState");
	addProjection(FinalState(mineta, maxeta, minpt), "FS");
	}

	/// Constructor with specific FinalState.
	VisibleFinalState(const FinalState& fsp)
	{
	setName("VisibleFinalState");
	addProjection(fsp, "FS");
	}

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new VisibleFinalState(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(VisibleFinalState);

	//@}


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;

	};


	}

	#endif
	diff --git a/include/Rivet/Projections/WFinder.hh b/include/Rivet/Projections/WFinder.hh
	--- a/include/Rivet/Projections/WFinder.hh
	+++ b/include/Rivet/Projections/WFinder.hh
	@@ -1,164 +1,162 @@
	// -- C++ --
	#ifndef RIVET_WFinder_HH
	#define RIVET_WFinder_HH

	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief Convenience finder of leptonically decaying W
	///
	/// Chain together different projections as convenience for finding one W
	/// from one lepton and the missing E 4-vector in the final state, including photon clustering.
	///
	/// @todo Inherit directly from ParticleFinder, not FinalState
	class WFinder : public FinalState {
	public:

	enum ClusterPhotons { NOCLUSTER=0, CLUSTERNODECAY=1, CLUSTERALL };
	enum PhotonTracking { NOTRACK=0, TRACK=1 };
	enum MassWindow { MASS=0, TRANSMASS=1 };

	/// @name Constructors
	//@{

	/// Constructor taking cuts object
	/// @param inputfs Input final state
	/// @param leptoncuts Charged lepton cuts
	/// @param pid Type of the charged lepton
	/// @param minmass,maxmass (Transverse) mass window
	/// @param missingET Minimal amount of missing ET (neutrinos) required
	/// @param dRmax Maximum dR of photons around charged lepton to take into account
	/// for W reconstruction (only relevant if one of the following are true)
	/// @param clusterPhotons Whether such photons are supposed to be
	/// clustered to the lepton object and thus W mom
	/// @param trackPhotons Whether such photons should be added to _theParticles
	/// @param masstype Whether mass window should be applied using m or mT
	WFinder(const FinalState& inputfs,
	const Cut& leptoncuts,
	PdgId pid,
	double minmass, double maxmass,
	double missingET,
	double dRmax=0.1,
	ClusterPhotons clusterPhotons=CLUSTERNODECAY,
	PhotonTracking trackPhotons=NOTRACK,
	MassWindow masstype=MASS,
	double masstarget=80.4*GeV);

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new WFinder(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(WFinder);

	//@}


	/// Access to the found bosons
	///
	/// @note Currently either 0 or 1 boson can be found.
	const Particles& bosons() const { return _bosons; }

	/// Access to the found boson (assuming it exists)
	const Particle& boson() const { return _bosons[0]; }


	/// Access to the Ws' constituent clustered leptons
	///
	/// @note Either size 0 if no boson was found or 1 if one boson was found
	const Particles& constituentLeptons() const { return _constituentLeptons; }

	/// Access to the W's constituent clustered lepton (assuming it exists)
	const Particle& constituentLepton() const { return _constituentLeptons[0]; }


	/// Access to the Ws' constituent neutrinos
	///
	/// @note Either size 0 if no boson was found or 1 if one boson was found
	/// @note The neutrino can't be perfecly reconstructed -- this is a pseudo-nu from the MET.
	const Particles& constituentNeutrinos() const { return _constituentNeutrinos; }

	/// Access to the W's constituent neutrino (assuming it exists)
	/// @note The neutrino can't be perfecly reconstructed -- this is a pseudo-nu from the MET.
	const Particle& constituentNeutrino() const { return _constituentNeutrinos[0]; }


	/// Access to the particles other than the W leptons and clustered photons
	///
	/// Useful for e.g. input to a jet finder
	const VetoedFinalState& remainingFinalState() const;

	/// Access to the missing momentum projection used to find the "neutrino"
	const MissingMomentum& missingMom() const;

	/// @brief Calculate the transverse mass of the W, from the charged lepton and neutrino
	///
	/// Defined as sqrt(2 pT_l pT_nu (1.0 - cos(dphi_lnu))). Return -1 if no boson found.
	double mT() const {
	if (bosons().empty()) return -1;
	const FourMomentum& l = constituentLeptons()[0].momentum();
	const FourMomentum& nu = constituentNeutrinos()[0].momentum();
	return sqrt( 2 * l.pT() * nu.pT() * (1 - cos(deltaPhi(l, nu))) );
	}


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;


	public:

	/// Clear the projection
	void clear() {
	_theParticles.clear();
	_bosons.clear();
	_constituentLeptons.clear();
	_constituentNeutrinos.clear();
	}

	private:

	/// Transverse mass cuts
	double _minmass, _maxmass, _masstarget;
	bool _useTransverseMass;

	/// Missing ET cut
	double _etMiss;

	/// Switch for tracking of photons (whether to add them to _theParticles)
	/// This is relevant when the ZFinder::_theParticles are to be excluded
	/// from e.g. the input to a jet finder, to specify whether the clustered
	/// photons are to be excluded as well.
	/// (Yes, some experiments make a difference between clusterPhotons and
	/// trackPhotons!)
	PhotonTracking _trackPhotons;

	/// Lepton flavour
	PdgId _pid;

	/// Neutrino flavour
	PdgId _nu_pid;

	/// list of found bosons (currently either 0 or 1)
	Particles _bosons;

	/// Constituent leptons (currently either 0 or 1)
	Particles _constituentLeptons;

	/// Constituent neutrinos (currently either 0 or 1)
	Particles _constituentNeutrinos;

	};


	}


	#endif
	diff --git a/include/Rivet/Projections/ZFinder.hh b/include/Rivet/Projections/ZFinder.hh
	--- a/include/Rivet/Projections/ZFinder.hh
	+++ b/include/Rivet/Projections/ZFinder.hh
	@@ -1,143 +1,142 @@
	// -- C++ --
	#ifndef RIVET_ZFinder_HH
	#define RIVET_ZFinder_HH

	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief Convenience finder of leptonically decaying Zs
	///
	/// Chain together different projections as convenience for finding Z's
	/// from two leptons in the final state, including photon clustering.
	///
	/// @todo Inherit directly from ParticleFinder, not FinalState
	+ /// @todo Alias then rename as Dileptons
	class ZFinder : public FinalState {
	public:

	enum ClusterPhotons { NOCLUSTER=0, CLUSTERNODECAY=1, CLUSTERALL };
	enum PhotonTracking { NOTRACK=0, TRACK=1 };

	/// @name Constructors
	//@{

	/// Constructor taking cuts object
	/// @param inputfs Input final state
	/// @param cuts lepton cuts
	/// @param pid type of the leptons
	/// @param minmass,maxmass mass window
	/// @param dRmax maximum dR of photons around leptons to take into account
	/// for Z reconstruction (only relevant if one of the following are true)
	/// @param clusterPhotons whether such photons are supposed to be
	/// clustered to the lepton objects and thus Z mom
	/// @param trackPhotons whether such photons should be added to _theParticles
	/// (cf. _trackPhotons)
	ZFinder(const FinalState& inputfs,
	const Cut & cuts,
	PdgId pid,
	double minmass, double maxmass,
	- double dRmax=0.1,
	- ClusterPhotons clusterPhotons=CLUSTERNODECAY,
	+ double dRmax=0.1,
	+ ClusterPhotons clusterPhotons=CLUSTERNODECAY,
	PhotonTracking trackPhotons=NOTRACK,
	double masstarget=91.2*GeV);

	/// Clone on the heap.
	- virtual unique_ptr<Projection> clone() const {
	- return unique_ptr<Projection>(new ZFinder(*this));
	- }
	+ DEFAULT_RIVET_PROJ_CLONE(ZFinder);

	//@}


	/// Access to the found bosons
	///
	/// @note Currently either 0 or 1 boson can be found.
	const Particles& bosons() const { return _bosons; }

	/// Access to the found boson (assuming it exists).
	const Particle boson() const { return _bosons[0]; }

	/// Access to the Z constituent clustered leptons
	///
	/// For example, to make more fine-grained cuts on the clustered leptons.
	/// The positive charge constituent is first in the list (if not empty), and
	/// the negative one second.
	const Particles& constituents() const { return _constituents; }

	/// Access to the Z constituent clustered leptons, sorted by a comparison functor
	///
	/// Unlike the no-arg version, this returns by value (i.e. is less efficient)
	template <typename CMP>
	Particles constituents(const CMP& cmp) const {
	Particles rtn = constituents();
	std::sort(rtn.begin(), rtn.end(), cmp);
	return rtn;
	}

	/// Access to all DressedLeptons in the fiducial region.
	///
	/// This includes those DressedLeptons that could not
	/// be paired up with any other DressedLepton to form a Z candidate.
	const vector<DressedLepton>& allLeptons() const { return _allLeptons; }

	/// Access to the particles other than the Z leptons and clustered photons
	///
	/// Useful for e.g. input to a jet finder
	const VetoedFinalState& remainingFinalState() const;


	protected:

	/// Apply the projection on the supplied event.
	void project(const Event& e);

	/// Compare projections.
	int compare(const Projection& p) const;


	public:

	/// Clear the projection
	void clear() {
	_theParticles.clear();
	_bosons.clear();
	_constituents.clear();
	_allLeptons.clear();
	}


	private:
	/// Mass cuts to apply to clustered leptons (cf. InvMassFinalState)
	double _minmass, _maxmass, _masstarget;

	/// Switch for tracking of photons (whether to add them to _theParticles)
	/// This is relevant when the ZFinder::_theParticles are to be excluded
	/// from e.g. the input to a jet finder, to specify whether the clustered
	/// photons are to be excluded as well.
	/// (Yes, some experiments make a difference between clusterPhotons and
	/// trackPhotons!)
	PhotonTracking _trackPhotons;

	/// Lepton flavour
	PdgId _pid;

	/// list of found bosons (currently either 0 or 1)
	Particles _bosons;

	/// Clustered leptons
	vector<Particle> _constituents;

	///Dressed leptons
	vector<DressedLepton> _allLeptons;

	};


	}



	#endif
	diff --git a/include/Rivet/Run.hh b/include/Rivet/Run.hh
	--- a/include/Rivet/Run.hh
	+++ b/include/Rivet/Run.hh
	@@ -1,108 +1,111 @@
	// -- C++ --
	#ifndef RIVET_Run_HH
	#define RIVET_Run_HH

	#include "Rivet/Tools/RivetSTL.hh"
	#include "Rivet/Tools/RivetHepMC.hh"

	namespace Rivet {


	// Forward declaration
	class AnalysisHandler;


	/// @brief Interface to handle a run of events read from a HepMC stream or file.
	class Run {
	public:

	/// @name Standard constructors and destructors. */
	//@{
	/// The standard constructor.
	Run(AnalysisHandler& ah);

	/// The destructor
	~Run();
	//@}


	public:

	/// @name Set run properties
	//@{

	/// Get the cross-section for this run.
	Run& setCrossSection(const double xs);

	/// Get the current cross-section from the analysis handler in pb.
	double crossSection() const;

	/// Declare whether to list available analyses
	Run& setListAnalyses(const bool dolist);

	//@}


	/// @name File processing stages
	//@{

	/// Set up HepMC file readers (using the appropriate file weight for the first file)
	bool init(const std::string& evtfile, double weight=1.0);

	/// Open a HepMC GenEvent file (using the appropriate file weight for the first file)
	bool openFile(const std::string& evtfile, double weight=1.0);

	/// Read the next HepMC event
	bool readEvent();
	+
	+ /// Read the next HepMC event only to skip it
	+ bool skipEvent();

	/// Handle next event
	bool processEvent();

	/// Close up HepMC I/O
	bool finalize();

	//@}


	private:

	/// AnalysisHandler object
	AnalysisHandler& _ah;

	/// @name Run variables obtained from events or command line
	//@{

	/// @brief An extra event weight scaling per event file.
	/// Useful for e.g. AlpGen n-parton event file combination.
	double _fileweight;

	/// Cross-section from command line.
	double _xs;

	//@}


	/// Flag to show list of analyses
	bool _listAnalyses;


	/// @name HepMC I/O members
	//@{

	/// Current event
	std::shared_ptr<GenEvent> _evt;

	/// Output stream for HepMC writer
	std::shared_ptr<std::istream> _istr;

	/// HepMC I/O writer
	std::shared_ptr<HepMC::IO_GenEvent> _io;

	//@}

	};


	}

	#endif
	diff --git a/include/Rivet/BeamConstraint.hh b/include/Rivet/Tools/BeamConstraint.hh
	rename from include/Rivet/BeamConstraint.hh
	rename to include/Rivet/Tools/BeamConstraint.hh
	--- a/include/Rivet/BeamConstraint.hh
	+++ b/include/Rivet/Tools/BeamConstraint.hh
	@@ -1,66 +1,63 @@
	// -- C++ --
	#ifndef RIVET_BeamConstraint_HH
	#define RIVET_BeamConstraint_HH

	-#include "Rivet/Config/RivetCommon.hh"
	-#include "Rivet/ParticleName.hh"
	#include "Rivet/Particle.hh"
	-#include <iostream>
	-

	namespace Rivet {

	+
	/// Find whether ParticleName @a p is compatible with the
	/// template ParticleName @a allowed. Effectively this is
	/// asking whether @a p is a subset of @a allowed.
	inline bool compatible(PdgId p, PdgId allowed) {
	return (allowed == PID::ANY \|\| p == allowed);
	}

	/// Find whether PdgIdPair @a pair is compatible with the template
	/// PdgIdPair @a allowedpair. This assesses whether either of the
	/// two possible pairings of @a pair's constituents is compatible.
	inline bool compatible(const PdgIdPair& pair, const PdgIdPair& allowedpair) {
	bool oneToOne = compatible(pair.first, allowedpair.first);
	bool twoToTwo = compatible(pair.second, allowedpair.second);
	bool oneToTwo = compatible(pair.first, allowedpair.second);
	bool twoToOne = compatible(pair.second, allowedpair.first);
	return (oneToOne && twoToTwo) \|\| (oneToTwo && twoToOne);
	}


	/// Check particle compatibility of Particle pairs
	inline bool compatible(const ParticlePair& ppair,
	const PdgIdPair& allowedpair) {
	return compatible(PID::make_pdgid_pair(ppair.first.pid(),
	ppair.second.pid()), allowedpair);
	}
	/// Check particle compatibility of Particle pairs (for symmetric completeness)
	inline bool compatible(const PdgIdPair& allowedpair,
	const ParticlePair& ppair) {
	return compatible(ppair, allowedpair);
	}


	/// Find whether a PdgIdPair @a pair is compatible with at least one template
	/// beam pair in a set @a allowedpairs.
	inline bool compatible(const PdgIdPair& pair, const set<PdgIdPair>& allowedpairs) {
	for (set<PdgIdPair>::const_iterator bp = allowedpairs.begin(); bp != allowedpairs.end(); ++bp) {
	if (compatible(pair, *bp)) return true;
	}
	return false;
	}

	/// Return the intersection of two sets of {PdgIdPair}s.
	inline set<PdgIdPair> intersection(const set<PdgIdPair>& a, const set<PdgIdPair>& b) {
	set<PdgIdPair> ret;
	for (set<PdgIdPair>::const_iterator bp = a.begin(); bp != a.end(); ++bp) {
	if (compatible(bp, b)) ret.insert(bp);
	}
	return ret;
	}


	}

	#endif
	diff --git a/include/Rivet/Tools/CentralityHistogram.hh b/include/Rivet/Tools/CentralityHistogram.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Tools/CentralityHistogram.hh
	@@ -0,0 +1,231 @@
	+// -- C++ --
	+#ifndef RIVET_CENTRALITYHISTOGRAM_HH
	+#define RIVET_CENTRALITYHISTOGRAM_HH
	+#include "Rivet/Config/RivetCommon.hh"
	+#include "Rivet/Tools/RivetYODA.hh"
	+#include "Rivet/Projections/CentralityEstimator.hh"
	+namespace Rivet {
	+
	+class Analysis;
	+
	+
	+/**
	+ * CentralityHistogram contains a series of histograms of the same
	+ * quantity each in a different percentiles of a second quantity.
	+ * For example, a CentralityHistogram may contain histograms of the
	+ * cross section differential in \f$ p_T \f$ in different centrality
	+ * regions for heavy ion collisions.
	+ **/
	+class CentralityHistogram: public ProjectionApplier {
	+ public:
	+
	+ /// Create a new empty CentralityHistogram. As an optional
	+ /// argument a CentralityProjector may be supplied. This will then
	+ /// be responsible for calculating a centrality estimate for each
	+ /// event.
	+ CentralityHistogram()
	+ : _currentHist(Histo1DPtr()), _currentCEst(-1.0),
	+ _overSamplingFactor(10), _weightsum(0.0) {
	+ _percentiles.insert(0.0);
	+ _percentiles.insert(1.0);
	+ }
	+
	+ /// Set the centrality projection to be used. Note that this
	+ /// projection must have already been declared to Rivet.
	+ void setProjection(string pname) {
	+ _estimator = pname;
	+ }
	+
	+ /// Return the class name.
	+ std::string name() const {
	+ return "Rivet::CentralityHistogram";
	+ }
	+
	+
	+ /// Add a histogram in the region between @a cmin and @a cmax to
	+ /// this set of CentralityHistograms. The range represent
	+ /// percentiles and must be between 0 and 100. No overlaping bins
	+ /// are allowed.
	+
	+ /// Note that (cmin=0, cmax=5), means the five percent LEAST
	+ /// central events.
	+ void add(Histo1DPtr hist, double cmin, double cmax,
	+ double cestmin = -1.0, double cestmax = -1.0 );
	+
	+ /// Setup the CentralityHistogram for the given event. Must be
	+ /// called for every event before any fill. Optionally an explicit
	+ /// value of the centrality estimator can be given, Otherwise a
	+ /// CentralityEstimator must have been provided beforehand.
	+ void setup(const Event & ev, double cest = -1.0);
	+
	+ /// Fill the histogram that lies in the same region as @a bin with the value
	+ /// @a x of weight @a weight.
	+ void fill(double x, double weight = 1.0) {
	+ if ( _currentHist ) _currentHist->fill(x, weight);
	+ for ( auto h : _ready )
	+ if ( h.second.inRange(_currentCEst) )
	+ h.second._hist->fill(x, weight);
	+ }
	+
	+ /// Fill histo bin i with the given weight
	+ void fillBin(size_t i, double weight = 1.0) {
	+ if ( _currentHist ) _currentHist->fill(i, weight);
	+ for ( auto h : _ready )
	+ if ( h.second.inRange(_currentCEst) )
	+ h.second._hist->fill(i, weight);
	+ }
	+
	+ /// At the end of the run, calculate the percentiles and fill the
	+ /// histograms provided with addHistogram(). This is typically
	+ /// called from the finalize method in a Analysis, but can also be
	+ /// called earlier in which case the the fill function can be
	+ /// continued to run as before.
	+ void finalize();
	+
	+ /// Normalize each histogram to the sum of event weights in the
	+ /// corresponding centrality bin.
	+ void normalizePerEvent();
	+
	+ /// Return a map bin edges of the centrality extimator indexed by
	+ /// the corresponing percentile.
	+ map<double,double> edges() const;
	+
	+protected:
	+
	+ /// Create a copy of the first original histogram to be used in
	+ /// the dynamical binning of centrality.
	+ Histo1DPtr _newSamplerHist();
	+
	+ /// Take the sampler histogram which is furthest away from a
	+ /// centrality limit and merging it into the closest one and clear
	+ /// it and return it to be used for another dynamic bin.
	+ Histo1DPtr _purgeSamplers();
	+
	+
	+private:
	+
	+ /// A flexible bin struct to be used to store temporary histograms.
	+ struct FlexiBin {
	+
	+ /// Construct with an initial centrality estimate and an event
	+ /// weight.
	+ FlexiBin(Histo1DPtr hist, double cest = 0.0, double weight = 0.0)
	+ : _hist(hist), _cestLo(cest), _cestHi(cest), _weightsum(weight) {}
	+
	+ /// Construct a temporary FlexiBin for finding a bin in a set.
	+ FlexiBin(double cest)
	+ : _cestLo(cest), _cestHi(cest), _weightsum(0.0) {}
	+
	+ /// Merge in the contents of another FlexiBin into this.
	+ void merge(const FlexiBin & fb) {
	+ _cestLo = min(_cestLo, fb._cestLo);
	+ _cestHi = max(_cestHi, fb._cestHi);
	+ _weightsum += fb._weightsum;
	+ _hist += fb._hist;
	+ }
	+
	+ /// Comparisons for containers.
	+ bool operator< (const FlexiBin & fb) const {
	+ return ( _cestLo < fb._cestLo \|\|
	+ ( _cestLo == fb._cestLo && _cestLo < fb._cestHi ) );
	+ }
	+
	+ /// The associated histogram.
	+ Histo1DPtr _hist;
	+
	+ /// Current lower and upper edge of the centrality estimator for
	+ /// the fills in the associated histogram.
	+ double _cestLo, _cestHi;
	+
	+ /// The sum of weights for all events entering the associated
	+ /// histogram.
	+ mutable double _weightsum;
	+
	+ };
	+
	+ struct HistBin {
	+
	+ /// Construct a completely empty bin.
	+ HistBin()
	+ : _centLo(-1.0), _centHi(-1.0),
	+ _cestLo(-1.0), _cestHi(-1.0), _weightsum(0.0) {}
	+
	+ /// Constructor taking a histogram and centrality interval as
	+ /// argument. Optionally the interval in the estimator can be
	+ /// given, in which case this histogram is considered to be
	+ /// "final".
	+ HistBin(Histo1DPtr h, double centLo, double centHi,
	+ double cestLo = -1.0, double cestHi = -1.0)
	+ : _hist(h), _centLo(centLo), _centHi(centHi),
	+ _cestLo(cestLo), _cestHi(cestHi), _weightsum(0.0) {}
	+
	+ /// Return true if the given centrality estimate is in the range
	+ /// of this histogram.
	+ bool inRange(double cest) const {
	+ return _cestHi > 0 && _cestLo < cest && cest <= _cestHi;
	+ }
	+
	+ /// Normalise the histogram to the tital cross section.
	+ void normalizePerEvent() {
	+ if ( _weightsum > 0.0 ) _hist->normalize(1.0/_weightsum);
	+ }
	+
	+ /// The histogram.
	+ Histo1DPtr _hist;
	+
	+ /// The range in centrality.
	+ double _centLo, _centHi;
	+
	+ /// The corresponding range in the centrality estimator.
	+ double _cestLo, _cestHi;
	+
	+ /// The sum of event weights for this bin;
	+ double _weightsum;
	+
	+ };
	+
	+ /// Convenient typedefs.
	+ typedef set<FlexiBin> FlexiBinSet;
	+
	+ /// Find a bin corresponding to a given value of the centrality
	+ /// estimator.
	+ FlexiBinSet::iterator _findBin(double cest) const;
	+
	+ /// The name of the CentralityEstimator projection to be used.
	+ string _estimator;
	+
	+ /// The current temporary histogram selected for the centrality
	+ /// estimator calculated from the event presented in setup().
	+ Histo1DPtr _currentHist;
	+
	+ /// THe current value of the centrality estimator.
	+ double _currentCEst;
	+
	+ /// The oversampling of centrality bins. For each requested
	+ /// centrality bin this number of dynamic bins will be used.
	+ int _overSamplingFactor;
	+
	+ /// The unfilled histograms where the esimator edges has not yet
	+ /// been determined.
	+ vector<HistBin> _unfilled;
	+
	+ /// The dynamic bins for ranges of centrality estimators.
	+ FlexiBinSet _flexiBins;
	+
	+ /// The sum of all event weights so far.
	+ double _weightsum;
	+
	+ /// The sum of weights per original histogram.
	+ map<Histo1DPtr, double> _histWeightSum;
	+
	+ /// Percentile limits.
	+ set<double> _percentiles;
	+
	+ /// The filled histograms where the estimator edges has been determined.
	+ map<Histo1DPtr, HistBin> _ready;
	+
	+};
	+
	+}
	+
	+#endif
	diff --git a/include/Rivet/Cmp.fhh b/include/Rivet/Tools/Cmp.fhh
	rename from include/Rivet/Cmp.fhh
	rename to include/Rivet/Tools/Cmp.fhh
	diff --git a/include/Rivet/Cmp.hh b/include/Rivet/Tools/Cmp.hh
	rename from include/Rivet/Cmp.hh
	rename to include/Rivet/Tools/Cmp.hh
	diff --git a/include/Rivet/Tools/Cutflow.hh b/include/Rivet/Tools/Cutflow.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Tools/Cutflow.hh
	@@ -0,0 +1,210 @@
	+#ifndef RIVET_Cutflow_HH
	+#define RIVET_Cutflow_HH
	+
	+#include "Rivet/Tools/Utils.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// A tracker of numbers & fractions of events passing sequential cuts
	+ struct Cutflow {
	+
	+ /// @brief Default constructor
	+ ///
	+ /// Does nothing! Just to allow storage in STL containers and use as a member variable without using the init list
	+ Cutflow() {}
	+
	+ /// Proper constructor
	+ Cutflow(const string& cfname, const vector<string>& cutnames)
	+ : name(cfname), ncuts(cutnames.size()), cuts(cutnames), counts(ncuts+1, 0)
	+ { }
	+
	+ /// @brief Fill the pre-cut counter
	+ void fillinit(double weight=1.) {
	+ counts[0] += weight;
	+ }
	+
	+ /// @brief Fill the @a {icut}'th post-cut counter
	+ ///
	+ /// @note Returns the cut result to allow 'side-effect' cut-flow filling in an if-statement
	+ bool fill(size_t icut, bool cutresult, double weight=1.) {
	+ if (cutresult) counts[icut+1] += weight;
	+ return cutresult;
	+ }
	+
	+ /// @brief Fill all cut-state counters from an Ncut-element results vector
	+ ///
	+ /// This function is to be used to fill all of an event's pre- and post-cut
	+ /// state counters at once, including the incoming event counter. It must not be
	+ /// mixed with calls to the @c fill(size_t, bool) and @c fillinit() methods,
	+ /// or double-counting will occur.
	+ ///
	+ /// @note Returns the overall cut result to allow 'side-effect' cut-flow filling in an if-statement
	+ bool fill(const vector<bool>& cutresults, double weight=1.) {
	+ if (cutresults.size() != ncuts)
	+ throw RangeError("Number of filled cut results needs to match the Cutflow construction");
	+ counts[0] += 1;
	+ for (size_t i = 0; i < ncuts; ++i) {
	+ if (cutresults[i]) counts[i+1] += weight; else break;
	+ }
	+ return all(cutresults);
	+ }
	+
	+ /// @todo Add a fillnext(), keeping track of current ifill
	+
	+ /// @todo Add a fillhead() (or vector fillnext()?)
	+
	+ /// @brief Fill the N trailing post-cut counters, when supplied with an N-element results vector
	+ ///
	+ /// The @a cutresults vector represents the boolean results of the last N cuts. This function
	+ /// allows mixing of cut-flow filling with higher-level analyze() function escapes such as
	+ /// the vetoEvent directive. The initial state (state 0) is not incremented.
	+ ///
	+ /// @note Returns the overall cut result to allow 'side-effect' cut-flow filling in an if-statement
	+ bool filltail(const vector<bool>& cutresults, double weight=1.) {
	+ if (cutresults.size() > ncuts)
	+ throw RangeError("Number of filled cut results needs to match the Cutflow construction");
	+ const size_t offset = counts.size() - cutresults.size();
	+ for (size_t i = 0; i < cutresults.size(); ++i) {
	+ if (cutresults[i]) counts[offset+i] += weight; else break;
	+ }
	+ return all(cutresults);
	+ }
	+
	+ /// Scale the cutflow weights by the given factor
	+ void scale(double factor) {
	+ for (double& x : counts) x *= factor;
	+ }
	+
	+ /// Create a string representation
	+ string str() const {
	+ stringstream ss;
	+ ss << fixed << setprecision(1) << counts[0];
	+ const size_t count0len = ss.str().length();
	+ ss.str("");
	+ ss << name << " cut-flow:";
	+ size_t maxnamelen = 0;
	+ for (const string& t : cuts)
	+ maxnamelen = max(t.length(), maxnamelen);
	+ for (size_t i = 0; i <= ncuts; ++i) {
	+ const int pcttot = (counts[0] == 0) ? -1 : round(100*counts[i]/double(counts[0]));
	+ const int pctinc = (i == 0 \|\| counts[i-1] == 0) ? -1 : round(100*counts[i]/double(counts[i-1]));
	+ stringstream ss2;
	+ ss2 << fixed << setprecision(1) << counts[i];
	+ const string countstr = ss2.str(); ss2.str("");
	+ ss2 << fixed << setprecision(2) << pcttot << "%";
	+ const string pcttotstr = ss2.str(); ss2.str("");
	+ ss2 << fixed << setprecision(2) << pctinc << "%";
	+ const string pctincstr = ss2.str();
	+ ss << "\n"
	+ << setw(maxnamelen+5) << left << (i == 0 ? "" : "Pass "+cuts[i-1]) << " "
	+ << setw(count0len) << right << countstr << " "
	+ << setw(4) << right << (pcttot < 0 ? "- " : pcttotstr) << " "
	+ << setw(4) << right << (pctinc < 0 ? "- " : pctincstr);
	+ }
	+ return ss.str();
	+ }
	+
	+ /// Print string representation to a stream
	+ void print(ostream& os) const {
	+ os << str() << flush;
	+ }
	+
	+ string name;
	+ size_t ncuts;
	+ vector<string> cuts;
	+ vector<double> counts;
	+
	+ };
	+
	+
	+ /// Print a Cutflow to a stream
	+ inline ostream& operator << (ostream& os, const Cutflow& cf) {
	+ return os << cf.str();
	+ }
	+
	+
	+
	+ /// A container for several Cutflow objects, with some convenient batch access
	+ struct Cutflows {
	+
	+ /// Do-nothing default constructor
	+ Cutflows() { }
	+
	+ /// Populating constructor
	+ Cutflows(const vector<Cutflow>& cutflows) : cfs(cutflows) { }
	+
	+ /// Append a provided Cutflow to the list
	+ void addCutflow(const Cutflow& cf) {
	+ cfs.push_back(cf);
	+ }
	+
	+ /// Append a newly constructed Cutflow to the list
	+ void addCutflow(const string& cfname, const vector<string>& cutnames) {
	+ cfs.push_back(Cutflow(cfname, cutnames));
	+ }
	+
	+ /// Access the @a i'th Cutflow
	+ Cutflow& operator [] (size_t i) { return cfs[i]; }
	+ /// Access the @a i'th Cutflow (const)
	+ const Cutflow& operator [] (size_t i) const { return cfs[i]; }
	+
	+ /// Access the Cutflow whose name is @a name
	+ Cutflow& operator [] (const string& name) {
	+ for (Cutflow& cf : cfs)
	+ if (cf.name == name) return cf;
	+ throw UserError("Requested cut-flow name '" + name + "' does not exist");
	+ }
	+ /// Access the @a i'th Cutflow (const)
	+ const Cutflow& operator [] (const string& name) const {
	+ for (const Cutflow& cf : cfs)
	+ if (cf.name == name) return cf;
	+ throw UserError("Requested cut-flow name '" + name + "' does not exist");
	+ }
	+
	+ /// Fill the pre-cuts state counter for all contained {Cutflow}s
	+ void fillinit(double weight=1.) {
	+ for (Cutflow& cf : cfs) cf.fillinit(weight);
	+ }
	+
	+ /// @brief Fill the @a {icut}'th post-cut counter with the same result for all {Cutflow}s
	+ bool fill(size_t icut, bool cutresult, double weight=1.) {
	+ for (Cutflow& cf : cfs) cf.fill(icut, cutresult, weight);
	+ return cutresult;
	+ }
	+
	+ /// @todo Add a fillnext(), keeping track of current ifill
	+
	+ /// @todo Add a fillhead() (or vector fillnext()?)
	+
	+ /// Scale the contained {Cutflow}s by the given factor
	+ void scale(double factor) {
	+ for (Cutflow& cf : cfs) cf.scale(factor);
	+ }
	+
	+ /// Create a string representation
	+ string str() const {
	+ stringstream ss;
	+ for (const Cutflow& cf : cfs)
	+ ss << cf << "\n\n";
	+ return ss.str();
	+ }
	+
	+ /// Print string representation to a stream
	+ void print(ostream& os) const {
	+ os << str() << flush;
	+ }
	+
	+ vector<Cutflow> cfs;
	+
	+ };
	+
	+ /// Print a Cutflows to a stream
	+ inline ostream& operator << (ostream& os, const Cutflows& cfs) {
	+ return os << cfs.str();
	+ }
	+
	+
	+}
	+
	+#endif
	diff --git a/include/Rivet/Cuts.fhh b/include/Rivet/Tools/Cuts.fhh
	rename from include/Rivet/Cuts.fhh
	rename to include/Rivet/Tools/Cuts.fhh
	diff --git a/include/Rivet/Cuts.hh b/include/Rivet/Tools/Cuts.hh
	rename from include/Rivet/Cuts.hh
	rename to include/Rivet/Tools/Cuts.hh
	--- a/include/Rivet/Cuts.hh
	+++ b/include/Rivet/Tools/Cuts.hh
	@@ -1,103 +1,119 @@
	#ifndef RIVET_Cuts_HH
	#define RIVET_Cuts_HH

	-#include "Rivet/Cuts.fhh"
	+#include "Rivet/Tools/Cuts.fhh"
	#include <memory>

	namespace Rivet {


	class CutBase {
	public:

	- /// Main work method.
	+ /// Main work method, checking whether the cut is passed
	/// @internal Forwards the received object to @ref accept_, wrapped in the Cuttable converter
	- template <typename ClassToCheck> bool accept(const ClassToCheck&) const;
	+ template <typename ClassToCheck>
	+ bool accept(const ClassToCheck&) const;
	+
	+ /// @brief Call operator alias for @a accept
	+ /// @note A bit subtle, because this gets wrapped in a shared_ptr so you need to dereference to get the functor
	+ template <typename ClassToCheck>
	+ bool operator () (const ClassToCheck& x) const { return accept(x); }
	+
	/// Comparison to another Cut
	- virtual bool operator==(const Cut&) const = 0;
	+ virtual bool operator == (const Cut&) const = 0;
	+
	/// Default destructor
	virtual ~CutBase() {}

	protected:
	+
	/// @internal Actual accept implementation, overloadable by various cut combiners
	virtual bool _accept(const CuttableBase&) const = 0;

	};


	/// Compare two cuts for equality, forwards to the cut-specific implementation
	inline bool operator == (const Cut& a, const Cut& b) { return *a == b; }


	/// Namespace used for ambiguous identifiers.
	namespace Cuts {

	/// Available categories of cut objects
	- enum Quantity { pT=0, pt=0, Et=1, et=1, mass, rap, absrap, eta, abseta, phi };
	+ enum Quantity { pT=0, pt=0, Et=1, et=1, mass, rap, absrap, eta, abseta, phi,
	+ pid, abspid, charge, abscharge, charge3, abscharge3 };

	/// Fully open cut singleton, accepts everything
	const Cut& open(); //< access by factory function

	extern const Cut& OPEN; //= open(); //< access by constant
	extern const Cut& NOCUT; //= open(); //< access by constant

	/// @name Shortcuts for common cuts
	//@{
	Cut range(Quantity, double m, double n);
	inline Cut etaIn(double m, double n) { return range(eta,m,n); }
	inline Cut rapIn(double m, double n) { return range(rap,m,n); }
	inline Cut absetaIn(double m, double n) { return range(abseta,m,n); }
	inline Cut absrapIn(double m, double n) { return range(absrap,m,n); }
	inline Cut ptIn(double m, double n) { return range(pT,m,n); }
	inline Cut etIn(double m, double n) { return range(Et,m,n); }
	inline Cut massIn(double m, double n) { return range(mass,m,n); }
	//@}

	}


	/// @name Cut constructors
	//@{
	- Cut operator < (Cuts::Quantity, double);
	- Cut operator > (Cuts::Quantity, double);
	+ Cut operator == (Cuts::Quantity, double);
	+ Cut operator != (Cuts::Quantity, double);
	+ Cut operator < (Cuts::Quantity, double);
	+ Cut operator > (Cuts::Quantity, double);
	Cut operator <= (Cuts::Quantity, double);
	Cut operator >= (Cuts::Quantity, double);

	/// @internal Overload helpers for integer arguments
	//@{
	+ inline Cut operator == (Cuts::Quantity qty, int i) { return qty == double(i); }
	+ inline Cut operator != (Cuts::Quantity qty, int i) { return qty != double(i); }
	+ // Cut operator == (Cuts::Quantity qty, int i);
	+ // Cut operator != (Cuts::Quantity qty, int i);
	inline Cut operator < (Cuts::Quantity qty, int i) { return qty < double(i); }
	inline Cut operator > (Cuts::Quantity qty, int i) { return qty > double(i); }
	inline Cut operator <= (Cuts::Quantity qty, int i) { return qty <= double(i); }
	inline Cut operator >= (Cuts::Quantity qty, int i) { return qty >= double(i); }
	//@}

	//@}


	/// @name Cut combiners
	//@{

	/// Logical AND operation on two cuts
	/// @note No comparison short-circuiting for overloaded &&!
	Cut operator && (const Cut & aptr, const Cut & bptr);
	/// Logical OR operation on two cuts
	/// @note No comparison short-circuiting for overloaded \|\|!
	Cut operator \|\| (const Cut & aptr, const Cut & bptr);
	/// Logical NOT operation on a cut
	Cut operator ! (const Cut & cptr);

	/// Logical AND operation on two cuts
	Cut operator & (const Cut & aptr, const Cut & bptr);
	/// Logical OR operation on two cuts
	Cut operator \| (const Cut & aptr, const Cut & bptr);
	/// Logical NOT operation on a cut
	Cut operator ~ (const Cut & cptr);
	/// Logical XOR operation on two cuts
	Cut operator ^ (const Cut & aptr, const Cut & bptr);

	//@}


	}

	#endif
	diff --git a/include/Rivet/Exceptions.hh b/include/Rivet/Tools/Exceptions.hh
	rename from include/Rivet/Exceptions.hh
	rename to include/Rivet/Tools/Exceptions.hh
	diff --git a/include/Rivet/Tools/JetUtils.hh b/include/Rivet/Tools/JetUtils.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Tools/JetUtils.hh
	@@ -0,0 +1,91 @@
	+#ifndef RIVET_JETUTILS_HH
	+#define RIVET_JETUTILS_HH
	+
	+#include "Rivet/Jet.hh"
	+#include "Rivet/Tools/ParticleBaseUtils.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// std::function instantiation for functors taking a Jet and returning a bool
	+ using JetSelector = function<bool(const Jet&)>;
	+ /// std::function instantiation for functors taking two Jets and returning a bool
	+ using JetSorter = function<bool(const Jet&, const Jet&)>;
	+
	+
	+ /// @name Unbound functions for converting between Jets, Particles and PseudoJets
	+ //@{
	+
	+ inline PseudoJets mkPseudoJets(const Particles& ps) {
	+ PseudoJets rtn; rtn.reserve(ps.size());
	+ for (const Particle& p : ps)
	+ rtn.push_back(p);
	+ return rtn;
	+ }
	+
	+ inline PseudoJets mkPseudoJets(const Jets& js) {
	+ PseudoJets rtn; rtn.reserve(js.size());
	+ for (const Jet& j : js)
	+ rtn.push_back(j);
	+ return rtn;
	+ }
	+
	+ inline Jets mkJets(const PseudoJets& pjs) {
	+ Jets rtn; rtn.reserve(pjs.size());
	+ for (const PseudoJet& pj : pjs)
	+ rtn.push_back(pj);
	+ return rtn;
	+ }
	+
	+ //@}
	+
	+
	+ /// @name Unbound functions for filtering jets
	+ //@{
	+
	+ /// Filter a jet collection in-place to the subset that passes the supplied Cut
	+ Jets& ifilter_select(Jets& jets, const Cut& c);
	+ /// Alias for ifilter_select
	+ /// @deprecated Use ifilter_select
	+ inline Jets& ifilterBy(Jets& jets, const Cut& c) { return ifilter_select(jets, c); }
	+
	+ /// Filter a jet collection in-place to the subset that passes the supplied Cut
	+ inline Jets filter_select(const Jets& jets, const Cut& c) {
	+ Jets rtn = jets;
	+ return ifilter_select(rtn, c);
	+ }
	+ /// Alias for ifilter_select
	+ /// @deprecated Use filter_select
	+ inline Jets filterBy(const Jets& jets, const Cut& c) { return filter_select(jets, c); }
	+
	+ /// Filter a jet collection in-place to the subset that passes the supplied Cut
	+ inline Jets filter_select(const Jets& jets, const Cut& c, Jets& out) {
	+ out = filter_select(jets, c);
	+ return out;
	+ }
	+ /// Alias for ifilter_select
	+ /// @deprecated Use filter_select
	+ inline Jets filterBy(const Jets& jets, const Cut& c, Jets& out) { return filter_select(jets, c, out); }
	+
	+
	+ /// Filter a jet collection in-place to the subset that fails the supplied Cut
	+ Jets& ifilter_discard(Jets& jets, const Cut& c);
	+
	+ /// Filter a jet collection in-place to the subset that fails the supplied Cut
	+ inline Jets filter_discard(const Jets& jets, const Cut& c) {
	+ Jets rtn = jets;
	+ return ifilter_discard(rtn, c);
	+ }
	+
	+ /// Filter a jet collection in-place to the subset that fails the supplied Cut
	+ inline Jets filter_discard(const Jets& jets, const Cut& c, Jets& out) {
	+ out = filter_discard(jets, c);
	+ return out;
	+ }
	+
	+ //@}
	+
	+
	+}
	+
	+#endif
	diff --git a/include/Rivet/Tools/ParticleBaseUtils.hh b/include/Rivet/Tools/ParticleBaseUtils.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Tools/ParticleBaseUtils.hh
	@@ -0,0 +1,355 @@
	+#ifndef RIVET_PARTICLEBASEUTILS_HH
	+#define RIVET_PARTICLEBASEUTILS_HH
	+
	+#include "Rivet/ParticleBase.hh"
	+
	+namespace Rivet {
	+
	+
	+
	+ /// @name ParticleBase classifier -> bool functors
	+ /// @todo Move to FourMomentum functions
	+ ///
	+ /// To be passed to any() or all() e.g. any(jets, DeltaRLess(electron, 0.4))
	+ //@{
	+
	+ /// std::function instantiation for functors taking a ParticleBase and returning a bool
	+ using ParticleBaseSelector = function<bool(const ParticleBase&)>;
	+ /// std::function instantiation for functors taking two ParticleBase and returning a bool
	+ using ParticleBaseSorter = function<bool(const ParticleBase&, const ParticleBase&)>;
	+
	+
	+ /// Base type for Particle -> bool functors
	+ struct BoolParticleBaseFunctor {
	+ virtual bool operator()(const ParticleBase& p) const = 0;
	+ };
	+
	+
	+ /// Transverse momentum greater-than functor
	+ struct PtGtr : public BoolParticleBaseFunctor {
	+ PtGtr(double pt) : ptcut(pt) { }
	+ bool operator()(const ParticleBase& p) const { return p.pT() > ptcut; }
	+ double ptcut;
	+ };
	+ using pTGtr = PtGtr;
	+ using ptGtr = PtGtr;
	+
	+ /// Transverse momentum less-than functor
	+ struct PtLess : public BoolParticleBaseFunctor {
	+ PtLess(double pt) : ptcut(pt) { }
	+ bool operator()(const ParticleBase& p) const { return p.pT() < ptcut; }
	+ double ptcut;
	+ };
	+ using pTLess = PtLess;
	+ using ptLess = PtLess;
	+
	+
	+ /// Pseudorapidity greater-than functor
	+ struct EtaGtr : public BoolParticleBaseFunctor {
	+ EtaGtr(double eta) : etacut(eta) { }
	+ bool operator()(const ParticleBase& p) const { return p.eta() > etacut; }
	+ double etacut;
	+ };
	+ using etaGtr = EtaGtr;
	+
	+ /// Pseudorapidity momentum less-than functor
	+ struct EtaLess : public BoolParticleBaseFunctor {
	+ EtaLess(double eta) : etacut(eta) { }
	+ bool operator()(const ParticleBase& p) const { return p.eta() < etacut; }
	+ double etacut;
	+ };
	+ using etaLess = EtaLess;
	+
	+ /// Abs pseudorapidity greater-than functor
	+ struct AbsEtaGtr : public BoolParticleBaseFunctor {
	+ AbsEtaGtr(double abseta) : absetacut(abseta) { }
	+ bool operator()(const ParticleBase& p) const { return p.abseta() > absetacut; }
	+ double absetacut;
	+ };
	+ using absEtaGtr = AbsEtaGtr;
	+ using absetaGtr = AbsEtaGtr;
	+
	+ /// Abs pseudorapidity momentum less-than functor
	+ struct AbsEtaLess : public BoolParticleBaseFunctor {
	+ AbsEtaLess(double abseta) : absetacut(abseta) { }
	+ bool operator()(const ParticleBase& p) const { return p.abseta() < absetacut; }
	+ double absetacut;
	+ };
	+ using absEtaLess = AbsEtaLess;
	+ using absetaLess = AbsEtaLess;
	+
	+
	+ /// Rapidity greater-than functor
	+ struct RapGtr : public BoolParticleBaseFunctor {
	+ RapGtr(double rap) : rapcut(rap) { }
	+ bool operator()(const ParticleBase& p) const { return p.rap() > rapcut; }
	+ double rapcut;
	+ };
	+ using rapGtr = RapGtr;
	+
	+ /// Rapidity momentum less-than functor
	+ struct RapLess : public BoolParticleBaseFunctor {
	+ RapLess(double rap) : rapcut(rap) { }
	+ bool operator()(const ParticleBase& p) const { return p.rap() < rapcut; }
	+ double rapcut;
	+ };
	+ using rapLess = RapLess;
	+
	+ /// Abs rapidity greater-than functor
	+ struct AbsRapGtr : public BoolParticleBaseFunctor {
	+ AbsRapGtr(double absrap) : absrapcut(absrap) { }
	+ bool operator()(const ParticleBase& p) const { return p.absrap() > absrapcut; }
	+ double absrapcut;
	+ };
	+ using absRapGtr = AbsRapGtr;
	+ using absrapGtr = AbsRapGtr;
	+
	+ /// Abs rapidity momentum less-than functor
	+ struct AbsRapLess : public BoolParticleBaseFunctor {
	+ AbsRapLess(double absrap) : absrapcut(absrap) { }
	+ bool operator()(const ParticleBase& p) const { return p.absrap() < absrapcut; }
	+ double absrapcut;
	+ };
	+ using absRapLess = AbsRapLess;
	+ using absrapLess = AbsRapLess;
	+
	+
	+ /// @f$ \Delta R @f$ (with respect to another 4-momentum, @a vec) greater-than functor
	+ struct DeltaRGtr : public BoolParticleBaseFunctor {
	+ DeltaRGtr(const ParticleBase& vec, double dr, RapScheme scheme=PSEUDORAPIDITY)
	+ : refvec(vec.mom()), drcut(dr), rapscheme(scheme) { }
	+ DeltaRGtr(const FourMomentum& vec, double dr, RapScheme scheme=PSEUDORAPIDITY)
	+ : refvec(vec), drcut(dr), rapscheme(scheme) { }
	+ DeltaRGtr(const Vector3& vec, double dr)
	+ : drcut(dr), rapscheme(PSEUDORAPIDITY) { refvec.setPx(vec.x()); refvec.setPy(vec.y()); refvec.setPz(vec.z()); }
	+ bool operator()(const ParticleBase& p) const { return deltaR(p, refvec, rapscheme) > drcut; }
	+ FourMomentum refvec;
	+ double drcut;
	+ RapScheme rapscheme;
	+ };
	+ using deltaRGtr = DeltaRGtr;
	+
	+ /// @f$ \Delta R @f$ (with respect to another 4-momentum, @a vec) less-than functor
	+ struct DeltaRLess : public BoolParticleBaseFunctor {
	+ DeltaRLess(const ParticleBase& vec, double dr, RapScheme scheme=PSEUDORAPIDITY)
	+ : refvec(vec.mom()), drcut(dr), rapscheme(scheme) { }
	+ DeltaRLess(const FourMomentum& vec, double dr, RapScheme scheme=PSEUDORAPIDITY)
	+ : refvec(vec), drcut(dr), rapscheme(scheme) { }
	+ DeltaRLess(const Vector3& vec, double dr)
	+ : drcut(dr), rapscheme(PSEUDORAPIDITY) { refvec.setPx(vec.x()); refvec.setPy(vec.y()); refvec.setPz(vec.z()); }
	+ bool operator()(const ParticleBase& p) const { return deltaR(p, refvec, rapscheme) < drcut; }
	+ FourMomentum refvec;
	+ double drcut;
	+ RapScheme rapscheme;
	+ };
	+ using deltaRLess = DeltaRLess;
	+
	+
	+ /// @f$ \|\Delta \phi\| @f$ (with respect to another momentum, @a vec) greater-than functor
	+ struct DeltaPhiGtr : public BoolParticleBaseFunctor {
	+ DeltaPhiGtr(const ParticleBase& vec, double dphi)
	+ : refvec(vec.p3()), dphicut(dphi) { }
	+ DeltaPhiGtr(const FourMomentum& vec, double dphi)
	+ : refvec(vec.p3()), dphicut(dphi) { }
	+ DeltaPhiGtr(const Vector3& vec, double dphi)
	+ : refvec(vec), dphicut(dphi) { }
	+ bool operator()(const ParticleBase& p) const { return deltaPhi(p, refvec) > dphicut; }
	+ Vector3 refvec;
	+ double dphicut;
	+ };
	+ using deltaPhiGtr = DeltaPhiGtr;
	+
	+ /// @f$ \|\Delta \phi\| @f$ (with respect to another momentum, @a vec) less-than functor
	+ struct DeltaPhiLess : public BoolParticleBaseFunctor {
	+ DeltaPhiLess(const ParticleBase& vec, double dphi)
	+ : refvec(vec.p3()), dphicut(dphi) { }
	+ DeltaPhiLess(const FourMomentum& vec, double dphi)
	+ : refvec(vec.p3()), dphicut(dphi) { }
	+ DeltaPhiLess(const Vector3& vec, double dphi)
	+ : refvec(vec), dphicut(dphi) { }
	+ bool operator()(const ParticleBase& p) const { return deltaPhi(p, refvec) < dphicut; }
	+ Vector3 refvec;
	+ double dphicut;
	+ };
	+ using deltaPhiLess = DeltaPhiLess;
	+
	+
	+ /// @f$ \|\Delta \eta\| @f$ (with respect to another momentum, @a vec) greater-than functor
	+ struct DeltaEtaGtr : public BoolParticleBaseFunctor {
	+ DeltaEtaGtr(const ParticleBase& vec, double deta)
	+ : refvec(vec.p3()), detacut(deta) { }
	+ DeltaEtaGtr(const FourMomentum& vec, double deta)
	+ : refvec(vec.p3()), detacut(deta) { }
	+ DeltaEtaGtr(const Vector3& vec, double deta)
	+ : refvec(vec), detacut(deta) { }
	+ bool operator()(const ParticleBase& p) const { return std::abs(deltaEta(p, refvec)) > detacut; }
	+ Vector3 refvec;
	+ double detacut;
	+ };
	+ using deltaEtaGtr = DeltaEtaGtr;
	+
	+ /// @f$ \|\Delta \eta\| @f$ (with respect to another momentum, @a vec) less-than functor
	+ struct DeltaEtaLess : public BoolParticleBaseFunctor {
	+ DeltaEtaLess(const ParticleBase& vec, double deta)
	+ : refvec(vec.p3()), detacut(deta) { }
	+ DeltaEtaLess(const FourMomentum& vec, double deta)
	+ : refvec(vec.p3()), detacut(deta) { }
	+ DeltaEtaLess(const Vector3& vec, double deta)
	+ : refvec(vec), detacut(deta) { }
	+ bool operator()(const ParticleBase& p) const { return std::abs(deltaEta(p, refvec)) < detacut; }
	+ Vector3 refvec;
	+ double detacut;
	+ };
	+ using deltaEtaLess = DeltaEtaLess;
	+
	+
	+ /// @f$ \|\Delta y\| @f$ (with respect to another momentum, @a vec) greater-than functor
	+ struct DeltaRapGtr : public BoolParticleBaseFunctor {
	+ DeltaRapGtr(const ParticleBase& vec, double drap)
	+ : refvec(vec.mom()), drapcut(drap) { }
	+ DeltaRapGtr(const FourMomentum& vec, double drap)
	+ : refvec(vec), drapcut(drap) { }
	+ bool operator()(const ParticleBase& p) const { return std::abs(deltaRap(p, refvec)) > drapcut; }
	+ FourMomentum refvec;
	+ double drapcut;
	+ };
	+ using deltaRapGtr = DeltaRapGtr;
	+
	+ /// @f$ \|\Delta y\| @f$ (with respect to another momentum, @a vec) less-than functor
	+ struct DeltaRapLess : public BoolParticleBaseFunctor {
	+ DeltaRapLess(const ParticleBase& vec, double drap)
	+ : refvec(vec.mom()), drapcut(drap) { }
	+ DeltaRapLess(const FourMomentum& vec, double drap)
	+ : refvec(vec), drapcut(drap) { }
	+ bool operator()(const ParticleBase& p) const { return std::abs(deltaRap(p, refvec)) < drapcut; }
	+ FourMomentum refvec;
	+ double drapcut;
	+ };
	+ using deltaRapLess = DeltaRapLess;
	+
	+ //@}
	+
	+
	+ /// @name ParticleBase comparison -> double functors
	+ /// @todo Move to FourMomentum functions
	+ ///
	+ /// To be passed to transform()any(jets, DeltaRLess(electron, 0.4))
	+ //@{
	+
	+ /// Base type for Particle -> double functors
	+ struct DoubleParticleBaseFunctor {
	+ virtual double operator()(const ParticleBase& p) const = 0;
	+ };
	+
	+ /// Calculator of @f$ \Delta R @f$ with respect to a given momentum
	+ struct DeltaRWRT : public DoubleParticleBaseFunctor {
	+ DeltaRWRT(const ParticleBase& pb, RapScheme scheme=PSEUDORAPIDITY) : p(pb.mom()) {}
	+ DeltaRWRT(const FourMomentum& p4, RapScheme scheme=PSEUDORAPIDITY) : p(p4) {}
	+ DeltaRWRT(const Vector3& p3) : p(p3.mod(), p3.x(), p3.y(), p3.z()), rapscheme(PSEUDORAPIDITY) {}
	+ double operator()(const ParticleBase& pb) const { return deltaR(p, pb, rapscheme); }
	+ double operator()(const FourMomentum& p4) const { return deltaR(p, p4, rapscheme); }
	+ double operator()(const Vector3& p3) const { return deltaR(p, p3); }
	+ const FourMomentum p;
	+ RapScheme rapscheme;
	+ };
	+ using deltaRWRT = DeltaRWRT;
	+
	+ /// Calculator of @f$ \Delta \phi @f$ with respect to a given momentum
	+ struct DeltaPhiWRT : public DoubleParticleBaseFunctor {
	+ DeltaPhiWRT(const ParticleBase& pb) : p(pb.mom().vector3()) {}
	+ DeltaPhiWRT(const FourMomentum& p4) : p(p4.vector3()) {}
	+ DeltaPhiWRT(const Vector3& p3) : p(p3) {}
	+ double operator()(const ParticleBase& pb) const { return deltaPhi(p, pb); }
	+ double operator()(const FourMomentum& p4) const { return deltaPhi(p, p4); }
	+ double operator()(const Vector3& p3) const { return deltaPhi(p, p3); }
	+ const Vector3 p;
	+ };
	+ using deltaPhiWRT = DeltaPhiWRT;
	+
	+ /// Calculator of @f$ \Delta \eta @f$ with respect to a given momentum
	+ struct DeltaEtaWRT : public DoubleParticleBaseFunctor {
	+ DeltaEtaWRT(const ParticleBase& pb) : p(pb.mom().vector3()) {}
	+ DeltaEtaWRT(const FourMomentum& p4) : p(p4.vector3()) {}
	+ DeltaEtaWRT(const Vector3& p3) : p(p3) {}
	+ double operator()(const ParticleBase& pb) const { return deltaEta(p, pb); }
	+ double operator()(const FourMomentum& p4) const { return deltaEta(p, p4); }
	+ double operator()(const Vector3& p3) const { return deltaEta(p, p3); }
	+ const Vector3 p;
	+ };
	+ using deltaEtaWRT = DeltaEtaWRT;
	+
	+ /// Calculator of @f$ \|\Delta \eta\| @f$ with respect to a given momentum
	+ struct AbsDeltaEtaWRT : public DoubleParticleBaseFunctor {
	+ AbsDeltaEtaWRT(const ParticleBase& pb) : p(pb.mom().vector3()) {}
	+ AbsDeltaEtaWRT(const FourMomentum& p4) : p(p4.vector3()) {}
	+ AbsDeltaEtaWRT(const Vector3& p3) : p(p3) {}
	+ double operator()(const ParticleBase& pb) const { return fabs(deltaEta(p, pb)); }
	+ double operator()(const FourMomentum& p4) const { return fabs(deltaEta(p, p4)); }
	+ double operator()(const Vector3& p3) const { return fabs(deltaEta(p, p3)); }
	+ const Vector3 p;
	+ };
	+ using absDeltaEtaWRT = AbsDeltaEtaWRT;
	+
	+ /// Calculator of @f$ \Delta y @f$ with respect to a given momentum
	+ struct DeltaRapWRT : public DoubleParticleBaseFunctor {
	+ DeltaRapWRT(const ParticleBase& pb) : p(pb.mom()) {}
	+ DeltaRapWRT(const FourMomentum& p4) : p(p4) {}
	+ double operator()(const ParticleBase& pb) const { return deltaRap(p, pb); }
	+ double operator()(const FourMomentum& p4) const { return deltaRap(p, p4); }
	+ const FourMomentum p;
	+ };
	+ using deltaRapWRT = DeltaRapWRT;
	+
	+ /// Calculator of @f$ \|\Delta y\| @f$ with respect to a given momentum
	+ struct AbsDeltaRapWRT : public DoubleParticleBaseFunctor {
	+ AbsDeltaRapWRT(const ParticleBase& pb) : p(pb.mom()) {}
	+ AbsDeltaRapWRT(const FourMomentum& p4) : p(p4) {}
	+ double operator()(const ParticleBase& pb) const { return fabs(deltaRap(p, pb)); }
	+ double operator()(const FourMomentum& p4) const { return fabs(deltaRap(p, p4)); }
	+ const FourMomentum p;
	+ };
	+ using absDeltaRapWRT = AbsDeltaRapWRT;
	+
	+ //@}
	+
	+
	+ /// @name Non-PID particle properties, via unbound functions
	+ /// @todo Mostly move to functions on FourMomentum
	+ //@{
	+
	+ /// Unbound function access to momentum
	+ inline FourMomentum mom(const ParticleBase& p) { return p.mom(); }
	+
	+ /// Unbound function access to p3
	+ inline Vector3 p3(const ParticleBase& p) { return p.p3(); }
	+
	+ /// Unbound function access to pTvec
	+ inline Vector3 pTvec(const ParticleBase& p) { return p.pTvec(); }
	+
	+ /// Unbound function access to p
	+ inline double p(const ParticleBase& p) { return p.p(); }
	+
	+ /// Unbound function access to pT
	+ inline double pT(const ParticleBase& p) { return p.pT(); }
	+
	+ /// Unbound function access to ET
	+ inline double Et(const ParticleBase& p) { return p.Et(); }
	+
	+ /// Unbound function access to eta
	+ inline double eta(const ParticleBase& p) { return p.eta(); }
	+
	+ /// Unbound function access to abseta
	+ inline double abseta(const ParticleBase& p) { return p.abseta(); }
	+
	+ /// Unbound function access to rapidity
	+ inline double rap(const ParticleBase& p) { return p.rap(); }
	+
	+ /// Unbound function access to abs rapidity
	+ inline double absrap(const ParticleBase& p) { return p.absrap(); }
	+
	+ //@}
	+
	+
	+}
	+
	+#endif
	diff --git a/include/Rivet/Tools/ParticleIdUtils.hh b/include/Rivet/Tools/ParticleIdUtils.hh
	--- a/include/Rivet/Tools/ParticleIdUtils.hh
	+++ b/include/Rivet/Tools/ParticleIdUtils.hh
	@@ -1,768 +1,784 @@
	// -- C++ --
	//
	// This file is part of MCUtils -- https://bitbucket.org/andybuckley/mcutils
	// Copyright (C) 2013-2016 Andy Buckley <andy.buckley@cern.ch>
	//
	// Embedding of MCUtils code in other projects is permitted provided this
	// notice is retained and the MCUtils namespace and include path are changed.
	//
	#ifndef RIVET_PARTICLEIDUTILS_HH
	#define RIVET_PARTICLEIDUTILS_HH

	/// @file Utility functions for querying PDG ID codes (many from HepPID)
	/// @author Andy Buckley <andy.buckley@cern.ch>

	-//#include "Rivet/Tools/MCUtils/PIDCodes.h"
	+#include "Rivet/Tools/ParticleName.hh"
	#include "Rivet/Math/MathUtils.hh"

	namespace Rivet {
	namespace PID {


	/// @name Utility functions
	//@{

	/// Absolute value
	/// @deprecated Just use abs()!
	inline int abspid(int pid) { return abs(pid); }

	/// PID digits (base 10) are: n nr nl nq1 nq2 nq3 nj
	/// The Location enum provides a convenient index into the PID.
	enum Location { nj=1, nq3, nq2, nq1, nl, nr, n, n8, n9, n10 };

	/// Split the PID into constituent integers
	inline unsigned short _digit(Location loc, int pid) {
	// PID digits (base 10) are: n nr nl nq1 nq2 nq3 nj (cf. Location)
	int numerator = (int) std::pow(10.0, (loc-1));
	return (abs(pid)/numerator) % 10;
	}

	/// Returns everything beyond the 7th digit (e.g. outside the numbering scheme)
	inline int _extraBits(int pid) {
	return abs(pid)/10000000;
	}

	/// @brief Return the first two digits if this is a "fundamental" particle
	/// @note ID = 100 is a special case (internal generator ID's are 81-100)
	inline int _fundamentalID(int pid) {
	if (_extraBits(pid) > 0) return 0;
	if (_digit(nq2,pid) == 0 && _digit(nq1,pid) == 0) {
	return abs(pid) % 10000;
	} else if (abs(pid) <= 100) {
	return abs(pid);
	} else {
	return 0;
	}
	}

	//@}


	/// @name Nucleus/ion functions
	//@{

	/// @brief Is this a nucleus PID?
	///
	/// This implements the 2006 Monte Carlo nuclear code scheme.
	/// Ion numbers are +/- 10LZZZAAAI.
	/// AAA is A - total baryon number
	/// ZZZ is Z - total charge
	/// L is the total number of strange quarks.
	/// I is the isomer number, with I=0 corresponding to the ground state.
	inline bool isNucleus(int pid) {
	// a proton can also be a Hydrogen nucleus
	if (abs(pid) == 2212) return true;
	// new standard: +/- 10LZZZAAAI
	if ((_digit(n10,pid) == 1) && (_digit(n9,pid) == 0)) {
	// charge should always be less than or equal to baryon number
	// the following line is A >= Z
	if ((abs(pid)/10)%1000 >= (abs(pid)/10000)%1000) return true;
	}
	return false;
	}

	/// Get the atomic number (number of protons) in a nucleus/ion
	/// @note Ion numbers are +/- 10LZZZAAAI.
	inline int nuclZ(int pid) {
	// A proton can also be a Hydrogen nucleus
	if (abs(pid) == 2212) { return 1; }
	if (isNucleus(pid)) return (abs(pid)/10000) % 1000;
	return 0;
	}
	/// Alias for nuclZ
	/// @deprecated Use nuclZ
	inline int Z(int pid) { return nuclZ(pid); }

	/// Get the atomic weight (number of nucleons) in a nucleus/ion
	/// @note Ion numbers are +/- 10LZZZAAAI.
	inline int nuclA(int pid) {
	// A proton can also be a Hydrogen nucleus, and we might as well also allow single neutrons
	if (abs(pid) == 2212 \|\| abs(pid) == 2112) { return 1; }
	if (isNucleus(pid)) return (abs(pid)/10) % 1000;
	return 0;
	}
	/// Alias for nuclA
	/// @deprecated Use nuclA
	inline int A(int pid) { return nuclA(pid); }

	/// If this is a nucleus (ion), get nLambda
	/// @note Ion numbers are +/- 10LZZZAAAI.
	inline int nuclNlambda(int pid) {
	// a proton can also be a Hydrogen nucleus
	if (abs(pid) == 2212) { return 0; }
	if (isNucleus(pid)) return _digit(n8,pid);
	return 0;
	}
	/// Alias for nuclNlambda
	/// @deprecated Use nuclNlambda
	inline int lambda(int pid) { return nuclNlambda(pid); }

	//@}


	/// @name Quark composite functions
	//@{

	/// Is this a pomeron, odderon, or generic reggeon?
	inline bool isReggeon(int pid) {
	return pid == 110 \|\| pid == 990 \|\| pid == 9990;
	}

	/// Check to see if this is a valid meson
	inline bool isMeson(int pid) {
	if (_extraBits(pid) > 0) return false;
	const int aid = abs(pid);
	if (aid == 130 \|\| aid == 310 \|\| aid == 210) return true; //< special cases for kaons
	if (aid <= 100) return false;
	if (_digit(nq1,pid) != 0) return false;
	if (_digit(nq2,pid) == 0) return false;
	if (_digit(nq3,pid) == 0) return false;
	if (_digit(nq2,pid) < _digit(nq3,pid)) return false;
	// EvtGen uses some odd numbers
	/// @todo Remove special-casing for EvtGen
	if (aid == 150 \|\| aid == 350 \|\| aid == 510 \|\| aid == 530) return true;
	// Pomeron, Reggeon, etc.
	if (isReggeon(pid)) return false; //true; //< WTF?
	// Check for illegal antiparticles
	if (_digit(nj,pid) > 0 && _digit(nq3,pid) > 0 && _digit(nq2,pid) > 0 && _digit(nq1,pid) == 0) {
	return !(_digit(nq3,pid) == _digit(nq2,pid) && pid < 0);
	}
	return false;
	}

	/// Check to see if this is a valid baryon
	inline bool isBaryon(int pid) {
	if (_extraBits(pid) > 0) return false;
	if (abs(pid) <= 100) return false;
	if (_fundamentalID(pid) <= 100 && _fundamentalID(pid) > 0) return false;
	if (abs(pid) == 2110 \|\| abs(pid) == 2210) return true; ///< @todo Why this special case with nJ = 0? What are these? Not listed in RPP MC doc...
	if (_digit(nj,pid) == 0) return false;
	if (_digit(nq1,pid) == 0 \|\| _digit(nq2,pid) == 0 \|\| _digit(nq3,pid) == 0) return false;
	return true;
	/// @todo This is more correct by the definition, but the PDG's entries 1212, 1214, 1216, 1218 and 2122, 2124, 2126, 2128 come out as invalid
	// if ((_digit(nq1,pid) >= _digit(nq2,pid) && _digit(nq2,pid) >= _digit(nq3,pid)) \|\|
	// (_digit(nq1,pid) > _digit(nq3,pid) && _digit(nq3,pid) > _digit(nq2,pid)) \|\| //< case 6b for lighter quarks in J=1
	// (_digit(nq3,pid) > _digit(nq1,pid) && _digit(nq1,pid) > _digit(nq2,pid))) //< case 6e for extra states in excited multiplets
	// return true;
	// return false;
	}

	// Check to see if this is a valid diquark
	inline bool isDiquark(int pid) {
	if (_extraBits(pid) > 0) return false;
	if (abs(pid) <= 100) return false;
	if (_fundamentalID(pid) <= 100 && _fundamentalID(pid) > 0) return false;
	if (_digit(nq1,pid) == 0) return false;
	if (_digit(nq2,pid) == 0) return false;
	if (_digit(nq3,pid) != 0) return false;
	if (_digit(nq1,pid) < _digit(nq2,pid)) return false;
	if (_digit(nj,pid) > 0 && _digit(nq3,pid) == 0 && _digit(nq2,pid) > 0 && _digit(nq1,pid) > 0) return true; // diquark signature
	// EvtGen uses the diquarks for quark pairs, so, for instance, 5501 is a valid "diquark" for EvtGen
	// if (_digit(nj) == 1 && _digit(nq2) == _digit(nq1)) { // illegal
	// return false;
	// } else {
	// return true;
	// }
	return false;
	}
	/// @deprecated Use the nicer capitalisation isDiquark(pid)
	inline bool isDiQuark(int pid) { return isDiquark(pid); }

	/// Check to see if this is a valid pentaquark
	inline bool isPentaquark(int pid) {
	// a pentaquark is of the form 9abcdej,
	// where j is the spin and a, b, c, d, and e are quarks
	if (_extraBits(pid) > 0) return false;
	if (_digit(n,pid) != 9) return false;
	if (_digit(nr,pid) == 9 \|\| _digit(nr,pid) == 0) return false;
	if (_digit(nj,pid) == 9 \|\| _digit(nl,pid) == 0) return false;
	if (_digit(nq1,pid) == 0) return false;
	if (_digit(nq2,pid) == 0) return false;
	if (_digit(nq3,pid) == 0) return false;
	if (_digit(nj,pid) == 0) return false;
	// check ordering
	if (_digit(nq2,pid) > _digit(nq1,pid)) return false;
	if (_digit(nq1,pid) > _digit(nl,pid)) return false;
	if (_digit(nl,pid) > _digit(nr,pid)) return false;
	return true;
	}

	/// Is this a valid hadron ID?
	inline bool isHadron(int pid) {
	if (_extraBits(pid) > 0) return false;
	if (isMeson(pid)) return true;
	if (isBaryon(pid)) return true;
	if (isPentaquark(pid)) return true;
	return false;
	}

	//@}


	/// @name More general particle class identification functions
	//@{

	/// Is this a valid lepton ID?
	inline bool isLepton(int pid) {
	if (_extraBits(pid) > 0) return false;
	if (_fundamentalID(pid) >= 11 && _fundamentalID(pid) <= 18) return true;
	return false;
	}

	/// Is this a fundamental SUSY particle?
	inline bool isSUSY(int pid) {
	// Fundamental SUSY particles have n = 1 or 2
	if (_extraBits(pid) > 0) return false;
	if (_digit(n,pid) != 1 && _digit(n,pid) != 2) return false;
	if (_digit(nr,pid) != 0) return false;
	// Check fundamental part for SM PID on which it is based
	if (_fundamentalID(pid) == 0) return false;
	return true;
	}

	/// Is this an R-hadron?
	inline bool isRhadron(int pid) {
	// An R-hadron is of the form 10abcdj,
	// where j is the spin and a, b, c, and d are quarks or gluons
	if (_extraBits(pid) > 0) return false;
	if (_digit(n,pid) != 1) return false;
	if (_digit(nr,pid) != 0) return false;
	// Make sure this isn't a SUSY particle
	if (isSUSY(pid)) return false;
	// All R-hadrons have at least 3 core digits
	if (_digit(nq2,pid) == 0) return false;
	if (_digit(nq3,pid) == 0) return false;
	if (_digit(nj,pid) == 0) return false;
	return true;
	}
	inline bool isRHadron(int pid) { return isRhadron(pid); }

	/// Is this a technicolor particle?
	inline bool isTechnicolor(int pid) {
	if (_extraBits(pid) > 0) return false;
	return _digit(n,pid) == 3;
	}

	/// Is this an excited (composite) quark or lepton?
	inline bool isExcited(int pid) {
	if (_extraBits(pid) > 0) return false;
	return _digit(n,pid) == 4;
	}

	/// Is this a Kaluza-Klein excitation?
	inline bool isKK(int pid) {
	if (_extraBits(pid) > 0) return false;
	const int ndigit = _digit(n,pid);
	return ndigit == 5 \|\| ndigit == 6;
	}

	/// Is this a graviton?
	inline bool isGraviton(int pid) {
	return pid == 39;
	}

	/// Is this a BSM particle (including graviton)?
	inline bool isBSM(int pid) {
	return isSUSY(pid) \|\| isRhadron(pid) \|\| isTechnicolor(pid) \|\|
	isExcited(pid) \|\| isKK(pid) \|\| isGraviton(pid);
	}

	/// Check to see if this is a valid PID (i.e. matches any known scheme)
	inline bool _isValid(int pid) {
	// Starting with 99 means anything goes (but nothing is known)
	if (_digit(n,pid) == 9 && _digit(nr,pid) == 9) return true;
	// Check that extra bits are only used for nuclei
	if (_extraBits(pid) > 0) return isNucleus(pid);
	// Check that it fits into a standard non-nucleus convention
	if (isBSM(pid)) return true;
	if (isHadron(pid)) return true;
	if (_digit(n,pid) == 9 && _digit(nr,pid) == 0) return false; // could only have been a tentative hadron, but !isHadron
	if (isDiquark(pid)) return true;
	if (isReggeon(pid)) return true;
	// // Quark digit orderings required by the standard
	// if (_digit(nq1,pid) != 0 && _digit(nq1,pid) < _digit(nq2,pid)) return false;
	// if (_digit(nq2,pid) != 0 && _digit(nq2,pid) < _digit(nq3,pid)) return false;
	// Final check on fundamental ID
	return (_fundamentalID(pid) > 0);
	}
	inline bool isValid(int pid) { return _isValid(pid); }

	//@}


	/// @name Parton content functions
	//@{

	inline bool _hasQ(int pid, int q) {
	if (abs(pid) == q) return true; //< trivial case!
	if (!_isValid(pid)) return false;
	if (_extraBits(pid) > 0) return false;
	if (_fundamentalID(pid) > 0) return false;
	return _digit(nq3,pid) == q \|\| _digit(nq2,pid) == q \|\| _digit(nq1,pid) == q;
	}

	/// Does this particle contain a down quark?
	inline bool hasDown(int pid) { return _hasQ(pid, 1); }
	/// Does this particle contain an up quark?
	inline bool hasUp(int pid) { return _hasQ(pid, 2); }
	/// Does this particle contain a strange quark?
	inline bool hasStrange(int pid) { return _hasQ(pid, 3); }
	/// Does this particle contain a charm quark?
	inline bool hasCharm(int pid) { return _hasQ(pid, 4); }
	/// Does this particle contain a bottom quark?
	inline bool hasBottom(int pid) { return _hasQ(pid, 5); }
	/// Does this particle contain a top quark?
	inline bool hasTop(int pid) { return _hasQ(pid, 6); }

	//@}


	/// @name Angular momentum functions
	//@{

	/// jSpin returns 2J+1, where J is the total spin
	inline int jSpin(int pid) {
	const int fund = _fundamentalID(pid);
	if (fund > 0) {
	// some of these are known
	if (fund > 0 && fund < 7) return 2;
	if (fund == 9) return 3;
	if (fund > 10 && fund < 17) return 2;
	if (fund > 20 && fund < 25) return 3;
	return 0;
	} else if (_extraBits(pid) > 0) {
	return 0;
	}
	return abs(pid) % 10;
	}

	/// sSpin returns 2S+1, where S is the spin
	inline int sSpin(int pid) {
	// Handle invalid cases first
	if (!isMeson(pid)) return 0;
	if (_digit(n,pid) == 9 && _digit(nr,pid) == 0) return 0; // tentative ID
	// Special generic DM particles with defined spins
	const int fund = _fundamentalID(pid);
	if (fund == 51 \|\| fund == 54) return 1;
	if (fund == 52) return 2;
	if (fund == 53 \|\| fund == 55) return 3;
	// Calculate from nl and nj digits
	const int inl = _digit(nl,pid);
	const int js = _digit(nj,pid);
	if (inl == 0 && js >= 3) return 1;
	else if (inl == 0 && js == 1) return 0;
	else if (inl == 1 && js >= 3) return 0;
	else if (inl == 2 && js >= 3) return 1;
	else if (inl == 1 && js == 1) return 1;
	else if (inl == 3 && js >= 3) return 1;
	// Default to zero
	return 0;
	}

	/// lSpin returns 2L+1, where L is the orbital angular momentum
	inline int lSpin(int pid) {
	// Handle invalid cases first
	if (!isMeson(pid)) return 0;
	if (_digit(n,pid) == 9 && _digit(nr,pid) == 0) return 0; // tentative ID
	// Calculate from nl and nj digits
	const int inl = _digit(nl,pid);
	const int js = _digit(nj,pid);
	if (inl == 0 && js == 3) return 0;
	else if (inl == 0 && js == 5) return 1;
	else if (inl == 0 && js == 7) return 2;
	else if (inl == 0 && js == 9) return 3;
	else if (inl == 0 && js == 1) return 0;
	else if (inl == 1 && js == 3) return 1;
	else if (inl == 1 && js == 5) return 2;
	else if (inl == 1 && js == 7) return 3;
	else if (inl == 1 && js == 9) return 4;
	else if (inl == 2 && js == 3) return 1;
	else if (inl == 2 && js == 5) return 2;
	else if (inl == 2 && js == 7) return 3;
	else if (inl == 2 && js == 9) return 4;
	else if (inl == 1 && js == 1) return 1;
	else if (inl == 3 && js == 3) return 2;
	else if (inl == 3 && js == 5) return 3;
	else if (inl == 3 && js == 7) return 4;
	else if (inl == 3 && js == 9) return 5;
	// Default to zero
	return 0;
	}

	//@}


	/// @name Charge functions
	//@{

	/// Three times the EM charge (as integer)
	inline int charge3(int pid) {
	static int ch100[100] = { -1, 2,-1, 2,-1, 2,-1, 2, 0, 0,
	-3, 0,-3, 0,-3, 0,-3, 0, 0, 0,
	0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 3, 0, 0, 3, 0, 0, 0,
	0, -1, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 6, 3, 6, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
	const unsigned short q1 = _digit(nq1,pid);
	const unsigned short q2 = _digit(nq2,pid);
	const unsigned short q3 = _digit(nq3,pid);
	const int ida = abs(pid);
	const int sid = _fundamentalID(pid);
	int charge = 0;
	if (ida == 0 \|\| _extraBits(pid) > 0) {// ion or illegal
	return 0;
	} else if (sid > 0 && sid <= 100) {// use table
	if (ida == 1000017 \|\| ida == 1000018 \|\| ida == 1000034) charge = 0;
	else if (ida > 1000050 && ida <= 1000060) charge = 0; // ?
	else if (ida > 50 && ida <= 60) charge = 0; // Generic DM
	else if (ida == 5100061 \|\| ida == 5100062) charge = 6;
	else charge = ch100[sid-1];
	} else if (_digit(nj,pid) == 0) {// KL, Ks, or undefined
	return 0;
	} else if (isMeson(pid)) {// mesons
	if (q2 == 3 \|\| q2 == 5) {
	charge = ch100[q3-1] - ch100[q2-1];
	} else {
	charge = ch100[q2-1] - ch100[q3-1];
	}
	} else if (isDiQuark(pid)) {// diquarks
	charge = ch100[q2-1] + ch100[q1-1];
	} else if (isBaryon(pid)) {// baryons
	charge = ch100[q3-1] + ch100[q2-1] + ch100[q1-1];
	} else {// unknown
	return 0;
	}
	if (pid < 0) charge *= -1;
	return charge;
	}

	/// Alias for charge3
	/// @deprecated Prefer charge3
	inline int threeCharge(int pid) { return charge3(pid); }

	/// Return the absolute value of 3 times the EM charge
	inline int abscharge3(int pid) { return std::abs(charge3(pid)); }

	/// Return the EM charge (as floating point)
	inline double charge(int pid) { return charge3(pid)/3.0; }

	- /// Return the EM charge (as floating point)
	- inline double abscharge(int pid) { return std::abs(charge(pid)); }
	+ /// Return the absolute value of the EM charge (as floating point)
	+ inline double abscharge(int pid) { return abscharge3(pid)/3.0; }

	//@}


	/// @name General PID-based classifier functions
	//@{

	/// Determine if the particle is electrically charged
	inline bool isCharged(int pid) {
	return charge3(pid) != 0;
	}

	/// Determine if the particle is electrically neutral
	inline bool isNeutral(int pid) {
	return charge3(pid) == 0;
	}

	//@}


	/// @name Fundamental particles
	//@{

	/// Determine if the PID is that of a quark
	inline bool isQuark(int pid) {
	return in_closed_range(abs(pid), 1, 6);
	}

	/// Determine if the PID is that of a gluon
	inline bool isGluon(int pid) {
	return pid == GLUON;
	}

	/// Determine if the PID is that of a parton (quark or gluon)
	inline bool isParton(int pid) {
	return isGluon(pid) \|\| isQuark(pid);
	}

	/// Determine if the PID is that of a photon
	inline bool isPhoton(int pid) {
	return pid == PHOTON;
	}

	/// Determine if the PID is that of an electron or positron
	inline bool isElectron(int pid) {
	return abs(pid) == ELECTRON;
	}

	/// Determine if the PID is that of an muon or antimuon
	inline bool isMuon(int pid) {
	return abs(pid) == MUON;
	}

	/// Determine if the PID is that of an tau or antitau
	inline bool isTau(int pid) {
	return abs(pid) == TAU;
	}

	/// Determine if the PID is that of a charged lepton
	- inline bool isChLepton(int pid) {
	+ inline bool isChargedLepton(int pid) {
	const long apid = abs(pid);
	return apid == 11 \|\| apid == 13 \|\| apid == 15;
	}
	+ // Alias
	+ inline bool isChLepton(int pid) { return isChargedLepton(pid); }

	/// Determine if the PID is that of a neutrino
	inline bool isNeutrino(int pid) {
	const long apid = abs(pid);
	return apid == 12 \|\| apid == 14 \|\| apid == 16;
	}



	/// @todo Add isElectron, Muon, Tau (and +- specific versions?)... and is(Anti)Proton?

	/// Determine if the PID is that of a W+
	inline bool isWplus(int pid) {
	return pid == WPLUSBOSON;
	}

	/// Determine if the PID is that of a W-
	inline bool isWminus(int pid) {
	return pid == WMINUSBOSON;
	}

	/// Determine if the PID is that of a W+-
	inline bool isW(int pid) {
	return abs(pid) == WPLUSBOSON;
	}

	/// Determine if the PID is that of a Z0
	inline bool isZ(int pid) {
	return pid == Z0BOSON;
	}

	/// Determine if the PID is that of an SM/lightest SUSY Higgs
	inline bool isHiggs(int pid) {
	return pid == HIGGSBOSON \|\| pid == 26; //< @todo Check on 26 still needed? (used in HERWIG SUSY, for example)
	}

	/// @todo isSUSYHiggs?

	+
	+ // /// Determine if the PID is that of a d/dbar
	+ // inline bool isDown(int pid) { return abs(pid) == DQUARK; }
	+
	+ // /// Determine if the PID is that of a u/ubar
	+ // inline bool isUp(int pid) { return abs(pid) == UQUARK; }
	+
	+ /// Determine if the PID is that of a s/sbar
	+ inline bool isStrange(int pid) { return abs(pid) == SQUARK; }
	+
	+ /// Determine if the PID is that of a c/cbar
	+ inline bool isCharm(int pid) { return abs(pid) == CQUARK; }
	+
	+ /// Determine if the PID is that of a b/bbar
	+ inline bool isBottom(int pid) { return abs(pid) == BQUARK; }
	+
	/// Determine if the PID is that of a t/tbar
	- inline bool isTop(int pid) {
	- return abs(pid) == 6;
	- }
	+ inline bool isTop(int pid) { return abs(pid) == TQUARK; }

	//@}


	/// @name Hadron and parton flavour classification
	//@{

	/// Determine if the particle is a heavy flavour hadron or parton
	inline bool isHeavyFlavour(int pid) {
	return hasCharm(pid) \|\| hasBottom(pid) \|\| hasTop(pid);
	}

	// /// Determine if the particle is a light-flavour flavour hadron or parton
	// inline bool isLightFlavour(int pid) {
	// return !isHeavyFlavour();
	// }

	/// Determine if the PID is that of a heavy parton (c,b,t)
	inline bool isHeavyParton(int pid) {
	return isParton(pid) && isHeavyFlavour(pid);
	}

	/// Determine if the PID is that of a light parton (u,d,s)
	inline bool isLightParton(int pid) {
	return isParton(pid) && !isHeavyFlavour(pid);
	}


	/// Determine if the PID is that of a heavy flavour (b or c) meson
	inline bool isHeavyMeson(int pid) {
	return isMeson(pid) && isHeavyFlavour(pid);
	}

	/// Determine if the PID is that of a heavy flavour (b or c) baryon
	inline bool isHeavyBaryon(int pid) {
	return isBaryon(pid) && isHeavyFlavour(pid);
	}

	/// Determine if the PID is that of a heavy flavour (b or c) hadron
	inline bool isHeavyHadron(int pid) {
	return isHadron(pid) && isHeavyFlavour(pid);
	}

	/// Determine if the PID is that of a light flavour (not b or c) meson
	inline bool isLightMeson(int pid) {
	return isMeson(pid) && !isHeavyFlavour(pid);
	}

	/// Determine if the PID is that of a light flavour (not b or c) baryon
	inline bool isLightBaryon(int pid) {
	return isBaryon(pid) && !isHeavyFlavour(pid);
	}

	/// Determine if the PID is that of a light flavour (not b or c) hadron
	inline bool isLightHadron(int pid) {
	return isHadron(pid) && !isHeavyFlavour(pid);
	}


	/// Determine if the PID is that of a b-meson.
	inline bool isBottomMeson(int pid) {
	return hasBottom(pid) && isMeson(pid);
	}

	/// Determine if the PID is that of a b-baryon.
	inline bool isBottomBaryon(int pid) {
	return hasBottom(pid) && isBaryon(pid);
	}

	/// Determine if the PID is that of a b-hadron.
	inline bool isBottomHadron(int pid) {
	return hasBottom(pid) && isHadron(pid);
	}


	/// @brief Determine if the PID is that of a c-meson.
	///
	/// @note Specifically, the _heaviest_ quark is a c: a B_c is a b-meson and NOT a c-meson.
	/// Charmonia (closed charm) are counted as c-mesons here.
	inline bool isCharmMeson(int pid) {
	return isMeson(pid) && hasCharm(pid) &&
	!hasBottom(pid);
	}

	/// @brief Determine if the PID is that of a c-baryon.
	///
	/// @note Specifically, the _heaviest_ quark is a c: a baryon containing a b & c
	/// is a b-baryon and NOT a c-baryon. To test for the simpler case, just use
	/// a combination of hasCharm() and isBaryon().
	inline bool isCharmBaryon(int pid) {
	return isBaryon(pid) && hasCharm(pid) &&
	!hasBottom(pid);
	}

	/// Determine if the PID is that of a c-hadron.
	///
	/// @note Specifically, the _heaviest_ quark is a c: a baryon containing a b & c
	/// is a b-baryon and NOT a c-baryon. To test for the simpler case, just use
	/// a combination of hasCharm() and isBaryon().
	inline bool isCharmHadron(int pid) {
	return isHadron(pid) && hasCharm(pid) &&
	!hasBottom(pid);
	}


	/// Determine if the PID is that of a strange meson
	///
	/// @note Specifically, the _heaviest_ quark is an s: if it also contains
	/// either charm or bottom, it is not considered to be a strange hadron.
	inline bool isStrangeMeson(int pid) {
	return isMeson(pid) && hasStrange(pid) &&
	!(hasBottom(pid) \|\| hasCharm(pid));
	}

	/// Determine if the PID is that of a strange baryon
	///
	/// @note Specifically, the _heaviest_ quark is an s: if it also contains
	/// either charm or bottom, it is not considered to be a strange hadron.
	inline bool isStrangeBaryon(int pid) {
	return isBaryon(pid) && hasStrange(pid) &&
	!(hasBottom(pid) \|\| hasCharm(pid));
	}

	/// Determine if the PID is that of a strange hadron
	///
	/// @note Specifically, the _heaviest_ quark is an s: if it also contains
	/// either charm or bottom, it is not considered to be a strange hadron.
	inline bool isStrangeHadron(int pid) {
	return isHadron(pid) && hasStrange(pid) &&
	!(hasBottom(pid) \|\| hasCharm(pid));
	}

	//@}


	/// @name Interaction classifiers
	//@{

	/// Determine if the PID is that of a strongly interacting particle
	inline bool isStrongInteracting(int pid) {
	return isParton(pid) \|\| isHadron(pid);
	}

	/// Determine if the PID is that of a electromagnetically interacting particle
	inline bool isEMInteracting(int pid) {
	return isCharged(pid) \|\| isPhoton(pid);
	}

	/// Determine if the PID is that of a weakly interacting particle
	///
	/// @note Photons are considered weak-interacting, as are all hadrons and
	/// leptons (we can't distinguish between L and R fermions at physical particle level).
	inline bool isWeakInteracting(int pid) {
	return !isGluon(pid) && !isGraviton(pid);
	}

	//@}


	/// @name Other classifiers
	//@{

	/// Determine if the PID is in the generator-specific range
	inline bool isGenSpecific(int pid) {
	return in_range(pid, 80, 101);
	}

	/// Determine if the PID is that of an EW scale resonance
	///
	/// @todo Also include SUSY, technicolor, etc. etc.? Maybe via a isStandardModel(pid) function, but there are stable BSM particles (in principle)
	inline bool isResonance(int pid) {
	return isW(pid) \|\| isZ(pid) \|\| isHiggs(pid) \|\| isTop(pid);
	}

	/// Check the PID for usability in transport codes like Geant4
	///
	/// @todo Should exclude neutrinos/LSP, since the ATLAS G4 interface deletes them immediately?
	inline bool isTransportable(int pid) {
	// return !isResonance(pid) && !isParton(pid) && !isGenSpecific(pid);
	return isPhoton(pid) \|\| isHadron(pid) \|\| isLepton(pid);
	}

	//@}


	}
	}

	#endif
	diff --git a/include/Rivet/ParticleName.hh b/include/Rivet/Tools/ParticleName.hh
	rename from include/Rivet/ParticleName.hh
	rename to include/Rivet/Tools/ParticleName.hh
	--- a/include/Rivet/ParticleName.hh
	+++ b/include/Rivet/Tools/ParticleName.hh
	@@ -1,259 +1,264 @@
	#ifndef RIVET_PARTICLENAME_HH
	#define RIVET_PARTICLENAME_HH

	#include "Rivet/Particle.fhh"
	-#include "Rivet/Exceptions.hh"
	+#include "Rivet/Tools/Exceptions.hh"

	namespace Rivet {

	namespace PID {


	/// Static const convenience particle ID names

	/// Special wildcard particle name
	static const PdgId ANY = 10000;

	/// @name Charged leptons
	//@{
	static const PdgId ELECTRON = 11;
	static const PdgId POSITRON = -ELECTRON;
	static const PdgId EMINUS = ELECTRON;
	static const PdgId EPLUS = POSITRON;
	static const PdgId MUON = 13;
	static const PdgId ANTIMUON = -MUON;
	static const PdgId TAU = 15;
	static const PdgId ANTITAU = -TAU;
	//@}

	/// @name Neutrinos
	//@{
	static const PdgId NU_E = 12;
	static const PdgId NU_EBAR = -NU_E;
	static const PdgId NU_MU = 14;
	static const PdgId NU_MUBAR = -NU_MU;
	static const PdgId NU_TAU = 16;
	static const PdgId NU_TAUBAR = -NU_TAU;
	//@}

	/// @name Bosons
	//@{
	static const PdgId PHOTON = 22;
	static const PdgId GAMMA = PHOTON;
	static const PdgId GLUON = 21;
	static const PdgId WPLUSBOSON = 24;
	static const PdgId WMINUSBOSON = -WPLUSBOSON;
	static const PdgId WPLUS = WPLUSBOSON;
	static const PdgId WMINUS = WMINUSBOSON;
	static const PdgId Z0BOSON = 23;
	static const PdgId ZBOSON = Z0BOSON;
	static const PdgId Z0 = Z0BOSON;
	static const PdgId HIGGSBOSON = 25;
	static const PdgId HIGGS = HIGGSBOSON;
	//@}

	/// @name Quarks
	//@{
	static const PdgId DQUARK = 1;
	static const PdgId UQUARK = 2;
	static const PdgId SQUARK = 3;
	static const PdgId CQUARK = 4;
	static const PdgId BQUARK = 5;
	static const PdgId TQUARK = 6;
	//@}

	/// @name Nucleons
	//@{
	static const PdgId PROTON = 2212;
	static const PdgId ANTIPROTON = -PROTON;
	static const PdgId PBAR = ANTIPROTON;
	static const PdgId NEUTRON = 2112;
	static const PdgId ANTINEUTRON = -NEUTRON;
	//@}

	/// @name Light mesons
	//@{
	static const PdgId PI0 = 111;
	static const PdgId PIPLUS = 211;
	static const PdgId PIMINUS = -PIPLUS;
	+ static const PdgId RHO0 = 113;
	+ static const PdgId RHOPLUS = 213;
	+ static const PdgId RHOMINUS = -RHOPLUS;
	static const PdgId K0L = 130;
	static const PdgId K0S = 310;
	static const PdgId KPLUS = 321;
	static const PdgId KMINUS = -KPLUS;
	static const PdgId ETA = 221;
	static const PdgId ETAPRIME = 331;
	static const PdgId PHI = 333;
	static const PdgId OMEGA = 223;
	//@}

	/// @name Charmonia
	//@{
	static const PdgId ETAC = 441;
	static const PdgId JPSI = 443;
	static const PdgId PSI2S = 100443;
	//@}

	/// @name Charm mesons
	//@{
	static const PdgId D0 = 421;
	+ static const PdgId D0BAR = -421;
	static const PdgId DPLUS = 411;
	static const PdgId DMINUS = -DPLUS;
	static const PdgId DSPLUS = 431;
	static const PdgId DSMINUS = -DSPLUS;
	//@}

	/// @name Bottomonia
	//@{
	static const PdgId ETAB = 551;
	static const PdgId UPSILON1S = 553;
	static const PdgId UPSILON2S = 100553;
	static const PdgId UPSILON3S = 200553;
	static const PdgId UPSILON4S = 300553;
	//@}

	/// @name b mesons
	//@{
	static const PdgId B0 = 511;
	+ static const PdgId B0BAR = -511;
	static const PdgId BPLUS = 521;
	static const PdgId BMINUS = -BPLUS;
	static const PdgId B0S = 531;
	static const PdgId BCPLUS = 541;
	static const PdgId BCMINUS = -BCPLUS;
	//@}

	/// @name Baryons
	//@{
	static const PdgId LAMBDA = 3122;
	static const PdgId SIGMA0 = 3212;
	static const PdgId SIGMAPLUS = 3222;
	static const PdgId SIGMAMINUS = 3112;
	static const PdgId LAMBDACPLUS = 4122;
	static const PdgId LAMBDACMINUS = 4122;
	static const PdgId LAMBDAB = 5122;
	static const PdgId XI0 = 3322;
	static const PdgId XIMINUS = 3312;
	static const PdgId XIPLUS = -XIMINUS;
	static const PdgId OMEGAMINUS = 3334;
	static const PdgId OMEGAPLUS = -OMEGAMINUS;
	//@}

	/// @name Exotic/weird stuff
	//@{
	static const PdgId REGGEON = 110;
	static const PdgId POMERON = 990;
	static const PdgId ODDERON = 9990;
	static const PdgId GRAVITON = 39;
	static const PdgId NEUTRALINO1 = 1000022;
	static const PdgId GRAVITINO = 1000039;
	static const PdgId GLUINO = 1000021;
	/// @todo Add axion, black hole remnant, etc. on demand
	//@}



	/// Handler for particle name code <-> string conversion
	///
	/// @todo Hide this utility class or equiv in an unnamed namespace in a .cc file.
	class ParticleNames {
	public:

	static const std::string& particleName(PdgId pid) {
	/// @todo Isn't there a nicer, pointerless way to do singletons?
	if (!_instance) _instance = unique_ptr<ParticleNames>(new ParticleNames);
	return _instance->_particleName(pid);
	}

	static PdgId particleId(const std::string& pname) {
	/// @todo Isn't there a nicer, pointerless way to do singletons?
	if (!_instance) _instance = unique_ptr<ParticleNames>(new ParticleNames);
	return _instance->_particleId(pname);
	}

	const std::string& _particleName(PdgId pid);

	PdgId _particleId(const std::string& pname);


	private:

	ParticleNames() {
	_add_pid_name(ELECTRON, "ELECTRON");
	_add_pid_name(POSITRON, "POSITRON");
	_add_pid_name(PROTON, "PROTON");
	_add_pid_name(ANTIPROTON, "ANTIPROTON");
	_add_pid_name(PHOTON, "PHOTON");
	_add_pid_name(NEUTRON, "NEUTRON");
	_add_pid_name(ANTINEUTRON, "ANTINEUTRON");
	_add_pid_name(MUON, "MUON");
	_add_pid_name(ANTIMUON, "ANTIMUON");
	_add_pid_name(NU_E, "NU_E");
	_add_pid_name(NU_EBAR, "NU_EBAR");
	_add_pid_name(NU_MU, "NU_MU");
	_add_pid_name(NU_MUBAR, "NU_MUBAR");
	_add_pid_name(NU_TAU, "NU_TAU");
	_add_pid_name(NU_TAUBAR, "NU_TAUBAR");
	_add_pid_name(PIPLUS, "PIPLUS");
	_add_pid_name(PIMINUS, "PIMINUS");
	_add_pid_name(TAU, "TAU");
	_add_pid_name(WPLUSBOSON, "WPLUSBOSON");
	_add_pid_name(WMINUSBOSON, "WMINUSBOSON");
	_add_pid_name(ZBOSON, "ZBOSON");
	_add_pid_name(HIGGS, "HIGGS");
	_add_pid_name(ANTITAU, "ANTITAU");
	_add_pid_name(ANY, "*");
	}

	void _add_pid_name(PdgId pid, const std::string& pname) {
	_ids_names[pid] = pname;
	_names_ids[pname] = pid;
	}

	static unique_ptr<ParticleNames> _instance;

	std::map<PdgId, std::string> _ids_names;

	std::map<std::string, PdgId> _names_ids;

	};


	/// Print a PdgId as a named string.
	inline const std::string& toParticleName(PdgId p) {
	return ParticleNames::particleName(p);
	}


	/// Print a PdgId as a named string.
	inline PdgId toParticleId(const std::string& pname) {
	return ParticleNames::particleId(pname);
	}


	/// Convenience maker of particle ID pairs from PdgIds.
	inline std::pair<PdgId,PdgId> make_pdgid_pair(PdgId a, PdgId b) {
	return make_pair(a, b);
	}


	/// Convenience maker of particle ID pairs from particle names.
	inline std::pair<PdgId,PdgId> make_pdgid_pair(const std::string& a, const std::string& b) {
	const PdgId pa = toParticleId(a);
	const PdgId pb = toParticleId(b);
	return make_pair(pa, pb);
	}


	/// Print a PdgIdPair as a string.
	inline std::string toBeamsString(const PdgIdPair& pair) {
	string out = "[" +
	toParticleName(pair.first) + ", " +
	toParticleName(pair.second) + "]";
	return out;
	}


	}

	}

	#endif
	diff --git a/include/Rivet/Tools/ParticleUtils.hh b/include/Rivet/Tools/ParticleUtils.hh
	--- a/include/Rivet/Tools/ParticleUtils.hh
	+++ b/include/Rivet/Tools/ParticleUtils.hh
	@@ -1,314 +1,654 @@
	#ifndef RIVET_PARTICLEUTILS_HH
	#define RIVET_PARTICLEUTILS_HH

	#include "Rivet/Particle.hh"
	+#include "Rivet/Tools/ParticleBaseUtils.hh"
	#include "Rivet/Tools/ParticleIdUtils.hh"

	// Macros to map Rivet::Particle functions to PID:: functions of the same name
	-/// @todo Can leave return type out of the macro and put that on each line where it's used?
	#define PARTICLE_TO_PID_BOOLFN(fname) inline bool fname (const Particle& p) { return PID:: fname (p.pid()); }
	#define PARTICLE_TO_PID_INTFN(fname) inline int fname (const Particle& p) { return PID:: fname (p.pid()); }
	#define PARTICLE_TO_PID_DBLFN(fname) inline double fname (const Particle& p) { return PID:: fname (p.pid()); }

	namespace Rivet {


	+ /// std::function instantiation for functors taking a Particle and returning a bool
	+ using ParticleSelector = function<bool(const Particle&)>;
	+ /// std::function instantiation for functors taking two Particles and returning a bool
	+ using ParticleSorter = function<bool(const Particle&, const Particle&)>;
	+
	+
	/// @name Particle classifier functions
	//@{

	+ /// Unbound function access to PID code
	+ inline int pid(const Particle& p) { return p.pid(); }
	+
	+ /// Unbound function access to abs PID code
	+ inline int abspid(const Particle& p) { return p.abspid(); }
	+
	+
	/// Is this particle species charged?
	PARTICLE_TO_PID_BOOLFN(isCharged)

	/// Is this particle species neutral?
	PARTICLE_TO_PID_BOOLFN(isNeutral)


	/// Is this a neutrino?
	PARTICLE_TO_PID_BOOLFN(isNeutrino)

	/// Determine if the PID is that of a charged lepton
	+ PARTICLE_TO_PID_BOOLFN(isChargedLepton)
	PARTICLE_TO_PID_BOOLFN(isChLepton)

	/// Determine if the PID is that of a photon
	PARTICLE_TO_PID_BOOLFN(isPhoton)

	/// Determine if the PID is that of an electron or positron
	PARTICLE_TO_PID_BOOLFN(isElectron)

	/// Determine if the PID is that of an muon or antimuon
	PARTICLE_TO_PID_BOOLFN(isMuon)

	/// Determine if the PID is that of an tau or antitau
	PARTICLE_TO_PID_BOOLFN(isTau)

	/// Determine if the PID is that of a hadron
	PARTICLE_TO_PID_BOOLFN(isHadron)

	/// Determine if the PID is that of a meson
	PARTICLE_TO_PID_BOOLFN(isMeson)

	/// Determine if the PID is that of a baryon
	PARTICLE_TO_PID_BOOLFN(isBaryon)

	/// Determine if the PID is that of a quark
	PARTICLE_TO_PID_BOOLFN(isQuark)

	/// Determine if the PID is that of a parton (quark or gluon)
	PARTICLE_TO_PID_BOOLFN(isParton)



	/// Determine if the PID is that of a W+
	PARTICLE_TO_PID_BOOLFN(isWplus)

	/// Determine if the PID is that of a W-
	PARTICLE_TO_PID_BOOLFN(isWminus)

	/// Determine if the PID is that of a W+-
	PARTICLE_TO_PID_BOOLFN(isW)

	/// Determine if the PID is that of a Z0
	PARTICLE_TO_PID_BOOLFN(isZ)

	/// Determine if the PID is that of an SM/lightest SUSY Higgs
	PARTICLE_TO_PID_BOOLFN(isHiggs)

	+ /// Determine if the PID is that of an s/sbar
	+ PARTICLE_TO_PID_BOOLFN(isStrange)
	+
	+ /// Determine if the PID is that of a c/cbar
	+ PARTICLE_TO_PID_BOOLFN(isCharm)
	+
	+ /// Determine if the PID is that of a b/bbar
	+ PARTICLE_TO_PID_BOOLFN(isBottom)
	+
	/// Determine if the PID is that of a t/tbar
	PARTICLE_TO_PID_BOOLFN(isTop)


	/// Determine if the particle is a heavy flavour hadron or parton
	PARTICLE_TO_PID_BOOLFN(isHeavyFlavour)

	/// Determine if the PID is that of a heavy parton (c,b,t)
	PARTICLE_TO_PID_BOOLFN(isHeavyParton)

	/// Determine if the PID is that of a light parton (u,d,s)
	PARTICLE_TO_PID_BOOLFN(isLightParton)


	/// Determine if the PID is that of a heavy flavour (b or c) meson
	PARTICLE_TO_PID_BOOLFN(isHeavyMeson)

	/// Determine if the PID is that of a heavy flavour (b or c) baryon
	PARTICLE_TO_PID_BOOLFN(isHeavyBaryon)

	/// Determine if the PID is that of a heavy flavour (b or c) hadron
	PARTICLE_TO_PID_BOOLFN(isHeavyHadron)


	/// Determine if the PID is that of a light flavour (not b or c) meson
	PARTICLE_TO_PID_BOOLFN(isLightMeson)

	/// Determine if the PID is that of a light flavour (not b or c) baryon
	PARTICLE_TO_PID_BOOLFN(isLightBaryon)

	/// Determine if the PID is that of a light flavour (not b or c) hadron
	PARTICLE_TO_PID_BOOLFN(isLightHadron)


	/// Determine if the PID is that of a b-meson.
	PARTICLE_TO_PID_BOOLFN(isBottomMeson)

	/// Determine if the PID is that of a b-baryon.
	PARTICLE_TO_PID_BOOLFN(isBottomBaryon)

	/// Determine if the PID is that of a b-hadron.
	PARTICLE_TO_PID_BOOLFN(isBottomHadron)


	/// @brief Determine if the PID is that of a c-meson.
	///
	/// Specifically, the _heaviest_ quark is a c: a B_c is a b-meson and NOT a c-meson.
	/// Charmonia (closed charm) are counted as c-mesons here.
	PARTICLE_TO_PID_BOOLFN(isCharmMeson)

	/// @brief Determine if the PID is that of a c-baryon.
	///
	/// Specifically, the _heaviest_ quark is a c: a baryon containing a b & c
	/// is a b-baryon and NOT a c-baryon. To test for the simpler case, just use
	/// a combination of hasCharm() and isBaryon().
	PARTICLE_TO_PID_BOOLFN(isCharmBaryon)

	/// Determine if the PID is that of a c-hadron.
	PARTICLE_TO_PID_BOOLFN(isCharmHadron)


	// /// Determine if the PID is that of a strange meson
	// PARTICLE_TO_PID_BOOLFN(isStrangeMeson)

	// /// Determine if the PID is that of a strange baryon
	// PARTICLE_TO_PID_BOOLFN(isStrangeBaryon)

	// /// Determine if the PID is that of a strange hadron
	// PARTICLE_TO_PID_BOOLFN(isStrangeHadron)



	/// Is this a pomeron, odderon, or generic reggeon?
	PARTICLE_TO_PID_BOOLFN(isReggeon)

	/// Determine if the PID is that of a diquark (used in hadronization models)
	PARTICLE_TO_PID_BOOLFN(isDiquark)

	/// Determine if the PID is that of a pentaquark (hypothetical hadron)
	PARTICLE_TO_PID_BOOLFN(isPentaquark)

	/// Is this a fundamental SUSY particle?
	PARTICLE_TO_PID_BOOLFN(isSUSY)

	/// Is this an R-hadron?
	PARTICLE_TO_PID_BOOLFN(isRhadron)

	/// Is this a technicolor particle?
	PARTICLE_TO_PID_BOOLFN(isTechnicolor)

	/// Is this an excited (composite) quark or lepton?
	PARTICLE_TO_PID_BOOLFN(isExcited)

	/// Is this a Kaluza-Klein excitation?
	PARTICLE_TO_PID_BOOLFN(isKK)

	/// Is this a graviton?
	PARTICLE_TO_PID_BOOLFN(isGraviton)

	/// Is this a BSM particle (including graviton)?
	PARTICLE_TO_PID_BOOLFN(isBSM)



	/// Determine if the PID is in the generator-specific range
	PARTICLE_TO_PID_BOOLFN(isGenSpecific)

	/// Determine if the PID is that of an EW scale resonance
	PARTICLE_TO_PID_BOOLFN(isResonance)

	/// Check the PID for usability in transport codes like Geant4
	PARTICLE_TO_PID_BOOLFN(isTransportable)



	/// Does this particle contain an up quark?
	PARTICLE_TO_PID_BOOLFN(hasUp)

	/// Does this particle contain a down quark?
	PARTICLE_TO_PID_BOOLFN(hasDown)

	/// Does this particle contain a strange quark?
	PARTICLE_TO_PID_BOOLFN(hasStrange)

	/// Does this particle contain a charm quark?
	PARTICLE_TO_PID_BOOLFN(hasCharm)

	/// Does this particle contain a bottom quark?
	PARTICLE_TO_PID_BOOLFN(hasBottom)

	/// Does this particle contain a top quark?
	PARTICLE_TO_PID_BOOLFN(hasTop)



	/// jSpin returns 2J+1, where J is the total spin
	PARTICLE_TO_PID_INTFN(jSpin)

	/// sSpin returns 2S+1, where S is the spin
	PARTICLE_TO_PID_INTFN(sSpin)

	/// lSpin returns 2L+1, where L is the orbital angular momentum
	PARTICLE_TO_PID_INTFN(lSpin)


	/// Return the charge
	PARTICLE_TO_PID_DBLFN(charge)

	/// Return 3 times the charge (3 x quark charge is an int)
	PARTICLE_TO_PID_INTFN(charge3)

	/// Return the absolute charge
	PARTICLE_TO_PID_DBLFN(abscharge)

	/// Return 3 times the abs charge (3 x quark charge is an int)
	PARTICLE_TO_PID_INTFN(abscharge3)

	/// Alias for charge3
	/// @deprecated Use charge3
	PARTICLE_TO_PID_INTFN(threeCharge)


	/// Get the atomic number (number of protons) in a nucleus/ion
	PARTICLE_TO_PID_INTFN(nuclZ)

	/// Get the atomic weight (number of nucleons) in a nucleus/ion
	PARTICLE_TO_PID_INTFN(nuclA)

	/// If this is a nucleus (ion), get nLambda
	PARTICLE_TO_PID_INTFN(nuclNlambda)

	//@}


	/// @name Particle charge/sign comparison functions
	//@{

	/// @brief Return true if Particles @a a and @a b have the opposite charge sign
	/// @note Two neutrals returns false
	inline bool oppSign(const Particle& a, const Particle& b) {
	return sign(a.charge3()) == -sign(b.charge3()) && sign(a.charge3()) != ZERO;
	}

	/// Return true if Particles @a a and @a b have the same charge sign
	/// @note Two neutrals returns true
	inline bool sameSign(const Particle& a, const Particle& b) {
	return sign(a.charge3()) == sign(b.charge3());
	}

	/// Return true if Particles @a a and @a b have the exactly opposite charge
	/// @note Two neutrals returns false
	inline bool oppCharge(const Particle& a, const Particle& b) {
	return a.charge3() == -b.charge3() && a.charge3() != 0;
	}

	/// Return true if Particles @a a and @a b have the same charge (including neutral)
	/// @note Two neutrals returns true
	inline bool sameCharge(const Particle& a, const Particle& b) {
	return a.charge3() == b.charge3();
	}

	/// Return true if Particles @a a and @a b have a different (not necessarily opposite) charge
	inline bool diffCharge(const Particle& a, const Particle& b) {
	return a.charge3() != b.charge3();
	}

	//@}


	- /// @name Particle classifying functors
	+
	+ //////////////////////////////////////
	+
	+
	+
	+ /// @name Non-PID particle properties, via unbound functions
	+ //@{
	+
	+ /// Is this particle potentially visible in a detector?
	+ inline bool isVisible(const Particle& p) { return p.isVisible(); }
	+
	+ /// @brief Decide if a given particle is prompt, via Particle::isPrompt()
	+ ///
	+ /// The boolean arguments allow a decay lepton to be considered prompt if
	+ /// its parent was a "real" prompt lepton.
	+ inline bool isPrompt(const Particle& p, bool allow_from_prompt_tau=false, bool allow_from_prompt_mu=false) {
	+ return p.isPrompt(allow_from_prompt_tau, allow_from_prompt_mu);
	+ }
	+
	+ /// Decide if a given particle is stable, via Particle::isStable()
	+ inline bool isStable(const Particle& p) { return p.isStable(); }
	+
	+ /// Check whether a given PID is found in the particle's ancestor list
	+ inline bool hasAncestor(const Particle& p, PdgId pid) { return p.hasAncestor(pid); }
	+
	+ /// Determine whether the particle is from a b-hadron decay
	+ inline bool fromBottom(const Particle& p) { return p.fromBottom(); }
	+
	+ /// @brief Determine whether the particle is from a c-hadron decay
	+ inline bool fromCharm(const Particle& p) { return p.fromCharm(); }
	+
	+ /// @brief Determine whether the particle is from a hadron decay
	+ inline bool fromHadron(const Particle& p) { return p.fromHadron(); }
	+
	+ /// @brief Determine whether the particle is from a tau decay
	+ inline bool fromTau(const Particle& p, bool prompt_taus_only=false) {
	+ return p.fromTau(prompt_taus_only);
	+ }
	+
	+ /// @brief Determine whether the particle is from a prompt tau decay
	+ inline bool fromPromptTau(const Particle& p) { return p.fromPromptTau(); }
	+
	+ /// @brief Determine whether the particle is from a hadron or tau decay
	+ inline bool fromDecay(const Particle& p) { return p.fromDecay(); }
	+
	+
	+ /// @brief Determine whether a particle is the first in a decay chain to meet the function requirement
	+ template <typename FN>
	+ inline bool isFirstWith(const Particle& p, const FN& f) {
	+ if (!f(p)) return false; //< This doesn't even meet f, let alone being the last to do so
	+ if (any(p.parents(), f)) return false; //< If a direct parent has this property, this isn't the first
	+ return true;
	+ }
	+
	+ /// @brief Determine whether a particle is the first in a decay chain not to meet the function requirement
	+ template <typename FN>
	+ inline bool isFirstWithout(const Particle& p, const FN& f) {
	+ return isFirstWith(p, [&](const Particle& pp){ return !f(pp); });
	+ }
	+
	+ /// @brief Determine whether a particle is the last in a decay chain to meet the function requirement
	+ template <typename FN>
	+ inline bool isLastWith(const Particle& p, const FN& f) {
	+ if (!f(p)) return false; //< This doesn't even meet f, let alone being the last to do so
	+ if (any(p.children(), f)) return false; //< If a child has this property, this isn't the last
	+ return true;
	+ }
	+
	+ /// @brief Determine whether a particle is the last in a decay chain not to meet the function requirement
	+ template <typename FN>
	+ inline bool isLastWithout(const Particle& p, const FN& f) {
	+ return isLastWith(p, [&](const Particle& pp){ return !f(pp); });
	+ }
	+
	+
	+ /// @brief Determine whether a particle has an ancestor which meets the function requirement
	+ template <typename FN>
	+ inline bool hasAncestorWith(const Particle& p, const FN& f) {
	+ return p.hasAncestorWith(f);
	+ }
	+
	+ /// @brief Determine whether a particle has an ancestor which doesn't meet the function requirement
	+ template <typename FN>
	+ inline bool hasAncestorWithout(const Particle& p, const FN& f) {
	+ return hasAncestorWith(p, [&](const Particle& pp){ return !f(pp); });
	+ }
	+
	+
	+ /// @brief Determine whether a particle has a parent which meets the function requirement
	+ template <typename FN>
	+ inline bool hasParentWith(const Particle& p, const FN& f) {
	+ return p.hasParentWith(f);
	+ }
	+
	+ /// @brief Determine whether a particle has a parent which doesn't meet the function requirement
	+ template <typename FN>
	+ inline bool hasParentWithout(const Particle& p, const FN& f) {
	+ return hasParentWith(p, [&](const Particle& pp){ return !f(pp); });
	+ }
	+
	+
	+ /// @brief Determine whether a particle has a child which meets the function requirement
	+ template <typename FN>
	+ inline bool hasChildWith(const Particle& p, const FN& f) {
	+ return !p.children(f).empty();
	+ }
	+
	+ /// @brief Determine whether a particle has a child which doesn't meet the function requirement
	+ template <typename FN>
	+ inline bool hasChildWithout(const Particle& p, const FN& f) {
	+ return p.children(f).empty();
	+ }
	+
	+
	+ /// @brief Determine whether a particle has a descendant which meets the function requirement
	+ template <typename FN>
	+ inline bool hasDescendantWith(const Particle& p, const FN& f) {
	+ return !p.allDescendants(f).empty();
	+ }
	+
	+ /// @brief Determine whether a particle has a descendant which doesn't meet the function requirement
	+ template <typename FN>
	+ inline bool hasDescendantWithout(const Particle& p, const FN& f) {
	+ return p.allDescendants(f).empty();
	+ }
	+
	+ //@}
	+
	+
	+ /// @name Particle classifier -> bool functors
	///
	/// To be passed to any() or all() e.g. any(p.children(), HasPID(PID::MUON))
	//@{

	/// Base type for Particle -> bool functors
	struct BoolParticleFunctor {
	virtual bool operator()(const Particle& p) const = 0;
	};

	+
	/// PID matching functor
	struct HasPID : public BoolParticleFunctor {
	HasPID(PdgId pid) : targetpid(pid) { }
	bool operator()(const Particle& p) const { return p.pid() == targetpid; }
	PdgId targetpid;
	};
	+ using hasPID = HasPID;

	/// \|PID\| matching functor
	struct HasAbsPID : public BoolParticleFunctor {
	HasAbsPID(PdgId pid) : targetpid(abs(pid)) { }
	bool operator()(const Particle& p) const { return p.abspid() == abs(targetpid); }
	PdgId targetpid;
	};
	+ using hasAbsPID = HasAbsPID;
	+
	+
	+ /// Determine whether a particle is the first in a decay chain to meet the cut/function
	+ struct FirstParticleWith : public BoolParticleFunctor {
	+ template <typename FN>
	+ FirstParticleWith(const FN& f) : fn(f) { }
	+ FirstParticleWith(const Cut& c);
	+ bool operator()(const Particle& p) const { return isFirstWith(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using firstParticleWith = FirstParticleWith;
	+
	+ /// Determine whether a particle is the first in a decay chain not to meet the cut/function
	+ struct FirstParticleWithout : public BoolParticleFunctor {
	+ template <typename FN>
	+ FirstParticleWithout(const FN& f) : fn(f) { }
	+ FirstParticleWithout(const Cut& c);
	+ bool operator()(const Particle& p) const { return isFirstWithout(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using firstParticleWithout = FirstParticleWithout;
	+
	+
	+ /// Determine whether a particle is the last in a decay chain to meet the cut/function
	+ struct LastParticleWith : public BoolParticleFunctor {
	+ template <typename FN>
	+ LastParticleWith(const FN& f) : fn(f) { }
	+ LastParticleWith(const Cut& c);
	+ bool operator()(const Particle& p) const { return isLastWith(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using lastParticleWith = LastParticleWith;
	+
	+ /// Determine whether a particle is the last in a decay chain not to meet the cut/function
	+ struct LastParticleWithout : public BoolParticleFunctor {
	+ template <typename FN>
	+ LastParticleWithout(const FN& f) : fn(f) { }
	+ LastParticleWithout(const Cut& c);
	+ bool operator()(const Particle& p) const { return isLastWithout(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using lastParticleWithout = LastParticleWithout;
	+
	+
	+ /// Determine whether a particle has an ancestor which meets the cut/function
	+ struct HasParticleAncestorWith : public BoolParticleFunctor {
	+ template <typename FN>
	+ HasParticleAncestorWith(const FN& f) : fn(f) { }
	+ HasParticleAncestorWith(const Cut& c);
	+ bool operator()(const Particle& p) const { return hasAncestorWith(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using hasParticleAncestorWith = HasParticleAncestorWith;
	+
	+ /// Determine whether a particle has an ancestor which doesn't meet the cut/function
	+ struct HasParticleAncestorWithout : public BoolParticleFunctor {
	+ template <typename FN>
	+ HasParticleAncestorWithout(const FN& f) : fn(f) { }
	+ HasParticleAncestorWithout(const Cut& c);
	+ bool operator()(const Particle& p) const { return hasAncestorWithout(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using hasParticleAncestorWithout = HasParticleAncestorWithout;
	+
	+
	+ /// Determine whether a particle has an parent which meets the cut/function
	+ struct HasParticleParentWith : public BoolParticleFunctor {
	+ template <typename FN>
	+ HasParticleParentWith(const FN& f) : fn(f) { }
	+ HasParticleParentWith(const Cut& c);
	+ bool operator()(const Particle& p) const { return hasParentWith(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using hasParticleParentWith = HasParticleParentWith;
	+
	+ /// Determine whether a particle has an parent which doesn't meet the cut/function
	+ struct HasParticleParentWithout : public BoolParticleFunctor {
	+ template <typename FN>
	+ HasParticleParentWithout(const FN& f) : fn(f) { }
	+ HasParticleParentWithout(const Cut& c);
	+ bool operator()(const Particle& p) const { return hasParentWithout(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using hasParticleParentWithout = HasParticleParentWithout;
	+
	+
	+ /// Determine whether a particle has a child which meets the cut/function
	+ struct HasParticleChildWith : public BoolParticleFunctor {
	+ template <typename FN>
	+ HasParticleChildWith(const FN& f) : fn(f) { }
	+ HasParticleChildWith(const Cut& c);
	+ bool operator()(const Particle& p) const { return hasChildWith(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using hasParticleChildWith = HasParticleChildWith;
	+
	+ /// Determine whether a particle has a child which doesn't meet the cut/function
	+ struct HasParticleChildWithout : public BoolParticleFunctor {
	+ template <typename FN>
	+ HasParticleChildWithout(const FN& f) : fn(f) { }
	+ HasParticleChildWithout(const Cut& c);
	+ bool operator()(const Particle& p) const { return hasChildWithout(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using hasParticleChildWithout = HasParticleChildWithout;
	+
	+
	+ /// Determine whether a particle has a descendant which meets the cut/function
	+ struct HasParticleDescendantWith : public BoolParticleFunctor {
	+ template <typename FN>
	+ HasParticleDescendantWith(const FN& f) : fn(f) { }
	+ HasParticleDescendantWith(const Cut& c);
	+ bool operator()(const Particle& p) const { return hasDescendantWith(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using hasParticleDescendantWith = HasParticleDescendantWith;
	+
	+ /// Determine whether a particle has a descendant which doesn't meet the cut/function
	+ struct HasParticleDescendantWithout : public BoolParticleFunctor {
	+ template <typename FN>
	+ HasParticleDescendantWithout(const FN& f) : fn(f) { }
	+ HasParticleDescendantWithout(const Cut& c);
	+ bool operator()(const Particle& p) const { return hasDescendantWithout(p, fn); }
	+ std::function<bool(const Particle&)> fn;
	+ };
	+ using hasParticleDescendantWithout = HasParticleDescendantWithout;
	+
	+ //@}
	+
	+
	+ /// @name Unbound functions for filtering particles
	+ //@{
	+
	+ /// Filter a particle collection in-place to the subset that passes the supplied Cut
	+ Particles& ifilter_select(Particles& particles, const Cut& c);
	+ /// Alias for ifilter_select
	+ /// @deprecated Use ifilter_select
	+ inline Particles& ifilterBy(Particles& particles, const Cut& c) { return ifilter_select(particles, c); }
	+
	+ /// Filter a particle collection in-place to the subset that passes the supplied Cut
	+ inline Particles filter_select(const Particles& particles, const Cut& c) {
	+ Particles rtn = particles;
	+ return ifilter_select(rtn, c);
	+ }
	+ /// Alias for ifilter_select
	+ /// @deprecated Use filter_select
	+ inline Particles filterBy(const Particles& particles, const Cut& c) { return filter_select(particles, c); }
	+
	+ /// Filter a particle collection in-place to the subset that passes the supplied Cut
	+ inline Particles filter_select(const Particles& particles, const Cut& c, Particles& out) {
	+ out = filter_select(particles, c);
	+ return out;
	+ }
	+ /// Alias for ifilter_select
	+ /// @deprecated Use filter_select
	+ inline Particles filterBy(const Particles& particles, const Cut& c, Particles& out) { return filter_select(particles, c, out); }
	+
	+
	+ /// Filter a particle collection in-place to the subset that fails the supplied Cut
	+ Particles& ifilter_discard(Particles& particles, const Cut& c);
	+
	+ /// Filter a particle collection in-place to the subset that fails the supplied Cut
	+ inline Particles filter_discard(const Particles& particles, const Cut& c) {
	+ Particles rtn = particles;
	+ return ifilter_discard(rtn, c);
	+ }
	+
	+ /// Filter a particle collection in-place to the subset that fails the supplied Cut
	+ inline Particles filter_discard(const Particles& particles, const Cut& c, Particles& out) {
	+ out = filter_discard(particles, c);
	+ return out;
	+ }
	+
	+ //@}
	+
	+
	+
	+ /// @name Particle pair functions
	+ //@{
	+
	+ /// Get the PDG ID codes of a ParticlePair
	+ /// @todo Make ParticlePair a custom class instead?
	+ inline PdgIdPair pids(const ParticlePair& pp) {
	+ return make_pair(pp.first.pid(), pp.second.pid());
	+ }

	//@}


	}

	#endif
	diff --git a/include/Rivet/Tools/PrettyPrint.hh b/include/Rivet/Tools/PrettyPrint.hh
	new file mode 100644
	--- /dev/null
	+++ b/include/Rivet/Tools/PrettyPrint.hh
	@@ -0,0 +1,454 @@
	+// Copyright Louis Delacroix 2010 - 2014.
	+// Distributed under the Boost Software License, Version 1.0.
	+// (See accompanying file LICENSE_1_0.txt or copy at
	+// http://www.boost.org/LICENSE_1_0.txt)
	+//
	+// A pretty printing library for C++
	+//
	+// Usage:
	+// Include this header, and operator<< will "just work".
	+//
	+// See: https://louisdx.github.io/cxx-prettyprint/
	+
	+#ifndef H_PRETTY_PRINT
	+#define H_PRETTY_PRINT
	+
	+#include <cstddef>
	+#include <iterator>
	+#include <memory>
	+#include <ostream>
	+#include <set>
	+#include <tuple>
	+#include <type_traits>
	+#include <unordered_set>
	+#include <utility>
	+#include <valarray>
	+
	+namespace Rivet
	+{
	+namespace pretty_print
	+{
	+ namespace detail
	+ {
	+ // SFINAE type trait to detect whether T::const_iterator exists.
	+
	+ struct sfinae_base
	+ {
	+ using yes = char;
	+ using no = yes[2];
	+ };
	+
	+ template <typename T>
	+ struct has_const_iterator : private sfinae_base
	+ {
	+ private:
	+ template <typename C> static yes & test(typename C::const_iterator*);
	+ template <typename C> static no & test(...);
	+ public:
	+ static const bool value = sizeof(test<T>(nullptr)) == sizeof(yes);
	+ using type = T;
	+ };
	+
	+ template <typename T>
	+ struct has_begin_end : private sfinae_base
	+ {
	+ private:
	+ template <typename C>
	+ static yes & f(typename std::enable_if<
	+ std::is_same<decltype(static_cast<typename C::const_iterator(C::*)() const>(&C::begin)),
	+ typename C::const_iterator(C::)() const>::value>::type );
	+
	+ template <typename C> static no & f(...);
	+
	+ template <typename C>
	+ static yes & g(typename std::enable_if<
	+ std::is_same<decltype(static_cast<typename C::const_iterator(C::*)() const>(&C::end)),
	+ typename C::const_iterator(C::)() const>::value, void>::type);
	+
	+ template <typename C> static no & g(...);
	+
	+ public:
	+ static bool const beg_value = sizeof(f<T>(nullptr)) == sizeof(yes);
	+ static bool const end_value = sizeof(g<T>(nullptr)) == sizeof(yes);
	+ };
	+
	+ } // namespace detail
	+
	+
	+ // Holds the delimiter values for a specific character type
	+
	+ template <typename TChar>
	+ struct delimiters_values
	+ {
	+ using char_type = TChar;
	+ const char_type * prefix;
	+ const char_type * delimiter;
	+ const char_type * postfix;
	+ };
	+
	+
	+ // Defines the delimiter values for a specific container and character type
	+
	+ template <typename T, typename TChar>
	+ struct delimiters
	+ {
	+ using type = delimiters_values<TChar>;
	+ static const type values;
	+ };
	+
	+
	+ // Functor to print containers. You can use this directly if you want
	+ // to specificy a non-default delimiters type. The printing logic can
	+ // be customized by specializing the nested template.
	+
	+ template <typename T,
	+ typename TChar = char,
	+ typename TCharTraits = ::std::char_traits<TChar>,
	+ typename TDelimiters = delimiters<T, TChar>>
	+ struct print_container_helper
	+ {
	+ using delimiters_type = TDelimiters;
	+ using ostream_type = std::basic_ostream<TChar, TCharTraits>;
	+
	+ template <typename U>
	+ struct printer
	+ {
	+ static void print_body(const U & c, ostream_type & stream)
	+ {
	+ using std::begin;
	+ using std::end;
	+
	+ auto it = begin(c);
	+ const auto the_end = end(c);
	+
	+ if (it != the_end)
	+ {
	+ for ( ; ; )
	+ {
	+ stream << *it;
	+
	+ if (++it == the_end) break;
	+
	+ if (delimiters_type::values.delimiter != NULL)
	+ stream << delimiters_type::values.delimiter;
	+ }
	+ }
	+ }
	+ };
	+
	+ print_container_helper(const T & container)
	+ : container_(container)
	+ { }
	+
	+ inline void operator()(ostream_type & stream) const
	+ {
	+ if (delimiters_type::values.prefix != NULL)
	+ stream << delimiters_type::values.prefix;
	+
	+ printer<T>::print_body(container_, stream);
	+
	+ if (delimiters_type::values.postfix != NULL)
	+ stream << delimiters_type::values.postfix;
	+ }
	+
	+ private:
	+ const T & container_;
	+ };
	+
	+ // Specialization for pairs
	+
	+ template <typename T, typename TChar, typename TCharTraits, typename TDelimiters>
	+ template <typename T1, typename T2>
	+ struct print_container_helper<T, TChar, TCharTraits, TDelimiters>::printer<std::pair<T1, T2>>
	+ {
	+ using ostream_type = typename print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type;
	+
	+ static void print_body(const std::pair<T1, T2> & c, ostream_type & stream)
	+ {
	+ stream << c.first;
	+ if (print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL)
	+ stream << print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter;
	+ stream << c.second;
	+ }
	+ };
	+
	+ // Specialization for tuples
	+
	+ template <typename T, typename TChar, typename TCharTraits, typename TDelimiters>
	+ template <typename ...Args>
	+ struct print_container_helper<T, TChar, TCharTraits, TDelimiters>::printer<std::tuple<Args...>>
	+ {
	+ using ostream_type = typename print_container_helper<T, TChar, TCharTraits, TDelimiters>::ostream_type;
	+ using element_type = std::tuple<Args...>;
	+
	+ template <std::size_t I> struct Int { };
	+
	+ static void print_body(const element_type & c, ostream_type & stream)
	+ {
	+ tuple_print(c, stream, Int<0>());
	+ }
	+
	+ static void tuple_print(const element_type &, ostream_type &, Int<sizeof...(Args)>)
	+ {
	+ }
	+
	+ static void tuple_print(const element_type & c, ostream_type & stream,
	+ typename std::conditional<sizeof...(Args) != 0, Int<0>, std::nullptr_t>::type)
	+ {
	+ stream << std::get<0>(c);
	+ tuple_print(c, stream, Int<1>());
	+ }
	+
	+ template <std::size_t N>
	+ static void tuple_print(const element_type & c, ostream_type & stream, Int<N>)
	+ {
	+ if (print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter != NULL)
	+ stream << print_container_helper<T, TChar, TCharTraits, TDelimiters>::delimiters_type::values.delimiter;
	+
	+ stream << std::get<N>(c);
	+
	+ tuple_print(c, stream, Int<N + 1>());
	+ }
	+ };
	+
	+ // Prints a print_container_helper to the specified stream.
	+
	+ template<typename T, typename TChar, typename TCharTraits, typename TDelimiters>
	+ inline std::basic_ostream<TChar, TCharTraits> & operator<<(
	+ std::basic_ostream<TChar, TCharTraits> & stream,
	+ const print_container_helper<T, TChar, TCharTraits, TDelimiters> & helper)
	+ {
	+ helper(stream);
	+ return stream;
	+ }
	+
	+
	+ // Basic is_container template; specialize to derive from std::true_type for all desired container types
	+
	+ template <typename T>
	+ struct is_container : public std::integral_constant<bool,
	+ detail::has_const_iterator<T>::value &&
	+ detail::has_begin_end<T>::beg_value &&
	+ detail::has_begin_end<T>::end_value> { };
	+
	+ template <typename T, std::size_t N>
	+ struct is_container<T[N]> : std::true_type { };
	+
	+ template <std::size_t N>
	+ struct is_container<char[N]> : std::false_type { };
	+
	+ template <typename T>
	+ struct is_container<std::valarray<T>> : std::true_type { };
	+
	+ template <typename T1, typename T2>
	+ struct is_container<std::pair<T1, T2>> : std::true_type { };
	+
	+ template <typename ...Args>
	+ struct is_container<std::tuple<Args...>> : std::true_type { };
	+
	+
	+ // Default delimiters
	+
	+ template <typename T> struct delimiters<T, char> { static const delimiters_values<char> values; };
	+ template <typename T> const delimiters_values<char> delimiters<T, char>::values = { "[", ", ", "]" };
	+ template <typename T> struct delimiters<T, wchar_t> { static const delimiters_values<wchar_t> values; };
	+ template <typename T> const delimiters_values<wchar_t> delimiters<T, wchar_t>::values = { L"[", L", ", L"]" };
	+
	+
	+ // Delimiters for (multi)set and unordered_(multi)set
	+
	+ template <typename T, typename TComp, typename TAllocator>
	+ struct delimiters< ::std::set<T, TComp, TAllocator>, char> { static const delimiters_values<char> values; };
	+
	+ template <typename T, typename TComp, typename TAllocator>
	+ const delimiters_values<char> delimiters< ::std::set<T, TComp, TAllocator>, char>::values = { "{", ", ", "}" };
	+
	+ template <typename T, typename TComp, typename TAllocator>
	+ struct delimiters< ::std::set<T, TComp, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
	+
	+ template <typename T, typename TComp, typename TAllocator>
	+ const delimiters_values<wchar_t> delimiters< ::std::set<T, TComp, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
	+
	+ template <typename T, typename TComp, typename TAllocator>
	+ struct delimiters< ::std::multiset<T, TComp, TAllocator>, char> { static const delimiters_values<char> values; };
	+
	+ template <typename T, typename TComp, typename TAllocator>
	+ const delimiters_values<char> delimiters< ::std::multiset<T, TComp, TAllocator>, char>::values = { "{", ", ", "}" };
	+
	+ template <typename T, typename TComp, typename TAllocator>
	+ struct delimiters< ::std::multiset<T, TComp, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
	+
	+ template <typename T, typename TComp, typename TAllocator>
	+ const delimiters_values<wchar_t> delimiters< ::std::multiset<T, TComp, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
	+
	+ template <typename T, typename THash, typename TEqual, typename TAllocator>
	+ struct delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, char> { static const delimiters_values<char> values; };
	+
	+ template <typename T, typename THash, typename TEqual, typename TAllocator>
	+ const delimiters_values<char> delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, char>::values = { "{", ", ", "}" };
	+
	+ template <typename T, typename THash, typename TEqual, typename TAllocator>
	+ struct delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
	+
	+ template <typename T, typename THash, typename TEqual, typename TAllocator>
	+ const delimiters_values<wchar_t> delimiters< ::std::unordered_set<T, THash, TEqual, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
	+
	+ template <typename T, typename THash, typename TEqual, typename TAllocator>
	+ struct delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, char> { static const delimiters_values<char> values; };
	+
	+ template <typename T, typename THash, typename TEqual, typename TAllocator>
	+ const delimiters_values<char> delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, char>::values = { "{", ", ", "}" };
	+
	+ template <typename T, typename THash, typename TEqual, typename TAllocator>
	+ struct delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, wchar_t> { static const delimiters_values<wchar_t> values; };
	+
	+ template <typename T, typename THash, typename TEqual, typename TAllocator>
	+ const delimiters_values<wchar_t> delimiters< ::std::unordered_multiset<T, THash, TEqual, TAllocator>, wchar_t>::values = { L"{", L", ", L"}" };
	+
	+
	+ // Delimiters for pair and tuple
	+
	+ template <typename T1, typename T2> struct delimiters<std::pair<T1, T2>, char> { static const delimiters_values<char> values; };
	+ template <typename T1, typename T2> const delimiters_values<char> delimiters<std::pair<T1, T2>, char>::values = { "(", ", ", ")" };
	+ template <typename T1, typename T2> struct delimiters< ::std::pair<T1, T2>, wchar_t> { static const delimiters_values<wchar_t> values; };
	+ template <typename T1, typename T2> const delimiters_values<wchar_t> delimiters< ::std::pair<T1, T2>, wchar_t>::values = { L"(", L", ", L")" };
	+
	+ template <typename ...Args> struct delimiters<std::tuple<Args...>, char> { static const delimiters_values<char> values; };
	+ template <typename ...Args> const delimiters_values<char> delimiters<std::tuple<Args...>, char>::values = { "(", ", ", ")" };
	+ template <typename ...Args> struct delimiters< ::std::tuple<Args...>, wchar_t> { static const delimiters_values<wchar_t> values; };
	+ template <typename ...Args> const delimiters_values<wchar_t> delimiters< ::std::tuple<Args...>, wchar_t>::values = { L"(", L", ", L")" };
	+
	+
	+ // Type-erasing helper class for easy use of custom delimiters.
	+ // Requires TCharTraits = std::char_traits<TChar> and TChar = char or wchar_t, and MyDelims needs to be defined for TChar.
	+ // Usage: "cout << pretty_print::custom_delims<MyDelims>(x)".
	+
	+ struct custom_delims_base
	+ {
	+ virtual ~custom_delims_base() { }
	+ virtual std::ostream & stream(::std::ostream &) = 0;
	+ virtual std::wostream & stream(::std::wostream &) = 0;
	+ };
	+
	+ template <typename T, typename Delims>
	+ struct custom_delims_wrapper : custom_delims_base
	+ {
	+ custom_delims_wrapper(const T & t_) : t(t_) { }
	+
	+ std::ostream & stream(std::ostream & s)
	+ {
	+ return s << print_container_helper<T, char, std::char_traits<char>, Delims>(t);
	+ }
	+
	+ std::wostream & stream(std::wostream & s)
	+ {
	+ return s << print_container_helper<T, wchar_t, std::char_traits<wchar_t>, Delims>(t);
	+ }
	+
	+ private:
	+ const T & t;
	+ };
	+
	+ template <typename Delims>
	+ struct custom_delims
	+ {
	+ template <typename Container>
	+ custom_delims(const Container & c) : base(new custom_delims_wrapper<Container, Delims>(c)) { }
	+
	+ std::unique_ptr<custom_delims_base> base;
	+ };
	+
	+ template <typename TChar, typename TCharTraits, typename Delims>
	+ inline std::basic_ostream<TChar, TCharTraits> & operator<<(std::basic_ostream<TChar, TCharTraits> & s, const custom_delims<Delims> & p)
	+ {
	+ return p.base->stream(s);
	+ }
	+
	+
	+ // A wrapper for a C-style array given as pointer-plus-size.
	+ // Usage: std::cout << pretty_print_array(arr, n) << std::endl;
	+
	+ template<typename T>
	+ struct array_wrapper_n
	+ {
	+ typedef const T * const_iterator;
	+ typedef T value_type;
	+
	+ array_wrapper_n(const T * const a, size_t n) : _array(a), _n(n) { }
	+ inline const_iterator begin() const { return _array; }
	+ inline const_iterator end() const { return _array + _n; }
	+
	+ private:
	+ const T * const _array;
	+ size_t _n;
	+ };
	+
	+
	+ // A wrapper for hash-table based containers that offer local iterators to each bucket.
	+ // Usage: std::cout << bucket_print(m, 4) << std::endl; (Prints bucket 5 of container m.)
	+
	+ template <typename T>
	+ struct bucket_print_wrapper
	+ {
	+ typedef typename T::const_local_iterator const_iterator;
	+ typedef typename T::size_type size_type;
	+
	+ const_iterator begin() const
	+ {
	+ return m_map.cbegin(n);
	+ }
	+
	+ const_iterator end() const
	+ {
	+ return m_map.cend(n);
	+ }
	+
	+ bucket_print_wrapper(const T & m, size_type bucket) : m_map(m), n(bucket) { }
	+
	+ private:
	+ const T & m_map;
	+ const size_type n;
	+ };
	+
	+} // namespace pretty_print
	+
	+
	+// Global accessor functions for the convenience wrappers
	+
	+template<typename T>
	+inline pretty_print::array_wrapper_n<T> pretty_print_array(const T * const a, size_t n)
	+{
	+ return pretty_print::array_wrapper_n<T>(a, n);
	+}
	+
	+template <typename T> pretty_print::bucket_print_wrapper<T>
	+bucket_print(const T & m, typename T::size_type n)
	+{
	+ return pretty_print::bucket_print_wrapper<T>(m, n);
	+}
	+
	+
	+} // namespace Rivet
	+
	+
	+
	+// Main magic entry point: An overload snuck into namespace std.
	+// Can we do better?
	+
	+namespace std
	+{
	+
	+// Prints a container to the stream using default delimiters
	+template<typename T, typename TChar, typename TCharTraits>
	+inline typename enable_if< ::Rivet::pretty_print::is_container<T>::value,
	+ basic_ostream<TChar, TCharTraits> &>::type
	+operator<<(std::basic_ostream<TChar, TCharTraits> & stream, const T & container)
	+{
	+ return stream << ::Rivet::pretty_print::print_container_helper<T, TChar, TCharTraits>(container);
	+}
	+
	+}
	+
	+
	+
	+#endif // H_PRETTY_PRINT
	diff --git a/include/Rivet/Tools/RivetHepMC.hh b/include/Rivet/Tools/RivetHepMC.hh
	--- a/include/Rivet/Tools/RivetHepMC.hh
	+++ b/include/Rivet/Tools/RivetHepMC.hh
	@@ -1,182 +1,206 @@
	// -- C++ --
	#ifndef RIVET_RivetHepMC_HH
	#define RIVET_RivetHepMC_HH

	#include "HepMC/GenEvent.h"
	#include "HepMC/GenParticle.h"
	#include "HepMC/GenVertex.h"
	#include "HepMC/GenRanges.h"
	#include "HepMC/IO_GenEvent.h"
	#include "Rivet/Tools/RivetSTL.hh"
	-#include "Rivet/Exceptions.hh"
	+#include "Rivet/Tools/Exceptions.hh"

	namespace Rivet {


	using HepMC::GenEvent;
	using HepMC::GenParticle;
	using HepMC::GenVertex;

	+ #if HEPMC_VERSION_CODE >= 3000000
	+ using HepMC::GenEventPtr;
	+ using HepMC::GenParticlePtr;
	+ using HepMC::GenVertexPtr;
	+ #elif HEPMC_VERSION_CODE >= 2007000
	+ // HepMC 2.07 provides its own #defines
	+ #else
	+ #define GenEventPtr GenEvent*
	+ #define GenParticlePtr GenParticle*
	+ #define GenVertexPtr GenVertex*
	+ #endif

	- /// @todo Use mcutils
	+
	+ /// @todo Use mcutils?


	inline std::vector<GenParticle const > particles(const GenEvent ge) {
	assert(ge);
	std::vector<const GenParticle*> rtn;
	for (GenEvent::particle_const_iterator pi = ge->particles_begin(); pi != ge->particles_end(); ++pi)
	rtn.push_back(*pi);
	return rtn;
	}

	- inline std::vector<GenParticle> particles(GenEvent ge) {
	+ inline std::vector<GenParticlePtr> particles(GenEvent* ge) {
	assert(ge);
	std::vector<GenParticle*> rtn;
	for (GenEvent::particle_iterator pi = ge->particles_begin(); pi != ge->particles_end(); ++pi)
	rtn.push_back(*pi);
	return rtn;
	}


	inline std::vector<const GenVertex> vertices(const GenEvent ge) {
	std::vector<GenVertex const *> rtn;
	for (GenEvent::vertex_const_iterator vi = ge->vertices_begin(); vi != ge->vertices_end(); ++vi)
	rtn.push_back(*vi);
	return rtn;
	}

	inline std::vector<GenVertex> vertices(GenEvent ge) {
	std::vector<GenVertex*> rtn;
	for (GenEvent::vertex_iterator vi = ge->vertices_begin(); vi != ge->vertices_end(); ++vi)
	rtn.push_back(*vi);
	return rtn;
	}


	//////////////////////////


	inline std::vector<const GenParticle> particles(const GenVertex gv, HepMC::IteratorRange range=HepMC::relatives) {
	std::vector<GenParticle const *> rtn;
	/// @todo A particle_const_iterator on GenVertex would be nice...
	// Before HepMC 2.7.0 there were no GV::particles_const_iterators and constness consistency was all screwed up :-/
	#if HEPMC_VERSION_CODE >= 2007000
	// for (GenVertex::particle_iterator pi = gv->particles_const_begin(range); pi != gv->particles_const_end(range); ++pi)
	for (GenVertex::particle_iterator pi = gv->particles_begin(range); pi != gv->particles_end(range); ++pi)
	rtn.push_back(*pi);
	#else
	GenVertex* gv2 = const_cast<GenVertex*>(gv);
	for (GenVertex::particle_iterator pi = gv2->particles_begin(range); pi != gv2->particles_end(range); ++pi)
	rtn.push_back(const_cast<const GenParticle>(pi));
	#endif
	return rtn;
	}

	inline std::vector<GenParticle> particles(GenVertex gv, HepMC::IteratorRange range=HepMC::relatives) {
	std::vector<GenParticle*> rtn;
	for (GenVertex::particle_iterator pi = gv->particles_begin(range); pi != gv->particles_end(range); ++pi)
	rtn.push_back(*pi);
	return rtn;
	}



	// Get iterator ranges as wrapped begin/end pairs
	/// @note GenVertex _in and _out iterators are actually, secretly the same types sigh
	struct GenVertexIterRangeC {
	- GenVertexIterRangeC(const GenVertex::particles_in_const_iterator& begin, const GenVertex::particles_in_const_iterator& end)
	+ typedef vector<GenParticle*>::const_iterator genvertex_particles_const_iterator;
	+ GenVertexIterRangeC(const genvertex_particles_const_iterator& begin, const genvertex_particles_const_iterator& end)
	: _begin(begin), _end(end) { }
	- const GenVertex::particles_in_const_iterator& begin() { return _begin; }
	- const GenVertex::particles_in_const_iterator& end() { return _end; }
	+ const genvertex_particles_const_iterator& begin() { return _begin; }
	+ const genvertex_particles_const_iterator& end() { return _end; }
	private:
	- const GenVertex::particles_in_const_iterator _begin, _end;
	+ const genvertex_particles_const_iterator _begin, _end;
	};

	inline GenVertexIterRangeC particles_in(const GenVertex* gv) {
	return GenVertexIterRangeC(gv->particles_in_const_begin(), gv->particles_in_const_end());
	}

	inline GenVertexIterRangeC particles_out(const GenVertex* gv) {
	return GenVertexIterRangeC(gv->particles_out_const_begin(), gv->particles_out_const_end());
	}



	#if HEPMC_VERSION_CODE >= 2007000

	// Get iterator ranges as wrapped begin/end pairs
	/// @note GenVertex _in and _out iterators are actually, secretly the same types sigh
	struct GenVertexIterRange {
	- GenVertexIterRange(const GenVertex::particles_in_iterator& begin, const GenVertex::particles_in_iterator& end)
	+ typedef vector<GenParticle*>::iterator genvertex_particles_iterator;
	+ GenVertexIterRange(const genvertex_particles_iterator& begin, const genvertex_particles_iterator& end)
	: _begin(begin), _end(end) { }
	- const GenVertex::particles_in_iterator& begin() { return _begin; }
	- const GenVertex::particles_in_iterator& end() { return _end; }
	+ const genvertex_particles_iterator& begin() { return _begin; }
	+ const genvertex_particles_iterator& end() { return _end; }
	private:
	- const GenVertex::particles_in_iterator _begin, _end;
	+ const genvertex_particles_iterator _begin, _end;
	};

	- inline GenVertexIterRange particles_in(const GenVertex* gv) {
	+ inline GenVertexIterRange particles_in(GenVertex* gv) {
	return GenVertexIterRange(gv->particles_in_begin(), gv->particles_in_end());
	}

	- inline GenVertexIterRange particles_out(const GenVertex* gv) {
	+ inline GenVertexIterRange particles_out(GenVertex* gv) {
	return GenVertexIterRange(gv->particles_out_begin(), gv->particles_out_end());
	}

	#endif


	//////////////////////////


	/// Get the direct parents or all-ancestors of GenParticle @a gp
	inline std::vector<const GenParticle> particles_in(const GenParticle gp, HepMC::IteratorRange range=HepMC::ancestors) {
	if (range != HepMC::parents && range != HepMC::ancestors)
	throw UserError("Requested particles_in(GenParticle*) with a non-'in' iterator range");
	if (!gp->production_vertex()) return std::vector<const GenParticle*>();
	#if HEPMC_VERSION_CODE >= 2007000
	return particles(gp->production_vertex(), range);
	#else
	// Before HepMC 2.7.0 the constness consistency of methods and their return types was all screwed up :-/
	std::vector<const GenParticle*> rtn;
	foreach (GenParticle* gp2, particles(gp->production_vertex(), range))
	rtn.push_back( const_cast<const GenParticle*>(gp2) );
	return rtn;
	#endif
	}

	/// Get the direct parents or all-ancestors of GenParticle @a gp
	inline std::vector<GenParticle> particles_in(GenParticle gp, HepMC::IteratorRange range=HepMC::ancestors) {
	if (range != HepMC::parents && range != HepMC::ancestors)
	throw UserError("Requested particles_in(GenParticle*) with a non-'in' iterator range");
	return (gp->production_vertex()) ? particles(gp->production_vertex(), range) : std::vector<GenParticle*>();
	}


	/// Get the direct children or all-descendents of GenParticle @a gp
	inline std::vector<const GenParticle> particles_out(const GenParticle gp, HepMC::IteratorRange range=HepMC::descendants) {
	if (range != HepMC::children && range != HepMC::descendants)
	throw UserError("Requested particles_out(GenParticle*) with a non-'out' iterator range");
	if (!gp->end_vertex()) return std::vector<const GenParticle*>();
	#if HEPMC_VERSION_CODE >= 2007000
	return particles(gp->end_vertex(), range);
	#else
	// Before HepMC 2.7.0 the constness consistency of methods and their return types was all screwed up :-/
	std::vector<const GenParticle*> rtn;
	foreach (GenParticle* gp2, particles(gp->end_vertex(), range))
	rtn.push_back( const_cast<const GenParticle*>(gp2) );
	return rtn;
	#endif
	}

	/// Get the direct children or all-descendents of GenParticle @a gp
	inline std::vector<GenParticle> particles_out(GenParticle gp, HepMC::IteratorRange range=HepMC::descendants) {
	if (range != HepMC::children && range != HepMC::descendants)
	throw UserError("Requested particles_out(GenParticle*) with a non-'out' iterator range");
	return (gp->end_vertex()) ? particles(gp->end_vertex(), range) : std::vector<GenParticle*>();
	}


	+ /// Get any relatives of GenParticle @a gp
	+ inline std::vector<const GenParticle> particles(const GenParticle gp, HepMC::IteratorRange range=HepMC::ancestors) {
	+ if (range == HepMC::parents \|\| range == HepMC::ancestors)
	+ return particles_in(gp, range);
	+ if (range == HepMC::children \|\| range == HepMC::descendants)
	+ return particles_in(gp, range);
	+ throw UserError("Requested particles(GenParticle*) with an unsupported iterator range");
	+ }
	+
	+
	}

	#endif
	diff --git a/include/Rivet/Tools/RivetMT2.hh b/include/Rivet/Tools/RivetMT2.hh
	--- a/include/Rivet/Tools/RivetMT2.hh
	+++ b/include/Rivet/Tools/RivetMT2.hh
	@@ -1,23 +1,23 @@
	// -- C++ --
	#ifndef RIVET_MT2_HH
	#define RIVET_MT2_HH

	-// Convenience wrapper for the m_T2 calculator of Cheng/Han
	-// (arXiv:0810.5178). Could be adapted for other backends in future
	-
	namespace Rivet {

	class FourMomentum;

	namespace mT2 {
	-
	- double mT2(const FourMomentum & a,
	- const FourMomentum & b,
	- const FourMomentum & pTmiss,
	- double invisiblesMass);
	+
	+ /// @brief Convenience wrapper for the mT2 calculator of Cheng/Han
	+ ///
	+ /// (arXiv:0810.5178). Could be adapted for other backends in future.
	+ double mT2(const FourMomentum& a,
	+ const FourMomentum& b,
	+ const FourMomentum& pTmiss,
	+ double invisiblesMass);

	}
	+
	}

	-
	#endif
	diff --git a/include/Rivet/Tools/RivetPaths.hh b/include/Rivet/Tools/RivetPaths.hh
	--- a/include/Rivet/Tools/RivetPaths.hh
	+++ b/include/Rivet/Tools/RivetPaths.hh
	@@ -1,95 +1,104 @@
	// -- C++ --
	#ifndef RIVET_RivetPaths_HH
	#define RIVET_RivetPaths_HH
	#include <string>
	#include <vector>
	#include <unistd.h>

	namespace Rivet {


	/// Convenience function for determining if a filesystem path exists
	inline bool fileexists(const std::string& path) {
	return (access(path.c_str(), R_OK) == 0);
	}


	/// @name Installation directory paths
	//@{

	/// Get library install path
	std::string getLibPath();

	/// Get data install path
	std::string getDataPath();

	/// Get Rivet data install path
	std::string getRivetDataPath();

	//@}


	/// @name Analysis library search paths
	//@{

	/// Get Rivet analysis plugin library search paths
	std::vector<std::string> getAnalysisLibPaths();

	/// Set the Rivet analysis plugin library search paths
	void setAnalysisLibPaths(const std::vector<std::string>& paths);

	- /// Set the Rivet analysis plugin library search paths
	+ /// Add a Rivet analysis plugin library search path
	void addAnalysisLibPath(const std::string& extrapath);

	/// @brief Find the first file of the given name in the analysis library search dirs
	/// @note If none found, returns an empty string
	std::string findAnalysisLibFile(const std::string& filename);

	//@}


	/// @name Analysis data/metadata paths and search functions
	//@{

	/// Get Rivet analysis reference data search paths
	std::vector<std::string> getAnalysisDataPaths();

	+ /// Set the Rivet data file search paths
	+ void setAnalysisDataPaths(const std::vector<std::string>& paths);
	+
	+ /// Add a Rivet data file search path
	+ void addAnalysisDataPath(const std::string& extrapath);
	+
	/// @brief Find the first file of the given name in the general data file search dirs
	/// @note If none found, returns an empty string
	std::string findAnalysisDataFile(const std::string& filename,
	- const std::vector<std::string>& pathprepend=std::vector<std::string>(),
	- const std::vector<std::string>& pathappend=std::vector<std::string>());
	+ const std::vector<std::string>& pathprepend=std::vector<std::string>(),
	+ const std::vector<std::string>& pathappend=std::vector<std::string>());
	+

	/// Get Rivet analysis reference data search paths
	std::vector<std::string> getAnalysisRefPaths();

	/// @brief Find the first file of the given name in the ref data file search dirs
	/// @note If none found, returns an empty string
	std::string findAnalysisRefFile(const std::string& filename,
	const std::vector<std::string>& pathprepend=std::vector<std::string>(),
	const std::vector<std::string>& pathappend=std::vector<std::string>());

	+
	/// Get Rivet analysis info metadata search paths
	std::vector<std::string> getAnalysisInfoPaths();

	/// @brief Find the first file of the given name in the analysis info file search dirs
	/// @note If none found, returns an empty string
	std::string findAnalysisInfoFile(const std::string& filename,
	const std::vector<std::string>& pathprepend=std::vector<std::string>(),
	const std::vector<std::string>& pathappend=std::vector<std::string>());

	+
	/// Get Rivet analysis plot style search paths
	std::vector<std::string> getAnalysisPlotPaths();

	/// @brief Find the first file of the given name in the analysis plot file search dirs
	/// @note If none found, returns an empty string
	std::string findAnalysisPlotFile(const std::string& filename,
	const std::vector<std::string>& pathprepend=std::vector<std::string>(),
	const std::vector<std::string>& pathappend=std::vector<std::string>());

	//@}


	}

	#endif
	diff --git a/include/Rivet/Tools/RivetSTL.hh b/include/Rivet/Tools/RivetSTL.hh
	--- a/include/Rivet/Tools/RivetSTL.hh
	+++ b/include/Rivet/Tools/RivetSTL.hh
	@@ -1,158 +1,173 @@
	#ifndef RIVET_RivetSTL_HH
	#define RIVET_RivetSTL_HH

	#include <string>
	#include <vector>
	#include <set>
	#include <list>
	#include <map>
	#include <utility>
	#include <algorithm>
	#include <type_traits>
	#include <stdexcept>
	#include <cassert>
	#include <memory>
	#include <typeinfo>
	#include <sstream>
	#include <fstream>
	#include <iostream>
	#include <iomanip>
	#include <cmath>
	#include <limits>


	#ifndef foreach
	/// @decl A foreach macro for backward compatibility with BOOST_FOREACH
	#define foreach(value, container) for (value : container)
	#endif


	namespace Rivet {


	/// We implicitly use STL entities in the Rivet namespace
	using namespace std;


	/// @name Streaming containers as string reps
	/// @todo Make these named toStr rather than operator<<
	+ /// @todo Make these generic to any iterable
	//@{

	/// Convenient function for streaming out vectors of any streamable object.
	template<typename T>
	inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
	os << "[ ";
	for (size_t i=0; i<vec.size(); ++i) {
	os << vec[i] << " ";
	}
	os << "]";
	return os;
	}

	/// Convenient function for streaming out lists of any streamable object.
	template<typename T>
	inline std::ostream& operator<<(std::ostream& os, const std::list<T>& vec) {
	os << "[ ";
	for (size_t i=0; i<vec.size(); ++i) {
	os << vec[i] << " ";
	}
	os << "]";
	return os;
	}

	//@}


	/// @name Boolean-return container searching
	//@{

	/// @todo Use SFINAE, Boost.Range, or other template trickery for more generic container matching?

	/// Does @a s contain @a sub as a substring?
	inline bool contains(const std::string& s, const std::string& sub) {
	return s.find(sub) != string::npos;
	}

	/// Does the vector @a v contain @a x?
	template <typename T>
	inline bool contains(const std::vector<T>& v, const T& x) {
	return find(v.begin(), v.end(), x) != v.end();
	}

	/// Does the list @a l contain @a x?
	template <typename T>
	inline bool contains(const std::list<T>& l, const T& x) {
	return find(l.begin(), l.end(), x) != l.end();
	}

	/// Does the set @a s contain @a x?
	template <typename T>
	inline bool contains(const std::set<T>& s, const T& x) {
	return find(s.begin(), s.end(), x) != s.end();
	}

	/// Does the map @a m contain the key @a key?
	template <typename K, typename T>
	inline bool has_key(const std::map<K, T>& m, const K& key) {
	return m.find(key) != m.end();
	}

	/// Does the map @a m contain the value @a val?
	template <typename K, typename T>
	inline bool has_value(const std::map<K, T>& m, const T& val) {
	for (typename std::map<K,T>::const_iterator it = m.begin(); it != m.end(); ++it) {
	if (it->second == val) return true;
	}
	return false;
	}

	//@}


	}

	namespace std {


	/// @name Container filling and merging
	//@{

	/// Append a single item to vector @a v
	template <typename T>
	inline void operator+=(std::vector<T>& v, const T& x) { v.push_back(x); }

	/// Append all the items from vector @a v2 to vector @a v1
	template <typename T>
	inline void operator+=(std::vector<T>& v1, const std::vector<T>& v2) {
	for (const auto& x : v2) v1.push_back(x);
	}

	/// Create a new vector from the concatenated items in vectors @a v1 and @a v2
	template <typename T>
	inline std::vector<T> operator+(const std::vector<T>& v1, const std::vector<T>& v2) {
	std::vector<T> rtn(v1);
	rtn += v2;
	return rtn;
	}


	/// Merge the contents of set @a s2 into @a s1
	template <typename T>
	inline void operator+=(std::set<T>& s1, const std::set<T>& s2) {
	for (const auto& x : s2) s1.insert(x);
	}

	/// Merge the contents of sets @a s1 and @a s2
	template <typename T>
	inline std::set<T> operator+(const std::set<T>& s1, const std::set<T>& s2) {
	std::set<T> rtn(s1);
	rtn += s2;
	return rtn;
	}

	//@}


	+ /// @name Function helpers
	+ //@{
	+
	+ /// Get a function pointer / hash integer from an std::function
	+ template<typename T, typename... U>
	+ inline size_t get_address(std::function<T(U...)> f) {
	+ typedef T(fnType)(U...);
	+ fnType ** fnPointer = f.template target<fnType*>();
	+ return (fnPointer != nullptr) ? reinterpret_cast<size_t>(*fnPointer) : 0;
	+ }
	+
	+ //@}
	+
	+
	}

	#endif
	diff --git a/include/Rivet/Tools/RivetYODA.hh b/include/Rivet/Tools/RivetYODA.hh
	--- a/include/Rivet/Tools/RivetYODA.hh
	+++ b/include/Rivet/Tools/RivetYODA.hh
	@@ -1,61 +1,54 @@
	#ifndef RIVET_RIVETYODA_HH
	#define RIVET_RIVETYODA_HH

	#include "Rivet/Config/RivetCommon.hh"
	#include "YODA/AnalysisObject.h"
	#include "YODA/Counter.h"
	#include "YODA/Histo1D.h"
	#include "YODA/Histo2D.h"
	#include "YODA/Profile1D.h"
	#include "YODA/Profile2D.h"
	#include "YODA/Scatter1D.h"
	#include "YODA/Scatter2D.h"
	#include "YODA/Scatter3D.h"

	namespace Rivet {

	typedef std::shared_ptr<YODA::AnalysisObject> AnalysisObjectPtr;
	typedef std::shared_ptr<YODA::Counter> CounterPtr;
	typedef std::shared_ptr<YODA::Histo1D> Histo1DPtr;
	typedef std::shared_ptr<YODA::Histo2D> Histo2DPtr;
	typedef std::shared_ptr<YODA::Profile1D> Profile1DPtr;
	typedef std::shared_ptr<YODA::Profile2D> Profile2DPtr;
	typedef std::shared_ptr<YODA::Scatter1D> Scatter1DPtr;
	typedef std::shared_ptr<YODA::Scatter2D> Scatter2DPtr;
	typedef std::shared_ptr<YODA::Scatter3D> Scatter3DPtr;

	using YODA::AnalysisObject;
	using YODA::Counter;
	using YODA::Histo1D;
	using YODA::HistoBin1D;
	using YODA::Histo2D;
	using YODA::HistoBin2D;
	using YODA::Profile1D;
	using YODA::ProfileBin1D;
	using YODA::Profile2D;
	using YODA::ProfileBin2D;
	using YODA::Scatter1D;
	using YODA::Point1D;
	using YODA::Scatter2D;
	using YODA::Point2D;
	using YODA::Scatter3D;
	using YODA::Point3D;


	/// Function to get a map of all the refdata in a paper with the given @a papername.
	map<string, AnalysisObjectPtr> getRefData(const string& papername);

	/// Get the file system path to the reference file for this paper.
	string getDatafilePath(const string& papername);

	- /// Return the integral over the histogram bins
	- /// @deprecated Prefer to directly use the histo's integral() method.
	- DEPRECATED("Prefer to directly use the histo's integral() method.")
	- inline double integral(Histo1DPtr histo) {
	- return histo->integral();
	- }
	-

	}

	#endif
	diff --git a/include/Rivet/Tools/SmearingFunctions.hh b/include/Rivet/Tools/SmearingFunctions.hh
	--- a/include/Rivet/Tools/SmearingFunctions.hh
	+++ b/include/Rivet/Tools/SmearingFunctions.hh
	@@ -1,518 +1,823 @@
	// -- C++ --
	#ifndef RIVET_SmearingFunctions_HH
	#define RIVET_SmearingFunctions_HH

	#include "Rivet/Particle.hh"
	#include "Rivet/Jet.hh"
	#include <random>

	namespace Rivet {


	+ /// @name Random number and filtering utils
	+ //@{
	+
	/// Return a uniformly sampled random number between 0 and 1
	+ /// @todo Where is it seeded?! Default = by timestamp?!
	/// @todo Move to (math?)utils
	/// @todo Need to isolate random generators to a single thread
	inline double rand01() {
	//return rand() / (double)RAND_MAX;
	static random_device rd;
	static mt19937 gen(rd());
	return generate_canonical<double, 10>(gen);
	}

	+ /// Return true if Particle @a p is chosen to survive a random efficiency selection
	+ template <typename FN>
	+ inline bool efffilt(const Particle& p, FN& feff) {
	+ return rand01() < feff(p);
	+ }
	+ /// Return true if Jet @a j is chosen to survive a random efficiency selection
	+ template <typename FN>
	+ inline bool efffilt(const Jet& j, FN& feff) {
	+ return rand01() < feff(j);
	+ }

	+ /// A functor to return true if Particle @a p survives a random efficiency selection
	+ struct ParticleEffFilter {
	+ template <typename FN>
	+ ParticleEffFilter(const FN& feff) : _feff(feff) {}
	+ ParticleEffFilter(double eff) : ParticleEffFilter( [&](const Particle& p){return eff;} ) {}
	+ bool operator () (const Particle& p) const { return efffilt(p, _feff); }
	+ private:
	+ const std::function<bool(const Particle&)> _feff;
	+ };
	+ using particleEffFilter = ParticleEffFilter;

	- /// @name General particle efficiency and smearing functions
	- //@{
	-
	- inline double PARTICLE_FN0(const Particle& p) { return 0; }
	- inline double PARTICLE_FN1(const Particle& p) { return 1; }
	-
	- inline double P4_FN0(const FourMomentum& p) { return 0; }
	- inline double P4_FN1(const FourMomentum& p) { return 1; }
	-
	- inline Particle PARTICLE_SMEAR_IDENTITY(const Particle& p) { return p; }
	+ /// A functor to return true if Jet @a j survives a random efficiency selection
	+ struct JetEffFilter {
	+ template <typename FN>
	+ JetEffFilter(const FN& feff) : _feff(feff) {}
	+ JetEffFilter(double eff) : JetEffFilter( [&](const Jet& j){return eff;} ) {}
	+ bool operator () (const Jet& j) const { return efffilt(j, _feff); }
	+ private:
	+ const std::function<bool(const Jet&)> _feff;
	+ };
	+ using jetEffFilter = JetEffFilter;

	//@}


	+ /// @name General particle & momentum efficiency and smearing functions
	+ //@{
	+
	+ /// Take a Particle and return 0
	+ inline double PARTICLE_FN0(const Particle& p) { return 0; }
	+ /// Take a Particle and return 1
	+ inline double PARTICLE_FN1(const Particle& p) { return 1; }
	+ /// Take a Particle and return it unmodified
	+ inline Particle PARTICLE_SMEAR_IDENTITY(const Particle& p) { return p; }
	+
	+
	+ /// Take a FourMomentum and return 0
	+ inline double P4_FN0(const FourMomentum& p) { return 0; }
	+ /// Take a FourMomentum and return 1
	+ inline double P4_FN1(const FourMomentum& p) { return 1; }
	+ /// Take a FourMomentum and return it unmodified
	+ inline FourMomentum P4_SMEAR_IDENTITY(const FourMomentum& p) { return p; }
	+
	+ /// Smear a FourMomentum's energy using a Gaussian of absolute width @a resolution
	+ /// @todo Also make jet versions that update/smear constituents?
	+ inline FourMomentum P4_SMEAR_E_GAUSS(const FourMomentum& p, double resolution) {
	+ /// @todo Need to isolate random generators to a single thread
	+ static random_device rd;
	+ static mt19937 gen(rd());
	+ normal_distribution<> d(p.E(), resolution);
	+ const double mass = p.mass2() > 0 ? p.mass() : 0; //< numerical carefulness...
	+ const double smeared_E = max(d(gen), mass); //< can't let the energy go below the mass!
	+ return FourMomentum::mkEtaPhiME(p.eta(), p.phi(), mass, smeared_E);
	+ }
	+
	+ /// Smear a FourMomentum's transverse momentum using a Gaussian of absolute width @a resolution
	+ inline FourMomentum P4_SMEAR_PT_GAUSS(const FourMomentum& p, double resolution) {
	+ /// @todo Need to isolate random generators to a single thread
	+ static random_device rd;
	+ static mt19937 gen(rd());
	+ normal_distribution<> d(p.pT(), resolution);
	+ const double smeared_pt = max(d(gen), 0.);
	+ const double mass = p.mass2() > 0 ? p.mass() : 0; //< numerical carefulness...
	+ return FourMomentum::mkEtaPhiMPt(p.eta(), p.phi(), mass, smeared_pt);
	+ }
	+
	+ /// Smear a FourMomentum's mass using a Gaussian of absolute width @a resolution
	+ inline FourMomentum P4_SMEAR_MASS_GAUSS(const FourMomentum& p, double resolution) {
	+ /// @todo Need to isolate random generators to a single thread
	+ static random_device rd;
	+ static mt19937 gen(rd());
	+ normal_distribution<> d(p.mass(), resolution);
	+ const double smeared_mass = max(d(gen), 0.);
	+ return FourMomentum::mkEtaPhiMPt(p.eta(), p.phi(), smeared_mass, p.pT());
	+ }
	+
	+
	+ /// Take a Vector3 and return 0
	+ inline double P3_FN0(const Vector3& p) { return 0; }
	+ /// Take a Vector3 and return 1
	+ inline double P3_FN1(const Vector3& p) { return 1; }
	+ /// Take a Vector3 and return it unmodified
	+ inline Vector3 P3_SMEAR_IDENTITY(const Vector3& p) { return p; }
	+
	+ /// Smear a Vector3's length using a Gaussian of absolute width @a resolution
	+ inline Vector3 P3_SMEAR_LEN_GAUSS(const Vector3& p, double resolution) {
	+ /// @todo Need to isolate random generators to a single thread
	+ static random_device rd;
	+ static mt19937 gen(rd());
	+ normal_distribution<> d(p.mod(), resolution);
	+ const double smeared_mod = max(d(gen), 0.); //< can't let the energy go below the mass!
	+ return smeared_mod * p.unit();
	+ }
	+
	+ //@}
	+
	+
	/// @name Electron efficiency and smearing functions
	//@{

	- /// ATLAS Run 1 electron tracking efficiency
	- /// @todo How to use this in combination with reco eff?
	- inline double ELECTRON_TRKEFF_ATLAS_RUN1(const Particle& e) {
	- if (e.abseta() > 2.5) return 0;
	- if (e.pT() < 0.1*GeV) return 0;
	- if (e.abseta() < 1.5) {
	- if (e.pT() < 1*GeV) return 0.73;
	- if (e.pT() < 100*GeV) return 0.95;
	- return 0.99;
	- } else {
	- if (e.pT() < 1*GeV) return 0.50;
	- if (e.pT() < 100*GeV) return 0.83;
	- else return 0.90;
	- }
	- }
	-
	-
	- /// ATLAS Run 2 electron tracking efficiency
	- /// @todo Currently just a copy of Run 1: fix!
	- inline double ELECTRON_TRKEFF_ATLAS_RUN2(const Particle& e) {
	- return ELECTRON_TRKEFF_ATLAS_RUN1(e);
	- }
	-
	/// ATLAS Run 1 electron reconstruction efficiency
	/// @todo Include reco eff (but no e/y discrimination) in forward region
	/// @todo How to use this in combination with tracking eff?
	inline double ELECTRON_EFF_ATLAS_RUN1(const Particle& e) {
	if (e.abseta() > 2.5) return 0;
	if (e.pT() < 10*GeV) return 0;
	return (e.abseta() < 1.5) ? 0.95 : 0.85;
	}

	-
	/// ATLAS Run 2 electron reco efficiency
	/// @todo Currently just a copy of Run 1: fix!
	inline double ELECTRON_EFF_ATLAS_RUN2(const Particle& e) {
	return ELECTRON_EFF_ATLAS_RUN1(e);
	}


	+ /// @brief ATLAS Run 2 'loose' electron identification/selection efficiency
	+ ///
	+ /// Values read from Fig 3 of ATL-PHYS-PUB-2015-041
	+ /// @todo What about faking by jets or non-electrons?
	+ inline double ELECTRON_IDEFF_ATLAS_RUN2_LOOSE(const Particle& e) {
	+
	+ // Manually symmetrised eta eff histogram
	+ const static vector<double> edges_eta = { 0.0, 0.1, 0.8, 1.37, 1.52, 2.01, 2.37, 2.47 };
	+ const static vector<double> effs_eta = { 0.950, 0.965, 0.955, 0.885, 0.950, 0.935, 0.90 };
	+ // Et eff histogram (10-20 is a guess)
	+ const static vector<double> edges_et = { 0, 10, 20, 25, 30, 35, 40, 45, 50, 60, 80 };
	+ const static vector<double> effs_et = { 0.0, 0.90, 0.91, 0.92, 0.94, 0.95, 0.955, 0.965, 0.97, 0.98 };
	+
	+ if (e.abseta() > 2.47) return 0.0; // no ID outside the tracker
	+
	+ const int i_eta = binIndex(e.abseta(), edges_eta);
	+ const int i_et = binIndex(e.Et()/GeV, edges_et, true);
	+ const double eff = effs_et[i_et] * effs_eta[i_eta] / 0.95; //< norm factor as approximate double differential
	+ return min(eff, 1.0);
	+ }
	+
	+
	+ /// @brief ATLAS Run 1 'medium' electron identification/selection efficiency
	+ inline double ELECTRON_IDEFF_ATLAS_RUN1_MEDIUM(const Particle& e) {
	+
	+ const static vector<double> eta_edges_10 = {0.000, 0.049, 0.454, 1.107, 1.46, 1.790, 2.277, 2.500};
	+ const static vector<double> eta_vals_10 = {0.730, 0.757, 0.780, 0.771, 0.77, 0.777, 0.778};
	+
	+ const static vector<double> eta_edges_15 = {0.000, 0.053, 0.456, 1.102, 1.463, 1.783, 2.263, 2.500};
	+ const static vector<double> eta_vals_15 = {0.780, 0.800, 0.819, 0.759, 0.749, 0.813, 0.829};
	+
	+ const static vector<double> eta_edges_20 = {0.000, 0.065, 0.362, 0.719, 0.980, 1.289, 1.455, 1.681, 1.942, 2.239, 2.452, 2.500};
	+ const static vector<double> eta_vals_20 = {0.794, 0.806, 0.816, 0.806, 0.797, 0.774, 0.764, 0.788, 0.793, 0.806, 0.825};
	+
	+ const static vector<double> eta_edges_25 = {0.000, 0.077, 0.338, 0.742, 1.004, 1.265, 1.467, 1.692, 1.940, 2.227, 2.452, 2.500};
	+ const static vector<double> eta_vals_25 = {0.833, 0.843, 0.853, 0.845, 0.839, 0.804, 0.790, 0.825, 0.830, 0.833, 0.839};
	+
	+ const static vector<double> eta_edges_30 = {0.000, 0.077, 0.350, 0.707, 0.980, 1.289, 1.479, 1.681, 1.942, 2.239, 2.441, 2.500};
	+ const static vector<double> eta_vals_30 = {0.863, 0.872, 0.881, 0.874, 0.870, 0.824, 0.808, 0.847, 0.845, 0.840, 0.842};
	+
	+ const static vector<double> eta_edges_35 = {0.000, 0.058, 0.344, 0.700, 1.009, 1.270, 1.458, 1.685, 1.935, 2.231, 2.468, 2.500};
	+ const static vector<double> eta_vals_35 = {0.878, 0.889, 0.901, 0.895, 0.893, 0.849, 0.835, 0.868, 0.863, 0.845, 0.832};
	+
	+ const static vector<double> eta_edges_40 = {0.000, 0.047, 0.355, 0.699, 0.983, 1.280, 1.446, 1.694, 1.943, 2.227, 2.441, 2.500};
	+ const static vector<double> eta_vals_40 = {0.894, 0.901, 0.909, 0.905, 0.904, 0.875, 0.868, 0.889, 0.876, 0.848, 0.827};
	+
	+ const static vector<double> eta_edges_45 = {0.000, 0.058, 0.356, 0.712, 0.997, 1.282, 1.459, 1.686, 1.935, 2.220, 2.444, 2.500};
	+ const static vector<double> eta_vals_45 = {0.900, 0.911, 0.923, 0.918, 0.917, 0.897, 0.891, 0.904, 0.894, 0.843, 0.796};
	+
	+ const static vector<double> eta_edges_50 = {0.000, 0.059, 0.355, 0.711, 0.983, 1.280, 1.469, 1.682, 1.919, 2.227, 2.441, 2.500};
	+ const static vector<double> eta_vals_50 = {0.903, 0.913, 0.923, 0.922, 0.923, 0.903, 0.898, 0.908, 0.895, 0.831, 0.774};
	+
	+ const static vector<double> eta_edges_60 = {0.000, 0.053, 0.351, 0.720, 1.006, 1.291, 1.469, 1.696, 1.946, 2.243, 2.455, 2.500};
	+ const static vector<double> eta_vals_60 = {0.903, 0.917, 0.928, 0.924, 0.927, 0.915, 0.911, 0.915, 0.899, 0.827, 0.760};
	+
	+ const static vector<double> eta_edges_80 = {0.000, 0.053, 0.351, 0.720, 0.994, 1.292, 1.482, 1.708, 1.934, 2.220, 2.458, 2.500};
	+ const static vector<double> eta_vals_80 = {0.936, 0.942, 0.952, 0.956, 0.956, 0.934, 0.931, 0.944, 0.933, 0.940, 0.948};
	+
	+ const static vector<double> et_edges = { 10, 15, 20, 25, 30, 35, 40, 45, 50, 60, 80 };
	+ const static vector< vector<double> > et_eta_edges = { eta_edges_10, eta_edges_15, eta_edges_20, eta_edges_25, eta_edges_30, eta_edges_35, eta_edges_40, eta_edges_45, eta_edges_50, eta_edges_60, eta_edges_80 };
	+ const static vector< vector<double> > et_eta_vals = { eta_vals_10, eta_vals_15, eta_vals_20, eta_vals_25, eta_vals_30, eta_vals_35, eta_vals_40, eta_vals_45, eta_vals_50, eta_vals_60, eta_vals_80 };
	+
	+ if (e.abseta() > 2.5 \|\| e.Et() < 10*GeV) return 0.0;
	+ const int i_et = binIndex(e.Et()/GeV, et_edges, true);
	+ const int i_eta = binIndex(e.abseta(), et_eta_edges[i_et]);
	+ return et_eta_vals[i_et][i_eta];
	+ }
	+
	+ /// @brief ATLAS Run 2 'medium' electron identification/selection efficiency
	+ /// @todo Currently just a copy of Run 1: fix!
	+ inline double ELECTRON_IDEFF_ATLAS_RUN2_MEDIUM(const Particle& e) {
	+ return ELECTRON_IDEFF_ATLAS_RUN1_MEDIUM(e);
	+ }
	+
	+
	+ /// @brief ATLAS Run 1 'tight' electron identification/selection efficiency
	+ inline double ELECTRON_IDEFF_ATLAS_RUN1_TIGHT(const Particle& e) {
	+
	+ const static vector<double> eta_edges_10 = {0.000, 0.049, 0.459, 1.100, 1.461, 1.789, 2.270, 2.500};
	+ const static vector<double> eta_vals_10 = {0.581, 0.632, 0.668, 0.558, 0.548, 0.662, 0.690};
	+
	+ const static vector<double> eta_edges_15 = {0.000, 0.053, 0.450, 1.096, 1.463, 1.783, 2.269, 2.500};
	+ const static vector<double> eta_vals_15 = {0.630, 0.678, 0.714, 0.633, 0.616, 0.700, 0.733};
	+
	+ const static vector<double> eta_edges_20 = {0.000, 0.065, 0.362, 0.719, 0.992, 1.277, 1.479, 1.692, 1.930, 2.227, 2.464, 2.500};
	+ const static vector<double> eta_vals_20 = {0.653, 0.695, 0.735, 0.714, 0.688, 0.635, 0.625, 0.655, 0.680, 0.691, 0.674};
	+
	+ const static vector<double> eta_edges_25 = {0.000, 0.077, 0.362, 0.719, 0.992, 1.300, 1.479, 1.692, 1.942, 2.227, 2.464, 2.500};
	+ const static vector<double> eta_vals_25 = {0.692, 0.732, 0.768, 0.750, 0.726, 0.677, 0.667, 0.692, 0.710, 0.706, 0.679};
	+
	+ const static vector<double> eta_edges_30 = {0.000, 0.053, 0.362, 0.719, 1.004, 1.277, 1.467, 1.681, 1.954, 2.239, 2.452, 2.500};
	+ const static vector<double> eta_vals_30 = {0.724, 0.763, 0.804, 0.789, 0.762, 0.702, 0.690, 0.720, 0.731, 0.714, 0.681};
	+
	+ const static vector<double> eta_edges_35 = {0.000, 0.044, 0.342, 0.711, 0.971, 1.280, 1.456, 1.683, 1.944, 2.218, 2.442, 2.500};
	+ const static vector<double> eta_vals_35 = {0.736, 0.778, 0.824, 0.811, 0.784, 0.730, 0.718, 0.739, 0.743, 0.718, 0.678};
	+
	+ const static vector<double> eta_edges_40 = {0.000, 0.047, 0.355, 0.699, 0.983, 1.268, 1.457, 1.671, 1.931, 2.204, 2.453, 2.500};
	+ const static vector<double> eta_vals_40 = {0.741, 0.774, 0.823, 0.823, 0.802, 0.764, 0.756, 0.771, 0.771, 0.734, 0.684};
	+
	+ const static vector<double> eta_edges_45 = {0.000, 0.056, 0.354, 0.711, 0.984, 1.280, 1.458, 1.684, 1.945, 2.207, 2.442, 2.500};
	+ const static vector<double> eta_vals_45 = {0.758, 0.792, 0.841, 0.841, 0.823, 0.792, 0.786, 0.796, 0.794, 0.734, 0.663};
	+
	+ const static vector<double> eta_edges_50 = {0.000, 0.059, 0.355, 0.699, 0.983, 1.268, 1.446, 1.682, 1.943, 2.216, 2.453, 2.500};
	+ const static vector<double> eta_vals_50 = {0.771, 0.806, 0.855, 0.858, 0.843, 0.810, 0.800, 0.808, 0.802, 0.730, 0.653};
	+
	+ const static vector<double> eta_edges_60 = {0.000, 0.050, 0.350, 0.707, 0.981, 1.278, 1.468, 1.694, 1.944, 2.242, 2.453, 2.500};
	+ const static vector<double> eta_vals_60 = {0.773, 0.816, 0.866, 0.865, 0.853, 0.820, 0.812, 0.817, 0.804, 0.726, 0.645};
	+
	+ const static vector<double> eta_edges_80 = {0.000, 0.051, 0.374, 0.720, 0.981, 1.279, 1.468, 1.707, 1.945, 2.207, 2.457, 2.500};
	+ const static vector<double> eta_vals_80 = {0.819, 0.855, 0.899, 0.906, 0.900, 0.869, 0.865, 0.873, 0.869, 0.868, 0.859};
	+
	+ const static vector<double> et_edges = { 10, 15, 20, 25, 30, 35, 40, 45, 50, 60, 80 };
	+ const static vector< vector<double> > et_eta_edges = { eta_edges_10, eta_edges_15, eta_edges_20, eta_edges_25, eta_edges_30, eta_edges_35, eta_edges_40, eta_edges_45, eta_edges_50, eta_edges_60, eta_edges_80 };
	+ const static vector< vector<double> > et_eta_vals = { eta_vals_10, eta_vals_15, eta_vals_20, eta_vals_25, eta_vals_30, eta_vals_35, eta_vals_40, eta_vals_45, eta_vals_50, eta_vals_60, eta_vals_80 };
	+
	+ if (e.abseta() > 2.5 \|\| e.Et() < 10*GeV) return 0.0;
	+ const int i_et = binIndex(e.Et()/GeV, et_edges, true);
	+ const int i_eta = binIndex(e.abseta(), et_eta_edges[i_et]);
	+ return et_eta_vals[i_et][i_eta];
	+ }
	+
	+ /// @brief ATLAS Run 2 'tight' electron identification/selection efficiency
	+ /// @todo Currently just a copy of Run 1: fix!
	+ inline double ELECTRON_IDEFF_ATLAS_RUN2_TIGHT(const Particle& e) {
	+ return ELECTRON_IDEFF_ATLAS_RUN1_TIGHT(e);
	+ }
	+
	+
	+
	/// ATLAS Run 1 electron reco smearing
	inline Particle ELECTRON_SMEAR_ATLAS_RUN1(const Particle& e) {
	- /// @todo Need to isolate random generators to a single thread
	- static random_device rd;
	- static mt19937 gen(rd());
	-
	static const vector<double> edges_eta = {0., 2.5, 3.};
	static const vector<double> edges_pt = {0., 0.1, 25.};
	static const vector<double> e2s = {0.000, 0.015, 0.005,
	0.005, 0.005, 0.005,
	0.107, 0.107, 0.107};
	static const vector<double> es = {0.00, 0.00, 0.05,
	0.05, 0.05, 0.05,
	2.08, 2.08, 2.08};
	static const vector<double> cs = {0.00, 0.00, 0.25,
	0.25, 0.25, 0.25,
	0.00, 0.00, 0.00};

	const int i_eta = binIndex(e.abseta(), edges_eta, true);
	const int i_pt = binIndex(e.pT()/GeV, edges_pt, true);
	const int i = i_eta*edges_pt.size() + i_pt;

	// Calculate absolute resolution in GeV
	const double c1 = sqr(e2s[i]), c2 = sqr(es[i]), c3 = sqr(cs[i]);
	const double resolution = sqrt(c1e.E2() + c2e.E() + c3) * GeV;

	- /// @todo Extract to a smear_energy helper function
	- /// @todo Also make smear_direction and smear_pt functions, and jet versions that also update/smear constituents
	- normal_distribution<> d(e.E(), resolution);
	- const double smeared_E = max(d(gen), e.mass()); //< can't let the energy go below the mass!
	- return Particle(e.pid(), FourMomentum::mkEtaPhiME(e.eta(), e.phi(), e.mass(), smeared_E));
	+ // normal_distribution<> d(e.E(), resolution);
	+ // const double mass = e.mass2() > 0 ? e.mass() : 0; //< numerical carefulness...
	+ // const double smeared_E = max(d(gen), mass); //< can't let the energy go below the mass!
	+ // return Particle(e.pid(), FourMomentum::mkEtaPhiME(e.eta(), e.phi(), mass, smeared_E));
	+ return Particle(e.pid(), P4_SMEAR_E_GAUSS(e, resolution));
	}


	/// ATLAS Run 2 electron reco smearing
	/// @todo Currently just a copy of the Run 1 version: fix!
	inline Particle ELECTRON_SMEAR_ATLAS_RUN2(const Particle& e) {
	return ELECTRON_SMEAR_ATLAS_RUN1(e);
	}


	/// @todo Add charge flip efficiency?


	- /// CMS Run 1 electron tracking efficiency
	- /// @todo How to use this in combination with reco eff?
	- inline double ELECTRON_TRKEFF_CMS_RUN1(const Particle& e) {
	- if (e.abseta() > 2.5) return 0;
	- if (e.pT() < 0.1*GeV) return 0;
	- if (e.abseta() < 1.5) {
	- return (e.pT() < 1*GeV) ? 0.70 : 0.95;
	- } else {
	- return (e.pT() < 1*GeV) ? 0.60 : 0.85;
	- }
	- }
	-
	-
	- /// CMS Run 2 electron tracking efficiency
	- /// @todo Currently just a copy of Run 1: fix!
	- inline double ELECTRON_TRKEFF_CMS_RUN2(const Particle& e) {
	- return ELECTRON_TRKEFF_CMS_RUN1(e);
	- }
	-

	/// CMS Run 1 electron reconstruction efficiency
	/// @todo How to use this in combination with tracking eff?
	inline double ELECTRON_EFF_CMS_RUN1(const Particle& e) {
	if (e.abseta() > 2.5) return 0;
	if (e.pT() < 10*GeV) return 0;
	return (e.abseta() < 1.5) ? 0.95 : 0.85;
	}


	/// CMS Run 2 electron reco efficiency
	/// @todo Currently just a copy of Run 1: fix!
	inline double ELECTRON_EFF_CMS_RUN2(const Particle& e) {
	return ELECTRON_EFF_CMS_RUN1(e);
	}


	/// @brief CMS electron energy smearing, preserving direction
	///
	/// Calculate resolution
	/// for pT > 0.1 GeV, E resolution = \|eta\| < 0.5 -> sqrt(0.06^2 + pt^2 * 1.3e-3^2)
	/// \|eta\| < 1.5 -> sqrt(0.10^2 + pt^2 * 1.7e-3^2)
	/// \|eta\| < 2.5 -> sqrt(0.25^2 + pt^2 * 3.1e-3^2)
	inline Particle ELECTRON_SMEAR_CMS_RUN1(const Particle& e) {
	- /// @todo Need to isolate random generators to a single thread
	- static random_device rd;
	- static mt19937 gen(rd());
	-
	// Calculate absolute resolution in GeV from functional form
	double resolution = 0;
	const double abseta = e.abseta();
	if (e.pT() > 0.1*GeV && abseta < 2.5) { //< should be a given from efficiencies
	if (abseta < 0.5) {
	resolution = add_quad(0.06, 1.3e-3 * e.pT()/GeV) * GeV;
	} else if (abseta < 1.5) {
	resolution = add_quad(0.10, 1.7e-3 * e.pT()/GeV) * GeV;
	} else { // still \|eta\| < 2.5
	resolution = add_quad(0.25, 3.1e-3 * e.pT()/GeV) * GeV;
	}
	}

	- /// @todo Extract to a smear_energy helper function
	- normal_distribution<> d(e.E(), resolution);
	- const double smeared_E = max(d(gen), e.mass()); //< can't let the energy go below the mass!
	- return Particle(e.pid(), FourMomentum::mkEtaPhiME(e.eta(), e.phi(), e.mass(), smeared_E));
	+ // normal_distribution<> d(e.E(), resolution);
	+ // const double mass = e.mass2() > 0 ? e.mass() : 0; //< numerical carefulness...
	+ // const double smeared_E = max(d(gen), mass); //< can't let the energy go below the mass!
	+ // return Particle(e.pid(), FourMomentum::mkEtaPhiME(e.eta(), e.phi(), mass, smeared_E));
	+ return Particle(e.pid(), P4_SMEAR_E_GAUSS(e, resolution));
	}


	/// CMS Run 2 electron reco smearing
	/// @todo Currently just a copy of the Run 1 version: fix!
	inline Particle ELECTRON_SMEAR_CMS_RUN2(const Particle& e) {
	return ELECTRON_SMEAR_CMS_RUN1(e);
	}

	//@}



	/// @name Photon efficiency and smearing functions
	//@{

	- /// @todo Photon efficiency and smearing
	+ /// ATLAS Run 1 photon reco efficiency
	+ /// @todo Currently identical to CMS, cf. Delphes
	+ inline double PHOTON_EFF_ATLAS_RUN1(const Particle& y) {
	+ if (y.pT() < 10*GeV \|\| y.abseta() > 2.5) return 0;
	+ return (y.abseta() < 1.5) ? 0.95 : 0.85;
	+ }
	+
	+ /// ATLAS Run 2 photon reco efficiency
	+ /// @todo Currently just a copy of Run 1: fix!
	+ inline double PHOTON_EFF_ATLAS_RUN2(const Particle& y) {
	+ return PHOTON_EFF_ATLAS_RUN1(y);
	+ }
	+
	+ /// CMS Run 1 photon reco efficiency
	+ /// @todo Currently identical to ATLAS, cf. Delphes
	+ inline double PHOTON_EFF_CMS_RUN1(const Particle& y) {
	+ if (y.pT() < 10*GeV \|\| y.abseta() > 2.5) return 0;
	+ return (y.abseta() < 1.5) ? 0.95 : 0.85;
	+ }
	+
	+ /// CMS Run 2 photon reco efficiency
	+ /// @todo Currently just a copy of Run 1: fix!
	+ inline double PHOTON_EFF_CMS_RUN2(const Particle& y) {
	+ return PHOTON_EFF_CMS_RUN1(y);
	+ }

	//@}



	/// @name Muon efficiency and smearing functions
	//@{

	- /// ATLAS Run 1 muon tracking efficiency
	- /// @todo How to use this in combination with reco eff?
	- inline double MUON_TRKEFF_ATLAS_RUN1(const Particle& m) {
	- if (m.abseta() > 2.5) return 0;
	- if (m.pT() < 0.1*GeV) return 0;
	- if (m.abseta() < 1.5) {
	- return (m.pT() < 1*GeV) ? 0.75 : 0.99;
	- } else {
	- return (m.pT() < 1*GeV) ? 0.70 : 0.98;
	- }
	- }
	-
	- /// ATLAS Run 2 muon tracking efficiency
	- /// @todo Currently just a copy of Run 1: fix!
	- inline double MUON_TRKEFF_ATLAS_RUN2(const Particle& m) {
	- return MUON_TRKEFF_ATLAS_RUN1(m);
	- }
	-
	-
	/// ATLAS Run 1 muon reco efficiency
	- /// @todo How to use this in combination with tracking eff?
	inline double MUON_EFF_ATLAS_RUN1(const Particle& m) {
	if (m.abseta() > 2.7) return 0;
	if (m.pT() < 10*GeV) return 0;
	return (m.abseta() < 1.5) ? 0.95 : 0.85;
	}

	/// ATLAS Run 2 muon reco efficiency
	/// @todo Currently just a copy of Run 1: fix!
	inline double MUON_EFF_ATLAS_RUN2(const Particle& m) {
	return MUON_EFF_ATLAS_RUN1(m);
	}


	/// ATLAS Run 1 muon reco smearing
	inline Particle MUON_SMEAR_ATLAS_RUN1(const Particle& m) {
	- /// @todo Need to isolate random generators to a single thread
	- static random_device rd;
	- static mt19937 gen(rd());
	-
	static const vector<double> edges_eta = {0, 1.5, 2.5};
	static const vector<double> edges_pt = {0, 0.1, 1.0, 10., 200.};
	static const vector<double> res = {0., 0.03, 0.02, 0.03, 0.05,
	0., 0.04, 0.03, 0.04, 0.05};

	const int i_eta = binIndex(m.abseta(), edges_eta, true);
	const int i_pt = binIndex(m.pT()/GeV, edges_pt, true);
	const int i = i_eta*edges_pt.size() + i_pt;

	const double resolution = res[i];

	// Smear by a Gaussian centered on the current pT, with width given by the resolution
	- /// @todo Extract to a smear_pt helper function
	- normal_distribution<> d(m.pT(), resolution*m.pT());
	- const double smeared_pt = max(d(gen), 0.);
	- return Particle(m.pid(), FourMomentum::mkEtaPhiMPt(m.eta(), m.phi(), m.mass(), smeared_pt));
	+ // normal_distribution<> d(m.pT(), resolution*m.pT());
	+ // const double smeared_pt = max(d(gen), 0.);
	+ // const double mass = m.mass2() > 0 ? m.mass() : 0; //< numerical carefulness...
	+ // return Particle(m.pid(), FourMomentum::mkEtaPhiMPt(m.eta(), m.phi(), mass, smeared_pt));
	+ return Particle(m.pid(), P4_SMEAR_PT_GAUSS(m, resolution*m.pT()));
	}

	/// ATLAS Run 2 muon reco smearing
	/// @todo Currently just a copy of the Run 1 version: fix!
	inline Particle MUON_SMEAR_ATLAS_RUN2(const Particle& m) {
	return MUON_SMEAR_ATLAS_RUN1(m);
	}


	- /// CMS Run 1 muon tracking efficiency
	- /// @todo How to use this in combination with reco eff?
	- /// @note Eff values currently identical to those in ATLAS (AB, 2016-04-12)
	- inline double MUON_TRKEFF_CMS_RUN1(const Particle& m) {
	- if (m.abseta() > 2.5) return 0;
	- if (m.pT() < 0.1*GeV) return 0;
	- if (m.abseta() < 1.5) {
	- return (m.pT() < 1*GeV) ? 0.75 : 0.99;
	- } else {
	- return (m.pT() < 1*GeV) ? 0.70 : 0.98;
	- }
	- }
	-
	- /// CMS Run 2 muon tracking efficiency
	- /// @todo Currently just a copy of Run 1: fix!
	- inline double MUON_TRKEFF_CMS_RUN2(const Particle& m) {
	- return MUON_TRKEFF_CMS_RUN1(m);
	- }


	/// CMS Run 1 muon reco efficiency
	- /// @todo How to use this in combination with tracking eff?
	inline double MUON_EFF_CMS_RUN1(const Particle& m) {
	if (m.abseta() > 2.4) return 0;
	if (m.pT() < 10*GeV) return 0;
	return 0.95 * (m.abseta() < 1.5 ? 1 : exp(0.5 - 5e-4*m.pT()/GeV));
	}

	/// CMS Run 2 muon reco efficiency
	/// @todo Currently just a copy of Run 1: fix!
	inline double MUON_EFF_CMS_RUN2(const Particle& m) {
	return MUON_EFF_CMS_RUN1(m);
	}


	/// CMS Run 1 muon reco smearing
	inline Particle MUON_SMEAR_CMS_RUN1(const Particle& m) {
	- /// @todo Need to isolate random generators to a single thread
	- static random_device rd;
	- static mt19937 gen(rd());
	-
	// Calculate fractional resolution
	// for pT > 0.1 GeV, mom resolution = \|eta\| < 0.5 -> sqrt(0.01^2 + pt^2 * 2.0e-4^2)
	// \|eta\| < 1.5 -> sqrt(0.02^2 + pt^2 * 3.0e-4^2)
	// \|eta\| < 2.5 -> sqrt(0.05^2 + pt^2 * 2.6e-4^2)
	double resolution = 0;
	const double abseta = m.abseta();
	if (m.pT() > 0.1*GeV && abseta < 2.5) {
	if (abseta < 0.5) {
	resolution = add_quad(0.01, 2.0e-4 * m.pT()/GeV);
	} else if (abseta < 1.5) {
	resolution = add_quad(0.02, 3.0e-4 * m.pT()/GeV);
	} else { // still \|eta\| < 2.5... but isn't CMS' mu acceptance < 2.4?
	resolution = add_quad(0.05, 2.6e-4 * m.pT()/GeV);
	}
	}

	// Smear by a Gaussian centered on the current pT, with width given by the resolution
	- /// @todo Extract to a smear_pt helper function
	- normal_distribution<> d(m.pT(), resolution*m.pT());
	- const double smeared_pt = max(d(gen), 0.);
	- return Particle(m.pid(), FourMomentum::mkEtaPhiMPt(m.eta(), m.phi(), m.mass(), smeared_pt));
	+ // normal_distribution<> d(m.pT(), resolution*m.pT());
	+ // const double smeared_pt = max(d(gen), 0.);
	+ // const double mass = m.mass2() > 0 ? m.mass() : 0; //< numerical carefulness...
	+ // return Particle(m.pid(), FourMomentum::mkEtaPhiMPt(m.eta(), m.phi(), mass, smeared_pt));
	+ return Particle(m.pid(), P4_SMEAR_PT_GAUSS(m, resolution*m.pT()));
	}

	/// CMS Run 2 muon reco smearing
	/// @todo Currently just a copy of the Run 1 version: fix!
	inline Particle MUON_SMEAR_CMS_RUN2(const Particle& m) {
	return MUON_SMEAR_CMS_RUN1(m);
	}

	//@}



	/// @name Tau efficiency and smearing functions
	//@{

	/// @brief ATLAS Run 1 8 TeV tau efficiencies (medium working point)
	///
	/// Taken from http://arxiv.org/pdf/1412.7086.pdf
	/// 20-40 GeV 1-prong LMT eff\|mis = 0.66\|1/10, 0.56\|1/20, 0.36\|1/80
	/// 20-40 GeV 3-prong LMT eff\|mis = 0.45\|1/60, 0.38\|1/100, 0.27\|1/300
	/// > 40 GeV 1-prong LMT eff\|mis = 0.66\|1/15, 0.56\|1/25, 0.36\|1/80
	/// > 40 GeV 3-prong LMT eff\|mis = 0.45\|1/250, 0.38\|1/400, 0.27\|1/1300
	inline double TAU_EFF_ATLAS_RUN1(const Particle& t) {
	if (t.abseta() > 2.5) return 0; //< hmm... mostly
	double pThadvis = 0;
	Particles chargedhadrons;
	for (const Particle& p : t.children()) {
	if (p.isHadron()) {
	pThadvis += p.pT(); //< right definition? Paper is unclear
	if (p.charge3() != 0 && p.abseta() < 2.5 && p.pT() > 1*GeV) chargedhadrons += p;
	}
	}
	if (chargedhadrons.empty()) return 0; //< leptonic tau
	if (pThadvis < 20*GeV) return 0; //< below threshold
	if (pThadvis < 40*GeV) {
	if (chargedhadrons.size() == 1) return (t.abspid() == PID::TAU) ? 0.56 : 1/20.;
	if (chargedhadrons.size() == 3) return (t.abspid() == PID::TAU) ? 0.38 : 1/100.;
	} else {
	if (chargedhadrons.size() == 1) return (t.abspid() == PID::TAU) ? 0.56 : 1/25.;
	if (chargedhadrons.size() == 3) return (t.abspid() == PID::TAU) ? 0.38 : 1/400.;
	}
	return 0;
	}


	/// @brief ATLAS Run 2 13 TeV tau efficiencies (medium working point)
	///
	/// From https://atlas.web.cern.ch/Atlas/GROUPS/PHYSICS/PUBNOTES/ATL-PHYS-PUB-2015-045/ATL-PHYS-PUB-2015-045.pdf
	/// LMT 1 prong efficiency/mistag = 0.6\|1/30, 0.55\|1/50, 0.45\|1/120
	/// LMT 3 prong efficiency/mistag = 0.5\|1/30, 0.4\|1/110, 0.3\|1/300
	inline double TAU_EFF_ATLAS_RUN2(const Particle& t) {
	if (t.abseta() > 2.5) return 0; //< hmm... mostly
	double pThadvis = 0;
	Particles chargedhadrons;
	for (const Particle& p : t.children()) {
	if (p.isHadron()) {
	pThadvis += p.pT(); //< right definition? Paper is unclear
	if (p.charge3() != 0 && p.abseta() < 2.5 && p.pT() > 1*GeV) chargedhadrons += p;
	}
	}
	if (chargedhadrons.empty()) return 0; //< leptonic tau
	if (pThadvis < 20*GeV) return 0; //< below threshold
	if (chargedhadrons.size() == 1) return (t.abspid() == PID::TAU) ? 0.55 : 1/50.;
	if (chargedhadrons.size() == 3) return (t.abspid() == PID::TAU) ? 0.40 : 1/110.;
	return 0;
	}


	/// ATLAS Run 1 tau smearing
	/// @todo Currently a copy of the crappy jet smearing that is probably wrong...
	inline Particle TAU_SMEAR_ATLAS_RUN1(const Particle& t) {
	- /// @todo Need to isolate random generators to a single thread
	- static random_device rd;
	- static mt19937 gen(rd());
	-
	// Const fractional resolution for now
	static const double resolution = 0.03;

	// Smear by a Gaussian centered on 1 with width given by the (fractional) resolution
	/// @todo Is this the best way to smear? Should we preserve the energy, or pT, or direction?
	+ /// @todo Need to isolate random generators to a single thread
	+ static random_device rd;
	+ static mt19937 gen(rd());
	normal_distribution<> d(1., resolution);
	const double fsmear = max(d(gen), 0.);
	- return Particle(t.pid(), FourMomentum::mkXYZM(t.px()fsmear, t.py()fsmear, t.pz()*fsmear, t.mass()));
	+ const double mass = t.mass2() > 0 ? t.mass() : 0; //< numerical carefulness...
	+ return Particle(t.pid(), FourMomentum::mkXYZM(t.px()fsmear, t.py()fsmear, t.pz()*fsmear, mass));
	}


	/// ATLAS Run 2 tau smearing
	/// @todo Currently a copy of the Run 1 version
	inline Particle TAU_SMEAR_ATLAS_RUN2(const Particle& t) {
	return TAU_SMEAR_ATLAS_RUN1(t);
	}


	/// CMS Run 2 tau efficiency
	///
	/// @todo Needs work; this is the dumb version from Delphes 3.3.2
	inline double TAU_EFF_CMS_RUN2(const Particle& t) {
	return (t.abspid() == PID::TAU) ? 0.6 : 0;
	}

	/// CMS Run 1 tau efficiency
	///
	/// @todo Needs work; this is just a copy of the Run 2 version in Delphes 3.3.2
	inline double TAU_EFF_CMS_RUN1(const Particle& t) {
	return TAU_EFF_CMS_RUN2(t);
	}


	/// CMS Run 1 tau smearing
	/// @todo Currently a copy of the crappy ATLAS one
	inline Particle TAU_SMEAR_CMS_RUN1(const Particle& t) {
	return TAU_SMEAR_ATLAS_RUN1(t);
	}


	/// CMS Run 2 tau smearing
	/// @todo Currently a copy of the Run 1 version
	inline Particle TAU_SMEAR_CMS_RUN2(const Particle& t) {
	return TAU_SMEAR_CMS_RUN1(t);
	}

	//@}


	/// @name Jet efficiency and smearing functions
	//@{

	/// Return a constant 0 given a Jet as argument
	inline double JET_EFF_ZERO(const Jet& p) { return 0; }
	/// Return a constant 1 given a Jet as argument
	inline double JET_EFF_ONE(const Jet& p) { return 1; }

	/// Return 1 if the given Jet contains a b, otherwise 0
	inline double JET_BTAG_PERFECT(const Jet& j) { return j.bTagged() ? 1 : 0; }
	/// Return the ATLAS Run 1 jet flavour tagging efficiency for the given Jet
	inline double JET_BTAG_ATLAS_RUN1(const Jet& j) {
	- if (j.bTagged()) return 0.80tanh(0.003j.pT()/GeV)(30/(1+0.086j.pT()/GeV));
	- if (j.cTagged()) return 0.20tanh(0.02j.pT()/GeV)(1/(1+0.0034j.pT()/GeV));
	+ /// @todo This form drops past ~100 GeV, asymptotically to zero efficiency... really?!
	+ if (j.abseta() > 2.5) return 0;
	+ const auto ftagsel = [&](const Particle& p){ return p.pT() > 5*GeV && deltaR(p,j) < 0.3; };
	+ if (j.bTagged(ftagsel)) return 0.80tanh(0.003j.pT()/GeV)(30/(1+0.0860j.pT()/GeV));
	+ if (j.cTagged(ftagsel)) return 0.20tanh(0.020j.pT()/GeV)( 1/(1+0.0034j.pT()/GeV));
	return 0.002 + 7.3e-6*j.pT()/GeV;
	}
	+ /// Return the ATLAS Run 2 MC2c20 jet flavour tagging efficiency for the given Jet
	+ inline double JET_BTAG_ATLAS_RUN2_MV2C20(const Jet& j) {
	+ if (j.abseta() > 2.5) return 0;
	+ if (j.bTagged(Cuts::pT > 5*GeV)) return 0.77;
	+ if (j.cTagged(Cuts::pT > 5*GeV)) return 1/4.5;
	+ return 1/140.;
	+ }
	+ /// Return the ATLAS Run 2 MC2c10 jet flavour tagging efficiency for the given Jet
	+ inline double JET_BTAG_ATLAS_RUN2_MV2C10(const Jet& j) {
	+ if (j.abseta() > 2.5) return 0;
	+ if (j.bTagged(Cuts::pT > 5*GeV)) return 0.77;
	+ if (j.cTagged(Cuts::pT > 5*GeV)) return 1/6.0;
	+ return 1/134.;
	+ }

	/// Return 1 if the given Jet contains a c, otherwise 0
	inline double JET_CTAG_PERFECT(const Jet& j) { return j.cTagged() ? 1 : 0; }

	/// Take a jet and return an unmodified copy
	/// @todo Modify constituent particle vectors for consistency
	/// @todo Set a null PseudoJet if the Jet is smeared?
	inline Jet JET_SMEAR_IDENTITY(const Jet& j) { return j; }

	/// ATLAS Run 1 jet smearing
	/// @todo This is a cluster-level flat 3% resolution, I think, and smearing is suboptimal: improve!
	inline Jet JET_SMEAR_ATLAS_RUN1(const Jet& j) {
	- /// @todo Need to isolate random generators to a single thread
	- static random_device rd;
	- static mt19937 gen(rd());
	-
	// Const fractional resolution for now
	static const double resolution = 0.03;

	// Smear by a Gaussian centered on 1 with width given by the (fractional) resolution
	/// @todo Is this the best way to smear? Should we preserve the energy, or pT, or direction?
	+ /// @todo Need to isolate random generators to a single thread
	+ static random_device rd;
	+ static mt19937 gen(rd());
	normal_distribution<> d(1., resolution);
	const double fsmear = max(d(gen), 0.);
	- return Jet(FourMomentum::mkXYZM(j.px()fsmear, j.py()fsmear, j.pz()*fsmear, j.mass()));
	+ const double mass = j.mass2() > 0 ? j.mass() : 0; //< numerical carefulness...
	+ return Jet(FourMomentum::mkXYZM(j.px()fsmear, j.py()fsmear, j.pz()*fsmear, mass));
	}

	- /// CMS Run 1 jet smearing
	+ /// ATLAS Run 2 jet smearing
	+ /// @todo Just a copy of the Run 1 one: improve!!
	+ inline Jet JET_SMEAR_ATLAS_RUN2(const Jet& j) {
	+ return JET_SMEAR_ATLAS_RUN1(j);
	+ }
	+
	+ /// CMS Run 2 jet smearing
	/// @todo Just a copy of the suboptimal ATLAS one: improve!!
	- inline Jet JET_SMEAR_CMS_RUN1(const Jet& j) {
	+ inline Jet JET_SMEAR_CMS_RUN2(const Jet& j) {
	return JET_SMEAR_ATLAS_RUN1(j);
	}

	//@}


	+ /// @name ETmiss smearing functions
	+ //@{
	+
	+ inline Vector3 MET_SMEAR_IDENTITY(const Vector3& met, double) { return met; }
	+
	+ /// @brief ATLAS Run 1 ETmiss smearing
	+ ///
	+ /// Based on https://arxiv.org/pdf/1108.5602v2.pdf, Figs 14 and 15
	+ inline Vector3 MET_SMEAR_ATLAS_RUN1(const Vector3& met, double set) {
	+ // Linearity offset (Fig 14)
	+ Vector3 smeared_met = met;
	+ if (met.mod()/GeV < 25GeV) smeared_met = 1.05;
	+ else if (met.mod()/GeV < 40GeV) smeared_met = (1.05 - (0.04/15)*(met.mod()/GeV - 25)); //< linear decrease
	+ else smeared_met *= 1.01;
	+
	+ // Smear by a Gaussian with width given by the resolution(sumEt) ~ 0.45 sqrt(sumEt) GeV
	+ const double resolution = 0.45 * sqrt(set/GeV) * GeV;
	+ static random_device rd;
	+ static mt19937 gen(rd());
	+ normal_distribution<> d(smeared_met.mod(), resolution);
	+ const double metsmear = max(d(gen), 0.);
	+ smeared_met = metsmear * smeared_met.unit();
	+
	+ return smeared_met;
	+ }
	+
	+ /// ATLAS Run 2 ETmiss smearing
	+ /// @todo Just a copy of the Run 1 one: improve!!
	+ inline Vector3 MET_SMEAR_ATLAS_RUN2(const Vector3& met, double set) {
	+ return MET_SMEAR_ATLAS_RUN1(met, set);
	+ }
	+
	+ /// CMS Run 1 ETmiss smearing
	+ /// @todo Just a copy of the ATLAS one: improve!!
	+ inline Vector3 MET_SMEAR_CMS_RUN1(const Vector3& met, double set) {
	+ return MET_SMEAR_ATLAS_RUN1(met, set);
	+ }
	+
	+ /// CMS Run 2 ETmiss smearing
	+ /// @todo Just a copy of the ATLAS one: improve!!
	+ inline Vector3 MET_SMEAR_CMS_RUN2(const Vector3& met, double set) {
	+ return MET_SMEAR_ATLAS_RUN2(met, set);
	+ }
	+
	+ //@}
	+
	+
	+ /// @name Tracking efficiency and smearing functions
	+ //@{
	+
	+ /// ATLAS Run 1 tracking efficiency
	+ inline double TRK_EFF_ATLAS_RUN1(const Particle& p) {
	+ if (p.charge3() == 0) return 0;
	+ if (p.abseta() > 2.5) return 0;
	+ if (p.pT() < 0.1*GeV) return 0;
	+
	+ if (p.abspid() == PID::ELECTRON) {
	+ if (p.abseta() < 1.5) {
	+ if (p.pT() < 1*GeV) return 0.73;
	+ if (p.pT() < 100*GeV) return 0.95;
	+ return 0.99;
	+ } else {
	+ if (p.pT() < 1*GeV) return 0.50;
	+ if (p.pT() < 100*GeV) return 0.83;
	+ else return 0.90;
	+ }
	+ } else if (p.abspid() == PID::MUON) {
	+ if (p.abseta() < 1.5) {
	+ return (p.pT() < 1*GeV) ? 0.75 : 0.99;
	+ } else {
	+ return (p.pT() < 1*GeV) ? 0.70 : 0.98;
	+ }
	+ } else { // charged hadrons
	+ if (p.abseta() < 1.5) {
	+ return (p.pT() < 1*GeV) ? 0.70 : 0.95;
	+ } else {
	+ return (p.pT() < 1*GeV) ? 0.60 : 0.85;
	+ }
	+ }
	+ }
	+
	+ /// ATLAS Run 2 tracking efficiency
	+ /// @todo Currently just a copy of Run 1: fix!
	+ inline double TRK_EFF_ATLAS_RUN2(const Particle& p) {
	+ return TRK_EFF_ATLAS_RUN1(p);
	+ }
	+
	+
	+ /// CMS Run 1 tracking efficiency
	+ inline double TRK_EFF_CMS_RUN1(const Particle& p) {
	+ if (p.charge3() == 0) return 0;
	+ if (p.abseta() > 2.5) return 0;
	+ if (p.pT() < 0.1*GeV) return 0;
	+
	+ if (p.abspid() == PID::ELECTRON) {
	+ if (p.abseta() < 1.5) {
	+ if (p.pT() < 1*GeV) return 0.73;
	+ if (p.pT() < 100*GeV) return 0.95;
	+ return 0.99;
	+ } else {
	+ if (p.pT() < 1*GeV) return 0.50;
	+ if (p.pT() < 100*GeV) return 0.83;
	+ else return 0.90;
	+ }
	+ } else if (p.abspid() == PID::MUON) {
	+ if (p.abseta() < 1.5) {
	+ return (p.pT() < 1*GeV) ? 0.75 : 0.99;
	+ } else {
	+ return (p.pT() < 1*GeV) ? 0.70 : 0.98;
	+ }
	+ } else { // charged hadrons
	+ if (p.abseta() < 1.5) {
	+ return (p.pT() < 1*GeV) ? 0.70 : 0.95;
	+ } else {
	+ return (p.pT() < 1*GeV) ? 0.60 : 0.85;
	+ }
	+ }
	+ }
	+
	+ /// CMS Run 2 tracking efficiency
	+ /// @todo Currently just a copy of Run 1: fix!
	+ inline double TRK_EFF_CMS_RUN2(const Particle& p) {
	+ return TRK_EFF_CMS_RUN1(p);
	+ }
	+
	+ //@}
	+
	+
	}

	#endif
	diff --git a/include/Rivet/Tools/TypeTraits.hh b/include/Rivet/Tools/TypeTraits.hh
	--- a/include/Rivet/Tools/TypeTraits.hh
	+++ b/include/Rivet/Tools/TypeTraits.hh
	@@ -1,37 +1,66 @@
	// -- C++ --
	#ifndef RIVET_TypeTraits_HH
	#define RIVET_TypeTraits_HH

	+#include <type_traits>
	+
	namespace Rivet {

	/// Mechanisms to allow references and pointers to templated types
	/// to be distinguished from one another (since C++ doesn't allow
	/// partial template specialisation for functions.
	/// Traits methods use specialisation of class/struct templates, and
	/// some trickery with typedefs and static const integral types (or
	/// enums) to implement partial function specialisation as a work-around.

	/// @cond INTERNAL

	+ namespace SFINAE {
	+ /// C++11 equivalent of C++17 std::void_t
	+ template <typename ...>
	+ using void_t = void;
	+ }
	+
	+
	struct RefType { };

	struct PtrType { };

	template <typename T>
	struct TypeTraits;

	template <typename U>
	struct TypeTraits<const U&> {
	typedef RefType ArgType;
	};

	template <typename U>
	struct TypeTraits<const U*> {
	typedef PtrType ArgType;
	};

	+
	+
	+ /// SFINAE definition of dereferenceability trait, cf. Boost has_dereference
	+ template <typename T, typename=void>
	+ struct Derefable : std::false_type {};
	+ //
	+ template <typename T>
	+ struct Derefable<T, SFINAE::void_t< decltype(*std::declval<T>())> > : std::true_type {};
	+
	+
	+ /// SFINAE check for non-const iterability trait
	+ // template <typename T, typename=void>
	+ // struct Iterable : std::false_type {};
	+ // //
	+ // template <typename T>
	+ // struct Iterable<T, SFINAE::void_t< decltype(*std::declval<T>())> > : std::true_type {};
	+ template <T>
	+ using ConstIterable = pretty_print::is_container<T>
	+
	+
	/// @endcond

	}

	#endif
	diff --git a/include/Rivet/Tools/Utils.hh b/include/Rivet/Tools/Utils.hh
	--- a/include/Rivet/Tools/Utils.hh
	+++ b/include/Rivet/Tools/Utils.hh
	@@ -1,217 +1,467 @@
	// -- C++ --
	#ifndef RIVET_Utils_HH
	#define RIVET_Utils_HH

	-#include <Rivet/Math/Math.hh>
	-#include <Rivet/Tools/RivetSTL.hh>
	-#include <sstream>
	+#include "Rivet/Tools/RivetSTL.hh"
	+#include "Rivet/Tools/PrettyPrint.hh"
	+#include <ostream>
	+#include <iostream>
	#include <cctype>
	-#include <algorithm>
	#include <cerrno>
	+#include <stdexcept>
	+#include <numeric>
	+#include <limits>
	+#include <climits>
	+#include <cfloat>
	+#include <cmath>
	+
	+
	+// Macro to help with overzealous compiler warnings
	+/// @note It's easier and better to just not give an arg name to args which won't be used, when possible.
	+#ifdef UNUSED
	+#elif defined(__GNUC__)
	+# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
	+#elif defined(__LCLINT__)
	+# define UNUSED(x) /@unused@/ x
	+#else
	+# define UNUSED(x) x
	+#endif
	+
	+
	+/// Macro to help mark code as deprecated to produce compiler warnings
	+#ifndef DEPRECATED
	+#if __GNUC__ && __cplusplus && RIVET_NO_DEPRECATION_WARNINGS == 0
	+#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
	+#if GCC_VERSION >= 40500
	+ #if __cplusplus > 201103L
	+ #define DEPRECATED(x) [[deprecated(x)]]
	+ #else
	+ #define DEPRECATED(x) __attribute__((deprecated(x)))
	+ #endif
	+#else
	+ #define DEPRECATED(x) __attribute__((deprecated))
	+#endif
	+#else
	+ #define DEPRECATED(x)
	+#endif
	+#endif
	+

	namespace Rivet {


	+ /// Convenient const for getting the double NaN value
	+ static constexpr double DBL_NAN = std::numeric_limits<double>::quiet_NaN();
	+
	+
	/// @name String utils
	//@{

	struct bad_lexical_cast : public std::runtime_error {
	bad_lexical_cast(const std::string& what) : std::runtime_error(what) {}
	};

	/// @brief Convert between any types via stringstream
	template<typename T, typename U>
	T lexical_cast(const U& in) {
	try {
	std::stringstream ss;
	ss << in;
	T out;
	ss >> out;
	return out;
	} catch (const std::exception& e) {
	throw bad_lexical_cast(e.what());
	}
	}

	/// @brief Convert any object to a string
	///
	/// Just a convenience wrapper for the more general Boost lexical_cast
	template <typename T>
	inline string to_str(const T& x) {
	return lexical_cast<string>(x);
	}

	/// @brief Convert any object to a string
	///
	/// An alias for to_str() with a more "Rivety" mixedCase name.
	template <typename T>
	inline string toString(const T& x) {
	return to_str(x);
	}

	/// Replace the first instance of patt with repl
	inline string& replace_first(string& str, const string& patt, const string& repl) {
	if (!contains(str, patt)) return str; //< contains from RivetSTL
	str.replace(str.find(patt), patt.size(), repl);
	return str;
	}

	/// @brief Replace all instances of patt with repl
	///
	/// @note Finding is interleaved with replacement, so the second search happens after
	/// first replacement, etc. This could lead to infinite loops and other counterintuitive
	/// behaviours if not careful.
	inline string& replace_all(string& str, const string& patt, const string& repl) {
	if (!contains(str, patt)) return str; //< contains from RivetSTL
	while (true) {
	string::size_type it = str.find(patt);
	if (it == string::npos) break;
	str.replace(it, patt.size(), repl);
	}
	return str;
	}


	/// Case-insensitive string comparison function
	inline int nocase_cmp(const string& s1, const string& s2) {
	string::const_iterator it1 = s1.begin();
	string::const_iterator it2 = s2.begin();
	while ( (it1 != s1.end()) && (it2 != s2.end()) ) {
	if(::toupper(it1) != ::toupper(it2)) { // < Letters differ?
	// Return -1 to indicate smaller than, 1 otherwise
	return (::toupper(it1) < ::toupper(it2)) ? -1 : 1;
	}
	// Proceed to the next character in each string
	++it1;
	++it2;
	}
	size_t size1 = s1.size(), size2 = s2.size(); // Cache lengths
	// Return -1,0 or 1 according to strings' lengths
	if (size1 == size2) return 0;
	return (size1 < size2) ? -1 : 1;
	}


	/// Case-insensitive string equality function
	inline bool nocase_equals(const string& s1, const string& s2) {
	return nocase_cmp(s1, s2) == 0;
	}


	/// Convert a string to lower-case
	inline string toLower(const string& s) {
	string out = s;
	- std::transform(out.begin(), out.end(), out.begin(), (int(*)(int)) tolower);
	+ std::transform(out.begin(), out.end(), out.begin(), (int(*)(int)) std::tolower);
	return out;
	}


	/// Convert a string to upper-case
	inline string toUpper(const string& s) {
	string out = s;
	- std::transform(out.begin(), out.end(), out.begin(), (int(*)(int)) toupper);
	+ std::transform(out.begin(), out.end(), out.begin(), (int(*)(int)) std::toupper);
	return out;
	}


	/// Check whether a string @a start is found at the start of @a s
	inline bool startsWith(const string& s, const string& start) {
	if (s.length() < start.length()) return false;
	return s.substr(0, start.length()) == start;
	}


	/// Check whether a string @a end is found at the end of @a s
	inline bool endsWith(const string& s, const string& end) {
	if (s.length() < end.length()) return false;
	return s.substr(s.length() - end.length()) == end;
	}


	/// Make a string containing the string representations of each item in v, separated by sep
	template <typename T>
	inline string join(const vector<T>& v, const string& sep=" ") {
	string rtn;
	for (size_t i = 0; i < v.size(); ++i) {
	if (i != 0) rtn += sep;
	rtn += to_str(v[i]);
	}
	return rtn;
	}

	/// Make a string containing the string representations of each item in s, separated by sep
	template <typename T>
	inline string join(const set<T>& s, const string& sep=" ") {
	string rtn;
	- foreach (const T& x, s) {
	+ for (const T& x : s) {
	if (rtn.size() > 0) rtn += sep;
	rtn += to_str(x);
	}
	return rtn;
	}

	//@}


	/// @name Path utils
	//@{

	/// @brief Split a path string with colon delimiters
	///
	/// Ignores zero-length substrings. Designed for getting elements of filesystem paths, naturally.
	inline vector<string> pathsplit(const string& path) {
	const string delim = ":";
	vector<string> dirs;
	string tmppath = path;
	while (true) {
	const size_t delim_pos = tmppath.find(delim);
	if (delim_pos == string::npos) break;
	const string dir = tmppath.substr(0, delim_pos);
	if (dir.length()) dirs.push_back(dir); // Don't insert "empties"
	tmppath.replace(0, delim_pos+1, "");
	}
	if (tmppath.length()) dirs.push_back(tmppath); // Don't forget the trailing component!
	return dirs;
	}


	/// @brief Join several filesystem paths together with the standard ':' delimiter
	///
	/// Note that this does NOT join path elements together with a platform-portable
	/// directory delimiter, cf. the Python @c {os.path.join}!
	inline string pathjoin(const vector<string>& paths) {
	return join(paths, ":");
	}

	//@}


	/// @name Container utils
	//@{

	+ /// Return number of elements in the container @a c for which @c f(x) is true.
	+ template <typename CONTAINER>
	+ inline unsigned int count(const CONTAINER& c) {
	+ // return std::count_if(std::begin(c), std::end(c), [](const typename CONTAINER::value_type& x){return bool(x);});
	+ unsigned int rtn = 0;
	+ for (const auto& x : c) if (bool(x)) rtn += 1;
	+ return rtn;
	+ }
	+
	+ /// Return number of elements in the container @a c for which @c f(x) is true.
	+ template <typename CONTAINER, typename FN>
	+ inline unsigned int count(const CONTAINER& c, const FN& f) {
	+ return std::count_if(std::begin(c), std::end(c), f);
	+ }
	+
	+ /// Return true if x is true for any x in container c, otherwise false.
	+ template <typename CONTAINER>
	+ inline bool any(const CONTAINER& c) {
	+ // return std::any_of(std::begin(c), std::end(c), [](const auto& x){return bool(x);});
	+ for (const auto& x : c) if (bool(x)) return true;
	+ return false;
	+ }
	+
	/// Return true if f(x) is true for any x in container c, otherwise false.
	template <typename CONTAINER, typename FN>
	inline bool any(const CONTAINER& c, const FN& f) {
	- //for (const typename CONTAINER::value_type& val : c) {
	- foreach (const typename CONTAINER::value_type& val, c) {
	- if (f(val)) return true;
	- }
	- return false;
	+ return std::any_of(std::begin(c), std::end(c), f);
	}

	- /// Return true if f(x) is true for all x in container c, otherwise false.
	+ /// Return true if @a x is true for all @c x in container @a c, otherwise false.
	+ template <typename CONTAINER>
	+ inline bool all(const CONTAINER& c) {
	+ // return std::all_of(std::begin(c), std::end(c), [](const auto& x){return bool(x);});
	+ for (const auto& x : c) if (!bool(x)) return false;
	+ return true;
	+ }
	+
	+ /// Return true if @a f(x) is true for all @c x in container @a c, otherwise false.
	template <typename CONTAINER, typename FN>
	inline bool all(const CONTAINER& c, const FN& f) {
	- //for (const typename CONTAINER::value_type& val : c) {
	- foreach (const typename CONTAINER::value_type& val, c) {
	- if (!f(val)) return false;
	- }
	+ return std::all_of(std::begin(c), std::end(c), f);
	+ }
	+
	+ /// Return true if @a x is false for all @c x in container @a c, otherwise false.
	+ template <typename CONTAINER>
	+ inline bool none(const CONTAINER& c) {
	+ // return std::none_of(std::begin(c), std::end(c), [](){});
	+ for (const auto& x : c) if (bool(x)) return false;
	return true;
	}

	+ /// Return true if @a f(x) is false for all @c x in container @a c, otherwise false.
	+ template <typename CONTAINER, typename FN>
	+ inline bool none(const CONTAINER& c, const FN& f) {
	+ return std::none_of(std::begin(c), std::end(c), f);
	+ }
	+
	+
	+ /// A single-container-arg version of std::transform, aka @c map
	+ template <typename C1, typename C2, typename FN>
	+ inline const C2& transform(const C1& in, C2& out, const FN& f) {
	+ out.clear(); out.resize(in.size());
	+ std::transform(in.begin(), in.end(), out.begin(), f);
	+ return out;
	+ }
	+
	+ /// A single-container-arg version of std::accumulate, aka @c reduce
	+ template <typename C1, typename T, typename FN>
	+ inline T accumulate(const C1& in, const T& init, const FN& f) {
	+ const T rtn = std::accumulate(in.begin(), in.end(), init, f);
	+ return rtn;
	+ }
	+
	+ /// Generic sum function, adding @c x for all @c x in container @a c, starting with @a start
	+ template <typename CONTAINER, typename T>
	+ inline T sum(const CONTAINER& c, const T& start=T()) {
	+ T rtn = start;
	+ for (const auto& x : c) rtn += x;
	+ return rtn;
	+ }
	+
	+ /// Generic sum function, adding @a fn(@c x) for all @c x in container @a c, starting with @a start
	+ template <typename CONTAINER, typename FN, typename T>
	+ inline T sum(const CONTAINER& c, const FN& f, const T& start=T()) {
	+ T rtn = start;
	+ for (const auto& x : c) rtn += f(x);
	+ return rtn;
	+ }
	+
	+
	+ /// Filter a collection in-place, removing the subset that passes the supplied function
	+ template <typename CONTAINER, typename FN>
	+ inline CONTAINER& ifilter_discard(CONTAINER& c, const FN& f) {
	+ const auto newend = std::remove_if(std::begin(c), std::end(c), f);
	+ c.erase(newend, c.end());
	+ return c;
	+ }
	+
	+ /// Filter a collection by copy, removing the subset that passes the supplied function
	+ template <typename CONTAINER, typename FN>
	+ inline CONTAINER filter_discard(const CONTAINER& c, const FN& f) {
	+ CONTAINER rtn = c;
	+ return ifilter_discard(rtn, f); ///< @todo More efficient would be copy_if with back_inserter...
	+ }
	+
	+ /// Filter a collection by copy into a supplied container, removing the subset that passes the supplied function
	+ /// @note New container will be replaced, not appended to
	+ template <typename CONTAINER, typename FN>
	+ inline CONTAINER& filter_discard(const CONTAINER& c, const FN& f, CONTAINER& out) {
	+ out = filter_discard(c, f);
	+ return out;
	+ }
	+
	+
	+ /// Filter a collection in-place, keeping the subset that passes the supplied function
	+ template <typename CONTAINER, typename FN>
	+ inline CONTAINER& ifilter_select(CONTAINER& c, const FN& f) {
	+ //using value_type = typename std::remove_reference<decltype(*std::begin(std::declval<typename std::add_lvalue_reference<CONTAINER>::type>()))>::type;
	+ auto invf = [&](const typename CONTAINER::value_type& x){ return !f(x); };
	+ return ifilter_discard(c, invf);
	+ }
	+
	+ /// Filter a collection by copy, keeping the subset that passes the supplied function
	+ template <typename CONTAINER, typename FN>
	+ inline CONTAINER filter_select(const CONTAINER& c, const FN& f) {
	+ CONTAINER rtn = c;
	+ return ifilter_select(rtn, f); ///< @todo More efficient would be copy_if with back_inserter ... but is that equally container agnostic?
	+ }
	+
	+ /// Filter a collection by copy into a supplied container, keeping the subset that passes the supplied function
	+ /// @note New container will be replaced, not appended to
	+ template <typename CONTAINER, typename FN>
	+ inline CONTAINER& filter_select(const CONTAINER& c, const FN& f, CONTAINER& out) {
	+ out = filter_select(c, f);
	+ return out;
	+ }
	+
	+
	+ /// @brief Slice of the container elements cf. Python's [i:j] syntax
	+ ///
	+ /// The element at the @j index is not included in the returned container.
	+ /// @a i and @a j can be negative, treated as backward offsets from the end of the container.
	+ template <typename CONTAINER>
	+ inline CONTAINER slice(const CONTAINER& c, int i, int j) {
	+ CONTAINER rtn;
	+ const size_t off1 = (i >= 0) ? i : c.size() + i;
	+ const size_t off2 = (j >= 0) ? j : c.size() + j;
	+ if (off1 > c.size() \|\| off2 > c.size()) throw RangeError("Attempting to slice beyond requested offsets");
	+ if (off2 < off1) throw RangeError("Requested offsets in invalid order");
	+ rtn.resize(off2 - off1);
	+ std::copy(c.begin()+off1, c.begin()+off2, rtn.begin());
	+ return rtn;
	+ }
	+
	+ /// @brief Tail slice of the container elements cf. Python's [i:] syntax
	+ ///
	+ /// Single-index specialisation of @c slice(c, i, j)
	+ template <typename CONTAINER>
	+ inline CONTAINER slice(const CONTAINER& c, int i) {
	+ return slice(c, i, c.size());
	+ }
	+
	+ /// @brief Head slice of the @a n first container elements
	+ ///
	+ /// Negative @a n means to take the head excluding the @a{n}-element tail
	+ template <typename CONTAINER>
	+ inline CONTAINER head(const CONTAINER& c, int n) {
	+ // if (n > c.size()) throw RangeError("Requested head longer than container");
	+ if (n < 0) n = std::max(0, (int)c.size()+n);
	+ n = std::min(n, (int)c.size());
	+ return slice(c, 0, n);
	+ }
	+
	+ /// @brief Tail slice of the @a n last container elements
	+ ///
	+ /// Negative @a n means to take the tail from after the @a{n}th element
	+ template <typename CONTAINER>
	+ inline CONTAINER tail(const CONTAINER& c, int n) {
	+ // if (n > c.size()) throw RangeError("Requested tail longer than container");
	+ if (n < 0) n = std::max(0, (int)c.size()+n);
	+ n = std::min(n, (int)c.size());
	+ return slice(c, c.size()-n);
	+ }
	+
	+
	+ using std::min;
	+ using std::max;
	+
	+ /// Find the minimum value in the vector
	+ inline double min(const vector<double>& in, double errval=DBL_NAN) {
	+ return *std::min_element(in.begin(), in.end());
	+ }
	+
	+ /// Find the maximum value in the vector
	+ inline double max(const vector<double>& in, double errval=DBL_NAN) {
	+ const auto e = std::max_element(in.begin(), in.end());
	+ return e != in.end() ? *e : errval;
	+ }
	+
	+ /// Find the minimum and maximum values in the vector
	+ inline pair<double,double> minmax(const vector<double>& in, double errval=DBL_NAN) {
	+ const auto e = std::minmax_element(in.begin(), in.end());
	+ const double rtnmin = e.first != in.end() ? *e.first : errval;
	+ const double rtnmax = e.second != in.end() ? *e.first : errval;
	+ return std::make_pair(rtnmin, rtnmax);
	+ }
	+
	+
	+ /// Find the minimum value in the vector
	+ inline int min(const vector<int>& in, int errval=-1) {
	+ const auto e = std::min_element(in.begin(), in.end());
	+ return e != in.end() ? *e : errval;
	+ }
	+
	+ /// Find the maximum value in the vector
	+ inline int max(const vector<int>& in, int errval=-1) {
	+ const auto e = std::max_element(in.begin(), in.end());
	+ return e != in.end() ? *e : errval;
	+ }
	+
	+ /// Find the minimum and maximum values in the vector
	+ inline pair<int,int> minmax(const vector<int>& in, int errval=-1) {
	+ const auto e = std::minmax_element(in.begin(), in.end());
	+ const double rtnmin = e.first != in.end() ? *e.first : errval;
	+ const double rtnmax = e.second != in.end() ? *e.first : errval;
	+ return std::make_pair(rtnmin, rtnmax);
	+ }
	+
	//@}


	}

	#endif
	diff --git a/m4/ax_python_devel.m4 b/m4/ax_python_devel.m4
	new file mode 100644
	--- /dev/null
	+++ b/m4/ax_python_devel.m4
	@@ -0,0 +1,330 @@
	+# ===========================================================================
	+# http://www.gnu.org/software/autoconf-archive/ax_python_devel.html
	+# ===========================================================================
	+#
	+# SYNOPSIS
	+#
	+# AX_PYTHON_DEVEL([version])
	+#
	+# DESCRIPTION
	+#
	+# Note: Defines as a precious variable "PYTHON_VERSION". Don't override it
	+# in your configure.ac.
	+#
	+# This macro checks for Python and tries to get the include path to
	+# 'Python.h'. It provides the $(PYTHON_CPPFLAGS) and $(PYTHON_LIBS) output
	+# variables. It also exports $(PYTHON_EXTRA_LIBS) and
	+# $(PYTHON_EXTRA_LDFLAGS) for embedding Python in your code.
	+#
	+# You can search for some particular version of Python by passing a
	+# parameter to this macro, for example ">= '2.3.1'", or "== '2.4'". Please
	+# note that you have to pass also an operator along with the version to
	+# match, and pay special attention to the single quotes surrounding the
	+# version number. Don't use "PYTHON_VERSION" for this: that environment
	+# variable is declared as precious and thus reserved for the end-user.
	+#
	+# This macro should work for all versions of Python >= 2.1.0. As an end
	+# user, you can disable the check for the python version by setting the
	+# PYTHON_NOVERSIONCHECK environment variable to something else than the
	+# empty string.
	+#
	+# If you need to use this macro for an older Python version, please
	+# contact the authors. We're always open for feedback.
	+#
	+# LICENSE
	+#
	+# Copyright (c) 2009 Sebastian Huber <sebastian-huber@web.de>
	+# Copyright (c) 2009 Alan W. Irwin
	+# Copyright (c) 2009 Rafael Laboissiere <rafael@laboissiere.net>
	+# Copyright (c) 2009 Andrew Collier
	+# Copyright (c) 2009 Matteo Settenvini <matteo@member.fsf.org>
	+# Copyright (c) 2009 Horst Knorr <hk_classes@knoda.org>
	+# Copyright (c) 2013 Daniel Mullner <muellner@math.stanford.edu>
	+#
	+# This program is free software: you can redistribute it and/or modify it
	+# under the terms of the GNU General Public License as published by the
	+# Free Software Foundation, either version 3 of the License, or (at your
	+# option) any later version.
	+#
	+# This program is distributed in the hope that it will be useful, but
	+# WITHOUT ANY WARRANTY; without even the implied warranty of
	+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
	+# Public License for more details.
	+#
	+# You should have received a copy of the GNU General Public License along
	+# with this program. If not, see <http://www.gnu.org/licenses/>.
	+#
	+# As a special exception, the respective Autoconf Macro's copyright owner
	+# gives unlimited permission to copy, distribute and modify the configure
	+# scripts that are the output of Autoconf when processing the Macro. You
	+# need not follow the terms of the GNU General Public License when using
	+# or distributing such scripts, even though portions of the text of the
	+# Macro appear in them. The GNU General Public License (GPL) does govern
	+# all other use of the material that constitutes the Autoconf Macro.
	+#
	+# This special exception to the GPL applies to versions of the Autoconf
	+# Macro released by the Autoconf Archive. When you make and distribute a
	+# modified version of the Autoconf Macro, you may extend this special
	+# exception to the GPL to apply to your modified version as well.
	+
	+#serial 18
	+
	+AU_ALIAS([AC_PYTHON_DEVEL], [AX_PYTHON_DEVEL])
	+AC_DEFUN([AX_PYTHON_DEVEL],[
	+ #
	+ # Allow the use of a (user set) custom python version
	+ #
	+ AC_ARG_VAR([PYTHON_VERSION],[The installed Python
	+ version to use, for example '2.3'. This string
	+ will be appended to the Python interpreter
	+ canonical name.])
	+
	+ AC_PATH_PROG([PYTHON],[python[$PYTHON_VERSION]])
	+ if test -z "$PYTHON"; then
	+ AC_MSG_ERROR([Cannot find python$PYTHON_VERSION in your system path])
	+ PYTHON_VERSION=""
	+ fi
	+
	+ #
	+ # Check for a version of Python >= 2.1.0
	+ #
	+ AC_MSG_CHECKING([for a version of Python >= '2.1.0'])
	+ ac_supports_python_ver=`$PYTHON -c "import sys; \
	+ ver = sys.version.split ()[[0]]; \
	+ print (ver >= '2.1.0')"`
	+ if test "$ac_supports_python_ver" != "True"; then
	+ if test -z "$PYTHON_NOVERSIONCHECK"; then
	+ AC_MSG_RESULT([no])
	+ AC_MSG_FAILURE([
	+This version of the AC@&t@_PYTHON_DEVEL macro
	+doesn't work properly with versions of Python before
	+2.1.0. You may need to re-run configure, setting the
	+variables PYTHON_CPPFLAGS, PYTHON_LIBS, PYTHON_SITE_PKG,
	+PYTHON_EXTRA_LIBS and PYTHON_EXTRA_LDFLAGS by hand.
	+Moreover, to disable this check, set PYTHON_NOVERSIONCHECK
	+to something else than an empty string.
	+])
	+ else
	+ AC_MSG_RESULT([skip at user request])
	+ fi
	+ else
	+ AC_MSG_RESULT([yes])
	+ fi
	+
	+ #
	+ # if the macro parameter ``version'' is set, honour it
	+ #
	+ if test -n "$1"; then
	+ AC_MSG_CHECKING([for a version of Python $1])
	+ ac_supports_python_ver=`$PYTHON -c "import sys; \
	+ ver = sys.version.split ()[[0]]; \
	+ print (ver $1)"`
	+ if test "$ac_supports_python_ver" = "True"; then
	+ AC_MSG_RESULT([yes])
	+ else
	+ AC_MSG_RESULT([no])
	+ AC_MSG_ERROR([this package requires Python $1.
	+If you have it installed, but it isn't the default Python
	+interpreter in your system path, please pass the PYTHON_VERSION
	+variable to configure. See ``configure --help'' for reference.
	+])
	+ PYTHON_VERSION=""
	+ fi
	+ fi
	+
	+ #
	+ # Check if you have distutils, else fail
	+ #
	+ AC_MSG_CHECKING([for the distutils Python package])
	+ ac_distutils_result=`$PYTHON -c "import distutils" 2>&1`
	+ if test -z "$ac_distutils_result"; then
	+ AC_MSG_RESULT([yes])
	+ else
	+ AC_MSG_RESULT([no])
	+ AC_MSG_ERROR([cannot import Python module "distutils".
	+Please check your Python installation. The error was:
	+$ac_distutils_result])
	+ PYTHON_VERSION=""
	+ fi
	+
	+ #
	+ # Check for Python include path
	+ #
	+ AC_MSG_CHECKING([for Python include path])
	+ if test -z "$PYTHON_CPPFLAGS"; then
	+ python_path=`$PYTHON -c "import distutils.sysconfig; \
	+ print (distutils.sysconfig.get_python_inc ());"`
	+ plat_python_path=`$PYTHON -c "import distutils.sysconfig; \
	+ print (distutils.sysconfig.get_python_inc (plat_specific=1));"`
	+ if test -n "${python_path}"; then
	+ if test "${plat_python_path}" != "${python_path}"; then
	+ python_path="-I$python_path -I$plat_python_path"
	+ else
	+ python_path="-I$python_path"
	+ fi
	+ fi
	+ PYTHON_CPPFLAGS=$python_path
	+ fi
	+ AC_MSG_RESULT([$PYTHON_CPPFLAGS])
	+ AC_SUBST([PYTHON_CPPFLAGS])
	+
	+ #
	+ # Check for Python library path
	+ #
	+ AC_MSG_CHECKING([for Python library path])
	+ if test -z "$PYTHON_LIBS"; then
	+ # (makes two attempts to ensure we've got a version number
	+ # from the interpreter)
	+ ac_python_version=`cat<<EOD \| $PYTHON -
	+
	+# join all versioning strings, on some systems
	+# major/minor numbers could be in different list elements
	+from distutils.sysconfig import *
	+e = get_config_var('VERSION')
	+if e is not None:
	+ print(e)
	+EOD`
	+
	+ if test -z "$ac_python_version"; then
	+ if test -n "$PYTHON_VERSION"; then
	+ ac_python_version=$PYTHON_VERSION
	+ else
	+ ac_python_version=`$PYTHON -c "import sys; \
	+ print (sys.version[[:3]])"`
	+ fi
	+ fi
	+
	+ # Make the versioning information available to the compiler
	+ AC_DEFINE_UNQUOTED([HAVE_PYTHON], ["$ac_python_version"],
	+ [If available, contains the Python version number currently in use.])
	+
	+ # First, the library directory:
	+ ac_python_libdir=`cat<<EOD \| $PYTHON -
	+
	+# There should be only one
	+import distutils.sysconfig
	+e = distutils.sysconfig.get_config_var('LIBDIR')
	+if e is not None:
	+ print (e)
	+EOD`
	+
	+ # Now, for the library:
	+ ac_python_library=`cat<<EOD \| $PYTHON -
	+
	+import distutils.sysconfig
	+c = distutils.sysconfig.get_config_vars()
	+if 'LDVERSION' in c:
	+ print ('python'+c[['LDVERSION']])
	+else:
	+ print ('python'+c[['VERSION']])
	+EOD`
	+
	+ # This small piece shamelessly adapted from PostgreSQL python macro;
	+ # credits goes to momjian, I think. I'd like to put the right name
	+ # in the credits, if someone can point me in the right direction... ?
	+ #
	+ if test -n "$ac_python_libdir" -a -n "$ac_python_library"
	+ then
	+ # use the official shared library
	+ ac_python_library=`echo "$ac_python_library" \| sed "s/^lib//"`
	+ PYTHON_LIBS="-L$ac_python_libdir -l$ac_python_library"
	+ else
	+ # old way: use libpython from python_configdir
	+ ac_python_libdir=`$PYTHON -c \
	+ "from distutils.sysconfig import get_python_lib as f; \
	+ import os; \
	+ print (os.path.join(f(plat_specific=1, standard_lib=1), 'config'));"`
	+ PYTHON_LIBS="-L$ac_python_libdir -lpython$ac_python_version"
	+ fi
	+
	+ if test -z "PYTHON_LIBS"; then
	+ AC_MSG_ERROR([
	+ Cannot determine location of your Python DSO. Please check it was installed with
	+ dynamic libraries enabled, or try setting PYTHON_LIBS by hand.
	+ ])
	+ fi
	+ fi
	+ AC_MSG_RESULT([$PYTHON_LIBS])
	+ AC_SUBST([PYTHON_LIBS])
	+
	+ #
	+ # Check for site packages
	+ #
	+ AC_MSG_CHECKING([for Python site-packages path])
	+ if test -z "$PYTHON_SITE_PKG"; then
	+ PYTHON_SITE_PKG=`$PYTHON -c "import distutils.sysconfig; \
	+ print (distutils.sysconfig.get_python_lib(0,0));"`
	+ fi
	+ AC_MSG_RESULT([$PYTHON_SITE_PKG])
	+ AC_SUBST([PYTHON_SITE_PKG])
	+
	+ #
	+ # libraries which must be linked in when embedding
	+ #
	+ AC_MSG_CHECKING(python extra libraries)
	+ if test -z "$PYTHON_EXTRA_LDFLAGS"; then
	+ PYTHON_EXTRA_LDFLAGS=`$PYTHON -c "import distutils.sysconfig; \
	+ conf = distutils.sysconfig.get_config_var; \
	+ print (conf('LIBS') + ' ' + conf('SYSLIBS'))"`
	+ fi
	+ AC_MSG_RESULT([$PYTHON_EXTRA_LDFLAGS])
	+ AC_SUBST(PYTHON_EXTRA_LDFLAGS)
	+
	+ #
	+ # linking flags needed when embedding
	+ #
	+ AC_MSG_CHECKING(python extra linking flags)
	+dnl
	+dnl removed by dg to try to fix the issue described in https://trac.macports.org/ticket/39223
	+dnl
	+dnl if test -z "$PYTHON_EXTRA_LIBS"; then
	+dnl PYTHON_EXTRA_LIBS=`$PYTHON -c "import distutils.sysconfig; \
	+dnl conf = distutils.sysconfig.get_config_var; \
	+dnl print (conf('LINKFORSHARED'))"`
	+dnl fi
	+ AC_MSG_RESULT([$PYTHON_EXTRA_LIBS])
	+ AC_SUBST(PYTHON_EXTRA_LIBS)
	+
	+ #
	+ # final check to see if everything compiles alright
	+ #
	+ AC_MSG_CHECKING([consistency of all components of python development environment])
	+ # save current global flags
	+ ac_save_LIBS="$LIBS"
	+ ac_save_LDFLAGS="$LDFLAGS"
	+ ac_save_CPPFLAGS="$CPPFLAGS"
	+ LIBS="$ac_save_LIBS $PYTHON_LIBS $PYTHON_EXTRA_LIBS $PYTHON_EXTRA_LIBS"
	+ LDFLAGS="$ac_save_LDFLAGS $PYTHON_EXTRA_LDFLAGS"
	+ CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS"
	+ AC_LANG_PUSH([C])
	+ AC_LINK_IFELSE([
	+ AC_LANG_PROGRAM([[#include <Python.h>]],
	+ [[Py_Initialize();]])
	+ ],[pythonexists=yes],[pythonexists=no])
	+ AC_LANG_POP([C])
	+ # turn back to default flags
	+ CPPFLAGS="$ac_save_CPPFLAGS"
	+ LIBS="$ac_save_LIBS"
	+ LDFLAGS="$ac_save_LDFLAGS"
	+
	+ AC_MSG_RESULT([$pythonexists])
	+
	+ if test ! "x$pythonexists" = "xyes"; then
	+ AC_MSG_FAILURE([
	+ Could not link test program to Python. Maybe the main Python library has been
	+ installed in some non-standard library path. If so, pass it to configure,
	+ via the LIBS environment variable.
	+ Example: ./configure LIBS="-L/usr/non-standard-path/python/lib"
	+ ============================================================================
	+ ERROR!
	+ You probably have to install the development version of the Python package
	+ for your distribution. The exact name of this package varies among them.
	+ ============================================================================
	+ ])
	+ PYTHON_VERSION=""
	+ fi
	+
	+ #
	+ # all done!
	+ #
	+])
	diff --git a/m4/python.m4 b/m4/python.m4
	deleted file mode 100644
	--- a/m4/python.m4
	+++ /dev/null
	@@ -1,782 +0,0 @@
	-# ===========================================================================
	-# http://autoconf-archive.cryp.to/az_python.html
	-# ===========================================================================
	-#
	-# SYNOPSIS
	-#
	-# AZ_PYTHON_DEFAULT
	-# AZ_PYTHON_ENABLE
	-# AZ_PYTHON_WITH
	-# AZ_PYTHON_PATH
	-# AZ_PYTHON_VERSION_ENSURE( [2.2] )
	-# AZ_PYTHON_CSPEC
	-# AZ_PYTHON_LSPEC
	-#
	-# DESCRIPTION
	-#
	-# This file provides autoconf support for those applications that want to
	-# embed python. It supports all pythons >= 2.2 which is the first official
	-# release containing distutils. Version 2.2 of python was released
	-# December 21, 2001. Since it actually executes the python, cross platform
	-# configuration will probably not work. Also, most of the platforms
	-# supported are consistent until you look into MacOSX. The python included
	-# with it is installed as a framework which is a very different
	-# environment to set up the normal tools such as gcc and libtool to deal
	-# with. Therefore, once we establish which python that we are going to
	-# use, we use its distutils to actually compile and link our modules or
	-# applications.
	-#
	-# At this time, it does NOT support linking with Python statically. It
	-# does support dynamic linking.
	-#
	-# This set of macros help define $PYTHON, $PYTHON_USE, $PYTHON_CSPEC and
	-# $PYTHON_LSPEC. $PYTHON defines the full executable path for the Python
	-# being linked to and is used within these macros to determine if that has
	-# been specified or found. These macros do execute this python version so
	-# it must be present on the system at configure time.
	-#
	-# $PYTHON_USE is an automake variable that defines whether Python support
	-# should be included or not in your application. $PYTHON_CSPEC is a
	-# variable that supplies additional CFLAGS for the compilation of the
	-# application/shared library. $PYTHON_LSPEC is a variable that supplies
	-# additional LDFLAGS for linking the application/shared library.
	-#
	-# The following is an example of how to set up for python usage within
	-# your application in your configure.in:
	-#
	-# AZ_PYTHON_DEFAULT( )
	-# AZ_PYTHON_ENABLE( ) # Optional
	-# AZ_PYTHON_WITH( ) # Optional
	-# AZ_PYTHON_PATH( ) # or AZ_PYTHON_INSIST( )
	-# # if $PYTHON is not defined, then the following do nothing.
	-# AZ_PYTHON_VERSION_ENSURE( [2.2] )
	-# AZ_PYTHON_CSPEC
	-# AZ_PYTHON_LSPEC
	-#
	-# The AZ_PYTHON_DEFAULT sets the $PYTHON_USE to false. Thereby, excluding
	-# it if it was optional.
	-#
	-# The AZ_PYTHON_ENABLE looks for the optional configure parameters of
	-# --enable-python/--disable-python and establishes the $PYTHON and
	-# $PYTHON_USE variables accordingly.
	-#
	-# The AZ_PYTHON_WITH looks for the optional configure parameters of
	-# --with-python/--without-python and establishes the $PYTHON and
	-# $PYTHON_USE variables accordingly.
	-#
	-# The AZ_PYTHON_PATH looks for python assuming that none has been
	-# previously found or defined and issues an error if it does not find it.
	-# If it does find it, it establishes the $PYTHON and $PYTHON_USE variables
	-# accordingly. AZ_PYTHON_INSIST could be used here instead if you want to
	-# insist that Python support be included using the --enable-python or
	-# --with-python checks previously done.
	-#
	-# The AZ_PYTHON_VERSION_ENSURE issues an error if the Python previously
	-# found is not of version 2.2 or greater.
	-#
	-# Once that these macros have be run, we can use PYTHON_USE within the
	-# makefile.am file to conditionally add the Python support such as:
	-#
	-# Makefile.am example showing optional inclusion of directories:
	-#
	-# if PYTHON_USE
	-# plugins = plugins
	-# src = src
	-# else
	-# plugins =
	-# src =
	-# endif
	-#
	-# SUBDIRS = . $(plugins) $(src)
	-#
	-# Makefile.am example showing optional shared library build:
	-#
	-# if PYTHON_USE
	-# lib_LTLIBRARIES = libElemList.la
	-# libElemList_la_SOURCES = libElemList.c
	-# libElemList_la_CFLAGS = @PYTHON_CSPEC@
	-# libElemList_la_LDFLAGS = @PYTHON_LSPEC@
	-# endif
	-#
	-# Makefile.am example showing optional program build:
	-#
	-# if PYTHON_USE
	-# bin_PROGRAMS = runFunc
	-# runFunc_SOURCES = runFunc.c
	-# runFunc_CFLAGS = @PYTHON_CSPEC@
	-# runFunc_LDFLAGS = @PYTHON_LSPEC@
	-# endif
	-#
	-# The above compiles the modules only if PYTHON_USE was specified as true.
	-# Also, the else portion of the if was optional.
	-#
	-# LAST MODIFICATION
	-#
	-# 2008-04-12
	-#
	-# COPYLEFT
	-#
	-# Copyright (c) 2008 Robert White <kranki@mac.com>
	-# Copyright (c) 2008 Dustin J. Mitchell <dustin@cs.uchicago.edu>
	-#
	-# Copying and distribution of this file, with or without modification, are
	-# permitted in any medium without royalty provided the copyright notice
	-# and this notice are preserved.
	-
	-# AZ_PYTHON_DEFAULT( )
	-# -----------------
	-# Sets the default to not include Python support.
	-
	-AC_DEFUN([AZ_PYTHON_DEFAULT],
	-[
	- az_python_use=false
	- AM_CONDITIONAL(PYTHON_USE, test x"$az_python_use" = x"true")
	-])
	-
	-
	-
	-# AZ_PYTHON_ENABLE( [path] )
	-# -----------------------------------------------------------------
	-# Handles the various --enable-python commands.
	-# Input:
	-# $1 is the optional search path for the python executable if needed
	-# Ouput:
	-# PYTHON_USE (AM_CONDITIONAL) is true if python executable found
	-# and --enable-python was requested; otherwise false.
	-# $PYTHON contains the full executable path to python if PYTHON_ENABLE_USE
	-# is true.
	-#
	-# Example:
	-# AZ_PYTHON_ENABLE( )
	-# or
	-# AZ_PYTHON_ENABLE( "/usr/bin" )
	-
	-AC_DEFUN([AZ_PYTHON_ENABLE],
	-[
	- AC_ARG_VAR([PYTHON],[Python Executable Path])
	-
	- # unless PYTHON was supplied to us (as a precious variable),
	- # see if --enable-python[=PythonExecutablePath], --enable-python,
	- # --disable-python or --enable-python=no was given.
	- if test -z "$PYTHON"
	- then
	- AC_MSG_CHECKING(for --enable-python)
	- AC_ARG_ENABLE(
	- python,
	- AC_HELP_STRING([--enable-python@<:@=PYTHON@:>@],
	- [absolute path name of Python executable]
	- ),
	- [
	- if test "$enableval" = "yes"
	- then
	- # "yes" was specified, but we don't have a path
	- # for the executable.
	- # So, let's searth the PATH Environment Variable.
	- AC_MSG_RESULT(yes)
	- AC_PATH_PROG(
	- [PYTHON],
	- python,
	- [],
	- $1
	- )
	- if test -z "$PYTHON"
	- then
	- AC_MSG_ERROR(no path to python found)
	- fi
	- az_python_use=true
	- AM_CONDITIONAL(PYTHON_USE, test x"$az_python_use" = x"true")
	- AZ_PYTHON_PREFIX( )
	- elif test "$enableval" = "no"
	- then
	- AC_MSG_RESULT(no)
	- az_python_use=false
	- AM_CONDITIONAL(PYTHON_USE, test x"$az_python_use" = x"true")
	- else
	- # $enableval must be the executable path then.
	- AC_SUBST([PYTHON], ["${enableval}"])
	- AC_MSG_RESULT($withval)
	- az_python_use=true
	- AM_CONDITIONAL(PYTHON_USE, test x"$az_python_use" = x"true")
	- AZ_PYTHON_PREFIX( )
	- fi
	- ],
	- [
	- # --with-python was not specified.
	- AC_MSG_RESULT(no)
	- az_python_use=false
	- AM_CONDITIONAL(PYTHON_USE, test x"$az_python_use" = x"true")
	- ]
	- )
	- fi
	-
	-])
	-
	-
	-
	-# AZ_PYTHON_CSPEC( )
	-# -----------------
	-# Set up the c compiler options to compile Python
	-# embedded programs/libraries in $PYTHON_CSPEC if
	-# $PYTHON has been defined.
	-
	-AC_DEFUN([AZ_PYTHON_CSPEC],
	-[
	- AC_ARG_VAR( [PYTHON], [Python Executable Path] )
	- if test -n "$PYTHON"
	- then
	- az_python_prefix=`${PYTHON} -c "import sys; print sys.prefix"`
	- if test -z "$az_python_prefix"
	- then
	- AC_MSG_ERROR([Python Prefix is not known])
	- fi
	- az_python_execprefix=`${PYTHON} -c "import sys; print sys.exec_prefix"`
	- az_python_version=`$PYTHON -c "import sys; print sys.version[[:3]]"`
	- az_python_includespec="-I${az_python_prefix}/include/python${az_python_version}"
	- if test x"$python_prefix" != x"$python_execprefix"; then
	- az_python_execspec="-I${az_python_execprefix}/include/python${az_python_version}"
	- az_python_includespec="${az_python_includespec} $az_python_execspec"
	- fi
	- az_python_ccshared=`${PYTHON} -c "import distutils.sysconfig; print distutils.sysconfig.get_config_var('CFLAGSFORSHARED')"`
	- az_python_cspec="${az_python_ccshared} ${az_python_includespec}"
	- AC_SUBST([PYTHON_CSPEC], [${az_python_cspec}])
	- AC_MSG_NOTICE([PYTHON_CSPEC=${az_python_cspec}])
	- fi
	-])
	-
	-
	-
	-# AZ_PYTHON_INSIST( )
	-# -----------------
	-# Look for Python and set the output variable 'PYTHON'
	-# to 'python' if found, empty otherwise.
	-
	-AC_DEFUN([AZ_PYTHON_PATH],
	-[
	- AC_ARG_VAR( [PYTHON], [Python Executable Path] )
	- if test -z "$PYTHON"
	- then
	- AC_MSG_ERROR([Python Executable not found])
	- fi
	-])
	-
	-
	-
	-# AZ_PYTHON_LSPEC( )
	-# -----------------
	-# Set up the linker options to link Python embedded
	-# programs/libraries in $PYTHON_LSPEC if $PYTHON
	-# has been defined.
	-
	-AC_DEFUN([AZ_PYTHON_LSPEC],
	-[
	- AC_ARG_VAR( [PYTHON], [Python Executable Path] )
	- if test -n "$PYTHON"
	- then
	- AZ_PYTHON_RUN([
	-import sys
	-import distutils.sysconfig
	-strUseFrameWork = "--enable-framework"
	-dictConfig = distutils.sysconfig.get_config_vars( )
	-strConfigArgs = dictConfig.get("CONFIG_ARGS")
	-strLinkSpec = dictConfig.get('LDFLAGS')
	-if -1 == strConfigArgs.find(strUseFrameWork):
	- strLibPL = dictConfig.get("LIBPL")
	- if strLibPL and (strLibPL != ""):
	- strLinkSpec += " -L%s" % (strLibPL)
	- strSys = dictConfig.get("SYSLIBS")
	- if strSys and (strSys != ""):
	- strLinkSpec += " %s" % (strSys)
	- strSHL = dictConfig.get("SHLIBS")
	- if strSHL and (strSHL != ""):
	- strLinkSpec += " %s" % (strSHL)
	- # Construct the Python Library Name.
	- strTmplte = " -lpython%d.%d"
	- if (sys.platform == "win32") or (sys.platform == "os2emx"):
	- strTmplte = " -lpython%d%d"
	- strWrk = strTmplte % ( (sys.hexversion >> 24),
	- ((sys.hexversion >> 16) & 0xff))
	- strLinkSpec += strWrk
	-else:
	- # This is not ideal since it changes the search path
	- # for Frameworks which could have side-effects on
	- # other included Frameworks. However, it is necessary
	- # where someone has installed more than one frameworked
	- # Python. Frameworks are really only used in MacOSX.
	- strLibFW = dictConfig.get("PYTHONFRAMEWORKPREFIX")
	- if strLibFW and (strLibFW != ""):
	- strLinkSpec += " -F%s" % (strLibFW)
	-strLinkSpec += " %s" % (dictConfig.get('LINKFORSHARED'))
	-print strLinkSpec
	- ])
	- AC_SUBST([PYTHON_LSPEC], [${az_python_output}])
	- AC_MSG_NOTICE([PYTHON_LSPEC=${az_python_output}])
	- fi
	-])
	-
	-
	-
	-# AZ_PYTHON_PATH( )
	-# -----------------
	-# Look for Python and set the output variable 'PYTHON'
	-# to 'python' if found, empty otherwise.
	-
	-AC_DEFUN([AZ_PYTHON_PATH],
	-[
	- AC_ARG_VAR( [PYTHON], [Python Executable Path] )
	- AC_PATH_PROG( PYTHON, python, [], $1 )
	- if test -z "$PYTHON"
	- then
	- AC_MSG_ERROR([Python Executable not found])
	- else
	- az_python_use=true
	- fi
	- AM_CONDITIONAL(PYTHON_USE, test "$az_python_use" = "true")
	-])
	-
	-
	-
	-# AZ_PYTHON_PREFIX( )
	-# -------------------
	-# Use the values of $prefix and $exec_prefix for the corresponding
	-# values of PYTHON_PREFIX and PYTHON_EXEC_PREFIX.
	-
	-AC_DEFUN([AZ_PYTHON_PREFIX],
	-[
	- if test -z "$PYTHON"
	- then
	- AC_MSG_ERROR([Python Executable Path is not known])
	- fi
	- ax_python_prefix=`${PYTHON} -c "import sys; print sys.prefix"`
	- ax_python_execprefix=`${PYTHON} -c "import sys; print sys.exec_prefix"`
	- AC_SUBST([PYTHON_PREFIX], ["${ax_python_prefix}"])
	- AC_SUBST([PYTHON_EXECPREFIX], ["${ax_python_execprefix}"])
	-])
	-
	-
	-
	-# AZ_PYTHON_RUN( PYTHON_PROGRAM )
	-# -----------------
	-# Run a Python Test Program saving its output
	-# in az_python_output and its condition code
	-# in az_python_cc.
	-
	-AC_DEFUN([AZ_PYTHON_RUN],
	-[
	- AC_ARG_VAR( [PYTHON], [Python Executable Path] )
	- if test -z "$PYTHON"
	- then
	- AC_MSG_ERROR([Python Executable not found])
	- else
	- cat >conftest.py <<_ACEOF
	-$1
	-_ACEOF
	- az_python_output=`$PYTHON conftest.py`
	- az_python_cc=$?
	- rm conftest.py
	- if test -f "conftest.pyc"
	- then
	- rm conftest.pyc
	- fi
	- fi
	-])
	-
	-
	-
	-# AZ_PYTHON_VERSION_CHECK( VERSION, [ACTION-IF-TRUE], [ACTION-IF-FALSE] )
	-# -----------------------------------------------------------------------------
	-# Run ACTION-IF-TRUE if the Python interpreter has version >= VERSION.
	-# Run ACTION-IF-FALSE otherwise.
	-# This test uses sys.hexversion instead of the string equivalant (first
	-# word of sys.version), in order to cope with versions such as 2.2c1.
	-# hexversion has been introduced in Python 1.5.2; it's probably not
	-# worth to support older versions (1.5.1 was released on October 31, 1998).
	-
	-AC_DEFUN([AZ_PYTHON_VERSION_CHECK],
	- [
	- AC_ARG_VAR( [PYTHON], [Python Executable Path] )
	- if test -n "$PYTHON"
	- then
	- AC_MSG_CHECKING([whether $PYTHON version >= $1])
	- AZ_PYTHON_RUN([
	-import sys, string
	-# split strings by '.' and convert to numeric. Append some zeros
	-# because we need at least 4 digits for the hex conversion.
	-minver = map(int, string.split('$1', '.')) + [[0, 0, 0]]
	-minverhex = 0
	-for i in xrange(0, 4): minverhex = (minverhex << 8) + minver[[i]]
	-if sys.hexversion >= minverhex:
	- sys.exit( 0 )
	-else:
	- sys.exit( 1 )
	- ])
	- if test $az_python_cc -eq 0
	- then
	- $2
	- m4_ifvaln(
	- [$3],
	- [else $3]
	- )
	- fi
	- fi
	-])
	-
	-
	-
	-# AZ_PYTHON_VERSION_ENSURE( VERSION )
	-# -----------------
	-# Insure that the Python Interpreter Version
	-# is greater than or equal to the VERSION
	-# parameter.
	-
	-AC_DEFUN([AZ_PYTHON_VERSION_ENSURE],
	-[
	- AZ_PYTHON_VERSION_CHECK(
	- [$1],
	- [AC_MSG_RESULT(yes)],
	- [AC_MSG_ERROR(too old)]
	- )
	-])
	-
	-
	-
	-# AZ_PYTHON_WITH( [path] )
	-# -----------------------------------------------------------------
	-# Handles the various --with-python commands.
	-# Input:
	-# $1 is the optional search path for the python executable if needed
	-# Ouput:
	-# PYTHON_USE (AM_CONDITIONAL) is true if python executable found
	-# and --with-python was requested; otherwise false.
	-# $PYTHON contains the full executable path to python if PYTHON_USE
	-# is true.
	-#
	-# Example:
	-# AZ_PYTHON_WITH( )
	-# or
	-# AZ_PYTHON_WITH("/usr/bin")
	-
	-AC_DEFUN([AZ_PYTHON_WITH],
	-[
	- AC_ARG_VAR([PYTHON],[Python Executable Path])
	-
	- # unless PYTHON was supplied to us (as a precious variable),
	- # see if --with-python[=PythonExecutablePath], --with-python,
	- # --without-python or --with-python=no was given.
	- if test -z "$PYTHON"
	- then
	- AC_MSG_CHECKING(for --with-python)
	- AC_ARG_WITH(
	- python,
	- AC_HELP_STRING([--with-python@<:@=PYTHON@:>@],
	- [absolute path name of Python executable]
	- ),
	- [
	- if test "$withval" = "yes"
	- then
	- # "yes" was specified, but we don't have a path
	- # for the executable.
	- # So, let's searth the PATH Environment Variable.
	- AC_MSG_RESULT(yes)
	- AC_PATH_PROG(
	- [PYTHON],
	- python,
	- [],
	- $1
	- )
	- if test -z "$PYTHON"
	- then
	- AC_MSG_ERROR(no path to python found)
	- fi
	- az_python_use=true
	- AM_CONDITIONAL(PYTHON_USE, test x"$az_python_use" = x"true")
	- AZ_PYTHON_PREFIX( )
	- elif test "$withval" = "no"
	- then
	- AC_MSG_RESULT(no)
	- az_python_use=false
	- AM_CONDITIONAL(PYTHON_USE, test x"$az_python_use" = x"true")
	- else
	- # $withval must be the executable path then.
	- AC_SUBST([PYTHON], ["${withval}"])
	- AC_MSG_RESULT($withval)
	- az_python_use=true
	- AM_CONDITIONAL(PYTHON_USE, test x"$az_python_use" = x"true")
	- AZ_PYTHON_PREFIX( )
	- fi
	- ],
	- [
	- # --with-python was not specified.
	- AC_MSG_RESULT(no)
	- az_python_use=false
	- AM_CONDITIONAL(PYTHON_USE, test x"$az_python_use" = x"true")
	- ]
	- )
	- fi
	-
	-])
	-
	-# ===========================================================================
	-# http://autoconf-archive.cryp.to/ac_python_devel.html
	-# ===========================================================================
	-#
	-# SYNOPSIS
	-#
	-# AC_PYTHON_DEVEL([version])
	-#
	-# DESCRIPTION
	-#
	-# Note: Defines as a precious variable "PYTHON_VERSION". Don't override it
	-# in your configure.ac.
	-#
	-# This macro checks for Python and tries to get the include path to
	-# 'Python.h'. It provides the $(PYTHON_CPPFLAGS) and $(PYTHON_LDFLAGS)
	-# output variables. It also exports $(PYTHON_EXTRA_LIBS) and
	-# $(PYTHON_EXTRA_LDFLAGS) for embedding Python in your code.
	-#
	-# You can search for some particular version of Python by passing a
	-# parameter to this macro, for example ">= '2.3.1'", or "== '2.4'". Please
	-# note that you have to pass also an operator along with the version to
	-# match, and pay special attention to the single quotes surrounding the
	-# version number. Don't use "PYTHON_VERSION" for this: that environment
	-# variable is declared as precious and thus reserved for the end-user.
	-#
	-# This macro should work for all versions of Python >= 2.1.0. As an end
	-# user, you can disable the check for the python version by setting the
	-# PYTHON_NOVERSIONCHECK environment variable to something else than the
	-# empty string.
	-#
	-# If you need to use this macro for an older Python version, please
	-# contact the authors. We're always open for feedback.
	-#
	-# LAST MODIFICATION
	-#
	-# 2008-04-12
	-#
	-# COPYLEFT
	-#
	-# Copyright (c) 2008 Sebastian Huber <sebastian-huber@web.de>
	-# Copyright (c) 2008 Alan W. Irwin <irwin@beluga.phys.uvic.ca>
	-# Copyright (c) 2008 Rafael Laboissiere <rafael@laboissiere.net>
	-# Copyright (c) 2008 Andrew Collier <colliera@ukzn.ac.za>
	-# Copyright (c) 2008 Matteo Settenvini <matteo@member.fsf.org>
	-# Copyright (c) 2008 Horst Knorr <hk_classes@knoda.org>
	-#
	-# This program is free software: you can redistribute it and/or modify it
	-# under the terms of the GNU General Public License as published by the
	-# Free Software Foundation, either version 3 of the License, or (at your
	-# option) any later version.
	-#
	-# This program is distributed in the hope that it will be useful, but
	-# WITHOUT ANY WARRANTY; without even the implied warranty of
	-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
	-# Public License for more details.
	-#
	-# You should have received a copy of the GNU General Public License along
	-# with this program. If not, see <http://www.gnu.org/licenses/>.
	-#
	-# As a special exception, the respective Autoconf Macro's copyright owner
	-# gives unlimited permission to copy, distribute and modify the configure
	-# scripts that are the output of Autoconf when processing the Macro. You
	-# need not follow the terms of the GNU General Public License when using
	-# or distributing such scripts, even though portions of the text of the
	-# Macro appear in them. The GNU General Public License (GPL) does govern
	-# all other use of the material that constitutes the Autoconf Macro.
	-#
	-# This special exception to the GPL applies to versions of the Autoconf
	-# Macro released by the Autoconf Macro Archive. When you make and
	-# distribute a modified version of the Autoconf Macro, you may extend this
	-# special exception to the GPL to apply to your modified version as well.
	-
	-AC_DEFUN([AC_PYTHON_DEVEL],[
	- #
	- # Allow the use of a (user set) custom python version
	- #
	- AC_ARG_VAR([PYTHON_VERSION],[The installed Python
	- version to use, for example '2.3'. This string
	- will be appended to the Python interpreter
	- canonical name.])
	-
	- AC_PATH_PROG([PYTHON],[python[$PYTHON_VERSION]])
	- if test -z "$PYTHON"; then
	- AC_MSG_ERROR([Cannot find python$PYTHON_VERSION in your system path])
	- PYTHON_VERSION=""
	- fi
	-
	- #
	- # Check for a version of Python >= 2.1.0
	- #
	- AC_MSG_CHECKING([for a version of Python >= '2.1.0'])
	- ac_supports_python_ver=`$PYTHON -c "import sys, string; \
	- ver = string.split(sys.version)[[0]]; \
	- print ver >= '2.1.0'"`
	- if test "$ac_supports_python_ver" != "True"; then
	- if test -z "$PYTHON_NOVERSIONCHECK"; then
	- AC_MSG_RESULT([no])
	- AC_MSG_FAILURE([
	-This version of the AC@&t@_PYTHON_DEVEL macro
	-doesn't work properly with versions of Python before
	-2.1.0. You may need to re-run configure, setting the
	-variables PYTHON_CPPFLAGS, PYTHON_LDFLAGS, PYTHON_SITE_PKG,
	-PYTHON_EXTRA_LIBS and PYTHON_EXTRA_LDFLAGS by hand.
	-Moreover, to disable this check, set PYTHON_NOVERSIONCHECK
	-to something else than an empty string.
	-])
	- else
	- AC_MSG_RESULT([skip at user request])
	- fi
	- else
	- AC_MSG_RESULT([yes])
	- fi
	-
	- #
	- # if the macro parameter ``version'' is set, honour it
	- #
	- if test -n "$1"; then
	- AC_MSG_CHECKING([for a version of Python $1])
	- ac_supports_python_ver=`$PYTHON -c "import sys, string; \
	- ver = string.split(sys.version)[[0]]; \
	- print ver $1"`
	- if test "$ac_supports_python_ver" = "True"; then
	- AC_MSG_RESULT([yes])
	- else
	- AC_MSG_RESULT([no])
	- AC_MSG_ERROR([this package requires Python $1.
	-If you have it installed, but it isn't the default Python
	-interpreter in your system path, please pass the PYTHON_VERSION
	-variable to configure. See ``configure --help'' for reference.
	-])
	- PYTHON_VERSION=""
	- fi
	- fi
	-
	- #
	- # Check if you have distutils, else fail
	- #
	- AC_MSG_CHECKING([for the distutils Python package])
	- ac_distutils_result=`$PYTHON -c "import distutils" 2>&1`
	- if test -z "$ac_distutils_result"; then
	- AC_MSG_RESULT([yes])
	- else
	- AC_MSG_RESULT([no])
	- AC_MSG_ERROR([cannot import Python module "distutils".
	-Please check your Python installation. The error was:
	-$ac_distutils_result])
	- PYTHON_VERSION=""
	- fi
	-
	- #
	- # Check for Python include path
	- #
	- AC_MSG_CHECKING([for Python include path])
	- if test -z "$PYTHON_CPPFLAGS"; then
	- python_path=`$PYTHON -c "import distutils.sysconfig; \
	- print distutils.sysconfig.get_python_inc();"`
	- if test -n "${python_path}"; then
	- python_path="-I$python_path"
	- fi
	- PYTHON_CPPFLAGS=$python_path
	- fi
	- AC_MSG_RESULT([$PYTHON_CPPFLAGS])
	- AC_SUBST([PYTHON_CPPFLAGS])
	-
	- #
	- # Check for Python library path
	- #
	- AC_MSG_CHECKING([for Python library path])
	- if test -z "$PYTHON_LDFLAGS"; then
	- # (makes two attempts to ensure we've got a version number
	- # from the interpreter)
	- py_version=`$PYTHON -c "from distutils.sysconfig import *; \
	- from string import join; \
	- print join(get_config_vars('VERSION'))"`
	- if test "$py_version" == "[None]"; then
	- if test -n "$PYTHON_VERSION"; then
	- py_version=$PYTHON_VERSION
	- else
	- py_version=`$PYTHON -c "import sys; \
	- print sys.version[[:3]]"`
	- fi
	- fi
	-
	- PYTHON_LDFLAGS=`$PYTHON -c "from distutils.sysconfig import *; \
	- from string import join; \
	- print '-L' + get_python_lib(0,1), \
	- '-lpython';"`$py_version
	- fi
	- AC_MSG_RESULT([$PYTHON_LDFLAGS])
	- AC_SUBST([PYTHON_LDFLAGS])
	-
	- #
	- # Check for site packages
	- #
	- AC_MSG_CHECKING([for Python site-packages path])
	- if test -z "$PYTHON_SITE_PKG"; then
	- PYTHON_SITE_PKG=`$PYTHON -c "import distutils.sysconfig; \
	- print distutils.sysconfig.get_python_lib(0,0);"`
	- fi
	- AC_MSG_RESULT([$PYTHON_SITE_PKG])
	- AC_SUBST([PYTHON_SITE_PKG])
	-
	- #
	- # libraries which must be linked in when embedding
	- #
	- AC_MSG_CHECKING(python extra libraries)
	- if test -z "$PYTHON_EXTRA_LIBS"; then
	- PYTHON_EXTRA_LIBS=`$PYTHON -c "import distutils.sysconfig; \
	- conf = distutils.sysconfig.get_config_var; \
	- print conf('LOCALMODLIBS'), conf('LIBS')"`
	- fi
	- AC_MSG_RESULT([$PYTHON_EXTRA_LIBS])
	- AC_SUBST(PYTHON_EXTRA_LIBS)
	-
	- #
	- # linking flags needed when embedding
	- #
	- AC_MSG_CHECKING(python extra linking flags)
	- if test -z "$PYTHON_EXTRA_LDFLAGS"; then
	- PYTHON_EXTRA_LDFLAGS=`$PYTHON -c "import distutils.sysconfig; \
	- conf = distutils.sysconfig.get_config_var; \
	- print conf('LINKFORSHARED')"`
	- fi
	- AC_MSG_RESULT([$PYTHON_EXTRA_LDFLAGS])
	- AC_SUBST(PYTHON_EXTRA_LDFLAGS)
	-
	- #
	- # final check to see if everything compiles alright
	- #
	- AC_MSG_CHECKING([consistency of all components of python development environment])
	- AC_LANG_PUSH([C])
	- # save current global flags
	- LIBS="$ac_save_LIBS $PYTHON_LDFLAGS"
	- CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS"
	- AC_TRY_LINK([
	- #include <Python.h>
	- ],[
	- Py_Initialize();
	- ],[pythonexists=yes],[pythonexists=no])
	-
	- AC_MSG_RESULT([$pythonexists])
	-
	- if test ! "$pythonexists" = "yes"; then
	- AC_MSG_ERROR([
	- Could not link test program to Python. Maybe the main Python library has been
	- installed in some non-standard library path. If so, pass it to configure,
	- via the LDFLAGS environment variable.
	- Example: ./configure LDFLAGS="-L/usr/non-standard-path/python/lib"
	- ============================================================================
	- ERROR!
	- You probably have to install the development version of the Python package
	- for your distribution. The exact name of this package varies among them.
	- ============================================================================
	- ])
	- PYTHON_VERSION=""
	- fi
	- AC_LANG_POP
	- # turn back to default flags
	- CPPFLAGS="$ac_save_CPPFLAGS"
	- LIBS="$ac_save_LIBS"
	-
	- #
	- # all done!
	- #
	-])
	diff --git a/plotnanas b/plotnanas
	new file mode 100755
	--- /dev/null
	+++ b/plotnanas
	@@ -0,0 +1,27 @@
	+#! /usr/bin/env python
	+
	+import argparse
	+ap = argparse.ArgumentParser()
	+ap.add_argument("DATFILE", metavar="file", default="nanas.dat", help="release/count data file to read")
	+args = ap.parse_args()
	+
	+import datetime
	+import numpy as np
	+import matplotlib.pyplot as plt
	+# import matplotlib.dates as mdates
	+# import matplotlib.cbook as cbook
	+
	+tags, dates, nanas = [], [], []
	+with open(args.DATFILE) as f:
	+ for line in f:
	+ items = line.split()
	+ tags.append(items[0])
	+ ts = float(items[1].replace("-3600", "").replace("-7200", ""))
	+ dates.append(datetime.date.fromtimestamp(ts))
	+ nanas.append(int(items[2]))
	+
	+plt.plot(dates, nanas)
	+plt.xlabel("Year")
	+plt.ylabel("# analyses")
	+plt.savefig(args.DATFILE.replace(".dat", ".pdf"))
	+# plt.show()
	diff --git a/pyext/rivet/core.pyx b/pyext/rivet/core.pyx
	--- a/pyext/rivet/core.pyx
	+++ b/pyext/rivet/core.pyx
	@@ -1,189 +1,215 @@
	# distutils: language = c++

	cimport rivet as c
	from cython.operator cimport dereference as deref
	# Need to be careful with memory management -- perhaps use the base object that
	# we used in YODA?

	cdef extern from "<utility>" namespace "std" nogil:
	cdef c.unique_ptr[c.Analysis] move(c.unique_ptr[c.Analysis])

	cdef class AnalysisHandler:
	cdef c.AnalysisHandler *_ptr

	def __cinit__(self):
	self._ptr = new c.AnalysisHandler()

	def __del__(self):
	del self._ptr

	def setIgnoreBeams(self, ignore=True):
	self._ptr.setIgnoreBeams(ignore)

	def addAnalysis(self, name):
	self._ptr.addAnalysis(name)
	return self

	+ def analysisNames(self):
	+ anames = self._ptr.analysisNames()
	+ return [a for a in anames]
	+
	+ # def analysis(self, aname):
	+ # cdef c.Analysis* ptr = self._ptr.analysis(aname)
	+ # cdef Analysis pyobj = Analysis.__new__(Analysis)
	+ # if not ptr:
	+ # return None
	+ # pyobj._ptr = ptr
	+ # return pyobj
	+
	def writeData(self, name):
	self._ptr.writeData(name)

	def crossSection(self):
	return self._ptr.crossSection()

	def finalize(self):
	self._ptr.finalize()


	cdef class Run:
	cdef c.Run *_ptr

	def __cinit__(self, AnalysisHandler h):
	self._ptr = new c.Run(h._ptr[0])

	def __del__(self):
	del self._ptr

	def setCrossSection(self, double x):
	self._ptr.setCrossSection(x)
	return self

	def setListAnalyses(self, choice):
	self._ptr.setListAnalyses(choice)
	return self

	def init(self, name, weight=1.0):
	return self._ptr.init(name, weight)

	def openFile(self, name, weight=1.0):
	return self._ptr.openFile(name, weight)

	def readEvent(self):
	return self._ptr.readEvent()

	+ def skipEvent(self):
	+ return self._ptr.skipEvent()
	+
	def processEvent(self):
	return self._ptr.processEvent()

	def finalize(self):
	return self._ptr.finalize()


	cdef class Analysis:
	cdef c.unique_ptr[c.Analysis] _ptr

	def __init__(self):
	raise RuntimeError('This class cannot be instantiated')

	def requiredBeams(self):
	return deref(self._ptr).requiredBeams()

	def requiredEnergies(self):
	return deref(self._ptr).requiredEnergies()

	+ def keywords(self):
	+ return deref(self._ptr).keywords()
	+
	def authors(self):
	return deref(self._ptr).authors()

	def bibKey(self):
	return deref(self._ptr).bibKey()

	def name(self):
	return deref(self._ptr).name()

	def bibTeX(self):
	return deref(self._ptr).bibTeX()

	def references(self):
	return deref(self._ptr).references()

	def collider(self):
	return deref(self._ptr).collider()

	def description(self):
	return deref(self._ptr).description()

	def experiment(self):
	return deref(self._ptr).experiment()

	def inspireId(self):
	return deref(self._ptr).inspireId()

	def spiresId(self):
	return deref(self._ptr).spiresId()

	def runInfo(self):
	return deref(self._ptr).runInfo()

	def status(self):
	return deref(self._ptr).status()

	def summary(self):
	return deref(self._ptr).summary()

	def year(self):
	return deref(self._ptr).year()

	+ def luminosityfb(self):
	+ return deref(self._ptr).luminosityfb()

	#cdef object
	LEVELS = dict(TRACE = 0, DEBUG = 10, INFO = 20,
	WARN = 30, WARNING = 30, ERROR = 40,
	CRITICAL = 50, ALWAYS = 50)


	cdef class AnalysisLoader:
	@staticmethod
	def analysisNames():
	return c.AnalysisLoader_analysisNames()

	@staticmethod
	def getAnalysis(name):
	cdef c.unique_ptr[c.Analysis] ptr = c.AnalysisLoader_getAnalysis(name)
	cdef Analysis pyobj = Analysis.__new__(Analysis)
	if not ptr:
	return None
	pyobj._ptr = move(ptr)
	# Create python object
	return pyobj


	def getAnalysisLibPaths():
	return c.getAnalysisLibPaths()

	def setAnalysisLibPaths(xs):
	c.setAnalysisLibPaths(xs)

	def addAnalysisLibPath(path):
	c.addAnalysisLibPath(path)


	-def getAnalysisRefPaths():
	- return c.getAnalysisRefPaths()
	+def setAnalysisDataPaths(xs):
	+ c.setAnalysisDataPaths(xs)

	-def findAnalysisRefFile(q):
	- return c.findAnalysisRefFile(q)
	-
	+def addAnalysisDataPath(path):
	+ c.addAnalysisDataPath(path)

	def getAnalysisDataPaths():
	return c.getAnalysisDataPaths()

	def findAnalysisDataFile(q):
	return c.findAnalysisDataFile(q)


	+def getAnalysisRefPaths():
	+ return c.getAnalysisRefPaths()
	+
	+def findAnalysisRefFile(q):
	+ return c.findAnalysisRefFile(q)
	+
	+
	def getAnalysisInfoPaths():
	return c.getAnalysisInfoPaths()

	def findAnalysisInfoFile(q):
	return c.findAnalysisInfoFile(q)


	def getAnalysisPlotPaths():
	return c.getAnalysisPlotPaths()

	def findAnalysisPlotFile(q):
	return c.findAnalysisPlotFile(q)


	def version():
	return c.version()

	def setLogLevel(name, level):
	c.setLogLevel(name, level)
	diff --git a/pyext/rivet/plotinfo.py b/pyext/rivet/plotinfo.py
	--- a/pyext/rivet/plotinfo.py
	+++ b/pyext/rivet/plotinfo.py
	@@ -1,214 +1,229 @@
	import os, re
	from .util import texpand

	class PlotParser(object):
	"""
	Reads Rivet's .plot files and determines which attributes to apply to each histo path.
	"""

	pat_begin_block = re.compile(r'^(#\s)?BEGIN (\w+) ?(\S+)?')
	pat_end_block = re.compile(r'^(#\s)?END (\w+)')
	pat_comment = re.compile(r'^\s#\|^\s$')
	pat_property = re.compile(r'^(\w+?)\s=\s(.*)$')
	pat_path_property = re.compile(r'^(\S+?)::(\w+?)=(.*)$')
	pat_paths = {}

	def __init__(self, plotpaths=None, addfiles=[]):
	"""
	Parameters
	----------
	plotpaths : list of str, optional
	The directories to search for .plot files.
	The default is to call the rivet.getAnalysisPlotPaths() function to get
	the directory where the .plot files can be found. (Usually equivalent to calling :command:`rivet-config --datadir`)

	Raises
	------
	ValueError
	If `plotpaths` is not specified and calling
	:command:`rivet-config` fails.
	"""
	self.addfiles = addfiles

	self.plotpaths = plotpaths
	if not self.plotpaths:
	try:
	import rivet
	self.plotpaths = rivet.getAnalysisPlotPaths()
	except Exception, e:
	sys.stderr.write("Failed to load Rivet analysis plot paths: %s\n" % e)
	raise ValueError("No plot paths given and the rivet module could not be loaded!")


	def getSection(self, section, hpath):
	"""Get a section for a histogram from a .plot file.

	Parameters
	----------
	section : ('PLOT'\|'SPECIAL'\|'HISTOGRAM')
	The section that should be extracted.
	hpath : str
	The histogram path, i.e. /AnalysisID/HistogramID .

	TODO:
	* Caching! The result of the lookup is not cached so every call requires a file to be searched for and opened.
	"""
	if section not in ['PLOT', 'SPECIAL', 'HISTOGRAM']:
	raise ValueError("Can't parse section \'%s\'" % section)

	## Decompose the histo path and remove the /REF prefix if necessary
	from rivet.aopaths import AOPath
	try:
	aop = AOPath(hpath)
	except:
	print "Found analysis object with non-standard path structure:", hpath, "... skipping"
	return None
	# TODO: needed?
	# if len(parts) == 1:
	# parts.insert(0, "ANALYSIS")
	# TODO: why only taking the last 2 parts?
	# hpath = "/" + "/".join(aop.basepathparts[-2:])

	## Assemble the list of headers from any matching plotinfo paths and additional style files
	plotfile = aop.basepathparts()[0] + ".plot"
	ret = {'PLOT': {}, 'SPECIAL': None, 'HISTOGRAM': {}}
	for pidir in self.plotpaths:
	plotpath = os.path.join(pidir, plotfile)
	# self._readHeadersFromFile(plotpath, ret, section, hpath)
	self._readHeadersFromFile(plotpath, ret, section, aop.basepath())
	## Don't break here: we can collect settings from multiple .plot files
	# TODO: So the last path wins? Hmm... reverse the loop order?
	# TODO: Also, is it good that the user-specific extra files override the official ones? Depends on the point of the extra files...
	for extrafile in self.addfiles:
	self._readHeadersFromFile(extrafile, ret, section, hpath)
	return ret[section]


	def _readHeadersFromFile(self, plotfile, ret, section, hpath):
	"""Get a section for a histogram from a .plot file."""
	if not os.access(plotfile, os.R_OK):
	return
	startreading = False
	f = open(plotfile)
	+ msec = None
	for line in f:
	m = self.pat_begin_block.match(line)
	if m:
	tag, pathpat = m.group(2,3)
	- #print tag, pathpat
	# pathpat could be a regex
	if not self.pat_paths.has_key(pathpat):
	self.pat_paths[pathpat] = re.compile(pathpat)
	if tag == section:
	- if self.pat_paths[pathpat].match(hpath):
	+ m2 = self.pat_paths[pathpat].match(hpath)
	+ if m2:
	+ msec = m2
	startreading = True
	if section in ['SPECIAL']:
	ret[section] = ''
	continue
	if not startreading:
	continue
	if self.isEndMarker(line, section):
	startreading = False
	continue
	elif self.isComment(line):
	continue
	if section in ['PLOT', 'HISTOGRAM']:
	vm = self.pat_property.match(line)
	if vm:
	prop, value = vm.group(1,2)
	- #print prop, value
	- ret[section][prop] = texpand(value)
	+ if msec:
	+ oldval = value
	+ try:
	+ ## First escape backslashes except regex groups, then expand regex groups from path match
	+ #print "\n", value
	+ value = value.encode("string-escape")
	+ #print value
	+ value = re.sub("(\\\\)(\\d)", "\\2", value) #< r-strings actually made this harder, since the \) is still treated as an escape!
	+ #print value
	+ value = msec.expand(value)
	+ #print value
	+ except Exception as e:
	+ #print e
	+ value = oldval #< roll back escapes if it goes wrong
	+ ret[section][prop] = texpand(value) #< expand TeX shorthands
	elif section in ['SPECIAL']:
	ret[section] += line
	f.close()


	def getHeaders(self, hpath):
	"""Get the plot headers for histogram hpath.

	This returns the PLOT section.

	Parameters
	----------
	hpath : str
	The histogram path, i.e. /AnalysisID/HistogramID .

	Returns
	-------
	plot_section : dict
	The dictionary usually contains the 'Title', 'XLabel' and
	'YLabel' properties of the respective plot.

	See also
	--------
	:meth:`getSection`
	"""
	return self.getSection('PLOT', hpath)
	## Alias
	getPlot = getHeaders


	def getSpecial(self, hpath):
	"""Get a SPECIAL section for histogram hpath.

	The SPECIAL section is only available in a few analyses.

	Parameters
	----------
	hpath : str
	Histogram path. Must have the form /AnalysisID/HistogramID .

	See also
	--------
	:meth:`getSection`
	"""
	return self.getSection('SPECIAL', hpath)


	def getHistogramOptions(self, hpath):
	"""Get a HISTOGRAM section for histogram hpath.

	The HISTOGRAM section is only available in a few analyses.

	Parameters
	----------
	hpath : str
	Histogram path. Must have the form /AnalysisID/HistogramID .

	See also
	--------
	:meth:`getSection`
	"""
	return self.getSection('HISTOGRAM', hpath)


	def isEndMarker(self, line, blockname):
	m = self.pat_end_block.match(line)
	return m and m.group(2) == blockname


	def isComment(self, line):
	return self.pat_comment.match(line) is not None


	def updateHistoHeaders(self, hist):
	headers = self.getHeaders(hist.histopath)
	if headers.has_key("Title"):
	hist.title = headers["Title"]
	if headers.has_key("XLabel"):
	hist.xlabel = headers["XLabel"]
	if headers.has_key("YLabel"):
	hist.ylabel = headers["YLabel"]


	def mkStdPlotParser(dirs=None, addfiles=[]):
	"""
	Make a PlotParser with the standard Rivet .plot locations automatically added to
	the manually set plot info dirs and additional files.
	"""
	if dirs is None:
	dirs = []
	from .core import getAnalysisPlotPaths
	dirs += getAnalysisPlotPaths()
	seen = set()
	dirs = [d for d in dirs if d not in seen and not seen.add(d)]
	return PlotParser(dirs, addfiles)
	diff --git a/pyext/rivet/rivet.pxd b/pyext/rivet/rivet.pxd
	--- a/pyext/rivet/rivet.pxd
	+++ b/pyext/rivet/rivet.pxd
	@@ -1,84 +1,91 @@
	from libcpp.map cimport map
	from libcpp.pair cimport pair
	from libcpp.vector cimport vector
	from libcpp cimport bool
	from libcpp.string cimport string
	from libcpp.memory cimport unique_ptr

	ctypedef int PdgId
	ctypedef pair[PdgId,PdgId] PdgIdPair

	cdef extern from "Rivet/AnalysisHandler.hh" namespace "Rivet":
	cdef cppclass AnalysisHandler:
	void setIgnoreBeams(bool)
	AnalysisHandler& addAnalysis(string)
	+ vector[string] analysisNames() const
	+ # Analysis* analysis(string)
	void writeData(string&)
	double crossSection()
	void finalize()

	cdef extern from "Rivet/Run.hh" namespace "Rivet":
	cdef cppclass Run:
	Run(AnalysisHandler)
	Run& setCrossSection(double) # For chaining?
	Run& setListAnalyses(bool)
	bool init(string, double) # $2=1.0
	bool openFile(string, double) # $2=1.0
	bool readEvent()
	+ bool skipEvent()
	bool processEvent()
	bool finalize()

	cdef extern from "Rivet/Analysis.hh" namespace "Rivet":
	cdef cppclass Analysis:
	vector[PdgIdPair]& requiredBeams()
	vector[pair[double, double]] requiredEnergies()
	vector[string] authors()
	vector[string] references()
	+ vector[string] keywords()
	string name()
	string bibTeX()
	string bibKey()
	string collider()
	string description()
	string experiment()
	string inspireId()
	string spiresId()
	string runInfo()
	string status()
	string summary()
	string year()
	+ string luminosityfb()

	# Might need to translate the following errors, although I believe 'what' is now
	# preserved. But often, we need the exception class name.
	#Error
	#RangeError
	#LogicError
	#PidError
	#InfoError
	#WeightError
	#UserError

	cdef extern from "Rivet/AnalysisLoader.hh":
	vector[string] AnalysisLoader_analysisNames "Rivet::AnalysisLoader::analysisNames" ()
	unique_ptr[Analysis] AnalysisLoader_getAnalysis "Rivet::AnalysisLoader::getAnalysis" (string)

	cdef extern from "Rivet/Tools/RivetPaths.hh" namespace "Rivet":
	vector[string] getAnalysisLibPaths()
	void setAnalysisLibPaths(vector[string])
	void addAnalysisLibPath(string)

	vector[string] getAnalysisDataPaths()
	- string findAnalysisRefFile(string)
	+ void setAnalysisDataPaths(vector[string])
	+ void addAnalysisDataPath(string)
	+ string findAnalysisDataFile(string)

	vector[string] getAnalysisRefPaths()
	- string findAnalysisDataFile(string)
	+ string findAnalysisRefFile(string)

	vector[string] getAnalysisInfoPaths()
	string findAnalysisInfoFile(string)

	vector[string] getAnalysisPlotPaths()
	string findAnalysisPlotFile(string)

	cdef extern from "Rivet/Rivet.hh" namespace "Rivet":
	string version()

	cdef extern from "Rivet/Tools/Logging.hh":
	void setLogLevel "Rivet::Log::setLevel" (string, int)
	diff --git a/pyext/rivet/util.py b/pyext/rivet/util.py
	--- a/pyext/rivet/util.py
	+++ b/pyext/rivet/util.py
	@@ -1,195 +1,204 @@
	"Python utility functions for use by Rivet scripts (and anyone else who wants to)"


	def check_python_version(req_version=(2,6,0)):
	"Enforce the Rivet scripts' minimal Python version requirement"
	import sys
	if sys.version_info[:3] < req_version:
	sys.stderr.write( "Python version >= %s is required... exiting\n" % ".".join(req_version) )
	sys.exit(1)


	def set_process_name(name):
	"Try to rename the process on Linux so it doesn't appear as 'python <scriptpath>'"
	try:
	## Try to use this: https://code.google.com/p/py-setproctitle/
	import setproctitle
	setproctitle.setproctitle(name)
	except:
	try:
	## Fall back to a by-hand thing that doesn't work for me...
	import ctypes
	libc = ctypes.cdll.LoadLibrary("libc.so.6")
	libc.prctl(15, name, 0, 0, 0)
	except:
	## And then give up ;-)
	pass


	def import_ET():
	"Try to import the ElementTree XML parser, which has many historical import signatures"
	ET = None
	try:
	import xml.etree.cElementTree as ET
	except ImportError:
	try:
	import cElementTree as ET
	except ImportError:
	try:
	import xml.etree.ElementTree as ET
	except:
	raise ImportError("Can't load the ElementTree XML parser (any of three historical ways)")
	return ET


	def htmlify(s, para=False):
	"""Modify LaTeX text strings from analysis metadata for inclusion
	in MathJax-enabled web page source code."""
	if not s:
	return s
	t = s.replace("&", "&")\
	.replace("<","<")\
	.replace(">",">")\
	.replace(r"~", " ")
	t = t.replace(r"\pT", r"p_\perp")\
	.replace(r"\degree", r"^\circ")\
	.replace(r"\MeV", r"\text{MeV}")\
	.replace(r"\GeV", r"\text{GeV}")\
	.replace(r"\TeV", r"\text{TeV}")
	# t = t.replace(r"\;", " ")\
	# .replace(r"\,", " ")\
	# .replace(r"\!", "")
	if para:
	t = t.replace("\n\n", "</p><p>")
	return t


	def texify(s):
	"Insert required TeX escapes"
	if not s:
	return s
	t = s \
	.replace(r"&", r"\&") \
	.replace(r"\\&", r"\&") \
	.replace(r"#", r"\#") \
	# .replace(r"_", r"\_") \
	# .replace(r"^", r"") \
	return t


	def texpand(s):
	"Expand some physics-specific TeX macros."
	if not s:
	return s
	t = s \
	.replace(r"\kT", r"\ensuremath{k_\perp}\xspace") \
	.replace(r"\kt", r"\ensuremath{k_\mathrm{T}}\xspace") \
	.replace(r"\pT", r"\ensuremath{p_\perp}\xspace") \
	.replace(r"\pt", r"\ensuremath{p_\mathrm{T}}\xspace") \
	.replace(r"\sqrts", r"\ensuremath{\sqrt{s}}\xspace") \
	.replace(r"\sqrtS", r"\ensuremath{\sqrt{s}}\xspace") \
	- .replace(r"\MeV", r"\ensuremath{\text{M\eV}}\xspace") \
	- .replace(r"\GeV", r"\ensuremath{\text{G\eV}}\xspace") \
	- .replace(r"\TeV", r"\ensuremath{\text{T\eV}}\xspace") \
	- .replace(r"\eV", r"\ensuremath{\text{e\kern-0.15ex{}V}}\xspace")
	+ .replace(r"\MeV", r"\text{M\eV}\xspace") \
	+ .replace(r"\GeV", r"\text{G\eV}\xspace") \
	+ .replace(r"\TeV", r"\text{T\eV}\xspace") \
	+ .replace(r"\eV", r"\text{e\kern-0.15ex{}V}\xspace")
	return t


	def detex(tex):
	"""Use pandoc (if available) to modify LaTeX text strings from
	analysis metadata for use as plain text, e.g. as printed to the terminal.

	- TODO: Maybe group many strings to be processed together, to save on system call / pandoc startup?
	+ The argument can either be a string or an iterable of strings.
	+
	+ TODO: Replace \gamma, \mu, \tau, \Upsilon, \rho, \psi, \pi, \eta, \Delta, \Omega, \omega -> no-\ form?
	+ TODO: Replace e^+- -> e+-?
	"""
	if not tex:
	return tex
	from distutils.spawn import find_executable
	if not find_executable("pandoc"):
	return tex
	texheader = r"""
	\newcommand{\text}[1]{#1}
	\newcommand{\ensuremath}[1]{#1}
	\newcommand{\emph}[1]{_#1_}
	\newcommand{\textrm}[1]{#1}
	\newcommand{\textit}[1]{_#1_}
	\newcommand{\textbf}[1]{#1}
	\newcommand{\mathrm}[1]{#1}
	\newcommand{\mathit}[1]{_#1_}
	\newcommand{\mathbf}[1]{#1}
	\newcommand{\bm}[1]{#1}
	\newcommand{\frac}[2]{#1/#2}
	\newcommand{\sqrt}[1]{sqrt(#1)}
	\newcommand{\hat}[1]{#1hat}
	\newcommand{\bar}[1]{#1bar}
	\newcommand{\d}[1]{d#1}
	\newcommand{\degree}{^\circ }
	\newcommand{\infty}{oo }
	\newcommand{\exp}{exp }
	\newcommand{\log}{log }
	\newcommand{\ln}{ln }
	\newcommand{\sin}{sin }
	\newcommand{\cos}{cos }
	\newcommand{\tan}{tan }
	\newcommand{\sinh}{sinh }
	\newcommand{\cosh}{cosh }
	\newcommand{\tanh}{tanh }
	\newcommand{\ell}{l}
	\newcommand{\varphi}{\phi}
	\newcommand{\varepsilon}{\epsilon}
	\newcommand{\sim}{~}
	\newcommand{\lesssim}{<~ }
	\newcommand{\gtrsim}{>~ }
	\newcommand{\neq}{!= }
	\newcommand{\ge}{>= }
	\newcommand{\gg}{>> }
	\newcommand{\le}{<= }
	\newcommand{\ll}{<< }
	\newcommand{\pm}{+- }
	\newcommand{\mp}{-+ }
	\newcommand{\times}{x }
	\newcommand{\cdot}{. }
	\newcommand{\dots}{... }
	\newcommand{\ldots}{... }
	\newcommand{\langle}{<}
	\newcommand{\rangle}{>}
	\newcommand{\gets}{<- }
	\newcommand{\to}{-> }
	\newcommand{\leftarrow}{<- }
	\newcommand{\rightarrow}{-> }
	\newcommand{\leftrightarrow}{<-> }
	\newcommand{\Leftarrow}{<= }
	\newcommand{\Rightarrow}{=> }
	\newcommand{\Leftrightarrow}{ }
	\newcommand{\left}{}
	\newcommand{\right}{}
	\newcommand{\!}{}
	\newcommand{\/}{}
	\newcommand{\rm}{}
	\newcommand{\it}{}
	\newcommand{\,}{ }
	\newcommand{\;}{ }
	\newcommand{\ }{ }
	\newcommand{\unit}[2]{#1 #2}
	\newcommand{\bar}[1]{#1bar}
	\newcommand{\pT}{pT }
	\newcommand{\perp}{T}
	\newcommand{\ast}{*}
	\newcommand{\MeV}{MeV }
	\newcommand{\GeV}{GeV }
	\newcommand{\TeV}{TeV }
	"""
	import subprocess, shlex
	- p = subprocess.Popen(shlex.split("pandoc -f latex -t plain --no-wrap"),
	- stdin=subprocess.PIPE, stdout=subprocess.PIPE)
	- plain, err = p.communicate((texheader + tex).replace("\n", ""))
	- plain = plain.replace(r"\&", "&")
	- # TODO: Replace \gamma, \mu, \tau, \Upsilon, \rho, \psi, \pi, \eta, \Delta, \Omega, \omega -> no-\ form?
	- # TODO: Replace e^+- -> e+-?
	- if plain[-1] == "\n":
	- return plain[:-1]
	- elif plain:
	- return plain
	+ nowrap_flags = "--wrap=none"
	+ x = subprocess.Popen(["pandoc", nowrap_flags, "/dev/null"],
	+ stdout=subprocess.PIPE, stderr=subprocess.PIPE).wait()
	+ if x != 0:
	+ nowrap_flags = "--no-wrap"
	+ p = subprocess.Popen(shlex.split("pandoc -f latex -t plain " + nowrap_flags),
	+ stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
	+ texbody = tex if type(tex) is str else "@@".join(tex)
	+ # texbody = texbody.replace("$", "")
	+ plain, err = p.communicate((texheader + texbody).replace("\n", ""))
	+ plain = plain.replace("\n", "")
	+ plains = plain.replace(r"\&", "&").split("@@")
	+ if type(tex) is str:
	+ assert len(plains) == 1
	+ return plains[0] if plains[0] else tex
	else:
	- return tex
	+ return plains if plains else tex

	-#print detex(r"Foo \! $\int \text{bar} \d{x} \sim \; \frac{1}{3} \neq \emph{foo}$ \to \gg bar")
	+# print detex(r"Foo \! $\int \text{bar} \d{x} \sim \; \frac{1}{3} \neq \emph{foo}$ \to \gg bar")
	+# print detex([r"Foo \! $\int \text{bar} \d{x} \sim", r"\frac{1}{3} \neq \emph{foo}$ \to \gg bar"])
	diff --git a/pyext/setup.py.in b/pyext/setup.py.in
	--- a/pyext/setup.py.in
	+++ b/pyext/setup.py.in
	@@ -1,48 +1,48 @@
	#! /usr/bin/env python

	from distutils.core import setup
	from distutils.extension import Extension
	from glob import glob

	## Extension definition
	import os.path
	srcincdir = os.path.abspath("@top_srcdir@/include")
	buildincdir = os.path.abspath("@top_builddir@/include")
	srcdir = os.path.abspath("@top_srcdir@/src")
	libdir = os.path.abspath("@top_builddir@/src/.libs")

	## Assemble the library search dirs
	lookupdirs = [
	libdir,
	"@HEPMCLIBPATH@",
	"@FASTJETLIBPATH@",
	"@YODALIBPATH@" ]

	## Be careful with extracting the GSL path from the flags string
	import re
	re_libdirflag = re.compile(r".-L\s(\S+).*")
	re_match = re_libdirflag.search("@GSL_LDFLAGS@")
	if re_match:
	lookupdirs.append( re_match.group(1) )

	## A helper function (since we have two modules now...)
	def ext(name, depends=[], statics=[]):
	return Extension(
	"rivet.%s" % name,
	["rivet/%s.cpp" % name] + statics,
	language="c++",
	depends=depends,
	include_dirs=[srcincdir, buildincdir],
	- extra_compile_args="-std=c++11 -I@prefix@/include @PYEXT_CXXFLAGS@ @HEPMCCPPFLAGS@ @FASTJETCPPFLAGS@ @YODACPPFLAGS@ @GSLCPPFLAGS@".split(),
	+ extra_compile_args="-I@prefix@/include @PYEXT_CXXFLAGS@ @HEPMCCPPFLAGS@ @FASTJETCPPFLAGS@ @YODACPPFLAGS@ @GSLCPPFLAGS@".split(),
	library_dirs=lookupdirs,
	runtime_library_dirs=lookupdirs[1:],
	libraries=["gsl", "HepMC", "fastjet", "YODA", "Rivet"])

	header_files = glob("../include/Rivet/.h") + glob("../include/Rivet/Utils/.h")

	extns = [ext("core", header_files)]

	setup(name = "rivet",
	version="@PACKAGE_VERSION@",
	ext_modules = extns,
	packages = ["rivet"])
	diff --git a/src/Analyses/ALEPH_1991_S2435284.cc b/src/Analyses/ALEPH_1991_S2435284.cc
	--- a/src/Analyses/ALEPH_1991_S2435284.cc
	+++ b/src/Analyses/ALEPH_1991_S2435284.cc
	@@ -1,62 +1,62 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	/// @brief ALEPH LEP1 charged multiplicity in hadronic Z decay
	/// @author Andy Buckley
	class ALEPH_1991_S2435284 : public Analysis {
	public:

	/// Constructor.
	ALEPH_1991_S2435284()
	: Analysis("ALEPH_1991_S2435284")
	{
	}


	/// @name Analysis methods
	//@{

	/// Book projections and histogram
	void init() {
	const ChargedFinalState cfs;
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	_histChTot = bookHisto1D(1, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& event) {
	- const FinalState& cfs = applyProjection<FinalState>(event, "CFS");
	+ const FinalState& cfs = apply<FinalState>(event, "CFS");
	MSG_DEBUG("Total charged multiplicity = " << cfs.size());
	_histChTot->fill(cfs.size(), event.weight());
	}


	/// Normalize the histogram
	void finalize() {
	scale(_histChTot, 2.0/sumOfWeights()); // same as in ALEPH 1996
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _histChTot;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALEPH_1991_S2435284);

	}
	diff --git a/src/Analyses/ALEPH_1995_I382179.cc b/src/Analyses/ALEPH_1995_I382179.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ALEPH_1995_I382179.cc
	@@ -0,0 +1,98 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+#include "Rivet/Projections/Beam.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief ALEPH pi+-, K+-, p and pbar differential cross-sections at the Z peak
	+ class ALEPH_1995_I382179 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ALEPH_1995_I382179);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+
	+ // Book histograms
	+ _histXpPion = bookHisto1D( 1, 1, 1);
	+ _histXpKaon = bookHisto1D( 2, 1, 1);
	+ _histXpProton = bookHisto1D( 3, 1, 1);
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	+ if (fs.particles().size() < 2) {
	+ MSG_DEBUG("Failed ncharged cut");
	+ vetoEvent;
	+ }
	+ MSG_DEBUG("Passed ncharged cut");
	+
	+ // Get event weight for histo filling
	+ const double weight = event.weight();
	+
	+ // Get beams and average beam momentum
	+ const ParticlePair& beams = apply<Beam>(event, "Beams").beams();
	+ const double meanBeamMom = ( beams.first.p3().mod() + beams.second.p3().mod() ) / 2.0;
	+ MSG_DEBUG("Avg beam momentum = " << meanBeamMom);
	+
	+ foreach (const Particle& p, fs.particles()) {
	+ int id = p.abspid();
	+ // charged pions
	+ if (id == PID::PIPLUS \|\| id == PID::PIMINUS) {
	+ _histXpPion->fill(p.p3().mod()/meanBeamMom, weight);
	+ } else if(id == PID::KPLUS \|\| id == PID::KMINUS) {
	+ _histXpKaon->fill(p.p3().mod()/meanBeamMom, weight);
	+ } else if(id == PID::PROTON \|\| id == PID::ANTIPROTON) {
	+ _histXpProton->fill(p.p3().mod()/meanBeamMom, weight);
	+ }
	+ }
	+
	+
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ scale(_histXpPion, 1./sumOfWeights());
	+ scale(_histXpKaon, 1./sumOfWeights());
	+ scale(_histXpProton, 1./sumOfWeights());
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+
	+ /// @name Histograms
	+ Histo1DPtr _histXpPion;
	+ Histo1DPtr _histXpKaon;
	+ Histo1DPtr _histXpProton;
	+
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ALEPH_1995_I382179);
	+
	+
	+}
	diff --git a/src/Analyses/ALEPH_1996_S3196992.cc b/src/Analyses/ALEPH_1996_S3196992.cc
	--- a/src/Analyses/ALEPH_1996_S3196992.cc
	+++ b/src/Analyses/ALEPH_1996_S3196992.cc
	@@ -1,156 +1,156 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/Thrust.hh"

	namespace Rivet {


	/// @brief ALEPH measurement of quark-to-photon fragmentation function
	class ALEPH_1996_S3196992 : public Analysis {
	public:

	/// Constructor
	ALEPH_1996_S3196992()
	: Analysis("ALEPH_1996_S3196992")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	FinalState fs;
	- addProjection(FastJets(fs, FastJets::DURHAM, 0.7), "DurhamJets");
	+ declare(FastJets(fs, FastJets::DURHAM, 0.7), "DurhamJets");
	IdentifiedFinalState ifs; //(Cuts::pT > 0);
	ifs.acceptId(PID::PHOTON);
	- addProjection(ifs, "Photons");
	- addProjection(Thrust(fs), "Thrust");
	- addProjection(ChargedFinalState(), "CFS");
	+ declare(ifs, "Photons");
	+ declare(Thrust(fs), "Thrust");
	+ declare(ChargedFinalState(), "CFS");

	// Book histograms
	_h_z_2jet_001 = bookHisto1D(1, 1, 1);
	_h_z_2jet_006 = bookHisto1D(2, 1, 1);
	_h_z_2jet_01 = bookHisto1D(3, 1, 1);
	_h_z_2jet_033 = bookHisto1D(4, 1, 1);
	_h_z_3jet_001 = bookHisto1D(5, 1, 1);
	_h_z_3jet_006 = bookHisto1D(6, 1, 1);
	_h_z_3jet_01 = bookHisto1D(7, 1, 1);
	_h_z_4jet_001 = bookHisto1D(8, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	- if (applyProjection<FinalState>(event, "CFS").particles().size() < 2) vetoEvent;
	+ if (apply<FinalState>(event, "CFS").particles().size() < 2) vetoEvent;

	- const Particles allphotons = applyProjection<IdentifiedFinalState>(event, "Photons").particles();
	+ const Particles allphotons = apply<IdentifiedFinalState>(event, "Photons").particles();
	Particles photons;
	for (const Particle& photon : allphotons)
	if (fabs(cos(photon.theta())) < 0.95 && photon.E() > 5.0*GeV)
	photons.push_back(photon);
	if (photons.size() < 1) vetoEvent;

	- const Thrust& thrust = applyProjection<Thrust>(event, "Thrust");
	+ const Thrust& thrust = apply<Thrust>(event, "Thrust");
	if (fabs(cos(thrust.thrustAxis().theta()))>0.95) vetoEvent;

	- const FastJets& durjet = applyProjection<FastJets>(event, "DurhamJets");
	+ const FastJets& durjet = apply<FastJets>(event, "DurhamJets");


	const double weight = event.weight();
	for (const Particle& photon : photons) {

	PseudoJets jets_001 = durjet.clusterSeq()->exclusive_jets_ycut(0.01);
	for (const fastjet::PseudoJet& jet : jets_001) {
	if (particleInJet(photon, jet)) {
	double zgamma = photon.E()/jet.E();
	if (jets_001.size() == 2) _h_z_2jet_001->fill(zgamma, weight);
	else if (jets_001.size() == 3) _h_z_3jet_001->fill(zgamma, weight);
	else if (jets_001.size() > 3) _h_z_4jet_001->fill(zgamma, weight);
	break;
	}
	}

	PseudoJets jets_006 = durjet.clusterSeq()->exclusive_jets_ycut(0.06);
	for (const fastjet::PseudoJet& jet : jets_006) {
	if (particleInJet(photon, jet)) {
	double zgamma = photon.E()/jet.E();
	if (jets_006.size() == 2) _h_z_2jet_006->fill(zgamma, weight);
	else if (jets_006.size() == 3) _h_z_3jet_006->fill(zgamma, weight);
	break;
	}
	}

	PseudoJets jets_01 = durjet.clusterSeq()->exclusive_jets_ycut(0.1);
	for (const fastjet::PseudoJet& jet : jets_01) {
	if (particleInJet(photon, jet)) {
	double zgamma = photon.E()/jet.E();
	if (jets_01.size() == 2) _h_z_2jet_01->fill(zgamma, weight);
	else if (jets_01.size() == 3) _h_z_3jet_01->fill(zgamma, weight);
	break;
	}
	}

	PseudoJets jets_033 = durjet.clusterSeq()->exclusive_jets_ycut(0.33);
	for (const fastjet::PseudoJet& jet : jets_033) {
	if (particleInJet(photon, jet)) {
	double zgamma = photon.E()/jet.E();
	if (jets_033.size() == 2) _h_z_2jet_033->fill(zgamma, weight);
	break;
	}
	}

	}
	}


	bool particleInJet(const Particle& p, const fastjet::PseudoJet& jet) {
	for (const fastjet::PseudoJet& jetpart : jet.constituents()) {
	if (fuzzyEquals(jetpart.E(), p.E()) &&
	fuzzyEquals(jetpart.px(), p.px()) &&
	fuzzyEquals(jetpart.py(), p.py()) &&
	fuzzyEquals(jetpart.pz(), p.pz())) {
	return true;
	}
	}
	return false;
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_z_2jet_001, 1000.0/sumOfWeights());
	scale(_h_z_2jet_006, 1000.0/sumOfWeights());
	scale(_h_z_2jet_01, 1000.0/sumOfWeights());
	scale(_h_z_2jet_033, 1000.0/sumOfWeights());
	scale(_h_z_3jet_001, 1000.0/sumOfWeights());
	scale(_h_z_3jet_006, 1000.0/sumOfWeights());
	scale(_h_z_3jet_01, 1000.0/sumOfWeights());
	scale(_h_z_4jet_001, 1000.0/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_z_2jet_001, _h_z_2jet_006, _h_z_2jet_01, _h_z_2jet_033;
	Histo1DPtr _h_z_3jet_001, _h_z_3jet_006, _h_z_3jet_01;
	Histo1DPtr _h_z_4jet_001;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALEPH_1996_S3196992);


	}
	diff --git a/src/Analyses/ALEPH_1996_S3486095.cc b/src/Analyses/ALEPH_1996_S3486095.cc
	--- a/src/Analyses/ALEPH_1996_S3486095.cc
	+++ b/src/Analyses/ALEPH_1996_S3486095.cc
	@@ -1,557 +1,557 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/Sphericity.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ParisiTensor.hh"
	#include "Rivet/Projections/Hemispheres.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief ALEPH QCD study with event shapes and identified particles
	/// @author Holger Schulz
	class ALEPH_1996_S3486095 : public Analysis {

	public:

	/// Constructor
	ALEPH_1996_S3486095()
	: Analysis("ALEPH_1996_S3486095")
	{
	_numChParticles = 0;
	_weightedTotalPartNum = 0;
	_weightedTotalNumPiPlus = 0;
	_weightedTotalNumKPlus = 0;
	_weightedTotalNumP = 0;
	_weightedTotalNumPhoton = 0;
	_weightedTotalNumPi0 = 0;
	_weightedTotalNumEta = 0;
	_weightedTotalNumEtaPrime = 0;
	_weightedTotalNumK0 = 0;
	_weightedTotalNumLambda0 = 0;
	_weightedTotalNumXiMinus = 0;
	_weightedTotalNumSigma1385Plus= 0;
	_weightedTotalNumXi1530_0 = 0;
	_weightedTotalNumRho = 0;
	_weightedTotalNumOmega782 = 0;
	_weightedTotalNumKStar892_0 = 0;
	_weightedTotalNumPhi = 0;
	_weightedTotalNumKStar892Plus = 0;
	}


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	- addProjection(Beam(), "Beams");
	+ declare(Beam(), "Beams");
	const ChargedFinalState cfs;
	- addProjection(cfs, "FS");
	- addProjection(UnstableFinalState(), "UFS");
	- addProjection(FastJets(cfs, FastJets::DURHAM, 0.7), "DurhamJets");
	- addProjection(Sphericity(cfs), "Sphericity");
	- addProjection(ParisiTensor(cfs), "Parisi");
	+ declare(cfs, "FS");
	+ declare(UnstableFinalState(), "UFS");
	+ declare(FastJets(cfs, FastJets::DURHAM, 0.7), "DurhamJets");
	+ declare(Sphericity(cfs), "Sphericity");
	+ declare(ParisiTensor(cfs), "Parisi");
	const Thrust thrust(cfs);
	- addProjection(thrust, "Thrust");
	- addProjection(Hemispheres(thrust), "Hemispheres");
	+ declare(thrust, "Thrust");
	+ declare(Hemispheres(thrust), "Hemispheres");

	// Book histograms
	_histSphericity = bookHisto1D(1, 1, 1);
	_histAplanarity = bookHisto1D(2, 1, 1);

	_hist1MinusT = bookHisto1D(3, 1, 1);
	_histTMinor = bookHisto1D(4, 1, 1);

	_histY3 = bookHisto1D(5, 1, 1);
	_histHeavyJetMass = bookHisto1D(6, 1, 1);
	_histCParam = bookHisto1D(7, 1, 1);
	_histOblateness = bookHisto1D(8, 1, 1);

	_histScaledMom = bookHisto1D(9, 1, 1);
	_histRapidityT = bookHisto1D(10, 1, 1);

	_histPtSIn = bookHisto1D(11, 1, 1);
	_histPtSOut = bookHisto1D(12, 1, 1);

	_histLogScaledMom = bookHisto1D(17, 1, 1);

	_histChMult = bookHisto1D(18, 1, 1);
	_histMeanChMult = bookHisto1D(19, 1, 1);

	_histMeanChMultRapt05= bookHisto1D(20, 1, 1);
	_histMeanChMultRapt10= bookHisto1D(21, 1, 1);
	_histMeanChMultRapt15= bookHisto1D(22, 1, 1);
	_histMeanChMultRapt20= bookHisto1D(23, 1, 1);


	// Particle spectra
	_histMultiPiPlus = bookHisto1D(25, 1, 1);
	_histMultiKPlus = bookHisto1D(26, 1, 1);
	_histMultiP = bookHisto1D(27, 1, 1);
	_histMultiPhoton = bookHisto1D(28, 1, 1);
	_histMultiPi0 = bookHisto1D(29, 1, 1);
	_histMultiEta = bookHisto1D(30, 1, 1);
	_histMultiEtaPrime = bookHisto1D(31, 1, 1);
	_histMultiK0 = bookHisto1D(32, 1, 1);
	_histMultiLambda0 = bookHisto1D(33, 1, 1);
	_histMultiXiMinus = bookHisto1D(34, 1, 1);
	_histMultiSigma1385Plus = bookHisto1D(35, 1, 1);
	_histMultiXi1530_0 = bookHisto1D(36, 1, 1);
	_histMultiRho = bookHisto1D(37, 1, 1);
	_histMultiOmega782 = bookHisto1D(38, 1, 1);
	_histMultiKStar892_0 = bookHisto1D(39, 1, 1);
	_histMultiPhi = bookHisto1D(40, 1, 1);

	_histMultiKStar892Plus = bookHisto1D(43, 1, 1);

	// Mean multiplicities
	_histMeanMultiPi0 = bookHisto1D(44, 1, 2);
	_histMeanMultiEta = bookHisto1D(44, 1, 3);
	_histMeanMultiEtaPrime = bookHisto1D(44, 1, 4);
	_histMeanMultiK0 = bookHisto1D(44, 1, 5);
	_histMeanMultiRho = bookHisto1D(44, 1, 6);
	_histMeanMultiOmega782 = bookHisto1D(44, 1, 7);
	_histMeanMultiPhi = bookHisto1D(44, 1, 8);
	_histMeanMultiKStar892Plus = bookHisto1D(44, 1, 9);
	_histMeanMultiKStar892_0 = bookHisto1D(44, 1, 10);
	_histMeanMultiLambda0 = bookHisto1D(44, 1, 11);
	_histMeanMultiSigma0 = bookHisto1D(44, 1, 12);
	_histMeanMultiXiMinus = bookHisto1D(44, 1, 13);
	_histMeanMultiSigma1385Plus = bookHisto1D(44, 1, 14);
	_histMeanMultiXi1530_0 = bookHisto1D(44, 1, 15);
	_histMeanMultiOmegaOmegaBar = bookHisto1D(44, 1, 16);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();
	_weightedTotalPartNum += numParticles * weight;

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Thrusts
	MSG_DEBUG("Calculating thrust");
	- const Thrust& thrust = applyProjection<Thrust>(e, "Thrust");
	+ const Thrust& thrust = apply<Thrust>(e, "Thrust");
	_hist1MinusT->fill(1 - thrust.thrust(), weight);
	_histTMinor->fill(thrust.thrustMinor(), weight);
	_histOblateness->fill(thrust.oblateness(), weight);

	// Jets
	MSG_DEBUG("Calculating differential jet rate plots:");
	- const FastJets& durjet = applyProjection<FastJets>(e, "DurhamJets");
	+ const FastJets& durjet = apply<FastJets>(e, "DurhamJets");
	if (durjet.clusterSeq()) {
	double y3 = durjet.clusterSeq()->exclusive_ymerge_max(2);
	if (y3>0.0) _histY3->fill(-1. * std::log(y3), weight);
	}

	// Sphericities
	MSG_DEBUG("Calculating sphericity");
	- const Sphericity& sphericity = applyProjection<Sphericity>(e, "Sphericity");
	+ const Sphericity& sphericity = apply<Sphericity>(e, "Sphericity");
	_histSphericity->fill(sphericity.sphericity(), weight);
	_histAplanarity->fill(sphericity.aplanarity(), weight);

	// C param
	MSG_DEBUG("Calculating Parisi params");
	- const ParisiTensor& parisi = applyProjection<ParisiTensor>(e, "Parisi");
	+ const ParisiTensor& parisi = apply<ParisiTensor>(e, "Parisi");
	_histCParam->fill(parisi.C(), weight);

	// Hemispheres
	MSG_DEBUG("Calculating hemisphere variables");
	- const Hemispheres& hemi = applyProjection<Hemispheres>(e, "Hemispheres");
	+ const Hemispheres& hemi = apply<Hemispheres>(e, "Hemispheres");
	_histHeavyJetMass->fill(hemi.scaledM2high(), weight);

	// Iterate over all the charged final state particles.
	double Evis = 0.0;
	double rapt05 = 0.;
	double rapt10 = 0.;
	double rapt15 = 0.;
	double rapt20 = 0.;
	//int numChParticles = 0;
	MSG_DEBUG("About to iterate over charged FS particles");
	foreach (const Particle& p, fs.particles()) {
	// Get momentum and energy of each particle.
	const Vector3 mom3 = p.p3();
	const double energy = p.E();
	Evis += energy;
	_numChParticles += weight;

	// Scaled momenta.
	const double mom = mom3.mod();
	const double scaledMom = mom/meanBeamMom;
	const double logInvScaledMom = -std::log(scaledMom);
	_histLogScaledMom->fill(logInvScaledMom, weight);
	_histScaledMom->fill(scaledMom, weight);

	// Get momenta components w.r.t. thrust and sphericity.
	const double momT = dot(thrust.thrustAxis(), mom3);
	const double pTinS = dot(mom3, sphericity.sphericityMajorAxis());
	const double pToutS = dot(mom3, sphericity.sphericityMinorAxis());
	_histPtSIn->fill(fabs(pTinS/GeV), weight);
	_histPtSOut->fill(fabs(pToutS/GeV), weight);

	// Calculate rapidities w.r.t. thrust.
	const double rapidityT = 0.5 * std::log((energy + momT) / (energy - momT));
	_histRapidityT->fill(fabs(rapidityT), weight);
	if (std::fabs(rapidityT) <= 0.5) {
	rapt05 += 1.0;
	}
	if (std::fabs(rapidityT) <= 1.0) {
	rapt10 += 1.0;
	}
	if (std::fabs(rapidityT) <= 1.5) {
	rapt15 += 1.0;
	}
	if (std::fabs(rapidityT) <= 2.0) {
	rapt20 += 1.0;
	}

	}

	_histChMult->fill(numParticles, weight);

	_histMeanChMultRapt05->fill(_histMeanChMultRapt05->bin(0).xMid(), rapt05 * weight);
	_histMeanChMultRapt10->fill(_histMeanChMultRapt10->bin(0).xMid(), rapt10 * weight);
	_histMeanChMultRapt15->fill(_histMeanChMultRapt15->bin(0).xMid(), rapt15 * weight);
	_histMeanChMultRapt20->fill(_histMeanChMultRapt20->bin(0).xMid(), rapt20 * weight);
	_histMeanChMult->fill(_histMeanChMult->bin(0).xMid(), numParticles*weight);


	//// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	for (Particles::const_iterator p = ufs.particles().begin(); p != ufs.particles().end(); ++p) {
	const Vector3 mom3 = p->momentum().p3();
	int id = abs(p->pid());
	const double mom = mom3.mod();
	const double energy = p->momentum().E();
	const double scaledMom = mom/meanBeamMom;
	const double scaledEnergy = energy/meanBeamMom; // meanBeamMom is approximately beam energy
	switch (id) {
	case 22:
	_histMultiPhoton->fill(-1.*std::log(scaledMom), weight);
	_weightedTotalNumPhoton += weight;
	break;
	case -321:
	case 321:
	_weightedTotalNumKPlus += weight;
	_histMultiKPlus->fill(scaledMom, weight);
	break;
	case 211:
	case -211:
	_histMultiPiPlus->fill(scaledMom, weight);
	_weightedTotalNumPiPlus += weight;
	break;
	case 2212:
	case -2212:
	_histMultiP->fill(scaledMom, weight);
	_weightedTotalNumP += weight;
	break;
	case 111:
	_histMultiPi0->fill(scaledMom, weight);
	_histMeanMultiPi0->fill(_histMeanMultiPi0->bin(0).xMid(), weight);
	_weightedTotalNumPi0 += weight;
	break;
	case 221:
	if (scaledMom >= 0.1) {
	_histMultiEta->fill(scaledEnergy, weight);
	_histMeanMultiEta->fill(_histMeanMultiEta->bin(0).xMid(), weight);
	_weightedTotalNumEta += weight;
	}
	break;
	case 331:
	if (scaledMom >= 0.1) {
	_histMultiEtaPrime->fill(scaledEnergy, weight);
	_histMeanMultiEtaPrime->fill(_histMeanMultiEtaPrime->bin(0).xMid(), weight);
	_weightedTotalNumEtaPrime += weight;
	}
	break;
	case 130: //klong
	case 310: //kshort
	_histMultiK0->fill(scaledMom, weight);
	_histMeanMultiK0->fill(_histMeanMultiK0->bin(0).xMid(), weight);
	_weightedTotalNumK0 += weight;
	break;
	case 113:
	_histMultiRho->fill(scaledMom, weight);
	_histMeanMultiRho->fill(_histMeanMultiRho->bin(0).xMid(), weight);
	_weightedTotalNumRho += weight;
	break;
	case 223:
	_histMultiOmega782->fill(scaledMom, weight);
	_histMeanMultiOmega782->fill(_histMeanMultiOmega782->bin(0).xMid(), weight);
	_weightedTotalNumOmega782 += weight;
	break;
	case 333:
	_histMultiPhi->fill(scaledMom, weight);
	_histMeanMultiPhi->fill(_histMeanMultiPhi->bin(0).xMid(), weight);
	_weightedTotalNumPhi += weight;
	break;
	case 313:
	case -313:
	_histMultiKStar892_0->fill(scaledMom, weight);
	_histMeanMultiKStar892_0->fill(_histMeanMultiKStar892_0->bin(0).xMid(), weight);
	_weightedTotalNumKStar892_0 += weight;
	break;
	case 323:
	case -323:
	_histMultiKStar892Plus->fill(scaledEnergy, weight);
	_histMeanMultiKStar892Plus->fill(_histMeanMultiKStar892Plus->bin(0).xMid(), weight);
	_weightedTotalNumKStar892Plus += weight;
	break;
	case 3122:
	case -3122:
	_histMultiLambda0->fill(scaledMom, weight);
	_histMeanMultiLambda0->fill(_histMeanMultiLambda0->bin(0).xMid(), weight);
	_weightedTotalNumLambda0 += weight;
	break;
	case 3212:
	case -3212:
	_histMeanMultiSigma0->fill(_histMeanMultiSigma0->bin(0).xMid(), weight);
	break;
	case 3312:
	case -3312:
	_histMultiXiMinus->fill(scaledEnergy, weight);
	_histMeanMultiXiMinus->fill(_histMeanMultiXiMinus->bin(0).xMid(), weight);
	_weightedTotalNumXiMinus += weight;
	break;
	case 3114:
	case -3114:
	case 3224:
	case -3224:
	_histMultiSigma1385Plus->fill(scaledEnergy, weight);
	_histMeanMultiSigma1385Plus->fill(_histMeanMultiSigma1385Plus->bin(0).xMid(), weight);
	_weightedTotalNumSigma1385Plus += weight;
	break;
	case 3324:
	case -3324:
	_histMultiXi1530_0->fill(scaledEnergy, weight);
	_histMeanMultiXi1530_0->fill(_histMeanMultiXi1530_0->bin(0).xMid(), weight);
	_weightedTotalNumXi1530_0 += weight;
	break;
	case 3334:
	_histMeanMultiOmegaOmegaBar->fill(_histMeanMultiOmegaOmegaBar->bin(0).xMid(), weight);
	break;
	}
	}

	}



	/// Finalize
	void finalize() {
	// Normalize inclusive single particle distributions to the average number
	// of charged particles per event.
	const double avgNumParts = _weightedTotalPartNum / sumOfWeights();

	normalize(_histPtSIn, avgNumParts);
	normalize(_histPtSOut, avgNumParts);

	normalize(_histRapidityT, avgNumParts);
	normalize(_histY3);

	normalize(_histLogScaledMom, avgNumParts);
	normalize(_histScaledMom, avgNumParts);

	// particle spectra
	scale(_histMultiPiPlus ,1./sumOfWeights());
	scale(_histMultiKPlus ,1./sumOfWeights());
	scale(_histMultiP ,1./sumOfWeights());
	scale(_histMultiPhoton ,1./sumOfWeights());
	scale(_histMultiPi0 ,1./sumOfWeights());
	scale(_histMultiEta ,1./sumOfWeights());
	scale(_histMultiEtaPrime ,1./sumOfWeights());
	scale(_histMultiK0 ,1./sumOfWeights());
	scale(_histMultiLambda0 ,1./sumOfWeights());
	scale(_histMultiXiMinus ,1./sumOfWeights());
	scale(_histMultiSigma1385Plus ,1./sumOfWeights());
	scale(_histMultiXi1530_0 ,1./sumOfWeights());
	scale(_histMultiRho ,1./sumOfWeights());
	scale(_histMultiOmega782 ,1./sumOfWeights());
	scale(_histMultiKStar892_0 ,1./sumOfWeights());
	scale(_histMultiPhi ,1./sumOfWeights());

	scale(_histMultiKStar892Plus ,1./sumOfWeights());

	//normalize(_histMultiPiPlus ,_weightedTotalNumPiPlus / sumOfWeights());
	//normalize(_histMultiKPlus ,_weightedTotalNumKPlus/sumOfWeights());
	//normalize(_histMultiP ,_weightedTotalNumP/sumOfWeights());
	//normalize(_histMultiPhoton ,_weightedTotalNumPhoton/sumOfWeights());
	//normalize(_histMultiPi0 ,_weightedTotalNumPi0/sumOfWeights());
	//normalize(_histMultiEta ,_weightedTotalNumEta/sumOfWeights());
	//normalize(_histMultiEtaPrime ,_weightedTotalNumEtaPrime/sumOfWeights());
	//normalize(_histMultiK0 ,_weightedTotalNumK0/sumOfWeights());
	//normalize(_histMultiLambda0 ,_weightedTotalNumLambda0/sumOfWeights());
	//normalize(_histMultiXiMinus ,_weightedTotalNumXiMinus/sumOfWeights());
	//normalize(_histMultiSigma1385Plus ,_weightedTotalNumSigma1385Plus/sumOfWeights());
	//normalize(_histMultiXi1530_0 ,_weightedTotalNumXi1530_0 /sumOfWeights());
	//normalize(_histMultiRho ,_weightedTotalNumRho/sumOfWeights());
	//normalize(_histMultiOmegaMinus ,_weightedTotalNumOmegaMinus/sumOfWeights());
	//normalize(_histMultiKStar892_0 ,_weightedTotalNumKStar892_0/sumOfWeights());
	//normalize(_histMultiPhi ,_weightedTotalNumPhi/sumOfWeights());

	//normalize(_histMultiKStar892Plus ,_weightedTotalNumKStar892Plus/sumOfWeights());

	// event shape
	normalize(_hist1MinusT);
	normalize(_histTMinor);
	normalize(_histOblateness);

	normalize(_histSphericity);
	normalize(_histAplanarity);
	normalize(_histHeavyJetMass);
	normalize(_histCParam);


	// mean multiplicities
	scale(_histChMult , 2.0/sumOfWeights()); // taking into account the binwidth of 2
	scale(_histMeanChMult , 1.0/sumOfWeights());
	scale(_histMeanChMultRapt05 , 1.0/sumOfWeights());
	scale(_histMeanChMultRapt10 , 1.0/sumOfWeights());
	scale(_histMeanChMultRapt15 , 1.0/sumOfWeights());
	scale(_histMeanChMultRapt20 , 1.0/sumOfWeights());


	scale(_histMeanMultiPi0 , 1.0/sumOfWeights());
	scale(_histMeanMultiEta , 1.0/sumOfWeights());
	scale(_histMeanMultiEtaPrime , 1.0/sumOfWeights());
	scale(_histMeanMultiK0 , 1.0/sumOfWeights());
	scale(_histMeanMultiRho , 1.0/sumOfWeights());
	scale(_histMeanMultiOmega782 , 1.0/sumOfWeights());
	scale(_histMeanMultiPhi , 1.0/sumOfWeights());
	scale(_histMeanMultiKStar892Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiKStar892_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiLambda0 , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma0 , 1.0/sumOfWeights());
	scale(_histMeanMultiXiMinus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma1385Plus, 1.0/sumOfWeights());
	scale(_histMeanMultiXi1530_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiOmegaOmegaBar, 1.0/sumOfWeights());
	}

	//@}


	private:
	/// Store the weighted sums of numbers of charged / charged+neutral
	/// particles - used to calculate average number of particles for the
	/// inclusive single particle distributions' normalisations.
	double _weightedTotalPartNum;
	double _weightedTotalNumPiPlus;
	double _weightedTotalNumKPlus;
	double _weightedTotalNumP;
	double _weightedTotalNumPhoton;
	double _weightedTotalNumPi0;
	double _weightedTotalNumEta;
	double _weightedTotalNumEtaPrime;
	double _weightedTotalNumK0;
	double _weightedTotalNumLambda0;
	double _weightedTotalNumXiMinus;
	double _weightedTotalNumSigma1385Plus;
	double _weightedTotalNumXi1530_0;
	double _weightedTotalNumRho;
	double _weightedTotalNumOmega782;
	double _weightedTotalNumKStar892_0;
	double _weightedTotalNumPhi;
	double _weightedTotalNumKStar892Plus;
	double _numChParticles;

	/// @name Histograms
	//@{
	Histo1DPtr _histSphericity;
	Histo1DPtr _histAplanarity;

	Histo1DPtr _hist1MinusT;
	Histo1DPtr _histTMinor;

	Histo1DPtr _histY3;
	Histo1DPtr _histHeavyJetMass;
	Histo1DPtr _histCParam;
	Histo1DPtr _histOblateness;

	Histo1DPtr _histScaledMom;
	Histo1DPtr _histRapidityT;

	Histo1DPtr _histPtSIn;
	Histo1DPtr _histPtSOut;

	Histo1DPtr _histJetRate2Durham;
	Histo1DPtr _histJetRate3Durham;
	Histo1DPtr _histJetRate4Durham;
	Histo1DPtr _histJetRate5Durham;

	Histo1DPtr _histLogScaledMom;

	Histo1DPtr _histChMult;

	Histo1DPtr _histMultiPiPlus;
	Histo1DPtr _histMultiKPlus;
	Histo1DPtr _histMultiP;
	Histo1DPtr _histMultiPhoton;
	Histo1DPtr _histMultiPi0;
	Histo1DPtr _histMultiEta;
	Histo1DPtr _histMultiEtaPrime;
	Histo1DPtr _histMultiK0;
	Histo1DPtr _histMultiLambda0;
	Histo1DPtr _histMultiXiMinus;
	Histo1DPtr _histMultiSigma1385Plus;
	Histo1DPtr _histMultiXi1530_0;
	Histo1DPtr _histMultiRho;
	Histo1DPtr _histMultiOmega782;
	Histo1DPtr _histMultiKStar892_0;
	Histo1DPtr _histMultiPhi;
	Histo1DPtr _histMultiKStar892Plus;

	// mean multiplicities
	Histo1DPtr _histMeanChMult;
	Histo1DPtr _histMeanChMultRapt05;
	Histo1DPtr _histMeanChMultRapt10;
	Histo1DPtr _histMeanChMultRapt15;
	Histo1DPtr _histMeanChMultRapt20;

	Histo1DPtr _histMeanMultiPi0;
	Histo1DPtr _histMeanMultiEta;
	Histo1DPtr _histMeanMultiEtaPrime;
	Histo1DPtr _histMeanMultiK0;
	Histo1DPtr _histMeanMultiRho;
	Histo1DPtr _histMeanMultiOmega782;
	Histo1DPtr _histMeanMultiPhi;
	Histo1DPtr _histMeanMultiKStar892Plus;
	Histo1DPtr _histMeanMultiKStar892_0;
	Histo1DPtr _histMeanMultiLambda0;
	Histo1DPtr _histMeanMultiSigma0;
	Histo1DPtr _histMeanMultiXiMinus;
	Histo1DPtr _histMeanMultiSigma1385Plus;
	Histo1DPtr _histMeanMultiXi1530_0;
	Histo1DPtr _histMeanMultiOmegaOmegaBar;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALEPH_1996_S3486095);

	}
	diff --git a/src/Analyses/ALEPH_1999_S4193598.cc b/src/Analyses/ALEPH_1999_S4193598.cc
	--- a/src/Analyses/ALEPH_1999_S4193598.cc
	+++ b/src/Analyses/ALEPH_1999_S4193598.cc
	@@ -1,96 +1,96 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {

	class ALEPH_1999_S4193598 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ALEPH_1999_S4193598()
	: Analysis("ALEPH_1999_S4193598")
	{
	_sumWpassed = 0.0;
	}

	//@}


	public:

	/// Book histograms and initialise projections before the run
	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(UnstableFinalState(), "UFS");
	- addProjection(ChargedFinalState(), "CFS");
	+ declare(Beam(), "Beams");
	+ declare(UnstableFinalState(), "UFS");
	+ declare(ChargedFinalState(), "CFS");

	_h_Xe_Ds = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Trigger condition
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	if (cfs.size() < 5) vetoEvent;

	_sumWpassed += weight;

	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(event, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(event, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0/GeV;

	foreach (const Particle& p, ufs.particles()) {
	const PdgId pid = p.abspid();

	switch (pid) {
	case 413:

	// Accept all D*+- decays. Normalisation to D0 + pi+- in finalize()

	// Scaled energy.
	const double energy = p.E()/GeV;
	const double scaledEnergy = energy/meanBeamMom;
	_h_Xe_Ds->fill(scaledEnergy, weight);

	break;
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	// Scale to the product of branching fractions D0*->D0 pi x D0->Kpi(charged)
	// Numbers are taken from PDG 2010
	scale(_h_Xe_Ds, 0.677*0.0389/_sumWpassed);

	}

	private:
	double _sumWpassed;

	private:

	Histo1DPtr _h_Xe_Ds;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALEPH_1999_S4193598);

	}
	diff --git a/src/Analyses/ALEPH_2001_S4656318.cc b/src/Analyses/ALEPH_2001_S4656318.cc
	--- a/src/Analyses/ALEPH_2001_S4656318.cc
	+++ b/src/Analyses/ALEPH_2001_S4656318.cc
	@@ -1,128 +1,128 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"


	/// @todo Use inline PID functions instead
	#define IS_PARTON_PDGID(id) ( abs(id) <= 100 && abs(id) != 22 && (abs(id) < 11 \|\| abs(id) > 18) )
	#define IS_BHADRON_PDGID(id) ( ((abs(id)/100)%10 == 5) \|\| (abs(id) >= 5000 && abs(id) <= 5999) )

	namespace Rivet {


	/// @brief DELPHI b-fragmentation measurement
	/// @author Hendrik Hoeth
	class ALEPH_2001_S4656318 : public Analysis {
	public:

	/// Constructor
	ALEPH_2001_S4656318()
	: Analysis("ALEPH_2001_S4656318")
	{
	}


	/// @name Analysis methods
	//@{

	/// Book projections and histograms
	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	_histXbweak = bookHisto1D(1, 1, 1);
	_histXbprim = bookHisto1D(1, 1, 2);
	_histMeanXbweak = bookProfile1D(7, 1, 1);
	_histMeanXbprim = bookProfile1D(7, 1, 2);
	}


	void analyze(const Event& e) {
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed ncharged cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed ncharged cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);


	foreach (const GenParticle* p, particles(e.genEvent())) {
	const GenVertex* pv = p->production_vertex();
	const GenVertex* dv = p->end_vertex();
	if (IS_BHADRON_PDGID(p->pdg_id())) {
	const double xp = p->momentum().e()/meanBeamMom;

	// If the B-hadron has a parton as parent, call it primary B-hadron:
	if (pv) {
	bool is_primary = false;
	for (GenVertex::particles_in_const_iterator pp = pv->particles_in_const_begin(); pp != pv->particles_in_const_end() ; ++pp) {
	if (IS_PARTON_PDGID((*pp)->pdg_id())) is_primary = true;
	}
	if (is_primary) {
	_histXbprim->fill(xp, weight);
	_histMeanXbprim->fill(_histMeanXbprim->bin(0).xMid(), xp, weight);
	}
	}

	// If the B-hadron has no B-hadron as a child, it decayed weakly:
	if (dv) {
	bool is_weak = true;
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin() ;
	pp != dv->particles_out_const_end() ; ++pp) {
	if (IS_BHADRON_PDGID((*pp)->pdg_id())) {
	is_weak = false;
	}
	}
	if (is_weak) {
	_histXbweak->fill(xp, weight);
	_histMeanXbweak->fill(_histMeanXbweak->bin(0).xMid(), xp, weight);
	}
	}

	}
	}
	}


	// Finalize
	void finalize() {
	normalize(_histXbprim);
	normalize(_histXbweak);
	}


	private:

	/// Store the weighted sums of numbers of charged / charged+neutral
	/// particles - used to calculate average number of particles for the
	/// inclusive single particle distributions' normalisations.

	Histo1DPtr _histXbprim;
	Histo1DPtr _histXbweak;

	Profile1DPtr _histMeanXbprim;
	Profile1DPtr _histMeanXbweak;

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALEPH_2001_S4656318);

	}
	diff --git a/src/Analyses/ALEPH_2002_S4823664.cc b/src/Analyses/ALEPH_2002_S4823664.cc
	--- a/src/Analyses/ALEPH_2002_S4823664.cc
	+++ b/src/Analyses/ALEPH_2002_S4823664.cc
	@@ -1,91 +1,91 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief ALEPH eta/omega fragmentation function paper
	/// @author Peter Richardson
	class ALEPH_2002_S4823664 : public Analysis {
	public:

	/// Constructor
	ALEPH_2002_S4823664()
	: Analysis("ALEPH_2002_S4823664")
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	_histXpEta = bookHisto1D( 2, 1, 2);
	_histXpOmega = bookHisto1D( 3, 1, 2);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	if(p.abspid()==221) {
	double xp = p.p3().mod()/meanBeamMom;
	_histXpEta->fill(xp, weight);
	}
	else if(p.abspid()==223) {
	double xp = p.p3().mod()/meanBeamMom;
	_histXpOmega->fill(xp, weight);
	}
	}
	}


	/// Finalize
	void finalize() {
	scale(_histXpEta , 1./sumOfWeights());
	scale(_histXpOmega, 1./sumOfWeights());
	}

	//@}


	private:

	Histo1DPtr _histXpEta;
	Histo1DPtr _histXpOmega;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALEPH_2002_S4823664);

	}
	diff --git a/src/Analyses/ALEPH_2004_S5765862.cc b/src/Analyses/ALEPH_2004_S5765862.cc
	--- a/src/Analyses/ALEPH_2004_S5765862.cc
	+++ b/src/Analyses/ALEPH_2004_S5765862.cc
	@@ -1,326 +1,326 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/Sphericity.hh"
	#include "Rivet/Projections/ParisiTensor.hh"
	#include "Rivet/Projections/Hemispheres.hh"
	#include "Rivet/Projections/Beam.hh"

	namespace Rivet {


	/// @brief ALEPH jet rates and event shapes at LEP 1 and 2
	class ALEPH_2004_S5765862 : public Analysis {
	public:

	ALEPH_2004_S5765862()
	: Analysis("ALEPH_2004_S5765862") , _initialisedJets(false),
	_initialisedSpectra(false), _weightedTotalChargedPartNum(0)
	{
	}


	public:

	void init() {
	_initialisedJets = true;
	_initialisedSpectra = true;
	// TODO: According to the paper they seem to discard neutral particles
	// between 1 and 2 GeV. That correction is included in the systematic
	// uncertainties and overly complicated to program, so we ignore it.
	const FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	FastJets durhamjets(fs, FastJets::DURHAM, 0.7);
	durhamjets.useInvisibles(true);
	- addProjection(durhamjets, "DurhamJets");
	+ declare(durhamjets, "DurhamJets");

	const Thrust thrust(fs);
	- addProjection(thrust, "Thrust");
	- addProjection(Sphericity(fs), "Sphericity");
	- addProjection(ParisiTensor(fs), "Parisi");
	- addProjection(Hemispheres(thrust), "Hemispheres");
	+ declare(thrust, "Thrust");
	+ declare(Sphericity(fs), "Sphericity");
	+ declare(ParisiTensor(fs), "Parisi");
	+ declare(Hemispheres(thrust), "Hemispheres");

	const ChargedFinalState cfs;
	- addProjection(Beam(), "Beams");
	- addProjection(cfs, "CFS");
	+ declare(Beam(), "Beams");
	+ declare(cfs, "CFS");

	// Histos
	// offset for the event shapes and jets
	int offset = 0;
	switch (int(sqrtS()/GeV + 0.5)) {
	case 91: offset = 0; break;
	case 133: offset = 1; break;
	case 161: offset = 2; break;
	case 172: offset = 3; break;
	case 183: offset = 4; break;
	case 189: offset = 5; break;
	case 200: offset = 6; break;
	case 206: offset = 7; break;
	default:
	_initialisedJets = false;
	}
	// event shapes
	if(_initialisedJets) {
	_h_thrust = bookHisto1D(offset+54, 1, 1);
	_h_heavyjetmass = bookHisto1D(offset+62, 1, 1);
	_h_totaljetbroadening = bookHisto1D(offset+70, 1, 1);
	_h_widejetbroadening = bookHisto1D(offset+78, 1, 1);
	_h_cparameter = bookHisto1D(offset+86, 1, 1);
	_h_thrustmajor = bookHisto1D(offset+94, 1, 1);
	_h_thrustminor = bookHisto1D(offset+102, 1, 1);
	_h_jetmassdifference = bookHisto1D(offset+110, 1, 1);
	_h_aplanarity = bookHisto1D(offset+118, 1, 1);
	_h_planarity = offset==0 ? Histo1DPtr() : bookHisto1D(offset+125, 1, 1);
	_h_oblateness = bookHisto1D(offset+133, 1, 1);
	_h_sphericity = bookHisto1D(offset+141, 1, 1);

	// Durham n->m jet resolutions
	_h_y_Durham[0] = bookHisto1D(offset+149, 1, 1); // y12 d149 ... d156
	_h_y_Durham[1] = bookHisto1D(offset+157, 1, 1); // y23 d157 ... d164
	if (offset<6) { // there is no y34, y45 and y56 for 200 gev
	_h_y_Durham[2] = bookHisto1D(offset+165, 1, 1); // y34 d165 ... d172, but not 171
	_h_y_Durham[3] = bookHisto1D(offset+173, 1, 1); // y45 d173 ... d179
	_h_y_Durham[4] = bookHisto1D(offset+180, 1, 1); // y56 d180 ... d186
	}
	else if (offset==6) {
	_h_y_Durham[2].reset();
	_h_y_Durham[3].reset();
	_h_y_Durham[4].reset();
	}
	else if (offset==7) {
	_h_y_Durham[2] = bookHisto1D(172, 1, 1);
	_h_y_Durham[3] = bookHisto1D(179, 1, 1);
	_h_y_Durham[4] = bookHisto1D(186, 1, 1);
	}

	// Durham n-jet fractions
	_h_R_Durham[0] = bookHisto1D(offset+187, 1, 1); // R1 d187 ... d194
	_h_R_Durham[1] = bookHisto1D(offset+195, 1, 1); // R2 d195 ... d202
	_h_R_Durham[2] = bookHisto1D(offset+203, 1, 1); // R3 d203 ... d210
	_h_R_Durham[3] = bookHisto1D(offset+211, 1, 1); // R4 d211 ... d218
	_h_R_Durham[4] = bookHisto1D(offset+219, 1, 1); // R5 d219 ... d226
	_h_R_Durham[5] = bookHisto1D(offset+227, 1, 1); // R>=6 d227 ... d234
	}
	// offset for the charged particle distributions
	offset = 0;
	switch (int(sqrtS()/GeV + 0.5)) {
	case 133: offset = 0; break;
	case 161: offset = 1; break;
	case 172: offset = 2; break;
	case 183: offset = 3; break;
	case 189: offset = 4; break;
	case 196: offset = 5; break;
	case 200: offset = 6; break;
	case 206: offset = 7; break;
	default:
	_initialisedSpectra=false;
	}
	if (_initialisedSpectra) {
	_h_xp = bookHisto1D( 2+offset, 1, 1);
	_h_xi = bookHisto1D(11+offset, 1, 1);
	_h_xe = bookHisto1D(19+offset, 1, 1);
	_h_pTin = bookHisto1D(27+offset, 1, 1);
	_h_pTout = offset!=7 ? Histo1DPtr() : bookHisto1D(35, 1, 1);
	_h_rapidityT = bookHisto1D(36+offset, 1, 1);
	_h_rapidityS = bookHisto1D(44+offset, 1, 1);
	}

	if (!_initialisedSpectra && !_initialisedJets) {
	MSG_WARNING("CoM energy of events sqrt(s) = " << sqrtS()/GeV
	<< " doesn't match any available analysis energy .");
	}
	}


	void analyze(const Event& e) {
	const double weight = e.weight();

	- const Thrust& thrust = applyProjection<Thrust>(e, "Thrust");
	- const Sphericity& sphericity = applyProjection<Sphericity>(e, "Sphericity");
	+ const Thrust& thrust = apply<Thrust>(e, "Thrust");
	+ const Sphericity& sphericity = apply<Sphericity>(e, "Sphericity");

	if(_initialisedJets) {
	bool LEP1 = fuzzyEquals(sqrtS(),91.2*GeV,0.01);
	// event shapes
	double thr = LEP1 ? thrust.thrust() : 1.0 - thrust.thrust();
	_h_thrust->fill(thr,weight);
	_h_thrustmajor->fill(thrust.thrustMajor(),weight);
	if(LEP1)
	_h_thrustminor->fill(log(thrust.thrustMinor()),weight);
	else
	_h_thrustminor->fill(thrust.thrustMinor(),weight);
	_h_oblateness->fill(thrust.oblateness(),weight);

	- const Hemispheres& hemi = applyProjection<Hemispheres>(e, "Hemispheres");
	+ const Hemispheres& hemi = apply<Hemispheres>(e, "Hemispheres");
	_h_heavyjetmass->fill(hemi.scaledM2high(),weight);
	_h_jetmassdifference->fill(hemi.scaledM2diff(),weight);
	_h_totaljetbroadening->fill(hemi.Bsum(),weight);
	_h_widejetbroadening->fill(hemi.Bmax(),weight);

	- const ParisiTensor& parisi = applyProjection<ParisiTensor>(e, "Parisi");
	+ const ParisiTensor& parisi = apply<ParisiTensor>(e, "Parisi");
	_h_cparameter->fill(parisi.C(),weight);

	_h_aplanarity->fill(sphericity.aplanarity(),weight);
	if(_h_planarity)
	_h_planarity->fill(sphericity.planarity(),weight);
	_h_sphericity->fill(sphericity.sphericity(),weight);

	// Jet rates
	- const FastJets& durjet = applyProjection<FastJets>(e, "DurhamJets");
	+ const FastJets& durjet = apply<FastJets>(e, "DurhamJets");
	double log10e = log10(exp(1.));
	if (durjet.clusterSeq()) {
	double logynm1=0.;
	double logyn;
	for (size_t i=0; i<5; ++i) {
	double yn = durjet.clusterSeq()->exclusive_ymerge_max(i+1);
	if (yn<=0.0) continue;
	logyn = -log(yn);
	if (_h_y_Durham[i]) {
	_h_y_Durham[i]->fill(logyn, weight);
	}
	if(!LEP1) logyn *= log10e;
	for (size_t j = 0; j < _h_R_Durham[i]->numBins(); ++j) {
	double val = _h_R_Durham[i]->bin(j).xMin();
	double width = _h_R_Durham[i]->bin(j).xWidth();
	if(-val<=logynm1) break;
	if(-val<logyn) {
	_h_R_Durham[i]->fill(val+0.5width, weightwidth);
	}
	}
	logynm1 = logyn;
	}
	for (size_t j = 0; j < _h_R_Durham[5]->numBins(); ++j) {
	double val = _h_R_Durham[5]->bin(j).xMin();
	double width = _h_R_Durham[5]->bin(j).xWidth();
	if(-val<=logynm1) break;
	_h_R_Durham[5]->fill(val+0.5width, weightwidth);
	}
	}
	if( !_initialisedSpectra) {
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(e, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(e, "CFS");
	const size_t numParticles = cfs.particles().size();
	_weightedTotalChargedPartNum += numParticles * weight;
	}
	}

	// charged particle distributions
	if(_initialisedSpectra) {
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(e, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(e, "CFS");
	const size_t numParticles = cfs.particles().size();
	_weightedTotalChargedPartNum += numParticles * weight;
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	foreach (const Particle& p, cfs.particles()) {
	const double xp = p.p3().mod()/meanBeamMom;
	_h_xp->fill(xp , weight);
	const double logxp = -std::log(xp);
	_h_xi->fill(logxp, weight);
	const double xe = p.E()/meanBeamMom;
	_h_xe->fill(xe , weight);
	const double pTinT = dot(p.p3(), thrust.thrustMajorAxis());
	const double pToutT = dot(p.p3(), thrust.thrustMinorAxis());
	_h_pTin->fill(fabs(pTinT/GeV), weight);
	if(_h_pTout) _h_pTout->fill(fabs(pToutT/GeV), weight);
	const double momT = dot(thrust.thrustAxis() ,p.p3());
	const double rapidityT = 0.5 * std::log((p.E() + momT) /
	(p.E() - momT));
	_h_rapidityT->fill(fabs(rapidityT), weight);
	const double momS = dot(sphericity.sphericityAxis(),p.p3());
	const double rapidityS = 0.5 * std::log((p.E() + momS) /
	(p.E() - momS));
	_h_rapidityS->fill(fabs(rapidityS), weight);
	}
	}
	}

	void finalize() {
	if(!_initialisedJets && !_initialisedSpectra) return;

	if (_initialisedJets) {
	normalize(_h_thrust);
	normalize(_h_heavyjetmass);
	normalize(_h_totaljetbroadening);
	normalize(_h_widejetbroadening);
	normalize(_h_cparameter);
	normalize(_h_thrustmajor);
	normalize(_h_thrustminor);
	normalize(_h_jetmassdifference);
	normalize(_h_aplanarity);
	if(_h_planarity) normalize(_h_planarity);
	normalize(_h_oblateness);
	normalize(_h_sphericity);

	for (size_t n=0; n<6; ++n) {
	scale(_h_R_Durham[n], 1./sumOfWeights());
	}

	for (size_t n = 0; n < 5; ++n) {
	if (_h_y_Durham[n]) {
	scale(_h_y_Durham[n], 1.0/sumOfWeights());
	}
	}
	}

	Histo1D temphisto(refData(1, 1, 1));
	const double avgNumParts = _weightedTotalChargedPartNum / sumOfWeights();
	Scatter2DPtr mult = bookScatter2D(1, 1, 1);
	for (size_t b = 0; b < temphisto.numBins(); b++) {
	const double x = temphisto.bin(b).xMid();
	const double ex = temphisto.bin(b).xWidth()/2.;
	if (inRange(sqrtS()/GeV, x-ex, x+ex)) {
	mult->addPoint(x, avgNumParts, ex, 0.);
	}
	}

	if (_initialisedSpectra) {
	normalize(_h_xp, avgNumParts);
	normalize(_h_xi, avgNumParts);
	normalize(_h_xe, avgNumParts);
	normalize(_h_pTin , avgNumParts);
	if (_h_pTout) normalize(_h_pTout, avgNumParts);
	normalize(_h_rapidityT, avgNumParts);
	normalize(_h_rapidityS, avgNumParts);
	}
	}

	private:

	bool _initialisedJets;
	bool _initialisedSpectra;

	Histo1DPtr _h_xp;
	Histo1DPtr _h_xi;
	Histo1DPtr _h_xe;
	Histo1DPtr _h_pTin;
	Histo1DPtr _h_pTout;
	Histo1DPtr _h_rapidityT;
	Histo1DPtr _h_rapidityS;
	Histo1DPtr _h_thrust;
	Histo1DPtr _h_heavyjetmass;
	Histo1DPtr _h_totaljetbroadening;
	Histo1DPtr _h_widejetbroadening;
	Histo1DPtr _h_cparameter;
	Histo1DPtr _h_thrustmajor;
	Histo1DPtr _h_thrustminor;
	Histo1DPtr _h_jetmassdifference;
	Histo1DPtr _h_aplanarity;
	Histo1DPtr _h_planarity;
	Histo1DPtr _h_oblateness;
	Histo1DPtr _h_sphericity;

	Histo1DPtr _h_R_Durham[6];
	Histo1DPtr _h_y_Durham[5];

	double _weightedTotalChargedPartNum;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALEPH_2004_S5765862);

	}
	diff --git a/src/Analyses/ALICE_2010_S8624100.cc b/src/Analyses/ALICE_2010_S8624100.cc
	--- a/src/Analyses/ALICE_2010_S8624100.cc
	+++ b/src/Analyses/ALICE_2010_S8624100.cc
	@@ -1,94 +1,94 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class ALICE_2010_S8624100 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ALICE_2010_S8624100()
	: Analysis("ALICE_2010_S8624100")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	ChargedFinalState cfs05(-0.5, 0.5);
	ChargedFinalState cfs10(-1.0, 1.0);
	ChargedFinalState cfs13(-1.3, 1.3);
	- addProjection(cfs05, "CFS05");
	- addProjection(cfs10, "CFS10");
	- addProjection(cfs13, "CFS13");
	+ declare(cfs05, "CFS05");
	+ declare(cfs10, "CFS10");
	+ declare(cfs13, "CFS13");

	if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) {
	_h_dN_dNch_05 = bookHisto1D(11, 1, 1);
	_h_dN_dNch_10 = bookHisto1D(12, 1, 1);
	_h_dN_dNch_13 = bookHisto1D(13, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 2360, 1E-3)) {
	_h_dN_dNch_05 = bookHisto1D(17, 1, 1);
	_h_dN_dNch_10 = bookHisto1D(18, 1, 1);
	_h_dN_dNch_13 = bookHisto1D(19, 1, 1);
	}

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ChargedFinalState& charged_05 = applyProjection<ChargedFinalState>(event, "CFS05");
	- const ChargedFinalState& charged_10 = applyProjection<ChargedFinalState>(event, "CFS10");
	- const ChargedFinalState& charged_13 = applyProjection<ChargedFinalState>(event, "CFS13");
	+ const ChargedFinalState& charged_05 = apply<ChargedFinalState>(event, "CFS05");
	+ const ChargedFinalState& charged_10 = apply<ChargedFinalState>(event, "CFS10");
	+ const ChargedFinalState& charged_13 = apply<ChargedFinalState>(event, "CFS13");

	_h_dN_dNch_05->fill(charged_05.size(), weight);
	_h_dN_dNch_10->fill(charged_10.size(), weight);
	_h_dN_dNch_13->fill(charged_13.size(), weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	normalize(_h_dN_dNch_05);
	normalize(_h_dN_dNch_10);
	normalize(_h_dN_dNch_13);

	}

	//@}


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_dN_dNch_05;
	Histo1DPtr _h_dN_dNch_10;
	Histo1DPtr _h_dN_dNch_13;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALICE_2010_S8624100);

	}
	diff --git a/src/Analyses/ALICE_2010_S8625980.cc b/src/Analyses/ALICE_2010_S8625980.cc
	--- a/src/Analyses/ALICE_2010_S8625980.cc
	+++ b/src/Analyses/ALICE_2010_S8625980.cc
	@@ -1,99 +1,99 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class ALICE_2010_S8625980 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ALICE_2010_S8625980()
	: Analysis("ALICE_2010_S8625980"),
	_Nevt_after_cuts(0.0)
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	ChargedFinalState cfs(-1.0, 1.0);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) {
	_h_dN_deta = bookHisto1D(4, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 2360, 1E-3)) {
	_h_dN_deta = bookHisto1D(5, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 7000, 1E-3)) {
	_h_dN_deta = bookHisto1D(6, 1, 1);
	_h_dN_dNch = bookHisto1D(3, 1, 1);
	}

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ChargedFinalState& charged = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& charged = apply<ChargedFinalState>(event, "CFS");
	if (charged.size() < 1) {
	vetoEvent;
	}
	_Nevt_after_cuts += weight;


	foreach (const Particle& p, charged.particles()) {
	const double eta = p.eta();
	_h_dN_deta->fill(eta, weight);
	}

	if (fuzzyEquals(sqrtS()/GeV, 7000, 1E-3)) {
	_h_dN_dNch->fill(charged.size(), weight);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	if (fuzzyEquals(sqrtS()/GeV, 7000, 1E-3)) {
	normalize(_h_dN_dNch);
	}
	scale(_h_dN_deta, 1.0/_Nevt_after_cuts);

	}

	//@}


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_dN_deta;
	Histo1DPtr _h_dN_dNch;
	double _Nevt_after_cuts;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALICE_2010_S8625980);

	}
	diff --git a/src/Analyses/ALICE_2010_S8706239.cc b/src/Analyses/ALICE_2010_S8706239.cc
	--- a/src/Analyses/ALICE_2010_S8706239.cc
	+++ b/src/Analyses/ALICE_2010_S8706239.cc
	@@ -1,101 +1,101 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class ALICE_2010_S8706239 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ALICE_2010_S8706239()
	: Analysis("ALICE_2010_S8706239"),
	_Nevt_after_cuts(0.0)
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	ChargedFinalState cfs(-0.8, 0.8, 0.15);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	_h_pT = bookHisto1D(4, 1, 1);

	_h_pT_Nch_015 = bookProfile1D(11, 1, 1);
	_h_pT_Nch_05 = bookProfile1D(12, 1, 1);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ChargedFinalState& charged = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& charged = apply<ChargedFinalState>(event, "CFS");

	_Nevt_after_cuts += weight;

	// Get number of particles that fulfill certain pT requirements
	int Nch_015 = 0;
	int Nch_05 = 0;
	foreach (const Particle& p, charged.particles()) {
	double pT = p.pT()/GeV;
	if (pT < 4.0) Nch_015++;
	if (pT > 0.5 && pT < 4.0) Nch_05++;
	}

	// Now we can fill histograms
	foreach (const Particle& p, charged.particles()) {
	double pT = p.pT()/GeV;
	if (pT < 4.0) _h_pT_Nch_015 ->fill(Nch_015, pT, weight);
	if (pT > 0.5 && pT < 4.0) _h_pT_Nch_05 ->fill(Nch_05, pT, weight);

	// To get the Yield, fill appropriate weight 1/(2PI * pT * d eta)
	_h_pT->fill(pT, weight /(TWOPIpT1.6) );
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_pT, 1.0/_Nevt_after_cuts);
	}

	//@}


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_pT;

	Profile1DPtr _h_pT_Nch_015 ;
	Profile1DPtr _h_pT_Nch_05 ;

	double _Nevt_after_cuts;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALICE_2010_S8706239);

	}
	diff --git a/src/Analyses/ALICE_2011_S8909580.cc b/src/Analyses/ALICE_2011_S8909580.cc
	--- a/src/Analyses/ALICE_2011_S8909580.cc
	+++ b/src/Analyses/ALICE_2011_S8909580.cc
	@@ -1,103 +1,103 @@
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	class ALICE_2011_S8909580 : public Analysis {
	public:

	ALICE_2011_S8909580()
	: Analysis("ALICE_2011_S8909580")
	{}


	public:
	void init() {
	const UnstableFinalState ufs(Cuts::abseta < 15);
	- addProjection(ufs, "UFS");
	+ declare(ufs, "UFS");

	_histPtK0s = bookHisto1D(1, 1, 1);
	_histPtLambda = bookHisto1D(2, 1, 1);
	_histPtAntiLambda = bookHisto1D(3, 1, 1);
	_histPtXi = bookHisto1D(4, 1, 1);
	_histPtPhi = bookHisto1D(5, 1, 1);
	_temp_h_Lambdas = bookHisto1D("TMP/h_Lambdas", refData(6, 1, 1));
	_temp_h_Kzeros = bookHisto1D("TMP/h_Kzeros", refData(6, 1, 1));
	_h_LamKzero = bookScatter2D(6, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	const double absrap = p.absrap();
	const double pT = p.pT()/GeV;

	if (absrap < 0.8) {
	switch(p.pid()) {
	case 3312:
	case -3312:
	if ( !( p.hasAncestor(3334) \|\| p.hasAncestor(-3334) ) ) {
	_histPtXi->fill(pT, weight);
	}
	break;
	if (absrap < 0.75) {
	case 310:
	_histPtK0s->fill(pT, weight);
	_temp_h_Kzeros->fill(pT, 2*weight);
	break;
	case 3122:
	if ( !( p.hasAncestor(3322) \|\| p.hasAncestor(-3322) \|\|
	p.hasAncestor(3312) \|\| p.hasAncestor(-3312) \|\|
	p.hasAncestor(3334) \|\| p.hasAncestor(-3334) ) ) {
	_histPtLambda->fill(pT, weight);
	_temp_h_Lambdas->fill(pT, weight);
	}
	break;
	case -3122:
	if ( !( p.hasAncestor(3322) \|\| p.hasAncestor(-3322) \|\|
	p.hasAncestor(3312) \|\| p.hasAncestor(-3312) \|\|
	p.hasAncestor(3334) \|\| p.hasAncestor(-3334) ) ) {
	_histPtAntiLambda->fill(pT, weight);
	_temp_h_Lambdas->fill(pT, weight);
	}
	break;
	}
	if (absrap<0.6) {
	case 333:
	_histPtPhi->fill(pT, weight);
	break;
	}
	}
	}
	}
	}


	void finalize() {
	scale(_histPtK0s, 1./(1.5*sumOfWeights()));
	scale(_histPtLambda, 1./(1.5*sumOfWeights()));
	scale(_histPtAntiLambda, 1./(1.5*sumOfWeights()));
	scale(_histPtXi, 1./(1.6*sumOfWeights()));
	scale(_histPtPhi, 1./(1.2*sumOfWeights()));
	divide(_temp_h_Lambdas, _temp_h_Kzeros, _h_LamKzero);
	}


	private:

	Histo1DPtr _histPtK0s, _histPtLambda, _histPtAntiLambda, _histPtXi, _histPtPhi;
	Histo1DPtr _temp_h_Lambdas, _temp_h_Kzeros;
	Scatter2DPtr _h_LamKzero;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALICE_2011_S8909580);

	}
	diff --git a/src/Analyses/ALICE_2011_S8945144.cc b/src/Analyses/ALICE_2011_S8945144.cc
	--- a/src/Analyses/ALICE_2011_S8945144.cc
	+++ b/src/Analyses/ALICE_2011_S8945144.cc
	@@ -1,105 +1,105 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class ALICE_2011_S8945144 : public Analysis {
	public:

	ALICE_2011_S8945144()
	: Analysis("ALICE_2011_S8945144")
	{}


	public:

	void init() {
	const ChargedFinalState cfs(-15, 15);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	_histPtPions = bookHisto1D("d01-x01-y01");
	_histPtAntiPions = bookHisto1D("d01-x01-y02");
	_histPtKaons = bookHisto1D("d02-x01-y01");
	_histPtAntiKaons = bookHisto1D("d02-x01-y02");
	_histPtProtons = bookHisto1D("d03-x01-y01");
	_histPtAntiProtons = bookHisto1D("d03-x01-y02");
	_histAveragePt = bookProfile1D("d04-x01-y01");
	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	foreach (const Particle& p, cfs.particles()) {
	if(p.absrap()<0.5) {
	switch (p.pid()) {
	case 211:
	_histPtPions->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case -211:
	_histPtAntiPions->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case 2212:
	if ( !(p.hasAncestor(3322) \|\| // Xi0
	p.hasAncestor(3122) \|\| p.hasAncestor(-3122) \|\| // Lambda
	p.hasAncestor(3222) \|\| p.hasAncestor(-3222) \|\| // Sigma+/-
	p.hasAncestor(3312) \|\| p.hasAncestor(-3312) ) ) { // Xi-/+
	_histPtProtons->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	}
	break;
	case -2212:
	if ( !(p.hasAncestor(3322) \|\| // Xi0
	p.hasAncestor(3122) \|\| p.hasAncestor(-3122) \|\| // Lambda
	p.hasAncestor(3222) \|\| p.hasAncestor(-3222) \|\| // Sigma+/-
	p.hasAncestor(3312) \|\| p.hasAncestor(-3312) ) ) { // Xi-/+
	_histPtAntiProtons->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	}
	break;
	case 321:
	_histPtKaons->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case -321:
	_histPtAntiKaons->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	}
	}
	}
	}


	void finalize() {
	scale(_histPtPions, 1./sumOfWeights());
	scale(_histPtProtons, 1./sumOfWeights());
	scale(_histPtKaons, 1./sumOfWeights());
	scale(_histPtAntiPions, 1./sumOfWeights());
	scale(_histPtAntiProtons, 1./sumOfWeights());
	scale(_histPtAntiKaons, 1./sumOfWeights());
	}


	private:

	Histo1DPtr _histPtPions;
	Histo1DPtr _histPtProtons;
	Histo1DPtr _histPtKaons;
	Histo1DPtr _histPtAntiPions;
	Histo1DPtr _histPtAntiProtons;
	Histo1DPtr _histPtAntiKaons;
	Profile1DPtr _histAveragePt;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALICE_2011_S8945144);

	}
	diff --git a/src/Analyses/ALICE_2012_I1116147.cc b/src/Analyses/ALICE_2012_I1116147.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ALICE_2012_I1116147.cc
	@@ -0,0 +1,86 @@
	+//-- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ class ALICE_2012_I1116147 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ALICE_2012_I1116147);
	+
	+
	+ void init() {
	+
	+ const UnstableFinalState ufs(Cuts::absrap < RAPMAX);
	+ addProjection(ufs, "UFS");
	+
	+ // Check if cm energy is 7 TeV or 0.9 TeV
	+ if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) _cm_energy_case = 1;
	+ else if (fuzzyEquals(sqrtS()/GeV, 7000, 1E-3)) _cm_energy_case = 2;
	+ if (_cm_energy_case == 0)
	+ throw UserError("Center of mass energy of the given input is neither 900 nor 7000 GeV.");
	+
	+ // Book histos
	+ if (_cm_energy_case == 1) {
	+ _h_pi0 = bookHisto1D(2,1,1);
	+ } else {
	+ _h_pi0 = bookHisto1D(1,1,1);
	+ _h_eta = bookHisto1D(3,1,1);
	+ _h_etaToPion = bookScatter2D(4,1,1);
	+ }
	+
	+ // Temporary plots with the binning of _h_etaToPion to construct the eta/pi0 ratio
	+ _temp_h_pion = bookHisto1D("TMP/h_pion", refData(4,1,1));
	+ _temp_h_eta = bookHisto1D("TMP/h_eta", refData(4,1,1));
	+ }
	+
	+
	+ void analyze(const Event& event) {
	+
	+ const FinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const double weight = event.weight();
	+
	+ for (const Particle& p : ufs.particles()) {
	+ if (p.pid() == 111) {
	+ // Neutral pion
	+ _h_pi0->fill(p.pT()/GeV, weight /(TWOPIp.pT()/GeV2*RAPMAX));
	+ _temp_h_pion->fill(p.pT()/GeV, weight);
	+ } else if ((p.pid() == 221) && _cm_energy_case == 2) {
	+ // Eta meson (only for 7 TeV)
	+ _h_eta->fill(p.pT()/GeV, weight /(TWOPIp.pT()/GeV2*RAPMAX));
	+ _temp_h_eta->fill(p.pT()/GeV, weight);
	+ }
	+ }
	+
	+ }
	+
	+
	+ void finalize() {
	+
	+ scale(_h_pi0, crossSection()/microbarn/sumOfWeights());
	+ scale(_h_eta, crossSection()/microbarn/sumOfWeights());
	+
	+ if (_cm_energy_case == 2)
	+ divide(_temp_h_eta, _temp_h_pion, _h_etaToPion);
	+
	+ }
	+
	+
	+ private:
	+
	+ const double RAPMAX = 0.8;
	+ int _cm_energy_case = 0;
	+
	+ Histo1DPtr _h_pi0, _h_eta;
	+ Histo1DPtr _temp_h_pion, _temp_h_eta;
	+ Scatter2DPtr _h_etaToPion;
	+
	+ };
	+
	+
	+ DECLARE_RIVET_PLUGIN(ALICE_2012_I1116147);
	+
	+}
	diff --git a/src/Analyses/ALICE_2012_I1181770.cc b/src/Analyses/ALICE_2012_I1181770.cc
	--- a/src/Analyses/ALICE_2012_I1181770.cc
	+++ b/src/Analyses/ALICE_2012_I1181770.cc
	@@ -1,115 +1,115 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {

	class ALICE_2012_I1181770 : public Analysis {
	public:

	ALICE_2012_I1181770()
	: Analysis("ALICE_2012_I1181770")
	{ }


	void init() {
	// Projection setup
	- addProjection(ChargedFinalState(), "CFS");
	+ declare(ChargedFinalState(), "CFS");

	// Book (energy-specific) histograms
	int isqrts = -1;
	if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) isqrts = 1;
	else if (fuzzyEquals(sqrtS()/GeV, 2760, 1E-3)) isqrts = 2;
	else if (fuzzyEquals(sqrtS()/GeV, 7000, 1E-3)) isqrts = 3;
	assert(isqrts > 0);

	_h_frac_sd_inel = bookScatter2D(1, 1, isqrts);
	_h_frac_dd_inel = bookScatter2D(2, 1, isqrts);
	_h_xsec_sd = bookHisto1D (3, 1, isqrts);
	_h_xsec_dd = bookHisto1D (4, 1, isqrts);
	_h_xsec_inel = bookHisto1D (5, 1, isqrts);
	}


	void analyze(const Event& event) {
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	if (cfs.size() < 2) vetoEvent; // need at least two particles to calculate gaps

	const double weight = event.weight();

	// Fill INEL plots for each event
	_h_xsec_inel->fill(sqrtS()/GeV, weight);

	// Identify particles with most positive/most negative rapidities
	const Particles particlesByRap = cfs.particles(cmpMomByRap);
	const Particle pslowest = particlesByRap.front();
	const Particle pfastest = particlesByRap.back();

	// Find gap sizes
	const Particles particlesByEta = cfs.particles(cmpMomByEta); // sorted from minus to plus
	const size_t num_particles = particlesByEta.size();
	vector<double> gaps;
	for (size_t ip = 1; ip < num_particles; ++ip) {
	const Particle& p1 = particlesByEta[ip-1];
	const Particle& p2 = particlesByEta[ip];
	const double gap = p2.eta() - p1.eta();
	assert(gap >= 0);
	gaps.push_back(gap);
	}

	// First, last, and largest gaps
	const double gapmax = *max_element(gaps.begin(), gaps.end());
	const double gapbwd = gaps.front();
	const double gapfwd = gaps.back();

	// Mx calculation
	FourMomentum p4lead;
	if (pslowest.pid() == PID::PROTON && pfastest.pid() == PID::PROTON) {
	p4lead = (fabs(pslowest.rapidity()) > fabs(pfastest.rapidity())) ? pslowest.momentum() : pfastest.momentum();
	} else if (pslowest.pid() == PID::PROTON) {
	p4lead = pslowest.momentum();
	} else if (pfastest.pid() == PID::PROTON) {
	p4lead = pfastest.momentum();
	}
	const double Mx = sqrt( (sqrtS()-p4lead.E()-p4lead.p3().mod()) * (sqrtS()-p4lead.E()+p4lead.p3().mod()) );

	// Fill SD (and escape) if Mx is sufficiently low
	if (Mx < 200*GeV) {
	_h_xsec_sd->fill(sqrtS()/GeV, weight);
	return;
	}

	// Also remove SD-like events in NSD events
	if (fuzzyEquals(gapbwd, gapmax) \|\| fuzzyEquals(gapfwd, gapmax)) vetoEvent;

	// Fill DD plots
	if (gapmax > 3) _h_xsec_dd->fill(sqrtS()/GeV, weight);
	}


	void finalize() {

	// get the ratio plots: SD/inel, DD/inel
	divide(_h_xsec_sd , _h_xsec_inel, _h_frac_sd_inel);
	divide(_h_xsec_sd , _h_xsec_inel, _h_frac_dd_inel);

	scale(_h_xsec_sd, crossSection()/millibarn/sumOfWeights());
	scale(_h_xsec_dd, crossSection()/millibarn/sumOfWeights());
	scale(_h_xsec_inel, crossSection()/millibarn/sumOfWeights());

	}

	private:

	Scatter2DPtr _h_frac_sd_inel;
	Scatter2DPtr _h_frac_dd_inel;
	Histo1DPtr _h_xsec_sd;
	Histo1DPtr _h_xsec_dd;
	Histo1DPtr _h_xsec_inel;

	};

	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALICE_2012_I1181770);

	}
	diff --git a/src/Analyses/ALICE_2014_I1300380.cc b/src/Analyses/ALICE_2014_I1300380.cc
	--- a/src/Analyses/ALICE_2014_I1300380.cc
	+++ b/src/Analyses/ALICE_2014_I1300380.cc
	@@ -1,120 +1,120 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	namespace Rivet {


	class ALICE_2014_I1300380 : public Analysis {
	public:

	ALICE_2014_I1300380()
	: Analysis("ALICE_2014_I1300380")
	{}


	public:

	void init() {
	const UnstableFinalState cfs(Cuts::absrap<0.5);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	// Plots from the paper
	_histPtSigmaStarPlus = bookHisto1D("d01-x01-y01"); // Sigma*+
	_histPtSigmaStarMinus = bookHisto1D("d01-x01-y02"); // Sigma*-
	_histPtSigmaStarPlusAnti = bookHisto1D("d01-x01-y03"); // anti Sigma*-
	_histPtSigmaStarMinusAnti = bookHisto1D("d01-x01-y04"); // anti Sigma*+
	_histPtXiStar = bookHisto1D("d02-x01-y01"); // 0.5 * (xi star + anti xi star)
	_histAveragePt = bookProfile1D("d03-x01-y01"); // <pT> profile
	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	- const UnstableFinalState& cfs = applyProjection<UnstableFinalState>(event, "CFS");
	+ const UnstableFinalState& cfs = apply<UnstableFinalState>(event, "CFS");
	foreach (const Particle& p, cfs.particles()) {
	// protections against mc generators decaying long-lived particles
	if ( !(p.hasAncestor(310) \|\| p.hasAncestor(-310) \|\| // K0s
	p.hasAncestor(130) \|\| p.hasAncestor(-130) \|\| // K0l
	p.hasAncestor(3322) \|\| p.hasAncestor(-3322) \|\| // Xi0
	p.hasAncestor(3122) \|\| p.hasAncestor(-3122) \|\| // Lambda
	p.hasAncestor(3222) \|\| p.hasAncestor(-3222) \|\| // Sigma+/-
	p.hasAncestor(3312) \|\| p.hasAncestor(-3312) \|\| // Xi-/+
	p.hasAncestor(3334) \|\| p.hasAncestor(-3334) )) // Omega-/+
	{
	int aid = abs(p.pdgId());
	if (aid == 211 \|\| // pi+
	aid == 321 \|\| // K+
	aid == 313 \|\| // K*(892)0
	aid == 2212 \|\| // proton
	aid == 333 ) { // phi(1020)
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	}
	} // end if "rejection of long-lived particles"


	switch (p.pdgId()) {
	case 3224:
	_histPtSigmaStarPlus->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case -3224:
	_histPtSigmaStarPlusAnti->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case 3114:
	_histPtSigmaStarMinus->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case -3114:
	_histPtSigmaStarMinusAnti->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case 3324:
	_histPtXiStar->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case -3324:
	_histPtXiStar->fill(p.pT()/GeV, weight);
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case 3312:
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case -3312:
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case 3334:
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	case -3334:
	_histAveragePt->fill(p.mass()/GeV, p.pT()/GeV, weight);
	break;
	}
	}
	}


	void finalize() {
	scale(_histPtSigmaStarPlus, 1./sumOfWeights());
	scale(_histPtSigmaStarPlusAnti, 1./sumOfWeights());
	scale(_histPtSigmaStarMinus, 1./sumOfWeights());
	scale(_histPtSigmaStarMinusAnti, 1./sumOfWeights());
	scale(_histPtXiStar, 1./sumOfWeights()/ 2.);
	}


	private:
	// plots from the paper
	Histo1DPtr _histPtSigmaStarPlus;
	Histo1DPtr _histPtSigmaStarPlusAnti;
	Histo1DPtr _histPtSigmaStarMinus;
	Histo1DPtr _histPtSigmaStarMinusAnti;
	Histo1DPtr _histPtXiStar;
	Profile1DPtr _histAveragePt;
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALICE_2014_I1300380);
	}
	diff --git a/src/Analyses/ALICE_2015_I1357424.cc b/src/Analyses/ALICE_2015_I1357424.cc
	--- a/src/Analyses/ALICE_2015_I1357424.cc
	+++ b/src/Analyses/ALICE_2015_I1357424.cc
	@@ -1,99 +1,99 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class ALICE_2015_I1357424 : public Analysis {
	public:

	ALICE_2015_I1357424()
	: Analysis("ALICE_2015_I1357424")
	{}


	public:

	void init() {
	const ChargedFinalState cfs(Cuts::absrap<0.5);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");
	//
	// plots from the paper
	_histPtPions = bookHisto1D("d01-x01-y01"); // pions
	_histPtKaons = bookHisto1D("d01-x01-y02"); // kaons
	_histPtProtons = bookHisto1D("d01-x01-y03"); // protons
	_histPtKtoPi = bookScatter2D("d02-x01-y01"); // K to pi ratio
	_histPtPtoPi = bookScatter2D("d03-x01-y01"); // p to pi ratio
	//
	// temp histos for ratios
	_histPtPionsR1 = bookHisto1D("TMP/pT_pi1", refData(2, 1, 1)); // pi histo compatible with more restricted kaon binning
	_histPtPionsR2 = bookHisto1D("TMP/pT_pi2", refData(3, 1, 1)); // pi histo compatible with more restricted proton binning
	_histPtKaonsR = bookHisto1D("TMP/pT_K", refData(2, 1, 1)); // K histo with more restricted binning
	_histPtProtonsR = bookHisto1D("TMP/pT_p", refData(3, 1, 1)); // p histo with more restricted binning
	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	foreach (const Particle& p, cfs.particles()) {
	// protections against mc generators decaying long-lived particles
	if ( !(p.hasAncestor(310) \|\| p.hasAncestor(-310) \|\| // K0s
	p.hasAncestor(130) \|\| p.hasAncestor(-130) \|\| // K0l
	p.hasAncestor(3322) \|\| p.hasAncestor(-3322) \|\| // Xi0
	p.hasAncestor(3122) \|\| p.hasAncestor(-3122) \|\| // Lambda
	p.hasAncestor(3222) \|\| p.hasAncestor(-3222) \|\| // Sigma+/-
	p.hasAncestor(3312) \|\| p.hasAncestor(-3312) \|\| // Xi-/+
	p.hasAncestor(3334) \|\| p.hasAncestor(-3334) )) // Omega-/+
	{
	switch (abs(p.pid())) {
	case 211: // pi+
	_histPtPions->fill(p.pT()/GeV, weight);
	_histPtPionsR1->fill(p.pT()/GeV, weight);
	_histPtPionsR2->fill(p.pT()/GeV, weight);
	break;
	case 2212: // proton
	_histPtProtons->fill(p.pT()/GeV, weight);
	_histPtProtonsR->fill(p.pT()/GeV, weight);
	break;
	case 321: // K+
	_histPtKaons->fill(p.pT()/GeV, weight);
	_histPtKaonsR->fill(p.pT()/GeV, weight);
	break;
	} // particle switch
	} // primary pi, K, p only
	} // particle loop
	}

	void finalize() {
	divide(_histPtKaonsR, _histPtPionsR1, _histPtKtoPi);
	divide(_histPtProtonsR, _histPtPionsR2, _histPtPtoPi);

	scale(_histPtPions, 1./sumOfWeights());
	scale(_histPtProtons, 1./sumOfWeights());
	scale(_histPtKaons, 1./sumOfWeights());
	}


	private:

	Histo1DPtr _histPtPions;
	Histo1DPtr _histPtProtons;
	Histo1DPtr _histPtKaons;

	Histo1DPtr _histPtPionsR1;
	Histo1DPtr _histPtPionsR2;
	Histo1DPtr _histPtProtonsR;
	Histo1DPtr _histPtKaonsR;

	Scatter2DPtr _histPtKtoPi;
	Scatter2DPtr _histPtPtoPi;
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ALICE_2015_I1357424);

	}
	diff --git a/src/Analyses/ARGUS_1993_S2653028.cc b/src/Analyses/ARGUS_1993_S2653028.cc
	--- a/src/Analyses/ARGUS_1993_S2653028.cc
	+++ b/src/Analyses/ARGUS_1993_S2653028.cc
	@@ -1,176 +1,177 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	-#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	-#include "Rivet/ParticleName.hh"

	namespace Rivet {


	/// @brief BELLE pi+/-, K+/- and proton/antiproton spectrum at Upsilon(4S)
	/// @author Peter Richardson
	class ARGUS_1993_S2653028 : public Analysis {
	public:

	ARGUS_1993_S2653028()
	- : Analysis("ARGUS_1993_S2653028"), _weightSum(0.)
	+ : Analysis("ARGUS_1993_S2653028"),
	+ _weightSum(0.)
	{ }


	void analyze(const Event& e) {
	const double weight = e.weight();

	// Find the upsilons
	Particles upsilons;
	// First in unstable final state
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	foreach (const Particle& p, ufs.particles()) {
	if (p.pid() == 300553) upsilons.push_back(p);
	}
	// Then in whole event if that failed
	if (upsilons.empty()) {
	foreach (const GenParticle* p, particles(e.genEvent())) {
	if (p->pdg_id() != 300553) continue;
	const GenVertex* pv = p->production_vertex();
	bool passed = true;
	if (pv) {
	foreach (const GenParticle* pp, particles_in(pv)) {
	if ( p->pdg_id() == pp->pdg_id() ) {
	passed = false;
	break;
	}
	}
	}
	if (passed) upsilons.push_back(Particle(*p));
	}
	}

	// Find an upsilon
	foreach (const Particle& p, upsilons) {
	_weightSum += weight;
	vector<GenParticle *> pionsA,pionsB,protonsA,protonsB,kaons;
	// Find the decay products we want
	findDecayProducts(p.genParticle(), pionsA, pionsB, protonsA, protonsB, kaons);
	LorentzTransform cms_boost;
	if (p.p3().mod() > 1*MeV)
	- cms_boost = LorentzTransform(-p.momentum().boostVector());
	+ cms_boost = LorentzTransform::mkFrameTransformFromBeta(p.momentum().betaVec());
	for (size_t ix = 0; ix < pionsA.size(); ++ix) {
	FourMomentum ptemp(pionsA[ix]->momentum());
	FourMomentum p2 = cms_boost.transform(ptemp);
	double pcm = cms_boost.transform(ptemp).vector3().mod();
	_histPiA->fill(pcm,weight);
	}
	_multPiA->fill(10.58,double(pionsA.size())*weight);
	for (size_t ix = 0; ix < pionsB.size(); ++ix) {
	double pcm = cms_boost.transform(FourMomentum(pionsB[ix]->momentum())).vector3().mod();
	_histPiB->fill(pcm,weight);
	}
	_multPiB->fill(10.58,double(pionsB.size())*weight);
	for (size_t ix = 0; ix < protonsA.size(); ++ix) {
	double pcm = cms_boost.transform(FourMomentum(protonsA[ix]->momentum())).vector3().mod();
	_histpA->fill(pcm,weight);
	}
	_multpA->fill(10.58,double(protonsA.size())*weight);
	for (size_t ix = 0; ix < protonsB.size(); ++ix) {
	double pcm = cms_boost.transform(FourMomentum(protonsB[ix]->momentum())).vector3().mod();
	_histpB->fill(pcm,weight);
	}
	_multpB->fill(10.58,double(protonsB.size())*weight);
	for (size_t ix = 0 ;ix < kaons.size(); ++ix) {
	double pcm = cms_boost.transform(FourMomentum(kaons[ix]->momentum())).vector3().mod();
	_histKA->fill(pcm,weight);
	_histKB->fill(pcm,weight);
	}
	_multK->fill(10.58,double(kaons.size())*weight);
	}
	}


	void finalize() {
	if (_weightSum > 0.) {
	scale(_histPiA, 1./_weightSum);
	scale(_histPiB, 1./_weightSum);
	scale(_histKA , 1./_weightSum);
	scale(_histKB , 1./_weightSum);
	scale(_histpA , 1./_weightSum);
	scale(_histpB , 1./_weightSum);
	scale(_multPiA, 1./_weightSum);
	scale(_multPiB, 1./_weightSum);
	scale(_multK , 1./_weightSum);
	scale(_multpA , 1./_weightSum);
	scale(_multpB , 1./_weightSum);
	}
	}


	void init() {
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");

	// spectra
	_histPiA = bookHisto1D(1, 1, 1);
	_histPiB = bookHisto1D(2, 1, 1);
	_histKA = bookHisto1D(3, 1, 1);
	_histKB = bookHisto1D(6, 1, 1);
	_histpA = bookHisto1D(4, 1, 1);
	_histpB = bookHisto1D(5, 1, 1);
	// multiplicities
	_multPiA = bookHisto1D( 7, 1, 1);
	_multPiB = bookHisto1D( 8, 1, 1);
	_multK = bookHisto1D( 9, 1, 1);
	_multpA = bookHisto1D(10, 1, 1);
	_multpB = bookHisto1D(11, 1, 1);
	} // init


	private:

	//@{
	/// Count of weights
	double _weightSum;
	/// Spectra
	Histo1DPtr _histPiA, _histPiB, _histKA, _histKB, _histpA, _histpB;
	/// Multiplicities
	Histo1DPtr _multPiA, _multPiB, _multK, _multpA, _multpB;
	//@}

	+
	void findDecayProducts(const GenParticle* p,
	vector<GenParticle>& pionsA, vector<GenParticle>& pionsB,
	vector<GenParticle>& protonsA, vector<GenParticle>& protonsB,
	vector<GenParticle*>& kaons)
	{
	int parentId = p->pdg_id();
	const GenVertex* dv = p->end_vertex();
	/// @todo Use better looping
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	int id = abs((*pp)->pdg_id());
	if (id == PID::PIPLUS) {
	if (parentId != PID::LAMBDA && parentId != PID::K0S) {
	pionsA.push_back(*pp);
	pionsB.push_back(*pp);
	}
	else
	pionsB.push_back(*pp);
	}
	else if (id == PID::PROTON) {
	if (parentId != PID::LAMBDA && parentId != PID::K0S) {
	protonsA.push_back(*pp);
	protonsB.push_back(*pp);
	}
	else
	protonsB.push_back(*pp);
	}
	else if (id == PID::KPLUS) {
	kaons.push_back(*pp);
	}
	else if ((*pp)->end_vertex())
	findDecayProducts(*pp, pionsA, pionsB, protonsA, protonsB, kaons);
	}
	}
	+
	+
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ARGUS_1993_S2653028);

	}
	diff --git a/src/Analyses/ARGUS_1993_S2669951.cc b/src/Analyses/ARGUS_1993_S2669951.cc
	--- a/src/Analyses/ARGUS_1993_S2669951.cc
	+++ b/src/Analyses/ARGUS_1993_S2669951.cc
	@@ -1,189 +1,192 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	-#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	-#include "Rivet/ParticleName.hh"

	namespace Rivet {


	/// @brief Production of the $\eta'(958)$ and $f_0(980)$ in $e^+e^-$ annihilation in the Upsilon region
	/// @author Peter Richardson
	class ARGUS_1993_S2669951 : public Analysis {
	public:

	ARGUS_1993_S2669951()
	: Analysis("ARGUS_1993_S2669951"),
	- _count_etaPrime_highZ(2, 0.), _count_etaPrime_allZ(3, 0.), _count_f0(3, 0.),
	- _weightSum_cont(0.), _weightSum_Ups1(0.), _weightSum_Ups2(0.)
	+ _count_etaPrime_highZ(2, 0.),
	+ _count_etaPrime_allZ(3, 0.),
	+ _count_f0(3, 0.),
	+ _weightSum_cont(0.),
	+ _weightSum_Ups1(0.),
	+ _weightSum_Ups2(0.)
	{ }


	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");

	_hist_cont_f0 = bookHisto1D(2, 1, 1);
	_hist_Ups1_f0 = bookHisto1D(3, 1, 1);
	_hist_Ups2_f0 = bookHisto1D(4, 1, 1);
	}


	void analyze(const Event& e) {
	- const double weight = e.weight();

	- const Beam beamproj = applyProjection<Beam>(e, "Beams");
	- const double s = sqr(beamproj.sqrtS());
	- const double roots = sqrt(s);
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ // Find the Upsilons among the unstables
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	+ Particles upsilons;

	- // Find the upsilons
	- Particles upsilons;
	// First in unstable final state
	foreach (const Particle& p, ufs.particles())
	- if (p.pid() == 553 \|\| p.pid() == 100553 ) upsilons.push_back(p);
	+ if (p.pid() == 553 \|\| p.pid() == 100553)
	+ upsilons.push_back(p);
	// Then in whole event if fails
	if (upsilons.empty()) {
	+ /// @todo Replace HepMC digging with Particle::descendents etc. calls
	foreach (const GenParticle* p, Rivet::particles(e.genEvent())) {
	if ( p->pdg_id() != 553 && p->pdg_id() != 100553 ) continue;
	+ // Discard it if its parent has the same PDG ID code (avoid duplicates)
	const GenVertex* pv = p->production_vertex();
	bool passed = true;
	if (pv) {
	foreach (const GenParticle* pp, particles_in(pv)) {
	if ( p->pdg_id() == pp->pdg_id() ) {
	passed = false;
	break;
	}
	}
	}
	if (passed) upsilons.push_back(Particle(*p));
	}
	}
	- // Continuum
	- if (upsilons.empty()) {
	+
	+
	+ // Finding done, now fill counters
	+ const double weight = e.weight();
	+ if (upsilons.empty()) { // Continuum
	+ MSG_DEBUG("No Upsilons found => continuum event");
	+
	_weightSum_cont += weight;
	- unsigned int nEtaA(0),nEtaB(0),nf0(0);
	+ unsigned int nEtaA(0), nEtaB(0), nf0(0);
	foreach (const Particle& p, ufs.particles()) {
	- int id = p.abspid();
	- double xp = 2.*p.E()/roots;
	- double beta = p.p3().mod() / p.E();
	+ const int id = p.abspid();
	+ const double xp = 2.*p.E()/sqrtS();
	+ const double beta = p.p3().mod() / p.E();
	if (id == 9010221) {
	_hist_cont_f0->fill(xp, weight/beta);
	- ++nf0;
	+ nf0 += 1;
	} else if (id == 331) {
	- if (xp > 0.35) ++nEtaA;
	- ++nEtaB;
	+ if (xp > 0.35) nEtaA += 1;
	+ nEtaB += 1;
	}
	}
	_count_f0[2] += nf0*weight;
	_count_etaPrime_highZ[1] += nEtaA*weight;
	_count_etaPrime_allZ[2] += nEtaB*weight;
	- }
	- else {
	- // Find an Upsilon
	+
	+ } else { // Upsilon(s) found
	+ MSG_DEBUG("Upsilons found => resonance event");
	+
	foreach (const Particle& ups, upsilons) {
	- int parentId = ups.pid();
	+ const int parentId = ups.pid();
	((parentId == 553) ? _weightSum_Ups1 : _weightSum_Ups2) += weight;
	Particles unstable;
	// Find the decay products we want
	findDecayProducts(ups.genParticle(), unstable);
	LorentzTransform cms_boost;
	if (ups.p3().mod() > 1*MeV)
	- cms_boost = LorentzTransform(-ups.momentum().boostVector());
	- double mass = ups.mass();
	+ cms_boost = LorentzTransform::mkFrameTransformFromBeta(ups.momentum().betaVec());
	+ const double mass = ups.mass();
	unsigned int nEtaA(0), nEtaB(0), nf0(0);
	- foreach(const Particle& p , unstable) {
	+ foreach(const Particle& p, unstable) {
	const int id = p.abspid();
	- FourMomentum p2 = cms_boost.transform(p.momentum());
	- double xp = 2.*p2.E()/mass;
	- double beta = p2.p3().mod()/p2.E();
	- if (id == 9010221) {
	+ const FourMomentum p2 = cms_boost.transform(p.momentum());
	+ const double xp = 2.*p2.E()/mass;
	+ const double beta = p2.p3().mod()/p2.E();
	+ if (id == 9010221) { //< ?
	((parentId == 553) ? _hist_Ups1_f0 : _hist_Ups2_f0)->fill(xp, weight/beta);
	- ++nf0;
	- } else if (id == 331) {
	- if (xp > 0.35) ++nEtaA;
	- ++nEtaB;
	+ nf0 += 1;
	+ } else if (id == 331) { //< ?
	+ if (xp > 0.35) nEtaA += 1;
	+ nEtaB += 1;
	}
	}
	if (parentId == 553) {
	_count_f0[0] += nf0*weight;
	_count_etaPrime_highZ[0] += nEtaA*weight;
	_count_etaPrime_allZ[0] += nEtaB*weight;
	} else {
	_count_f0[1] += nf0*weight;
	_count_etaPrime_allZ[1] += nEtaB*weight;
	}
	}
	}
	}


	void finalize() {

	- /// @todo Better to group these by coherent 'if (weightSum_X)' statements?
	-
	// High-Z eta' multiplicity
	Scatter2DPtr s111 = bookScatter2D(1, 1, 1, true);
	if (_weightSum_Ups1 > 0) // Point at 9.460
	s111->point(0).setY(_count_etaPrime_highZ[0] / _weightSum_Ups1, 0);
	if (_weightSum_cont > 0) // Point at 9.905
	s111->point(1).setY(_count_etaPrime_highZ[1] / _weightSum_cont, 0);

	-
	// All-Z eta' multiplicity
	Scatter2DPtr s112 = bookScatter2D(1, 1, 2, true);
	if (_weightSum_Ups1 > 0) // Point at 9.460
	s112->point(0).setY(_count_etaPrime_allZ[0] / _weightSum_Ups1, 0);
	if (_weightSum_cont > 0) // Point at 9.905
	s112->point(1).setY(_count_etaPrime_allZ[2] / _weightSum_cont, 0);
	if (_weightSum_Ups2 > 0) // Point at 10.02
	s112->point(2).setY(_count_etaPrime_allZ[1] / _weightSum_Ups2, 0);

	// f0 multiplicity
	Scatter2DPtr s511 = bookScatter2D(5, 1, 1, true);
	if (_weightSum_Ups1 > 0) // Point at 9.46
	s511->point(0).setY(_count_f0[0] / _weightSum_Ups1, 0);
	if (_weightSum_Ups2 > 0) // Point at 10.02
	s511->point(1).setY(_count_f0[1] / _weightSum_Ups2, 0);
	if (_weightSum_cont > 0) // Point at 10.45
	s511->point(2).setY(_count_f0[2] / _weightSum_cont, 0);

	+ // Scale histos
	if (_weightSum_cont > 0.) scale(_hist_cont_f0, 1./_weightSum_cont);
	if (_weightSum_Ups1 > 0.) scale(_hist_Ups1_f0, 1./_weightSum_Ups1);
	if (_weightSum_Ups2 > 0.) scale(_hist_Ups2_f0, 1./_weightSum_Ups2);
	}


	private:

	/// @name Counters
	//@{
	vector<double> _count_etaPrime_highZ, _count_etaPrime_allZ, _count_f0;
	double _weightSum_cont,_weightSum_Ups1,_weightSum_Ups2;
	//@}


	/// Histos
	Histo1DPtr _hist_cont_f0, _hist_Ups1_f0, _hist_Ups2_f0;


	/// Recursively walk the HepMC tree to find decay products of @a p
	void findDecayProducts(const GenParticle* p, Particles& unstable) {
	const GenVertex* dv = p->end_vertex();
	/// @todo Use better looping
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	const int id = abs((*pp)->pdg_id());
	if (id == 331 \|\| id == 9010221) unstable.push_back(Particle(*pp));
	else if ((pp)->end_vertex()) findDecayProducts(pp, unstable);
	}
	}


	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ARGUS_1993_S2669951);

	}
	diff --git a/src/Analyses/ARGUS_1993_S2789213.cc b/src/Analyses/ARGUS_1993_S2789213.cc
	--- a/src/Analyses/ARGUS_1993_S2789213.cc
	+++ b/src/Analyses/ARGUS_1993_S2789213.cc
	@@ -1,289 +1,256 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	-#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	-#include "Rivet/ParticleName.hh"

	namespace Rivet {


	/// @brief ARGUS vector meson production
	/// @author Peter Richardson
	class ARGUS_1993_S2789213 : public Analysis {
	public:

	ARGUS_1993_S2789213()
	: Analysis("ARGUS_1993_S2789213"),
	_weightSum_cont(0.),_weightSum_Ups1(0.),_weightSum_Ups4(0.)
	{ }


	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");

	_mult_cont_Omega = bookHisto1D( 1, 1, 1);
	_mult_cont_Rho0 = bookHisto1D( 1, 1, 2);
	_mult_cont_KStar0 = bookHisto1D( 1, 1, 3);
	_mult_cont_KStarPlus = bookHisto1D( 1, 1, 4);
	_mult_cont_Phi = bookHisto1D( 1, 1, 5);

	_mult_Ups1_Omega = bookHisto1D( 2, 1, 1);
	_mult_Ups1_Rho0 = bookHisto1D( 2, 1, 2);
	_mult_Ups1_KStar0 = bookHisto1D( 2, 1, 3);
	_mult_Ups1_KStarPlus = bookHisto1D( 2, 1, 4);
	_mult_Ups1_Phi = bookHisto1D( 2, 1, 5);

	_mult_Ups4_Omega = bookHisto1D( 3, 1, 1);
	_mult_Ups4_Rho0 = bookHisto1D( 3, 1, 2);
	_mult_Ups4_KStar0 = bookHisto1D( 3, 1, 3);
	_mult_Ups4_KStarPlus = bookHisto1D( 3, 1, 4);
	_mult_Ups4_Phi = bookHisto1D( 3, 1, 5);

	_hist_cont_KStarPlus = bookHisto1D( 4, 1, 1);
	_hist_Ups1_KStarPlus = bookHisto1D( 5, 1, 1);
	_hist_Ups4_KStarPlus = bookHisto1D( 6, 1, 1);

	_hist_cont_KStar0 = bookHisto1D( 7, 1, 1);
	_hist_Ups1_KStar0 = bookHisto1D( 8, 1, 1);
	_hist_Ups4_KStar0 = bookHisto1D( 9, 1, 1);

	_hist_cont_Rho0 = bookHisto1D(10, 1, 1);
	_hist_Ups1_Rho0 = bookHisto1D(11, 1, 1);
	_hist_Ups4_Rho0 = bookHisto1D(12, 1, 1);

	_hist_cont_Omega = bookHisto1D(13, 1, 1);
	_hist_Ups1_Omega = bookHisto1D(14, 1, 1);
	- } // init
	+ }


	void analyze(const Event& e) {
	const double weight = e.weight();

	- const Beam beamproj = applyProjection<Beam>(e, "Beams");
	- const double s = sqr(beamproj.sqrtS());
	- const double roots = sqrt(s);
	-
	// Find the upsilons
	Particles upsilons;
	// First in unstable final state
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	foreach (const Particle& p, ufs.particles())
	if (p.pid() == 300553 \|\| p.pid() == 553) upsilons.push_back(p);
	// Then in whole event if that failed
	if (upsilons.empty()) {
	foreach (const GenParticle* p, Rivet::particles(e.genEvent())) {
	if (p->pdg_id() != 300553 && p->pdg_id() != 553) continue;
	const GenVertex* pv = p->production_vertex();
	bool passed = true;
	if (pv) {
	foreach (const GenParticle* pp, particles_in(pv)) {
	if ( p->pdg_id() == pp->pdg_id() ) {
	passed = false;
	break;
	}
	}
	}
	if (passed) upsilons.push_back(Particle(*p));
	}
	}

	- // continuum
	- if (upsilons.empty()) {
	+ if (upsilons.empty()) { // continuum
	+
	_weightSum_cont += weight;
	- unsigned int nOmega(0),nRho0(0),nKStar0(0),nKStarPlus(0),nPhi(0);
	+ unsigned int nOmega(0), nRho0(0), nKStar0(0), nKStarPlus(0), nPhi(0);
	foreach (const Particle& p, ufs.particles()) {
	int id = p.abspid();
	- double xp = 2.*p.E()/roots;
	+ double xp = 2.*p.E()/sqrtS();
	double beta = p.p3().mod()/p.E();
	if (id == 113) {
	- _hist_cont_Rho0->fill(xp,weight/beta);
	+ _hist_cont_Rho0->fill(xp, weight/beta);
	++nRho0;
	}
	else if (id == 313) {
	- _hist_cont_KStar0->fill(xp,weight/beta);
	+ _hist_cont_KStar0->fill(xp, weight/beta);
	++nKStar0;
	}
	else if (id == 223) {
	- _hist_cont_Omega->fill(xp,weight/beta);
	+ _hist_cont_Omega->fill(xp, weight/beta);
	++nOmega;
	}
	else if (id == 323) {
	_hist_cont_KStarPlus->fill(xp,weight/beta);
	++nKStarPlus;
	}
	else if (id == 333) {
	++nPhi;
	}
	}
	/// @todo Replace with Counters and fill one-point Scatters at the end
	- _mult_cont_Omega ->fill(10.45,weight*nOmega );
	- _mult_cont_Rho0 ->fill(10.45,weight*nRho0 );
	- _mult_cont_KStar0 ->fill(10.45,weight*nKStar0 );
	- _mult_cont_KStarPlus->fill(10.45,weight*nKStarPlus);
	- _mult_cont_Phi ->fill(10.45,weight*nPhi );
	- }
	- else {
	- // find an upsilon
	+ _mult_cont_Omega ->fill(10.45, weight*nOmega );
	+ _mult_cont_Rho0 ->fill(10.45, weight*nRho0 );
	+ _mult_cont_KStar0 ->fill(10.45, weight*nKStar0 );
	+ _mult_cont_KStarPlus->fill(10.45, weight*nKStarPlus);
	+ _mult_cont_Phi ->fill(10.45, weight*nPhi );
	+
	+ } else { // found an upsilon
	+
	foreach (const Particle& ups, upsilons) {
	- int parentId = ups.pid();
	- if (parentId == 553)
	- _weightSum_Ups1 += weight;
	- else
	- _weightSum_Ups4 += weight;
	+ const int parentId = ups.pid();
	+ (parentId == 553 ? _weightSum_Ups1 : _weightSum_Ups4) += weight;
	Particles unstable;
	- // find the decay products we want
	+ // Find the decay products we want
	findDecayProducts(ups.genParticle(),unstable);
	+ /// @todo Update to new LT mk* functions
	LorentzTransform cms_boost;
	if (ups.p3().mod() > 0.001)
	- cms_boost = LorentzTransform(-ups.momentum().boostVector());
	+ cms_boost = LorentzTransform::mkFrameTransformFromBeta(ups.momentum().betaVec());
	double mass = ups.mass();
	unsigned int nOmega(0),nRho0(0),nKStar0(0),nKStarPlus(0),nPhi(0);
	foreach(const Particle & p , unstable) {
	int id = p.abspid();
	FourMomentum p2 = cms_boost.transform(p.momentum());
	double xp = 2.*p2.E()/mass;
	double beta = p2.p3().mod()/p2.E();
	if (id == 113) {
	if (parentId == 553) _hist_Ups1_Rho0->fill(xp,weight/beta);
	else _hist_Ups4_Rho0->fill(xp,weight/beta);
	++nRho0;
	}
	else if (id == 313) {
	if (parentId == 553) _hist_Ups1_KStar0->fill(xp,weight/beta);
	else _hist_Ups4_KStar0->fill(xp,weight/beta);
	++nKStar0;
	}
	else if (id == 223) {
	if (parentId == 553) _hist_Ups1_Omega->fill(xp,weight/beta);
	++nOmega;
	}
	else if (id == 323) {
	if (parentId == 553) _hist_Ups1_KStarPlus->fill(xp,weight/beta);
	else _hist_Ups4_KStarPlus->fill(xp,weight/beta);
	++nKStarPlus;
	}
	else if (id == 333) {
	++nPhi;
	}
	}
	if (parentId == 553) {
	_mult_Ups1_Omega ->fill(9.46,weight*nOmega );
	_mult_Ups1_Rho0 ->fill(9.46,weight*nRho0 );
	_mult_Ups1_KStar0 ->fill(9.46,weight*nKStar0 );
	_mult_Ups1_KStarPlus->fill(9.46,weight*nKStarPlus);
	_mult_Ups1_Phi ->fill(9.46,weight*nPhi );
	}
	else {
	_mult_Ups4_Omega ->fill(10.58,weight*nOmega );
	_mult_Ups4_Rho0 ->fill(10.58,weight*nRho0 );
	_mult_Ups4_KStar0 ->fill(10.58,weight*nKStar0 );
	_mult_Ups4_KStarPlus->fill(10.58,weight*nKStarPlus);
	_mult_Ups4_Phi ->fill(10.58,weight*nPhi );
	}
	}
	}
	- } // analyze
	+
	+ }


	void finalize() {
	if (_weightSum_cont > 0.) {
	/// @todo Replace with Counters and fill one-point Scatters at the end
	scale(_mult_cont_Omega , 1./_weightSum_cont);
	scale(_mult_cont_Rho0 , 1./_weightSum_cont);
	scale(_mult_cont_KStar0 , 1./_weightSum_cont);
	scale(_mult_cont_KStarPlus, 1./_weightSum_cont);
	scale(_mult_cont_Phi , 1./_weightSum_cont);
	scale(_hist_cont_KStarPlus, 1./_weightSum_cont);
	scale(_hist_cont_KStar0 , 1./_weightSum_cont);
	scale(_hist_cont_Rho0 , 1./_weightSum_cont);
	scale(_hist_cont_Omega , 1./_weightSum_cont);
	}
	if (_weightSum_Ups1 > 0.) {
	/// @todo Replace with Counters and fill one-point Scatters at the end
	scale(_mult_Ups1_Omega , 1./_weightSum_Ups1);
	scale(_mult_Ups1_Rho0 , 1./_weightSum_Ups1);
	scale(_mult_Ups1_KStar0 , 1./_weightSum_Ups1);
	scale(_mult_Ups1_KStarPlus, 1./_weightSum_Ups1);
	scale(_mult_Ups1_Phi , 1./_weightSum_Ups1);
	scale(_hist_Ups1_KStarPlus, 1./_weightSum_Ups1);
	scale(_hist_Ups1_KStar0 , 1./_weightSum_Ups1);
	scale(_hist_Ups1_Rho0 , 1./_weightSum_Ups1);
	scale(_hist_Ups1_Omega , 1./_weightSum_Ups1);
	}
	if (_weightSum_Ups4 > 0.) {
	/// @todo Replace with Counters and fill one-point Scatters at the end
	scale(_mult_Ups4_Omega , 1./_weightSum_Ups4);
	scale(_mult_Ups4_Rho0 , 1./_weightSum_Ups4);
	scale(_mult_Ups4_KStar0 , 1./_weightSum_Ups4);
	scale(_mult_Ups4_KStarPlus, 1./_weightSum_Ups4);
	scale(_mult_Ups4_Phi , 1./_weightSum_Ups4);
	scale(_hist_Ups4_KStarPlus, 1./_weightSum_Ups4);
	scale(_hist_Ups4_KStar0 , 1./_weightSum_Ups4);
	scale(_hist_Ups4_Rho0 , 1./_weightSum_Ups4);
	}
	- } // finalize
	+ }


	private:

	//@{
	- Histo1DPtr _mult_cont_Omega ;
	- Histo1DPtr _mult_cont_Rho0 ;
	- Histo1DPtr _mult_cont_KStar0 ;
	- Histo1DPtr _mult_cont_KStarPlus;
	- Histo1DPtr _mult_cont_Phi ;
	-
	- Histo1DPtr _mult_Ups1_Omega ;
	- Histo1DPtr _mult_Ups1_Rho0 ;
	- Histo1DPtr _mult_Ups1_KStar0 ;
	- Histo1DPtr _mult_Ups1_KStarPlus;
	- Histo1DPtr _mult_Ups1_Phi ;
	-
	- Histo1DPtr _mult_Ups4_Omega ;
	- Histo1DPtr _mult_Ups4_Rho0 ;
	- Histo1DPtr _mult_Ups4_KStar0 ;
	- Histo1DPtr _mult_Ups4_KStarPlus;
	- Histo1DPtr _mult_Ups4_Phi ;
	-
	- Histo1DPtr _hist_cont_KStarPlus;
	- Histo1DPtr _hist_Ups1_KStarPlus;
	- Histo1DPtr _hist_Ups4_KStarPlus;
	-
	- Histo1DPtr _hist_cont_KStar0 ;
	- Histo1DPtr _hist_Ups1_KStar0 ;
	- Histo1DPtr _hist_Ups4_KStar0 ;
	-
	- Histo1DPtr _hist_cont_Rho0 ;
	- Histo1DPtr _hist_Ups1_Rho0 ;
	- Histo1DPtr _hist_Ups4_Rho0 ;
	-
	- Histo1DPtr _hist_cont_Omega ;
	- Histo1DPtr _hist_Ups1_Omega ;
	+ Histo1DPtr _mult_cont_Omega, _mult_cont_Rho0, _mult_cont_KStar0, _mult_cont_KStarPlus, _mult_cont_Phi;
	+ Histo1DPtr _mult_Ups1_Omega, _mult_Ups1_Rho0, _mult_Ups1_KStar0, _mult_Ups1_KStarPlus, _mult_Ups1_Phi;
	+ Histo1DPtr _mult_Ups4_Omega, _mult_Ups4_Rho0, _mult_Ups4_KStar0, _mult_Ups4_KStarPlus, _mult_Ups4_Phi;
	+ Histo1DPtr _hist_cont_KStarPlus, _hist_Ups1_KStarPlus, _hist_Ups4_KStarPlus;
	+ Histo1DPtr _hist_cont_KStar0, _hist_Ups1_KStar0, _hist_Ups4_KStar0 ;
	+ Histo1DPtr _hist_cont_Rho0, _hist_Ups1_Rho0, _hist_Ups4_Rho0;
	+ Histo1DPtr _hist_cont_Omega, _hist_Ups1_Omega;

	double _weightSum_cont,_weightSum_Ups1,_weightSum_Ups4;
	//@}


	void findDecayProducts(const GenParticle* p, Particles& unstable) {
	const GenVertex* dv = p->end_vertex();
	/// @todo Use better looping
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	int id = abs((*pp)->pdg_id());
	if (id == 113 \|\| id == 313 \|\| id == 323 \|\|
	id == 333 \|\| id == 223 ) {
	unstable.push_back(Particle(*pp));
	}
	else if ((*pp)->end_vertex())
	findDecayProducts(*pp, unstable);
	}
	}

	+
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ARGUS_1993_S2789213);

	}
	diff --git a/src/Analyses/ATLAS_2010_CONF_2010_049.cc b/src/Analyses/ATLAS_2010_CONF_2010_049.cc
	--- a/src/Analyses/ATLAS_2010_CONF_2010_049.cc
	+++ b/src/Analyses/ATLAS_2010_CONF_2010_049.cc
	@@ -1,126 +1,126 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2010_CONF_2010_049 : public Analysis {
	public:

	ATLAS_2010_CONF_2010_049()
	: Analysis("ATLAS_2010_CONF_2010_049")
	{ }


	void init() {
	ChargedFinalState cfs(-1.5, 1.5, 0.5*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	FastJets jetsproj6(cfs, FastJets::ANTIKT, 0.6);
	- addProjection(jetsproj6, "Jets6");
	+ declare(jetsproj6, "Jets6");

	FastJets jetsproj4(cfs, FastJets::ANTIKT, 0.4);
	- addProjection(jetsproj4, "Jets4");
	+ declare(jetsproj4, "Jets4");

	for (size_t i=0 ; i<2 ; i++) {
	_h_xsec[i] = bookHisto1D(1+i, 1, 1);
	_h_frag_04_06[i] = bookHisto1D(3+i, 1, 1);
	_h_frag_06_10[i] = bookHisto1D(3+i, 2, 1);
	_h_frag_10_15[i] = bookHisto1D(3+i, 3, 1);
	_h_frag_15_24[i] = bookHisto1D(3+i, 4, 1);
	_njets_04_06[i] = 0.0;
	_njets_06_10[i] = 0.0;
	_njets_10_15[i] = 0.0;
	_njets_15_24[i] = 0.0;
	}
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const FastJets & jetsproj6 = applyProjection<FastJets>(event, "Jets6");
	- const FastJets & jetsproj4 = applyProjection<FastJets>(event, "Jets4");
	+ const FastJets & jetsproj6 = apply<FastJets>(event, "Jets6");
	+ const FastJets & jetsproj4 = apply<FastJets>(event, "Jets4");
	Jets alljets[2];
	alljets[0] = jetsproj6.jetsByPt(4.0*GeV);
	alljets[1] = jetsproj4.jetsByPt(4.0*GeV);

	for (size_t i=0 ; i<2 ; i++) {
	Jets jets;

	// First we want to make sure that we only use jets within \|eta\|<0.57
	foreach (const Jet& jet, alljets[i]) {
	if (jet.abseta()<0.57) {
	jets.push_back(jet);
	}
	}
	foreach (const Jet& jet, jets) {
	const double pTjet = jet.pT();
	const double pjet = jet.p3().mod();
	_h_xsec[i]->fill(pTjet, weight);
	if (pTjet > 24*GeV) continue;
	foreach (const Particle& p, jet.particles()) {
	double z = p.p3().mod()/pjet;
	if (z >= 1) z = 0.9999; // Make sure that z=1 doesn't go into overflow
	if (pTjet > 15*GeV) {
	_h_frag_15_24[i]->fill(z, weight);
	}
	else if (pTjet > 10*GeV) {
	_h_frag_10_15[i]->fill(z, weight);
	}
	else if (pTjet > 6*GeV) {
	_h_frag_06_10[i]->fill(z, weight);
	}
	else {
	_h_frag_04_06[i]->fill(z, weight);
	}
	}
	if (pTjet > 15*GeV) {
	_njets_15_24[i] += weight;
	}
	else if (pTjet > 10*GeV) {
	_njets_10_15[i] += weight;
	}
	else if (pTjet > 6*GeV) {
	_njets_06_10[i] += weight;
	}
	else {
	_njets_04_06[i] += weight;
	}
	}
	}
	}

	void finalize() {
	for (size_t i=0 ; i<2 ; i++) {
	// deta = 2*0.57
	scale(_h_xsec[i], crossSection()/microbarn/sumOfWeights()/(2*0.57));
	scale(_h_frag_04_06[i], 1./_njets_04_06[i]);
	scale(_h_frag_06_10[i], 1./_njets_06_10[i]);
	scale(_h_frag_10_15[i], 1./_njets_10_15[i]);
	scale(_h_frag_15_24[i], 1./_njets_15_24[i]);
	}
	}


	private:

	Histo1DPtr _h_xsec[2];
	Histo1DPtr _h_frag_04_06[2];
	Histo1DPtr _h_frag_06_10[2];
	Histo1DPtr _h_frag_10_15[2];
	Histo1DPtr _h_frag_15_24[2];
	double _njets_04_06[2];
	double _njets_06_10[2];
	double _njets_10_15[2];
	double _njets_15_24[2];
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2010_CONF_2010_049);

	}
	diff --git a/src/Analyses/ATLAS_2010_S8591806.cc b/src/Analyses/ATLAS_2010_S8591806.cc
	--- a/src/Analyses/ATLAS_2010_S8591806.cc
	+++ b/src/Analyses/ATLAS_2010_S8591806.cc
	@@ -1,72 +1,72 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	/// @brief ATLAS minimum bias analysis at 900 GeV
	/// @author Frank Siegert
	class ATLAS_2010_S8591806 : public Analysis {
	public:

	ATLAS_2010_S8591806()
	: Analysis("ATLAS_2010_S8591806"),
	_Nevt_after_cuts(0.0)
	{ }


	void init() {
	ChargedFinalState cfs(-2.5, 2.5, 0.5*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	_h_dNch_deta = bookHisto1D(2, 1, 1);
	_h_dNch_dpT = bookHisto1D(3, 1, 1);
	_h_dNevt_dNch = bookHisto1D(4, 1, 1);
	_p_meanpT_Nch = bookProfile1D(5, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ChargedFinalState& charged = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& charged = apply<ChargedFinalState>(event, "CFS");
	if (charged.size() < 1) {
	vetoEvent;
	}
	_Nevt_after_cuts += weight;

	_h_dNevt_dNch->fill(charged.size(), weight);
	foreach (const Particle& p, charged.particles()) {
	double pT = p.pT()/GeV;
	_h_dNch_deta->fill(p.eta(), weight);
	_h_dNch_dpT->fill(pT, weight/pT);
	_p_meanpT_Nch->fill(charged.size(), pT, weight);
	}
	}


	void finalize() {
	double deta = 5.0;
	scale(_h_dNch_deta, 1.0/_Nevt_after_cuts);
	scale(_h_dNch_dpT, 1.0/_Nevt_after_cuts/TWOPI/deta);
	scale(_h_dNevt_dNch, 1.0/_Nevt_after_cuts);
	}


	private:

	Histo1DPtr _h_dNch_deta;
	Histo1DPtr _h_dNch_dpT;
	Histo1DPtr _h_dNevt_dNch;
	Profile1DPtr _p_meanpT_Nch;

	double _Nevt_after_cuts;

	};


	//DECLARE_RIVET_PLUGIN(ATLAS_2010_S8591806);
	DECLARE_ALIASED_RIVET_PLUGIN(ATLAS_2010_S8591806, ATLAS_2010_I849050);

	}
	diff --git a/src/Analyses/ATLAS_2010_S8817804.cc b/src/Analyses/ATLAS_2010_S8817804.cc
	--- a/src/Analyses/ATLAS_2010_S8817804.cc
	+++ b/src/Analyses/ATLAS_2010_S8817804.cc
	@@ -1,122 +1,122 @@
	// -- C++ --

	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief ATLAS inclusive jet pT spectrum, di-jet Mass and di-jet chi
	class ATLAS_2010_S8817804: public Analysis {
	public:

	ATLAS_2010_S8817804() : Analysis("ATLAS_2010_S8817804")
	{ }


	private:

	enum Alg { AKT4=0, AKT6=1 };


	public:

	void init() {
	FinalState fs;
	- addProjection(fs, "FinalState");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.6), "AntiKT06");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.4), "AntiKT04");
	+ declare(fs, "FinalState");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.6), "AntiKT06");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.4), "AntiKT04");

	double ybins[] = { 0.0, 0.3, 0.8, 1.2, 2.1, 2.8 };
	double massBinsForChi[] = { 340, 520, 800, 1200 };


	size_t ptDsOffset(0), massDsOffset(10), chiDsOffset(20);
	for (size_t alg = 0; alg < 2; ++alg) {
	for (size_t i = 0; i < 5; ++i) {
	_pThistos[alg].addHistogram(ybins[i], ybins[i+1], bookHisto1D(i + 1 + ptDsOffset, 1, 1));
	}
	ptDsOffset += 5;

	for (size_t i = 0; i < 5; ++i) {
	_massVsY[alg].addHistogram(ybins[i], ybins[i+1], bookHisto1D(i + 1 + massDsOffset, 1, 1));
	}
	massDsOffset += 5;

	for (size_t i = 0; i < 3; ++i) {
	_chiVsMass[alg].addHistogram(massBinsForChi[i], massBinsForChi[i+1], bookHisto1D(i + 1 + chiDsOffset, 1, 1));
	}
	chiDsOffset += 3;
	}
	}


	void analyze(const Event& evt) {
	Jets jetAr[2];
	- jetAr[AKT6] = applyProjection<FastJets>(evt, "AntiKT06").jetsByPt(30*GeV);
	- jetAr[AKT4] = applyProjection<FastJets>(evt, "AntiKT04").jetsByPt(30*GeV);
	+ jetAr[AKT6] = apply<FastJets>(evt, "AntiKT06").jetsByPt(30*GeV);
	+ jetAr[AKT4] = apply<FastJets>(evt, "AntiKT04").jetsByPt(30*GeV);

	// Identify the dijets
	for (size_t alg = 0; alg < 2; ++alg) {
	vector<FourMomentum> leadjets;
	foreach (const Jet& jet, jetAr[alg]) {
	const double pT = jet.pT();
	const double absy = jet.absrap();
	_pThistos[alg].fill(absy, pT/GeV, evt.weight());

	if (absy < 2.8 && leadjets.size() < 2) {
	if (leadjets.empty() && pT < 60*GeV) continue;
	leadjets.push_back(jet.momentum());
	}
	}

	// Veto if no acceptable dijet found
	if (leadjets.size() < 2) {
	MSG_DEBUG("Could not find two suitable leading jets");
	continue;
	}

	const double rap1 = leadjets[0].rapidity();
	const double rap2 = leadjets[1].rapidity();
	const double mass = (leadjets[0] + leadjets[1]).mass();
	const double ymax = max(fabs(rap1), fabs(rap2));
	const double chi = exp(fabs(rap1 - rap2));
	if (fabs(rap1 + rap2) < 2.2) {
	_chiVsMass[alg].fill(mass/GeV, chi, evt.weight());
	}
	_massVsY[alg].fill(ymax, mass/GeV, evt.weight());

	}
	}


	void finalize() {
	for (size_t alg = 0; alg < 2; ++alg) {
	// factor 0.5 needed because it is differential in dy and not d\|y\|
	_pThistos[alg].scale(0.5*crossSectionPerEvent()/picobarn, this);
	_massVsY[alg].scale(crossSectionPerEvent()/picobarn, this);
	_chiVsMass[alg].scale(crossSectionPerEvent()/picobarn, this);
	}
	}


	private:

	/// The inclusive pT spectrum for akt6 and akt4 jets (array index is jet type from enum above)
	BinnedHistogram<double> _pThistos[2];

	/// The di-jet mass spectrum binned in rapidity for akt6 and akt4 jets (array index is jet type from enum above)
	BinnedHistogram<double> _massVsY[2];

	/// The di-jet chi distribution binned in mass for akt6 and akt4 jets (array index is jet type from enum above)
	BinnedHistogram<double> _chiVsMass[2];

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2010_S8817804);

	}
	diff --git a/src/Analyses/ATLAS_2010_S8894728.cc b/src/Analyses/ATLAS_2010_S8894728.cc
	--- a/src/Analyses/ATLAS_2010_S8894728.cc
	+++ b/src/Analyses/ATLAS_2010_S8894728.cc
	@@ -1,342 +1,342 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class ATLAS_2010_S8894728 : public Analysis {
	public:

	ATLAS_2010_S8894728() : Analysis("ATLAS_2010_S8894728") { }


	void init() {
	const ChargedFinalState cfs100(-2.5, 2.5, 100*MeV);
	- addProjection(cfs100, "CFS100");
	+ declare(cfs100, "CFS100");
	const ChargedFinalState cfs500(-2.5, 2.5, 500*MeV);
	- addProjection(cfs500, "CFS500");
	+ declare(cfs500, "CFS500");
	const ChargedFinalState cfslead(-2.5, 2.5, 1.0*GeV);
	- addProjection(cfslead, "CFSlead");
	+ declare(cfslead, "CFSlead");

	// Get an index for the beam energy
	int isqrts = -1;
	if (fuzzyEquals(sqrtS(), 900*GeV)) isqrts = 0;
	else if (fuzzyEquals(sqrtS(), 7*TeV)) isqrts = 1;
	assert(isqrts >= 0);

	// Nch profiles, 500 MeV track pT cut
	_hist_nch_transverse_500[0] = bookProfile1D(1+isqrts, 1, 1);
	_hist_nch_toward_500 = bookProfile1D(1+isqrts, 1, 2);
	_hist_nch_away_500 = bookProfile1D(1+isqrts, 1, 3);

	// pTsum profiles, 500 MeV track pT cut
	_hist_ptsum_transverse_500[0] = bookProfile1D(3+isqrts, 1, 1);
	_hist_ptsum_toward_500 = bookProfile1D(3+isqrts, 1, 2);
	_hist_ptsum_away_500 = bookProfile1D(3+isqrts, 1, 3);

	// Standard deviation profiles
	// First the higher moments of main profiles to calculate variance and error on variance...
	for (size_t i = 1; i < 4; ++i) {
	_hist_nch_transverse_500[i].reset(new Profile1D(refData(1+isqrts, 1, 1)));
	_hist_ptsum_transverse_500[i].reset(new Profile1D(refData(3+isqrts, 1, 1)));
	}
	// Then the data point sets into which the results will be inserted
	_dps_sdnch_transverse_500 = bookScatter2D(5+isqrts, 1, 1);
	_dps_sdptsum_transverse_500 = bookScatter2D(7+isqrts, 1, 1);

	// <pT> profiles, 500 MeV track pT cut
	_hist_ptavg_transverse_500 = bookProfile1D(9+isqrts, 1, 1);
	_hist_ptavg_toward_500 = bookProfile1D(9+isqrts, 1, 2);
	_hist_ptavg_away_500 = bookProfile1D(9+isqrts, 1, 3);

	// <pT> vs. Nch profiles, 500 MeV track pT cut
	_hist_dn_dpt_transverse_500 = bookProfile1D(11+isqrts, 1, 1);
	_hist_dn_dpt_toward_500 = bookProfile1D(11+isqrts, 1, 2);
	_hist_dn_dpt_away_500 = bookProfile1D(11+isqrts, 1, 3);

	// Nch vs. Delta(phi) profiles, 500 MeV track pT cut
	_hist_N_vs_dPhi_1_500 = bookProfile1D(13+isqrts, 1, 1);
	_hist_N_vs_dPhi_2_500 = bookProfile1D(13+isqrts, 1, 2);
	_hist_N_vs_dPhi_3_500 = bookProfile1D(13+isqrts, 1, 3);
	_hist_N_vs_dPhi_5_500 = bookProfile1D(13+isqrts, 1, 4);
	// pT vs. Delta(phi) profiles, 500 MeV track pT cut
	_hist_pT_vs_dPhi_1_500 = bookProfile1D(15+isqrts, 1, 1);
	_hist_pT_vs_dPhi_2_500 = bookProfile1D(15+isqrts, 1, 2);
	_hist_pT_vs_dPhi_3_500 = bookProfile1D(15+isqrts, 1, 3);
	_hist_pT_vs_dPhi_5_500 = bookProfile1D(15+isqrts, 1, 4);

	// Nch and pTsum profiles, 100 MeV track pT cut
	_hist_nch_transverse_100 = bookProfile1D(17+isqrts, 1, 1);
	_hist_nch_toward_100 = bookProfile1D(17+isqrts, 1, 2);
	_hist_nch_away_100 = bookProfile1D(17+isqrts, 1, 3);
	_hist_ptsum_transverse_100 = bookProfile1D(19+isqrts, 1, 1);
	_hist_ptsum_toward_100 = bookProfile1D(19+isqrts, 1, 2);
	_hist_ptsum_away_100 = bookProfile1D(19+isqrts, 1, 3);

	// Profiles vs. eta (7 TeV only)
	if (isqrts == 1) {
	_hist_nch_vs_eta_transverse_100 = bookProfile1D(21, 1, 1);
	_hist_ptsum_vs_eta_transverse_100 = bookProfile1D(22, 1, 1);
	}

	}


	// Little helper function to identify Delta(phi) regions
	inline int region_index(double dphi) {
	assert(inRange(dphi, 0.0, PI, CLOSED, CLOSED));
	if (dphi < PI/3.0) return 0;
	if (dphi < 2*PI/3.0) return 1;
	return 2;
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	// Require at least one track in the event with pT >= 1 GeV
	- const ChargedFinalState& cfslead = applyProjection<ChargedFinalState>(event, "CFSlead");
	+ const ChargedFinalState& cfslead = apply<ChargedFinalState>(event, "CFSlead");
	if (cfslead.size() < 1) {
	vetoEvent;
	}

	// These are the charged particles (tracks) with pT > 500 MeV
	- const ChargedFinalState& charged500 = applyProjection<ChargedFinalState>(event, "CFS500");
	+ const ChargedFinalState& charged500 = apply<ChargedFinalState>(event, "CFS500");

	// Identify leading track and its phi and pT (this is the same for both the 100 MeV and 500 MeV track cuts)
	Particles particles500 = charged500.particlesByPt();
	Particle p_lead = particles500[0];
	const double philead = p_lead.phi();
	const double etalead = p_lead.eta();
	const double pTlead = p_lead.perp();
	MSG_DEBUG("Leading track: pT = " << pTlead << ", eta = " << etalead << ", phi = " << philead);

	// Iterate over all > 500 MeV particles and count particles and scalar pTsum in the three regions
	vector<double> num500(3, 0), ptSum500(3, 0.0);
	// Temporary histos that bin Nch and pT in dPhi.
	// NB. Only one of each needed since binnings are the same for the energies and pT cuts
	Histo1D hist_num_dphi_500(refData(13,1,1));
	Histo1D hist_pt_dphi_500(refData(15,1,1));
	foreach (const Particle& p, particles500) {
	const double pT = p.pT();
	const double dPhi = deltaPhi(philead, p.phi());
	const int ir = region_index(dPhi);
	num500[ir] += 1;
	ptSum500[ir] += pT;

	// Fill temp histos to bin Nch and pT in dPhi
	if (p.genParticle() != p_lead.genParticle()) { // We don't want to fill all those zeros from the leading track...
	hist_num_dphi_500.fill(dPhi, 1);
	hist_pt_dphi_500.fill(dPhi, pT);
	}
	}


	// Iterate over charged particles again for profiles against Nch
	// This is necessary since the Nch are region-specific and so are only known after the first loop
	foreach (const Particle& p, particles500) {
	const double pT = p.pT();
	const double dPhi = deltaPhi(philead, p.phi());
	const int ir = region_index(dPhi);
	switch (ir) {
	case 0:
	_hist_dn_dpt_toward_500->fill(num500[0], pT, weight);
	break;
	case 1:
	_hist_dn_dpt_transverse_500->fill(num500[1], pT, weight);
	break;
	case 2:
	_hist_dn_dpt_away_500->fill(num500[2], pT, weight);
	break;
	default:
	assert(false && "How did we get here?");
	}
	}


	// Now fill underlying event histograms
	// The densities are calculated by dividing the UE properties by dEta*dPhi
	// -- each region has a dPhi of 2*PI/3 and dEta is two times 2.5
	const double dEtadPhi = (22.5 2*PI/3.0);
	// Transverse profiles need 4 orders of moments for stddev with errors
	for (int i = 0; i < 4; ++i) {
	_hist_nch_transverse_500[i]->fill(pTlead/GeV, intpow(num500[1]/dEtadPhi, i+1), weight);
	_hist_ptsum_transverse_500[i]->fill(pTlead/GeV, intpow(ptSum500[1]/GeV/dEtadPhi, i+1), weight);
	}
	// Toward and away profiles only need the first moment (the mean)
	_hist_nch_toward_500->fill(pTlead/GeV, num500[0]/dEtadPhi, weight);
	_hist_nch_away_500->fill(pTlead/GeV, num500[2]/dEtadPhi, weight);
	_hist_ptsum_toward_500->fill(pTlead/GeV, ptSum500[0]/GeV/dEtadPhi, weight);
	_hist_ptsum_away_500->fill(pTlead/GeV, ptSum500[2]/GeV/dEtadPhi, weight);
	// <pT> profiles
	//MSG_INFO("Trans pT1, pTsum, Nch, <pT>" << pTlead/GeV << ", " << ptSum500[1]/GeV << ", " << num500[1] << ", " << ptSum500[1]/GeV/num500[1]);
	if (num500[1] > 0) _hist_ptavg_transverse_500->fill(pTlead/GeV, ptSum500[1]/GeV/num500[1], weight);
	if (num500[0] > 0) _hist_ptavg_toward_500->fill(pTlead/GeV, ptSum500[0]/GeV/num500[0], weight);
	if (num500[2] > 0) _hist_ptavg_away_500->fill(pTlead/GeV, ptSum500[2]/GeV/num500[2], weight);


	// Update the "proper" dphi profile histograms
	// Note that we fill dN/dEtadPhi: dEta = 22.5, dPhi = 2PI/nBins
	// The values tabulated in the note are for an (undefined) signed Delta(phi) rather than
	// \|Delta(phi)\| and so differ by a factor of 2: we have to actually norm for angular range = 2pi
	const size_t nbins = refData(13,1,1).numPoints();
	std::vector<double> ptcut;
	if (fuzzyEquals(sqrtS(), 900*GeV)) {
	ptcut += 1.0; ptcut += 1.5; ptcut += 2.0; ptcut += 2.5;
	}
	else if (fuzzyEquals(sqrtS(), 7*TeV)) {
	ptcut += 1.0; ptcut += 2.0; ptcut += 3.0; ptcut += 5.0;
	}
	assert(ptcut.size() == 4);
	for (size_t i = 0; i < nbins; ++i) {
	// First Nch
	double mean = hist_num_dphi_500.bin(i).xMid();
	double value = 0.;
	if (hist_num_dphi_500.bin(i).numEntries() > 0) {
	mean = hist_num_dphi_500.bin(i).xMean();
	value = hist_num_dphi_500.bin(i).area()/hist_num_dphi_500.bin(i).xWidth()/10.0;
	}
	if (pTlead/GeV >= ptcut[0]) _hist_N_vs_dPhi_1_500->fill(mean, value, weight);
	if (pTlead/GeV >= ptcut[1]) _hist_N_vs_dPhi_2_500->fill(mean, value, weight);
	if (pTlead/GeV >= ptcut[2]) _hist_N_vs_dPhi_3_500->fill(mean, value, weight);
	if (pTlead/GeV >= ptcut[3]) _hist_N_vs_dPhi_5_500->fill(mean, value, weight);

	// Then pT
	mean = hist_pt_dphi_500.bin(i).xMid();
	value = 0.;
	if (hist_pt_dphi_500.bin(i).numEntries() > 0) {
	mean = hist_pt_dphi_500.bin(i).xMean();
	value = hist_pt_dphi_500.bin(i).area()/hist_pt_dphi_500.bin(i).xWidth()/10.0;
	}
	if (pTlead/GeV >= ptcut[0]) _hist_pT_vs_dPhi_1_500->fill(mean, value, weight);
	if (pTlead/GeV >= ptcut[1]) _hist_pT_vs_dPhi_2_500->fill(mean, value, weight);
	if (pTlead/GeV >= ptcut[2]) _hist_pT_vs_dPhi_3_500->fill(mean, value, weight);
	if (pTlead/GeV >= ptcut[3]) _hist_pT_vs_dPhi_5_500->fill(mean, value, weight);
	}


	//////////////////////


	// These are the charged particles (tracks) with pT > 100 MeV
	- const ChargedFinalState& charged100 = applyProjection<ChargedFinalState>(event, "CFS100");
	+ const ChargedFinalState& charged100 = apply<ChargedFinalState>(event, "CFS100");

	// Iterate over all > 100 MeV particles and count particles and scalar pTsum in the three regions
	vector<double> num100(3, 0), ptSum100(3, 0.0);
	foreach (const Particle& p, charged100.particles()) {
	const double pT = p.pT();
	const double dPhi = deltaPhi(philead, p.phi());
	const int ir = region_index(dPhi);
	num100[ir] += 1;
	ptSum100[ir] += pT;
	}

	// Now fill the two sets of 100 MeV underlying event histograms
	_hist_nch_transverse_100->fill(pTlead/GeV, num100[1]/dEtadPhi, weight);
	_hist_nch_toward_100->fill(pTlead/GeV, num100[0]/dEtadPhi, weight);
	_hist_nch_away_100->fill(pTlead/GeV, num100[2]/dEtadPhi, weight);
	_hist_ptsum_transverse_100->fill(pTlead/GeV, ptSum100[1]/GeV/dEtadPhi, weight);
	_hist_ptsum_toward_100->fill(pTlead/GeV, ptSum100[0]/GeV/dEtadPhi, weight);
	_hist_ptsum_away_100->fill(pTlead/GeV, ptSum100[2]/GeV/dEtadPhi, weight);

	// And finally the Nch and pT vs eta_lead profiles (again from > 100 MeV tracks, and only at 7 TeV)
	if (fuzzyEquals(sqrtS(), 7TeV) && pTlead > 5GeV) {
	// MSG_INFO(sqrtS() << " " << pTlead << " " << ptSum100[1]/dEtadPhi << " " << num100[1]/dEtadPhi);
	_hist_nch_vs_eta_transverse_100->fill(etalead, num100[1]/dEtadPhi, weight);
	_hist_ptsum_vs_eta_transverse_100->fill(etalead, ptSum100[1]/GeV/dEtadPhi, weight);
	}

	}


	void finalize() {
	// Convert the various moments of the 500 MeV trans pT and Nch distributions to std devs with correct error
	_moments_to_stddev(_hist_nch_transverse_500, _dps_sdnch_transverse_500);
	_moments_to_stddev(_hist_ptsum_transverse_500, _dps_sdptsum_transverse_500);
	}


	private:


	inline void _moments_to_stddev(Profile1DPtr moment_profiles[], Scatter2DPtr target_dps) {
	for (size_t b = 0; b < moment_profiles[0]->numBins(); ++b) { // loop over points
	/// @todo Assuming unit weights here! Should use N_effective = sumW**2/sumW2?
	const double numentries = moment_profiles[0]->bin(b).numEntries();
	const double x = moment_profiles[0]->bin(b).xMid();
	const double ex = moment_profiles[0]->bin(b).xWidth()/2.;
	double var = 0.;
	double sd = 0.;
	if (numentries > 0) {
	var = moment_profiles[1]->bin(b).mean() - intpow(moment_profiles[0]->bin(b).mean(), 2);
	sd = fuzzyLessEquals(var,0.) ? 0 : sqrt(var); ///< Numerical safety check
	}
	if (sd == 0 \|\| numentries < 3) {
	MSG_WARNING("Need at least 3 bin entries and a non-zero central value to calculate "
	<< "an error on standard deviation profiles (bin " << b << ")");
	target_dps->addPoint(x, sd, ex, 0);
	continue;
	}
	// c2(y) = m4(x) - 4 m3(x) m1(x) - m2(x)^2 + 8 m2(x) m1(x)^2 - 4 m1(x)^4
	const double var_on_var = moment_profiles[3]->bin(b).mean()
	- 4 * moment_profiles[2]->bin(b).mean() * moment_profiles[0]->bin(b).mean()
	- intpow(moment_profiles[1]->bin(b).mean(), 2)
	+ 8 * moment_profiles[1]->bin(b).mean() * intpow(moment_profiles[0]->bin(b).mean(), 2)
	- 4 * intpow(moment_profiles[0]->bin(b).mean(), 4);
	const double stderr_on_var = sqrt(var_on_var/(numentries-2.0));
	const double stderr_on_sd = stderr_on_var / (2.0*sd);
	target_dps->addPoint(x, sd, ex, stderr_on_sd);
	}
	}


	private:

	Profile1DPtr _hist_nch_transverse_500[4];
	Profile1DPtr _hist_nch_toward_500;
	Profile1DPtr _hist_nch_away_500;

	Profile1DPtr _hist_ptsum_transverse_500[4];
	Profile1DPtr _hist_ptsum_toward_500;
	Profile1DPtr _hist_ptsum_away_500;

	Scatter2DPtr _dps_sdnch_transverse_500;
	Scatter2DPtr _dps_sdptsum_transverse_500;

	Profile1DPtr _hist_ptavg_transverse_500;
	Profile1DPtr _hist_ptavg_toward_500;
	Profile1DPtr _hist_ptavg_away_500;

	Profile1DPtr _hist_dn_dpt_transverse_500;
	Profile1DPtr _hist_dn_dpt_toward_500;
	Profile1DPtr _hist_dn_dpt_away_500;

	Profile1DPtr _hist_N_vs_dPhi_1_500;
	Profile1DPtr _hist_N_vs_dPhi_2_500;
	Profile1DPtr _hist_N_vs_dPhi_3_500;
	Profile1DPtr _hist_N_vs_dPhi_5_500;

	Profile1DPtr _hist_pT_vs_dPhi_1_500;
	Profile1DPtr _hist_pT_vs_dPhi_2_500;
	Profile1DPtr _hist_pT_vs_dPhi_3_500;
	Profile1DPtr _hist_pT_vs_dPhi_5_500;

	Profile1DPtr _hist_nch_transverse_100;
	Profile1DPtr _hist_nch_toward_100;
	Profile1DPtr _hist_nch_away_100;
	Profile1DPtr _hist_ptsum_transverse_100;
	Profile1DPtr _hist_ptsum_toward_100;
	Profile1DPtr _hist_ptsum_away_100;

	Profile1DPtr _hist_nch_vs_eta_transverse_100;
	Profile1DPtr _hist_ptsum_vs_eta_transverse_100;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2010_S8894728);

	}
	diff --git a/src/Analyses/ATLAS_2010_S8914702.cc b/src/Analyses/ATLAS_2010_S8914702.cc
	--- a/src/Analyses/ATLAS_2010_S8914702.cc
	+++ b/src/Analyses/ATLAS_2010_S8914702.cc
	@@ -1,175 +1,123 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2010_S8914702 : public Analysis {
	public:

	/// Constructor
	ATLAS_2010_S8914702()
	- : Analysis("ATLAS_2010_S8914702"),
	- _eta_bins{0.00, 0.60, 1.37, 1.52, 1.81},
	- _eta_bins_areaoffset{0.0, 1.5, 3.0}
	+ : Analysis("ATLAS_2010_S8914702")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	FastJets fj(fs, FastJets::KT, 0.5);
	- _area_def = new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec());
	- fj.useJetArea(_area_def);
	- addProjection(fj, "KtJetsD05");
	+ fj.useJetArea(new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec()));
	+ declare(fj, "KtJetsD05");

	LeadingParticlesFinalState photonfs(FinalState(Cuts::abseta < 1.81 && Cuts::pT > 15*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	size_t hist_bin = 0;
	for (size_t i = 0; i < _eta_bins.size()-1; ++i) {
	if (fabs(_eta_bins[i] - 1.37) < .0001) continue;
	_h_Et_photon[i] = bookHisto1D(1, 1, hist_bin+1);
	hist_bin += 1;
	}
	}


	- /// @todo Improve using YODA bin lookup tools
	- size_t getEtaBin(double eta_w, bool area_eta) const {
	- double eta = fabs(eta_w);
	- size_t v_iter = 0;
	- if (!area_eta) {
	- for (v_iter=0; v_iter < _eta_bins.size()-1; ++v_iter) {
	- if (eta >= _eta_bins.at(v_iter) && eta < _eta_bins.at(v_iter+1)) break;
	- }
	- return min(v_iter, _eta_bins.size()-2);
	- } else {
	- for (v_iter=0; v_iter < _eta_bins_areaoffset.size()-1; ++v_iter) {
	- if (eta >= _eta_bins_areaoffset.at(v_iter) && eta < _eta_bins_areaoffset.at(v_iter+1)) break;
	- }
	- return v_iter;
	- }
	+ size_t getEtaBin(double eta, bool area_eta) const {
	+ return (!area_eta) ? binIndex(fabs(eta), _eta_bins) : binIndex(fabs(eta), _eta_bins_areaoffset);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	- const double weight = event.weight();
	-
	- Particles photons = applyProjection<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	+ Particles photons = apply<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	if (photons.size() != 1) vetoEvent;

	- const FourMomentum leadingPhoton = photons[0].momentum();
	- const double eta_P = leadingPhoton.eta();
	- const double phi_P = leadingPhoton.phi();
	- if (fabs(eta_P) >= 1.37 && fabs(eta_P) < 1.52) vetoEvent;
	- int eta_bin = getEtaBin(eta_P,false);
	+ const Particle& leadingPhoton = photons[0];
	+ if (inRange(leadingPhoton.abseta(), 1.37, 1.52)) vetoEvent;
	+ const int eta_bin = getEtaBin(leadingPhoton.abseta(), false);

	- Particles fs = applyProjection<FinalState>(event, "FS").particles();
	+ const Particles& fs = apply<FinalState>(event, "FS").particles();
	FourMomentum mom_in_EtCone;
	- foreach (const Particle& p, fs) {
	- // check if it's in the cone of .4
	- if (deltaR(eta_P, phi_P, p.eta(), p.phi()) >= 0.4) continue;
	-
	- // check if it's in the 5x7 central core
	- if (fabs(eta_P-p.eta()) < .0255.00.5 &&
	- fabs(phi_P-p.phi()) < (PI/128.)7.00.5) continue;
	+ for (const Particle& p : fs) {
	+ // Check if it's in the cone of .4
	+ if (deltaR(leadingPhoton, p) >= 0.4) continue;
	+ // Check if it's in the 5x7 central core
	+ if (fabs(deltaEta(leadingPhoton, p)) < .0255.00.5 &&
	+ fabs(deltaPhi(leadingPhoton, p)) < (PI/128.)7.00.5) continue;
	+ // Increment
	mom_in_EtCone += p.momentum();
	}
	- MSG_DEBUG("Done with initial EtCone");
	+ MSG_DEBUG("Done with initial Et cone");

	- // Now compute the median energy density
	- _ptDensity.clear();
	- _sigma.clear();
	- _Njets.clear();
	-
	- vector< vector<double> > ptDensities;
	- vector<double> emptyVec;
	- ptDensities.assign(_eta_bins_areaoffset.size()-1, emptyVec);
	-
	- FastJets fast_jets = applyProjection<FastJets>(event, "KtJetsD05");
	- const shared_ptr<fastjet::ClusterSequenceArea> clust_seq_area = fast_jets.clusterSeqArea();
	- for (const fastjet::PseudoJet& jet : fast_jets.pseudoJets(0.0*GeV)) {
	- const double eta = fabs(jet.eta());
	- const double pt = fabs(jet.perp());
	-
	- // Get the cluster sequence
	- double area = clust_seq_area->area(jet);
	-
	- if (area > 10e-4 && fabs(eta)<_eta_bins_areaoffset.back()) {
	- ptDensities.at(getEtaBin(fabs(eta),true)).push_back(pt/area);
	+ // Get the jet pT densities
	+ vector< vector<double> > ptDensities(_eta_bins_areaoffset.size()-1);
	+ FastJets fastjets = apply<FastJets>(event, "KtJetsD05");
	+ const shared_ptr<fastjet::ClusterSequenceArea> clust_seq_area = fastjets.clusterSeqArea();
	+ for (const Jet& jet : fastjets.jets()) {
	+ const double area = clust_seq_area->area(jet); //< Implicit call to pseudojet()
	+ if (area > 1e-4 && jet.abseta() < _eta_bins_areaoffset.back()) {
	+ ptDensities.at(getEtaBin(jet.abseta(), true)) += jet.pT()/area;
	}
	}

	+ // Now compute the median energy densities
	+ vector<double> ptDensity;
	for (size_t b = 0; b < _eta_bins_areaoffset.size()-1; ++b) {
	- double median = 0.0;
	- double sigma = 0.0;
	- int Njets = 0;
	- if (ptDensities[b].size() > 0) {
	- std::sort(ptDensities[b].begin(), ptDensities[b].end());
	- int nDens = ptDensities[b].size();
	- if (nDens % 2 == 0) {
	- median = (ptDensities[b][nDens/2]+ptDensities[b][(nDens-2)/2])/2;
	- } else {
	- median = ptDensities[b][(nDens-1)/2];
	- }
	- sigma = ptDensities[b][(int)(.15865*nDens)];
	- Njets = nDens;
	- }
	- _ptDensity.push_back(median);
	- _sigma.push_back(sigma);
	- _Njets.push_back(Njets);
	+ ptDensity += ptDensities[b].empty() ? 0 : median(ptDensities[b]);
	}

	// Now figure out the correction
	- float EtCone_area = PI.4.4 - (7.0.025)(5.0*PI/128.);
	- float correction = _ptDensity[getEtaBin(eta_P,true)]*EtCone_area;
	- MSG_DEBUG("Jet area correction done.");
	+ const double ETCONE_AREA = PI.4.4 - (7.0.025)(5.0*PI/128.);
	+ const double correction = ptDensity[getEtaBin(leadingPhoton.abseta(), true)]*ETCONE_AREA;
	+ MSG_DEBUG("Jet area correction done");

	// Shouldn't need to subtract photon
	// NB. Using expected cut at hadron/particle level, not cut at reco level
	- if (mom_in_EtCone.Et() - correction/-leadingPhoton.Et()/ > 4.0*GeV) {
	- vetoEvent;
	- }
	- MSG_DEBUG("Passed isolation cut.");
	+ if (mom_in_EtCone.Et() - correction/-leadingPhoton.Et()/ > 4.0*GeV) vetoEvent;
	+ MSG_DEBUG("Passed isolation cut");

	- _h_Et_photon[eta_bin]->fill(leadingPhoton.Et(), weight);
	+ // Fill histogram
	+ _h_Et_photon[eta_bin]->fill(leadingPhoton.Et()/GeV, event.weight());
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t i = 0; i < _eta_bins.size()-1; ++i) {
	if (fabs(_eta_bins[i] - 1.37) < .0001) continue;
	scale(_h_Et_photon[i], crossSection()/sumOfWeights());
	}
	}


	private:

	Histo1DPtr _h_Et_photon[6];

	- fastjet::AreaDefinition* _area_def;
	+ const vector<double> _eta_bins = {0.00, 0.60, 1.37, 1.52, 1.81};
	+ const vector<double> _eta_bins_areaoffset = {0.0, 1.5, 3.0};

	- std::vector<float> _eta_bins;
	- std::vector<float> _eta_bins_areaoffset;
	-
	- std::vector<float> _ptDensity;
	- std::vector<float> _sigma;
	- std::vector<float> _Njets;
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2010_S8914702);

	}
	diff --git a/src/Analyses/ATLAS_2010_S8918562.cc b/src/Analyses/ATLAS_2010_S8918562.cc
	--- a/src/Analyses/ATLAS_2010_S8918562.cc
	+++ b/src/Analyses/ATLAS_2010_S8918562.cc
	@@ -1,220 +1,220 @@
	// -- C++ --

	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	/// Rivet analysis class for ATLAS 2010 minimum bias analysis
	class ATLAS_2010_S8918562 : public Analysis {
	public:

	/// Helper for collectively filling Nch, pT, eta, and pT vs. Nch histograms
	void fillPtEtaNch(const ChargedFinalState& cfs, int nchcut, double weight,
	Histo1DPtr h_nch, Histo1DPtr h_pt,
	Histo1DPtr h_eta, Profile1DPtr h_ptnch = Profile1DPtr()) {

	// Get number of particles and skip if event fails cut
	const int nch = cfs.size();
	if (nch < nchcut) return;

	// Fill nch
	h_nch->fill(nch, weight);
	// Loop over particles, fill pT, eta and ptnch
	foreach (const Particle& p, cfs.particles()) {
	const double pt = p.pT();
	h_pt->fill(pt/GeV, weight/pt);
	h_eta->fill(p.eta(), weight);
	if (h_ptnch != 0) h_ptnch->fill(nch, pt/GeV, weight);
	}
	}


	/// Default constructor
	ATLAS_2010_S8918562() : Analysis("ATLAS_2010_S8918562") {
	_sumW_pt100_nch2 = 0;
	_sumW_pt100_nch20 = 0;
	_sumW_pt500_nch1 = 0;
	_sumW_pt500_nch6 = 0;
	_sumW_pt2500_nch1 = 0;
	}


	/// Initialization, called once before running
	void init() {
	// Projections
	const ChargedFinalState cfs100(-2.5, 2.5, 100.0*MeV);
	- addProjection(cfs100, "CFS100");
	+ declare(cfs100, "CFS100");
	const ChargedFinalState cfs500(-2.5, 2.5, 500.0*MeV);
	- addProjection(cfs500, "CFS500");
	+ declare(cfs500, "CFS500");
	const ChargedFinalState cfs2500(-2.5, 2.5, 2500.0*MeV);
	- addProjection(cfs2500, "CFS2500");
	+ declare(cfs2500, "CFS2500");

	// Book histograms
	if (fuzzyEquals(sqrtS()/GeV, 900)) {
	_hist_pt100_nch2_nch = bookHisto1D(18, 1, 1);
	_hist_pt100_nch2_pt = bookHisto1D(11, 1, 1);
	_hist_pt100_nch2_eta = bookHisto1D(4, 1, 1);
	_hist_pt100_nch2_ptnch = bookProfile1D(24, 1, 1);

	_hist_pt100_nch20_nch = bookHisto1D(34, 1, 1);
	_hist_pt100_nch20_pt = bookHisto1D(30, 1, 1);
	_hist_pt100_nch20_eta = bookHisto1D(26, 1, 1);

	_hist_pt500_nch1_nch = bookHisto1D(15, 1, 1);
	_hist_pt500_nch1_pt = bookHisto1D(8, 1, 1);
	_hist_pt500_nch1_eta = bookHisto1D(1, 1, 1);
	_hist_pt500_nch1_ptnch = bookProfile1D(22, 1, 1);

	_hist_pt500_nch6_nch = bookHisto1D(20, 1, 1);
	_hist_pt500_nch6_pt = bookHisto1D(13, 1, 1);
	_hist_pt500_nch6_eta = bookHisto1D(6, 1, 1);

	_hist_pt2500_nch1_nch = bookHisto1D(36, 1, 1);
	_hist_pt2500_nch1_pt = bookHisto1D(32, 1, 1);
	_hist_pt2500_nch1_eta = bookHisto1D(28, 1, 1);
	_hist_pt2500_nch1_ptnch = bookProfile1D(38, 1, 1);

	} else if (fuzzyEquals(sqrtS()/GeV, 2360)) {

	_hist_pt500_nch1_nch = bookHisto1D(16, 1, 1);
	_hist_pt500_nch1_pt = bookHisto1D(9, 1, 1);
	_hist_pt500_nch1_eta = bookHisto1D(2, 1, 1);
	// This one histogram might be called while unbooked, so ensure its pointer is null!
	_hist_pt500_nch1_ptnch = Profile1DPtr();

	} else if (fuzzyEquals(sqrtS()/GeV, 7000)) {

	_hist_pt100_nch2_nch = bookHisto1D(19, 1, 1);
	_hist_pt100_nch2_pt = bookHisto1D(12, 1, 1);
	_hist_pt100_nch2_eta = bookHisto1D(5, 1, 1);
	_hist_pt100_nch2_ptnch = bookProfile1D(25, 1, 1);

	_hist_pt100_nch20_nch = bookHisto1D(35, 1, 1);
	_hist_pt100_nch20_pt = bookHisto1D(31, 1, 1);
	_hist_pt100_nch20_eta = bookHisto1D(27, 1, 1);

	_hist_pt500_nch1_nch = bookHisto1D(17, 1, 1);
	_hist_pt500_nch1_pt = bookHisto1D(10, 1, 1);
	_hist_pt500_nch1_eta = bookHisto1D(3, 1, 1);
	_hist_pt500_nch1_ptnch = bookProfile1D(23, 1, 1);

	_hist_pt500_nch6_nch = bookHisto1D(21, 1, 1);
	_hist_pt500_nch6_pt = bookHisto1D(14, 1, 1);
	_hist_pt500_nch6_eta = bookHisto1D(7, 1, 1);

	_hist_pt2500_nch1_nch = bookHisto1D(37, 1, 1);
	_hist_pt2500_nch1_pt = bookHisto1D(33, 1, 1);
	_hist_pt2500_nch1_eta = bookHisto1D(29, 1, 1);
	_hist_pt2500_nch1_ptnch = bookProfile1D(39, 1, 1);

	} else {
	throw LogicError("The ATLAS_2010_S8918562 analysis is only valid for sqrt(s) = 900, 2360 and 7000 GeV!");
	}

	}



	void analyze(const Event& event) {
	const double weight = event.weight();

	// 100 GeV final states
	if (!fuzzyEquals(sqrtS()/GeV, 2360)) {
	- const ChargedFinalState& cfs100 = applyProjection<ChargedFinalState>(event, "CFS100");
	+ const ChargedFinalState& cfs100 = apply<ChargedFinalState>(event, "CFS100");
	// nch>=2
	if (cfs100.size() >= 2) _sumW_pt100_nch2 += weight;
	fillPtEtaNch(cfs100, 2, weight, _hist_pt100_nch2_nch, _hist_pt100_nch2_pt, _hist_pt100_nch2_eta, _hist_pt100_nch2_ptnch);
	// nch>=20
	if (cfs100.size() >= 20) _sumW_pt100_nch20 += weight;
	fillPtEtaNch(cfs100, 20, weight, _hist_pt100_nch20_nch, _hist_pt100_nch20_pt, _hist_pt100_nch20_eta);
	}

	// 500 GeV final states
	- const ChargedFinalState& cfs500 = applyProjection<ChargedFinalState>(event, "CFS500");
	+ const ChargedFinalState& cfs500 = apply<ChargedFinalState>(event, "CFS500");
	// nch>=1
	if (cfs500.size() >= 1) _sumW_pt500_nch1 += weight;
	fillPtEtaNch(cfs500, 1, weight, _hist_pt500_nch1_nch, _hist_pt500_nch1_pt, _hist_pt500_nch1_eta, _hist_pt500_nch1_ptnch);
	// nch>=6
	if (!fuzzyEquals(sqrtS()/GeV, 2360)) {
	if (cfs500.size() >= 6) _sumW_pt500_nch6 += weight;
	fillPtEtaNch(cfs500, 6, weight, _hist_pt500_nch6_nch, _hist_pt500_nch6_pt, _hist_pt500_nch6_eta);
	}

	// 2500 GeV final states
	if (!fuzzyEquals(sqrtS()/GeV, 2360)) {
	- const ChargedFinalState& cfs2500 = applyProjection<ChargedFinalState>(event, "CFS2500");
	+ const ChargedFinalState& cfs2500 = apply<ChargedFinalState>(event, "CFS2500");
	// nch>=1
	if (cfs2500.size() >= 1) _sumW_pt2500_nch1 += weight;
	fillPtEtaNch(cfs2500, 1, weight, _hist_pt2500_nch1_nch, _hist_pt2500_nch1_pt, _hist_pt2500_nch1_eta, _hist_pt2500_nch1_ptnch);
	}

	}



	void finalize() {

	if (!fuzzyEquals(sqrtS()/GeV, 2360)) {
	if (_sumW_pt100_nch2 > 0) {
	scale(_hist_pt100_nch2_nch, 1.0/_sumW_pt100_nch2);
	scale(_hist_pt100_nch2_pt, 1.0/_sumW_pt100_nch2/TWOPI/5);
	scale(_hist_pt100_nch2_eta, 1.0/_sumW_pt100_nch2);
	}

	if (_sumW_pt100_nch20 > 0) {
	scale(_hist_pt100_nch20_nch, 1.0/_sumW_pt100_nch20);
	scale(_hist_pt100_nch20_pt, 1.0/_sumW_pt100_nch20/TWOPI/5);
	scale(_hist_pt100_nch20_eta, 1.0/_sumW_pt100_nch20);
	}

	if (_sumW_pt500_nch6 > 0) {
	scale(_hist_pt500_nch6_nch, 1.0/_sumW_pt500_nch6);
	scale(_hist_pt500_nch6_pt, 1.0/_sumW_pt500_nch6/TWOPI/5);
	scale(_hist_pt500_nch6_eta, 1.0/_sumW_pt500_nch6);
	}

	if (_sumW_pt2500_nch1 > 0) {
	scale(_hist_pt2500_nch1_nch, 1.0/_sumW_pt2500_nch1);
	scale(_hist_pt2500_nch1_pt, 1.0/_sumW_pt2500_nch1/TWOPI/5);
	scale(_hist_pt2500_nch1_eta, 1.0/_sumW_pt2500_nch1);
	}
	}

	if (_sumW_pt500_nch1 > 0) {
	scale(_hist_pt500_nch1_nch, 1.0/_sumW_pt500_nch1);
	scale(_hist_pt500_nch1_pt, 1.0/_sumW_pt500_nch1/TWOPI/5);
	scale(_hist_pt500_nch1_eta, 1.0/_sumW_pt500_nch1);
	}
	}


	private:

	double _sumW_pt100_nch2, _sumW_pt100_nch20, _sumW_pt500_nch1,
	_sumW_pt500_nch6, _sumW_pt2500_nch1;

	Histo1DPtr _hist_pt100_nch2_nch,
	_hist_pt100_nch20_nch, _hist_pt500_nch1_nch,
	_hist_pt500_nch6_nch, _hist_pt2500_nch1_nch;

	Histo1DPtr _hist_pt100_nch2_pt,
	_hist_pt100_nch20_pt, _hist_pt500_nch1_pt,
	_hist_pt500_nch6_pt, _hist_pt2500_nch1_pt;

	Histo1DPtr _hist_pt100_nch2_eta,
	_hist_pt100_nch20_eta, _hist_pt500_nch1_eta,
	_hist_pt500_nch6_eta, _hist_pt2500_nch1_eta;

	Profile1DPtr _hist_pt100_nch2_ptnch,
	_hist_pt500_nch1_ptnch, _hist_pt2500_nch1_ptnch;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2010_S8918562);

	}
	diff --git a/src/Analyses/ATLAS_2010_S8919674.cc b/src/Analyses/ATLAS_2010_S8919674.cc
	--- a/src/Analyses/ATLAS_2010_S8919674.cc
	+++ b/src/Analyses/ATLAS_2010_S8919674.cc
	@@ -1,156 +1,156 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/WFinder.hh"

	namespace Rivet {


	/// W + jets jet multiplicities and pT
	class ATLAS_2010_S8919674 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2010_S8919674()
	: Analysis("ATLAS_2010_S8919674")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Set up projections to find the electron and muon Ws
	FinalState fs;
	Cut cuts = (Cuts::abseta < 1.37 \|\| Cuts::absetaIn(1.52, 2.47)) && Cuts::pT > 20*GeV;
	WFinder wfinder_e(fs, cuts, PID::ELECTRON, 0GeV, 1000GeV, 25*GeV);
	- addProjection(wfinder_e, "W_e");
	+ declare(wfinder_e, "W_e");
	WFinder wfinder_mu(fs, Cuts::abseta < 2.4 && Cuts::pT > 20GeV, PID::MUON, 0GeV, 1000GeV, 25GeV);
	- addProjection(wfinder_mu, "W_mu");
	+ declare(wfinder_mu, "W_mu");

	// Input for the jets: no neutrinos, no muons, and no electron which passed the electron cuts
	VetoedFinalState veto;
	veto.addVetoOnThisFinalState(wfinder_e);
	veto.addVetoOnThisFinalState(wfinder_mu);
	veto.addVetoPairId(PID::MUON);
	veto.vetoNeutrinos();
	FastJets jets(veto, FastJets::ANTIKT, 0.4);
	- addProjection(jets, "jets");
	+ declare(jets, "jets");

	/// Book histograms
	_h_el_njet_inclusive = bookHisto1D(1,1,1);
	_h_mu_njet_inclusive = bookHisto1D(2,1,1);
	_h_el_pT_jet1 = bookHisto1D(5,1,1);
	_h_mu_pT_jet1 = bookHisto1D(6,1,1);
	_h_el_pT_jet2 = bookHisto1D(7,1,1);
	_h_mu_pT_jet2 = bookHisto1D(8,1,1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const Jets& jets = applyProjection<FastJets>(event, "jets").jetsByPt(20.0*GeV);
	+ const Jets& jets = apply<FastJets>(event, "jets").jetsByPt(20.0*GeV);

	- const WFinder& We = applyProjection<WFinder>(event, "W_e");
	+ const WFinder& We = apply<WFinder>(event, "W_e");
	if (We.bosons().size() == 1) {
	const FourMomentum& p_miss = We.constituentNeutrinos()[0].momentum();
	const FourMomentum& p_lept = We.constituentLeptons()[0].momentum();
	if (p_miss.Et() > 25GeV && We.mT() > 40GeV) {
	Jets js;
	foreach (const Jet& j, jets) {
	if (j.abseta() < 2.8 && deltaR(p_lept, j.momentum()) > 0.5)
	js.push_back(j);
	}
	_h_el_njet_inclusive->fill(0, weight);
	if (js.size() >= 1) {
	_h_el_njet_inclusive->fill(1, weight);
	_h_el_pT_jet1->fill(js[0].pT(), weight);
	}
	if (js.size() >= 2) {
	_h_el_njet_inclusive->fill(2, weight);
	_h_el_pT_jet2->fill(js[1].pT(), weight);
	}
	if (js.size() >= 3) {
	_h_el_njet_inclusive->fill(3, weight);
	}
	}
	}

	- const WFinder& Wm = applyProjection<WFinder>(event, "W_mu");
	+ const WFinder& Wm = apply<WFinder>(event, "W_mu");
	if (Wm.bosons().size() == 1) {
	const FourMomentum& p_miss = Wm.constituentNeutrinos()[0].momentum();
	const FourMomentum& p_lept = Wm.constituentLeptons()[0].momentum();
	if (p_miss.Et() > 25GeV && Wm.mT() > 40GeV) {
	Jets js;
	foreach (const Jet& j, jets) {
	if (j.abseta() < 2.8 && deltaR(p_lept, j.momentum()) > 0.5)
	js.push_back(j);
	}
	_h_mu_njet_inclusive->fill(0, weight);
	if (js.size() >= 1) {
	_h_mu_njet_inclusive->fill(1, weight);
	_h_mu_pT_jet1->fill(js[0].pT(), weight);
	}
	if (js.size() >= 2) {
	_h_mu_njet_inclusive->fill(2, weight);
	_h_mu_pT_jet2->fill(js[1].pT(), weight);
	}
	if (js.size() >= 3) {
	_h_mu_njet_inclusive->fill(3, weight);
	}
	if (js.size() >= 4) {
	_h_mu_njet_inclusive->fill(4, weight);
	}
	}
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	double normfac = crossSection()/sumOfWeights();
	scale(_h_el_njet_inclusive, normfac);
	scale(_h_mu_njet_inclusive, normfac);
	scale(_h_el_pT_jet1, normfac);
	scale(_h_mu_pT_jet1, normfac);
	scale(_h_el_pT_jet2, normfac);
	scale(_h_mu_pT_jet2, normfac);
	}

	//@}


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_el_njet_inclusive;
	Histo1DPtr _h_mu_njet_inclusive;
	Histo1DPtr _h_el_pT_jet1;
	Histo1DPtr _h_mu_pT_jet1;
	Histo1DPtr _h_el_pT_jet2;
	Histo1DPtr _h_mu_pT_jet2;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2010_S8919674);

	}
	diff --git a/src/Analyses/ATLAS_2011_CONF_2011_090.cc b/src/Analyses/ATLAS_2011_CONF_2011_090.cc
	--- a/src/Analyses/ATLAS_2011_CONF_2011_090.cc
	+++ b/src/Analyses/ATLAS_2011_CONF_2011_090.cc
	@@ -1,336 +1,336 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2011_CONF_2011_090 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor

	ATLAS_2011_CONF_2011_090()
	: Analysis("ATLAS_2011_CONF_2011_090")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialize projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT >= 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// veto region electrons (from 2010 arXiv:1102.2357v2)
	Cut vetocut = Cuts::absetaIn(1.37, 1.52);
	IdentifiedFinalState veto_elecs(vetocut && Cuts::pT > 10*GeV);
	veto_elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(veto_elecs, "veto_elecs");
	+ declare(veto_elecs, "veto_elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0 && Cuts::pT > 0.5*GeV), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0 && Cuts::pT > 0.5*GeV), "cfs");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9), "vfs");

	/// Book histograms
	_count_mu_channel = bookHisto1D("count_muon_channel", 1, 0., 1.);
	_count_e_channel = bookHisto1D("count_electron_channel", 1, 0., 1.);
	_hist_eTmiss_e = bookHisto1D("Et_miss_e", 50, 0., 500.);
	_hist_eTmiss_mu = bookHisto1D("Et_miss_mu", 50, 0., 500.);
	_hist_m_eff_e = bookHisto1D("m_eff_e", 60, 0., 1500.);
	_hist_m_eff_mu = bookHisto1D("m_eff_mu", 60, 0., 1500.);
	_hist_m_eff_e_final = bookHisto1D("m_eff_e_final", 15, 0., 1500.);
	_hist_m_eff_mu_final = bookHisto1D("m_eff_mu_final", 15, 0., 1500.);
	}



	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	- Particles veto_e = applyProjection<IdentifiedFinalState>(event, "veto_elecs").particles();
	+ Particles veto_e = apply<IdentifiedFinalState>(event, "veto_elecs").particles();
	if ( ! veto_e.empty() ) {
	MSG_DEBUG("electrons in veto region");
	vetoEvent;
	}

	- Jets cand_jets = applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.8);
	+ Jets cand_jets = apply<FastJets>(event, "AntiKtJets04").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.8);

	- Particles candtemp_e = applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	- Particles candtemp_mu = applyProjection<IdentifiedFinalState>(event,"muons").particlesByPt();
	- Particles chg_tracks = applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ Particles candtemp_e = apply<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ Particles candtemp_mu = apply<IdentifiedFinalState>(event,"muons").particlesByPt();
	+ Particles chg_tracks = apply<ChargedFinalState>(event, "cfs").particles();
	Particles cand_mu;
	Particles cand_e;

	// pTcone around muon track
	foreach ( const Particle& mu, candtemp_mu ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle& track, chg_tracks ) {
	if ( deltaR(mu, track) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	cand_mu.push_back(mu);
	}


	// pTcone around electron
	foreach ( const Particle& e, candtemp_e ) {
	double pTinCone = -e.pT();
	foreach ( const Particle& track, chg_tracks ) {
	if ( deltaR(e, track) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 0.10 * e.pT() )
	cand_e.push_back(e);
	}


	// discard jets that overlap with electrons
	Jets cand_jets_2;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e, jet) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e )
	cand_jets_2.push_back( jet );
	}

	// only consider leptons far from jet
	Particles recon_e, recon_mu;
	foreach ( const Particle & e, cand_e ) {
	bool e_near_jet = false;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if (inRange(deltaR(e, jet), 0.2, 0.4)) e_near_jet = true;
	}
	if ( ! e_near_jet ) recon_e.push_back( e );
	}

	foreach ( const Particle & mu, cand_mu ) {
	bool mu_near_jet = false;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( deltaR(mu, jet) < 0.4 ) mu_near_jet = true;
	}
	if ( ! mu_near_jet ) recon_mu.push_back( mu );
	}

	// pTmiss
	Particles vfs_particles
	- = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();


	// final jet filter
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets_2 ) {
	recon_jets.push_back( jet );
	}




	// ==================== observables ====================


	// Njets

	int Njets = 0;
	double pTmiss_phi = pTmiss.phi();
	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.abseta() < 2.8 )
	Njets+=1;
	}
	if ( Njets < 3 ) {
	MSG_DEBUG("Only " << Njets << " jets w/ eta<2.8 left");
	vetoEvent;
	}

	if ( recon_jets[0].pT() <= 60.0 * GeV ) {
	MSG_DEBUG("No hard leading jet in " << recon_jets.size() << " jets");
	vetoEvent;
	}
	for ( int i = 1; i < 3; ++i ) {
	if ( recon_jets[i].pT() <= 25*GeV ) {
	vetoEvent;
	}
	}

	for ( int i = 0; i < 3; ++i ) {
	double dPhi = deltaPhi( pTmiss_phi, recon_jets[i].phi() );
	if ( dPhi <= 0.2 ) {
	MSG_DEBUG("dPhi too small");
	vetoEvent;
	break;
	}
	}


	Particles lepton;
	if ( recon_mu.empty() && recon_e.empty() ) {
	MSG_DEBUG("No leptons");
	vetoEvent;
	}
	else {
	foreach ( const Particle & mu, recon_mu )
	lepton.push_back(mu);
	foreach ( const Particle & e, recon_e )
	lepton.push_back(e);
	}

	std::sort(lepton.begin(), lepton.end(), cmpMomByPt);

	double e_id = 11;
	double mu_id = 13;

	// one hard leading lepton cut
	if ( lepton[0].abspid() == e_id &&
	lepton[0].pT() <= 25*GeV ) {
	vetoEvent;
	}
	else if ( lepton[0].abspid() == mu_id &&
	lepton[0].pT() <= 20*GeV ) {
	vetoEvent;
	}

	// exactly one hard leading lepton cut
	if(lepton.size()>1) {
	if ( lepton[1].abspid() == e_id &&
	lepton[1].pT() > 20*GeV ) {
	vetoEvent;
	}
	else if ( lepton[1].abspid() == mu_id &&
	lepton[1].pT() > 10*GeV ) {
	vetoEvent;
	}
	}


	// ==================== FILL ====================


	FourMomentum pT_l = lepton[0].momentum();


	double dPhi = deltaPhi( pT_l.phi(), pTmiss_phi);
	double mT = sqrt( 2 * pT_l.pT() * eTmiss * (1 - cos(dPhi)) );


	// effective mass
	double m_eff = eTmiss + pT_l.pT()
	+ recon_jets[0].pT()
	+ recon_jets[1].pT()
	+ recon_jets[2].pT();


	// Electron channel signal region

	if ( lepton[0].abspid() == e_id ) {

	_hist_eTmiss_e->fill(eTmiss, weight);
	_hist_m_eff_e->fill(m_eff, weight);

	if ( mT > 100GeV && eTmiss > 125GeV ) {
	_hist_m_eff_e_final->fill(m_eff, weight);
	if ( m_eff > 500GeV && eTmiss > 0.25m_eff ) {
	_count_e_channel->fill(0.5,weight);
	}
	}
	}

	// Muon channel signal region

	else if ( lepton[0].abspid() == mu_id ) {

	_hist_eTmiss_mu->fill(eTmiss, weight);
	_hist_m_eff_mu->fill(m_eff, weight);

	if ( mT > 100GeV && eTmiss > 125GeV ) {
	_hist_m_eff_mu_final->fill(m_eff, weight);
	if ( m_eff > 500GeV && eTmiss > 0.25m_eff ) {
	_count_mu_channel->fill(0.5,weight);
	}
	}

	}


	}

	//@}


	void finalize() {
	scale( _hist_eTmiss_e , 10. * 165. * crossSection()/picobarn/sumOfWeights() );
	scale( _hist_eTmiss_mu , 10. * 165. * crossSection()/picobarn/sumOfWeights() );
	scale( _hist_m_eff_e , 25. * 165. * crossSection()/picobarn/sumOfWeights() );
	scale( _hist_m_eff_mu , 25. * 165. * crossSection()/picobarn/sumOfWeights() );
	scale( _hist_m_eff_e_final , 100. * 165. * crossSection()/picobarn/sumOfWeights() );
	scale( _hist_m_eff_mu_final, 100. * 165. * crossSection()/picobarn/sumOfWeights() );
	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_e_channel;
	Histo1DPtr _count_mu_channel;

	Histo1DPtr _hist_eTmiss_e;
	Histo1DPtr _hist_eTmiss_mu;

	Histo1DPtr _hist_m_eff_e;
	Histo1DPtr _hist_m_eff_mu;
	Histo1DPtr _hist_m_eff_e_final;
	Histo1DPtr _hist_m_eff_mu_final;


	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_CONF_2011_090);

	}
	diff --git a/src/Analyses/ATLAS_2011_CONF_2011_098.cc b/src/Analyses/ATLAS_2011_CONF_2011_098.cc
	--- a/src/Analyses/ATLAS_2011_CONF_2011_098.cc
	+++ b/src/Analyses/ATLAS_2011_CONF_2011_098.cc
	@@ -1,324 +1,324 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2011_CONF_2011_098 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_CONF_2011_098()
	: Analysis("ATLAS_2011_CONF_2011_098"),
	//debug variables
	threeJA(0), threeJB(0), threeJC(0), threeJD(0), bj(0), jets(0), zerolept(0), eTmisscut(0)
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");


	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	/// Jet finder
	- addProjection(FastJets(FinalState(), FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(FinalState(), FastJets::ANTIKT, 0.4), "AntiKtJets04");


	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0),"cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0),"cfs");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");


	/// Book histograms
	_count_threeJA = bookHisto1D("count_threeJA", 1, 0., 1.);
	_count_threeJB = bookHisto1D("count_threeJB", 1, 0., 1.);
	_count_threeJC = bookHisto1D("count_threeJC", 1, 0., 1.);
	_count_threeJD = bookHisto1D("count_threeJD", 1, 0., 1.);
	_hist_meff_1bjet = bookHisto1D("meff_1bjet", 32, 0., 1600.);
	_hist_eTmiss_1bjet = bookHisto1D("eTmiss_1bjet", 6, 0., 600.);
	_hist_pTj_1bjet = bookHisto1D("pTjet_1bjet", 20, 0., 800.);
	_hist_meff_2bjet = bookHisto1D("meff_2bjet", 32, 0., 1600.);
	_hist_eTmiss_2bjet = bookHisto1D("eTmiss_2bjet", 6, 0., 600.);
	_hist_pTj_2bjet = bookHisto1D("pTjet_2bjet", 20, 0., 800.);


	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	// Temp: calorimeter module failure with 10% acceptance loss;
	// region unknown ==> randomly choose 10% of events to be vetoed

	if ( rand()/static_cast<double>(RAND_MAX) < 0.1 )
	vetoEvent;

	Jets tmp_cand_jets;
	foreach (const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	tmp_cand_jets.push_back(jet);
	}
	}

	Particles cand_e =
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt();
	Particles cand_mu =
	- applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "muons").particlesByPt();
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();

	//cerr << "cand_e.size(): " << cand_e.size() << " cand_mu.size(): " << cand_mu.size() << '\n';


	Jets cand_jets;
	foreach ( const Jet& jet, tmp_cand_jets ) {
	if ( fabs( jet.eta() ) >= 2.8 )
	cand_jets.push_back( jet );
	else {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e )
	cand_jets.push_back( jet );
	}
	}

	Particles cand_lept;

	bool isolated_e;
	foreach ( const Particle & e, cand_e ) {
	isolated_e = true;
	foreach ( const Jet& jet, cand_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 )
	isolated_e = false;
	}
	if ( isolated_e == true )
	cand_lept.push_back( e );
	}


	bool isolated_mu;
	foreach ( const Particle & mu, cand_mu ) {
	isolated_mu = true;
	foreach ( const Jet& jet, cand_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 )
	isolated_mu = false;
	}
	if ( isolated_mu == true)
	cand_lept.push_back( mu );
	}


	// pTmiss
	Particles vfs_particles
	- = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();


	// bjets
	Jets bjets,recon_jets;
	foreach (const Jet& j, cand_jets) {
	if(fabs( j.eta() ) <= 2.8) {
	recon_jets.push_back(j);
	if ( fabs( j.eta() ) <= 2.5 && j.perp()>50. &&
	j.bTagged() && rand()/static_cast<double>(RAND_MAX) < 0.5 )
	bjets.push_back(j);
	}
	}

	if (bjets.empty()) {
	MSG_DEBUG("No b-jet axes in acceptance");
	vetoEvent;
	}

	++bj;



	// Jets event selection
	if ( recon_jets.size() < 3 )
	vetoEvent;
	if ( recon_jets[0].pT() <= 130*GeV )
	vetoEvent;
	if ( recon_jets[1].pT() <= 50*GeV \|\|
	recon_jets[2].pT() <= 50*GeV )
	vetoEvent;
	++jets;

	// eTmiss cut
	if ( eTmiss <= 130*GeV )
	vetoEvent;

	++eTmisscut;

	// 0-lepton requirement
	if ( !cand_lept.empty() )
	vetoEvent;
	++zerolept;

	// m_eff cut
	double m_eff = eTmiss
	+ recon_jets[0].pT()
	+ recon_jets[1].pT()
	+ recon_jets[2].pT();

	if ( eTmiss / m_eff <= 0.25 )
	vetoEvent;


	// min_dPhi
	double min_dPhi = 999.999;
	for ( int i = 0; i < 3; ++i ) {
	double dPhi = deltaPhi( pTmiss.phi(), recon_jets[i].phi() );
	min_dPhi = min( min_dPhi, dPhi );
	}

	if ( min_dPhi <= 0.4 )
	vetoEvent;



	// ==================== FILL ====================


	// 1 bjet
	if ( bjets.size() >= 1 ) {

	_hist_meff_1bjet->fill(m_eff, weight);
	_hist_eTmiss_1bjet->fill(eTmiss, weight);
	_hist_pTj_1bjet->fill(recon_jets[0].pT(), weight);

	// 3JA region
	if ( m_eff > 200*GeV ) {
	++threeJA;
	_count_threeJA->fill(0.5, weight);
	}

	// 3JB region
	if ( m_eff > 700*GeV ) {
	++threeJB;
	_count_threeJB->fill(0.5, weight);
	}
	}

	// 2 bjets
	if ( bjets.size() >= 2 ) {

	_hist_meff_2bjet->fill(m_eff, weight);
	_hist_eTmiss_2bjet->fill(eTmiss, weight);
	_hist_pTj_2bjet->fill(recon_jets[0].pT(), weight);

	// 3JC region
	if ( m_eff > 500*GeV ) {
	++threeJC;
	_count_threeJC->fill(0.5, weight);
	}

	// 3JD region
	if ( m_eff > 700*GeV ) {
	++threeJD;
	_count_threeJD->fill(0.5, weight);
	}
	}




	}

	//@}


	void finalize() {
	scale( _hist_meff_1bjet, 50. * 830. * crossSection()/sumOfWeights() );
	scale( _hist_eTmiss_1bjet, 100. * 830. * crossSection()/sumOfWeights() );
	scale( _hist_pTj_1bjet, 40. * 830. * crossSection()/sumOfWeights() );
	scale( _hist_meff_2bjet, 50. * 830. * crossSection()/sumOfWeights() );
	scale( _hist_eTmiss_2bjet, 100. * 830. * crossSection()/sumOfWeights() );
	scale( _hist_pTj_2bjet, 40. * 830. * crossSection()/sumOfWeights() );

	// cerr<< '\n'<<'\n'
	// << "Saw "
	// << bj << " events aft bjets cut, "
	// << jets << " events aft jet cuts, "
	// << eTmisscut << " events aft eTmiss cut, "
	// << zerolept << " events after 0-lept cut. "
	// << '\n'
	// << threeJA << " 3JA events, "
	// << threeJB << " 3JB events, "
	// << threeJC << " 3JC events, "
	// << threeJD << " 3JD events. "
	// << '\n'
	// ;

	}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_threeJA;
	Histo1DPtr _count_threeJB;
	Histo1DPtr _count_threeJC;
	Histo1DPtr _count_threeJD;
	Histo1DPtr _hist_meff_1bjet;
	Histo1DPtr _hist_eTmiss_1bjet;
	Histo1DPtr _hist_pTj_1bjet;
	Histo1DPtr _hist_meff_2bjet;
	Histo1DPtr _hist_eTmiss_2bjet;
	Histo1DPtr _hist_pTj_2bjet;

	//@}


	// debug variables
	int threeJA;
	int threeJB;
	int threeJC;
	int threeJD;
	int bj;
	int jets;
	int zerolept;
	int eTmisscut;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_CONF_2011_098);

	}
	diff --git a/src/Analyses/ATLAS_2011_I894867.cc b/src/Analyses/ATLAS_2011_I894867.cc
	--- a/src/Analyses/ATLAS_2011_I894867.cc
	+++ b/src/Analyses/ATLAS_2011_I894867.cc
	@@ -1,75 +1,61 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	class ATLAS_2011_I894867 : public Analysis {
	public:

	- ATLAS_2011_I894867()
	- : Analysis("ATLAS_2011_I894867")
	- { }
	-
	- public:
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2011_I894867);

	void init() {
	- addProjection(FinalState(), "FS");
	+ declare(FinalState(), "FS");
	_h_sigma = bookHisto1D(1, 1, 1);
	}


	void analyze(const Event& event) {
	- const double weight = event.weight();

	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	if (fs.size() < 2) vetoEvent; // need at least two particles to calculate gaps

	- double gapcenter = 0.;
	- double LRG = 0.;
	- double etapre = 0.;
	- bool first = true;
	-
	- foreach(const Particle& p, fs.particles(cmpMomByEta)) { // sorted from minus to plus
	- if (first) { // First particle
	- first = false;
	- etapre = p.eta();
	- } else {
	- double gap = fabs(p.eta() - etapre);
	- if (gap > LRG) {
	- LRG = gap; // largest gap
	- gapcenter = (p.eta() + etapre)/2.; // find the center of the gap to separate the X and Y systems.
	- }
	- etapre = p.eta();
	+ const Particles particles = fs.particles(cmpMomByEta);
	+ double etaprev = particles.front().eta();
	+ double gapcenter = etaprev;
	+ double detamax = -1;
	+ for (const Particle& p : particles) { // sorted from minus to plus
	+ const double deta = p.eta() - etaprev; // guaranteed positive
	+ if (deta > detamax) { // largest gap so far
	+ detamax = deta;
	+ gapcenter = (p.eta() + etaprev)/2.; // find the center of the gap to separate the X and Y systems.
	}
	+ etaprev = p.eta();
	}

	-
	FourMomentum mxFourVector, myFourVector;
	- foreach(const Particle& p, fs.particles(cmpMomByEta)) {
	- ((p.eta() > gapcenter) ? mxFourVector : myFourVector) += p.momentum();
	- }
	- const double M2 = max(mxFourVector.mass2(), myFourVector.mass2());
	- const double xi = M2/sqr(sqrtS()); // sqrt(s)=7000 GeV, note that units cancel
	+ for (const Particle& p : particles)
	+ (p.eta() > gapcenter ? mxFourVector : myFourVector) += p.momentum();
	+ const double m2 = max(mxFourVector.mass2(), myFourVector.mass2());
	+ const double xi = m2/sqr(sqrtS()); // sqrt(s) = 7000 GeV
	if (xi < 5e-6) vetoEvent;

	- _h_sigma->fill(sqrtS()/GeV, weight);
	+ _h_sigma->fill(sqrtS()/GeV, event.weight());
	}


	void finalize() {
	scale(_h_sigma, crossSection()/millibarn/sumOfWeights());
	}

	- private:

	Histo1DPtr _h_sigma;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_I894867);

	}
	diff --git a/src/Analyses/ATLAS_2011_I919017.cc b/src/Analyses/ATLAS_2011_I919017.cc
	--- a/src/Analyses/ATLAS_2011_I919017.cc
	+++ b/src/Analyses/ATLAS_2011_I919017.cc
	@@ -1,1180 +1,1180 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	namespace {

	inline double calcz(const Jet& j, const Particle& p) {
	const double num = j.p3().dot(p.p3());
	const double den = j.p3().mod2();
	return num/den;
	}

	inline double calcptrel(const Jet& j, const Particle& p) {
	const double num = j.p3().cross(p.p3()).mod();
	const double den = j.p3().mod();
	return num/den;
	}

	inline double calcr(const Jet& j, const Particle& p) {
	return deltaR(j.rapidity(), j.phi(), p.rapidity(), p.phi());
	}

	// For annulus area kludge
	/// @todo Improve somehow... need normalisation without bin width factors!
	inline double calcrweight(const Jet& j, const Particle& p) {
	size_t nBins_r = 26;
	double bins_r[] = { 0.00, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10,
	0.12, 0.14, 0.16, 0.18, 0.20, 0.22, 0.24, 0.26, 0.28, 0.30,
	0.35, 0.40, 0.45, 0.50, 0.55, 0.60 };
	double r = calcr(j,p);
	for (size_t bin = 0 ; bin < nBins_r ; bin++) {
	if (r < bins_r[bin+1]) {
	double up = bins_r[bin+1];
	double down = bins_r[bin];
	return ((up-down)/(M_PI(upup-down*down)));
	}
	}
	return 1.0;
	}
	}


	class ATLAS_2011_I919017 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2011_I919017()
	: Analysis("ATLAS_2011_I919017"),
	_sumofweights04(0), _sumofweights06(0),
	_numjets04_00_05_04_06(0), _numjets04_00_05_06_10(0), _numjets04_00_05_10_15(0), _numjets04_00_05_15_24(0), _numjets04_00_05_24_40(0),
	_numjets06_00_05_04_06(0), _numjets06_00_05_06_10(0), _numjets06_00_05_10_15(0), _numjets06_00_05_15_24(0), _numjets06_00_05_24_40(0),
	_numjets04_05_10_04_06(0), _numjets04_05_10_06_10(0), _numjets04_05_10_10_15(0), _numjets04_05_10_15_24(0), _numjets04_05_10_24_40(0),
	_numjets06_05_10_04_06(0), _numjets06_05_10_06_10(0), _numjets06_05_10_10_15(0), _numjets06_05_10_15_24(0), _numjets06_05_10_24_40(0),
	_numjets04_10_15_04_06(0), _numjets04_10_15_06_10(0), _numjets04_10_15_10_15(0), _numjets04_10_15_15_24(0), _numjets04_10_15_24_40(0),
	_numjets06_10_15_04_06(0), _numjets06_10_15_06_10(0), _numjets06_10_15_10_15(0), _numjets06_10_15_15_24(0), _numjets06_10_15_24_40(0),
	_numjets04_15_19_04_06(0), _numjets04_15_19_06_10(0), _numjets04_15_19_10_15(0), _numjets04_15_19_15_24(0), _numjets04_15_19_24_40(0),
	_numjets06_15_19_04_06(0), _numjets06_15_19_06_10(0), _numjets06_15_19_10_15(0), _numjets06_15_19_15_24(0), _numjets06_15_19_24_40(0),
	_numjets04_00_19_04_06(0), _numjets04_00_19_06_10(0), _numjets04_00_19_10_15(0), _numjets04_00_19_15_24(0), _numjets04_00_19_24_40(0),
	_numjets06_00_19_04_06(0), _numjets06_00_19_06_10(0), _numjets06_00_19_10_15(0), _numjets06_00_19_15_24(0), _numjets06_00_19_24_40(0)
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	ChargedFinalState cfs(-2.5, 2.5, 0.3*GeV);
	FastJets trkjets04(cfs, FastJets::ANTIKT, 0.4);
	FastJets trkjets06(cfs, FastJets::ANTIKT, 0.6);
	- addProjection(trkjets04, "Jets04");
	- addProjection(trkjets06, "Jets06");
	+ declare(trkjets04, "Jets04");
	+ declare(trkjets06, "Jets06");

	// Book histograms
	_h_pt04_00_05 = bookHisto1D(1, 1, 1);
	_h_pt06_00_05 = bookHisto1D(2, 1, 1);
	_h_N04_00_05_04_06 = bookHisto1D(1, 2, 1+5);
	_h_N06_00_05_04_06 = bookHisto1D(2, 2, 1+5);
	_h_N04_00_05_06_10 = bookHisto1D(1, 2, 2+5);
	_h_N06_00_05_06_10 = bookHisto1D(2, 2, 2+5);
	_h_N04_00_05_10_15 = bookHisto1D(1, 2, 3+5);
	_h_N06_00_05_10_15 = bookHisto1D(2, 2, 3+5);
	_h_N04_00_05_15_24 = bookHisto1D(1, 2, 4+5);
	_h_N06_00_05_15_24 = bookHisto1D(2, 2, 4+5);
	_h_N04_00_05_24_40 = bookHisto1D(1, 2, 5+5);
	_h_N06_00_05_24_40 = bookHisto1D(2, 2, 5+5);
	_h_z04_00_05_04_06 = bookHisto1D(1, 3, 1+5);
	_h_z06_00_05_04_06 = bookHisto1D(2, 3, 1+5);
	_h_z04_00_05_06_10 = bookHisto1D(1, 3, 2+5);
	_h_z06_00_05_06_10 = bookHisto1D(2, 3, 2+5);
	_h_z04_00_05_10_15 = bookHisto1D(1, 3, 3+5);
	_h_z06_00_05_10_15 = bookHisto1D(2, 3, 3+5);
	_h_z04_00_05_15_24 = bookHisto1D(1, 3, 4+5);
	_h_z06_00_05_15_24 = bookHisto1D(2, 3, 4+5);
	_h_z04_00_05_24_40 = bookHisto1D(1, 3, 5+5);
	_h_z06_00_05_24_40 = bookHisto1D(2, 3, 5+5);
	_h_ptrel04_00_05_04_06 = bookHisto1D(1, 4, 1+5);
	_h_ptrel06_00_05_04_06 = bookHisto1D(2, 4, 1+5);
	_h_ptrel04_00_05_06_10 = bookHisto1D(1, 4, 2+5);
	_h_ptrel06_00_05_06_10 = bookHisto1D(2, 4, 2+5);
	_h_ptrel04_00_05_10_15 = bookHisto1D(1, 4, 3+5);
	_h_ptrel06_00_05_10_15 = bookHisto1D(2, 4, 3+5);
	_h_ptrel04_00_05_15_24 = bookHisto1D(1, 4, 4+5);
	_h_ptrel06_00_05_15_24 = bookHisto1D(2, 4, 4+5);
	_h_ptrel04_00_05_24_40 = bookHisto1D(1, 4, 5+5);
	_h_ptrel06_00_05_24_40 = bookHisto1D(2, 4, 5+5);
	_h_rdA04_00_05_04_06 = bookHisto1D(1, 5, 1+5);
	_h_rdA06_00_05_04_06 = bookHisto1D(2, 5, 1+5);
	_h_rdA04_00_05_06_10 = bookHisto1D(1, 5, 2+5);
	_h_rdA06_00_05_06_10 = bookHisto1D(2, 5, 2+5);
	_h_rdA04_00_05_10_15 = bookHisto1D(1, 5, 3+5);
	_h_rdA06_00_05_10_15 = bookHisto1D(2, 5, 3+5);
	_h_rdA04_00_05_15_24 = bookHisto1D(1, 5, 4+5);
	_h_rdA06_00_05_15_24 = bookHisto1D(2, 5, 4+5);
	_h_rdA04_00_05_24_40 = bookHisto1D(1, 5, 5+5);
	_h_rdA06_00_05_24_40 = bookHisto1D(2, 5, 5+5);

	_h_pt04_05_10 = bookHisto1D(1, 1, 2);
	_h_pt06_05_10 = bookHisto1D(2, 1, 2);
	_h_N04_05_10_04_06 = bookHisto1D(1, 2, 1+10);
	_h_N06_05_10_04_06 = bookHisto1D(2, 2, 1+10);
	_h_N04_05_10_06_10 = bookHisto1D(1, 2, 2+10);
	_h_N06_05_10_06_10 = bookHisto1D(2, 2, 2+10);
	_h_N04_05_10_10_15 = bookHisto1D(1, 2, 3+10);
	_h_N06_05_10_10_15 = bookHisto1D(2, 2, 3+10);
	_h_N04_05_10_15_24 = bookHisto1D(1, 2, 4+10);
	_h_N06_05_10_15_24 = bookHisto1D(2, 2, 4+10);
	_h_N04_05_10_24_40 = bookHisto1D(1, 2, 5+10);
	_h_N06_05_10_24_40 = bookHisto1D(2, 2, 5+10);
	_h_z04_05_10_04_06 = bookHisto1D(1, 3, 1+10);
	_h_z06_05_10_04_06 = bookHisto1D(2, 3, 1+10);
	_h_z04_05_10_06_10 = bookHisto1D(1, 3, 2+10);
	_h_z06_05_10_06_10 = bookHisto1D(2, 3, 2+10);
	_h_z04_05_10_10_15 = bookHisto1D(1, 3, 3+10);
	_h_z06_05_10_10_15 = bookHisto1D(2, 3, 3+10);
	_h_z04_05_10_15_24 = bookHisto1D(1, 3, 4+10);
	_h_z06_05_10_15_24 = bookHisto1D(2, 3, 4+10);
	_h_z04_05_10_24_40 = bookHisto1D(1, 3, 5+10);
	_h_z06_05_10_24_40 = bookHisto1D(2, 3, 5+10);
	_h_ptrel04_05_10_04_06 = bookHisto1D(1, 4, 1+10);
	_h_ptrel06_05_10_04_06 = bookHisto1D(2, 4, 1+10);
	_h_ptrel04_05_10_06_10 = bookHisto1D(1, 4, 2+10);
	_h_ptrel06_05_10_06_10 = bookHisto1D(2, 4, 2+10);
	_h_ptrel04_05_10_10_15 = bookHisto1D(1, 4, 3+10);
	_h_ptrel06_05_10_10_15 = bookHisto1D(2, 4, 3+10);
	_h_ptrel04_05_10_15_24 = bookHisto1D(1, 4, 4+10);
	_h_ptrel06_05_10_15_24 = bookHisto1D(2, 4, 4+10);
	_h_ptrel04_05_10_24_40 = bookHisto1D(1, 4, 5+10);
	_h_ptrel06_05_10_24_40 = bookHisto1D(2, 4, 5+10);
	_h_rdA04_05_10_04_06 = bookHisto1D(1, 5, 1+10);
	_h_rdA06_05_10_04_06 = bookHisto1D(2, 5, 1+10);
	_h_rdA04_05_10_06_10 = bookHisto1D(1, 5, 2+10);
	_h_rdA06_05_10_06_10 = bookHisto1D(2, 5, 2+10);
	_h_rdA04_05_10_10_15 = bookHisto1D(1, 5, 3+10);
	_h_rdA06_05_10_10_15 = bookHisto1D(2, 5, 3+10);
	_h_rdA04_05_10_15_24 = bookHisto1D(1, 5, 4+10);
	_h_rdA06_05_10_15_24 = bookHisto1D(2, 5, 4+10);
	_h_rdA04_05_10_24_40 = bookHisto1D(1, 5, 5+10);
	_h_rdA06_05_10_24_40 = bookHisto1D(2, 5, 5+10);

	_h_pt04_10_15 = bookHisto1D(1, 1, 3);
	_h_pt06_10_15 = bookHisto1D(2, 1, 3);
	_h_N04_10_15_04_06 = bookHisto1D(1, 2, 1+15);
	_h_N06_10_15_04_06 = bookHisto1D(2, 2, 1+15);
	_h_N04_10_15_06_10 = bookHisto1D(1, 2, 2+15);
	_h_N06_10_15_06_10 = bookHisto1D(2, 2, 2+15);
	_h_N04_10_15_10_15 = bookHisto1D(1, 2, 3+15);
	_h_N06_10_15_10_15 = bookHisto1D(2, 2, 3+15);
	_h_N04_10_15_15_24 = bookHisto1D(1, 2, 4+15);
	_h_N06_10_15_15_24 = bookHisto1D(2, 2, 4+15);
	_h_N04_10_15_24_40 = bookHisto1D(1, 2, 5+15);
	_h_N06_10_15_24_40 = bookHisto1D(2, 2, 5+15);
	_h_z04_10_15_04_06 = bookHisto1D(1, 3, 1+15);
	_h_z06_10_15_04_06 = bookHisto1D(2, 3, 1+15);
	_h_z04_10_15_06_10 = bookHisto1D(1, 3, 2+15);
	_h_z06_10_15_06_10 = bookHisto1D(2, 3, 2+15);
	_h_z04_10_15_10_15 = bookHisto1D(1, 3, 3+15);
	_h_z06_10_15_10_15 = bookHisto1D(2, 3, 3+15);
	_h_z04_10_15_15_24 = bookHisto1D(1, 3, 4+15);
	_h_z06_10_15_15_24 = bookHisto1D(2, 3, 4+15);
	_h_z04_10_15_24_40 = bookHisto1D(1, 3, 5+15);
	_h_z06_10_15_24_40 = bookHisto1D(2, 3, 5+15);
	_h_ptrel04_10_15_04_06 = bookHisto1D(1, 4, 1+15);
	_h_ptrel06_10_15_04_06 = bookHisto1D(2, 4, 1+15);
	_h_ptrel04_10_15_06_10 = bookHisto1D(1, 4, 2+15);
	_h_ptrel06_10_15_06_10 = bookHisto1D(2, 4, 2+15);
	_h_ptrel04_10_15_10_15 = bookHisto1D(1, 4, 3+15);
	_h_ptrel06_10_15_10_15 = bookHisto1D(2, 4, 3+15);
	_h_ptrel04_10_15_15_24 = bookHisto1D(1, 4, 4+15);
	_h_ptrel06_10_15_15_24 = bookHisto1D(2, 4, 4+15);
	_h_ptrel04_10_15_24_40 = bookHisto1D(1, 4, 5+15);
	_h_ptrel06_10_15_24_40 = bookHisto1D(2, 4, 5+15);
	_h_rdA04_10_15_04_06 = bookHisto1D(1, 5, 1+15);
	_h_rdA06_10_15_04_06 = bookHisto1D(2, 5, 1+15);
	_h_rdA04_10_15_06_10 = bookHisto1D(1, 5, 2+15);
	_h_rdA06_10_15_06_10 = bookHisto1D(2, 5, 2+15);
	_h_rdA04_10_15_10_15 = bookHisto1D(1, 5, 3+15);
	_h_rdA06_10_15_10_15 = bookHisto1D(2, 5, 3+15);
	_h_rdA04_10_15_15_24 = bookHisto1D(1, 5, 4+15);
	_h_rdA06_10_15_15_24 = bookHisto1D(2, 5, 4+15);
	_h_rdA04_10_15_24_40 = bookHisto1D(1, 5, 5+15);
	_h_rdA06_10_15_24_40 = bookHisto1D(2, 5, 5+15);

	_h_pt04_15_19 = bookHisto1D(1, 1, 4);
	_h_pt06_15_19 = bookHisto1D(2, 1, 4);
	_h_N04_15_19_04_06 = bookHisto1D(1, 2, 1+20);
	_h_N06_15_19_04_06 = bookHisto1D(2, 2, 1+20);
	_h_N04_15_19_06_10 = bookHisto1D(1, 2, 2+20);
	_h_N06_15_19_06_10 = bookHisto1D(2, 2, 2+20);
	_h_N04_15_19_10_15 = bookHisto1D(1, 2, 3+20);
	_h_N06_15_19_10_15 = bookHisto1D(2, 2, 3+20);
	_h_N04_15_19_15_24 = bookHisto1D(1, 2, 4+20);
	_h_N06_15_19_15_24 = bookHisto1D(2, 2, 4+20);
	_h_N04_15_19_24_40 = bookHisto1D(1, 2, 5+20);
	_h_N06_15_19_24_40 = bookHisto1D(2, 2, 5+20);
	_h_z04_15_19_04_06 = bookHisto1D(1, 3, 1+20);
	_h_z06_15_19_04_06 = bookHisto1D(2, 3, 1+20);
	_h_z04_15_19_06_10 = bookHisto1D(1, 3, 2+20);
	_h_z06_15_19_06_10 = bookHisto1D(2, 3, 2+20);
	_h_z04_15_19_10_15 = bookHisto1D(1, 3, 3+20);
	_h_z06_15_19_10_15 = bookHisto1D(2, 3, 3+20);
	_h_z04_15_19_15_24 = bookHisto1D(1, 3, 4+20);
	_h_z06_15_19_15_24 = bookHisto1D(2, 3, 4+20);
	_h_z04_15_19_24_40 = bookHisto1D(1, 3, 5+20);
	_h_z06_15_19_24_40 = bookHisto1D(2, 3, 5+20);
	_h_ptrel04_15_19_04_06 = bookHisto1D(1, 4, 1+20);
	_h_ptrel06_15_19_04_06 = bookHisto1D(2, 4, 1+20);
	_h_ptrel04_15_19_06_10 = bookHisto1D(1, 4, 2+20);
	_h_ptrel06_15_19_06_10 = bookHisto1D(2, 4, 2+20);
	_h_ptrel04_15_19_10_15 = bookHisto1D(1, 4, 3+20);
	_h_ptrel06_15_19_10_15 = bookHisto1D(2, 4, 3+20);
	_h_ptrel04_15_19_15_24 = bookHisto1D(1, 4, 4+20);
	_h_ptrel06_15_19_15_24 = bookHisto1D(2, 4, 4+20);
	_h_ptrel04_15_19_24_40 = bookHisto1D(1, 4, 5+20);
	_h_ptrel06_15_19_24_40 = bookHisto1D(2, 4, 5+20);
	_h_rdA04_15_19_04_06 = bookHisto1D(1, 5, 1+20);
	_h_rdA06_15_19_04_06 = bookHisto1D(2, 5, 1+20);
	_h_rdA04_15_19_06_10 = bookHisto1D(1, 5, 2+20);
	_h_rdA06_15_19_06_10 = bookHisto1D(2, 5, 2+20);
	_h_rdA04_15_19_10_15 = bookHisto1D(1, 5, 3+20);
	_h_rdA06_15_19_10_15 = bookHisto1D(2, 5, 3+20);
	_h_rdA04_15_19_15_24 = bookHisto1D(1, 5, 4+20);
	_h_rdA06_15_19_15_24 = bookHisto1D(2, 5, 4+20);
	_h_rdA04_15_19_24_40 = bookHisto1D(1, 5, 5+20);
	_h_rdA06_15_19_24_40 = bookHisto1D(2, 5, 5+20);

	_h_N04_00_19_04_06 = bookHisto1D(1, 2, 1+0);
	_h_N06_00_19_04_06 = bookHisto1D(2, 2, 1+0);
	_h_N04_00_19_06_10 = bookHisto1D(1, 2, 2+0);
	_h_N06_00_19_06_10 = bookHisto1D(2, 2, 2+0);
	_h_N04_00_19_10_15 = bookHisto1D(1, 2, 3+0);
	_h_N06_00_19_10_15 = bookHisto1D(2, 2, 3+0);
	_h_N04_00_19_15_24 = bookHisto1D(1, 2, 4+0);
	_h_N06_00_19_15_24 = bookHisto1D(2, 2, 4+0);
	_h_N04_00_19_24_40 = bookHisto1D(1, 2, 5+0);
	_h_N06_00_19_24_40 = bookHisto1D(2, 2, 5+0);
	_h_z04_00_19_04_06 = bookHisto1D(1, 3, 1+0);
	_h_z06_00_19_04_06 = bookHisto1D(2, 3, 1+0);
	_h_z04_00_19_06_10 = bookHisto1D(1, 3, 2+0);
	_h_z06_00_19_06_10 = bookHisto1D(2, 3, 2+0);
	_h_z04_00_19_10_15 = bookHisto1D(1, 3, 3+0);
	_h_z06_00_19_10_15 = bookHisto1D(2, 3, 3+0);
	_h_z04_00_19_15_24 = bookHisto1D(1, 3, 4+0);
	_h_z06_00_19_15_24 = bookHisto1D(2, 3, 4+0);
	_h_z04_00_19_24_40 = bookHisto1D(1, 3, 5+0);
	_h_z06_00_19_24_40 = bookHisto1D(2, 3, 5+0);
	_h_ptrel04_00_19_04_06 = bookHisto1D(1, 4, 1+0);
	_h_ptrel06_00_19_04_06 = bookHisto1D(2, 4, 1+0);
	_h_ptrel04_00_19_06_10 = bookHisto1D(1, 4, 2+0);
	_h_ptrel06_00_19_06_10 = bookHisto1D(2, 4, 2+0);
	_h_ptrel04_00_19_10_15 = bookHisto1D(1, 4, 3+0);
	_h_ptrel06_00_19_10_15 = bookHisto1D(2, 4, 3+0);
	_h_ptrel04_00_19_15_24 = bookHisto1D(1, 4, 4+0);
	_h_ptrel06_00_19_15_24 = bookHisto1D(2, 4, 4+0);
	_h_ptrel04_00_19_24_40 = bookHisto1D(1, 4, 5+0);
	_h_ptrel06_00_19_24_40 = bookHisto1D(2, 4, 5+0);
	_h_rdA04_00_19_04_06 = bookHisto1D(1, 5, 1+0);
	_h_rdA06_00_19_04_06 = bookHisto1D(2, 5, 1+0);
	_h_rdA04_00_19_06_10 = bookHisto1D(1, 5, 2+0);
	_h_rdA06_00_19_06_10 = bookHisto1D(2, 5, 2+0);
	_h_rdA04_00_19_10_15 = bookHisto1D(1, 5, 3+0);
	_h_rdA06_00_19_10_15 = bookHisto1D(2, 5, 3+0);
	_h_rdA04_00_19_15_24 = bookHisto1D(1, 5, 4+0);
	_h_rdA06_00_19_15_24 = bookHisto1D(2, 5, 4+0);
	_h_rdA04_00_19_24_40 = bookHisto1D(1, 5, 5+0);
	_h_rdA06_00_19_24_40 = bookHisto1D(2, 5, 5+0);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const Jets& jets04 = applyProjection<JetAlg>(event, "Jets04").jets();
	+ const Jets& jets04 = apply<JetAlg>(event, "Jets04").jets();
	if (!jets04.empty()) {
	_sumofweights04 += weight;
	foreach (const Jet& j, jets04) {
	const double jetpt = j.pT();
	if (j.absrap() < 0.5) {
	_h_pt04_00_05->fill(jetpt/GeV, weight);
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets04_00_05_04_06 += weight;
	_h_N04_00_05_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_05_04_06->fill(calcz(j,p),weight);
	_h_ptrel04_00_05_04_06->fill(calcptrel(j,p),weight);
	_h_rdA04_00_05_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets04_00_05_06_10 += weight;
	_h_N04_00_05_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_05_06_10->fill(calcz(j,p),weight);
	_h_ptrel04_00_05_06_10->fill(calcptrel(j,p),weight);
	_h_rdA04_00_05_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets04_00_05_10_15 += weight;
	_h_N04_00_05_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_05_10_15->fill(calcz(j,p),weight);
	_h_ptrel04_00_05_10_15->fill(calcptrel(j,p),weight);
	_h_rdA04_00_05_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets04_00_05_15_24 += weight;
	_h_N04_00_05_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_05_15_24->fill(calcz(j,p),weight);
	_h_ptrel04_00_05_15_24->fill(calcptrel(j,p),weight);
	_h_rdA04_00_05_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets04_00_05_24_40 += weight;
	_h_N04_00_05_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_05_24_40->fill(calcz(j,p),weight);
	_h_ptrel04_00_05_24_40->fill(calcptrel(j,p),weight);
	_h_rdA04_00_05_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	}
	if (j.absrap() > 0.5 && j.absrap() < 1.0) {
	_h_pt04_05_10->fill(jetpt/GeV, weight);
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets04_05_10_04_06 += weight;
	_h_N04_05_10_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_05_10_04_06->fill(calcz(j,p),weight);
	_h_ptrel04_05_10_04_06->fill(calcptrel(j,p),weight);
	_h_rdA04_05_10_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets04_05_10_06_10 += weight;
	_h_N04_05_10_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_05_10_06_10->fill(calcz(j,p),weight);
	_h_ptrel04_05_10_06_10->fill(calcptrel(j,p),weight);
	_h_rdA04_05_10_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets04_05_10_10_15 += weight;
	_h_N04_05_10_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_05_10_10_15->fill(calcz(j,p),weight);
	_h_ptrel04_05_10_10_15->fill(calcptrel(j,p),weight);
	_h_rdA04_05_10_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets04_05_10_15_24 += weight;
	_h_N04_05_10_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_05_10_15_24->fill(calcz(j,p),weight);
	_h_ptrel04_05_10_15_24->fill(calcptrel(j,p),weight);
	_h_rdA04_05_10_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets04_05_10_24_40 += weight;
	_h_N04_05_10_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_05_10_24_40->fill(calcz(j,p),weight);
	_h_ptrel04_05_10_24_40->fill(calcptrel(j,p),weight);
	_h_rdA04_05_10_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	}
	if (j.absrap() > 1.0 && j.absrap() < 1.5) {
	_h_pt04_10_15->fill(jetpt/GeV, weight);
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets04_10_15_04_06 += weight;
	_h_N04_10_15_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_10_15_04_06->fill(calcz(j,p),weight);
	_h_ptrel04_10_15_04_06->fill(calcptrel(j,p),weight);
	_h_rdA04_10_15_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets04_10_15_06_10 += weight;
	_h_N04_10_15_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_10_15_06_10->fill(calcz(j,p),weight);
	_h_ptrel04_10_15_06_10->fill(calcptrel(j,p),weight);
	_h_rdA04_10_15_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets04_10_15_10_15 += weight;
	_h_N04_10_15_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_10_15_10_15->fill(calcz(j,p),weight);
	_h_ptrel04_10_15_10_15->fill(calcptrel(j,p),weight);
	_h_rdA04_10_15_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets04_10_15_15_24 += weight;
	_h_N04_10_15_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_10_15_15_24->fill(calcz(j,p),weight);
	_h_ptrel04_10_15_15_24->fill(calcptrel(j,p),weight);
	_h_rdA04_10_15_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets04_10_15_24_40 += weight;
	_h_N04_10_15_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_10_15_24_40->fill(calcz(j,p),weight);
	_h_ptrel04_10_15_24_40->fill(calcptrel(j,p),weight);
	_h_rdA04_10_15_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	}
	if (j.absrap() > 1.5 && j.absrap() < 1.9) {
	_h_pt04_15_19->fill(jetpt/GeV, weight);
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets04_15_19_04_06 += weight;
	_h_N04_15_19_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_15_19_04_06->fill(calcz(j,p),weight);
	_h_ptrel04_15_19_04_06->fill(calcptrel(j,p),weight);
	_h_rdA04_15_19_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets04_15_19_06_10 += weight;
	_h_N04_15_19_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_15_19_06_10->fill(calcz(j,p),weight);
	_h_ptrel04_15_19_06_10->fill(calcptrel(j,p),weight);
	_h_rdA04_15_19_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets04_15_19_10_15 += weight;
	_h_N04_15_19_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_15_19_10_15->fill(calcz(j,p),weight);
	_h_ptrel04_15_19_10_15->fill(calcptrel(j,p),weight);
	_h_rdA04_15_19_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets04_15_19_15_24 += weight;
	_h_N04_15_19_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_15_19_15_24->fill(calcz(j,p),weight);
	_h_ptrel04_15_19_15_24->fill(calcptrel(j,p),weight);
	_h_rdA04_15_19_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets04_15_19_24_40 += weight;
	_h_N04_15_19_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_15_19_24_40->fill(calcz(j,p),weight);
	_h_ptrel04_15_19_24_40->fill(calcptrel(j,p),weight);
	_h_rdA04_15_19_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	} // 1.5 < rapidity < 1.9
	if (j.absrap() < 1.9) {
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets04_00_19_04_06 += weight;
	_h_N04_00_19_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_19_04_06->fill(calcz(j,p),weight);
	_h_ptrel04_00_19_04_06->fill(calcptrel(j,p),weight);
	_h_rdA04_00_19_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets04_00_19_06_10 += weight;
	_h_N04_00_19_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_19_06_10->fill(calcz(j,p),weight);
	_h_ptrel04_00_19_06_10->fill(calcptrel(j,p),weight);
	_h_rdA04_00_19_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets04_00_19_10_15 += weight;
	_h_N04_00_19_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_19_10_15->fill(calcz(j,p),weight);
	_h_ptrel04_00_19_10_15->fill(calcptrel(j,p),weight);
	_h_rdA04_00_19_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets04_00_19_15_24 += weight;
	_h_N04_00_19_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_19_15_24->fill(calcz(j,p),weight);
	_h_ptrel04_00_19_15_24->fill(calcptrel(j,p),weight);
	_h_rdA04_00_19_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets04_00_19_24_40 += weight;
	_h_N04_00_19_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z04_00_19_24_40->fill(calcz(j,p),weight);
	_h_ptrel04_00_19_24_40->fill(calcptrel(j,p),weight);
	_h_rdA04_00_19_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	} // 0.0 < rapidity < 1.9
	} // each jet
	} // jets04 not empty

	- const Jets& jets06 = applyProjection<JetAlg>(event, "Jets06").jets();
	+ const Jets& jets06 = apply<JetAlg>(event, "Jets06").jets();
	if (!jets06.empty()) {
	_sumofweights06 += weight;
	foreach (const Jet& j, jets06) {
	const double jetpt = j.pT();
	if (j.absrap() < 0.5) {
	_h_pt06_00_05->fill(jetpt/GeV, weight);
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets06_00_05_04_06 += weight;
	_h_N06_00_05_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_05_04_06->fill(calcz(j,p),weight);
	_h_ptrel06_00_05_04_06->fill(calcptrel(j,p),weight);
	_h_rdA06_00_05_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets06_00_05_06_10 += weight;
	_h_N06_00_05_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_05_06_10->fill(calcz(j,p),weight);
	_h_ptrel06_00_05_06_10->fill(calcptrel(j,p),weight);
	_h_rdA06_00_05_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets06_00_05_10_15 += weight;
	_h_N06_00_05_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_05_10_15->fill(calcz(j,p),weight);
	_h_ptrel06_00_05_10_15->fill(calcptrel(j,p),weight);
	_h_rdA06_00_05_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets06_00_05_15_24 += weight;
	_h_N06_00_05_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_05_15_24->fill(calcz(j,p),weight);
	_h_ptrel06_00_05_15_24->fill(calcptrel(j,p),weight);
	_h_rdA06_00_05_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets06_00_05_24_40 += weight;
	_h_N06_00_05_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_05_24_40->fill(calcz(j,p),weight);
	_h_ptrel06_00_05_24_40->fill(calcptrel(j,p),weight);
	_h_rdA06_00_05_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	}
	if (j.absrap() > 0.5 && j.absrap() < 1.0) {
	_h_pt06_05_10->fill(jetpt/GeV, weight);
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets06_05_10_04_06 += weight;
	_h_N06_05_10_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_05_10_04_06->fill(calcz(j,p),weight);
	_h_ptrel06_05_10_04_06->fill(calcptrel(j,p),weight);
	_h_rdA06_05_10_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets06_05_10_06_10 += weight;
	_h_N06_05_10_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_05_10_06_10->fill(calcz(j,p),weight);
	_h_ptrel06_05_10_06_10->fill(calcptrel(j,p),weight);
	_h_rdA06_05_10_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets06_05_10_10_15 += weight;
	_h_N06_05_10_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_05_10_10_15->fill(calcz(j,p),weight);
	_h_ptrel06_05_10_10_15->fill(calcptrel(j,p),weight);
	_h_rdA06_05_10_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets06_05_10_15_24 += weight;
	_h_N06_05_10_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_05_10_15_24->fill(calcz(j,p),weight);
	_h_ptrel06_05_10_15_24->fill(calcptrel(j,p),weight);
	_h_rdA06_05_10_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets06_05_10_24_40 += weight;
	_h_N06_05_10_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_05_10_24_40->fill(calcz(j,p),weight);
	_h_ptrel06_05_10_24_40->fill(calcptrel(j,p),weight);
	_h_rdA06_05_10_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	}
	if (j.absrap() > 1.0 && j.absrap() < 1.5) {
	_h_pt06_10_15->fill(jetpt/GeV, weight);
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets06_10_15_04_06 += weight;
	_h_N06_10_15_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_10_15_04_06->fill(calcz(j,p),weight);
	_h_ptrel06_10_15_04_06->fill(calcptrel(j,p),weight);
	_h_rdA06_10_15_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets06_10_15_06_10 += weight;
	_h_N06_10_15_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_10_15_06_10->fill(calcz(j,p),weight);
	_h_ptrel06_10_15_06_10->fill(calcptrel(j,p),weight);
	_h_rdA06_10_15_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets06_10_15_10_15 += weight;
	_h_N06_10_15_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_10_15_10_15->fill(calcz(j,p),weight);
	_h_ptrel06_10_15_10_15->fill(calcptrel(j,p),weight);
	_h_rdA06_10_15_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets06_10_15_15_24 += weight;
	_h_N06_10_15_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_10_15_15_24->fill(calcz(j,p),weight);
	_h_ptrel06_10_15_15_24->fill(calcptrel(j,p),weight);
	_h_rdA06_10_15_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets06_10_15_24_40 += weight;
	_h_N06_10_15_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_10_15_24_40->fill(calcz(j,p),weight);
	_h_ptrel06_10_15_24_40->fill(calcptrel(j,p),weight);
	_h_rdA06_10_15_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	}
	if (j.absrap() > 1.5 && j.absrap() < 1.9) {
	_h_pt06_15_19->fill(jetpt/GeV, weight);
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets06_15_19_04_06 += weight;
	_h_N06_15_19_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_15_19_04_06->fill(calcz(j,p),weight);
	_h_ptrel06_15_19_04_06->fill(calcptrel(j,p),weight);
	_h_rdA06_15_19_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets06_15_19_06_10 += weight;
	_h_N06_15_19_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_15_19_06_10->fill(calcz(j,p),weight);
	_h_ptrel06_15_19_06_10->fill(calcptrel(j,p),weight);
	_h_rdA06_15_19_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets06_15_19_10_15 += weight;
	_h_N06_15_19_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_15_19_10_15->fill(calcz(j,p),weight);
	_h_ptrel06_15_19_10_15->fill(calcptrel(j,p),weight);
	_h_rdA06_15_19_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets06_15_19_15_24 += weight;
	_h_N06_15_19_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_15_19_15_24->fill(calcz(j,p),weight);
	_h_ptrel06_15_19_15_24->fill(calcptrel(j,p),weight);
	_h_rdA06_15_19_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets06_15_19_24_40 += weight;
	_h_N06_15_19_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_15_19_24_40->fill(calcz(j,p),weight);
	_h_ptrel06_15_19_24_40->fill(calcptrel(j,p),weight);
	_h_rdA06_15_19_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	} // 1.5 < rapidity < 1.9
	if (j.absrap() < 1.9) {
	if (inRange(jetpt/GeV, 4., 6.)) {
	_numjets06_00_19_04_06 += weight;
	_h_N06_00_19_04_06->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_19_04_06->fill(calcz(j,p),weight);
	_h_ptrel06_00_19_04_06->fill(calcptrel(j,p),weight);
	_h_rdA06_00_19_04_06->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 6., 10.)) {
	_numjets06_00_19_06_10 += weight;
	_h_N06_00_19_06_10->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_19_06_10->fill(calcz(j,p),weight);
	_h_ptrel06_00_19_06_10->fill(calcptrel(j,p),weight);
	_h_rdA06_00_19_06_10->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 10., 15.)) {
	_numjets06_00_19_10_15 += weight;
	_h_N06_00_19_10_15->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_19_10_15->fill(calcz(j,p),weight);
	_h_ptrel06_00_19_10_15->fill(calcptrel(j,p),weight);
	_h_rdA06_00_19_10_15->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 15., 24.)) {
	_numjets06_00_19_15_24 += weight;
	_h_N06_00_19_15_24->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_19_15_24->fill(calcz(j,p),weight);
	_h_ptrel06_00_19_15_24->fill(calcptrel(j,p),weight);
	_h_rdA06_00_19_15_24->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	if (inRange(jetpt/GeV, 24., 40.)) {
	_numjets06_00_19_24_40 += weight;
	_h_N06_00_19_24_40->fill(j.particles().size(),weight);
	foreach (const Particle& p, j.particles()) {
	_h_z06_00_19_24_40->fill(calcz(j,p),weight);
	_h_ptrel06_00_19_24_40->fill(calcptrel(j,p),weight);
	_h_rdA06_00_19_24_40->fill(calcr(j,p),weight*calcrweight(j,p));
	}
	}
	}
	} // each jet
	} // jets06 not empty

	} // end of event


	/// Normalise histograms etc., after the run
	void finalize() {

	// pT histos: d2sigma_jet / deta dpT
	const double xsec = crossSection()/microbarn;
	safeinvscale(_h_pt04_00_05, _sumofweights04(20.5)/xsec);
	safeinvscale(_h_pt06_00_05, _sumofweights06(20.5)/xsec);
	safeinvscale(_h_pt04_05_10, _sumofweights04(20.5)/xsec);
	safeinvscale(_h_pt06_05_10, _sumofweights06(20.5)/xsec);
	safeinvscale(_h_pt04_10_15, _sumofweights04(20.5)/xsec);
	safeinvscale(_h_pt06_10_15, _sumofweights06(20.5)/xsec);
	safeinvscale(_h_pt04_15_19, _sumofweights04(20.4)/xsec);
	safeinvscale(_h_pt06_15_19, _sumofweights06(20.4)/xsec);

	// N histos: 1/N_jet dN_jet / dN^{ch}_jet
	safeinvscale(_h_N04_00_05_04_06, _numjets04_00_05_04_06);
	safeinvscale(_h_N06_00_05_04_06, _numjets06_00_05_04_06);
	safeinvscale(_h_N04_00_05_06_10, _numjets04_00_05_06_10);
	safeinvscale(_h_N06_00_05_06_10, _numjets06_00_05_06_10);
	safeinvscale(_h_N04_00_05_10_15, _numjets04_00_05_10_15);
	safeinvscale(_h_N06_00_05_10_15, _numjets06_00_05_10_15);
	safeinvscale(_h_N04_00_05_15_24, _numjets04_00_05_15_24);
	safeinvscale(_h_N06_00_05_15_24, _numjets06_00_05_15_24);
	safeinvscale(_h_N04_00_05_24_40, _numjets04_00_05_24_40);
	safeinvscale(_h_N06_00_05_24_40, _numjets06_00_05_24_40);
	safeinvscale(_h_N04_05_10_04_06, _numjets04_05_10_04_06);
	safeinvscale(_h_N06_05_10_04_06, _numjets06_05_10_04_06);
	safeinvscale(_h_N04_05_10_06_10, _numjets04_05_10_06_10);
	safeinvscale(_h_N06_05_10_06_10, _numjets06_05_10_06_10);
	safeinvscale(_h_N04_05_10_10_15, _numjets04_05_10_10_15);
	safeinvscale(_h_N06_05_10_10_15, _numjets06_05_10_10_15);
	safeinvscale(_h_N04_05_10_15_24, _numjets04_05_10_15_24);
	safeinvscale(_h_N06_05_10_15_24, _numjets06_05_10_15_24);
	safeinvscale(_h_N04_05_10_24_40, _numjets04_05_10_24_40);
	safeinvscale(_h_N06_05_10_24_40, _numjets06_05_10_24_40);
	safeinvscale(_h_N04_10_15_04_06, _numjets04_10_15_04_06);
	safeinvscale(_h_N06_10_15_04_06, _numjets06_10_15_04_06);
	safeinvscale(_h_N04_10_15_06_10, _numjets04_10_15_06_10);
	safeinvscale(_h_N06_10_15_06_10, _numjets06_10_15_06_10);
	safeinvscale(_h_N04_10_15_10_15, _numjets04_10_15_10_15);
	safeinvscale(_h_N06_10_15_10_15, _numjets06_10_15_10_15);
	safeinvscale(_h_N04_10_15_15_24, _numjets04_10_15_15_24);
	safeinvscale(_h_N06_10_15_15_24, _numjets06_10_15_15_24);
	safeinvscale(_h_N04_10_15_24_40, _numjets04_10_15_24_40);
	safeinvscale(_h_N06_10_15_24_40, _numjets06_10_15_24_40);
	safeinvscale(_h_N04_15_19_04_06, _numjets04_15_19_04_06);
	safeinvscale(_h_N06_15_19_04_06, _numjets06_15_19_04_06);
	safeinvscale(_h_N04_15_19_06_10, _numjets04_15_19_06_10);
	safeinvscale(_h_N06_15_19_06_10, _numjets06_15_19_06_10);
	safeinvscale(_h_N04_15_19_10_15, _numjets04_15_19_10_15);
	safeinvscale(_h_N06_15_19_10_15, _numjets06_15_19_10_15);
	safeinvscale(_h_N04_15_19_15_24, _numjets04_15_19_15_24);
	safeinvscale(_h_N06_15_19_15_24, _numjets06_15_19_15_24);
	safeinvscale(_h_N04_15_19_24_40, _numjets04_15_19_24_40);
	safeinvscale(_h_N06_15_19_24_40, _numjets06_15_19_24_40);
	safeinvscale(_h_N04_00_19_04_06, _numjets04_00_19_04_06);
	safeinvscale(_h_N06_00_19_04_06, _numjets06_00_19_04_06);
	safeinvscale(_h_N04_00_19_06_10, _numjets04_00_19_06_10);
	safeinvscale(_h_N06_00_19_06_10, _numjets06_00_19_06_10);
	safeinvscale(_h_N04_00_19_10_15, _numjets04_00_19_10_15);
	safeinvscale(_h_N06_00_19_10_15, _numjets06_00_19_10_15);
	safeinvscale(_h_N04_00_19_15_24, _numjets04_00_19_15_24);
	safeinvscale(_h_N06_00_19_15_24, _numjets06_00_19_15_24);
	safeinvscale(_h_N04_00_19_24_40, _numjets04_00_19_24_40);
	safeinvscale(_h_N06_00_19_24_40, _numjets06_00_19_24_40);

	// z histos: 1/N_jet dN_track / dz_track
	safeinvscale(_h_z04_00_05_04_06, _numjets04_00_05_04_06);
	safeinvscale(_h_z06_00_05_04_06, _numjets06_00_05_04_06);
	safeinvscale(_h_z04_00_05_06_10, _numjets04_00_05_06_10);
	safeinvscale(_h_z06_00_05_06_10, _numjets06_00_05_06_10);
	safeinvscale(_h_z04_00_05_10_15, _numjets04_00_05_10_15);
	safeinvscale(_h_z06_00_05_10_15, _numjets06_00_05_10_15);
	safeinvscale(_h_z04_00_05_15_24, _numjets04_00_05_15_24);
	safeinvscale(_h_z06_00_05_15_24, _numjets06_00_05_15_24);
	safeinvscale(_h_z04_00_05_24_40, _numjets04_00_05_24_40);
	safeinvscale(_h_z06_00_05_24_40, _numjets06_00_05_24_40);
	safeinvscale(_h_z04_05_10_04_06, _numjets04_05_10_04_06);
	safeinvscale(_h_z06_05_10_04_06, _numjets06_05_10_04_06);
	safeinvscale(_h_z04_05_10_06_10, _numjets04_05_10_06_10);
	safeinvscale(_h_z06_05_10_06_10, _numjets06_05_10_06_10);
	safeinvscale(_h_z04_05_10_10_15, _numjets04_05_10_10_15);
	safeinvscale(_h_z06_05_10_10_15, _numjets06_05_10_10_15);
	safeinvscale(_h_z04_05_10_15_24, _numjets04_05_10_15_24);
	safeinvscale(_h_z06_05_10_15_24, _numjets06_05_10_15_24);
	safeinvscale(_h_z04_05_10_24_40, _numjets04_05_10_24_40);
	safeinvscale(_h_z06_05_10_24_40, _numjets06_05_10_24_40);
	safeinvscale(_h_z04_10_15_04_06, _numjets04_10_15_04_06);
	safeinvscale(_h_z06_10_15_04_06, _numjets06_10_15_04_06);
	safeinvscale(_h_z04_10_15_06_10, _numjets04_10_15_06_10);
	safeinvscale(_h_z06_10_15_06_10, _numjets06_10_15_06_10);
	safeinvscale(_h_z04_10_15_10_15, _numjets04_10_15_10_15);
	safeinvscale(_h_z06_10_15_10_15, _numjets06_10_15_10_15);
	safeinvscale(_h_z04_10_15_15_24, _numjets04_10_15_15_24);
	safeinvscale(_h_z06_10_15_15_24, _numjets06_10_15_15_24);
	safeinvscale(_h_z04_10_15_24_40, _numjets04_10_15_24_40);
	safeinvscale(_h_z06_10_15_24_40, _numjets06_10_15_24_40);
	safeinvscale(_h_z04_15_19_04_06, _numjets04_15_19_04_06);
	safeinvscale(_h_z06_15_19_04_06, _numjets06_15_19_04_06);
	safeinvscale(_h_z04_15_19_06_10, _numjets04_15_19_06_10);
	safeinvscale(_h_z06_15_19_06_10, _numjets06_15_19_06_10);
	safeinvscale(_h_z04_15_19_10_15, _numjets04_15_19_10_15);
	safeinvscale(_h_z06_15_19_10_15, _numjets06_15_19_10_15);
	safeinvscale(_h_z04_15_19_15_24, _numjets04_15_19_15_24);
	safeinvscale(_h_z06_15_19_15_24, _numjets06_15_19_15_24);
	safeinvscale(_h_z04_15_19_24_40, _numjets04_15_19_24_40);
	safeinvscale(_h_z06_15_19_24_40, _numjets06_15_19_24_40);
	safeinvscale(_h_z04_00_19_04_06, _numjets04_00_19_04_06);
	safeinvscale(_h_z06_00_19_04_06, _numjets06_00_19_04_06);
	safeinvscale(_h_z04_00_19_06_10, _numjets04_00_19_06_10);
	safeinvscale(_h_z06_00_19_06_10, _numjets06_00_19_06_10);
	safeinvscale(_h_z04_00_19_10_15, _numjets04_00_19_10_15);
	safeinvscale(_h_z06_00_19_10_15, _numjets06_00_19_10_15);
	safeinvscale(_h_z04_00_19_15_24, _numjets04_00_19_15_24);
	safeinvscale(_h_z06_00_19_15_24, _numjets06_00_19_15_24);
	safeinvscale(_h_z04_00_19_24_40, _numjets04_00_19_24_40);
	safeinvscale(_h_z06_00_19_24_40, _numjets06_00_19_24_40);

	// ptrel histos: 1/N_jet dN_track / dptrel_track
	safeinvscale(_h_ptrel04_00_05_04_06, _numjets04_00_05_04_06);
	safeinvscale(_h_ptrel06_00_05_04_06, _numjets06_00_05_04_06);
	safeinvscale(_h_ptrel04_00_05_06_10, _numjets04_00_05_06_10);
	safeinvscale(_h_ptrel06_00_05_06_10, _numjets06_00_05_06_10);
	safeinvscale(_h_ptrel04_00_05_10_15, _numjets04_00_05_10_15);
	safeinvscale(_h_ptrel06_00_05_10_15, _numjets06_00_05_10_15);
	safeinvscale(_h_ptrel04_00_05_15_24, _numjets04_00_05_15_24);
	safeinvscale(_h_ptrel06_00_05_15_24, _numjets06_00_05_15_24);
	safeinvscale(_h_ptrel04_00_05_24_40, _numjets04_00_05_24_40);
	safeinvscale(_h_ptrel06_00_05_24_40, _numjets06_00_05_24_40);
	safeinvscale(_h_ptrel04_05_10_04_06, _numjets04_05_10_04_06);
	safeinvscale(_h_ptrel06_05_10_04_06, _numjets06_05_10_04_06);
	safeinvscale(_h_ptrel04_05_10_06_10, _numjets04_05_10_06_10);
	safeinvscale(_h_ptrel06_05_10_06_10, _numjets06_05_10_06_10);
	safeinvscale(_h_ptrel04_05_10_10_15, _numjets04_05_10_10_15);
	safeinvscale(_h_ptrel06_05_10_10_15, _numjets06_05_10_10_15);
	safeinvscale(_h_ptrel04_05_10_15_24, _numjets04_05_10_15_24);
	safeinvscale(_h_ptrel06_05_10_15_24, _numjets06_05_10_15_24);
	safeinvscale(_h_ptrel04_05_10_24_40, _numjets04_05_10_24_40);
	safeinvscale(_h_ptrel06_05_10_24_40, _numjets06_05_10_24_40);
	safeinvscale(_h_ptrel04_10_15_04_06, _numjets04_10_15_04_06);
	safeinvscale(_h_ptrel06_10_15_04_06, _numjets06_10_15_04_06);
	safeinvscale(_h_ptrel04_10_15_06_10, _numjets04_10_15_06_10);
	safeinvscale(_h_ptrel06_10_15_06_10, _numjets06_10_15_06_10);
	safeinvscale(_h_ptrel04_10_15_10_15, _numjets04_10_15_10_15);
	safeinvscale(_h_ptrel06_10_15_10_15, _numjets06_10_15_10_15);
	safeinvscale(_h_ptrel04_10_15_15_24, _numjets04_10_15_15_24);
	safeinvscale(_h_ptrel06_10_15_15_24, _numjets06_10_15_15_24);
	safeinvscale(_h_ptrel04_10_15_24_40, _numjets04_10_15_24_40);
	safeinvscale(_h_ptrel06_10_15_24_40, _numjets06_10_15_24_40);
	safeinvscale(_h_ptrel04_15_19_04_06, _numjets04_15_19_04_06);
	safeinvscale(_h_ptrel06_15_19_04_06, _numjets06_15_19_04_06);
	safeinvscale(_h_ptrel04_15_19_06_10, _numjets04_15_19_06_10);
	safeinvscale(_h_ptrel06_15_19_06_10, _numjets06_15_19_06_10);
	safeinvscale(_h_ptrel04_15_19_10_15, _numjets04_15_19_10_15);
	safeinvscale(_h_ptrel06_15_19_10_15, _numjets06_15_19_10_15);
	safeinvscale(_h_ptrel04_15_19_15_24, _numjets04_15_19_15_24);
	safeinvscale(_h_ptrel06_15_19_15_24, _numjets06_15_19_15_24);
	safeinvscale(_h_ptrel04_15_19_24_40, _numjets04_15_19_24_40);
	safeinvscale(_h_ptrel06_15_19_24_40, _numjets06_15_19_24_40);

	safeinvscale(_h_ptrel04_00_19_04_06, _numjets04_00_19_04_06);
	safeinvscale(_h_ptrel06_00_19_04_06, _numjets06_00_19_04_06);
	safeinvscale(_h_ptrel04_00_19_06_10, _numjets04_00_19_06_10);
	safeinvscale(_h_ptrel06_00_19_06_10, _numjets06_00_19_06_10);
	safeinvscale(_h_ptrel04_00_19_10_15, _numjets04_00_19_10_15);
	safeinvscale(_h_ptrel06_00_19_10_15, _numjets06_00_19_10_15);
	safeinvscale(_h_ptrel04_00_19_15_24, _numjets04_00_19_15_24);
	safeinvscale(_h_ptrel06_00_19_15_24, _numjets06_00_19_15_24);
	safeinvscale(_h_ptrel04_00_19_24_40, _numjets04_00_19_24_40);
	safeinvscale(_h_ptrel06_00_19_24_40, _numjets06_00_19_24_40);

	// r histos: 1/N_jet dN_track / dA
	safeinvscale(_h_rdA04_00_05_04_06, _numjets04_00_05_04_06);
	safeinvscale(_h_rdA06_00_05_04_06, _numjets06_00_05_04_06);
	safeinvscale(_h_rdA04_00_05_06_10, _numjets04_00_05_06_10);
	safeinvscale(_h_rdA06_00_05_06_10, _numjets06_00_05_06_10);
	safeinvscale(_h_rdA04_00_05_10_15, _numjets04_00_05_10_15);
	safeinvscale(_h_rdA06_00_05_10_15, _numjets06_00_05_10_15);
	safeinvscale(_h_rdA04_00_05_15_24, _numjets04_00_05_15_24);
	safeinvscale(_h_rdA06_00_05_15_24, _numjets06_00_05_15_24);
	safeinvscale(_h_rdA04_00_05_24_40, _numjets04_00_05_24_40);
	safeinvscale(_h_rdA06_00_05_24_40, _numjets06_00_05_24_40);
	safeinvscale(_h_rdA04_05_10_04_06, _numjets04_05_10_04_06);
	safeinvscale(_h_rdA06_05_10_04_06, _numjets06_05_10_04_06);
	safeinvscale(_h_rdA04_05_10_06_10, _numjets04_05_10_06_10);
	safeinvscale(_h_rdA06_05_10_06_10, _numjets06_05_10_06_10);
	safeinvscale(_h_rdA04_05_10_10_15, _numjets04_05_10_10_15);
	safeinvscale(_h_rdA06_05_10_10_15, _numjets06_05_10_10_15);
	safeinvscale(_h_rdA04_05_10_15_24, _numjets04_05_10_15_24);
	safeinvscale(_h_rdA06_05_10_15_24, _numjets06_05_10_15_24);
	safeinvscale(_h_rdA04_05_10_24_40, _numjets04_05_10_24_40);
	safeinvscale(_h_rdA06_05_10_24_40, _numjets06_05_10_24_40);
	safeinvscale(_h_rdA04_10_15_04_06, _numjets04_10_15_04_06);
	safeinvscale(_h_rdA06_10_15_04_06, _numjets06_10_15_04_06);
	safeinvscale(_h_rdA04_10_15_06_10, _numjets04_10_15_06_10);
	safeinvscale(_h_rdA06_10_15_06_10, _numjets06_10_15_06_10);
	safeinvscale(_h_rdA04_10_15_10_15, _numjets04_10_15_10_15);
	safeinvscale(_h_rdA06_10_15_10_15, _numjets06_10_15_10_15);
	safeinvscale(_h_rdA04_10_15_15_24, _numjets04_10_15_15_24);
	safeinvscale(_h_rdA06_10_15_15_24, _numjets06_10_15_15_24);
	safeinvscale(_h_rdA04_10_15_24_40, _numjets04_10_15_24_40);
	safeinvscale(_h_rdA06_10_15_24_40, _numjets06_10_15_24_40);
	safeinvscale(_h_rdA04_15_19_04_06, _numjets04_15_19_04_06);
	safeinvscale(_h_rdA06_15_19_04_06, _numjets06_15_19_04_06);
	safeinvscale(_h_rdA04_15_19_06_10, _numjets04_15_19_06_10);
	safeinvscale(_h_rdA06_15_19_06_10, _numjets06_15_19_06_10);
	safeinvscale(_h_rdA04_15_19_10_15, _numjets04_15_19_10_15);
	safeinvscale(_h_rdA06_15_19_10_15, _numjets06_15_19_10_15);
	safeinvscale(_h_rdA04_15_19_15_24, _numjets04_15_19_15_24);
	safeinvscale(_h_rdA06_15_19_15_24, _numjets06_15_19_15_24);
	safeinvscale(_h_rdA04_15_19_24_40, _numjets04_15_19_24_40);
	safeinvscale(_h_rdA06_15_19_24_40, _numjets06_15_19_24_40);

	safeinvscale(_h_rdA04_00_19_04_06, _numjets04_00_19_04_06);
	safeinvscale(_h_rdA06_00_19_04_06, _numjets06_00_19_04_06);
	safeinvscale(_h_rdA04_00_19_06_10, _numjets04_00_19_06_10);
	safeinvscale(_h_rdA06_00_19_06_10, _numjets06_00_19_06_10);
	safeinvscale(_h_rdA04_00_19_10_15, _numjets04_00_19_10_15);
	safeinvscale(_h_rdA06_00_19_10_15, _numjets06_00_19_10_15);
	safeinvscale(_h_rdA04_00_19_15_24, _numjets04_00_19_15_24);
	safeinvscale(_h_rdA06_00_19_15_24, _numjets06_00_19_15_24);
	safeinvscale(_h_rdA04_00_19_24_40, _numjets04_00_19_24_40);
	safeinvscale(_h_rdA06_00_19_24_40, _numjets06_00_19_24_40);
	}

	//@}


	private:

	void safeinvscale(Histo1DPtr h, double denom) {
	if (denom != 0) {
	scale(h, 1.0/denom);
	} else {
	normalize(h, 0);
	}
	}


	/// Event weights
	double _sumofweights04, _sumofweights06;


	/// Jet counters
	double _numjets04_00_05_04_06, _numjets04_00_05_06_10, _numjets04_00_05_10_15, _numjets04_00_05_15_24, _numjets04_00_05_24_40;
	double _numjets06_00_05_04_06, _numjets06_00_05_06_10, _numjets06_00_05_10_15, _numjets06_00_05_15_24, _numjets06_00_05_24_40;
	double _numjets04_05_10_04_06, _numjets04_05_10_06_10, _numjets04_05_10_10_15, _numjets04_05_10_15_24, _numjets04_05_10_24_40;
	double _numjets06_05_10_04_06, _numjets06_05_10_06_10, _numjets06_05_10_10_15, _numjets06_05_10_15_24, _numjets06_05_10_24_40;
	double _numjets04_10_15_04_06, _numjets04_10_15_06_10, _numjets04_10_15_10_15, _numjets04_10_15_15_24, _numjets04_10_15_24_40;
	double _numjets06_10_15_04_06, _numjets06_10_15_06_10, _numjets06_10_15_10_15, _numjets06_10_15_15_24, _numjets06_10_15_24_40;
	double _numjets04_15_19_04_06, _numjets04_15_19_06_10, _numjets04_15_19_10_15, _numjets04_15_19_15_24, _numjets04_15_19_24_40;
	double _numjets06_15_19_04_06, _numjets06_15_19_06_10, _numjets06_15_19_10_15, _numjets06_15_19_15_24, _numjets06_15_19_24_40;
	double _numjets04_00_19_04_06, _numjets04_00_19_06_10, _numjets04_00_19_10_15, _numjets04_00_19_15_24, _numjets04_00_19_24_40;
	double _numjets06_00_19_04_06, _numjets06_00_19_06_10, _numjets06_00_19_10_15, _numjets06_00_19_15_24, _numjets06_00_19_24_40;


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_pt04_00_05, _h_pt06_00_05;
	Histo1DPtr _h_N04_00_05_04_06, _h_N06_00_05_04_06;
	Histo1DPtr _h_N04_00_05_06_10, _h_N06_00_05_06_10;
	Histo1DPtr _h_N04_00_05_10_15, _h_N06_00_05_10_15;
	Histo1DPtr _h_N04_00_05_15_24, _h_N06_00_05_15_24;
	Histo1DPtr _h_N04_00_05_24_40, _h_N06_00_05_24_40;
	Histo1DPtr _h_z04_00_05_04_06, _h_z06_00_05_04_06;
	Histo1DPtr _h_z04_00_05_06_10, _h_z06_00_05_06_10;
	Histo1DPtr _h_z04_00_05_10_15, _h_z06_00_05_10_15;
	Histo1DPtr _h_z04_00_05_15_24, _h_z06_00_05_15_24;
	Histo1DPtr _h_z04_00_05_24_40, _h_z06_00_05_24_40;
	Histo1DPtr _h_ptrel04_00_05_04_06, _h_ptrel06_00_05_04_06;
	Histo1DPtr _h_ptrel04_00_05_06_10, _h_ptrel06_00_05_06_10;
	Histo1DPtr _h_ptrel04_00_05_10_15, _h_ptrel06_00_05_10_15;
	Histo1DPtr _h_ptrel04_00_05_15_24, _h_ptrel06_00_05_15_24;
	Histo1DPtr _h_ptrel04_00_05_24_40, _h_ptrel06_00_05_24_40;
	Histo1DPtr _h_rdA04_00_05_04_06, _h_rdA06_00_05_04_06;
	Histo1DPtr _h_rdA04_00_05_06_10, _h_rdA06_00_05_06_10;
	Histo1DPtr _h_rdA04_00_05_10_15, _h_rdA06_00_05_10_15;
	Histo1DPtr _h_rdA04_00_05_15_24, _h_rdA06_00_05_15_24;
	Histo1DPtr _h_rdA04_00_05_24_40, _h_rdA06_00_05_24_40;

	Histo1DPtr _h_pt04_05_10, _h_pt06_05_10;
	Histo1DPtr _h_N04_05_10_04_06, _h_N06_05_10_04_06;
	Histo1DPtr _h_N04_05_10_06_10, _h_N06_05_10_06_10;
	Histo1DPtr _h_N04_05_10_10_15, _h_N06_05_10_10_15;
	Histo1DPtr _h_N04_05_10_15_24, _h_N06_05_10_15_24;
	Histo1DPtr _h_N04_05_10_24_40, _h_N06_05_10_24_40;
	Histo1DPtr _h_z04_05_10_04_06, _h_z06_05_10_04_06;
	Histo1DPtr _h_z04_05_10_06_10, _h_z06_05_10_06_10;
	Histo1DPtr _h_z04_05_10_10_15, _h_z06_05_10_10_15;
	Histo1DPtr _h_z04_05_10_15_24, _h_z06_05_10_15_24;
	Histo1DPtr _h_z04_05_10_24_40, _h_z06_05_10_24_40;
	Histo1DPtr _h_ptrel04_05_10_04_06, _h_ptrel06_05_10_04_06;
	Histo1DPtr _h_ptrel04_05_10_06_10, _h_ptrel06_05_10_06_10;
	Histo1DPtr _h_ptrel04_05_10_10_15, _h_ptrel06_05_10_10_15;
	Histo1DPtr _h_ptrel04_05_10_15_24, _h_ptrel06_05_10_15_24;
	Histo1DPtr _h_ptrel04_05_10_24_40, _h_ptrel06_05_10_24_40;
	Histo1DPtr _h_rdA04_05_10_04_06, _h_rdA06_05_10_04_06;
	Histo1DPtr _h_rdA04_05_10_06_10, _h_rdA06_05_10_06_10;
	Histo1DPtr _h_rdA04_05_10_10_15, _h_rdA06_05_10_10_15;
	Histo1DPtr _h_rdA04_05_10_15_24, _h_rdA06_05_10_15_24;
	Histo1DPtr _h_rdA04_05_10_24_40, _h_rdA06_05_10_24_40;

	Histo1DPtr _h_pt04_10_15, _h_pt06_10_15;
	Histo1DPtr _h_N04_10_15_04_06, _h_N06_10_15_04_06;
	Histo1DPtr _h_N04_10_15_06_10, _h_N06_10_15_06_10;
	Histo1DPtr _h_N04_10_15_10_15, _h_N06_10_15_10_15;
	Histo1DPtr _h_N04_10_15_15_24, _h_N06_10_15_15_24;
	Histo1DPtr _h_N04_10_15_24_40, _h_N06_10_15_24_40;
	Histo1DPtr _h_z04_10_15_04_06, _h_z06_10_15_04_06;
	Histo1DPtr _h_z04_10_15_06_10, _h_z06_10_15_06_10;
	Histo1DPtr _h_z04_10_15_10_15, _h_z06_10_15_10_15;
	Histo1DPtr _h_z04_10_15_15_24, _h_z06_10_15_15_24;
	Histo1DPtr _h_z04_10_15_24_40, _h_z06_10_15_24_40;
	Histo1DPtr _h_ptrel04_10_15_04_06, _h_ptrel06_10_15_04_06;
	Histo1DPtr _h_ptrel04_10_15_06_10, _h_ptrel06_10_15_06_10;
	Histo1DPtr _h_ptrel04_10_15_10_15, _h_ptrel06_10_15_10_15;
	Histo1DPtr _h_ptrel04_10_15_15_24, _h_ptrel06_10_15_15_24;
	Histo1DPtr _h_ptrel04_10_15_24_40, _h_ptrel06_10_15_24_40;
	Histo1DPtr _h_rdA04_10_15_04_06, _h_rdA06_10_15_04_06;
	Histo1DPtr _h_rdA04_10_15_06_10, _h_rdA06_10_15_06_10;
	Histo1DPtr _h_rdA04_10_15_10_15, _h_rdA06_10_15_10_15;
	Histo1DPtr _h_rdA04_10_15_15_24, _h_rdA06_10_15_15_24;
	Histo1DPtr _h_rdA04_10_15_24_40, _h_rdA06_10_15_24_40;

	Histo1DPtr _h_pt04_15_19, _h_pt06_15_19;
	Histo1DPtr _h_N04_15_19_04_06, _h_N06_15_19_04_06;
	Histo1DPtr _h_N04_15_19_06_10, _h_N06_15_19_06_10;
	Histo1DPtr _h_N04_15_19_10_15, _h_N06_15_19_10_15;
	Histo1DPtr _h_N04_15_19_15_24, _h_N06_15_19_15_24;
	Histo1DPtr _h_N04_15_19_24_40, _h_N06_15_19_24_40;
	Histo1DPtr _h_z04_15_19_04_06, _h_z06_15_19_04_06;
	Histo1DPtr _h_z04_15_19_06_10, _h_z06_15_19_06_10;
	Histo1DPtr _h_z04_15_19_10_15, _h_z06_15_19_10_15;
	Histo1DPtr _h_z04_15_19_15_24, _h_z06_15_19_15_24;
	Histo1DPtr _h_z04_15_19_24_40, _h_z06_15_19_24_40;
	Histo1DPtr _h_ptrel04_15_19_04_06, _h_ptrel06_15_19_04_06;
	Histo1DPtr _h_ptrel04_15_19_06_10, _h_ptrel06_15_19_06_10;
	Histo1DPtr _h_ptrel04_15_19_10_15, _h_ptrel06_15_19_10_15;
	Histo1DPtr _h_ptrel04_15_19_15_24, _h_ptrel06_15_19_15_24;
	Histo1DPtr _h_ptrel04_15_19_24_40, _h_ptrel06_15_19_24_40;
	Histo1DPtr _h_rdA04_15_19_04_06, _h_rdA06_15_19_04_06;
	Histo1DPtr _h_rdA04_15_19_06_10, _h_rdA06_15_19_06_10;
	Histo1DPtr _h_rdA04_15_19_10_15, _h_rdA06_15_19_10_15;
	Histo1DPtr _h_rdA04_15_19_15_24, _h_rdA06_15_19_15_24;
	Histo1DPtr _h_rdA04_15_19_24_40, _h_rdA06_15_19_24_40;

	Histo1DPtr _h_N04_00_19_04_06, _h_N06_00_19_04_06;
	Histo1DPtr _h_N04_00_19_06_10, _h_N06_00_19_06_10;
	Histo1DPtr _h_N04_00_19_10_15, _h_N06_00_19_10_15;
	Histo1DPtr _h_N04_00_19_15_24, _h_N06_00_19_15_24;
	Histo1DPtr _h_N04_00_19_24_40, _h_N06_00_19_24_40;
	Histo1DPtr _h_z04_00_19_04_06, _h_z06_00_19_04_06;
	Histo1DPtr _h_z04_00_19_06_10, _h_z06_00_19_06_10;
	Histo1DPtr _h_z04_00_19_10_15, _h_z06_00_19_10_15;
	Histo1DPtr _h_z04_00_19_15_24, _h_z06_00_19_15_24;
	Histo1DPtr _h_z04_00_19_24_40, _h_z06_00_19_24_40;
	Histo1DPtr _h_ptrel04_00_19_04_06, _h_ptrel06_00_19_04_06;
	Histo1DPtr _h_ptrel04_00_19_06_10, _h_ptrel06_00_19_06_10;
	Histo1DPtr _h_ptrel04_00_19_10_15, _h_ptrel06_00_19_10_15;
	Histo1DPtr _h_ptrel04_00_19_15_24, _h_ptrel06_00_19_15_24;
	Histo1DPtr _h_ptrel04_00_19_24_40, _h_ptrel06_00_19_24_40;
	Histo1DPtr _h_rdA04_00_19_04_06, _h_rdA06_00_19_04_06;
	Histo1DPtr _h_rdA04_00_19_06_10, _h_rdA06_00_19_06_10;
	Histo1DPtr _h_rdA04_00_19_10_15, _h_rdA06_00_19_10_15;
	Histo1DPtr _h_rdA04_00_19_15_24, _h_rdA06_00_19_15_24;
	Histo1DPtr _h_rdA04_00_19_24_40, _h_rdA06_00_19_24_40;

	//@}

	};


	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_I919017);

	}
	diff --git a/src/Analyses/ATLAS_2011_I921594.cc b/src/Analyses/ATLAS_2011_I921594.cc
	--- a/src/Analyses/ATLAS_2011_I921594.cc
	+++ b/src/Analyses/ATLAS_2011_I921594.cc
	@@ -1,133 +1,124 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// Inclusive isolated prompt photon analysis with full 2010 LHC data
	class ATLAS_2011_I921594 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_I921594()
	- : Analysis("ATLAS_2011_I921594"),
	- _eta_bins{0.00, 0.60, 1.37, 1.52, 1.81, 2.37},
	- _eta_bins_areaoffset{0.0, 1.5, 3.0}
	+ : Analysis("ATLAS_2011_I921594")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Consider the final state jets for the energy density calculation
	FastJets fj(fs, FastJets::KT, 0.5);
	fj.useJetArea(new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec()));
	- addProjection(fj, "KtJetsD05");
	+ declare(fj, "KtJetsD05");

	// Consider the leading pt photon with \|eta\|<2.37 and pT>45 GeV
	LeadingParticlesFinalState photonfs(FinalState(-2.37, 2.37, 45*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// Book the dsigma/dEt (in eta bins) histograms
	for (size_t i = 0; i < _eta_bins.size()-1; i++) {
	if (fuzzyEquals(_eta_bins[i], 1.37)) continue; // skip this bin
	_h_Et_photon[i] = bookHisto1D(1, 1, i+1);
	}
	}


	/// Return eta bin for either dsigma/dET histogram (area_eta=false) or energy density correction (area_eta=true)
	- size_t _getEtaBin(double eta_w, bool area_eta) const {
	- const double eta = fabs(eta_w);
	- if (!area_eta) {
	- return binIndex(eta, _eta_bins);
	- } else {
	- return binIndex(eta, _eta_bins_areaoffset);
	- }
	+ size_t _getEtaBin(double eta, bool area_eta) const {
	+ const double aeta = fabs(eta);
	+ return (!area_eta) ? binIndex(aeta, _eta_bins) : binIndex(aeta, _eta_bins_areaoffset);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	// Retrieve leading photon
	- const Particles& photons = applyProjection<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	+ const Particles& photons = apply<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	if (photons.size() != 1) vetoEvent;
	const Particle& leadingPhoton = photons[0];

	// Veto events with photon in ECAL crack
	if (inRange(leadingPhoton.abseta(), 1.37, 1.52)) vetoEvent;

	// Compute isolation energy in cone of radius .4 around photon (all particles)
	FourMomentum mom_in_EtCone;
	- Particles fs = applyProjection<FinalState>(event, "FS").particles();
	+ Particles fs = apply<FinalState>(event, "FS").particles();
	for (const Particle& p : fs) {
	// Check if it's outside the cone of 0.4
	if (deltaR(leadingPhoton, p) >= 0.4) continue;
	// Don't count particles in the 5x7 central core
	if (deltaEta(leadingPhoton, p) < .0255.00.5 &&
	deltaPhi(leadingPhoton, p) < (PI/128.)7.00.5) continue;
	// Increment isolation energy
	mom_in_EtCone += p.momentum();
	}

	// Get the area-filtered jet inputs for computing median energy density, etc.
	- vector<double> ptDensity, ptSigma, nJets;
	vector< vector<double> > ptDensities(_eta_bins_areaoffset.size()-1);
	- FastJets fast_jets = applyProjection<FastJets>(event, "KtJetsD05");
	+ FastJets fast_jets = apply<FastJets>(event, "KtJetsD05");
	const shared_ptr<fastjet::ClusterSequenceArea> clust_seq_area = fast_jets.clusterSeqArea();
	for (const Jet& jet : fast_jets.jets()) {
	const double area = clust_seq_area->area(jet); //< Implicit call to .pseudojet()
	- /// @todo Should be 1e-4?
	- if (area > 10e-4 && jet.abseta() < _eta_bins_areaoffset.back())
	+ if (area > 1e-4 && jet.abseta() < _eta_bins_areaoffset.back())
	ptDensities.at( _getEtaBin(jet.abseta(), true) ).push_back(jet.pT()/area);
	}
	+
	// Compute the median energy density, etc.
	+ vector<double> ptDensity;
	for (size_t b = 0; b < _eta_bins_areaoffset.size()-1; b++) {
	- const int njets = ptDensities[b].size();
	- const double ptmedian = (njets > 0) ? median(ptDensities[b]) : 0;
	- const double ptsigma = (njets > 0) ? ptDensities[b][(size_t)(0.15865*njets)] : 0;
	- nJets.push_back(njets);
	- ptDensity.push_back(ptmedian);
	- ptSigma.push_back(ptsigma);
	+ ptDensity += ptDensities[b].empty() ? 0 : median(ptDensities[b]);
	}
	+
	// Compute the isolation energy correction (cone area*energy density)
	- const double etCone_area = PIsqr(0.4) - (7.0.025)(5.0PI/128.);
	- const double correction = ptDensity[_getEtaBin(leadingPhoton.abseta(), true)]*etCone_area;
	+ const double ETCONE_AREA = M_PIsqr(0.4) - (7.0.025)(5.0PI/128.);
	+ const double correction = ptDensity[_getEtaBin(leadingPhoton.abseta(), true)] * ETCONE_AREA;

	// Apply isolation cut on area-corrected value
	if (mom_in_EtCone.Et() - correction > 4*GeV) vetoEvent;

	// Fill histograms
	const size_t eta_bin = _getEtaBin(leadingPhoton.abseta(), false);
	_h_Et_photon[eta_bin]->fill(leadingPhoton.Et(), event.weight());
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t i = 0; i < _eta_bins.size()-1; i++) {
	if (fuzzyEquals(_eta_bins[i], 1.37)) continue;
	scale(_h_Et_photon[i], crossSection()/picobarn/sumOfWeights());
	}
	}


	private:

	Histo1DPtr _h_Et_photon[5];

	- vector<double> _eta_bins, _eta_bins_areaoffset;
	+ const vector<double> _eta_bins = {0.00, 0.60, 1.37, 1.52, 1.81, 2.37};
	+ const vector<double> _eta_bins_areaoffset = {0.0, 1.5, 3.0};

	};


	DECLARE_RIVET_PLUGIN(ATLAS_2011_I921594);

	}
	diff --git a/src/Analyses/ATLAS_2011_I925932.cc b/src/Analyses/ATLAS_2011_I925932.cc
	--- a/src/Analyses/ATLAS_2011_I925932.cc
	+++ b/src/Analyses/ATLAS_2011_I925932.cc
	@@ -1,115 +1,115 @@
	// -- C++ --
	// ATLAS W pT analysis

	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/WFinder.hh"

	namespace Rivet {


	class ATLAS_2011_I925932 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_I925932() : Analysis("ATLAS_2011_I925932") { }


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	FinalState fs;
	Cut cuts = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;
	WFinder wfinder_dressed_el(fs, cuts, PID::ELECTRON, 0GeV, 1000GeV, 25*GeV, 0.2, WFinder::CLUSTERNODECAY);
	- addProjection(wfinder_dressed_el, "WFinder_dressed_el");
	+ declare(wfinder_dressed_el, "WFinder_dressed_el");
	WFinder wfinder_bare_el(fs, cuts, PID::ELECTRON, 0GeV, 1000GeV, 25*GeV, 0.0, WFinder::NOCLUSTER);
	- addProjection(wfinder_bare_el, "WFinder_bare_el");
	+ declare(wfinder_bare_el, "WFinder_bare_el");
	WFinder wfinder_dressed_mu(fs, cuts, PID::MUON, 0GeV, 1000GeV, 25*GeV, 0.2, WFinder::CLUSTERNODECAY);
	- addProjection(wfinder_dressed_mu, "WFinder_dressed_mu");
	+ declare(wfinder_dressed_mu, "WFinder_dressed_mu");
	WFinder wfinder_bare_mu(fs, cuts, PID::MUON, 0GeV, 1000GeV, 25*GeV, 0.0, WFinder::NOCLUSTER);
	- addProjection(wfinder_bare_mu, "WFinder_bare_mu");
	+ declare(wfinder_bare_mu, "WFinder_bare_mu");

	// Book histograms
	_hist_wpt_dressed_el = bookHisto1D(1, 1, 1);
	_hist_wpt_bare_el = bookHisto1D(1, 1, 2);
	_hist_wpt_dressed_mu = bookHisto1D(2, 1, 1);
	_hist_wpt_bare_mu = bookHisto1D(2, 1, 2);
	}


	/// Do the analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const WFinder& wfinder_dressed_el = applyProjection<WFinder>(event, "WFinder_dressed_el");
	- const WFinder& wfinder_bare_el = applyProjection<WFinder>(event, "WFinder_bare_el");
	- const WFinder& wfinder_dressed_mu = applyProjection<WFinder>(event, "WFinder_dressed_mu");
	- const WFinder& wfinder_bare_mu = applyProjection<WFinder>(event, "WFinder_bare_mu");
	+ const WFinder& wfinder_dressed_el = apply<WFinder>(event, "WFinder_dressed_el");
	+ const WFinder& wfinder_bare_el = apply<WFinder>(event, "WFinder_bare_el");
	+ const WFinder& wfinder_dressed_mu = apply<WFinder>(event, "WFinder_dressed_mu");
	+ const WFinder& wfinder_bare_mu = apply<WFinder>(event, "WFinder_bare_mu");

	if (wfinder_dressed_el.empty() && wfinder_bare_el.empty() &&
	wfinder_dressed_mu.empty() && wfinder_bare_mu.empty()) {
	MSG_DEBUG("No W bosons found");
	vetoEvent;
	}

	// "Dressed" electron
	if (!wfinder_dressed_el.particles().empty()) {
	const FourMomentum& nu = wfinder_dressed_el.constituentNeutrinos()[0].momentum();
	if (wfinder_dressed_el.mT() > 40GeV && nu.pT() > 25GeV) {
	_hist_wpt_dressed_el->fill(wfinder_dressed_el.bosons()[0].pT()/GeV, weight);
	}
	}

	// "Bare" electron
	if (!wfinder_bare_el.particles().empty()) {
	const FourMomentum& nu = wfinder_bare_el.constituentNeutrinos()[0].momentum();
	if (wfinder_bare_el.mT() > 40GeV && nu.pT() > 25GeV) {
	_hist_wpt_bare_el->fill(wfinder_bare_el.bosons()[0].pT()/GeV, weight);
	}
	}

	// "Dressed" muon
	if (!wfinder_dressed_mu.particles().empty()) {
	const FourMomentum& nu = wfinder_dressed_mu.constituentNeutrinos()[0].momentum();
	if (wfinder_dressed_mu.mT() > 40GeV && nu.pT() > 25GeV) {
	_hist_wpt_dressed_mu->fill(wfinder_dressed_mu.bosons()[0].pT()/GeV, weight);
	}
	}

	// "Bare" muon
	if (!wfinder_bare_mu.particles().empty()) {
	const FourMomentum& nu = wfinder_bare_mu.constituentNeutrinos()[0].momentum();
	if (wfinder_bare_mu.mT() > 40GeV && nu.pT() > 25GeV) {
	_hist_wpt_bare_mu->fill(wfinder_bare_mu.bosons()[0].pT()/GeV, weight);
	}
	}

	}


	// Normalize histos
	void finalize() {
	normalize(_hist_wpt_dressed_el);
	normalize(_hist_wpt_bare_el);
	normalize(_hist_wpt_dressed_mu);
	normalize(_hist_wpt_bare_mu);
	}

	//@}


	private:

	Histo1DPtr _hist_wpt_dressed_el;
	Histo1DPtr _hist_wpt_bare_el;
	Histo1DPtr _hist_wpt_dressed_mu;
	Histo1DPtr _hist_wpt_bare_mu;

	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_I925932);

	}
	diff --git a/src/Analyses/ATLAS_2011_I926145.cc b/src/Analyses/ATLAS_2011_I926145.cc
	--- a/src/Analyses/ATLAS_2011_I926145.cc
	+++ b/src/Analyses/ATLAS_2011_I926145.cc
	@@ -1,172 +1,172 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	/// @brief Measurement of electron and muon differential cross section from heavy flavour production
	///
	/// Lepton cross sections differential in pT
	///
	/// @author Paul Bell, Holger Schulz
	class ATLAS_2011_I926145 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_I926145()
	: Analysis("ATLAS_2011_I926145")
	{ }


	public:

	/// Book histograms and initialise projections before the run
	void init() {

	///projection for electrons
	Cut cuts = (Cuts::abseta < 1.37 \|\| Cuts::absetaIn(1.52, 2.00)) && Cuts::pT > 7*GeV;
	IdentifiedFinalState elecs(cuts);
	elecs.acceptId(PID::ELECTRON);
	elecs.acceptId(PID::POSITRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	//projection for muons -- same phase space as above??? Not sure if the crack region has
	//to be removed for the muons as well
	std::vector<std::pair<double, double> > eta_m;
	//eta_m.push_back(make_pair(-2.00,-1.52));
	//eta_m.push_back(make_pair(-1.37,1.37));
	//eta_m.push_back(make_pair(1.52,2.00));
	//IdentifiedFinalState muons(eta_m, 7.0*GeV);
	IdentifiedFinalState muons(Cuts::abseta < 2 && Cuts::pT > 7*GeV);
	muons.acceptId(PID::MUON);
	muons.acceptId(PID::ANTIMUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	//projection for muons full range
	IdentifiedFinalState muons_full(Cuts::abseta < 2.5 && Cuts::pT > 4*GeV);
	muons_full.acceptId(PID::MUON);
	muons_full.acceptId(PID::ANTIMUON);
	- addProjection(muons_full, "muons_full");
	+ declare(muons_full, "muons_full");
	Cut cut20 = Cuts::abseta < 2.0;
	Cut cut25 = Cuts::abseta < 2.5;
	const FinalState fs20(cut20);
	const FinalState fs25(cut25);

	/// @todo Bare Zs ...
	ZFinder zfinder_e(fs20, cut20, PID::ELECTRON, 66.0GeV, 116.0GeV, 0.1, ZFinder::NOCLUSTER);
	- addProjection(zfinder_e, "ZFinder_e");
	+ declare(zfinder_e, "ZFinder_e");
	ZFinder zfinder_mu(fs20, cut20, PID::MUON, 66.0GeV, 116.0GeV, 0.1, ZFinder::NOCLUSTER);
	- addProjection(zfinder_mu, "ZFinder_mu");
	+ declare(zfinder_mu, "ZFinder_mu");
	ZFinder zfinder_mufull(fs25, cut25, PID::MUON, 66.0GeV, 116.0GeV, 0.1, ZFinder::NOCLUSTER);
	- addProjection(zfinder_mufull, "ZFinder_mufull");
	+ declare(zfinder_mufull, "ZFinder_mufull");

	/// @todo ... but dressed Ws?
	WFinder wfinder_e(fs20, cut20, PID::ELECTRON, 60.0GeV, 100.0GeV, 25.0*GeV, 0.2);
	- addProjection(wfinder_e, "WFinder_e");
	+ declare(wfinder_e, "WFinder_e");
	WFinder wfinder_mu(fs20, cut20, PID::MUON, 60.0GeV, 100.0GeV, 25.0*GeV, 0.2);
	- addProjection(wfinder_mu, "WFinder_mu");
	+ declare(wfinder_mu, "WFinder_mu");
	WFinder wfinder_mufull(fs25, cut25, PID::MUON, 60.0GeV, 100.0GeV, 25.0*GeV, 0.2);
	- addProjection(wfinder_mufull, "WFinder_mufull");
	+ declare(wfinder_mufull, "WFinder_mufull");

	// Book histograms
	_histPt_elecs = bookHisto1D(1 ,1 ,1);
	_histPt_muons = bookHisto1D(2 ,1 ,1);
	_histPt_muons_full = bookHisto1D(3 ,1 ,1);
	}

	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const FinalState& elecs = applyProjection<FinalState>(event, "elecs");
	- const FinalState& muons = applyProjection<FinalState>(event, "muons");
	- const FinalState& muons_full = applyProjection<FinalState>(event, "muons_full");
	+ const FinalState& elecs = apply<FinalState>(event, "elecs");
	+ const FinalState& muons = apply<FinalState>(event, "muons");
	+ const FinalState& muons_full = apply<FinalState>(event, "muons_full");

	// Veto event if no lepton is present
	if (elecs.size() == 0 && muons.size() == 0 && muons_full.size() == 0) {
	vetoEvent;
	}

	// Check for W and or Z bosons in event
	//
	// Z veto
	- const ZFinder& zfinder_e = applyProjection<ZFinder>(event, "ZFinder_e");
	- const ZFinder& zfinder_mu = applyProjection<ZFinder>(event, "ZFinder_mu");
	- const ZFinder& zfinder_mufull = applyProjection<ZFinder>(event, "ZFinder_mufull");
	+ const ZFinder& zfinder_e = apply<ZFinder>(event, "ZFinder_e");
	+ const ZFinder& zfinder_mu = apply<ZFinder>(event, "ZFinder_mu");
	+ const ZFinder& zfinder_mufull = apply<ZFinder>(event, "ZFinder_mufull");

	if (zfinder_e.bosons().size() > 0 \|\| zfinder_mu.bosons().size() > 0 \|\| zfinder_mufull.bosons().size() > 0) {
	MSG_DEBUG("Num elec Z-bosons found: " << zfinder_e.bosons().size());
	MSG_DEBUG("Num muon Z-bosons found: " << zfinder_mu.bosons().size());
	MSG_DEBUG("Num muon Z-bosons found (\|eta\|<2.5): " << zfinder_mufull.bosons().size());
	vetoEvent;
	}

	// W veto
	- const WFinder& wfinder_e = applyProjection<WFinder>(event, "WFinder_e");
	- const WFinder& wfinder_mu = applyProjection<WFinder>(event, "WFinder_mu");
	- const WFinder& wfinder_mufull = applyProjection<WFinder>(event, "WFinder_mufull");
	+ const WFinder& wfinder_e = apply<WFinder>(event, "WFinder_e");
	+ const WFinder& wfinder_mu = apply<WFinder>(event, "WFinder_mu");
	+ const WFinder& wfinder_mufull = apply<WFinder>(event, "WFinder_mufull");

	if (wfinder_e.bosons().size() > 0 \|\| wfinder_mu.bosons().size() > 0 \|\| wfinder_mufull.bosons().size() > 0) {
	MSG_DEBUG("Num elec W-bosons found: " << wfinder_e.bosons().size());
	MSG_DEBUG("Num muon W-bosons found: " << wfinder_mu.bosons().size());
	MSG_DEBUG("Num muon W-bosons found (\|eta\|<2.5): " << wfinder_mufull.bosons().size());
	vetoEvent;
	}


	// Electron histogram
	if (elecs.size() > 0) {
	foreach (const Particle& ele, elecs.particles()) {
	if (ele.pT()*GeV < 26.0) {
	_histPt_elecs->fill(ele.pT()*GeV, weight);
	}
	}
	}

	// Muon histogram
	if (muons.size() > 0) {
	foreach (const Particle& muo, muons.particles()) {
	if (muo.pT()*GeV < 26.0) {
	_histPt_muons->fill(muo.pT()*GeV, weight);
	}
	}
	}

	// Muon full histogram
	if (muons_full.size() > 0) {
	foreach (const Particle& muo, muons_full.particles()) {
	if (muo.pT()*GeV < 100.0) {
	_histPt_muons_full->fill(muo.pT()*GeV, weight);
	}
	}
	}
	}

	/// Normalise histograms etc., after the run
	void finalize() {

	// Data cross-section is given in nb! x-sections in rivet are in pb!
	scale(_histPt_elecs, crossSection()/nanobarn/sumOfWeights());
	scale(_histPt_muons, crossSection()/nanobarn/sumOfWeights());
	scale(_histPt_muons_full, crossSection()/nanobarn/sumOfWeights());
	}



	private:

	/// @name Histograms
	Histo1DPtr _histPt_elecs;
	Histo1DPtr _histPt_muons;
	Histo1DPtr _histPt_muons_full;
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_I926145);

	}
	diff --git a/src/Analyses/ATLAS_2011_I928289_W.cc b/src/Analyses/ATLAS_2011_I928289_W.cc
	--- a/src/Analyses/ATLAS_2011_I928289_W.cc
	+++ b/src/Analyses/ATLAS_2011_I928289_W.cc
	@@ -1,172 +1,148 @@
	// -- C++ --
	-#include <cmath>
	-
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/WFinder.hh"

	-
	namespace Rivet {

	- using namespace Cuts;
	-

	class ATLAS_2011_I928289_W : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_I928289_W()
	: Analysis("ATLAS_2011_I928289_W")
	{
	setNeedsCrossSection(true);
	}


	- public:
	-
	/// @name Analysis methods
	//@{
	-
	+
	/// Book histograms and initialise projections before the run
	void init() {

	///Initialise and register projections here
	FinalState fs;
	-
	- Cut cut = pT >= 20*GeV;
	+
	+ Cut cut = (Cuts::pT >= 20*GeV);

	WFinder wfinder_el_bare( fs, cut, PID::ELECTRON, 40.0GeV, 7000.0GeV, 25.0*GeV, 0.0, WFinder::CLUSTERNODECAY, WFinder::NOTRACK, WFinder::TRANSMASS);
	WFinder wfinder_el_dressed(fs, cut, PID::ELECTRON, 40.0GeV, 7000.0GeV, 25.0*GeV, 0.1, WFinder::CLUSTERNODECAY, WFinder::NOTRACK, WFinder::TRANSMASS);
	WFinder wfinder_mu_bare (fs, cut, PID::MUON , 40.0GeV, 7000.0GeV, 25.0*GeV, 0.0, WFinder::CLUSTERNODECAY, WFinder::NOTRACK, WFinder::TRANSMASS);
	WFinder wfinder_mu_dressed(fs, cut, PID::MUON , 40.0GeV, 7000.0GeV, 25.0*GeV, 0.1, WFinder::CLUSTERNODECAY, WFinder::NOTRACK, WFinder::TRANSMASS);

	- addProjection(wfinder_el_bare , "WFinder_el_bare");
	- addProjection(wfinder_el_dressed, "WFinder_el_dressed");
	- addProjection(wfinder_mu_bare , "WFinder_mu_bare");
	- addProjection(wfinder_mu_dressed, "WFinder_mu_dressed");
	+ declare(wfinder_el_bare , "WFinder_el_bare");
	+ declare(wfinder_el_dressed, "WFinder_el_dressed");
	+ declare(wfinder_mu_bare , "WFinder_mu_bare");
	+ declare(wfinder_mu_dressed, "WFinder_mu_dressed");

	/// Book histograms here
	_h_Wminus_lepton_eta_el_bare = bookHisto1D(3, 1, 1);
	_h_Wminus_lepton_eta_el_dressed = bookHisto1D(3, 1, 2);
	_h_Wminus_lepton_eta_mu_bare = bookHisto1D(3, 1, 3);
	_h_Wminus_lepton_eta_mu_dressed = bookHisto1D(3, 1, 4);
	_h_Wplus_lepton_eta_el_bare = bookHisto1D(5, 1, 1);
	_h_Wplus_lepton_eta_el_dressed = bookHisto1D(5, 1, 2);
	_h_Wplus_lepton_eta_mu_bare = bookHisto1D(5, 1, 3);
	_h_Wplus_lepton_eta_mu_dressed = bookHisto1D(5, 1, 4);
	_h_W_asym_eta_el_bare = bookScatter2D(7, 1, 1);
	_h_W_asym_eta_el_dressed = bookScatter2D(7, 1, 2);
	_h_W_asym_eta_mu_bare = bookScatter2D(7, 1, 3);
	_h_W_asym_eta_mu_dressed = bookScatter2D(7, 1, 4);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	+ const WFinder& wfinder_el_bare = apply<WFinder>(event, "WFinder_el_bare");
	+ const WFinder& wfinder_el_dressed = apply<WFinder>(event, "WFinder_el_dressed");
	+ const WFinder& wfinder_mu_bare = apply<WFinder>(event, "WFinder_mu_bare");
	+ const WFinder& wfinder_mu_dressed = apply<WFinder>(event, "WFinder_mu_dressed");
	+
	const double weight = event.weight();
	-
	- ///Do the event by event analysis here
	- const WFinder& wfinder_el_bare = applyProjection<WFinder>(event, "WFinder_el_bare");
	- const WFinder& wfinder_el_dressed = applyProjection<WFinder>(event, "WFinder_el_dressed");
	- const WFinder& wfinder_mu_bare = applyProjection<WFinder>(event, "WFinder_mu_bare");
	- const WFinder& wfinder_mu_dressed = applyProjection<WFinder>(event, "WFinder_mu_dressed");
	-
	- FillPlots1d(wfinder_el_bare , _h_Wplus_lepton_eta_el_bare , _h_Wminus_lepton_eta_el_bare , weight);
	- FillPlots1d(wfinder_el_dressed, _h_Wplus_lepton_eta_el_dressed, _h_Wminus_lepton_eta_el_dressed, weight);
	- FillPlots1d(wfinder_mu_bare , _h_Wplus_lepton_eta_mu_bare , _h_Wminus_lepton_eta_mu_bare , weight);
	- FillPlots1d(wfinder_mu_dressed, _h_Wplus_lepton_eta_mu_dressed, _h_Wminus_lepton_eta_mu_dressed, weight);
	-
	-
	+ fillPlots1D(wfinder_el_bare , _h_Wplus_lepton_eta_el_bare , _h_Wminus_lepton_eta_el_bare , weight);
	+ fillPlots1D(wfinder_el_dressed, _h_Wplus_lepton_eta_el_dressed, _h_Wminus_lepton_eta_el_dressed, weight);
	+ fillPlots1D(wfinder_mu_bare , _h_Wplus_lepton_eta_mu_bare , _h_Wminus_lepton_eta_mu_bare , weight);
	+ fillPlots1D(wfinder_mu_dressed, _h_Wplus_lepton_eta_mu_dressed, _h_Wminus_lepton_eta_mu_dressed, weight);
	}

	- void FillPlots1d(const WFinder& wfinder, Histo1DPtr hist_plus, Histo1DPtr hist_minus, double weight) {

	+ void fillPlots1D(const WFinder& wfinder, Histo1DPtr hist_plus, Histo1DPtr hist_minus, double weight) {
	if (wfinder.bosons().size() != 1) return;
	-
	- Particle l = wfinder.constituentLeptons()[0];
	+ const Particle l = wfinder.constituentLeptons()[0];
	const FourMomentum& miss = wfinder.constituentNeutrinos()[0].momentum();
	-
	- if(l.momentum().pT() > 20GeV && miss.Et() > 25GeV && wfinder.mT() > 40*GeV) {
	- int lepCharge = l.charge();
	- if (lepCharge > 0) hist_plus ->fill( fabs(l.eta()), weight);
	- else if (lepCharge < 0) hist_minus->fill( fabs(l.eta()), weight);
	- }
	-
	- return;
	- }
	+ if (l.pT() > 20GeV && miss.Et() > 25GeV && wfinder.mT() > 40*GeV)
	+ (l.charge3() > 0 ? hist_plus : hist_minus)->fill(l.abseta(), weight);
	+ }


	/// Normalise histograms etc., after the run
	void finalize() {

	- // Construct asymmetry: (dsig+/deta - dsig-/deta) / (dsig+/deta + dsig-/deta)
	+ // Construct asymmetry: (dsig+/deta - dsig-/deta) / (dsig+/deta + dsig-/deta)
	divide(_h_Wplus_lepton_eta_el_bare - _h_Wminus_lepton_eta_el_bare,
	_h_Wplus_lepton_eta_el_bare + _h_Wminus_lepton_eta_el_bare,
	_h_W_asym_eta_el_bare);
	divide(_h_Wplus_lepton_eta_el_dressed - _h_Wminus_lepton_eta_el_dressed,
	_h_Wplus_lepton_eta_el_dressed + _h_Wminus_lepton_eta_el_dressed,
	_h_W_asym_eta_el_dressed);
	divide(_h_Wplus_lepton_eta_mu_bare - _h_Wminus_lepton_eta_mu_bare,
	_h_Wplus_lepton_eta_mu_bare + _h_Wminus_lepton_eta_mu_bare,
	_h_W_asym_eta_mu_bare);
	divide(_h_Wplus_lepton_eta_mu_dressed - _h_Wminus_lepton_eta_mu_dressed,
	_h_Wplus_lepton_eta_mu_dressed + _h_Wminus_lepton_eta_mu_dressed,
	_h_W_asym_eta_mu_dressed);

	// Print summary info
	const double xs_pb(crossSection() / picobarn);
	const double sumw(sumOfWeights());
	- MSG_INFO( "Cross-Section/pb : " << xs_pb );
	- MSG_INFO( "Sum of weights : " << sumw );
	- MSG_INFO( "nEvents : " << numEvents() );
	-
	- const double sf(0.5 * xs_pb / sumw); // 0.5 accounts for rapidity bin width
	+ MSG_DEBUG( "Cross-section/pb : " << xs_pb );
	+ MSG_DEBUG( "Sum of weights : " << sumw );
	+ MSG_DEBUG( "nEvents : " << numEvents() );

	/// Normalise, scale and otherwise manipulate histograms here
	- scale(_h_Wminus_lepton_eta_el_bare , sf);
	- scale(_h_Wminus_lepton_eta_el_dressed, sf);
	- scale(_h_Wminus_lepton_eta_mu_bare , sf);
	- scale(_h_Wminus_lepton_eta_mu_dressed, sf);
	- scale(_h_Wplus_lepton_eta_el_bare , sf);
	- scale(_h_Wplus_lepton_eta_el_dressed , sf);
	- scale(_h_Wplus_lepton_eta_mu_bare , sf);
	+ const double sf = 0.5 * xs_pb / sumw; // 0.5 accounts for rapidity bin width
	+ scale(_h_Wminus_lepton_eta_el_bare , sf);
	+ scale(_h_Wminus_lepton_eta_el_dressed, sf);
	+ scale(_h_Wminus_lepton_eta_mu_bare , sf);
	+ scale(_h_Wminus_lepton_eta_mu_dressed, sf);
	+ scale(_h_Wplus_lepton_eta_el_bare , sf);
	+ scale(_h_Wplus_lepton_eta_el_dressed , sf);
	+ scale(_h_Wplus_lepton_eta_mu_bare , sf);
	scale(_h_Wplus_lepton_eta_mu_dressed , sf);

	}

	//@}


	private:

	- // Data members like post-cuts event weight counters go here
	-
	-
	- private:
	-
	/// @name Histograms
	//@{
	Histo1DPtr _h_Wminus_lepton_eta_el_bare;
	Histo1DPtr _h_Wminus_lepton_eta_el_dressed;
	Histo1DPtr _h_Wminus_lepton_eta_mu_bare;
	Histo1DPtr _h_Wminus_lepton_eta_mu_dressed;
	Histo1DPtr _h_Wplus_lepton_eta_el_bare;
	Histo1DPtr _h_Wplus_lepton_eta_el_dressed;
	Histo1DPtr _h_Wplus_lepton_eta_mu_bare;
	Histo1DPtr _h_Wplus_lepton_eta_mu_dressed;
	Scatter2DPtr _h_W_asym_eta_el_bare;
	Scatter2DPtr _h_W_asym_eta_el_dressed;
	Scatter2DPtr _h_W_asym_eta_mu_bare;
	Scatter2DPtr _h_W_asym_eta_mu_dressed;

	//@}

	};
	-
	+

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_I928289_W);

	}
	diff --git a/src/Analyses/ATLAS_2011_I928289_Z.cc b/src/Analyses/ATLAS_2011_I928289_Z.cc
	--- a/src/Analyses/ATLAS_2011_I928289_Z.cc
	+++ b/src/Analyses/ATLAS_2011_I928289_Z.cc
	@@ -1,128 +1,111 @@
	// -- C++ --
	-#include <cmath>
	-
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"

	-
	namespace Rivet {

	- using namespace Cuts;

	class ATLAS_2011_I928289_Z : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_I928289_Z()
	: Analysis("ATLAS_2011_I928289_Z")
	{
	setNeedsCrossSection(true);
	}


	- public:
	-
	/// @name Analysis methods
	//@{
	-
	+
	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	-
	- Cut cut = pT >= 20.0*GeV;
	+
	+ Cut cut = (Cuts::pT >= 20.0*GeV);

	ZFinder zfinder_ee_bare( fs, cut, PID::ELECTRON, 66.0GeV, 116.0GeV, 0.0, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);
	ZFinder zfinder_ee_dressed(fs, cut, PID::ELECTRON, 66.0GeV, 116.0GeV, 0.1, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);
	ZFinder zfinder_mm_bare( fs, cut, PID::MUON , 66.0GeV, 116.0GeV, 0.0, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);
	ZFinder zfinder_mm_dressed(fs, cut, PID::MUON , 66.0GeV, 116.0GeV, 0.1, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);

	- addProjection(zfinder_ee_bare , "ZFinder_ee_bare" );
	- addProjection(zfinder_ee_dressed, "ZFinder_ee_dressed");
	- addProjection(zfinder_mm_bare , "ZFinder_mm_bare" );
	- addProjection(zfinder_mm_dressed, "ZFinder_mm_dressed");
	+ declare(zfinder_ee_bare , "ZFinder_ee_bare" );
	+ declare(zfinder_ee_dressed, "ZFinder_ee_dressed");
	+ declare(zfinder_mm_bare , "ZFinder_mm_bare" );
	+ declare(zfinder_mm_dressed, "ZFinder_mm_dressed");

	- //y(Z) cross-section dependence
	+ // y(Z) cross-section dependence
	_h_Z_y_ee_bare = bookHisto1D(1, 1, 1);
	_h_Z_y_ee_dressed = bookHisto1D(1, 1, 2);
	_h_Z_y_mm_bare = bookHisto1D(1, 1, 3);
	_h_Z_y_mm_dressed = bookHisto1D(1, 1, 4);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	+ const ZFinder& zfinder_ee_bare = apply<ZFinder>(event, "ZFinder_ee_bare" );
	+ const ZFinder& zfinder_ee_dressed = apply<ZFinder>(event, "ZFinder_ee_dressed");
	+ const ZFinder& zfinder_mm_bare = apply<ZFinder>(event, "ZFinder_mm_bare" );
	+ const ZFinder& zfinder_mm_dressed = apply<ZFinder>(event, "ZFinder_mm_dressed");
	+
	const double weight = event.weight();
	-
	- ///Do the event by event analysis here
	- const ZFinder& zfinder_ee_bare = applyProjection<ZFinder>(event, "ZFinder_ee_bare" );
	- const ZFinder& zfinder_ee_dressed = applyProjection<ZFinder>(event, "ZFinder_ee_dressed");
	- const ZFinder& zfinder_mm_bare = applyProjection<ZFinder>(event, "ZFinder_mm_bare" );
	- const ZFinder& zfinder_mm_dressed = applyProjection<ZFinder>(event, "ZFinder_mm_dressed");
	-
	- FillPlots1d(zfinder_ee_bare , _h_Z_y_ee_bare , weight);
	- FillPlots1d(zfinder_ee_dressed, _h_Z_y_ee_dressed, weight);
	- FillPlots1d(zfinder_mm_bare , _h_Z_y_mm_bare , weight);
	- FillPlots1d(zfinder_mm_dressed, _h_Z_y_mm_dressed, weight);
	+ fillPlots1D(zfinder_ee_bare , _h_Z_y_ee_bare , weight);
	+ fillPlots1D(zfinder_ee_dressed, _h_Z_y_ee_dressed, weight);
	+ fillPlots1D(zfinder_mm_bare , _h_Z_y_mm_bare , weight);
	+ fillPlots1D(zfinder_mm_dressed, _h_Z_y_mm_dressed, weight);

	}

	-
	- void FillPlots1d(const ZFinder& zfinder, Histo1DPtr hist, double weight) {

	+ void fillPlots1D(const ZFinder& zfinder, Histo1DPtr hist, double weight) {
	if (zfinder.bosons().size() != 1) return;
	-
	const FourMomentum zmom = zfinder.bosons()[0].momentum();
	-
	- hist->fill( fabs(zmom.rapidity()), weight);
	+ hist->fill(zmom.absrap(), weight);
	+ }

	- return;
	- }

	/// Normalise histograms etc., after the run
	void finalize() {

	- /// Print summary info
	+ // Print summary info
	const double xs_pb(crossSection() / picobarn);
	const double sumw(sumOfWeights());
	- MSG_INFO("Cross-Section/pb: " << xs_pb );
	- MSG_INFO("Sum of weights : " << sumw );
	- MSG_INFO("nEvents : " << numEvents());
	+ MSG_DEBUG("Cross-Section/pb: " << xs_pb );
	+ MSG_DEBUG("Sum of weights : " << sumw );
	+ MSG_DEBUG("nEvents : " << numEvents());

	+ // Normalise, scale and otherwise manipulate histograms here
	const double sf(0.5 * xs_pb / sumw); // 0.5 accounts for rapidity bin width
	-
	- ///Normalise, scale and otherwise manipulate histograms here
	- scale(_h_Z_y_ee_bare , sf);
	- scale(_h_Z_y_ee_dressed, sf);
	- scale(_h_Z_y_mm_bare , sf);
	- scale(_h_Z_y_mm_dressed, sf);
	+ scale(_h_Z_y_ee_bare , sf);
	+ scale(_h_Z_y_ee_dressed, sf);
	+ scale(_h_Z_y_mm_bare , sf);
	+ scale(_h_Z_y_mm_dressed, sf);

	}

	//@}


	private:

	- // Data members like post-cuts event weight counters go here
	-
	-
	- private:
	-
	/// @name Histograms
	//@{
	Histo1DPtr _h_Z_y_ee_bare;
	Histo1DPtr _h_Z_y_ee_dressed;
	Histo1DPtr _h_Z_y_mm_bare;
	Histo1DPtr _h_Z_y_mm_dressed;
	//@}
	+
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_I928289_Z);

	}
	diff --git a/src/Analyses/ATLAS_2011_I929691.cc b/src/Analyses/ATLAS_2011_I929691.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2011_I929691.cc
	@@ -0,0 +1,103 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// Jet fragmentation at 7 TeV
	+ class ATLAS_2011_I929691 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2011_I929691);
	+
	+
	+ /// Initialisation
	+ void init() {
	+ const FinalState fs(Cuts::abseta < 2.0);
	+
	+ FastJets antikt_06_jets(fs, FastJets::ANTIKT, 0.6, JetAlg::NO_MUONS, JetAlg::NO_INVISIBLES);
	+ declare(antikt_06_jets, "jets");
	+
	+ ChargedFinalState tracks(Cuts::pT > 0.5*GeV && Cuts::abseta < 2.0);
	+ declare(tracks, "tracks");
	+
	+ // Set up the histograms (each element is a binning in jet pT)
	+ for (size_t i = 0; i < 10; i++) {
	+ _p_F_z[i] = bookProfile1D(i+1, 1, 1);
	+ _p_rho_r[i] = bookProfile1D(i+11, 1, 1);
	+ _p_f_pTrel[i] = bookProfile1D(i+21, 1, 1);
	+ }
	+
	+ }
	+
	+
	+ // Per-event analysis
	+ void analyze(const Event& event) {
	+
	+ const Jets alljets = apply<FastJets>(event, "jets").jetsByPt(Cuts::absrap < 1.2);
	+ const Particles& tracks = apply<ChargedFinalState>(event, "tracks").particlesByPt();
	+
	+ for (size_t i = 0; i < 10; ++i) {
	+
	+ const Jets jets = filter_select(alljets, Cuts::pT > bedges[i] && Cuts::pT < bedges[i+1]);
	+ const int n_jets = jets.size();
	+ if (n_jets == 0) continue;
	+
	+ // First... count the tracks
	+ Histo1D h_ntracks_z(_p_F_z[i]), h_ntracks_r(_p_rho_r[i]), h_ntracks_pTrel(*_p_f_pTrel[i]);
	+
	+ for (const Jet& j : jets) {
	+ for (const Particle& p : tracks) {
	+ const double dr = deltaR(j, p, RAPIDITY);
	+ if (dr > 0.6) continue; // The paper uses pseudorapidity, but this is a requirement for filling the histogram
	+ h_ntracks_z.fill(z(j, p), 1.0/n_jets);
	+ h_ntracks_r.fill(dr, 1.0/n_jets);
	+ h_ntracks_pTrel.fill(pTrel(j, p), 1.0/n_jets);
	+ }
	+ }
	+
	+ // Then... calculate the observable and fill the profiles
	+ const double weight = event.weight();
	+ for (const HistoBin1D& b : h_ntracks_z.bins())
	+ _p_F_z[i]->fill(b.xMid(), b.height(), weight);
	+ for (const HistoBin1D& b : h_ntracks_r.bins())
	+ _p_rho_r[i]->fill(b.xMid(), b.area()/annulus_area(b.xMin(), b.xMax()), weight);
	+ for (const HistoBin1D& b : h_ntracks_pTrel.bins())
	+ _p_f_pTrel[i]->fill(b.xMid(), b.height(), weight);
	+
	+ }
	+
	+ }
	+
	+
	+ double z (const Jet& jet, const Particle& ch) {
	+ return dot(jet.p3(), ch.p3()) / jet.p3().mod2();
	+ }
	+
	+ double pTrel (const Jet& jet, const Particle& ch) {
	+ return (ch.p3().cross(jet.p3())).mod()/(jet.p3().mod());
	+ }
	+
	+ // To calculate the area of the annulus in an r bin
	+ double annulus_area(double r1, double r2) {
	+ return M_PI*(sqr(r2) - sqr(r1));
	+ }
	+
	+
	+ private:
	+
	+ Profile1DPtr _p_F_z[10], _p_rho_r[10], _p_f_pTrel[10];
	+ const vector<double> bedges = { 25., 40., 60., 80., 110., 160., 210., 260., 310., 400., 500. };
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2011_I929691);
	+
	+
	+}
	diff --git a/src/Analyses/ATLAS_2011_I930220.cc b/src/Analyses/ATLAS_2011_I930220.cc
	--- a/src/Analyses/ATLAS_2011_I930220.cc
	+++ b/src/Analyses/ATLAS_2011_I930220.cc
	@@ -1,141 +1,141 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/HeavyHadrons.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	/// @brief ATLAS inclusive b-jet pT spectrum, di-jet mass and di-jet chi
	class ATLAS_2011_I930220: public Analysis {
	public:

	ATLAS_2011_I930220()
	: Analysis("ATLAS_2011_I930220")
	{ }


	void init() {
	FinalState fs(-3.5, 3.5);
	- addProjection(fs, "FinalState");
	+ declare(fs, "FinalState");
	FastJets fj(fs, FastJets::ANTIKT, 0.4);
	fj.useInvisibles();
	- addProjection(fj, "Jets");
	- addProjection(HeavyHadrons(Cuts::abseta < 3.5 && Cuts::pT > 5*GeV), "BHadrons");
	+ declare(fj, "Jets");
	+ declare(HeavyHadrons(Cuts::abseta < 3.5 && Cuts::pT > 5*GeV), "BHadrons");

	double ybins[] = { 0.0, 0.3, 0.8, 1.2, 2.1 };
	for (size_t i = 0; i < 4; ++i)
	_bjetpT_SV0.addHistogram(ybins[i], ybins[i+1], bookHisto1D(i+1, 1, 1));

	_bjetpT_SV0_All = bookHisto1D(5, 1, 1);
	_bjetpT_pTRel = bookHisto1D(6, 1, 1);
	_dijet_mass = bookHisto1D(7, 1, 1);
	_dijet_phi = bookHisto1D(8, 1, 1);
	_dijet_chi_110_370 = bookHisto1D(9, 1, 1);
	_dijet_chi_370_850 = bookHisto1D(10, 1, 1);

	_chiCounter1 = 0.0;
	_chiCounter2 = 0.0;
	_phiCounter = 0.0;
	}


	void analyze(const Event& evt) {
	const double weight = evt.weight();

	- const Particles& bHadrons = applyProjection<HeavyHadrons>(evt, "BHadrons").bHadrons();
	- const Jets& jets = applyProjection<JetAlg>(evt, "Jets").jetsByPt(15*GeV);
	+ const Particles& bHadrons = apply<HeavyHadrons>(evt, "BHadrons").bHadrons();
	+ const Jets& jets = apply<JetAlg>(evt, "Jets").jetsByPt(15*GeV);

	FourMomentum leadingJet, subleadingJet;
	int leadJet = 0, subJet = 0;
	foreach (const Jet& j, jets) {
	bool hasB = false;
	foreach (const Particle& b, bHadrons)
	if (deltaR(j, b) < 0.3) { hasB = true; break; }

	// Identify and classify the leading and subleading jets
	if (j.absrap() < 2.1) { ///< Move this into the jets defn
	if (!leadJet) {
	leadingJet = j.momentum();
	leadJet = (hasB && j.pT() > 40*GeV) ? 2 : 1;
	}
	else if (leadJet && !subJet) {
	subleadingJet = j.momentum();
	subJet = (hasB && j.pT() > 40*GeV) ? 2 : 1;
	}
	if (hasB) {
	_bjetpT_SV0.fill(j.absrap(), j.pT()/GeV, weight);
	_bjetpT_SV0_All->fill(j.pT()/GeV, weight);
	_bjetpT_pTRel->fill(j.pT()/GeV, weight);
	}
	}
	}

	// Di-b-jet plots require both the leading and subleading jets to be b-tagged and have pT > 40 GeV
	if (leadJet == 2 && subJet == 2) {
	const double mass = FourMomentum( leadingJet + subleadingJet ).mass();
	_dijet_mass->fill(mass/GeV, weight);

	// Plot dphi for high-mass di-b-jets
	if (mass > 110*GeV) {
	_phiCounter += weight;
	const double d_phi = deltaPhi( leadingJet.phi(), subleadingJet.phi() );
	_dijet_phi->fill(fabs(d_phi), weight);
	}

	// Plot chi for low y_boost di-b-jets (in two high-mass bins)
	const double y_boost = 0.5 * (leadingJet.rapidity() + subleadingJet.rapidity());
	const double chi = exp( fabs( leadingJet.rapidity() - subleadingJet.rapidity() ) );
	if ( fabs(y_boost) < 1.1 ) {
	if (inRange(mass/GeV, 110, 370)) {
	_chiCounter1 += weight;
	_dijet_chi_110_370->fill(chi, weight);
	} else if (inRange(mass/GeV, 370, 850)) {
	_chiCounter2 += weight;
	_dijet_chi_370_850->fill(chi, weight);
	}
	}
	}
	}


	void finalize() {
	// Normalizing to cross-section and mass
	// Additional factors represent the division by rapidity
	const double xsec = crossSectionPerEvent()/(picobarn);
	const double chiScale1 = 1 / _chiCounter1 / 260.0;
	const double chiScale2 = 1 / _chiCounter2 / 480.0;
	const double phiScale = 1 / _phiCounter;

	_bjetpT_SV0.scale(xsec/2, this);
	scale(_bjetpT_SV0_All, xsec);
	scale(_bjetpT_pTRel, xsec);
	scale(_dijet_mass, xsec);
	scale(_dijet_phi, phiScale );
	scale(_dijet_chi_110_370, chiScale1);
	scale(_dijet_chi_370_850, chiScale2);
	}


	private:

	BinnedHistogram<double> _bjetpT_SV0;

	Histo1DPtr _bjetpT_SV0_All;
	Histo1DPtr _bjetpT_pTRel;
	Histo1DPtr _dijet_mass;
	Histo1DPtr _dijet_phi;
	Histo1DPtr _dijet_chi_110_370;
	Histo1DPtr _dijet_chi_370_850;

	double _chiCounter1;
	double _chiCounter2;
	double _phiCounter;
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_I930220);

	}
	diff --git a/src/Analyses/ATLAS_2011_I944826.cc b/src/Analyses/ATLAS_2011_I944826.cc
	--- a/src/Analyses/ATLAS_2011_I944826.cc
	+++ b/src/Analyses/ATLAS_2011_I944826.cc
	@@ -1,260 +1,260 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	class ATLAS_2011_I944826 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_I944826()
	: Analysis("ATLAS_2011_I944826")
	{
	_sum_w_ks = 0.0;
	_sum_w_lambda = 0.0;
	_sum_w_passed = 0.0;
	}


	/// Book histograms and initialise projections before the run
	void init() {

	UnstableFinalState ufs(Cuts::pT > 100*MeV);
	- addProjection(ufs, "UFS");
	+ declare(ufs, "UFS");

	ChargedFinalState mbts(Cuts::absetaIn(2.09, 3.84));
	- addProjection(mbts, "MBTS");
	+ declare(mbts, "MBTS");

	IdentifiedFinalState nstable(Cuts::abseta < 2.5 && Cuts::pT >= 100*MeV);
	nstable.acceptIdPair(PID::ELECTRON)
	.acceptIdPair(PID::MUON)
	.acceptIdPair(PID::PIPLUS)
	.acceptIdPair(PID::KPLUS)
	.acceptIdPair(PID::PROTON);
	- addProjection(nstable, "nstable");
	+ declare(nstable, "nstable");

	if (fuzzyEquals(sqrtS()/GeV, 7000, 1e-3)) {
	_hist_Ks_pT = bookHisto1D(1, 1, 1);
	_hist_Ks_y = bookHisto1D(2, 1, 1);
	_hist_Ks_mult = bookHisto1D(3, 1, 1);
	_hist_L_pT = bookHisto1D(7, 1, 1);
	_hist_L_y = bookHisto1D(8, 1, 1);
	_hist_L_mult = bookHisto1D(9, 1, 1);
	_hist_Ratio_v_y = bookScatter2D(13, 1, 1);
	_hist_Ratio_v_pT = bookScatter2D(14, 1, 1);
	//
	_temp_lambda_v_y = Histo1D(10, 0.0, 2.5);
	_temp_lambdabar_v_y = Histo1D(10, 0.0, 2.5);
	_temp_lambda_v_pT = Histo1D(18, 0.5, 4.1);
	_temp_lambdabar_v_pT = Histo1D(18, 0.5, 4.1);
	}
	else if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) {
	_hist_Ks_pT = bookHisto1D(4, 1, 1);
	_hist_Ks_y = bookHisto1D(5, 1, 1);
	_hist_Ks_mult = bookHisto1D(6, 1, 1);
	_hist_L_pT = bookHisto1D(10, 1, 1);
	_hist_L_y = bookHisto1D(11, 1, 1);
	_hist_L_mult = bookHisto1D(12, 1, 1);
	_hist_Ratio_v_y = bookScatter2D(15, 1, 1);
	_hist_Ratio_v_pT = bookScatter2D(16, 1, 1);
	//
	_temp_lambda_v_y = Histo1D(5, 0.0, 2.5);
	_temp_lambdabar_v_y = Histo1D(5, 0.0, 2.5);
	_temp_lambda_v_pT = Histo1D(8, 0.5, 3.7);
	_temp_lambdabar_v_pT = Histo1D(8, 0.5, 3.7);
	}
	}


	// This function is required to impose the flight time cuts on Kaons and Lambdas
	double getPerpFlightDistance(const Rivet::Particle& p) {
	const HepMC::GenParticle* genp = p.genParticle();
	const HepMC::GenVertex* prodV = genp->production_vertex();
	const HepMC::GenVertex* decV = genp->end_vertex();
	const HepMC::ThreeVector prodPos = prodV->point3d();
	if (decV) {
	const HepMC::ThreeVector decPos = decV->point3d();
	double dy = prodPos.y() - decPos.y();
	double dx = prodPos.x() - decPos.x();
	return add_quad(dx, dy);
	}
	return numeric_limits<double>::max();
	}


	bool daughtersSurviveCuts(const Rivet::Particle& p) {
	// We require the Kshort or Lambda to decay into two charged
	// particles with at least pT = 100 MeV inside acceptance region
	const HepMC::GenParticle* genp = p.genParticle();
	const HepMC::GenVertex* decV = genp->end_vertex();
	bool decision = true;

	if (!decV) return false;
	if (decV->particles_out_size() == 2) {
	std::vector<double> pTs;
	std::vector<int> charges;
	std::vector<double> etas;
	foreach (const HepMC::GenParticle* gp, particles(decV, HepMC::children)) {
	pTs.push_back(gp->momentum().perp());
	etas.push_back(fabs(gp->momentum().eta()));
	charges.push_back( Rivet::PID::threeCharge(gp->pdg_id()) );
	// gp->print();
	}
	if ( (pTs[0]/Rivet::GeV < 0.1) \|\| (pTs[1]/Rivet::GeV < 0.1) ) {
	decision = false;
	MSG_DEBUG("Failed pT cut: " << pTs[0]/Rivet::GeV << " " << pTs[1]/Rivet::GeV);
	}
	if ( etas[0] > 2.5 \|\| etas[1] > 2.5 ) {
	decision = false;
	MSG_DEBUG("Failed eta cut: " << etas[0] << " " << etas[1]);
	}
	if ( charges[0] * charges[1] >= 0 ) {
	decision = false;
	MSG_DEBUG("Failed opposite charge cut: " << charges[0] << " " << charges[1]);
	}
	}
	else {
	decision = false;
	MSG_DEBUG("Failed nDaughters cut: " << decV->particles_out_size());
	}

	return decision;
	}

	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// ATLAS MBTS trigger requirement of at least one hit in either hemisphere
	- if (applyProjection<FinalState>(event, "MBTS").size() < 1) {
	+ if (apply<FinalState>(event, "MBTS").size() < 1) {
	MSG_DEBUG("Failed trigger cut");
	vetoEvent;
	}

	// Veto event also when we find less than 2 particles in the acceptance region of type 211,2212,11,13,321
	- if (applyProjection<FinalState>(event, "nstable").size() < 2) {
	+ if (apply<FinalState>(event, "nstable").size() < 2) {
	MSG_DEBUG("Failed stable particle cut");
	vetoEvent;
	}
	_sum_w_passed += weight;

	// This ufs holds all the Kaons and Lambdas
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");

	// Some conters
	int n_KS0 = 0;
	int n_LAMBDA = 0;

	// Particle loop
	foreach (const Particle& p, ufs.particles()) {

	// General particle quantities
	const double pT = p.pT();
	const double y = p.rapidity();
	const PdgId apid = p.abspid();

	double flightd = 0.0;

	// Look for Kaons, Lambdas
	switch (apid) {

	case PID::K0S:
	flightd = getPerpFlightDistance(p);
	if (!inRange(flightd/mm, 4., 450.) ) {
	MSG_DEBUG("Kaon failed flight distance cut:" << flightd);
	break;
	}
	if (daughtersSurviveCuts(p) ) {
	_hist_Ks_y ->fill(y, weight);
	_hist_Ks_pT->fill(pT/GeV, weight);
	_sum_w_ks += weight;
	n_KS0++;
	}
	break;

	case PID::LAMBDA:
	if (pT < 0.5*GeV) { // Lambdas have an additional pT cut of 500 MeV
	MSG_DEBUG("Lambda failed pT cut:" << pT/GeV << " GeV");
	break;
	}
	flightd = getPerpFlightDistance(p);
	if (!inRange(flightd/mm, 17., 450.)) {
	MSG_DEBUG("Lambda failed flight distance cut:" << flightd/mm << " mm");
	break;
	}
	if ( daughtersSurviveCuts(p) ) {
	if (p.pid() == PID::LAMBDA) {
	_temp_lambda_v_y.fill(fabs(y), weight);
	_temp_lambda_v_pT.fill(pT/GeV, weight);
	_hist_L_y->fill(y, weight);
	_hist_L_pT->fill(pT/GeV, weight);
	_sum_w_lambda += weight;
	n_LAMBDA++;
	} else if (p.pid() == -PID::LAMBDA) {
	_temp_lambdabar_v_y.fill(fabs(y), weight);
	_temp_lambdabar_v_pT.fill(pT/GeV, weight);
	}
	}
	break;

	}
	}

	// Fill multiplicity histos
	_hist_Ks_mult->fill(n_KS0, weight);
	_hist_L_mult->fill(n_LAMBDA, weight);
	}



	/// Normalise histograms etc., after the run
	void finalize() {
	MSG_DEBUG("# Events that pass the trigger: " << _sum_w_passed);
	MSG_DEBUG("# Kshort events: " << _sum_w_ks);
	MSG_DEBUG("# Lambda events: " << _sum_w_lambda);

	/// @todo Replace with normalize()?
	scale(_hist_Ks_pT, 1.0/_sum_w_ks);
	scale(_hist_Ks_y, 1.0/_sum_w_ks);
	scale(_hist_Ks_mult, 1.0/_sum_w_passed);

	/// @todo Replace with normalize()?
	scale(_hist_L_pT, 1.0/_sum_w_lambda);
	scale(_hist_L_y, 1.0/_sum_w_lambda);
	scale(_hist_L_mult, 1.0/_sum_w_passed);

	// Division of histograms to obtain lambda_bar/lambda ratios
	divide(_temp_lambdabar_v_y, _temp_lambda_v_y, _hist_Ratio_v_y);
	divide(_temp_lambdabar_v_pT, _temp_lambda_v_pT, _hist_Ratio_v_pT);
	}


	private:

	/// Counters
	double _sum_w_ks, _sum_w_lambda, _sum_w_passed;

	/// @name Persistent histograms
	//@{
	Histo1DPtr _hist_Ks_pT, _hist_Ks_y, _hist_Ks_mult;
	Histo1DPtr _hist_L_pT, _hist_L_y, _hist_L_mult;
	Scatter2DPtr _hist_Ratio_v_pT, _hist_Ratio_v_y;
	//@}

	/// @name Temporary histograms
	//@{
	Histo1D _temp_lambda_v_y, _temp_lambdabar_v_y;
	Histo1D _temp_lambda_v_pT, _temp_lambdabar_v_pT;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_I944826);

	}
	diff --git a/src/Analyses/ATLAS_2011_I945498.cc b/src/Analyses/ATLAS_2011_I945498.cc
	--- a/src/Analyses/ATLAS_2011_I945498.cc
	+++ b/src/Analyses/ATLAS_2011_I945498.cc
	@@ -1,305 +1,305 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"

	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"


	namespace Rivet {


	/// ATLAS Z+jets in pp at 7 TeV
	class ATLAS_2011_I945498 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_I945498()
	: Analysis("ATLAS_2011_I945498")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {

	// Variable initialisation
	_isZeeSample = false;
	_isZmmSample = false;
	for (size_t chn = 0; chn < 3; ++chn) {
	weights_nj0[chn] = 0;
	weights_nj1[chn] = 0;
	weights_nj2[chn] = 0;
	weights_nj3[chn] = 0;
	weights_nj4[chn] = 0;
	}

	// Set up projections
	FinalState fs;
	ZFinder zfinder_mu(fs, Cuts::abseta < 2.4 && Cuts::pT > 20GeV, PID::MUON, 66GeV, 116*GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_mu, "ZFinder_mu");
	+ declare(zfinder_mu, "ZFinder_mu");

	Cut cuts = (Cuts::abseta < 1.37 \|\| Cuts::absetaIn(1.52, 2.47)) && Cuts::pT > 20*GeV;

	ZFinder zfinder_el(fs, cuts, PID::ELECTRON, 66GeV, 116GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_el, "ZFinder_el");
	+ declare(zfinder_el, "ZFinder_el");

	Cut cuts25_20 = Cuts::abseta < 2.5 && Cuts::pT > 20*GeV;
	// For combined cross-sections (combined phase space + dressed level)
	ZFinder zfinder_comb_mu(fs, cuts25_20, PID::MUON, 66.0GeV, 116.0GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_comb_mu, "ZFinder_comb_mu");
	+ declare(zfinder_comb_mu, "ZFinder_comb_mu");
	ZFinder zfinder_comb_el(fs, cuts25_20, PID::ELECTRON, 66.0GeV, 116.0GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_comb_el, "ZFinder_comb_el");
	+ declare(zfinder_comb_el, "ZFinder_comb_el");

	// Define veto FS in order to prevent Z-decay products entering the jet algorithm
	VetoedFinalState remfs;
	remfs.addVetoOnThisFinalState(zfinder_el);
	remfs.addVetoOnThisFinalState(zfinder_mu);
	VetoedFinalState remfs_comb;
	remfs_comb.addVetoOnThisFinalState(zfinder_comb_el);
	remfs_comb.addVetoOnThisFinalState(zfinder_comb_mu);

	FastJets jets(remfs, FastJets::ANTIKT, 0.4);
	jets.useInvisibles();
	- addProjection(jets, "jets");
	+ declare(jets, "jets");
	FastJets jets_comb(remfs_comb, FastJets::ANTIKT, 0.4);
	jets_comb.useInvisibles();
	- addProjection(jets_comb, "jets_comb");
	+ declare(jets_comb, "jets_comb");

	// 0=el, 1=mu, 2=comb
	for (size_t chn = 0; chn < 3; ++chn) {
	_h_njet_incl[chn] = bookHisto1D(1, 1, chn+1);
	_h_njet_ratio[chn] = bookScatter2D(2, 1, chn+1);
	_h_ptjet[chn] = bookHisto1D(3, 1, chn+1);
	_h_ptlead[chn] = bookHisto1D(4, 1, chn+1);
	_h_ptseclead[chn] = bookHisto1D(5, 1, chn+1);
	_h_yjet[chn] = bookHisto1D(6, 1, chn+1);
	_h_ylead[chn] = bookHisto1D(7, 1, chn+1);
	_h_yseclead[chn] = bookHisto1D(8, 1, chn+1);
	_h_mass[chn] = bookHisto1D(9, 1, chn+1);
	_h_deltay[chn] = bookHisto1D(10, 1, chn+1);
	_h_deltaphi[chn] = bookHisto1D(11, 1, chn+1);
	_h_deltaR[chn] = bookHisto1D(12, 1, chn+1);
	}
	}


	// Jet selection criteria universal for electron and muon channel
	/// @todo Replace with a Cut passed to jetsByPt
	Jets selectJets(const ZFinder* zf, const FastJets* allJets) {
	const FourMomentum l1 = zf->constituents()[0].momentum();
	const FourMomentum l2 = zf->constituents()[1].momentum();
	Jets jets;
	foreach (const Jet& jet, allJets->jetsByPt(30*GeV)) {
	const FourMomentum jmom = jet.momentum();
	if (jmom.absrap() < 4.4 &&
	deltaR(l1, jmom) > 0.5 && deltaR(l2, jmom) > 0.5) {
	jets.push_back(jet);
	}
	}
	return jets;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	vector<const ZFinder*> zfs;
	- zfs.push_back(& (applyProjection<ZFinder>(event, "ZFinder_el")));
	- zfs.push_back(& (applyProjection<ZFinder>(event, "ZFinder_mu")));
	- zfs.push_back(& (applyProjection<ZFinder>(event, "ZFinder_comb_el")));
	- zfs.push_back(& (applyProjection<ZFinder>(event, "ZFinder_comb_mu")));
	+ zfs.push_back(& (apply<ZFinder>(event, "ZFinder_el")));
	+ zfs.push_back(& (apply<ZFinder>(event, "ZFinder_mu")));
	+ zfs.push_back(& (apply<ZFinder>(event, "ZFinder_comb_el")));
	+ zfs.push_back(& (apply<ZFinder>(event, "ZFinder_comb_mu")));

	vector<const FastJets*> fjs;
	- fjs.push_back(& (applyProjection<FastJets>(event, "jets")));
	- fjs.push_back(& (applyProjection<FastJets>(event, "jets_comb")));
	+ fjs.push_back(& (apply<FastJets>(event, "jets")));
	+ fjs.push_back(& (apply<FastJets>(event, "jets_comb")));

	// Determine what kind of MC sample this is
	const bool isZee = (zfs[0]->bosons().size() == 1) \|\| (zfs[2]->bosons().size() == 1);
	const bool isZmm = (zfs[1]->bosons().size() == 1) \|\| (zfs[3]->bosons().size() == 1);
	if (isZee) _isZeeSample = true;
	if (isZmm) _isZmmSample = true;

	// Require exactly one electronic or muonic Z-decay in the event
	bool isZeemm = ( (zfs[0]->bosons().size() == 1 && zfs[1]->bosons().size() != 1) \|\|
	(zfs[1]->bosons().size() == 1 && zfs[0]->bosons().size() != 1) );
	bool isZcomb = ( (zfs[2]->bosons().size() == 1 && zfs[3]->bosons().size() != 1) \|\|
	(zfs[3]->bosons().size() == 1 && zfs[2]->bosons().size() != 1) );
	if (!isZeemm && !isZcomb) vetoEvent;

	vector<int> zfIDs;
	vector<int> fjIDs;
	if (isZeemm) {
	int chn = zfs[0]->bosons().size() == 1 ? 0 : 1;
	zfIDs.push_back(chn);
	fjIDs.push_back(0);
	}
	if (isZcomb) {
	int chn = zfs[2]->bosons().size() == 1 ? 2 : 3;
	zfIDs.push_back(chn);
	fjIDs.push_back(1);
	}

	for (size_t izf = 0; izf < zfIDs.size(); ++izf) {
	int zfID = zfIDs[izf];
	int fjID = fjIDs[izf];

	int chn = zfID;
	if (zfID == 2 \|\| zfID == 3) chn = 2;

	Jets jets = selectJets(zfs[zfID], fjs[fjID]);

	switch (jets.size()) {
	case 0:
	weights_nj0[chn] += weight;
	break;
	case 1:
	weights_nj0[chn] += weight;
	weights_nj1[chn] += weight;
	break;
	case 2:
	weights_nj0[chn] += weight;
	weights_nj1[chn] += weight;
	weights_nj2[chn] += weight;
	break;
	case 3:
	weights_nj0[chn] += weight;
	weights_nj1[chn] += weight;
	weights_nj2[chn] += weight;
	weights_nj3[chn] += weight;
	break;
	default: // >= 4
	weights_nj0[chn] += weight;
	weights_nj1[chn] += weight;
	weights_nj2[chn] += weight;
	weights_nj3[chn] += weight;
	weights_nj4[chn] += weight;
	}

	// Require at least one jet
	if (jets.empty()) continue;

	// Fill jet multiplicities
	for (size_t ijet = 1; ijet <= jets.size(); ++ijet) {
	_h_njet_incl[chn]->fill(ijet, weight);
	}

	// Loop over selected jets, fill inclusive jet distributions
	for (size_t ijet = 0; ijet < jets.size(); ++ijet) {
	_h_ptjet[chn]->fill(jets[ijet].pT()/GeV, weight);
	_h_yjet [chn]->fill(fabs(jets[ijet].rapidity()), weight);
	}

	// Leading jet histos
	const double ptlead = jets[0].pT()/GeV;
	const double yabslead = fabs(jets[0].rapidity());
	_h_ptlead[chn]->fill(ptlead, weight);
	_h_ylead [chn]->fill(yabslead, weight);

	if (jets.size() >= 2) {
	// Second jet histos
	const double pt2ndlead = jets[1].pT()/GeV;
	const double yabs2ndlead = fabs(jets[1].rapidity());
	_h_ptseclead[chn] ->fill(pt2ndlead, weight);
	_h_yseclead [chn] ->fill(yabs2ndlead, weight);

	// Dijet histos
	const double deltaphi = fabs(deltaPhi(jets[1], jets[0]));
	const double deltarap = fabs(jets[0].rapidity() - jets[1].rapidity()) ;
	const double deltar = fabs(deltaR(jets[0], jets[1], RAPIDITY));
	const double mass = (jets[0].momentum() + jets[1].momentum()).mass();
	_h_mass [chn] ->fill(mass/GeV, weight);
	_h_deltay [chn] ->fill(deltarap, weight);
	_h_deltaphi[chn] ->fill(deltaphi, weight);
	_h_deltaR [chn] ->fill(deltar, weight);
	}
	}
	}


	/// @name Ratio calculator util functions
	//@{

	/// Calculate the ratio, being careful about div-by-zero
	double ratio(double a, double b) {
	return (b != 0) ? a/b : 0;
	}

	/// Calculate the ratio error, being careful about div-by-zero
	double ratio_err(double a, double b) {
	return (b != 0) ? sqrt(a/sqr(b) + sqr(a)/(bbb)) : 0;
	}

	//@}


	void finalize() {
	// Fill ratio histograms
	for (size_t chn = 0; chn < 3; ++chn) {
	_h_njet_ratio[chn]->addPoint(1, ratio(weights_nj1[chn], weights_nj0[chn]), 0.5, ratio_err(weights_nj1[chn], weights_nj0[chn]));
	_h_njet_ratio[chn]->addPoint(2, ratio(weights_nj2[chn], weights_nj1[chn]), 0.5, ratio_err(weights_nj2[chn], weights_nj1[chn]));
	_h_njet_ratio[chn]->addPoint(3, ratio(weights_nj3[chn], weights_nj2[chn]), 0.5, ratio_err(weights_nj3[chn], weights_nj2[chn]));
	_h_njet_ratio[chn]->addPoint(4, ratio(weights_nj4[chn], weights_nj3[chn]), 0.5, ratio_err(weights_nj4[chn], weights_nj3[chn]));
	}

	// Scale other histos
	for (size_t chn = 0; chn < 3; ++chn) {
	// For ee and mumu channels: normalize to Njet inclusive cross-section
	double xs = (chn == 2) ? crossSectionPerEvent()/picobarn : 1 / weights_nj0[chn];
	// For inclusive MC sample(ee/mmu channels together) we want the single-lepton-flavor xsec
	if (_isZeeSample && _isZmmSample) xs /= 2;

	// Special case histogram: always not normalized
	scale(_h_njet_incl[chn], (chn < 2) ? crossSectionPerEvent()/picobarn : xs);

	scale(_h_ptjet[chn] , xs);
	scale(_h_ptlead[chn] , xs);
	scale(_h_ptseclead[chn], xs);
	scale(_h_yjet[chn] , xs);
	scale(_h_ylead[chn] , xs);
	scale(_h_yseclead[chn] , xs);
	scale(_h_deltaphi[chn] , xs);
	scale(_h_deltay[chn] , xs);
	scale(_h_deltaR[chn] , xs);
	scale(_h_mass[chn] , xs);
	}

	}

	//@}


	private:

	bool _isZeeSample;
	bool _isZmmSample;

	double weights_nj0[3];
	double weights_nj1[3];
	double weights_nj2[3];
	double weights_nj3[3];
	double weights_nj4[3];

	Scatter2DPtr _h_njet_ratio[3];
	Histo1DPtr _h_njet_incl[3];
	Histo1DPtr _h_ptjet[3];
	Histo1DPtr _h_ptlead[3];
	Histo1DPtr _h_ptseclead[3];
	Histo1DPtr _h_yjet[3];
	Histo1DPtr _h_ylead[3];
	Histo1DPtr _h_yseclead[3];
	Histo1DPtr _h_deltaphi[3];
	Histo1DPtr _h_deltay[3];
	Histo1DPtr _h_deltaR[3];
	Histo1DPtr _h_mass[3];

	};


	DECLARE_RIVET_PLUGIN(ATLAS_2011_I945498);


	}
	diff --git a/src/Analyses/ATLAS_2011_I954993.cc b/src/Analyses/ATLAS_2011_I954993.cc
	--- a/src/Analyses/ATLAS_2011_I954993.cc
	+++ b/src/Analyses/ATLAS_2011_I954993.cc
	@@ -1,117 +1,117 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief WZ fiducial cross-section measurement
	class ATLAS_2011_I954993 : public Analysis {
	public:

	/// Default constructor
	ATLAS_2011_I954993()
	: Analysis("ATLAS_2011_I954993")
	{
	setNeedsCrossSection(true);
	}


	/// @name Analysis methods
	//@{

	/// Projection and histogram setup
	void init() {
	FinalState fs;
	Cut cuts = Cuts::abseta < 2.5 && Cuts::pT > 15*GeV;

	ZFinder zfinder_e(fs, cuts, PID::ELECTRON, 81.1876GeV, 101.1876GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_e, "ZFinder_e");
	+ declare(zfinder_e, "ZFinder_e");
	ZFinder zfinder_mu(fs, cuts, PID::MUON, 81.1876GeV, 101.1876GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_mu, "ZFinder_mu");
	+ declare(zfinder_mu, "ZFinder_mu");

	VetoedFinalState weinput;
	weinput.addVetoOnThisFinalState(zfinder_e);
	WFinder wfinder_e(weinput, cuts, PID::ELECTRON, 0GeV, 1000GeV, 25*GeV, 0.1, WFinder::CLUSTERNODECAY);
	- addProjection(wfinder_e, "WFinder_e");
	+ declare(wfinder_e, "WFinder_e");

	VetoedFinalState wminput;
	wminput.addVetoOnThisFinalState(zfinder_mu);
	WFinder wfinder_mu(wminput,cuts, PID::MUON, 0GeV, 1000GeV, 25*GeV, 0.1, WFinder::CLUSTERNODECAY);
	- addProjection(wfinder_mu, "WFinder_mu");
	+ declare(wfinder_mu, "WFinder_mu");

	// Histograms
	_h_fiducial = bookHisto1D(1,1,1);
	}


	/// Do the analysis
	void analyze(const Event& e) {
	- const ZFinder& zfinder_e = applyProjection<ZFinder>(e, "ZFinder_e");
	- const ZFinder& zfinder_mu = applyProjection<ZFinder>(e, "ZFinder_mu");
	- const WFinder& wfinder_e = applyProjection<WFinder>(e, "WFinder_e");
	- const WFinder& wfinder_mu = applyProjection<WFinder>(e, "WFinder_mu");
	+ const ZFinder& zfinder_e = apply<ZFinder>(e, "ZFinder_e");
	+ const ZFinder& zfinder_mu = apply<ZFinder>(e, "ZFinder_mu");
	+ const WFinder& wfinder_e = apply<WFinder>(e, "WFinder_e");
	+ const WFinder& wfinder_mu = apply<WFinder>(e, "WFinder_mu");

	// Looking for a Z, exit if not found
	if (zfinder_e.bosons().size() != 1 && zfinder_mu.bosons().size() != 1) {
	MSG_DEBUG("No Z boson found, vetoing event");
	vetoEvent;
	}

	// Looking for a W, exit if not found
	if (wfinder_e.bosons().size()!= 1 && wfinder_mu.bosons().size() != 1) {
	MSG_DEBUG("No W boson found, vetoing event");
	vetoEvent;
	}

	// If we find a W, make fiducial acceptance cuts and exit if not found
	if (wfinder_e.bosons().size() == 1) {
	const FourMomentum& We = wfinder_e.constituentLeptons()[0].momentum();
	const FourMomentum& Wenu = wfinder_e.constituentNeutrinos()[0].momentum();
	const double mT = wfinder_e.mT();
	if (Wenu.pT() < 25GeV \|\| We.pT() < 20GeV \|\| mT < 20*GeV) {
	MSG_DEBUG("Wnu pT = " << Wenu.pT()/GeV << " GeV, Wl pT = " << We.pT()/GeV << " GeV, mT = " << mT/GeV << " GeV");
	vetoEvent;
	}
	} else if (wfinder_mu.bosons().size() == 1) {
	const FourMomentum& Wmu = wfinder_mu.constituentLeptons()[0].momentum();
	const FourMomentum& Wmunu = wfinder_mu.constituentNeutrinos()[0].momentum();
	const double mT = wfinder_mu.mT();
	if (Wmunu.pT() < 25GeV \|\| Wmu.pT() < 20GeV \|\| mT < 20*GeV) {
	MSG_DEBUG("Wnu pT = " << Wmunu.pT()/GeV << ", Wl pT = " << Wmu.pT()/GeV << " GeV, mT = " << mT/GeV << " GeV");
	vetoEvent;
	}
	} else {
	MSG_DEBUG("No W boson found: vetoing event");
	vetoEvent;
	}

	// Update the fiducial cross-section histogram
	_h_fiducial->fill(7000, e.weight());
	}


	/// Finalize
	void finalize() {
	scale(_h_fiducial, crossSection()/femtobarn/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_fiducial;
	//@}

	};


	//// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_I954993);

	}
	diff --git a/src/Analyses/ATLAS_2011_S8924791.cc b/src/Analyses/ATLAS_2011_S8924791.cc
	--- a/src/Analyses/ATLAS_2011_S8924791.cc
	+++ b/src/Analyses/ATLAS_2011_S8924791.cc
	@@ -1,127 +1,127 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/JetShape.hh"

	namespace Rivet {


	/// @brief ATLAS jet shape analysis
	/// @author Andy Buckley, Judith Katzy, Francesc Vives
	class ATLAS_2011_S8924791 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_S8924791()
	: Analysis("ATLAS_2011_S8924791")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	const FinalState fs(-5.0, 5.0);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	FastJets fj(fs, FastJets::ANTIKT, 0.6);
	fj.useInvisibles();
	- addProjection(fj, "Jets");
	+ declare(fj, "Jets");

	// Specify pT bins
	_ptedges = {{ 30.0, 40.0, 60.0, 80.0, 110.0, 160.0, 210.0, 260.0, 310.0, 400.0, 500.0, 600.0 }};
	_yedges = {{ 0.0, 0.3, 0.8, 1.2, 2.1, 2.8 }};

	// Register a jet shape projection and histogram for each pT bin
	for (size_t i = 0; i < 11; ++i) {
	for (size_t j = 0; j < 6; ++j) {
	if (i == 8 && j == 4) continue;
	if (i == 9 && j == 4) continue;
	if (i == 10 && j != 5) continue;

	// Set up projections for each (pT,y) bin
	_jsnames_pT[i][j] = "JetShape" + to_str(i) + to_str(j);
	const double ylow = (j < 5) ? _yedges[j] : _yedges.front();
	const double yhigh = (j < 5) ? _yedges[j+1] : _yedges.back();
	const JetShape jsp(fj, 0.0, 0.7, 7, _ptedges[i], _ptedges[i+1], ylow, yhigh, RAPIDITY);
	- addProjection(jsp, _jsnames_pT[i][j]);
	+ declare(jsp, _jsnames_pT[i][j]);

	// Book profile histograms for each (pT,y) bin
	_profhistRho_pT[i][j] = bookProfile1D(i+1, j+1, 1);
	_profhistPsi_pT[i][j] = bookProfile1D(i+1, j+1, 2);
	}
	}
	}



	/// Do the analysis
	void analyze(const Event& evt) {

	// Get jets and require at least one to pass pT and y cuts
	- const Jets jets = applyProjection<FastJets>(evt, "Jets")
	+ const Jets jets = apply<FastJets>(evt, "Jets")
	.jetsByPt(Cuts::ptIn(_ptedges.front()GeV, _ptedges.back()GeV) && Cuts::absrap < 2.8);
	MSG_DEBUG("Jet multiplicity before cuts = " << jets.size());
	if (jets.size() == 0) {
	MSG_DEBUG("No jets found in required pT and rapidity range");
	vetoEvent;
	}
	// Calculate and histogram jet shapes
	const double weight = evt.weight();

	for (size_t ipt = 0; ipt < 11; ++ipt) {
	for (size_t jy = 0; jy < 6; ++jy) {
	if (ipt == 8 && jy == 4) continue;
	if (ipt == 9 && jy == 4) continue;
	if (ipt == 10 && jy != 5) continue;
	- const JetShape& jsipt = applyProjection<JetShape>(evt, _jsnames_pT[ipt][jy]);
	+ const JetShape& jsipt = apply<JetShape>(evt, _jsnames_pT[ipt][jy]);
	for (size_t ijet = 0; ijet < jsipt.numJets(); ++ijet) {
	for (size_t rbin = 0; rbin < jsipt.numBins(); ++rbin) {
	const double r_rho = jsipt.rBinMid(rbin);
	_profhistRho_pT[ipt][jy]->fill(r_rho, (1./0.1)*jsipt.diffJetShape(ijet, rbin), weight);
	const double r_Psi = jsipt.rBinMid(rbin);
	_profhistPsi_pT[ipt][jy]->fill(r_Psi, jsipt.intJetShape(ijet, rbin), weight);
	}
	}
	}
	}
	}


	// Finalize
	void finalize() {
	}

	//@}


	private:

	/// @name Analysis data
	//@{

	/// Jet \f$ p_\perp\f$ bins.
	vector<double> _ptedges; // This can't be a raw array if we want to initialise it non-painfully
	vector<double> _yedges;

	/// JetShape projection name for each \f$p_\perp\f$ bin.
	string _jsnames_pT[11][6];

	//@}

	/// @name Histograms
	//@{
	Profile1DPtr _profhistRho_pT[11][6];
	Profile1DPtr _profhistPsi_pT[11][6];
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S8924791);

	}
	diff --git a/src/Analyses/ATLAS_2011_S8971293.cc b/src/Analyses/ATLAS_2011_S8971293.cc
	--- a/src/Analyses/ATLAS_2011_S8971293.cc
	+++ b/src/Analyses/ATLAS_2011_S8971293.cc
	@@ -1,91 +1,91 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2011_S8971293 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2011_S8971293()
	: Analysis("ATLAS_2011_S8971293")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	/// Initialise and register projections
	- addProjection(FastJets(FinalState(), FastJets::ANTIKT, 0.6), "AntiKtJets06");
	+ declare(FastJets(FinalState(), FastJets::ANTIKT, 0.6), "AntiKtJets06");

	/// Book histograms
	_h_deltaPhi.addHistogram(110., 160., bookHisto1D(1, 1, 1));
	_h_deltaPhi.addHistogram(160., 210., bookHisto1D(1, 1, 2));
	_h_deltaPhi.addHistogram(210., 260., bookHisto1D(1, 1, 3));
	_h_deltaPhi.addHistogram(260., 310., bookHisto1D(1, 1, 4));
	_h_deltaPhi.addHistogram(310., 400., bookHisto1D(1, 1, 5));
	_h_deltaPhi.addHistogram(400., 500., bookHisto1D(1, 1, 6));
	_h_deltaPhi.addHistogram(500., 600., bookHisto1D(1, 1, 7));
	_h_deltaPhi.addHistogram(600., 800., bookHisto1D(1, 1, 8));
	_h_deltaPhi.addHistogram(800., 10000., bookHisto1D(1, 1, 9));
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	Jets jets06;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "AntiKtJets06").jetsByPt(100.0*GeV)) {
	+ foreach (const Jet& jet, apply<FastJets>(event, "AntiKtJets06").jetsByPt(100.0*GeV)) {
	if (jet.absrap() < 2.8) {
	jets06.push_back(jet);
	}
	}
	if (jets06.size()>1){
	if (fabs(jets06[0].rapidity())<0.8 && fabs(jets06[1].rapidity())<0.8) {
	double observable = mapAngle0ToPi(jets06[0].phi()-jets06[1].phi()) / M_PI;
	_h_deltaPhi.fill(jets06[0].pT(), observable, weight);
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	foreach (Histo1DPtr hist, _h_deltaPhi.getHistograms()) {
	normalize(hist, 1/M_PI);
	}
	}

	//@}


	private:

	/// @name Histograms
	//@{
	BinnedHistogram<double> _h_deltaPhi;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S8971293);

	}
	diff --git a/src/Analyses/ATLAS_2011_S8983313.cc b/src/Analyses/ATLAS_2011_S8983313.cc
	--- a/src/Analyses/ATLAS_2011_S8983313.cc
	+++ b/src/Analyses/ATLAS_2011_S8983313.cc
	@@ -1,301 +1,301 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	class ATLAS_2011_S8983313 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_S8983313()
	: Analysis("ATLAS_2011_S8983313")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	Cut pt10 = Cuts::pT > 10.0*GeV;
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && pt10);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// veto region electrons
	Cut vetocut = Cuts::absetaIn(1.37, 1.52);
	IdentifiedFinalState veto_elecs(vetocut && pt10);
	veto_elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(veto_elecs, "veto_elecs");
	+ declare(veto_elecs, "veto_elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && pt10 );
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);

	/// Jet finder
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0),"cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0),"cfs");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");

	/// Book histograms
	_count_A = bookHisto1D("count_A", 1, 0., 1.);
	_count_B = bookHisto1D("count_B", 1, 0., 1.);
	_count_C = bookHisto1D("count_C", 1, 0., 1.);
	_count_D = bookHisto1D("count_D", 1, 0., 1.);

	_hist_meff_A = bookHisto1D("m_eff_A", 30, 0., 3000.);
	_hist_mT2_B = bookHisto1D("m_T2", 25, 0., 1000.);
	_hist_meff_CD = bookHisto1D("m_eff_C_D", 30, 0., 3000.);
	_hist_eTmiss = bookHisto1D("Et_miss", 20, 0., 1000.);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- Particles veto_e = applyProjection<IdentifiedFinalState>(event, "veto_elecs").particles();
	+ Particles veto_e = apply<IdentifiedFinalState>(event, "veto_elecs").particles();
	if ( ! veto_e.empty() ) {
	MSG_DEBUG("electrons in veto region");
	vetoEvent;
	}


	- Jets cand_jets = applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 4.9);
	- Particles cand_e = applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ Jets cand_jets = apply<FastJets>(event, "AntiKtJets04").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 4.9);
	+ Particles cand_e = apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	Particles cand_mu;
	- Particles chg_tracks = applyProjection<ChargedFinalState>(event, "cfs").particles();
	- foreach ( const Particle & mu, applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	+ Particles chg_tracks = apply<ChargedFinalState>(event, "cfs").particles();
	+ foreach ( const Particle & mu, apply<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu, track) <= 0.2 ) pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV ) cand_mu.push_back(mu);
	}

	Jets cand_jets_2;
	foreach (const Jet& jet, cand_jets) {
	if (jet.abseta() >= 2.5)
	cand_jets_2.push_back(jet);
	else {
	bool away_from_e = true;
	foreach (const Particle& e, cand_e) {
	if (deltaR(e, jet) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e )
	cand_jets_2.push_back( jet );
	}
	}

	Particles recon_e, recon_mu;
	foreach ( const Particle & e, cand_e ) {
	bool away = true;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( deltaR(e, jet) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away )
	recon_e.push_back( e );
	}

	foreach ( const Particle & mu, cand_mu ) {
	bool away = true;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( deltaR(mu, jet) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away )
	recon_mu.push_back( mu );
	}


	// pTmiss
	- Particles vfs_particles = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ Particles vfs_particles = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();


	// final jet filter
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( jet.abseta() <= 2.5 ) recon_jets.push_back( jet );
	}


	// now only use recon_jets, recon_mu, recon_e

	if ( ! ( recon_mu.empty() && recon_e.empty() ) ) {
	MSG_DEBUG("Charged leptons left after selection");
	vetoEvent;
	}

	if ( eTmiss <= 100*GeV ) {
	MSG_DEBUG("Not enough eTmiss: " << eTmiss << " < 100");
	vetoEvent;
	}


	if ( recon_jets.empty() \|\| recon_jets[0].pT() <= 120.0*GeV ) {
	MSG_DEBUG("No hard leading jet in " << recon_jets.size() << " jets");
	vetoEvent;
	}

	// ==================== observables ====================

	// Njets, min_dPhi

	int Njets = 0;
	double min_dPhi = 999.999;
	double pTmiss_phi = pTmiss.phi();
	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.pT() > 40 * GeV ) {
	if ( Njets < 3 )
	min_dPhi = min( min_dPhi, deltaPhi( pTmiss_phi, jet.phi() ) );
	++Njets;
	}
	}

	if ( Njets < 2 ) {
	MSG_DEBUG("Only " << Njets << " >40 GeV jets left");
	vetoEvent;
	}

	if ( min_dPhi <= 0.4 ) {
	MSG_DEBUG("dPhi too small");
	vetoEvent;
	}

	// m_eff

	double m_eff_2j = eTmiss
	+ recon_jets[0].pT()
	+ recon_jets[1].pT();

	double m_eff_3j = recon_jets.size() < 3 ? -999.0 : m_eff_2j + recon_jets[2].pT();

	// etmiss / m_eff

	double et_meff_2j = eTmiss / m_eff_2j;
	double et_meff_3j = eTmiss / m_eff_3j;

	FourMomentum a = recon_jets[0].momentum();
	FourMomentum b = recon_jets[1].momentum();

	double m_T2 = mT2::mT2( a,
	b,
	pTmiss,
	0.0 ); // zero mass invisibles


	// ==================== FILL ====================

	MSG_DEBUG( "Trying to fill "
	<< Njets << ' '
	<< m_eff_2j << ' '
	<< et_meff_2j << ' '
	<< m_eff_3j << ' '
	<< et_meff_3j << ' '
	<< m_T2 );

	_hist_eTmiss->fill(eTmiss, weight);

	// AAAAAAAAAA
	if ( et_meff_2j > 0.3 ) {
	_hist_meff_A->fill(m_eff_2j, weight);
	if ( m_eff_2j > 500 * GeV ) {
	MSG_DEBUG("Hits A");
	_count_A->fill(0.5, weight);
	}
	}

	// BBBBBBBBBB
	_hist_mT2_B->fill(m_T2, weight);
	if ( m_T2 > 300 * GeV ) {
	MSG_DEBUG("Hits B");
	_count_B->fill(0.5, weight);
	}

	// need 3 jets for C and D
	if ( Njets >= 3 && et_meff_3j > 0.25 ) {

	_hist_meff_CD->fill(m_eff_3j, weight);

	// CCCCCCCCCC
	if ( m_eff_3j > 500 * GeV ) {
	MSG_DEBUG("Hits C");
	_count_C->fill(0.5, weight);
	}

	// DDDDDDDDDD
	if ( m_eff_3j > 1000 * GeV ) {
	MSG_DEBUG("Hits D");
	_count_D->fill(0.5, weight);
	}
	}

	}

	//@}

	void finalize() {

	double norm = crossSection()/picobarn*35.0/sumOfWeights();
	scale(_hist_meff_A ,100.*norm);
	scale(_hist_mT2_B ,100.*norm);
	scale(_hist_meff_CD, 40.*norm);
	scale(_hist_eTmiss , 50.*norm);
	}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_A;
	Histo1DPtr _count_B;
	Histo1DPtr _count_C;
	Histo1DPtr _count_D;
	Histo1DPtr _hist_meff_A;
	Histo1DPtr _hist_mT2_B;
	Histo1DPtr _hist_meff_CD;
	Histo1DPtr _hist_eTmiss;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S8983313);

	}
	diff --git a/src/Analyses/ATLAS_2011_S8994773.cc b/src/Analyses/ATLAS_2011_S8994773.cc
	--- a/src/Analyses/ATLAS_2011_S8994773.cc
	+++ b/src/Analyses/ATLAS_2011_S8994773.cc
	@@ -1,138 +1,138 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @author Jinlong Zhang
	class ATLAS_2011_S8994773 : public Analysis {
	public:

	ATLAS_2011_S8994773()
	: Analysis("ATLAS_2011_S8994773") { }


	void init() {
	const FinalState fs500(-2.5, 2.5, 500*MeV);
	- addProjection(fs500, "FS500");
	+ declare(fs500, "FS500");
	const FinalState fslead(-2.5, 2.5, 1.0*GeV);
	- addProjection(fslead, "FSlead");
	+ declare(fslead, "FSlead");

	// Get an index for the beam energy
	isqrts = -1;
	if (fuzzyEquals(sqrtS(), 900*GeV)) isqrts = 0;
	else if (fuzzyEquals(sqrtS(), 7*TeV)) isqrts = 1;
	assert(isqrts >= 0);

	// N profiles, 500 MeV pT cut
	_hist_N_transverse_500 = bookProfile1D(1+isqrts, 1, 1);
	// pTsum profiles, 500 MeV pT cut
	_hist_ptsum_transverse_500 = bookProfile1D(3+isqrts, 1, 1);
	// N vs. Delta(phi) profiles, 500 MeV pT cut
	_hist_N_vs_dPhi_1_500 = bookProfile1D(13+isqrts, 1, 1);
	_hist_N_vs_dPhi_2_500 = bookProfile1D(13+isqrts, 1, 2);
	_hist_N_vs_dPhi_3_500 = bookProfile1D(13+isqrts, 1, 3);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	// Require at least one cluster in the event with pT >= 1 GeV
	- const FinalState& fslead = applyProjection<FinalState>(event, "FSlead");
	+ const FinalState& fslead = apply<FinalState>(event, "FSlead");
	if (fslead.size() < 1) {
	vetoEvent;
	}

	// These are the particles with pT > 500 MeV
	- const FinalState& chargedNeutral500 = applyProjection<FinalState>(event, "FS500");
	+ const FinalState& chargedNeutral500 = apply<FinalState>(event, "FS500");

	// Identify leading object and its phi and pT
	Particles particles500 = chargedNeutral500.particlesByPt();
	Particle p_lead = particles500[0];
	const double philead = p_lead.phi();
	const double etalead = p_lead.eta();
	const double pTlead = p_lead.pT();
	MSG_DEBUG("Leading object: pT = " << pTlead << ", eta = " << etalead << ", phi = " << philead);

	// Iterate over all > 500 MeV particles and count particles and scalar pTsum in the three regions
	vector<double> num500(3, 0), ptSum500(3, 0.0);
	// Temporary histos that bin N in dPhi.
	// NB. Only one of each needed since binnings are the same for the energies and pT cuts
	Histo1D hist_num_dphi_500(refData(13+isqrts,1,1));
	foreach (const Particle& p, particles500) {
	const double pT = p.pT();
	const double dPhi = deltaPhi(philead, p.phi());
	const int ir = region_index(dPhi);
	num500[ir] += 1;
	ptSum500[ir] += pT;

	// Fill temp histos to bin N in dPhi
	if (p.genParticle() != p_lead.genParticle()) { // We don't want to fill all those zeros from the leading track...
	hist_num_dphi_500.fill(dPhi, 1);
	}
	}


	// Now fill underlying event histograms
	// The densities are calculated by dividing the UE properties by dEta*dPhi
	// -- each region has a dPhi of 2*PI/3 and dEta is two times 2.5
	const double dEtadPhi = (22.5 2*PI/3.0);
	_hist_N_transverse_500->fill(pTlead/GeV, num500[1]/dEtadPhi, weight);
	_hist_ptsum_transverse_500->fill(pTlead/GeV, ptSum500[1]/GeV/dEtadPhi, weight);

	// Update the "proper" dphi profile histograms
	// Note that we fill dN/dEtadPhi: dEta = 22.5, dPhi = 2PI/nBins
	// The values tabulated in the note are for an (undefined) signed Delta(phi) rather than
	// \|Delta(phi)\| and so differ by a factor of 2: we have to actually norm for angular range = 2pi
	const size_t nbins = refData(13+isqrts,1,1).numPoints();
	for (size_t i = 0; i < nbins; ++i) {
	double mean = hist_num_dphi_500.bin(i).xMid();
	double value = 0.;
	if (hist_num_dphi_500.bin(i).numEntries() > 0) {
	mean = hist_num_dphi_500.bin(i).xMean();
	value = hist_num_dphi_500.bin(i).area()/hist_num_dphi_500.bin(i).xWidth()/10.0;
	}
	if (pTlead/GeV >= 1.0) _hist_N_vs_dPhi_1_500->fill(mean, value, weight);
	if (pTlead/GeV >= 2.0) _hist_N_vs_dPhi_2_500->fill(mean, value, weight);
	if (pTlead/GeV >= 3.0) _hist_N_vs_dPhi_3_500->fill(mean, value, weight);
	}

	}


	void finalize() {
	}


	private:

	// Little helper function to identify Delta(phi) regions
	inline int region_index(double dphi) {
	assert(inRange(dphi, 0.0, PI, CLOSED, CLOSED));
	if (dphi < PI/3.0) return 0;
	if (dphi < 2*PI/3.0) return 1;
	return 2;
	}


	private:
	int isqrts;

	Profile1DPtr _hist_N_transverse_500;

	Profile1DPtr _hist_ptsum_transverse_500;

	Profile1DPtr _hist_N_vs_dPhi_1_500;
	Profile1DPtr _hist_N_vs_dPhi_2_500;
	Profile1DPtr _hist_N_vs_dPhi_3_500;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S8994773);

	}
	diff --git a/src/Analyses/ATLAS_2011_S9002537.cc b/src/Analyses/ATLAS_2011_S9002537.cc
	--- a/src/Analyses/ATLAS_2011_S9002537.cc
	+++ b/src/Analyses/ATLAS_2011_S9002537.cc
	@@ -1,98 +1,98 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	class ATLAS_2011_S9002537 : public Analysis {
	public:

	ATLAS_2011_S9002537()
	: Analysis("ATLAS_2011_S9002537")
	{ }


	void init() {
	IdentifiedFinalState Muons(Cuts::abseta < 2.4 && Cuts::pT > 20*GeV);
	Muons.acceptIdPair(PID::MUON);
	- addProjection(Muons, "muons");
	+ declare(Muons, "muons");

	ChargedFinalState CFS(Cuts::abseta < 2.8);
	- addProjection(CFS, "tracks");
	+ declare(CFS, "tracks");

	MissingMomentum missmom(FinalState(Cuts::abseta < 5));
	- addProjection(missmom, "MissingMomentum");
	+ declare(missmom, "MissingMomentum");

	/// @todo Will need to register TMP histograms for future histogramming
	_tmp_h_plus = Histo1D(refData(1,1,1));
	_tmp_h_minus = Histo1D(refData(1,1,1));
	_h_asym = bookScatter2D(1, 1, 1);
	}


	void analyze(const Event& event) {

	- const IdentifiedFinalState& muons = applyProjection<IdentifiedFinalState>(event, "muons");
	+ const IdentifiedFinalState& muons = apply<IdentifiedFinalState>(event, "muons");
	if (muons.size() < 1) vetoEvent;
	- const ChargedFinalState& tracks = applyProjection<ChargedFinalState>(event, "tracks");
	+ const ChargedFinalState& tracks = apply<ChargedFinalState>(event, "tracks");

	Particles selected_muons;
	foreach (Particle muon, muons.particles()) {
	FourMomentum testmom = muon.momentum();
	double ptmu(testmom.pT()), ptsum(-ptmu), ratio(0.);
	foreach (Particle track, tracks.particles()) {
	const FourMomentum& trackmom = track.momentum();
	if (deltaR(testmom, trackmom) < 0.4) {
	ptsum += trackmom.pT();
	ratio = ptsum/ptmu;
	if (ratio > 0.2) break;
	}
	}
	if (ratio < 0.2) selected_muons.push_back(muon);
	}
	if (selected_muons.size() < 1) vetoEvent;

	const FourMomentum muonmom = selected_muons[0].momentum();
	- const MissingMomentum& missmom = applyProjection<MissingMomentum>(event, "MissingMomentum");
	+ const MissingMomentum& missmom = apply<MissingMomentum>(event, "MissingMomentum");
	FourMomentum missvec = -missmom.visibleMomentum();
	if (fabs(missvec.Et()) < 25*GeV) vetoEvent;

	double MTW = sqrt( 2 * missvec.pT() * muonmom.pT() * (1 - cos( deltaPhi(missvec.phi(), muonmom.phi()) )) );
	if (MTW < 40*GeV) vetoEvent;

	Histo1D& htmp = (selected_muons[0].pid() > 0) ? _tmp_h_minus : _tmp_h_plus;
	htmp.fill(muonmom.eta(), event.weight());
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	assert(_tmp_h_plus.numBins() == _tmp_h_minus.numBins());
	for (size_t i = 0; i < _tmp_h_plus.numBins(); ++i) {
	const double num = _tmp_h_plus.bin(i).sumW() - _tmp_h_minus.bin(i).sumW();
	const double denom = _tmp_h_plus.bin(i).sumW() + _tmp_h_minus.bin(i).sumW();
	const double relerr = _tmp_h_plus.bin(i).relErr() + _tmp_h_minus.bin(i).relErr();
	const double asym = (num != 0 && denom != 0) ? num / denom : 0;
	const double asym_err = (num != 0 && denom != 0) ? asym*relerr : 0;
	_h_asym->addPoint(_tmp_h_plus.bin(i).xMid(), asym, _tmp_h_plus.bin(i).xWidth()/2.0, asym_err);
	}
	}


	private:

	Scatter2DPtr _h_asym;
	/// @todo Will need to register TMP histograms for future histogramming
	Histo1D _tmp_h_plus, _tmp_h_minus;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9002537);

	}
	diff --git a/src/Analyses/ATLAS_2011_S9019561.cc b/src/Analyses/ATLAS_2011_S9019561.cc
	--- a/src/Analyses/ATLAS_2011_S9019561.cc
	+++ b/src/Analyses/ATLAS_2011_S9019561.cc
	@@ -1,316 +1,316 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	class ATLAS_2011_S9019561 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor

	ATLAS_2011_S9019561()
	: Analysis("ATLAS_2011_S9019561")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");


	// veto region electrons
	Cut vetocut = Cuts::absetaIn(1.37, 1.52);
	IdentifiedFinalState veto_elecs(vetocut && Cuts::pT > 10*GeV);
	veto_elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(veto_elecs, "veto_elecs");
	+ declare(veto_elecs, "veto_elecs");


	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 20*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");


	// jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");


	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");


	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");


	/// book histograms
	_count_OS_e_mu = bookHisto1D("count_OS_e+-mu-+", 1, 0., 1.);
	_count_OS_e_e = bookHisto1D("count_OS_e+e-", 1, 0., 1.);
	_count_OS_mu_mu = bookHisto1D("count_OS_mu+mu-", 1, 0., 1.);
	_count_SS_e_mu = bookHisto1D("count_SS_e+-mu+-", 1, 0., 1.);
	_count_SS_e_e = bookHisto1D("count_SS_e+-e+-", 1, 0., 1.);
	_count_SS_mu_mu = bookHisto1D("count_SS_mu+-mu+-", 1, 0., 1.);

	_hist_eTmiss_OS = bookHisto1D("Et_miss_OS", 20, 0., 400.);
	_hist_eTmiss_SS = bookHisto1D("Et_miss_SS", 20, 0., 400.);

	}




	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	Particles veto_e
	- = applyProjection<IdentifiedFinalState>(event, "veto_elecs").particles();
	+ = apply<IdentifiedFinalState>(event, "veto_elecs").particles();
	if ( ! veto_e.empty() ) {
	MSG_DEBUG("electrons in veto region");
	vetoEvent;
	}

	Jets cand_jets;
	foreach (const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.5 ) {
	cand_jets.push_back(jet);
	}
	}

	Particles cand_e =
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	// charged particle for isolation
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();

	// apply muon isolation
	Particles cand_mu;
	// pTcone around muon track
	foreach ( const Particle & mu,
	- applyProjection<IdentifiedFinalState>(event,"muons").particlesByPt() ) {
	+ apply<IdentifiedFinalState>(event,"muons").particlesByPt() ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	cand_mu.push_back(mu);
	}

	// Discard jets that overlap with electrons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e )
	recon_jets.push_back( jet );
	}

	// Leptons far from jet
	Particles recon_e;
	foreach ( const Particle & e, cand_e ) {
	bool e_near_jet = false;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	e_near_jet = true;
	break;
	}
	}
	// Electron isolation criterion
	if ( ! e_near_jet ) {
	double EtinCone = -e.Et();
	foreach ( const Particle & track, chg_tracks) {
	if ( deltaR(e.momentum(),track.momentum()) <= 0.2 )
	EtinCone += track.Et();
	}
	if ( EtinCone/e.pT() <= 0.15 )
	recon_e.push_back( e );
	}
	}

	Particles recon_mu;
	foreach ( const Particle & mu, cand_mu ) {
	bool mu_near_jet = false;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	mu_near_jet = true;
	break;
	}
	}
	if ( ! mu_near_jet )
	recon_mu.push_back( mu );
	}


	// pTmiss
	Particles vfs_particles
	- = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// Exactly two leptons for each event
	if ( recon_mu.size() + recon_e.size() != 2)
	vetoEvent;

	// Lepton pair mass
	FourMomentum p_leptons;
	foreach ( Particle e, recon_e ) {
	p_leptons += e.momentum();
	}
	foreach ( Particle mu, recon_mu) {
	p_leptons += mu.momentum();
	}

	if ( p_leptons.mass() <= 5.0 * GeV)
	vetoEvent;

	// ==================== FILL ====================


	// electron, electron
	if (recon_e.size() == 2 ) {

	// SS ee
	if ( recon_e[0].pid() * recon_e[1].pid() > 0 ) {
	_hist_eTmiss_SS->fill(eTmiss, weight);
	if ( eTmiss > 100 ) {
	MSG_DEBUG("Hits SS e+/-e+/-");
	_count_SS_e_e->fill(0.5, weight);
	}
	}

	// OS ee
	else if ( recon_e[0].pid() * recon_e[1].pid() < 0) {
	_hist_eTmiss_OS->fill(eTmiss, weight);
	if ( eTmiss > 150 ) {
	MSG_DEBUG("Hits OS e+e-");
	_count_OS_e_e->fill(0.5, weight);
	}
	}
	}


	// muon, electron
	else if ( recon_e.size() == 1 ) {

	// SS mu_e
	if ( recon_e[0].pid() * recon_mu[0].pid() > 0 ) {
	_hist_eTmiss_SS->fill(eTmiss, weight);
	if ( eTmiss > 100 ) {
	MSG_DEBUG("Hits SS e+/-mu+/-");
	_count_SS_e_mu->fill(0.5, weight);
	}
	}

	// OS mu_e
	else if ( recon_e[0].pid() * recon_mu[0].pid() < 0) {
	_hist_eTmiss_OS->fill(eTmiss, weight);
	if ( eTmiss > 150 ) {
	MSG_DEBUG("Hits OS e+mu-");
	_count_OS_e_mu->fill(0.5, weight);
	}
	}
	}


	// muon, muon
	else if ( recon_mu.size() == 2 ) {

	// SS mu_mu
	if ( recon_mu[0].pid() * recon_mu[1].pid() > 0 ) {
	_hist_eTmiss_SS->fill(eTmiss, weight);
	if ( eTmiss > 100 ) {
	MSG_DEBUG("Hits SS mu+/-mu+/-");
	_count_SS_mu_mu->fill(0.5, weight);
	}
	}

	// OS mu_mu
	else if ( recon_mu[0].pid() * recon_mu[1].pid() < 0) {
	_hist_eTmiss_OS->fill(eTmiss, weight);
	if ( eTmiss > 150 ) {
	MSG_DEBUG("Hits OS mu+mu-");
	_count_OS_mu_mu->fill(0.5, weight);
	}
	}
	}


	}

	//@}


	void finalize() {
	double norm = crossSection()/picobarn*35./sumOfWeights();
	// event counts
	scale(_count_OS_e_mu ,norm);
	scale(_count_OS_e_e ,norm);
	scale(_count_OS_mu_mu,norm);
	scale(_count_SS_e_mu ,norm);
	scale(_count_SS_e_e ,norm);
	scale(_count_SS_mu_mu,norm);
	scale(_hist_eTmiss_OS,10.*norm);
	scale(_hist_eTmiss_SS,10.*norm);
	}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_OS_e_mu;
	Histo1DPtr _count_OS_e_e;
	Histo1DPtr _count_OS_mu_mu;
	Histo1DPtr _count_SS_e_mu;
	Histo1DPtr _count_SS_e_e;
	Histo1DPtr _count_SS_mu_mu;
	Histo1DPtr _hist_eTmiss_OS;
	Histo1DPtr _hist_eTmiss_SS;

	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9019561);

	}
	diff --git a/src/Analyses/ATLAS_2011_S9035664.cc b/src/Analyses/ATLAS_2011_S9035664.cc
	--- a/src/Analyses/ATLAS_2011_S9035664.cc
	+++ b/src/Analyses/ATLAS_2011_S9035664.cc
	@@ -1,138 +1,138 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief J/psi production at ATLAS
	class ATLAS_2011_S9035664: public Analysis {
	public:

	/// Constructor
	ATLAS_2011_S9035664()
	: Analysis("ATLAS_2011_S9035664")
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");
	_nonPrRapHigh = bookHisto1D( 14, 1, 1);
	_nonPrRapMedHigh = bookHisto1D( 13, 1, 1);
	_nonPrRapMedLow = bookHisto1D( 12, 1, 1);
	_nonPrRapLow = bookHisto1D( 11, 1, 1);
	_PrRapHigh = bookHisto1D( 18, 1, 1);
	_PrRapMedHigh = bookHisto1D( 17, 1, 1);
	_PrRapMedLow = bookHisto1D( 16, 1, 1);
	_PrRapLow = bookHisto1D( 15, 1, 1);
	_IncRapHigh = bookHisto1D( 20, 1, 1);
	_IncRapMedHigh = bookHisto1D( 21, 1, 1);
	_IncRapMedLow = bookHisto1D( 22, 1, 1);
	_IncRapLow = bookHisto1D( 23, 1, 1);
	}


	void analyze(const Event& e) {

	// Get event weight for histo filling
	const double weight = e.weight();


	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	if (p.abspid() != 443) continue;
	const GenVertex* gv = p.genParticle()->production_vertex();
	bool nonPrompt = false;
	if (gv) {
	foreach (const GenParticle* pi, Rivet::particles(gv, HepMC::ancestors)) {
	const PdgId pid2 = pi->pdg_id();
	if (PID::isHadron(pid2) && PID::hasBottom(pid2)) {
	nonPrompt = true;
	break;
	}
	}
	}
	double absrap = p.absrap();
	double xp = p.perp();

	if (absrap<=2.4 and absrap>2.) {
	if (nonPrompt) _nonPrRapHigh->fill(xp, weight);
	else if (!nonPrompt) _PrRapHigh->fill(xp, weight);
	_IncRapHigh->fill(xp, weight);
	}
	else if (absrap<=2. and absrap>1.5) {
	if (nonPrompt) _nonPrRapMedHigh->fill(xp, weight);
	else if (!nonPrompt) _PrRapMedHigh->fill(xp, weight);
	_IncRapMedHigh->fill(xp, weight);
	}
	else if (absrap<=1.5 and absrap>0.75) {
	if (nonPrompt) _nonPrRapMedLow->fill(xp, weight);
	else if (!nonPrompt) _PrRapMedLow->fill(xp, weight);
	_IncRapMedLow->fill(xp, weight);
	}

	else if (absrap<=0.75) {
	if (nonPrompt) _nonPrRapLow->fill(xp, weight);
	else if (!nonPrompt) _PrRapLow->fill(xp, weight);
	_IncRapLow->fill(xp, weight);
	}
	}
	}


	/// Finalize
	void finalize() {
	double factor = crossSection()/nanobarn*0.0593;

	scale(_PrRapHigh , factor/sumOfWeights());
	scale(_PrRapMedHigh , factor/sumOfWeights());
	scale(_PrRapMedLow , factor/sumOfWeights());
	scale(_PrRapLow , factor/sumOfWeights());

	scale(_nonPrRapHigh , factor/sumOfWeights());
	scale(_nonPrRapMedHigh, factor/sumOfWeights());
	scale(_nonPrRapMedLow , factor/sumOfWeights());
	scale(_nonPrRapLow , factor/sumOfWeights());

	scale(_IncRapHigh , 1000.*factor/sumOfWeights());
	scale(_IncRapMedHigh , 1000.*factor/sumOfWeights());
	scale(_IncRapMedLow , 1000.*factor/sumOfWeights());
	scale(_IncRapLow , 1000.*factor/sumOfWeights());

	}

	//@}


	private:

	Histo1DPtr _nonPrRapHigh;
	Histo1DPtr _nonPrRapMedHigh;
	Histo1DPtr _nonPrRapMedLow;
	Histo1DPtr _nonPrRapLow;

	Histo1DPtr _PrRapHigh;
	Histo1DPtr _PrRapMedHigh;
	Histo1DPtr _PrRapMedLow;
	Histo1DPtr _PrRapLow;

	Histo1DPtr _IncRapHigh;
	Histo1DPtr _IncRapMedHigh;
	Histo1DPtr _IncRapMedLow;
	Histo1DPtr _IncRapLow;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9035664);

	}
	diff --git a/src/Analyses/ATLAS_2011_S9041966.cc b/src/Analyses/ATLAS_2011_S9041966.cc
	--- a/src/Analyses/ATLAS_2011_S9041966.cc
	+++ b/src/Analyses/ATLAS_2011_S9041966.cc
	@@ -1,664 +1,664 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// 1-lepton and 2-lepton search for first or second generation leptoquarks
	/// @todo Clean up the debug stuff
	class ATLAS_2011_S9041966 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2011_S9041966()
	: Analysis("ATLAS_2011_S9041966"),
	// DEBUG
	count(0), vetoe(0), Njetscut(0), //dilept(0),
	candmumujj(0), candeejj(0), //onelept(0),
	eTmisscut(0), candmvjj(0), candevjj(0),
	mumujj(0), eejj(0),
	mTonelept(0), MLQonelept(0), MtLQonelept(0), Stvonelept(0),
	mTev(0), MLQev(0), MtLQev(0), Stvev(0),
	muvjj(0), evjj(0), emuvjj(0),
	cande(0), candmu(0),
	tmpe(0), tmpmu(0),
	mumuZCR(0), eeZCR(0),
	munuW2CR(0), munuttCR(0),
	enuW2CR(0), enuttCR(0)
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialize projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// veto region electrons
	Cut vetocut = Cuts::absetaIn(1.35, 1.52);
	IdentifiedFinalState veto_elecs(vetocut && Cuts::pT > 10*GeV);
	veto_elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(veto_elecs, "veto_elecs");
	+ declare(veto_elecs, "veto_elecs");

	///DEBUG
	// projection to find all leptons
	IdentifiedFinalState all_mu_e;
	all_mu_e.acceptIdPair(PID::MUON);
	all_mu_e.acceptIdPair(PID::ELECTRON);
	- addProjection(all_mu_e, "all_mu_e"); //debug
	+ declare(all_mu_e, "all_mu_e"); //debug

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 20*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairDetail(PID::MUON, 20GeV, 7000GeV);
	vfs.addVetoPairDetail(PID::ELECTRON, 20GeV, 7000GeV);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9), "vfs");

	/// Book histograms
	_count_mumujj = bookHisto1D("count_2muons_dijet", 1, 0., 1.);
	_count_eejj = bookHisto1D("count_2elecs_dijet", 1, 0., 1.);
	_count_muvjj = bookHisto1D("count_muon_neutrino_dijet", 1, 0., 1.);
	_count_evjj = bookHisto1D("count_elec_neutrino_dijet", 1, 0., 1.);

	_hist_St_mumu = bookHisto1D("hist_mumujj_St", 10, 450., 1650.);
	_hist_St_ee = bookHisto1D("hist_eejj_St", 10, 450., 1650.);
	_hist_MLQ_muv = bookHisto1D("hist_munujj_MLQ", 9, 150., 600.);
	_hist_MLQ_ev = bookHisto1D("hist_enujj_MLQ", 9, 150., 600.);

	_hist_St_mumu_ZCR = bookHisto1D("CR_Zjets_St_mumu", 40, 0., 800.);
	_hist_St_ee_ZCR = bookHisto1D("CR_Zjets_Stee", 40, 0., 800.);
	_hist_MLQ_munu_W2CR = bookHisto1D("CR_W2jets_MLQ_munu", 20, 0., 400.);
	_hist_MLQ_enu_W2CR = bookHisto1D("CR_W2jets_MLQ_enu", 20, 0., 400.);
	_hist_MLQ_munu_ttCR = bookHisto1D("CR_tt_MLQ_munu", 35, 0., 700.);
	_hist_MLQ_enu_ttCR = bookHisto1D("CR_tt_MLQ_enu", 35, 0., 700.);

	}



	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	///DEBUG
	count +=1; //cerr<< "Event " << count << '\n';
	// debug

	- Particles veto_e = applyProjection<IdentifiedFinalState>(event, "veto_elecs").particles();
	+ Particles veto_e = apply<IdentifiedFinalState>(event, "veto_elecs").particles();
	if ( ! veto_e.empty() ) {
	MSG_DEBUG("electrons in veto region");
	vetoEvent;
	}
	++vetoe;

	- Jets cand_jets = applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.8);
	+ Jets cand_jets = apply<FastJets>(event, "AntiKtJets04").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.8);

	- Particles candtemp_e = applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	- Particles candtemp_mu = applyProjection<IdentifiedFinalState>(event,"muons").particlesByPt();
	+ Particles candtemp_e = apply<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ Particles candtemp_mu = apply<IdentifiedFinalState>(event,"muons").particlesByPt();
	Particles cand_mu;
	Particles cand_e;
	- Particles vfs_particles = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ Particles vfs_particles = apply<VisibleFinalState>(event, "vfs").particles();


	// pTcone around muon track
	foreach ( const Particle & mu, candtemp_mu ) {
	++tmpmu;
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, vfs_particles ) {
	if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone/mu.pT() < 0.25 )
	++candmu;
	cand_mu.push_back(mu);
	}

	// pTcone around electron
	foreach ( const Particle e, candtemp_e ) {
	++tmpe;
	double pTinCone = -e.pT();
	foreach ( const Particle & track, vfs_particles ) {
	if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone/e.pT() < 0.2 )
	++cande;
	cand_e.push_back(e);
	}

	if ( cand_e.empty() && cand_mu.empty() ) {
	//cerr<<" ->Event vetoed. No candidate lept"<<'\n';
	vetoEvent;
	}


	//DEBUG
	// else{
	// foreach (const Particle & mu, cand_mu) {
	// cerr << "cand mu: " << "Id " << mu.pid() << " eta " << mu.eta() << " pT " << mu.pT() << '\n';
	// }
	// foreach (const Particle & lepton, cand_e) {
	// cerr << "cand e: " << "Id " << lepton.pid() << " eta " << lepton.eta() << " pT " << lepton.pT() << '\n';
	// }} // debug



	// pTmiss
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();


	// discard jets that overlap with leptons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_lept = true;
	foreach ( const Particle e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.5 ) {
	away_from_lept = false;
	break;
	}
	}
	foreach ( const Particle & mu, cand_mu ) {
	if ( deltaR(mu.momentum(),jet.momentum()) <= 0.5 ) {
	away_from_lept = false;
	break;
	}
	}
	if ( away_from_lept )
	recon_jets.push_back( jet );
	}



	//DEBUG
	// cerr << " Num of recon jets: " << recon_jets.size() << '\n';
	// cerr << " Num of cand e: " << cand_e.size() << '\n';
	// cerr << " Num of cand mu: " << cand_mu.size() << '\n';
	//debug



	// ================ OBSERVABLES ================


	// At least 2 hard jets
	if ( recon_jets.size() < 2 ) {
	//cerr << " ->Event vetoed. Not enough hard jets." << '\n';
	vetoEvent;
	}
	++Njetscut;


	// Initialize variables for observables
	double M_ll=0., M_LQ=0., St_ll=0., Mt_LQ=0., St_v=0., mT=0.;
	FourMomentum p_l, p_l1, p_l2, p_j[2];
	p_j[0] = recon_jets[0].momentum();
	p_j[1] = recon_jets[1].momentum();

	Particles dilept_pair;
	bool single_lept = false;

	if ( cand_mu.size() == 2 && cand_e.empty() ) {
	++candmumujj;
	foreach ( const Particle& mu, cand_mu )
	dilept_pair.push_back(mu);
	}
	else if ( cand_e.size() == 2 && cand_mu.empty() ) {
	++candeejj;
	foreach ( const Particle& e, cand_e )
	dilept_pair.push_back(e);
	}
	else if ( cand_mu.size() == 1 && cand_e.empty() ) {
	++candmvjj;
	p_l = cand_mu[0].momentum();
	single_lept = true;
	}
	else if ( cand_e.size() == 1 && cand_mu.empty() ) {
	++candevjj;
	p_l = cand_e[0].momentum();
	single_lept = true;
	}

	// Dilepton channel observables
	if ( ! dilept_pair.empty() ) {

	double E_l1, E_l2, E_j1, E_j2;
	double tmpM_LQ1[2], tmpM_LQ2[2], M_LQDiff1, M_LQDiff2;

	p_l1 = dilept_pair[0].momentum();
	p_l2 = dilept_pair[1].momentum();
	E_l1 = p_l1.E();
	E_l2 = p_l2.E();

	E_j1 = p_j[0].E();
	E_j2 = p_j[1].E();

	// Calculate possible leptoquark mass M_LQ and reconstruct average M_LQ

	tmpM_LQ1[0] = E_l1 + E_j1;
	tmpM_LQ1[1] = E_l2 + E_j2;
	M_LQDiff1 = abs( tmpM_LQ1[0] - tmpM_LQ1[1] );

	tmpM_LQ2[0] = E_l1 + E_j2;
	tmpM_LQ2[1] = E_l2 + E_j1;
	M_LQDiff2 = abs( tmpM_LQ2[0] - tmpM_LQ2[1] );

	if ( M_LQDiff1 > M_LQDiff2 )
	M_LQ = ( tmpM_LQ2[0] + tmpM_LQ2[1] ) / 2;
	else
	M_LQ = ( tmpM_LQ1[0] + tmpM_LQ1[1] ) / 2;

	// Calculate event transverse energy St
	St_ll = p_l1.pT() + p_l2.pT() + p_j[0].pT() + p_j[1].pT();

	// Dilept pair invariant mass M_ll
	M_ll = E_l1 + E_l2;

	}

	// 1-lepton channel observables
	else if ( single_lept ) {

	double tmpM_LQ[2], tmpMt_LQ[2], dPhi_j[2], M_LQDiff1, M_LQDiff2;

	// List of possible M_LQ, Mt_LQ pairings

	for ( int i = 0; i < 2; ++i ) {
	tmpM_LQ[i] = p_l.E() + p_j[i].E();
	dPhi_j[1-i] = deltaPhi( p_j[1-i].phi(), pTmiss.phi() );
	tmpMt_LQ[i] = sqrt( 2 * p_j[1-i].pT() * eTmiss * (1 - cos( dPhi_j[1-i] )) );
	}

	// Choose pairing that gives smallest absolute difference

	M_LQDiff1 = abs( tmpM_LQ[0] - tmpMt_LQ[0] );
	M_LQDiff2 = abs( tmpM_LQ[1] - tmpMt_LQ[1] );

	if ( M_LQDiff1 > M_LQDiff2 ) {
	M_LQ = tmpM_LQ[1];
	Mt_LQ = tmpMt_LQ[1];
	}
	else {
	M_LQ = tmpM_LQ[0];
	Mt_LQ = tmpMt_LQ[0];
	}

	// Event transverse energy
	St_v = p_l.pT() + eTmiss + p_j[0].pT() + p_j[1].pT();

	// Transverse mass mT
	double dPhi_l = deltaPhi( p_l.phi(), pTmiss.phi());
	mT = sqrt( 2 * p_l.pT() * eTmiss * (1 - cos(dPhi_l)) );

	}


	// ============== CONTROL REGIONS ===============

	// mumujj, Z control region
	if ( cand_mu.size() == 2 ) {
	if ( M_ll >= 81GeV && M_ll <= 101GeV ) {
	++mumuZCR;
	_hist_St_mumu_ZCR->fill(St_ll, weight);
	}
	}
	// eejj, Z control region
	else if ( cand_e.size() == 2 ) {
	if ( M_ll >= 81GeV && M_ll <= 101GeV ) {
	++eeZCR;
	_hist_St_ee_ZCR->fill(St_ll, weight);

	}
	}

	if ( cand_mu.size() == 1 ) {
	// munujj, W+2jets control region
	if ( recon_jets.size() == 2 &&
	mT >= 40GeV && mT <= 150GeV ) {
	++munuW2CR;
	_hist_MLQ_munu_W2CR->fill(M_LQ, weight);
	}
	// munujj, tt control region
	if ( recon_jets.size() >= 4 &&
	recon_jets[0].pT() > 50GeV && recon_jets[1].pT() > 40GeV && recon_jets[2].pT() > 30*GeV ) {
	++munuttCR;
	_hist_MLQ_munu_ttCR->fill(M_LQ, weight);
	}
	}
	if ( cand_e.size() == 1 ) {
	// enujj, W+2jets control region
	if ( recon_jets.size() == 2 &&
	mT >= 40GeV && mT <= 150GeV ) {
	++enuW2CR;
	_hist_MLQ_enu_W2CR->fill(M_LQ, weight);
	}
	// enujj, tt control region
	if ( recon_jets.size() >= 4 &&
	recon_jets[0].pT() > 50GeV && recon_jets[1].pT() > 40GeV && recon_jets[2].pT() > 30*GeV ) {
	++enuttCR;
	_hist_MLQ_enu_ttCR->fill(M_LQ, weight);
	}
	}




	// ========= PRESELECTION =======================



	// Single lepton channel cuts
	if ( single_lept ) {

	if ( eTmiss <= 25*GeV ) {
	//cerr << " ->Event vetoed. eTmiss=" << eTmiss << '\n';
	vetoEvent;
	}
	++eTmisscut;

	if ( mT <= 40*GeV )
	vetoEvent;

	//++mTcut;

	// enujj channel
	if ( cand_e.size() == 1 && cand_mu.empty() ) {

	// Triangle cut
	double dPhi_jet1 = deltaPhi( recon_jets[0].phi(), pTmiss.phi() );
	double dPhi_jet2 = deltaPhi( recon_jets[1].phi(), pTmiss.phi() );

	if ( dPhi_jet1 <= 1.5 * (1 - eTmiss/45) \|\|
	dPhi_jet2 <= 1.5 * (1 - eTmiss/45) ) {
	++emuvjj;
	vetoEvent;
	}
	}
	}

	// ==================== FILL ====================


	// mumujj channel
	if ( cand_mu.size() == 2 ) {
	if ( M_ll <= 120*GeV \|\|
	M_LQ <= 150*GeV \|\|
	p_l1.pT() <= 30GeV \|\| p_l2.pT() <= 30GeV \|\|
	p_j[0].pT() <= 30GeV \|\| p_j[1].pT() <= 30GeV \|\|
	St_ll <= 450*GeV ) {
	//cerr<<" ->Dilept event vetoed. Table 4 cuts." << '\n';
	vetoEvent;
	}
	else {


	++mumujj;
	// cerr<< " ->MUMUJJ event selected." << '\n';
	_hist_St_mumu->fill(St_ll, weight);
	_count_mumujj->fill(0.5, weight);

	}
	}
	// eejj channel
	else if ( cand_e.size() == 2 ) {
	if ( M_ll <= 120*GeV \|\|
	M_LQ <= 150*GeV \|\|
	p_l1.pT() <= 30GeV \|\| p_l2.pT() <= 30GeV \|\|
	p_j[0].pT() <= 30GeV \|\| p_j[1].pT() <= 30GeV \|\|
	St_ll <= 450*GeV ) {
	//cerr<<" ->Dilept event vetoed. Table 4 cuts." << '\n';
	vetoEvent;
	}
	else {

	++eejj;
	//cerr<< " ->EEJJ event selected." << '\n';
	_hist_St_ee->fill(St_ll, weight);
	_count_eejj->fill(0.5, weight);

	}
	}


	// muvjj channel
	else if ( cand_mu.size() == 1 ) {



	if (M_LQ<=150*GeV) {
	//cerr<<" ->muvjj event vetoed. Not enough M_LQ: " << M_LQ<< '\n';
	vetoEvent;
	}
	++MLQonelept;
	if (Mt_LQ<=150*GeV) {
	//cerr<<" ->muvjj event vetoed. Not enough Mt_LQ: " << Mt_LQ<< '\n';
	vetoEvent;
	}
	++MtLQonelept;
	if (St_v<=400*GeV) {
	//cerr<<" ->muvjj event vetoed. Not enough St_v: " << St_v<< '\n';
	vetoEvent;
	}
	++Stvonelept;
	if (mT<=160*GeV) {
	//cerr<<" ->muvjj event vetoed. Not enough mT: " << mT<<'\n';
	vetoEvent;
	}
	++mTonelept;
	//else {
	++muvjj;
	//cerr<< " ->MUVJJ event selected." << '\n';
	_hist_MLQ_muv->fill(M_LQ, weight);
	_count_muvjj->fill(0.5, weight);

	//}
	}

	// evjj channel
	else if ( cand_e.size() == 1 ) {

	if (M_LQ<=180*GeV) {
	//cerr<<" ->evjj event vetoed. Not enough M_LQ: " << M_LQ<< '\n';
	vetoEvent;
	}
	++MLQev;
	if (Mt_LQ<=180*GeV) {
	//cerr<<" ->evjj event vetoed. Not enough Mt_LQ: " << Mt_LQ<< '\n';
	vetoEvent;
	}
	++MtLQev;
	if (St_v<=410*GeV) {
	//cerr<<" ->evjj event vetoed. Not enough St_v: " << St_v<< '\n';
	vetoEvent;
	}
	++Stvev;
	if (mT<=200*GeV) {
	//cerr<<" ->evjj event vetoed. Not enough mT: " << mT<<'\n';
	vetoEvent;
	}
	++mTev;
	//else {
	++evjj;
	//cerr<< " ->EVJJ event selected." << '\n';
	_hist_MLQ_ev->fill(M_LQ, weight);
	_count_evjj->fill(0.5, weight);



	// if ( mT <= 200*GeV \|\|
	// M_LQ <= 180*GeV \|\|
	// Mt_LQ <= 180*GeV \|\|
	// St_v <= 410*GeV ) {
	// cerr<<" ->evjj event vetoed. Doesn't pass table 4 cuts." << '\n';
	// vetoEvent;
	// }
	// else {
	// ++evjj;
	// cerr<< " ->EVJJ event selected." << '\n';
	// _hist_MLQ_ev->fill(M_LQ, weight);
	// _count_evjj->fill(0.5, weight);

	// }


	}


	}

	//@}


	void finalize() {
	// cerr << '\n' << "Of " << count << " events, saw "
	// << vetoe << " (after veto region cut), "
	// << Njetscut << " (after 2jet req). "
	// << '\n'
	// << "For " << dilept << " dilept events: "
	// << candmumujj << " cand mumujj events, "
	// << candeejj << " cand eejj events."
	// << '\n'
	// << "For " << onelept << " onelept events: "
	// << candmvjj << " preselected mvjj events, "
	// << candevjj << " preselected evjj events; "
	// << eTmisscut << " (eTmiss req); "
	// << emuvjj << " leftover; "
	// << MLQonelept << " (muvjj M_LQ cut), "
	// << MtLQonelept << " (muvjj Mt_LQ cut), "
	// << Stvonelept << " (muvjj St_v cut), "
	// << mTonelept << " (muvjj mT cut); "
	// << MLQev << " (evjj M_LQ cut), "
	// << MtLQev << " (evjj Mt_LQ cut), "
	// << Stvev << " (evjj St_v cut), "
	// << mTev << " (evjj mT cut). "
	// << '\n'<<'\n'
	// ;

	// cerr << "CR - " << "mumu Z: " << mumuZCR << " ee Z: " << eeZCR << " munu W+2jets: " << munuW2CR << " munu tt: " << munuttCR << " enu W+2jets: " << enuW2CR << " enu tt: " << enuttCR << '\n';

	// cerr << "mumujj: " << mumujj << " eejj: " << eejj << " muvjj: " << muvjj << " evjj: " << evjj << '\n';


	scale( _hist_St_ee, 120. * 35. * crossSection()/sumOfWeights() );
	scale( _hist_St_mumu, 120. * 35. * crossSection()/sumOfWeights() );
	scale( _hist_MLQ_muv, 50. * 35. * crossSection()/sumOfWeights() );
	scale( _hist_MLQ_ev, 50. * 35. * crossSection()/sumOfWeights() );



	scale( _hist_St_mumu_ZCR, 20. * 35. * crossSection()/sumOfWeights() );
	scale( _hist_St_ee_ZCR, 20. * 35. * crossSection()/sumOfWeights() );
	scale( _hist_MLQ_munu_W2CR, 20. * 35. * crossSection()/sumOfWeights() );
	scale( _hist_MLQ_enu_W2CR, 20. * 35. * crossSection()/sumOfWeights() );
	scale( _hist_MLQ_munu_ttCR, 20. * 35. * crossSection()/sumOfWeights() );
	scale( _hist_MLQ_enu_ttCR, 20. * 35. * crossSection()/sumOfWeights() );

	/*
	scale( _hist_eTmiss_mu, binwidthluminosity crossSection()/sumOfWeights() );
	*/

	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_mumujj;
	Histo1DPtr _count_eejj;
	Histo1DPtr _count_muvjj;
	Histo1DPtr _count_evjj;

	Histo1DPtr _hist_St_mumu;
	Histo1DPtr _hist_St_ee;
	Histo1DPtr _hist_MLQ_muv;
	Histo1DPtr _hist_MLQ_ev;

	Histo1DPtr _hist_St_mumu_ZCR;
	Histo1DPtr _hist_St_ee_ZCR;
	Histo1DPtr _hist_MLQ_munu_W2CR;
	Histo1DPtr _hist_MLQ_enu_W2CR;
	Histo1DPtr _hist_MLQ_munu_ttCR;
	Histo1DPtr _hist_MLQ_enu_ttCR;




	//@}


	// DEBUG VARIABLES
	int count;
	int vetoe;
	int Njetscut;
	//int dilept;
	int candmumujj;
	int candeejj;
	//int onelept;
	int eTmisscut;
	int candmvjj;
	int candevjj;
	int mumujj;
	int eejj;
	int mTonelept;
	int MLQonelept;
	int MtLQonelept;
	int Stvonelept;
	int mTev;
	int MLQev;
	int MtLQev;
	int Stvev;
	int muvjj;
	int evjj;
	int emuvjj;
	int cande;
	int candmu;
	int tmpe;
	int tmpmu;
	int mumuZCR;
	int eeZCR;
	int munuW2CR;
	int munuttCR;
	int enuW2CR;
	int enuttCR;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9041966);

	}
	diff --git a/src/Analyses/ATLAS_2011_S9108483.cc b/src/Analyses/ATLAS_2011_S9108483.cc
	--- a/src/Analyses/ATLAS_2011_S9108483.cc
	+++ b/src/Analyses/ATLAS_2011_S9108483.cc
	@@ -1,204 +1,204 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Math/Constants.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/NonHadronicFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	class ATLAS_2011_S9108483 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2011_S9108483()
	: Analysis("ATLAS_2011_S9108483")
	{
	}

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// get the non-hadronic final-state particles
	double etaMax = 2.5;
	const NonHadronicFinalState nhfs(-etaMax,etaMax,13.*GeV);
	- addProjection(nhfs,"NHFS");
	+ declare(nhfs,"NHFS");
	// select the charged ones
	const ChargedFinalState cfs(nhfs);
	- addProjection(cfs,"CFS");
	+ declare(cfs,"CFS");
	// and then veto electrons, and taus to be safe
	VetoedFinalState vfs(cfs);
	vfs.addVetoPairId(PID::ELECTRON);

	- addProjection(vfs,"VFS");
	+ declare(vfs,"VFS");

	/// Book histograms
	_count_trigger = bookHisto1D("count_trigger" , 1, 0., 1.);
	_count_event = bookHisto1D("count_selection", 1, 0., 1.);
	_count_quality = bookHisto1D("count_quality" , 1, 0., 1.);
	_count_beta = bookHisto1D("count_beta" , 1, 0., 1.);
	_count_90 = bookHisto1D("count_90" , 1, 0., 1.);
	_count_110 = bookHisto1D("count_110", 1, 0., 1.);
	_count_120 = bookHisto1D("count_120", 1, 0., 1.);
	_count_130 = bookHisto1D("count_130", 1, 0., 1.);

	_hist_beta = bookHisto1D("beta",1000, 0., 2.);
	_hist_time = bookHisto1D("time",1000, -50, 50.);
	_hist_mass = bookHisto1D("mass", 60, 5., 305.);
	}


	double rndGauss(double sigma, double mean) {
	double r = sqrt(-2.0*log(rand()/static_cast<double>(RAND_MAX)));
	double phi = rand()/static_cast<double>(RAND_MAX)2.0pi;
	return mean+sigmarsin(phi);
	}

	/// Perform the per-event analysis
	void analyze(const Event& event) {
	// smearing parameters
	// time measurement (in ns)
	// const double tsmear=5.*0.7;
	const double tsmear=0.7;
	// sagita error
	const double csag =1.1E-4;
	// multiple scattering
	const double cms =2.0E-2;
	// muon chamber radius (in metres)
	const double radius = 10.e3;
	// convert to ns
	const double tr = radius/c_light;
	// event weight
	const double weight = event.weight();
	// get the charged final-state particles
	Particles charged =
	- applyProjection<VetoedFinalState>(event,"VFS").particles();
	+ apply<VetoedFinalState>(event,"VFS").particles();
	// need at least two candidates
	if(charged.size()<2) vetoEvent;
	// number passing trigger
	_count_trigger->fill(0.5,weight);
	// Z mass veto
	foreach ( const Particle & mu1,charged ) {
	foreach ( const Particle & mu2,charged ) {
	double mass = (mu1.momentum()+mu2.momentum()).mass();
	double diff = abs(mass-91.18);
	if(diff<10.) vetoEvent;
	}
	}
	// number passing first event selection
	_count_event->fill(0.5,weight);
	// now find the candidates
	// loop over the particles and find muons and heavy charged particles
	map<double,Particle> muonCandidates;
	foreach (const Particle& mu, charged) {
	// calculate the smeared momentum
	double pT = mu.pT2();
	double pmag = sqrt(pT+sqr(mu.pz()));
	double deltap = sqrt( sqr(csagsqr(pmag)) + sqr(cmsmu.E()/GeV));
	double psmear = rndGauss(deltap,pmag);
	// keep particles with pT>40
	if(psmear/pmagmu.perp()<40.GeV\|\|
	psmear/pmagmu.perp()>1000.GeV) continue;
	muonCandidates.insert(make_pair(psmear,mu));
	}
	// require two candidates
	if(muonCandidates.size()<2) vetoEvent;
	// number passing "quality" cut
	_count_quality->fill(0.5,weight);
	// now do the time of flight
	bool filled = false;
	for(map<double,Particle>::const_iterator it=muonCandidates.begin();
	it!=muonCandidates.end();++it) {
	// true magnitude and pT of momentum
	double pT = it->second.pT2();
	double pmag = sqrt(pT+sqr(it->second.pz()));
	pT = sqrt(pT);
	// true time difference in ns
	double deltaT =tr *(it->second.E()-pmag)/pT;
	// smear it
	deltaT = rndGauss(tsmear,deltaT);
	// beta
	double beta = 1./(1.+deltaT/tr*pT/pmag);
	_hist_beta->fill(beta, weight);
	_hist_time->fill(deltaT, weight);
	// beta cut
	if(beta<0.95) continue;
	// mass
	double mass = 2.pTit->firstdeltaT/tr(1.+0.5deltaT/trpT/pmag);
	if(mass<0.) continue;
	mass = sqrt(mass);
	filled = true;
	_hist_mass->fill(mass,weight);
	if(mass>90. ) {
	_count_90 ->fill(0.5,weight);
	if(mass>110.) {
	_count_110->fill(0.5,weight);
	if(mass>120.) {
	_count_120->fill(0.5,weight);
	if(mass>130.) {
	_count_130->fill(0.5,weight);
	}
	}
	}
	}
	}
	if(!filled) vetoEvent;
	// number passing beta cut
	_count_beta->fill(0.5,weight);
	}

	//@}

	void finalize() {
	double fact = crossSection()/sumOfWeights()*37;
	MSG_WARNING("testing " << crossSection() << " " << sumOfWeights() << " " << fact);
	scale(_hist_beta,fact);
	scale(_hist_time,fact);
	scale(_hist_mass,fact);
	scale( _count_trigger, fact);
	scale( _count_event, fact);
	scale( _count_quality, fact);
	scale( _count_beta, fact);
	scale( _count_90, fact);
	scale( _count_110, fact);
	scale( _count_120, fact);
	scale( _count_130, fact);
	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _hist_beta;
	Histo1DPtr _hist_time;
	Histo1DPtr _hist_mass;
	Histo1DPtr _count_trigger;
	Histo1DPtr _count_event;
	Histo1DPtr _count_quality;
	Histo1DPtr _count_beta;
	Histo1DPtr _count_90;
	Histo1DPtr _count_110;
	Histo1DPtr _count_120;
	Histo1DPtr _count_130;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9108483);


	}
	diff --git a/src/Analyses/ATLAS_2011_S9120807.cc b/src/Analyses/ATLAS_2011_S9120807.cc
	--- a/src/Analyses/ATLAS_2011_S9120807.cc
	+++ b/src/Analyses/ATLAS_2011_S9120807.cc
	@@ -1,164 +1,147 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief Measurement of isolated diphoton + X differential cross-sections
	///
	- /// Inclusive isolated gamma gamma cross-sections, differential in M(gg), pT(gg),
	- /// dphi(gg)
	+ /// Inclusive isolated gamma gamma cross-sections, differential in M(gg), pT(gg), dphi(gg)
	///
	/// @author Giovanni Marchiori
	class ATLAS_2011_S9120807 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_S9120807()
	- : Analysis("ATLAS_2011_S9120807"),
	- _eta_bins_areaoffset{0.0, 1.5, 3.0}
	+ : Analysis("ATLAS_2011_S9120807")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	FastJets fj(fs, FastJets::KT, 0.5);
	fj.useJetArea(new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec()));
	- addProjection(fj, "KtJetsD05");
	+ declare(fj, "KtJetsD05");

	IdentifiedFinalState photonfs(Cuts::abseta < 2.37 && Cuts::pT > 16*GeV);
	photonfs.acceptId(PID::PHOTON);
	- addProjection(photonfs, "Photon");
	+ declare(photonfs, "Photon");

	_h_M = bookHisto1D(1, 1, 1);
	_h_pT = bookHisto1D(2, 1, 1);
	_h_dPhi = bookHisto1D(3, 1, 1);
	}


	- /// @todo Prefer to use Rivet::binIndex()
	- size_t getEtaBin(double eta_w) const {
	- const double aeta = fabs(eta_w);
	- size_t v_iter = 0;
	- for (; v_iter+1 < _eta_bins_areaoffset.size(); ++v_iter) {
	- if (inRange(aeta, _eta_bins_areaoffset[v_iter], _eta_bins_areaoffset[v_iter+1])) break;
	- }
	- return v_iter;
	+ size_t getEtaBin(double eta) const {
	+ const double aeta = fabs(eta);
	+ return binIndex(aeta, _eta_bins_areaoffset);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	// Require at least 2 photons in final state
	- Particles photons = applyProjection<IdentifiedFinalState>(event, "Photon").particlesByPt();
	+ Particles photons = apply<IdentifiedFinalState>(event, "Photon").particlesByPt();
	if (photons.size() < 2) vetoEvent;

	- // Compute the median energy density
	- vector<double> _ptDensity;
	+ // Compute jet pT densities
	+ vector<double> ptDensity;
	vector< vector<double> > ptDensities(_eta_bins_areaoffset.size()-1);
	-
	- const shared_ptr<fastjet::ClusterSequenceArea> clust_seq_area = applyProjection<FastJets>(event, "KtJetsD05").clusterSeqArea();
	- for (const Jet& jet : applyProjection<FastJets>(event, "KtJetsD05").jets()) {
	+ const shared_ptr<fastjet::ClusterSequenceArea> clust_seq_area = apply<FastJets>(event, "KtJetsD05").clusterSeqArea();
	+ for (const Jet& jet : apply<FastJets>(event, "KtJetsD05").jets()) {
	const double area = clust_seq_area->area(jet); // .pseudojet() called implicitly
	/// @todo Should be 1e-4?
	if (area > 10e-4 && jet.abseta() < _eta_bins_areaoffset.back()) {
	ptDensities.at(getEtaBin(jet.abseta())).push_back(jet.pT()/area);
	}
	}

	+ // Compute the median energy density
	for (size_t b = 0; b < _eta_bins_areaoffset.size()-1; ++b) {
	- double median = 0.0;
	- if (!ptDensities[b].empty()) {
	- std::sort(ptDensities[b].begin(), ptDensities[b].end());
	- int nDens = ptDensities[b].size();
	- if (nDens % 2 == 0) {
	- median = (ptDensities[b][nDens/2] + ptDensities[b][(nDens-2)/2]) / 2;
	- } else {
	- median = ptDensities[b][(nDens-1)/2];
	- }
	- }
	- _ptDensity.push_back(median);
	+ ptDensity += ptDensities[b].empty() ? 0 : median(ptDensities[b]);
	}

	// Loop over photons and fill vector of isolated ones
	Particles isolated_photons;
	for (const Particle& photon : photons) {

	// Remove photons in crack
	if (inRange(photon.abseta(), 1.37, 1.52)) continue;

	// Standard ET cone isolation
	- const Particles& fs = applyProjection<FinalState>(event, "FS").particles();
	+ const Particles& fs = apply<FinalState>(event, "FS").particles();
	FourMomentum mom_in_EtCone;
	for (const Particle& p : fs) {
	// Check if it's in the cone of .4
	if (deltaR(photon, p) >= 0.4) continue;
	// Veto if it's in the 5x7 central core
	if (fabs(deltaEta(photon, p)) < 0.0255.00.5 &&
	fabs(deltaPhi(photon, p)) < (M_PI/128.)7.00.5) continue;
	// Increment isolation cone ET sum
	mom_in_EtCone += p.momentum();
	}

	// Now figure out the correction (area*density)
	- const double EtCone_area = M_PI.4.4 - (7.0.025)(5.0*M_PI/128.);
	- const double correction = _ptDensity[getEtaBin(photon.abseta())]*EtCone_area;
	+ const double ETCONE_AREA = M_PI.4.4 - (7.0.025)(5.0*M_PI/128.);
	+ const double correction = ptDensity[getEtaBin(photon.abseta())] * ETCONE_AREA;

	// Shouldn't need to subtract photon
	// NB. Using expected cut at hadron/particle level, not cut at reco level
	if (mom_in_EtCone.Et() - correction > 4.0*GeV) continue;

	// Add to list of isolated photons
	isolated_photons.push_back(photon);
	}

	// Require at least two isolated photons
	if (isolated_photons.size() < 2) vetoEvent;

	// Select leading pT pair
	std::sort(isolated_photons.begin(), isolated_photons.end(), cmpMomByPt);
	const FourMomentum y1 = isolated_photons[0].momentum();
	const FourMomentum y2 = isolated_photons[1].momentum();

	// Require the two photons to be separated (dR>0.4)
	if (deltaR(y1, y2) < 0.4) vetoEvent;

	const FourMomentum yy = y1 + y2;
	const double Myy = yy.mass()/GeV;
	const double pTyy = yy.pT()/GeV;
	const double dPhiyy = deltaPhi(y1.phi(), y2.phi());

	const double weight = event.weight();
	_h_M->fill(Myy, weight);
	_h_pT->fill(pTyy, weight);
	_h_dPhi->fill(dPhiyy, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_M, crossSection()/sumOfWeights());
	scale(_h_pT, crossSection()/sumOfWeights());
	scale(_h_dPhi, crossSection()/sumOfWeights());
	}


	private:

	Histo1DPtr _h_M, _h_pT, _h_dPhi;
	- vector<double> _eta_bins_areaoffset;
	+ const vector<double> _eta_bins_areaoffset = {0.0, 1.5, 3.0};

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9120807);


	}
	diff --git a/src/Analyses/ATLAS_2011_S9126244.cc b/src/Analyses/ATLAS_2011_S9126244.cc
	--- a/src/Analyses/ATLAS_2011_S9126244.cc
	+++ b/src/Analyses/ATLAS_2011_S9126244.cc
	@@ -1,339 +1,339 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	struct ATLAS_2011_S9126244_Plots {

	int selectionType; ///< The HepData y-axis code
	string intermediateHistName;

	// Gap fraction vs DeltaY plot setup
	int _gapFractionDeltaYHistIndex;
	vector<double> _gapFractionDeltaYSlices;
	BinnedHistogram<double> _h_gapVsDeltaYVeto;
	BinnedHistogram<double> _h_gapVsDeltaYInc;

	// Gap fraction vs ptBar plot setup
	int _gapFractionPtBarHistIndex;
	vector<double> _gapFractionPtBarSlices;
	BinnedHistogram<double> _h_gapVsPtBarVeto;
	BinnedHistogram<double> _h_gapVsPtBarInc;

	// Gap fraction vs Q0 plot setup
	int _gapFractionQ0HistIndex;
	vector<double> _gapFractionQ0SlicesPtBar;
	vector<double> _gapFractionQ0SlicesDeltaY;
	vector<Histo1DPtr> _h_vetoPt;
	vector<Scatter2DPtr> _d_vetoPtGapFraction;
	vector<double> _vetoPtTotalSum; ///< @todo Can this just be replaced with _h_vetoPt.integral()?

	// Average njet vs DeltaY setup
	int _avgNJetDeltaYHistIndex;
	vector<double> _avgNJetDeltaYSlices;
	vector<Profile1DPtr> _p_avgJetVsDeltaY;

	// Average njet vs PptBar setup
	int _avgNJetPtBarHistIndex;
	vector<double> _avgNJetPtBarSlices;
	vector<Profile1DPtr> _p_avgJetVsPtBar;
	};



	/// ATLAS dijet production with central jet veto
	/// @todo Make sure that temp histos are removed
	class ATLAS_2011_S9126244 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_S9126244()
	: Analysis("ATLAS_2011_S9126244")
	{ }


	public:

	/// Book histograms and initialise projections before the run
	void init() {

	// Initialize the lone projection required
	- addProjection(FastJets(FinalState(), FastJets::ANTIKT, 0.6), "AntiKtJets06");
	+ declare(FastJets(FinalState(), FastJets::ANTIKT, 0.6), "AntiKtJets06");

	// Initialize plots for each selection type
	_selectionPlots[0].intermediateHistName = "highestPt";
	_selectionPlots[0].selectionType = 1;
	_selectionPlots[0]._gapFractionDeltaYHistIndex = 6;
	_selectionPlots[0]._gapFractionPtBarHistIndex = 1;
	_selectionPlots[0]._gapFractionQ0HistIndex = 13;
	_selectionPlots[0]._avgNJetDeltaYHistIndex = 37;
	_selectionPlots[0]._avgNJetPtBarHistIndex = 26;
	_selectionPlots[0]._gapFractionDeltaYSlices = {{ 70.0, 90.0, 120.0, 150.0, 180.0, 210.0, 240.0, 270.0 }};
	_selectionPlots[0]._gapFractionPtBarSlices = {{ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 }};
	_selectionPlots[0]._gapFractionQ0SlicesPtBar = {{ 70.0, 90.0, 120.0, 150.0, 210.0, 240.0 }};
	_selectionPlots[0]._gapFractionQ0SlicesDeltaY = {{ 2.0, 3.0, 4.0, 5.0 }};
	_selectionPlots[0]._avgNJetPtBarSlices = {{ 1.0, 2.0, 3.0, 4.0, 5.0 }};
	_selectionPlots[0]._avgNJetDeltaYSlices = {{ 70.0, 90.0, 120.0, 150.0, 180.0, 210.0, 240.0, 270.0 }};
	initializePlots(_selectionPlots[0]);

	_selectionPlots[1].intermediateHistName = "forwardBackward";
	_selectionPlots[1].selectionType = 2;
	_selectionPlots[1]._gapFractionDeltaYHistIndex = 6;
	_selectionPlots[1]._gapFractionPtBarHistIndex = 1;
	_selectionPlots[1]._gapFractionQ0HistIndex = 13;
	_selectionPlots[1]._avgNJetDeltaYHistIndex = 37;
	_selectionPlots[1]._avgNJetPtBarHistIndex = 26;
	_selectionPlots[1]._gapFractionDeltaYSlices = {{ 70.0, 90.0, 120.0, 150.0, 180.0, 210.0, 240.0, 270.0 }};
	_selectionPlots[1]._gapFractionPtBarSlices = {{ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 }};
	_selectionPlots[1]._gapFractionQ0SlicesPtBar = {{ 70.0, 90.0, 120.0, 150.0, 210.0, 240.0 }};
	_selectionPlots[1]._gapFractionQ0SlicesDeltaY = {{ 2.0, 3.0, 4.0, 5.0 }};
	_selectionPlots[1]._avgNJetPtBarSlices = {{ 1.0, 2.0, 3.0, 4.0, 5.0 }};
	_selectionPlots[1]._avgNJetDeltaYSlices = {{ 70.0, 90.0, 120.0, 150.0, 180.0, 210.0, 240.0, 270.0 }};
	initializePlots(_selectionPlots[1]);

	_selectionPlots[2].intermediateHistName = "forwardBackward_PtBarVeto";
	_selectionPlots[2].selectionType = 1;
	_selectionPlots[2]._gapFractionDeltaYHistIndex = 19;
	_selectionPlots[2]._avgNJetDeltaYHistIndex = 30;
	_selectionPlots[2]._gapFractionDeltaYSlices = {{ 70.0, 90.0, 120.0, 150.0, 180.0, 210.0, 240.0, 270.0 }};
	_selectionPlots[2]._avgNJetDeltaYSlices = {{ 70.0, 90.0, 120.0, 150.0, 180.0, 210.0, 240.0, 270.0 }};
	initializePlots(_selectionPlots[2]);
	}


	void initializePlots(ATLAS_2011_S9126244_Plots& plots) {

	// Gap fraction vs DeltaY
	if (!plots._gapFractionDeltaYSlices.empty()) {
	for (size_t x = 0; x < plots._gapFractionDeltaYSlices.size()-1; x++) {
	const string vetoHistName = "TMP/gapDeltaYVeto_" + plots.intermediateHistName + "_" + to_str(x);
	const string inclusiveHistName = "TMP/gapDeltaYInclusive_" + plots.intermediateHistName + "_" + to_str(x);
	plots._h_gapVsDeltaYVeto.addHistogram(plots._gapFractionDeltaYSlices[x], plots._gapFractionDeltaYSlices[x+1],
	bookHisto1D(vetoHistName,refData(plots._gapFractionDeltaYHistIndex+x, 1,plots.selectionType)));
	plots._h_gapVsDeltaYInc.addHistogram(plots._gapFractionDeltaYSlices[x], plots._gapFractionDeltaYSlices[x+1],
	bookHisto1D(inclusiveHistName,refData(plots._gapFractionDeltaYHistIndex+x, 1, plots.selectionType)));
	}
	}

	// Average njet vs DeltaY
	if (!plots._avgNJetDeltaYSlices.empty()) {
	for (size_t x = 0; x < plots._avgNJetDeltaYSlices.size()-1; x++) {
	plots._p_avgJetVsDeltaY += bookProfile1D(plots._avgNJetDeltaYHistIndex+x, 1, plots.selectionType);
	}
	}

	// Gap fraction vs PtBar
	if (!plots._gapFractionPtBarSlices.empty()) {
	for (size_t x = 0; x < plots._gapFractionPtBarSlices.size()-1; x++) {
	const string vetoHistName = "TMP/gapPtBarVeto_" + plots.intermediateHistName + "_" + to_str(x);
	const string inclusiveHistName = "TMP/gapPtBarInclusive_" + plots.intermediateHistName + "_" + to_str(x);
	plots._h_gapVsPtBarVeto.addHistogram(plots._gapFractionPtBarSlices[x], plots._gapFractionPtBarSlices[x+1],
	bookHisto1D(vetoHistName,refData(plots._gapFractionPtBarHistIndex+x, 1, plots.selectionType)));
	plots._h_gapVsPtBarInc.addHistogram(plots._gapFractionPtBarSlices[x], plots._gapFractionPtBarSlices[x+1],
	bookHisto1D(inclusiveHistName,refData(plots._gapFractionPtBarHistIndex+x, 1, plots.selectionType)));
	}
	}

	// Average njet vs PtBar
	if (!plots._avgNJetPtBarSlices.empty()) {
	for (size_t x=0; x<plots._avgNJetPtBarSlices.size()-1; x++) {
	plots._p_avgJetVsPtBar += bookProfile1D(plots._avgNJetPtBarHistIndex+x, 1, plots.selectionType);
	}
	}

	// Gap fraction vs Q0
	int q0PlotCount = 0;
	for (size_t x = 0; x < plots._gapFractionQ0SlicesPtBar.size()/2; x++) {
	for (size_t y = 0; y < plots._gapFractionQ0SlicesDeltaY.size()/2; y++) {
	const string vetoPtHistName = "TMP/vetoPt_" + plots.intermediateHistName + "_" + to_str(q0PlotCount);
	plots._h_vetoPt += bookHisto1D(vetoPtHistName, refData(plots._gapFractionQ0HistIndex + q0PlotCount, 1, plots.selectionType));
	plots._d_vetoPtGapFraction += bookScatter2D(plots._gapFractionQ0HistIndex + q0PlotCount, 1, plots.selectionType);
	plots._vetoPtTotalSum += 0.0; ///< @todo Can this just be replaced with _h_vetoPt.integral()?
	q0PlotCount += 1;
	}
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Get minimal list of jets needed to be considered
	double minimumJetPtBar = 50.0*GeV; // of interval defining jets

	vector<FourMomentum> acceptJets;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "AntiKtJets06").jetsByPt(20.0*GeV)) {
	+ foreach (const Jet& jet, apply<FastJets>(event, "AntiKtJets06").jetsByPt(20.0*GeV)) {
	if (jet.absrap() < 4.4) {
	acceptJets.push_back(jet.momentum());
	}
	}

	// If we can't form an interval, drop out of the analysis early
	if (acceptJets.size() < 2) vetoEvent;

	// Analyze leading jet case
	if (acceptJets[0].pT() + acceptJets[1].pT() > 2*minimumJetPtBar) {
	analyzeJets(acceptJets, _selectionPlots[0], weight, 20.0*GeV);
	}

	// Find the most forward-backward jets
	size_t minRapidityJet = 0, maxRapidityJet = 0;
	for (size_t j = 1; j < acceptJets.size(); j++) {
	if (acceptJets[j].rapidity() > acceptJets[maxRapidityJet].rapidity()) maxRapidityJet = j;
	if (acceptJets[j].rapidity() < acceptJets[minRapidityJet].rapidity()) minRapidityJet = j;
	}

	// Make a container of jet momenta with the extreme f/b jets at the front
	vector<FourMomentum> fwdBkwdJets;
	fwdBkwdJets.push_back(acceptJets[maxRapidityJet]);
	fwdBkwdJets.push_back(acceptJets[minRapidityJet]);
	for (size_t j = 0; j < acceptJets.size(); j++) {
	if (j == minRapidityJet \|\| j == maxRapidityJet) continue;
	fwdBkwdJets.push_back(acceptJets[j]);
	}

	if (fwdBkwdJets[0].pT() + fwdBkwdJets[1].pT() > 2*minimumJetPtBar) {
	// Use most forward/backward jets in rapidity to define the interval
	analyzeJets(fwdBkwdJets, _selectionPlots[1], weight, 20.0*GeV);
	// As before but now using PtBar of interval to define veto threshold
	analyzeJets(fwdBkwdJets, _selectionPlots[2], weight, (fwdBkwdJets[0].pT()+fwdBkwdJets[1].pT())/2.0);
	}
	}


	/// Fill plots!
	void analyzeJets(vector<FourMomentum>& jets, ATLAS_2011_S9126244_Plots& plots,
	const double weight, double vetoPtThreshold) {

	// Calculate the interval size, ptBar and veto Pt (if any)
	const double intervalSize = fabs(jets[0].rapidity()-jets[1].rapidity());
	const double ptBar = (jets[0].pT()+jets[1].pT())/2.0;

	const double minY = min(jets[0].rapidity(), jets[1].rapidity());
	const double maxY = max(jets[0].rapidity(), jets[1].rapidity());

	double vetoPt = 0.0*GeV;
	for (size_t j = 2; j < jets.size(); j++) {
	if (inRange(jets[j].rapidity(), minY, maxY)) vetoPt = max(jets[j].pT(), vetoPt);
	}

	// Fill the gap fraction vs delta Y histograms
	plots._h_gapVsDeltaYInc.fill(ptBar/GeV, intervalSize, weight);
	if (vetoPt < vetoPtThreshold) {
	plots._h_gapVsDeltaYVeto.fill(ptBar/GeV, intervalSize, weight);
	}

	// Fill the gap fraction vs ptBar histograms
	plots._h_gapVsPtBarInc.fill(intervalSize, ptBar/GeV, weight);
	if (vetoPt < vetoPtThreshold) {
	plots._h_gapVsPtBarVeto.fill(intervalSize, ptBar/GeV, weight);
	}

	// Count the number of veto jets present
	int vetoJetsCount = 0;
	for (size_t j = 2; j < jets.size(); j++) {
	if (inRange(jets[j].rapidity(), minY, maxY) && jets[j].pT() > vetoPtThreshold) {
	vetoJetsCount += 1;
	}
	}

	// Fill the avg NJet, deltaY slices
	if (!plots._avgNJetPtBarSlices.empty()) {
	for (size_t i = 0; i < plots._avgNJetPtBarSlices.size()-1; i++) {
	if (inRange(intervalSize, plots._avgNJetPtBarSlices[i], plots._avgNJetPtBarSlices[i+1])) {
	plots._p_avgJetVsPtBar[i]->fill(ptBar/GeV, vetoJetsCount, weight);
	}
	}
	}

	// Fill the avg NJet, ptBar slices
	if (!plots._avgNJetDeltaYSlices.empty()) {
	for (size_t i = 0; i < plots._avgNJetDeltaYSlices.size()-1; i++) {
	if (inRange(ptBar/GeV, plots._avgNJetDeltaYSlices[i], plots._avgNJetDeltaYSlices[i+1])) {
	plots._p_avgJetVsDeltaY[i]->fill(intervalSize, vetoJetsCount, weight);
	}
	}
	}

	// Fill the veto pt plots
	int q0PlotCount = 0;
	for (size_t x = 0; x < plots._gapFractionQ0SlicesPtBar.size()/2; x++) {
	for (size_t y = 0; y < plots._gapFractionQ0SlicesDeltaY.size()/2; y++) {
	// Check if it should be filled
	if ( ptBar/GeV < plots._gapFractionQ0SlicesPtBar[x*2] \|\|
	ptBar/GeV >= plots._gapFractionQ0SlicesPtBar[x*2+1] ) {
	q0PlotCount++;
	continue;
	}

	if ( intervalSize < plots._gapFractionQ0SlicesDeltaY[y*2] \|\|
	intervalSize >= plots._gapFractionQ0SlicesDeltaY[y*2+1] ) {
	q0PlotCount++;
	continue;
	}

	plots._h_vetoPt[q0PlotCount]->fill(vetoPt, weight);
	plots._vetoPtTotalSum[q0PlotCount] += weight;

	q0PlotCount++;
	}
	}
	}


	/// Derive final distributions for each selection
	void finalize() {
	foreach (const ATLAS_2011_S9126244_Plots& plots, _selectionPlots) {

	/// @todo Clean up temp histos -- requires restructuring the temp histo struct

	for (size_t x = 0; x < plots._h_gapVsDeltaYVeto.getHistograms().size(); x++) {
	divide(plots._h_gapVsDeltaYVeto.getHistograms()[x], plots._h_gapVsDeltaYInc.getHistograms()[x],
	bookScatter2D(plots._gapFractionDeltaYHistIndex+x, 1, plots.selectionType));
	}
	for (size_t x = 0; x < plots._h_gapVsPtBarVeto.getHistograms().size(); x++) {
	divide(plots._h_gapVsPtBarVeto.getHistograms()[x], plots._h_gapVsPtBarInc.getHistograms()[x],
	bookScatter2D(plots._gapFractionPtBarHistIndex+x, 1, plots.selectionType));
	}

	for (size_t h = 0; h < plots._d_vetoPtGapFraction.size(); h++) {
	finalizeQ0GapFraction(plots._vetoPtTotalSum[h], plots._d_vetoPtGapFraction[h], plots._h_vetoPt[h]);
	}
	}
	}


	/// Convert the differential histograms to an integral histo and assign binomial errors as a efficiency
	/// @todo Should be convertible to a YODA ~one-liner using toIntegralEfficiencyHisto
	void finalizeQ0GapFraction(double totalWeightSum, Scatter2DPtr gapFractionDP, Histo1DPtr vetoPtHist) {
	for (size_t i = 0; i < vetoPtHist->numBins(); ++i) {
	const double vetoPtWeightSum = vetoPtHist->integral(i); ///< Integral (with underflow) up to but not including bin i
	// Calculate the efficiency & binomial uncertainty
	const double eff = (totalWeightSum != 0) ? vetoPtWeightSum/totalWeightSum : 0;
	const double effErr = (totalWeightSum != 0) ? sqrt( eff*(1.0-eff)/totalWeightSum ) : 0;
	// get the x coord and bin width
	const double x = vetoPtHist->bin(i).xMid();
	const double xerr = 0.5*vetoPtHist->bin(i).xWidth();
	gapFractionDP->addPoint(x, eff, xerr, effErr);
	}
	}


	private:

	// Struct containing the complete set of plots, times 3 for the different selections
	ATLAS_2011_S9126244_Plots _selectionPlots[3];

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9126244);

	}
	diff --git a/src/Analyses/ATLAS_2011_S9128077.cc b/src/Analyses/ATLAS_2011_S9128077.cc
	--- a/src/Analyses/ATLAS_2011_S9128077.cc
	+++ b/src/Analyses/ATLAS_2011_S9128077.cc
	@@ -1,222 +1,222 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2011_S9128077 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_S9128077()
	: Analysis("ATLAS_2011_S9128077")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Projections
	const FinalState fs;
	FastJets j4(fs, FastJets::ANTIKT, 0.4);
	j4.useInvisibles();
	- addProjection(j4, "AntiKtJets04");
	+ declare(j4, "AntiKtJets04");
	FastJets j6(fs, FastJets::ANTIKT, 0.6);
	j6.useInvisibles();
	- addProjection(j6, "AntiKtJets06");
	+ declare(j6, "AntiKtJets06");

	// Persistent histograms
	_h_jet_multi_inclusive = bookHisto1D(1, 1, 1);
	_h_jet_multi_ratio = bookScatter2D(2, 1, 1);
	_h_jet_pT.resize(4);
	_h_jet_pT[0] = bookHisto1D(3, 1, 1);
	_h_jet_pT[1] = bookHisto1D(4, 1, 1);
	_h_jet_pT[2] = bookHisto1D(5, 1, 1);
	_h_jet_pT[3] = bookHisto1D(6, 1, 1);
	_h_HT_2 = bookHisto1D(7, 1, 1);
	_h_HT_3 = bookHisto1D(8, 1, 1);
	_h_HT_4 = bookHisto1D(9, 1, 1);
	//
	_h_pTlead_R06_60_ratio = bookScatter2D(10, 1, 1);
	_h_pTlead_R06_80_ratio = bookScatter2D(11, 1, 1);
	_h_pTlead_R06_110_ratio = bookScatter2D(12, 1, 1);
	_h_pTlead_R04_60_ratio = bookScatter2D(13, 1, 1);
	_h_pTlead_R04_80_ratio = bookScatter2D(14, 1, 1);
	_h_pTlead_R04_110_ratio = bookScatter2D(15, 1, 1);
	_h_HT2_R06_ratio = bookScatter2D(16, 1, 1);
	_h_HT2_R04_ratio = bookScatter2D(17, 1, 1);

	// Temporary histograms to be divided for the dsigma3/dsigma2 ratios
	_h_tmp_pTlead_R06_60_2 = Histo1D(refData(10, 1, 1));
	_h_tmp_pTlead_R06_80_2 = Histo1D(refData(11, 1, 1));
	_h_tmp_pTlead_R06_110_2 = Histo1D(refData(12, 1, 1));
	_h_tmp_pTlead_R06_60_3 = Histo1D(refData(10, 1, 1));
	_h_tmp_pTlead_R06_80_3 = Histo1D(refData(11, 1, 1));
	_h_tmp_pTlead_R06_110_3 = Histo1D(refData(12, 1, 1));
	//
	_h_tmp_pTlead_R04_60_2 = Histo1D(refData(13, 1, 1));
	_h_tmp_pTlead_R04_80_2 = Histo1D(refData(14, 1, 1));
	_h_tmp_pTlead_R04_110_2 = Histo1D(refData(15, 1, 1));
	_h_tmp_pTlead_R04_60_3 = Histo1D(refData(13, 1, 1));
	_h_tmp_pTlead_R04_80_3 = Histo1D(refData(14, 1, 1));
	_h_tmp_pTlead_R04_110_3 = Histo1D(refData(15, 1, 1));
	//
	_h_tmp_HT2_R06_2 = Histo1D(refData(16, 1, 1));
	_h_tmp_HT2_R06_3 = Histo1D(refData(16, 1, 1));
	_h_tmp_HT2_R04_2 = Histo1D(refData(17, 1, 1));
	_h_tmp_HT2_R04_3 = Histo1D(refData(17, 1, 1));
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	vector<FourMomentum> jets04;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(60.0*GeV)) {
	+ foreach (const Jet& jet, apply<FastJets>(event, "AntiKtJets04").jetsByPt(60.0*GeV)) {
	if (jet.abseta() < 2.8) {
	jets04.push_back(jet.momentum());
	}
	}

	if (jets04.size() > 1 && jets04[0].pT() > 80.0*GeV) {
	for (size_t i = 2; i <= jets04.size(); ++i) {
	_h_jet_multi_inclusive->fill(i, weight);
	}

	double HT = 0.0;
	for (size_t i = 0; i < jets04.size(); ++i) {
	if (i < _h_jet_pT.size()) _h_jet_pT[i]->fill(jets04[i].pT(), weight);
	HT += jets04[i].pT();
	}

	if (jets04.size() >= 2) _h_HT_2->fill(HT, weight);
	if (jets04.size() >= 3) _h_HT_3->fill(HT, weight);
	if (jets04.size() >= 4) _h_HT_4->fill(HT, weight);

	double pT1(jets04[0].pT()), pT2(jets04[1].pT());
	double HT2 = pT1 + pT2;
	if (jets04.size() >= 2) {
	_h_tmp_HT2_R04_2.fill(HT2, weight);
	_h_tmp_pTlead_R04_60_2.fill(pT1, weight);
	if (pT2 > 80.0*GeV) _h_tmp_pTlead_R04_80_2.fill(pT1, weight);
	if (pT2 > 110.0*GeV) _h_tmp_pTlead_R04_110_2.fill(pT1, weight);
	}
	if (jets04.size() >= 3) {
	double pT3(jets04[2].pT());
	_h_tmp_HT2_R04_3.fill(HT2, weight);
	_h_tmp_pTlead_R04_60_3.fill(pT1, weight);
	if (pT3 > 80.0*GeV) _h_tmp_pTlead_R04_80_3.fill(pT1, weight);
	if (pT3 > 110.0*GeV) _h_tmp_pTlead_R04_110_3.fill(pT1, weight);
	}
	}

	/// @todo It'd be better to avoid duplicating 95% of the code!
	vector<FourMomentum> jets06;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "AntiKtJets06").jetsByPt(60.0*GeV)) {
	+ foreach (const Jet& jet, apply<FastJets>(event, "AntiKtJets06").jetsByPt(60.0*GeV)) {
	if (jet.abseta() < 2.8) {
	jets06.push_back(jet.momentum());
	}
	}
	if (jets06.size() > 1 && jets06[0].pT() > 80.0*GeV) {
	double pT1(jets06[0].pT()), pT2(jets06[1].pT());
	double HT2 = pT1 + pT2;
	if (jets06.size() >= 2) {
	_h_tmp_HT2_R06_2.fill(HT2, weight);
	_h_tmp_pTlead_R06_60_2.fill(pT1, weight);
	if (pT2 > 80.0*GeV) _h_tmp_pTlead_R06_80_2.fill(pT1, weight);
	if (pT2 > 110.0*GeV) _h_tmp_pTlead_R06_110_2.fill(pT1, weight);
	}
	if (jets06.size() >= 3) {
	double pT3(jets06[2].pT());
	_h_tmp_HT2_R06_3.fill(HT2, weight);
	_h_tmp_pTlead_R06_60_3.fill(pT1, weight);
	if (pT3 > 80.0*GeV) _h_tmp_pTlead_R06_80_3.fill(pT1, weight);
	if (pT3 > 110.0*GeV) _h_tmp_pTlead_R06_110_3.fill(pT1, weight);
	}
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {

	// Fill inclusive jet multiplicity ratio
	Histo1D temphisto(refData(2, 1, 1));
	for (size_t b = 0; b < temphisto.numBins(); ++b) {
	if (_h_jet_multi_inclusive->bin(b).sumW() != 0) {
	const double x = temphisto.bin(b).xMid();
	const double ex = temphisto.bin(b).xWidth()/2.;
	const double val = _h_jet_multi_inclusive->bin(b+1).sumW() / _h_jet_multi_inclusive->bin(b).sumW();
	const double err = ( _h_jet_multi_inclusive->bin(b+1).relErr() + _h_jet_multi_inclusive->bin(b).relErr() ) * val;
	_h_jet_multi_ratio->addPoint(x, val, ex, err);
	}
	}

	// Normalize std histos
	scale(_h_jet_multi_inclusive, crossSectionPerEvent());
	scale(_h_jet_pT[0], crossSectionPerEvent());
	scale(_h_jet_pT[1], crossSectionPerEvent());
	scale(_h_jet_pT[2], crossSectionPerEvent());
	scale(_h_jet_pT[3], crossSectionPerEvent());
	scale(_h_HT_2, crossSectionPerEvent());
	scale(_h_HT_3, crossSectionPerEvent());
	scale(_h_HT_4, crossSectionPerEvent());

	/// Create ratio histograms
	divide(_h_tmp_pTlead_R06_60_3,_h_tmp_pTlead_R06_60_2, _h_pTlead_R06_60_ratio);
	divide(_h_tmp_pTlead_R06_80_3,_h_tmp_pTlead_R06_80_2, _h_pTlead_R06_80_ratio);
	divide(_h_tmp_pTlead_R06_110_3,_h_tmp_pTlead_R06_110_2, _h_pTlead_R06_110_ratio);
	divide(_h_tmp_pTlead_R04_60_3,_h_tmp_pTlead_R04_60_2, _h_pTlead_R04_60_ratio);
	divide(_h_tmp_pTlead_R04_80_3,_h_tmp_pTlead_R04_80_2, _h_pTlead_R04_80_ratio);
	divide(_h_tmp_pTlead_R04_110_3,_h_tmp_pTlead_R04_110_2, _h_pTlead_R04_110_ratio);
	divide(_h_tmp_HT2_R06_3,_h_tmp_HT2_R06_2, _h_HT2_R06_ratio);
	divide(_h_tmp_HT2_R04_3,_h_tmp_HT2_R04_2, _h_HT2_R04_ratio);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_jet_multi_inclusive;
	Scatter2DPtr _h_jet_multi_ratio;
	vector<Histo1DPtr> _h_jet_pT;
	Histo1DPtr _h_HT_2;
	Histo1DPtr _h_HT_3;
	Histo1DPtr _h_HT_4;
	//@}

	/// @name Ratio histograms
	//@{
	Scatter2DPtr _h_pTlead_R06_60_ratio, _h_pTlead_R06_80_ratio, _h_pTlead_R06_110_ratio;
	Scatter2DPtr _h_pTlead_R04_60_ratio, _h_pTlead_R04_80_ratio, _h_pTlead_R04_110_ratio;
	Scatter2DPtr _h_HT2_R06_ratio, _h_HT2_R04_ratio;
	//@}

	/// @name Temporary histograms to be divided for the dsigma3/dsigma2 ratios
	//@{
	Histo1D _h_tmp_pTlead_R06_60_2, _h_tmp_pTlead_R06_80_2, _h_tmp_pTlead_R06_110_2;
	Histo1D _h_tmp_pTlead_R06_60_3, _h_tmp_pTlead_R06_80_3, _h_tmp_pTlead_R06_110_3;
	Histo1D _h_tmp_pTlead_R04_60_2, _h_tmp_pTlead_R04_80_2, _h_tmp_pTlead_R04_110_2;
	Histo1D _h_tmp_pTlead_R04_60_3, _h_tmp_pTlead_R04_80_3, _h_tmp_pTlead_R04_110_3;
	Histo1D _h_tmp_HT2_R06_2, _h_tmp_HT2_R06_3, _h_tmp_HT2_R04_2, _h_tmp_HT2_R04_3;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9128077);


	}
	diff --git a/src/Analyses/ATLAS_2011_S9131140.cc b/src/Analyses/ATLAS_2011_S9131140.cc
	--- a/src/Analyses/ATLAS_2011_S9131140.cc
	+++ b/src/Analyses/ATLAS_2011_S9131140.cc
	@@ -1,110 +1,110 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	/// @brief ATLAS Z pT in Drell-Yan events at 7 TeV
	/// @author Elena Yatsenko, Judith Katzy
	class ATLAS_2011_S9131140 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_S9131140()
	: Analysis("ATLAS_2011_S9131140")
	{
	_sumw_el_bare = 0;
	_sumw_el_dressed = 0;
	_sumw_mu_bare = 0;
	_sumw_mu_dressed = 0;
	}


	/// @name Analysis methods
	//@{

	void init() {

	// Set up projections
	FinalState fs;
	Cut cut = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;

	ZFinder zfinder_dressed_el(fs, cut, PID::ELECTRON, 66.0GeV, 116.0GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_dressed_el, "ZFinder_dressed_el");
	+ declare(zfinder_dressed_el, "ZFinder_dressed_el");
	ZFinder zfinder_bare_el(fs, cut, PID::ELECTRON, 66.0GeV, 116.0GeV, 0.0, ZFinder::NOCLUSTER);
	- addProjection(zfinder_bare_el, "ZFinder_bare_el");
	+ declare(zfinder_bare_el, "ZFinder_bare_el");
	ZFinder zfinder_dressed_mu(fs, cut, PID::MUON, 66.0GeV, 116.0GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_dressed_mu, "ZFinder_dressed_mu");
	+ declare(zfinder_dressed_mu, "ZFinder_dressed_mu");
	ZFinder zfinder_bare_mu(fs, cut, PID::MUON, 66.0GeV, 116.0GeV, 0.0, ZFinder::NOCLUSTER);
	- addProjection(zfinder_bare_mu, "ZFinder_bare_mu");
	+ declare(zfinder_bare_mu, "ZFinder_bare_mu");

	// Book histograms
	_hist_zpt_el_dressed = bookHisto1D(1, 1, 2); // electron "dressed"
	_hist_zpt_el_bare = bookHisto1D(1, 1, 3); // electron "bare"
	_hist_zpt_mu_dressed = bookHisto1D(2, 1, 2); // muon "dressed"
	_hist_zpt_mu_bare = bookHisto1D(2, 1, 3); // muon "bare"
	}


	/// Do the analysis
	void analyze(const Event& evt) {
	const double weight = evt.weight();

	- const ZFinder& zfinder_dressed_el = applyProjection<ZFinder>(evt, "ZFinder_dressed_el");
	+ const ZFinder& zfinder_dressed_el = apply<ZFinder>(evt, "ZFinder_dressed_el");
	if (!zfinder_dressed_el.bosons().empty()) {
	_sumw_el_dressed += weight;
	const FourMomentum pZ = zfinder_dressed_el.bosons()[0].momentum();
	_hist_zpt_el_dressed->fill(pZ.pT()/GeV, weight);
	}

	- const ZFinder& zfinder_bare_el = applyProjection<ZFinder>(evt, "ZFinder_bare_el");
	+ const ZFinder& zfinder_bare_el = apply<ZFinder>(evt, "ZFinder_bare_el");
	if (!zfinder_bare_el.bosons().empty()) {
	_sumw_el_bare += weight;
	const FourMomentum pZ = zfinder_bare_el.bosons()[0].momentum();
	_hist_zpt_el_bare->fill(pZ.pT()/GeV, weight);
	}

	- const ZFinder& zfinder_dressed_mu = applyProjection<ZFinder>(evt, "ZFinder_dressed_mu");
	+ const ZFinder& zfinder_dressed_mu = apply<ZFinder>(evt, "ZFinder_dressed_mu");
	if (!zfinder_dressed_mu.bosons().empty()) {
	_sumw_mu_dressed += weight;
	const FourMomentum pZ = zfinder_dressed_mu.bosons()[0].momentum();
	_hist_zpt_mu_dressed->fill(pZ.pT()/GeV, weight);
	}

	- const ZFinder& zfinder_bare_mu = applyProjection<ZFinder>(evt, "ZFinder_bare_mu");
	+ const ZFinder& zfinder_bare_mu = apply<ZFinder>(evt, "ZFinder_bare_mu");
	if (!zfinder_bare_mu.bosons().empty()) {
	_sumw_mu_bare += weight;
	const FourMomentum pZ = zfinder_bare_mu.bosons()[0].momentum();
	_hist_zpt_mu_bare->fill(pZ.pT()/GeV, weight);
	}

	}


	void finalize() {
	if (_sumw_el_dressed != 0) scale(_hist_zpt_el_dressed, 1/_sumw_el_dressed);
	if (_sumw_el_bare != 0) scale(_hist_zpt_el_bare, 1/_sumw_el_bare);
	if (_sumw_mu_dressed != 0) scale(_hist_zpt_mu_dressed, 1/_sumw_mu_dressed);
	if (_sumw_mu_bare != 0) scale(_hist_zpt_mu_bare, 1/_sumw_mu_bare);
	}

	//@}


	private:

	double _sumw_el_bare, _sumw_el_dressed;
	double _sumw_mu_bare, _sumw_mu_dressed;

	Histo1DPtr _hist_zpt_el_dressed;
	Histo1DPtr _hist_zpt_el_bare;
	Histo1DPtr _hist_zpt_mu_dressed;
	Histo1DPtr _hist_zpt_mu_bare;
	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9131140);

	}
	diff --git a/src/Analyses/ATLAS_2011_S9212183.cc b/src/Analyses/ATLAS_2011_S9212183.cc
	--- a/src/Analyses/ATLAS_2011_S9212183.cc
	+++ b/src/Analyses/ATLAS_2011_S9212183.cc
	@@ -1,324 +1,324 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// @author Chris Wymant
	class ATLAS_2011_S9212183 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_S9212183()
	: Analysis("ATLAS_2011_S9212183")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// Projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	- addProjection(FastJets(FinalState(), FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(FinalState(), FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// All tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0), "cfs");

	// Used for pTmiss (N.B. the real 'vfs' extends beyond 4.5 to \|eta\| = 4.9)
	- addProjection(VisibleFinalState(Cuts::abseta < 4.5), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.5), "vfs");


	// Book histograms
	_count_2j = bookHisto1D("count_2j", 1, 0., 1.);
	_count_3j = bookHisto1D("count_3j", 1, 0., 1.);
	_count_4j5 = bookHisto1D("count_4j5", 1, 0., 1.);
	_count_4j10 = bookHisto1D("count_4j10", 1, 0., 1.);
	_count_HM = bookHisto1D("count_HM", 1, 0., 1.);

	_hist_meff_2j = bookHisto1D(1, 1, 1);
	_hist_meff_3j = bookHisto1D(2, 1, 1);
	_hist_meff_4j = bookHisto1D(3, 1, 1);
	_hist_meff_HM = bookHisto1D(4, 1, 1);

	_hist_eTmiss = bookHisto1D("Et_miss", 20, 0., 1000.);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	Jets cand_jets;
	- const Jets jets = applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
	+ const Jets jets = apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
	foreach (const Jet& jet, jets) {
	if ( fabs( jet.eta() ) < 4.9 ) {
	cand_jets.push_back(jet);
	}
	}

	- const Particles cand_e = applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ const Particles cand_e = apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	// Muon isolation not mentioned in hep-exp 1109.6572, unlike in 1102.5290,
	// but assumed to still be applicable
	Particles cand_mu;
	- const Particles chg_tracks = applyProjection<ChargedFinalState>(event, "cfs").particles();
	- const Particles muons = applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt();
	+ const Particles chg_tracks = apply<ChargedFinalState>(event, "cfs").particles();
	+ const Particles muons = apply<IdentifiedFinalState>(event, "muons").particlesByPt();
	foreach (const Particle& mu, muons) {
	double pTinCone = -mu.pT();
	foreach (const Particle& track, chg_tracks) {
	if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 ) {
	pTinCone += track.pT();
	}
	}
	if ( pTinCone < 1.8*GeV ) cand_mu.push_back(mu);
	}

	// Resolve jet-lepton overlap for jets with \|eta\| < 2.8
	Jets cand_jets_2;
	foreach ( const Jet& jet, cand_jets ) {
	if ( fabs( jet.eta() ) >= 2.8 ) {
	cand_jets_2.push_back( jet );
	} else {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) cand_jets_2.push_back( jet );
	}
	}


	Particles recon_e, recon_mu;

	foreach ( const Particle & e, cand_e ) {
	bool away = true;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away ) recon_e.push_back( e );
	}

	foreach ( const Particle & mu, cand_mu ) {
	bool away = true;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away ) recon_mu.push_back( mu );
	}


	// pTmiss
	// Based on all candidate electrons, muons and jets, plus everything else with \|eta\| < 4.5
	// i.e. everything in our projection "vfs" plus the jets with \|eta\| > 4.5
	- Particles vfs_particles = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ Particles vfs_particles = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( fabs( jet.eta() ) > 4.5 ) pTmiss -= jet.momentum();
	}
	double eTmiss = pTmiss.pT();


	// Final jet filter
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( fabs( jet.eta() ) <= 2.8 ) recon_jets.push_back( jet );
	}
	// NB. It seems that jets with \|eta\| > 2.8 could have been thrown away at
	// the start; we don't do so, in order to follow both the structure of
	// the paper and the similar Rivet analysis ATLAS_2011_S8983313

	// 'candidate' muons needed only 10 GeV, to cause a veto they need 20 GeV
	Particles veto_mu;
	foreach ( const Particle & mu, cand_mu ) {
	if ( mu.pT() >= 20.0*GeV ) veto_mu.push_back(mu);
	}

	if ( ! ( veto_mu.empty() && recon_e.empty() ) ) {
	MSG_DEBUG("Charged leptons left after selection");
	vetoEvent;
	}

	if ( eTmiss <= 130 * GeV ) {
	MSG_DEBUG("Not enough eTmiss: " << eTmiss << " < 130");
	vetoEvent;
	}

	if ( recon_jets.empty() \|\| recon_jets[0].pT() <= 130.0 * GeV ) {
	MSG_DEBUG("No hard leading jet in " << recon_jets.size() << " jets");
	vetoEvent;
	}

	// ==================== observables ====================

	int Njets = 0;
	double min_dPhi = 999.999;
	double pTmiss_phi = pTmiss.phi();
	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.pT() > 40 * GeV ) {
	if ( Njets < 3 ) {
	min_dPhi = min( min_dPhi, deltaPhi( pTmiss_phi, jet.phi() ) );
	}
	++Njets;
	}
	}

	int NjetsHighMass = 0;
	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.pT() > 80.0 * GeV ) {
	++NjetsHighMass;
	}
	}

	if ( Njets < 2 ) {
	MSG_DEBUG("Only " << Njets << " >40 GeV jets left");
	vetoEvent;
	}

	if ( min_dPhi <= 0.4 ) {
	MSG_DEBUG("dPhi too small");
	vetoEvent;
	}

	// m_eff
	double m_eff_2j = eTmiss + recon_jets[0].pT() + recon_jets[1].pT();
	double m_eff_3j = recon_jets.size() < 3 ? -999.0 : m_eff_2j + recon_jets[2].pT();
	double m_eff_4j = recon_jets.size() < 4 ? -999.0 : m_eff_3j + recon_jets[3].pT();
	double m_eff_HM = eTmiss;
	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.pT() > 40.0 * GeV ) m_eff_HM += jet.pT();
	}

	double et_meff_2j = eTmiss / m_eff_2j;
	double et_meff_3j = eTmiss / m_eff_3j;
	double et_meff_4j = eTmiss / m_eff_4j;
	double et_meff_HM = eTmiss / m_eff_HM;


	// ==================== FILL ====================

	MSG_DEBUG( "Trying to fill "
	<< Njets << ' '
	<< m_eff_2j << ' '
	<< et_meff_2j << ' '
	<< m_eff_3j << ' '
	<< et_meff_3j << ' '
	<< m_eff_4j << ' '
	<< et_meff_4j << ' '
	<< m_eff_HM << ' '
	<< et_meff_HM );


	_hist_eTmiss->fill(eTmiss, weight);


	// 2j region
	if ( et_meff_2j > 0.3 ) {
	_hist_meff_2j->fill(m_eff_2j, weight);
	if ( m_eff_2j > 1000 * GeV ) {
	MSG_DEBUG("Hits 2j");
	_count_2j->fill(0.5, weight);
	}
	}


	// 3j region
	if ( Njets >= 3 && et_meff_3j > 0.25 ) {
	_hist_meff_3j->fill(m_eff_3j, weight);
	if ( m_eff_3j > 1000 * GeV ) {
	MSG_DEBUG("Hits 3j");
	_count_3j->fill(0.5, weight);
	}
	}


	// 4j5 & 4j10 regions
	if ( Njets >= 4 && et_meff_4j > 0.25 ) {
	_hist_meff_4j->fill(m_eff_4j, weight);
	if ( m_eff_4j > 500 * GeV ) {
	MSG_DEBUG("Hits 4j5");
	_count_4j5->fill(0.5, weight);
	}
	if ( m_eff_4j > 1000 * GeV ) {
	MSG_DEBUG("Hits 4j10");
	_count_4j10->fill(0.5, weight);
	}
	}


	// High mass region
	if ( NjetsHighMass >= 4 && et_meff_HM > 0.2 ) {
	_hist_meff_HM->fill(m_eff_HM, weight);
	if ( m_eff_HM > 1100 * GeV ) {
	MSG_DEBUG("Hits HM");
	_count_HM->fill(0.5, weight);
	}
	}

	}


	void finalize() {
	// Two, three and four jet channels have bin width = 100 (GeV)
	// High mass channel has bin width = 150 (GeV)
	// Integrated luminosity = 1040 (pb)
	scale( _hist_meff_2j, 100. * 1040 * crossSection()/sumOfWeights() );
	scale( _hist_meff_3j, 100. * 1040 * crossSection()/sumOfWeights() );
	scale( _hist_meff_4j, 100. * 1040 * crossSection()/sumOfWeights() );
	scale( _hist_meff_HM, 150. * 1040 * crossSection()/sumOfWeights() );
	}

	//@}


	private:

	Histo1DPtr _count_2j;
	Histo1DPtr _count_3j;
	Histo1DPtr _count_4j5;
	Histo1DPtr _count_4j10;
	Histo1DPtr _count_HM;
	Histo1DPtr _hist_meff_2j;
	Histo1DPtr _hist_meff_3j;
	Histo1DPtr _hist_meff_4j;
	Histo1DPtr _hist_meff_HM;
	Histo1DPtr _hist_eTmiss;

	};


	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9212183);

	}
	diff --git a/src/Analyses/ATLAS_2011_S9212353.cc b/src/Analyses/ATLAS_2011_S9212353.cc
	--- a/src/Analyses/ATLAS_2011_S9212353.cc
	+++ b/src/Analyses/ATLAS_2011_S9212353.cc
	@@ -1,502 +1,502 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2011_S9212353 : public Analysis {
	public:

	/// Constructor
	ATLAS_2011_S9212353()
	: Analysis("ATLAS_2011_S9212353")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialize projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");


	// veto region electrons (from 2010 arXiv:1102.2357v2)
	Cut vetocut = Cuts::absetaIn(1.37, 1.52);
	IdentifiedFinalState veto_elecs(vetocut && Cuts::pT > 10*GeV);
	veto_elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(veto_elecs, "veto_elecs");
	+ declare(veto_elecs, "veto_elecs");


	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");


	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");


	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");


	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.5),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.5),"vfs");


	/// Book histograms
	_3jl_count_mu_channel = bookHisto1D("3jl_count_muon_channel", 1, 0., 1.);
	_3jl_count_e_channel = bookHisto1D("3jl_count_electron_channel", 1, 0., 1.);
	_3jt_count_mu_channel = bookHisto1D("3jt_count_muon_channel", 1, 0., 1.);
	_3jt_count_e_channel = bookHisto1D("3jt_count_electron_channel", 1, 0., 1.);
	_3j_hist_eTmiss_e = bookHisto1D("3j_Et_miss_e", 65, 0., 650.);
	_3j_hist_eTmiss_mu = bookHisto1D("3j_Et_miss_mu", 65, 0., 650.);
	_3j_hist_mT_e = bookHisto1D("3j_mT_e", 58, 0., 580.);
	_3j_hist_mT_mu = bookHisto1D("3j_mT_mu", 58, 0., 580.);
	_3j_hist_m_eff_e = bookHisto1D("3j_m_eff_e", 46, 0., 2300.);
	_3j_hist_m_eff_mu = bookHisto1D("3j_m_eff_mu", 46, 0., 2300.);
	_3jl_hist_m_eff_e_final = bookHisto1D("3jl_m_eff_e_final", 15, 0., 1500.);
	_3jl_hist_m_eff_mu_final = bookHisto1D("3jl_m_eff_mu_final", 15, 0., 1500.);
	_3jt_hist_m_eff_e_final = bookHisto1D("3jt_m_eff_e_final", 15, 0., 1500.);
	_3jt_hist_m_eff_mu_final = bookHisto1D("3jt_m_eff_mu_final", 15, 0., 1500.);


	_4jl_count_mu_channel = bookHisto1D("4jl_count_muon_channel", 1, 0., 1.);
	_4jl_count_e_channel = bookHisto1D("4jl_count_electron_channel", 1, 0., 1.);
	_4jt_count_mu_channel = bookHisto1D("4jt_count_muon_channel", 1, 0., 1.);
	_4jt_count_e_channel = bookHisto1D("4jt_count_electron_channel", 1, 0., 1.);
	_4j_hist_eTmiss_e = bookHisto1D("4j_Et_miss_e", 65, 0., 650.);
	_4j_hist_eTmiss_mu = bookHisto1D("4j_Et_miss_mu", 65, 0., 650.);
	_4j_hist_mT_e = bookHisto1D("4j_mT_e", 58, 0., 580.);
	_4j_hist_mT_mu = bookHisto1D("4j_mT_mu", 58, 0., 580.);
	_4j_hist_m_eff_e = bookHisto1D("4j_m_eff_e", 46, 0., 2300.);
	_4j_hist_m_eff_mu = bookHisto1D("4j_m_eff_mu", 46, 0., 2300.);
	_4jl_hist_m_eff_e_final = bookHisto1D("4jl_m_eff_e_final", 15, 0., 1500.);
	_4jl_hist_m_eff_mu_final = bookHisto1D("4jl_m_eff_mu_final", 15, 0., 1500.);
	_4jt_hist_m_eff_e_final = bookHisto1D("4jt_m_eff_e_final", 15, 0., 1500.);
	_4jt_hist_m_eff_mu_final = bookHisto1D("4jt_m_eff_mu_final", 15, 0., 1500.);


	}



	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	Particles veto_e
	- = applyProjection<IdentifiedFinalState>(event, "veto_elecs").particles();
	+ = apply<IdentifiedFinalState>(event, "veto_elecs").particles();
	if ( ! veto_e.empty() ) {
	MSG_DEBUG("electrons in veto region");
	vetoEvent;
	}

	Jets cand_jets;
	foreach ( const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	cand_jets.push_back(jet);
	}
	}

	Particles candtemp_e =
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt();
	Particles candtemp_mu =
	- applyProjection<IdentifiedFinalState>(event,"muons").particlesByPt();
	+ apply<IdentifiedFinalState>(event,"muons").particlesByPt();
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	Particles cand_mu;
	Particles cand_e;


	// pTcone around muon track
	foreach ( const Particle & mu, candtemp_mu ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	cand_mu.push_back(mu);
	}

	// pTcone around electron
	foreach ( const Particle e, candtemp_e ) {
	double pTinCone = -e.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 0.1 * e.pT() )
	cand_e.push_back(e);
	}

	// discard jets that overlap with electrons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e )
	recon_jets.push_back( jet );
	}

	// only consider leptons far from jet
	Particles recon_e, recon_mu;
	foreach ( const Particle & e, cand_e ) {
	bool e_near_jet = false;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 &&
	deltaR(e.momentum(),jet.momentum()) > 0.2 )
	e_near_jet = true;
	}
	if ( ! e_near_jet )
	recon_e.push_back( e );
	}

	foreach ( const Particle & mu, cand_mu ) {
	bool mu_near_jet = false;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 )
	mu_near_jet = true;
	}
	if ( ! mu_near_jet )
	recon_mu.push_back( mu );
	}

	// pTmiss
	Particles vfs_particles
	- = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();


	// ==================== observables ====================


	// Njets
	int Njets = 0;
	double pTmiss_phi = pTmiss.phi();
	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.abseta() < 2.8 )
	Njets+=1;
	}
	if ( Njets < 3 ) {
	MSG_DEBUG("Only " << Njets << " jets w/ eta<2.8 left");
	vetoEvent;
	}

	Particles lepton;
	if ( recon_mu.empty() && recon_e.empty() ) {
	MSG_DEBUG("No leptons");
	vetoEvent;
	}
	else {
	foreach ( const Particle & mu, recon_mu )
	lepton.push_back(mu);
	foreach ( const Particle & e, recon_e )
	lepton.push_back(e);
	}


	std::sort(lepton.begin(), lepton.end(), cmpMomByPt);

	double e_id = 11;
	double mu_id = 13;

	// one hard leading lepton cut
	if ( lepton[0].abspid() == e_id &&
	lepton[0].pT() <= 25*GeV ) {
	vetoEvent;
	}
	else if ( lepton[0].abspid() == mu_id &&
	lepton[0].pT() <= 20*GeV ) {
	vetoEvent;
	}

	// exactly one hard leading lepton cut
	if(lepton.size()>1) {
	if ( lepton[1].abspid() == e_id &&
	lepton[1].pT() > 20*GeV ) {
	vetoEvent;
	}
	else if ( lepton[1].abspid() == mu_id &&
	lepton[1].pT() > 10*GeV ) {
	vetoEvent;
	}
	}

	// 3JL
	if ( recon_jets[0].pT() > 60.0*GeV &&
	recon_jets[1].pT() > 25.0*GeV &&
	recon_jets[2].pT() > 25.0*GeV &&
	deltaPhi( pTmiss_phi, recon_jets[0].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[1].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[2].phi() ) > 0.2 ) {

	FourMomentum pT_l = lepton[0].momentum();
	double dPhi = deltaPhi( pT_l.phi(), pTmiss_phi);
	double mT = sqrt( 2 * pT_l.pT() * eTmiss * (1 - cos(dPhi)) );
	double m_eff = eTmiss + pT_l.pT()
	+ recon_jets[0].pT()
	+ recon_jets[1].pT()
	+ recon_jets[2].pT();

	if ( lepton[0].abspid() == e_id ) {
	_3j_hist_mT_e->fill(mT, weight);
	_3j_hist_eTmiss_e->fill(eTmiss, weight);
	_3j_hist_m_eff_e->fill(m_eff, weight);
	if ( mT > 100GeV && eTmiss > 125GeV ) {
	_3jl_hist_m_eff_e_final->fill(m_eff, weight);
	if ( m_eff > 500GeV && eTmiss > 0.25m_eff ) {
	_3jl_count_e_channel->fill(0.5,weight);
	}
	}
	}

	else if ( lepton[0].abspid() == mu_id ) {
	_3j_hist_mT_mu->fill(mT, weight);
	_3j_hist_eTmiss_mu->fill(eTmiss, weight);
	_3j_hist_m_eff_mu->fill(m_eff, weight);
	if ( mT > 100GeV && eTmiss > 125GeV ) {
	_3jl_hist_m_eff_mu_final->fill(m_eff, weight);
	if ( m_eff > 500GeV && eTmiss > 0.25m_eff ) {
	_3jl_count_mu_channel->fill(0.5,weight);
	}
	}
	}

	}

	// 3JT
	if ( recon_jets[0].pT() > 80.0*GeV &&
	recon_jets[1].pT() > 25.0*GeV &&
	recon_jets[2].pT() > 25.0*GeV &&
	deltaPhi( pTmiss_phi, recon_jets[0].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[1].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[2].phi() ) > 0.2 ) {

	FourMomentum pT_l = lepton[0].momentum();
	double dPhi = deltaPhi( pT_l.phi(), pTmiss_phi);
	double mT = sqrt( 2 * pT_l.pT() * eTmiss * (1 - cos(dPhi)) );
	double m_eff = eTmiss + pT_l.pT()
	+ recon_jets[0].pT()
	+ recon_jets[1].pT()
	+ recon_jets[2].pT();


	if ( lepton[0].abspid() == e_id ) {
	if ( mT > 100GeV && eTmiss > 240GeV ) {
	_3jt_hist_m_eff_e_final->fill(m_eff, weight);
	if ( m_eff > 600GeV && eTmiss > 0.15m_eff ) {
	_3jt_count_e_channel->fill(0.5,weight);
	}
	}
	}

	else if ( lepton[0].abspid() == mu_id ) {
	if ( mT > 100GeV && eTmiss > 240GeV ) {
	_3jt_hist_m_eff_mu_final->fill(m_eff, weight);
	if ( m_eff > 600GeV && eTmiss > 0.15m_eff ) {
	_3jt_count_mu_channel->fill(0.5,weight);
	}
	}
	}

	}

	if ( Njets < 4 ) {
	MSG_DEBUG("Only " << Njets << " jets w/ eta<2.8 left");
	vetoEvent;
	}



	// 4JL
	if ( recon_jets[0].pT() > 60.0*GeV &&
	recon_jets[1].pT() > 25.0*GeV &&
	recon_jets[2].pT() > 25.0*GeV &&
	recon_jets[3].pT() > 25.0*GeV &&
	deltaPhi( pTmiss_phi, recon_jets[0].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[1].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[2].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[3].phi() ) > 0.2 ) {

	FourMomentum pT_l = lepton[0].momentum();
	double dPhi = deltaPhi( pT_l.phi(), pTmiss_phi);
	double mT = sqrt( 2 * pT_l.pT() * eTmiss * (1 - cos(dPhi)) );
	double m_eff = eTmiss + pT_l.pT()
	+ recon_jets[0].pT()
	+ recon_jets[1].pT()
	+ recon_jets[2].pT()
	+ recon_jets[3].pT();


	if ( lepton[0].abspid() == e_id ) {
	_4j_hist_mT_e->fill(mT, weight);
	_4j_hist_eTmiss_e->fill(eTmiss, weight);
	_4j_hist_m_eff_e->fill(m_eff, weight);
	if ( mT > 100GeV && eTmiss > 140GeV ) {
	_4jl_hist_m_eff_e_final->fill(m_eff, weight);
	if ( m_eff > 300GeV && eTmiss > 0.3m_eff ) {
	_4jl_count_e_channel->fill(0.5,weight);
	}
	}
	}

	// Muon channel signal region
	else if ( lepton[0].abspid() == mu_id ) {
	_4j_hist_mT_mu->fill(mT, weight);
	_4j_hist_eTmiss_mu->fill(eTmiss, weight);
	_4j_hist_m_eff_mu->fill(m_eff, weight);
	if ( mT > 100GeV && eTmiss > 140GeV ) {
	_4jl_hist_m_eff_mu_final->fill(m_eff, weight);
	if ( m_eff > 300GeV && eTmiss > 0.3m_eff ) {
	_4jl_count_mu_channel->fill(0.5,weight);
	}
	}
	}

	}

	// 4JT
	if ( recon_jets[0].pT() > 60.0*GeV &&
	recon_jets[1].pT() > 40.0*GeV &&
	recon_jets[2].pT() > 40.0*GeV &&
	recon_jets[3].pT() > 40.0*GeV &&
	deltaPhi( pTmiss_phi, recon_jets[0].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[1].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[2].phi() ) > 0.2 &&
	deltaPhi( pTmiss_phi, recon_jets[3].phi() ) > 0.2 ) {

	FourMomentum pT_l = lepton[0].momentum();

	double m_eff = eTmiss + pT_l.pT()
	+ recon_jets[0].pT()
	+ recon_jets[1].pT()
	+ recon_jets[2].pT()
	+ recon_jets[3].pT();


	if ( lepton[0].abspid() == e_id ) {
	if ( eTmiss > 200*GeV ) {
	_4jt_hist_m_eff_e_final->fill(m_eff, weight);
	if ( m_eff > 500GeV && eTmiss > 0.15m_eff ) {
	_4jt_count_e_channel->fill(0.5,weight);
	}
	}
	}

	// Muon channel signal region
	else if ( lepton[0].abspid() == mu_id ) {
	if ( eTmiss > 200*GeV ) {
	_4jt_hist_m_eff_mu_final->fill(m_eff, weight);
	if ( m_eff > 500GeV && eTmiss > 0.15m_eff ) {
	_4jt_count_mu_channel->fill(0.5,weight);
	}
	}
	}

	}
	}

	//@}


	void finalize() {

	scale( _3j_hist_eTmiss_e, 10. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _3j_hist_eTmiss_mu, 10. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _3j_hist_m_eff_e, 50. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _3j_hist_m_eff_mu, 50. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _3j_hist_mT_e, 10. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _3j_hist_mT_mu, 10. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _3jl_hist_m_eff_e_final, 100. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _3jl_hist_m_eff_mu_final, 100. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _3jt_hist_m_eff_e_final, 100. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _3jt_hist_m_eff_mu_final, 100. * 1.04e3 * crossSection()/sumOfWeights() );

	scale( _4j_hist_eTmiss_e, 10. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _4j_hist_eTmiss_mu, 10. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _4j_hist_m_eff_e, 50. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _4j_hist_m_eff_mu, 50. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _4j_hist_mT_e, 10. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _4j_hist_mT_mu, 10. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _4jl_hist_m_eff_e_final, 100. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _4jl_hist_m_eff_mu_final, 100. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _4jt_hist_m_eff_e_final, 100. * 1.04e3 * crossSection()/sumOfWeights() );
	scale( _4jt_hist_m_eff_mu_final, 100. * 1.04e3 * crossSection()/sumOfWeights() );


	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _3jl_count_e_channel;
	Histo1DPtr _3jl_count_mu_channel;
	Histo1DPtr _3jt_count_e_channel;
	Histo1DPtr _3jt_count_mu_channel;
	Histo1DPtr _3j_hist_eTmiss_e;
	Histo1DPtr _3j_hist_eTmiss_mu;
	Histo1DPtr _3j_hist_m_eff_e;
	Histo1DPtr _3j_hist_m_eff_mu;
	Histo1DPtr _3j_hist_mT_e;
	Histo1DPtr _3j_hist_mT_mu;
	Histo1DPtr _3jl_hist_m_eff_e_final;
	Histo1DPtr _3jl_hist_m_eff_mu_final;
	Histo1DPtr _3jt_hist_m_eff_e_final;
	Histo1DPtr _3jt_hist_m_eff_mu_final;



	Histo1DPtr _4jl_count_e_channel;
	Histo1DPtr _4jl_count_mu_channel;
	Histo1DPtr _4jt_count_e_channel;
	Histo1DPtr _4jt_count_mu_channel;
	Histo1DPtr _4j_hist_eTmiss_e;
	Histo1DPtr _4j_hist_eTmiss_mu;
	Histo1DPtr _4j_hist_m_eff_e;
	Histo1DPtr _4j_hist_m_eff_mu;
	Histo1DPtr _4j_hist_mT_e;
	Histo1DPtr _4j_hist_mT_mu;
	Histo1DPtr _4jl_hist_m_eff_e_final;
	Histo1DPtr _4jl_hist_m_eff_mu_final;
	Histo1DPtr _4jt_hist_m_eff_e_final;
	Histo1DPtr _4jt_hist_m_eff_mu_final;


	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9212353);

	}
	diff --git a/src/Analyses/ATLAS_2011_S9225137.cc b/src/Analyses/ATLAS_2011_S9225137.cc
	--- a/src/Analyses/ATLAS_2011_S9225137.cc
	+++ b/src/Analyses/ATLAS_2011_S9225137.cc
	@@ -1,432 +1,432 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	class ATLAS_2011_S9225137 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2011_S9225137()
	: Analysis("ATLAS_2011_S9225137")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// veto region electrons
	Cut vetocut = Cuts::absetaIn(1.37, 1.52);
	IdentifiedFinalState veto_elecs(vetocut && Cuts::pT > 10*GeV);
	veto_elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(veto_elecs, "veto_elecs");
	+ declare(veto_elecs, "veto_elecs");

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9), "vfs");

	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);

	/// Jet finder
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3), "cfs");

	/// Book histograms
	_etmisspT_55_NJ_6_obs = bookHisto1D( 1,1,1);
	_etmisspT_55_NJ_6_bac = bookHisto1D( 1,1,2);
	_etmisspT_55_NJ_6_sig = bookHisto1D( 1,1,3);
	_etmisspT_55_NJ_7_obs = bookHisto1D(13,1,1);
	_etmisspT_55_NJ_7_bac = bookHisto1D(13,1,2);
	_etmisspT_55_NJ_7_sig = bookHisto1D(13,1,3);
	_etmisspT_55_NJ_8_obs = bookHisto1D(15,1,1);
	_etmisspT_55_NJ_8_bac = bookHisto1D(15,1,2);
	_etmisspT_55_NJ_8_sig = bookHisto1D(15,1,3);
	_etmisspT_80_NJ_5_obs = bookHisto1D( 2,1,1);
	_etmisspT_80_NJ_5_bac = bookHisto1D( 2,1,2);
	_etmisspT_80_NJ_5_sig = bookHisto1D( 2,1,3);
	_etmisspT_80_NJ_6_obs = bookHisto1D(14,1,1);
	_etmisspT_80_NJ_6_bac = bookHisto1D(14,1,2);
	_etmisspT_80_NJ_6_sig = bookHisto1D(14,1,3);
	_etmisspT_80_NJ_7_obs = bookHisto1D(16,1,1);
	_etmisspT_80_NJ_7_bac = bookHisto1D(16,1,2);
	_etmisspT_80_NJ_7_sig = bookHisto1D(16,1,3);

	_njet55A_obs = bookHisto1D( 3,1,1);
	_njet55A_bac = bookHisto1D( 3,1,2);
	_njet55A_sig = bookHisto1D( 3,1,3);
	_njet55B_obs = bookHisto1D( 4,1,1);
	_njet55B_bac = bookHisto1D( 4,1,2);
	_njet55B_sig = bookHisto1D( 4,1,3);
	_njet55C_obs = bookHisto1D(17,1,1);
	_njet55C_bac = bookHisto1D(17,1,2);
	_njet55C_sig = bookHisto1D(17,1,3);
	_njet80A_obs = bookHisto1D( 5,1,1);
	_njet80A_bac = bookHisto1D( 5,1,2);
	_njet80A_sig = bookHisto1D( 5,1,3);
	_njet80B_obs = bookHisto1D( 6,1,1);
	_njet80B_bac = bookHisto1D( 6,1,2);
	_njet80B_sig = bookHisto1D( 6,1,3);
	_njet80C_obs = bookHisto1D(18,1,1);
	_njet80C_bac = bookHisto1D(18,1,2);
	_njet80C_sig = bookHisto1D(18,1,3);

	_count_7j55 = bookHisto1D("count_7j55", 1, 0., 1.);
	_count_8j55 = bookHisto1D("count_8j55", 1, 0., 1.);
	_count_6j80 = bookHisto1D("count_6j80", 1, 0., 1.);
	_count_7j80 = bookHisto1D("count_7j80", 1, 0., 1.);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	// apply electron veto region
	Particles veto_e
	- = applyProjection<IdentifiedFinalState>(event, "veto_elecs").particles();
	+ = apply<IdentifiedFinalState>(event, "veto_elecs").particles();
	if ( ! veto_e.empty() ) {
	MSG_DEBUG("electrons in veto region");
	vetoEvent;
	}

	// get the jet candidates
	Jets cand_jets;
	foreach (const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 4.9 ) {
	cand_jets.push_back(jet);
	}
	}

	// candidate muons
	Particles cand_mu;
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	foreach ( const Particle & mu,
	- applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	+ apply<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	cand_mu.push_back(mu);
	}

	// candidate electrons

	Particles cand_e =
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	// resolve jet/lepton ambiguity
	Jets cand_jets_2;
	foreach ( const Jet& jet, cand_jets ) {
	// candidates above eta=2.8 are jets
	if ( fabs( jet.eta() ) >= 2.8 )
	cand_jets_2.push_back( jet );
	// otherwise more the R=0.2 from an electrons
	else {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e )
	cand_jets_2.push_back( jet );
	}
	}

	// only keep electrons more than R=0.4 from jets
	Particles recon_e;
	foreach ( const Particle & e, cand_e ) {
	bool away = true;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away )
	recon_e.push_back( e );
	}

	// only keep muons more than R=0.4 from jets
	Particles recon_mu;
	foreach ( const Particle & mu, cand_mu ) {
	bool away = true;
	foreach ( const Jet& jet, cand_jets_2 ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away ) recon_mu.push_back( mu );
	}

	// pTmiss
	Particles vfs_particles =
	- applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// final jet filter
	Jets recon_jets;
	foreach (const Jet& jet, cand_jets_2) {
	if (jet.abseta() <= 2.8 ) recon_jets.push_back( jet );
	}

	// now only use recon_jets, recon_mu, recon_e

	// reject events with electrons and muons
	if ( ! ( recon_mu.empty() && recon_e.empty() ) ) {
	MSG_DEBUG("Charged leptons left after selection");
	vetoEvent;
	}

	// calculate H_T
	double HT = 0;
	foreach (const Jet& jet, recon_jets) {
	if (jet.pT() > 40*GeV) HT += jet.pT() ;
	}

	// number of jets and deltaR
	bool pass55DeltaR=true, pass80DeltaR=true;
	size_t njet55=0, njet80=0;
	for (size_t ix=0; ix < recon_jets.size(); ++ix) {
	if (recon_jets[ix].pT() > 80*GeV) ++njet80;
	if (recon_jets[ix].pT() > 55*GeV) ++njet55;
	for (size_t iy = ix + 1; iy < recon_jets.size(); ++iy) {
	if (recon_jets[ix].pT() > 55*GeV &&
	recon_jets[iy].pT() > 55*GeV &&
	deltaR(recon_jets[ix], recon_jets[iy]) < 0.6)
	pass55DeltaR = false;
	// if (recon_jets[ix].pT() > 80*GeV &&
	// recon_jets[iy].pT() > 80*GeV &&
	// deltaR(recon_jets[ix], recon_jets[iy]) < 0.6)
	// pass80DeltaR = false;
	}
	}

	// require at least four jets with et > 55
	if (njet55 <= 3) vetoEvent;

	// plots of etmiss/ht
	double etht = eTmiss/sqrt(HT);
	if (njet55 == 6) {
	_etmisspT_55_NJ_6_obs->fill(etht,weight);
	_etmisspT_55_NJ_6_bac->fill(etht,weight);
	_etmisspT_55_NJ_6_sig->fill(etht,weight);
	} else if (njet55 == 7) {
	_etmisspT_55_NJ_7_obs->fill(etht,weight);
	_etmisspT_55_NJ_7_bac->fill(etht,weight);
	_etmisspT_55_NJ_7_sig->fill(etht,weight);
	} else if (njet55 == 8) {
	_etmisspT_55_NJ_8_obs->fill(etht,weight);
	_etmisspT_55_NJ_8_bac->fill(etht,weight);
	_etmisspT_55_NJ_8_sig->fill(etht,weight);
	}
	if (njet80 == 5) {
	_etmisspT_80_NJ_5_obs->fill(etht,weight);
	_etmisspT_80_NJ_5_bac->fill(etht,weight);
	_etmisspT_80_NJ_5_sig->fill(etht,weight);
	} else if (njet80 == 6) {
	_etmisspT_80_NJ_6_obs->fill(etht,weight);
	_etmisspT_80_NJ_6_bac->fill(etht,weight);
	_etmisspT_80_NJ_6_sig->fill(etht,weight);
	} else if (njet80 == 7) {
	_etmisspT_80_NJ_7_obs->fill(etht,weight);
	_etmisspT_80_NJ_7_bac->fill(etht,weight);
	_etmisspT_80_NJ_7_sig->fill(etht,weight);
	}

	if (etht > 1.5 && etht < 2.) {
	if (njet55 > 3) {
	_njet55A_obs->fill(njet55,weight);
	_njet55A_bac->fill(njet55,weight);
	_njet55A_sig->fill(njet55,weight);
	}
	if (njet80 > 3) {
	_njet80A_obs->fill(njet80,weight);
	_njet80A_bac->fill(njet80,weight);
	_njet80A_sig->fill(njet80,weight);
	}
	} else if (etht > 2. && etht < 3.) {
	if (njet55 > 3) {
	_njet55B_obs->fill(njet55,weight);
	_njet55B_bac->fill(njet55,weight);
	_njet55B_sig->fill(njet55,weight);
	}
	if (njet80 > 3) {
	_njet80B_obs->fill(njet80,weight);
	_njet80B_bac->fill(njet80,weight);
	_njet80B_sig->fill(njet80,weight);
	}
	} else {
	if (njet55 > 3) {
	_njet55C_obs->fill(njet55,weight);
	_njet55C_bac->fill(njet55,weight);
	_njet55C_sig->fill(njet55,weight);
	}
	if (njet80 > 3) {
	_njet80C_obs->fill(njet80,weight);
	_njet80C_bac->fill(njet80,weight);
	_njet80C_sig->fill(njet80,weight);
	}
	}

	// apply E_T/sqrt(H_T) cut
	if (etht <= 3.5*GeV) {
	MSG_DEBUG("Fails ET/sqrt(HT) cut ");
	vetoEvent;
	}

	// check passes at least one delta5/ njet number cut
	if (!(pass55DeltaR && njet55 >= 7) && !(pass80DeltaR && njet80 >= 6) ) {
	MSG_DEBUG("Fails DeltaR cut or jet number cuts");
	vetoEvent;
	}

	// 7j55
	if (njet55 >= 7 && pass55DeltaR) _count_7j55->fill( 0.5, weight);
	// 8j55
	if (njet55 >= 8 && pass55DeltaR) _count_8j55->fill( 0.5, weight);
	// 6j80
	if (njet80 >= 6 && pass80DeltaR) _count_6j80->fill( 0.5, weight);
	// 7j80
	if (njet80 >= 7 && pass80DeltaR) _count_7j80->fill( 0.5, weight);
	}

	//@}

	void finalize() {
	const double norm = crossSection()/femtobarn*1.34/sumOfWeights();
	scale(_etmisspT_55_NJ_6_obs,norm);
	scale(_etmisspT_55_NJ_6_bac,norm);
	scale(_etmisspT_55_NJ_6_sig,norm);
	scale(_etmisspT_55_NJ_7_obs,norm);
	scale(_etmisspT_55_NJ_7_bac,norm);
	scale(_etmisspT_55_NJ_7_sig,norm);
	scale(_etmisspT_55_NJ_8_obs,norm);
	scale(_etmisspT_55_NJ_8_bac,norm);
	scale(_etmisspT_55_NJ_8_sig,norm);
	scale(_etmisspT_80_NJ_5_obs,norm);
	scale(_etmisspT_80_NJ_5_bac,norm);
	scale(_etmisspT_80_NJ_5_sig,norm);
	scale(_etmisspT_80_NJ_6_obs,norm);
	scale(_etmisspT_80_NJ_6_bac,norm);
	scale(_etmisspT_80_NJ_6_sig,norm);
	scale(_etmisspT_80_NJ_7_obs,norm);
	scale(_etmisspT_80_NJ_7_bac,norm);
	scale(_etmisspT_80_NJ_7_sig,norm);
	scale(_njet55A_obs,norm);
	scale(_njet55A_bac,norm);
	scale(_njet55A_sig,norm);
	scale(_njet55B_obs,norm);
	scale(_njet55B_bac,norm);
	scale(_njet55B_sig,norm);
	scale(_njet55C_obs,norm);
	scale(_njet55C_bac,norm);
	scale(_njet55C_sig,norm);
	scale(_njet80A_obs,norm);
	scale(_njet80A_bac,norm);
	scale(_njet80A_sig,norm);
	scale(_njet80B_obs,norm);
	scale(_njet80B_bac,norm);
	scale(_njet80B_sig,norm);
	scale(_njet80C_obs,norm);
	scale(_njet80C_bac,norm);
	scale(_njet80C_sig,norm);
	scale(_count_7j55,norm);
	scale(_count_8j55,norm);
	scale(_count_6j80,norm);
	scale(_count_7j80,norm);
	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _etmisspT_55_NJ_6_obs;
	Histo1DPtr _etmisspT_55_NJ_6_bac;
	Histo1DPtr _etmisspT_55_NJ_6_sig;
	Histo1DPtr _etmisspT_55_NJ_7_obs;
	Histo1DPtr _etmisspT_55_NJ_7_bac;
	Histo1DPtr _etmisspT_55_NJ_7_sig;
	Histo1DPtr _etmisspT_55_NJ_8_obs;
	Histo1DPtr _etmisspT_55_NJ_8_bac;
	Histo1DPtr _etmisspT_55_NJ_8_sig;
	Histo1DPtr _etmisspT_80_NJ_5_obs;
	Histo1DPtr _etmisspT_80_NJ_5_bac;
	Histo1DPtr _etmisspT_80_NJ_5_sig;
	Histo1DPtr _etmisspT_80_NJ_6_obs;
	Histo1DPtr _etmisspT_80_NJ_6_bac;
	Histo1DPtr _etmisspT_80_NJ_6_sig;
	Histo1DPtr _etmisspT_80_NJ_7_obs;
	Histo1DPtr _etmisspT_80_NJ_7_bac;
	Histo1DPtr _etmisspT_80_NJ_7_sig;
	Histo1DPtr _njet55A_obs;
	Histo1DPtr _njet55A_bac;
	Histo1DPtr _njet55A_sig;
	Histo1DPtr _njet55B_obs;
	Histo1DPtr _njet55B_bac;
	Histo1DPtr _njet55B_sig;
	Histo1DPtr _njet55C_obs;
	Histo1DPtr _njet55C_bac;
	Histo1DPtr _njet55C_sig;
	Histo1DPtr _njet80A_obs;
	Histo1DPtr _njet80A_bac;
	Histo1DPtr _njet80A_sig;
	Histo1DPtr _njet80B_obs;
	Histo1DPtr _njet80B_bac;
	Histo1DPtr _njet80B_sig;
	Histo1DPtr _njet80C_obs;
	Histo1DPtr _njet80C_bac;
	Histo1DPtr _njet80C_sig;
	Histo1DPtr _count_7j55;
	Histo1DPtr _count_8j55;
	Histo1DPtr _count_6j80;
	Histo1DPtr _count_7j80;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2011_S9225137);

	}
	diff --git a/src/Analyses/ATLAS_2012_CONF_2012_001.cc b/src/Analyses/ATLAS_2012_CONF_2012_001.cc
	--- a/src/Analyses/ATLAS_2012_CONF_2012_001.cc
	+++ b/src/Analyses/ATLAS_2012_CONF_2012_001.cc
	@@ -1,395 +1,395 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	/// @author Peter Richardson
	class ATLAS_2012_CONF_2012_001 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_CONF_2012_001()
	: Analysis("ATLAS_2012_CONF_2012_001")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 10*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");

	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);

	/// Jet finder
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0),"cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0),"cfs");

	// Book histograms
	_hist_leptonpT.push_back(bookHisto1D(1,1,1));
	_hist_leptonpT.push_back(bookHisto1D(2,1,1));
	_hist_leptonpT.push_back(bookHisto1D(3,1,1));
	_hist_leptonpT.push_back(bookHisto1D(4,1,1));
	_hist_njet = bookHisto1D(5,1,1);
	_hist_etmiss = bookHisto1D(6,1,1);
	_hist_mSFOS = bookHisto1D(7,1,1);
	_hist_meff = bookHisto1D(8,1,1);

	_hist_leptonpT_MC.push_back(bookHisto1D("hist_lepton_pT_1", 26, 0., 260));
	_hist_leptonpT_MC.push_back(bookHisto1D("hist_lepton_pT_2", 15, 0., 150));
	_hist_leptonpT_MC.push_back(bookHisto1D("hist_lepton_pT_3", 20, 0., 100));
	_hist_leptonpT_MC.push_back(bookHisto1D("hist_lepton_pT_4", 20, 0., 100));
	_hist_njet_MC = bookHisto1D("hist_njet", 7, -0.5, 6.5);
	_hist_etmiss_MC = bookHisto1D("hist_etmiss",11,0.,220.);
	_hist_mSFOS_MC = bookHisto1D("hist_m_SFOS",13,0.,260.);
	_hist_meff_MC = bookHisto1D("hist_m_eff",19,0.,950.);

	_count_SR1 = bookHisto1D("count_SR1", 1, 0., 1.);
	_count_SR2 = bookHisto1D("count_SR2", 1, 0., 1.);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	// get the jet candidates
	Jets cand_jets;
	foreach (const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	cand_jets.push_back(jet);
	}
	}

	// candidate muons
	Particles cand_mu;
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	foreach ( const Particle & mu,
	- applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	+ apply<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	cand_mu.push_back(mu);
	}

	// candidate electrons
	Particles cand_e;
	foreach ( const Particle & e,
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt() ) {
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt() ) {
	double eta = e.eta();
	// remove electrons with pT<15 in old veto region
	if( fabs(eta)>1.37 && fabs(eta) < 1.52 && e.perp()< 15.*GeV)
	continue;
	double pTinCone = -e.perp();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if (pTinCone/e.perp()<0.1) {
	cand_e.push_back(e);
	}
	}

	// resolve jet/lepton ambiguity
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e )
	recon_jets.push_back( jet );
	}

	// only keep electrons more than R=0.4 from jets
	Particles cand2_e;
	for(unsigned int ie=0;ie<cand_e.size();++ie) {
	const Particle & e = cand_e[ie];
	// at least 0.4 from any jets
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	// and 0.1 from any muons
	if ( away ) {
	foreach ( const Particle & mu, cand_mu ) {
	if ( deltaR(mu.momentum(),e.momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	}
	// and 0.1 from electrons
	for(unsigned int ie2=0;ie2<cand_e.size();++ie2) {
	if(ie==ie2) continue;
	if ( deltaR(e.momentum(),cand_e[ie2].momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	// if isolated keep it
	if ( away ) cand2_e.push_back( e );
	}
	// remove e+e- pairs with mass < 20.
	Particles recon_e;
	for(unsigned int ie=0;ie<cand2_e.size();++ie) {
	bool pass = true;
	for(unsigned int ie2=0;ie2<cand2_e.size();++ie2) {
	if(cand2_e[ie].pid()*cand2_e[ie2].pid()>0) continue;
	double mtest = (cand2_e[ie].momentum()+cand2_e[ie2].momentum()).mass();
	if(mtest<=20.) {
	pass = false;
	break;
	}
	}
	if(pass) recon_e.push_back(cand2_e[ie]);
	}

	// only keep muons more than R=0.4 from jets
	Particles cand2_mu;
	for(unsigned int imu=0;imu<cand_mu.size();++imu) {
	const Particle & mu = cand_mu[imu];
	bool away = true;
	// at least 0.4 from any jets
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	// and 0.1 from any electrona
	if ( away ) {
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(mu.momentum(),e.momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	}
	// and 0.1 from muons
	for(unsigned int imu2=0;imu2<cand_mu.size();++imu2) {
	if(imu==imu2) continue;
	if ( deltaR(mu.momentum(),cand_mu[imu2].momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	if ( away )
	cand2_mu.push_back( mu );
	}

	// remove mu+mu- pairs with mass < 20.
	Particles recon_mu;
	for(unsigned int imu=0;imu<cand2_mu.size();++imu) {
	bool pass = true;
	for(unsigned int imu2=0;imu2<cand2_mu.size();++imu2) {
	if(cand2_mu[imu].pid()*cand2_mu[imu2].pid()>0) continue;
	double mtest = (cand2_mu[imu].momentum()+cand2_mu[imu2].momentum()).mass();
	if(mtest<=20.) {
	pass = false;
	break;
	}
	}
	if(pass) recon_mu.push_back(cand2_mu[imu]);
	}

	// pTmiss
	Particles vfs_particles =
	- applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// now only use recon_jets, recon_mu, recon_e

	// reject events with less than 4 electrons and muons
	if ( recon_mu.size() + recon_e.size() < 4 ) {
	MSG_DEBUG("To few charged leptons left after selection");
	vetoEvent;
	}

	// ATLAS calo problem
	if(rand()/static_cast<double>(RAND_MAX)<=0.42) {
	foreach ( const Particle & e, recon_e ) {
	double eta = e.eta();
	double phi = e.azimuthalAngle(MINUSPI_PLUSPI);
	if(eta>-0.1&&eta<1.5&&phi>-0.9&&phi<-0.5)
	vetoEvent;
	}
	foreach ( const Jet & jet, recon_jets ) {
	double eta = jet.rapidity();
	double phi = jet.azimuthalAngle(MINUSPI_PLUSPI);
	if(jet.perp()>40 && eta>-0.1&&eta<1.5&&phi>-0.9&&phi<-0.5)
	vetoEvent;
	}
	}

	// check at least one e/mu passing trigger
	if( !( !recon_e .empty() && recon_e[0] .perp()>25.) &&
	!( !recon_mu.empty() && recon_mu[0].perp()>20.) ) {
	MSG_DEBUG("Hardest lepton fails trigger");
	vetoEvent;
	}

	// calculate meff
	double meff = eTmiss;
	foreach ( const Particle & e , recon_e )
	meff += e.perp();
	foreach ( const Particle & mu, recon_mu )
	meff += mu.perp();
	foreach ( const Jet & jet, recon_jets ) {
	double pT = jet.perp();
	if(pT>40.) meff += pT;
	}

	double mSFOS=1e30, mdiff=1e30;
	// mass of SFOS pairs closest to the Z mass
	for(unsigned int ix=0;ix<recon_e.size();++ix) {
	for(unsigned int iy=ix+1;iy<recon_e.size();++iy) {
	if(recon_e[ix].pid()*recon_e[iy].pid()>0) continue;
	double mtest = (recon_e[ix].momentum()+recon_e[iy].momentum()).mass();
	if(fabs(mtest-90.)<mdiff) {
	mSFOS = mtest;
	mdiff = fabs(mtest-90.);
	}
	}
	}
	for(unsigned int ix=0;ix<recon_mu.size();++ix) {
	for(unsigned int iy=ix+1;iy<recon_mu.size();++iy) {
	if(recon_mu[ix].pid()*recon_mu[iy].pid()>0) continue;
	double mtest = (recon_mu[ix].momentum()+recon_mu[iy].momentum()).mass();
	if(fabs(mtest-91.118)<mdiff) {
	mSFOS = mtest;
	mdiff = fabs(mtest-91.118);
	}
	}
	}

	// make the control plots
	// lepton pT
	unsigned int ie=0,imu=0;
	for(unsigned int ix=0;ix<4;++ix) {
	double pTe = ie <recon_e .size() ?
	recon_e [ie ].perp() : -1*GeV;
	double pTmu = imu<recon_mu.size() ?
	recon_mu[imu].perp() : -1*GeV;
	if(pTe>pTmu) {
	_hist_leptonpT [ix]->fill(pTe ,weight);
	_hist_leptonpT_MC[ix]->fill(pTe ,weight);
	++ie;
	}
	else {
	_hist_leptonpT [ix]->fill(pTmu,weight);
	_hist_leptonpT_MC[ix]->fill(pTmu,weight);
	++imu;
	}
	}
	// njet
	_hist_njet ->fill(recon_jets.size(),weight);
	_hist_njet_MC->fill(recon_jets.size(),weight);
	// etmiss
	_hist_etmiss ->fill(eTmiss,weight);
	_hist_etmiss_MC->fill(eTmiss,weight);
	if(mSFOS<1e30) {
	_hist_mSFOS ->fill(mSFOS,weight);
	_hist_mSFOS_MC->fill(mSFOS,weight);
	}
	_hist_meff ->fill(meff,weight);
	_hist_meff_MC->fill(meff,weight);

	// finally the counts
	if(eTmiss>50.) {
	_count_SR1->fill(0.5,weight);
	if(mdiff>10.) _count_SR2->fill(0.5,weight);
	}
	}

	//@}

	void finalize() {
	double norm = crossSection()/femtobarn*2.06/sumOfWeights();
	// these are number of events at 2.06fb^-1 per 10 GeV
	scale(_hist_leptonpT [0],norm*10.);
	scale(_hist_leptonpT [1],norm*10.);
	scale(_hist_leptonpT_MC[0],norm*10.);
	scale(_hist_leptonpT_MC[1],norm*10.);
	// these are number of events at 2.06fb^-1 per 5 GeV
	scale(_hist_leptonpT [2],norm*5.);
	scale(_hist_leptonpT [3],norm*5.);
	scale(_hist_leptonpT_MC[2],norm*5.);
	scale(_hist_leptonpT_MC[3],norm*5.);
	// these are number of events at 2.06fb^-1 per 20 GeV
	scale(_hist_etmiss ,norm*20.);
	scale(_hist_mSFOS ,norm*20.);
	scale(_hist_etmiss_MC ,norm*20.);
	scale(_hist_mSFOS_MC ,norm*20.);
	// these are number of events at 2.06fb^-1 per 50 GeV
	scale(_hist_meff ,norm*50.);
	scale(_hist_meff_MC ,norm*50.);
	// these are number of events at 2.06fb^-1
	scale(_hist_njet ,norm);
	scale(_hist_njet_MC ,norm);
	scale(_count_SR1,norm);
	scale(_count_SR2,norm);
	}

	private:

	/// @name Histograms
	//@{
	vector<Histo1DPtr> _hist_leptonpT,_hist_leptonpT_MC;
	Histo1DPtr _hist_njet;
	Histo1DPtr _hist_njet_MC;
	Histo1DPtr _hist_etmiss;
	Histo1DPtr _hist_etmiss_MC;
	Histo1DPtr _hist_mSFOS;
	Histo1DPtr _hist_mSFOS_MC;
	Histo1DPtr _hist_meff;
	Histo1DPtr _hist_meff_MC;
	Histo1DPtr _count_SR1;
	Histo1DPtr _count_SR2;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_CONF_2012_001);

	}
	diff --git a/src/Analyses/ATLAS_2012_CONF_2012_103.cc b/src/Analyses/ATLAS_2012_CONF_2012_103.cc
	--- a/src/Analyses/ATLAS_2012_CONF_2012_103.cc
	+++ b/src/Analyses/ATLAS_2012_CONF_2012_103.cc
	@@ -1,262 +1,262 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	class ATLAS_2012_CONF_2012_103 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_CONF_2012_103()
	: Analysis("ATLAS_2012_CONF_2012_103")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9), "vfs");

	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);

	/// Jet finder
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	/// Book histograms
	_etmiss_HT_7j55 = bookHisto1D("etmiss_HT_7j55", 8, 0., 16.);
	_etmiss_HT_8j55 = bookHisto1D("etmiss_HT_8j55", 8, 0., 16.);
	_etmiss_HT_9j55 = bookHisto1D("etmiss_HT_9j55", 8, 0., 16.);
	_etmiss_HT_6j80 = bookHisto1D("etmiss_HT_6j80", 8, 0., 16.);
	_etmiss_HT_7j80 = bookHisto1D("etmiss_HT_7j80", 8, 0., 16.);
	_etmiss_HT_8j80 = bookHisto1D("etmiss_HT_8j80", 8, 0., 16.);

	_hist_njet55 = bookHisto1D("hist_njet55", 4, 5.5, 9.5);
	_hist_njet80 = bookHisto1D("hist_njet80", 4, 4.5, 8.5);

	_count_7j55 = bookHisto1D("count_7j55", 1, 0., 1.);
	_count_8j55 = bookHisto1D("count_8j55", 1, 0., 1.);
	_count_9j55 = bookHisto1D("count_9j55", 1, 0., 1.);
	_count_6j80 = bookHisto1D("count_6j80", 1, 0., 1.);
	_count_7j80 = bookHisto1D("count_7j80", 1, 0., 1.);
	_count_8j80 = bookHisto1D("count_8j80", 1, 0., 1.);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// get the jet candidates
	Jets cand_jets;
	foreach (const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	cand_jets.push_back(jet);
	}
	}

	// candidate muons
	Particles cand_mu =
	- applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "muons").particlesByPt();

	// candidate electrons
	Particles cand_e =
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	// resolve jet/lepton ambiguity
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	// candidates after \|eta\| < 2.8
	if ( fabs( jet.eta() ) >= 2.8 ) continue;
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}

	// only keep electrons more than R=0.4 from jets
	Particles recon_e;
	foreach ( const Particle & e, cand_e ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away )
	recon_e.push_back( e );
	}

	// only keep muons more than R=0.4 from jets
	Particles recon_mu;
	foreach ( const Particle & mu, cand_mu ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away )
	recon_mu.push_back( mu );
	}

	// pTmiss
	Particles vfs_particles =
	- applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// now only use recon_jets, recon_mu, recon_e

	// reject events with electrons and muons
	if ( ! ( recon_mu.empty() && recon_e.empty() ) ) {
	MSG_DEBUG("Charged leptons left after selection");
	vetoEvent;
	}

	// calculate H_T
	double HT=0;
	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.pT() > 40 * GeV )
	HT += jet.pT() ;
	}

	// number of jets
	unsigned int njet55=0, njet80=0;
	for (unsigned int ix=0;ix<recon_jets.size();++ix) {
	if(recon_jets[ix].pT()>80.*GeV) ++njet80;
	if(recon_jets[ix].pT()>55.*GeV) ++njet55;
	}

	double ratio = eTmiss/sqrt(HT);

	if(ratio>4.) {
	if(njet55>9) njet55 = 9;
	if(njet80>8) njet80 = 8;
	_hist_njet55->fill(njet55,weight);
	_hist_njet80->fill(njet80,weight);
	// 7j55
	if(njet55>=7)
	_count_7j55->fill( 0.5, weight);
	// 8j55
	if(njet55>=8)
	_count_8j55->fill( 0.5, weight) ;
	// 8j55
	if(njet55==9)
	_count_9j55->fill( 0.5, weight) ;
	// 6j80
	if(njet80>=6)
	_count_6j80->fill( 0.5, weight) ;
	// 7j80
	if(njet80>=7)
	_count_7j80->fill( 0.5, weight) ;
	// 8j80
	if(njet80==8)
	_count_8j80->fill( 0.5, weight) ;
	}

	if(njet55>=7)
	_etmiss_HT_7j55->fill( ratio, weight);
	// 8j55
	if(njet55>=8)
	_etmiss_HT_8j55->fill( ratio, weight) ;
	// 8j55
	if(njet55>=9)
	_etmiss_HT_9j55->fill( ratio, weight) ;
	// 6j80
	if(njet80>=6)
	_etmiss_HT_6j80->fill( ratio, weight) ;
	// 7j80
	if(njet80>=7)
	_etmiss_HT_7j80->fill( ratio, weight) ;
	// 8j80
	if(njet80>=8)
	_etmiss_HT_8j80->fill( ratio, weight) ;

	}

	//@}

	void finalize() {
	double norm = crossSection()/femtobarn*5.8/sumOfWeights();

	scale(_etmiss_HT_7j55,2.*norm);
	scale(_etmiss_HT_8j55,2.*norm);
	scale(_etmiss_HT_9j55,2.*norm);
	scale(_etmiss_HT_6j80,2.*norm);
	scale(_etmiss_HT_7j80,2.*norm);
	scale(_etmiss_HT_8j80,2.*norm);

	scale(_hist_njet55,norm);
	scale(_hist_njet80,norm);

	scale(_count_7j55,norm);
	scale(_count_8j55,norm);
	scale(_count_9j55,norm);
	scale(_count_6j80,norm);
	scale(_count_7j80,norm);
	scale(_count_8j80,norm);
	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _etmiss_HT_7j55;
	Histo1DPtr _etmiss_HT_8j55;
	Histo1DPtr _etmiss_HT_9j55;
	Histo1DPtr _etmiss_HT_6j80;
	Histo1DPtr _etmiss_HT_7j80;
	Histo1DPtr _etmiss_HT_8j80;

	Histo1DPtr _hist_njet55;
	Histo1DPtr _hist_njet80;

	Histo1DPtr _count_7j55;
	Histo1DPtr _count_8j55;
	Histo1DPtr _count_9j55;
	Histo1DPtr _count_6j80;
	Histo1DPtr _count_7j80;
	Histo1DPtr _count_8j80;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_CONF_2012_103);

	}
	diff --git a/src/Analyses/ATLAS_2012_CONF_2012_104.cc b/src/Analyses/ATLAS_2012_CONF_2012_104.cc
	--- a/src/Analyses/ATLAS_2012_CONF_2012_104.cc
	+++ b/src/Analyses/ATLAS_2012_CONF_2012_104.cc
	@@ -1,225 +1,225 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2012_CONF_2012_104 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_CONF_2012_104()
	: Analysis("ATLAS_2012_CONF_2012_104")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialize projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 10*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");

	// Book histograms
	_count_e = bookHisto1D("count_e" , 1, 0., 1.);
	_count_mu = bookHisto1D("count_mu", 1, 0., 1.);

	_hist_eTmiss_e = bookHisto1D("hist_eTmiss_e" , 25, 0., 1000.);
	_hist_eTmiss_mu = bookHisto1D("hist_eTmiss_mu" , 25, 0., 1000.);

	}

	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// get the candiate jets
	Jets cand_jets;
	foreach ( const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	cand_jets.push_back(jet);
	}
	}

	// get the candidate "medium" leptons without isolation
	Particles cand_e;
	foreach( const Particle & e,
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	// remove any leptons within 0.4 of any candidate jets
	bool e_near_jet = false;
	foreach ( const Jet& jet, cand_jets ) {
	double dR = deltaR(e.momentum(),jet.momentum());
	if ( dR < 0.4 && dR > 0.2 ) {
	e_near_jet = true;
	break;
	}
	}
	if ( ! e_near_jet ) cand_e.push_back(e);
	}
	Particles cand_mu;
	foreach( const Particle & mu,
	- applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	+ apply<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	// remove any leptons within 0.4 of any candidate jets
	bool mu_near_jet = false;
	foreach ( const Jet& jet, cand_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	mu_near_jet = true;
	break;
	}
	}
	if ( ! mu_near_jet ) cand_mu.push_back(mu);
	}
	// apply the isolation
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	// pTcone around muon track (hard)
	Particles recon_mu;
	foreach ( const Particle & mu, cand_mu ) {
	double pTinCone = -mu.pT();
	if(-pTinCone<25.) continue;
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV ) recon_mu.push_back(mu);
	}
	// pTcone around electron track (hard)
	Particles recon_e;
	foreach ( const Particle & e, cand_e ) {
	double pTinCone = -e.pT();
	if(-pTinCone<25.) continue;
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 0.1 * e.pT() ) recon_e.push_back(e);
	}

	// discard jets that overlap with electrons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	if(jet.abseta()>2.5\|\|
	jet.perp()<25.) continue;
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}

	// pTmiss
	FourMomentum pTmiss;
	foreach ( const Particle & p,
	- applyProjection<VisibleFinalState>(event, "vfs").particles() ) {
	+ apply<VisibleFinalState>(event, "vfs").particles() ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// at least 4 jets with pT>80.
	if(recon_jets.size()<4 \|\| recon_jets[3].perp()<80.) vetoEvent;

	// only 1 signal lepton
	if( recon_e.size() + recon_mu.size() != 1 )
	vetoEvent;
	if( cand_e .size() + cand_mu .size() != 1 )
	vetoEvent;

	// start of meff calculation
	double HT=0.;
	foreach( const Jet & jet, recon_jets) {
	double pT = jet.perp();
	if(pT>40.) HT += pT;
	}

	// get the lepton
	Particle lepton = recon_e.empty() ? recon_mu[0] : recon_e[0];

	// lepton variables
	double pT = lepton.perp();

	double mT = 2.(pTeTmiss -
	lepton.px()*pTmiss.px() -
	lepton.py()*pTmiss.py());
	mT = sqrt(mT);
	HT += pT;
	double m_eff_inc = HT + eTmiss + pT;
	double m_eff_4 = eTmiss + pT;
	for(unsigned int ix=0;ix<4;++ix)
	m_eff_4 += recon_jets[ix].perp();

	// four jet selecton
	if(mT>100.&& eTmiss/m_eff_4>0.2 &&
	m_eff_inc > 800.) {
	if( eTmiss > 250. ) {
	if(lepton.abspid()==PID::ELECTRON)
	_count_e->fill(0.5,weight);
	else if(lepton.abspid()==PID::MUON)
	_count_mu->fill(0.5,weight);
	}
	if(lepton.abspid()==PID::ELECTRON)
	_hist_eTmiss_e ->fill(eTmiss,weight);
	else if(lepton.abspid()==PID::MUON)
	_hist_eTmiss_mu->fill(eTmiss,weight);
	}
	}
	//@}


	void finalize() {

	double norm = 5.8* crossSection()/sumOfWeights()/femtobarn;
	scale(_count_e ,norm);
	scale(_count_mu,norm);
	scale(_hist_eTmiss_e ,40.*norm);
	scale(_hist_eTmiss_mu ,40.*norm);

	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_e ;
	Histo1DPtr _count_mu;

	Histo1DPtr _hist_eTmiss_e ;
	Histo1DPtr _hist_eTmiss_mu;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_CONF_2012_104);

	}
	diff --git a/src/Analyses/ATLAS_2012_CONF_2012_105.cc b/src/Analyses/ATLAS_2012_CONF_2012_105.cc
	--- a/src/Analyses/ATLAS_2012_CONF_2012_105.cc
	+++ b/src/Analyses/ATLAS_2012_CONF_2012_105.cc
	@@ -1,223 +1,223 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	class ATLAS_2012_CONF_2012_105 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_CONF_2012_105()
	: Analysis("ATLAS_2012_CONF_2012_105")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 20*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.5), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.5), "vfs");

	// book histograms

	// counts in signal regions
	_count_ee = bookHisto1D("count_ee" , 1, 0., 1.);
	_count_emu = bookHisto1D("count_emu" , 1, 0., 1.);
	_count_mumu = bookHisto1D("count_mumu", 1, 0., 1.);
	_count_ll = bookHisto1D("count_ll" , 1, 0., 1.);

	// histograms from paper
	_hist_eTmiss_ee = bookHisto1D("eTmiss_ee" , 8, 0., 400.);
	_hist_eTmiss_emu = bookHisto1D("eTmiss_emu" , 8, 0., 400.);
	_hist_eTmiss_mumu = bookHisto1D("eTmiss_mumu", 8, 0., 400.);
	_hist_eTmiss_ll = bookHisto1D("eTmiss_ll" , 8, 0., 400.);
	}

	/// Perform the event analysis
	void analyze(const Event& event) {
	// event weight
	const double weight = event.weight();

	// get the jet candidates
	Jets cand_jets;
	foreach (const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	cand_jets.push_back(jet);
	}
	}

	// electron candidates
	Particles cand_e =
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	// Discard jets that overlap with electrons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}
	// get the charged tracks for isolation
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();

	// Reconstructed electrons
	Particles recon_leptons;
	foreach ( const Particle & e, cand_e ) {
	// check not near a jet
	bool e_near_jet = false;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	e_near_jet = true;
	break;
	}
	}
	if ( e_near_jet ) continue;
	// check the isolation
	double pTinCone = -e.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 0.1*e.perp() )
	recon_leptons.push_back(e);
	}

	// Reconstructed Muons
	Particles cand_mu =
	- applyProjection<IdentifiedFinalState>(event,"muons").particlesByPt();
	+ apply<IdentifiedFinalState>(event,"muons").particlesByPt();
	foreach ( const Particle & mu, cand_mu ) {
	// check not near a jet
	bool mu_near_jet = false;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	mu_near_jet = true;
	break;
	}
	}
	if ( mu_near_jet ) continue;
	// isolation
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	recon_leptons.push_back(mu);
	}

	// pTmiss
	Particles vfs_particles
	- = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// Exactly two leptons for each event
	if ( recon_leptons.size() != 2) vetoEvent;
	// ensure 1st hardest
	if(recon_leptons[0].perp()<recon_leptons[1].perp())
	std::swap(recon_leptons[0],recon_leptons[1]);
	// only keep same sign
	if(recon_leptons[0].pid()*recon_leptons[1].pid()<0)
	vetoEvent;
	// at least 4 jets pt>50
	if(recon_jets.size()<4\|\|recon_jets[3].perp()<50.)
	vetoEvent;

	if(recon_leptons[0].pid()!=recon_leptons[1].pid())
	_hist_eTmiss_emu ->fill(eTmiss,weight);
	else if(recon_leptons[0].abspid()==PID::ELECTRON)
	_hist_eTmiss_ee ->fill(eTmiss,weight);
	else if(recon_leptons[0].abspid()==PID::MUON)
	_hist_eTmiss_mumu->fill(eTmiss,weight);
	_hist_eTmiss_ll->fill(eTmiss,weight);

	if(eTmiss>150.) {
	if(recon_leptons[0].pid()!=recon_leptons[1].pid())
	_count_emu ->fill(0.5,weight);
	else if(recon_leptons[0].abspid()==PID::ELECTRON)
	_count_ee ->fill(0.5,weight);
	else if(recon_leptons[0].abspid()==PID::MUON)
	_count_mumu->fill(0.5,weight);
	_count_ll->fill(0.5,weight);
	}

	}

	//@}


	void finalize() {

	double norm = crossSection()/femtobarn*5.8/sumOfWeights();
	// event counts
	scale(_count_ee ,norm);
	scale(_count_emu ,norm);
	scale(_count_mumu,norm);
	scale(_count_ll ,norm);
	// histograms
	scale(_hist_eTmiss_ee ,norm*50.);
	scale(_hist_eTmiss_emu ,norm*50.);
	scale(_hist_eTmiss_mumu,norm*50.);
	scale(_hist_eTmiss_ll ,norm*50.);

	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_ee ;
	Histo1DPtr _count_emu ;
	Histo1DPtr _count_mumu;
	Histo1DPtr _count_ll ;

	Histo1DPtr _hist_eTmiss_ee;
	Histo1DPtr _hist_eTmiss_emu;
	Histo1DPtr _hist_eTmiss_mumu;
	Histo1DPtr _hist_eTmiss_ll;
	//@}
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_CONF_2012_105);

	}
	diff --git a/src/Analyses/ATLAS_2012_CONF_2012_109.cc b/src/Analyses/ATLAS_2012_CONF_2012_109.cc
	--- a/src/Analyses/ATLAS_2012_CONF_2012_109.cc
	+++ b/src/Analyses/ATLAS_2012_CONF_2012_109.cc
	@@ -1,363 +1,363 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @author Peter Richardson
	class ATLAS_2012_CONF_2012_109 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_CONF_2012_109()
	: Analysis("ATLAS_2012_CONF_2012_109")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// Projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// All tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0), "cfs");

	// Used for pTmiss (N.B. the real 'vfs' extends beyond 4.5 to \|eta\| = 4.9)
	- addProjection(VisibleFinalState(Cuts::abseta < 4.5), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.5), "vfs");

	// Book histograms
	_count_A_tight = bookHisto1D("count_A_tight" , 1, 0., 1.);
	_count_A_medium = bookHisto1D("count_A_medium" , 1, 0., 1.);
	_count_A_loose = bookHisto1D("count_A_loose" , 1, 0., 1.);
	_count_B_tight = bookHisto1D("count_B_tight" , 1, 0., 1.);
	_count_B_medium = bookHisto1D("count_B_medium" , 1, 0., 1.);
	_count_C_tight = bookHisto1D("count_C_tight" , 1, 0., 1.);
	_count_C_medium = bookHisto1D("count_C_medium" , 1, 0., 1.);
	_count_C_loose = bookHisto1D("count_C_loose" , 1, 0., 1.);
	_count_D_tight = bookHisto1D("count_D_tight" , 1, 0., 1.);
	_count_E_tight = bookHisto1D("count_E_tight" , 1, 0., 1.);
	_count_E_medium = bookHisto1D("count_E_medium" , 1, 0., 1.);
	_count_E_loose = bookHisto1D("count_E_loose" , 1, 0., 1.);

	_hist_meff_A_medium = bookHisto1D("meff_A_medium" , 40, 0., 4000.);
	_hist_meff_A_tight = bookHisto1D("meff_A_tight" , 40, 0., 4000.);
	_hist_meff_B_medium = bookHisto1D("meff_B_medium" , 40, 0., 4000.);
	_hist_meff_B_tight = bookHisto1D("meff_B_tight" , 40, 0., 4000.);
	_hist_meff_C_medium = bookHisto1D("meff_C_medium" , 40, 0., 4000.);
	_hist_meff_C_tight = bookHisto1D("meff_C_tight" , 40, 0., 4000.);
	_hist_meff_D = bookHisto1D("meff_D" , 40, 0., 4000.);
	_hist_meff_E_loose = bookHisto1D("meff_E_loose" , 40, 0., 4000.);
	_hist_meff_E_medium = bookHisto1D("meff_E_medium" , 40, 0., 4000.);
	_hist_meff_E_tight = bookHisto1D("meff_E_tight" , 40, 0., 4000.);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	Jets cand_jets;
	- const Jets jets = applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
	+ const Jets jets = apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
	foreach (const Jet& jet, jets) {
	if ( fabs( jet.eta() ) < 4.9 ) {
	cand_jets.push_back(jet);
	}
	}

	- const Particles cand_e = applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ const Particles cand_e = apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	// Muon isolation not mentioned in hep-exp 1109.6572 but assumed to still be applicable
	Particles cand_mu;
	- const Particles chg_tracks = applyProjection<ChargedFinalState>(event, "cfs").particles();
	- const Particles muons = applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt();
	+ const Particles chg_tracks = apply<ChargedFinalState>(event, "cfs").particles();
	+ const Particles muons = apply<IdentifiedFinalState>(event, "muons").particlesByPt();
	foreach (const Particle& mu, muons) {
	double pTinCone = -mu.pT();
	foreach (const Particle& track, chg_tracks) {
	if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 ) {
	pTinCone += track.pT();
	}
	}
	if ( pTinCone < 1.8*GeV ) cand_mu.push_back(mu);
	}

	// Resolve jet-lepton overlap for jets with \|eta\| < 2.8
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	if ( fabs( jet.eta() ) >= 2.8 ) continue;
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}

	Particles recon_e, recon_mu;

	foreach ( const Particle & e, cand_e ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away ) recon_e.push_back( e );
	}

	foreach ( const Particle & mu, cand_mu ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away ) recon_mu.push_back( mu );
	}

	// pTmiss
	// Based on all candidate electrons, muons and jets, plus everything else with \|eta\| < 4.5
	// i.e. everything in our projection "vfs" plus the jets with \|eta\| > 4.5
	- Particles vfs_particles = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ Particles vfs_particles = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	foreach ( const Jet& jet, cand_jets ) {
	if ( fabs( jet.eta() ) > 4.5 ) pTmiss -= jet.momentum();
	}
	double eTmiss = pTmiss.pT();

	// no electron pT> 20 or muons pT>10
	if ( !recon_mu.empty() \|\| !recon_e.empty() ) {
	MSG_DEBUG("Charged leptons left after selection");
	vetoEvent;
	}

	if ( eTmiss <= 160 * GeV ) {
	MSG_DEBUG("Not enough eTmiss: " << eTmiss << " < 130");
	vetoEvent;
	}

	// check the hardest two jets
	if ( recon_jets.size()<2 \|\|
	recon_jets[0].pT() <= 130.0 * GeV \|\|
	recon_jets[0].pT() <= 60.0 * GeV ) {
	MSG_DEBUG("No hard leading jet in " << recon_jets.size() << " jets");
	vetoEvent;
	}

	// check the charged and EM fractions of the hard jets to avoid photons
	for (unsigned int ix = 0; ix < 2; ++ix) {
	// jets over 100 GeV
	if (recon_jets[ix].pT() < 100*GeV \|\|
	recon_jets[ix].eta() > 2.) continue; ///< @todo Should be \|eta\|?
	double fch(0.), fem(0.), eTotal(0.);
	foreach(const Particle & part, recon_jets[ix].particles()) {
	long id = part.abspid();
	if(PID::threeCharge(id)!=0)
	fch += part.E();
	if (id == PID::PHOTON \|\| id == PID::ELECTRON \|\| id == PID::PI0)
	fem += part.E();
	}
	fch /= eTotal;
	fem /= eTotal;
	// remove events with hard photon
	if (fch < 0.02 \|\| (fch < 0.05 && fem > 0.09)) vetoEvent;
	}

	// ==================== observables ====================

	int Njets = 0;
	double min_dPhi_All = 999.999; ///< @todo Use std::numeric_limits!
	double min_dPhi_2 = 999.999; ///< @todo Use std::numeric_limits!
	double min_dPhi_3 = 999.999; ///< @todo Use std::numeric_limits!
	double pTmiss_phi = pTmiss.phi();

	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.pT() < 40*GeV ) continue;
	double dPhi = deltaPhi( pTmiss_phi, jet.phi());
	if ( Njets < 2 ) min_dPhi_2 = min( min_dPhi_2, dPhi );
	if ( Njets < 3 ) min_dPhi_3 = min( min_dPhi_3, dPhi );
	min_dPhi_All = min( min_dPhi_All, dPhi );
	++Njets;
	}

	// inclusive meff
	double m_eff_inc = eTmiss;
	foreach ( const Jet& jet, recon_jets ) {
	double perp = jet.pT();
	if(perp>40.) m_eff_inc += perp;
	}

	// region A
	double m_eff_Nj = eTmiss + recon_jets[0].pT() + recon_jets[1].pT();
	if( min_dPhi_2 > 0.4 && eTmiss/m_eff_Nj > 0.3 ) {
	_hist_meff_A_tight ->fill(m_eff_inc,weight);
	if(eTmiss/m_eff_Nj > 0.4)
	_hist_meff_A_medium->fill(m_eff_inc,weight);
	if(m_eff_inc>1900.)
	_count_A_tight ->fill(0.5,weight);
	if(m_eff_inc>1300. && eTmiss/m_eff_Nj > 0.4)
	_count_A_medium->fill(0.5,weight);
	if(m_eff_inc>1300. && eTmiss/m_eff_Nj > 0.4)
	_count_A_loose ->fill(0.5,weight);
	}

	// for rest of regions 3 jets pT> 60 needed
	if(recon_jets.size()<3 \|\| recon_jets[2].perp()<60.)
	vetoEvent;

	// region B
	m_eff_Nj += recon_jets[2].perp();
	if( min_dPhi_3 > 0.4 && eTmiss/m_eff_Nj > 0.25 ) {
	_hist_meff_B_tight->fill(m_eff_inc,weight);
	if(eTmiss/m_eff_Nj > 0.3)
	_hist_meff_B_medium->fill(m_eff_inc,weight);
	if(m_eff_inc>1900.)
	_count_B_tight ->fill(0.5,weight);
	if(m_eff_inc>1300. && eTmiss/m_eff_Nj > 0.3)
	_count_B_medium->fill(0.5,weight);
	}

	// for rest of regions 4 jets pT> 60 needed
	if(recon_jets.size()<4 \|\| recon_jets[3].perp()<60.)
	vetoEvent;

	// region C
	m_eff_Nj += recon_jets[3].perp();
	if( min_dPhi_3 > 0.4 && min_dPhi_All > 0.2 && eTmiss/m_eff_Nj > 0.25 ) {
	_hist_meff_C_tight->fill(m_eff_inc,weight);
	if( eTmiss/m_eff_Nj > 0.3 )
	_hist_meff_C_medium->fill(m_eff_inc,weight);
	if(m_eff_inc>1900.)
	_count_C_tight ->fill(0.5,weight);
	if(m_eff_inc>1300. && eTmiss/m_eff_Nj > 0.3)
	_count_C_medium->fill(0.5,weight);
	if(m_eff_inc>1000. && eTmiss/m_eff_Nj > 0.3)
	_count_C_loose ->fill(0.5,weight);
	}

	// for rest of regions 5 jets pT> 40 needed
	if(recon_jets.size()<5 \|\| recon_jets[4].perp()<40.)
	vetoEvent;

	// region D
	m_eff_Nj += recon_jets[4].perp();
	if( min_dPhi_3 > 0.4 && min_dPhi_All > 0.2 && eTmiss/m_eff_Nj > 0.15 ) {
	_hist_meff_D->fill(m_eff_inc,weight);
	if(m_eff_inc>1700.) _count_D_tight ->fill(0.5,weight);
	}

	// for rest of regions 6 jets pT> 40 needed
	if(recon_jets.size()<6 \|\| recon_jets[5].perp()<40.)
	vetoEvent;

	// region E
	m_eff_Nj += recon_jets[5].perp();
	if( min_dPhi_3 > 0.4 && min_dPhi_All > 0.2 && eTmiss/m_eff_Nj > 0.15 ) {
	_hist_meff_E_tight->fill(m_eff_inc,weight);
	if( eTmiss/m_eff_Nj > 0.25 )
	_hist_meff_E_medium->fill(m_eff_inc,weight);
	if( eTmiss/m_eff_Nj > 0.3 )
	_hist_meff_E_loose->fill(m_eff_inc,weight);
	if(m_eff_inc>1400.) _count_E_tight ->fill(0.5,weight);
	if(m_eff_inc>1300.&& eTmiss/m_eff_Nj > 0.25 )
	_count_E_medium->fill(0.5,weight);
	if(m_eff_inc>1000.&& eTmiss/m_eff_Nj > 0.3 )
	_count_E_loose ->fill(0.5,weight);
	}
	}


	void finalize() {

	double norm = crossSection()/femtobarn*5.8/sumOfWeights();
	// these are number of events at 5.8fb^-1 per 100 GeV
	scale( _hist_meff_A_medium , 100. * norm );
	scale( _hist_meff_A_tight , 100. * norm );
	scale( _hist_meff_B_medium , 100. * norm );
	scale( _hist_meff_B_tight , 100. * norm );
	scale( _hist_meff_C_medium , 100. * norm );
	scale( _hist_meff_C_tight , 100. * norm );
	scale( _hist_meff_D , 100. * norm );
	scale( _hist_meff_E_loose , 100. * norm );
	scale( _hist_meff_E_medium , 100. * norm );
	scale( _hist_meff_E_tight , 100. * norm );
	// these are number of events at 5.8fb^-1
	scale(_count_A_tight ,norm);
	scale(_count_A_medium ,norm);
	scale(_count_A_loose ,norm);
	scale(_count_B_tight ,norm);
	scale(_count_B_medium ,norm);
	scale(_count_C_tight ,norm);
	scale(_count_C_medium ,norm);
	scale(_count_C_loose ,norm);
	scale(_count_D_tight ,norm);
	scale(_count_E_tight ,norm);
	scale(_count_E_medium ,norm);
	scale(_count_E_loose ,norm);
	}

	//@}

	private:

	Histo1DPtr _count_A_tight;
	Histo1DPtr _count_A_medium;
	Histo1DPtr _count_A_loose;
	Histo1DPtr _count_B_tight;
	Histo1DPtr _count_B_medium;
	Histo1DPtr _count_C_tight;
	Histo1DPtr _count_C_medium;
	Histo1DPtr _count_C_loose;
	Histo1DPtr _count_D_tight;
	Histo1DPtr _count_E_tight;
	Histo1DPtr _count_E_medium;
	Histo1DPtr _count_E_loose;

	Histo1DPtr _hist_meff_A_medium;
	Histo1DPtr _hist_meff_A_tight;
	Histo1DPtr _hist_meff_B_medium;
	Histo1DPtr _hist_meff_B_tight;
	Histo1DPtr _hist_meff_C_medium;
	Histo1DPtr _hist_meff_C_tight;
	Histo1DPtr _hist_meff_D;
	Histo1DPtr _hist_meff_E_loose;
	Histo1DPtr _hist_meff_E_medium;
	Histo1DPtr _hist_meff_E_tight;

	};


	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_CONF_2012_109);

	}
	diff --git a/src/Analyses/ATLAS_2012_CONF_2012_153.cc b/src/Analyses/ATLAS_2012_CONF_2012_153.cc
	--- a/src/Analyses/ATLAS_2012_CONF_2012_153.cc
	+++ b/src/Analyses/ATLAS_2012_CONF_2012_153.cc
	@@ -1,397 +1,397 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	class ATLAS_2012_CONF_2012_153 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2012_CONF_2012_153()
	: Analysis("ATLAS_2012_CONF_2012_153")
	{ }

	//@}



	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 10*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");


	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9), "vfs");

	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);

	/// Jet finder
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0), "cfs");

	vector<double> edges_meff;
	edges_meff.push_back( 0);
	edges_meff.push_back( 150);
	edges_meff.push_back( 300);
	edges_meff.push_back( 500);
	edges_meff.push_back(1000);
	edges_meff.push_back(1500);

	vector<double> edges_eT;
	edges_eT.push_back(0);
	edges_eT.push_back(50);
	edges_eT.push_back(150);
	edges_eT.push_back(300);
	edges_eT.push_back(500);

	// Book histograms
	_hist_electrons = bookHisto1D("hist_electrons_before", 11, -0.5,10.5);
	_hist_muons = bookHisto1D("hist_muons_before" , 11, -0.5,10.5);
	_hist_leptons = bookHisto1D("hist_leptons_before" , 11, -0.5,10.5);
	_hist_4leptons = bookHisto1D("hist_4leptons", 1, 0.,1.);
	_hist_veto = bookHisto1D("hist_veto", 1, 0., 1.);
	_hist_etmiss = bookHisto1D("hist_etmiss",edges_eT);
	_hist_meff = bookHisto1D("hist_m_eff",edges_meff);
	_count_SR1 = bookHisto1D("count_SR1", 1, 0., 1.);
	_count_SR2 = bookHisto1D("count_SR2", 1, 0., 1.);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	// get the jet candidates
	Jets cand_jets;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ foreach (const Jet& jet, apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if (jet.abseta() < 2.5) cand_jets.push_back(jet);
	}

	// candidate muons
	- Particles cand_mu = applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt();
	+ Particles cand_mu = apply<IdentifiedFinalState>(event, "muons").particlesByPt();

	// candidate electrons
	// Discard if two electrons are within R=0.1
	- Particles temp = applyProjection<IdentifiedFinalState>(event, "elecs").particles(cmpMomByE);
	+ Particles temp = apply<IdentifiedFinalState>(event, "elecs").particles(cmpMomByE);
	vector<bool> vetoed(temp.size(),false);
	Particles cand_e;
	for (size_t ix = 0; ix < temp.size(); ++ix) {
	if (vetoed[ix]) continue;
	for (size_t iy = ix+1; iy < temp.size(); ++iy) {
	if ( deltaR(temp[ix], temp[iy]) < 0.1 ) vetoed[iy] = true;
	}
	if (!vetoed[ix]) cand_e.push_back(temp[ix]);
	}

	// Sort by transverse momentum
	sortByPt(cand_e);

	// resolve jet/lepton ambiguity
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_e = true;
	foreach ( const Particle& e, cand_e ) {
	if (deltaR(e, jet) <= 0.2) {
	away_from_e = false;
	break;
	}
	}
	if (away_from_e) recon_jets.push_back( jet );
	}

	// only keep electrons more than R=0.4 from jets
	Particles cand2_e;
	foreach (const Particle& e, cand_e) {
	// at least 0.4 from any jets
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e, jet) < 0.4 ) {
	away = false;
	break;
	}
	}
	// if isolated keep it
	if ( away )
	cand2_e.push_back( e );
	}

	// only keep muons more than R=0.4 from jets
	Particles cand2_mu;
	foreach(const Particle & mu, cand_mu ) {
	bool away = true;
	// at least 0.4 from any jets
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu, jet) < 0.4 ) {
	away = false;
	break;
	}
	}
	if (away) cand2_mu.push_back( mu );
	}

	// electron and muon more than 0.1 apart
	Particles cand3_e;
	foreach ( const Particle & e, cand2_e ) {
	bool away = true;
	foreach( const Particle & mu, cand2_mu ) {
	if( deltaR(e, mu) < 0.1) {
	away = false;
	break;
	}
	}
	if (away) cand3_e.push_back(e);
	}
	Particles cand3_mu;
	foreach( const Particle & mu, cand2_mu ) {
	bool away = true;
	foreach ( const Particle & e, cand2_e ) {
	if( deltaR(e, mu) < 0.1) {
	away = false;
	break;
	}
	}
	if (away) cand3_mu.push_back(mu);
	}

	// pTmiss
	Particles vfs_particles =
	- applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// apply electron isolation
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	Particles cand4_e;
	foreach (const Particle& e, cand3_e) {
	// charge isolation
	double pTinCone = -e.pT();
	foreach (const Particle& track, chg_tracks) {
	if (track.pT() > 0.4*GeV && deltaR(e, track) <= 0.3 )
	pTinCone += track.pT();
	}
	if (pTinCone/e.pT() > 0.16) continue;
	// all particles isolation
	pTinCone = -e.pT();
	foreach (const Particle& p, vfs_particles) {
	if (p.abspid() != PID::MUON && deltaR(e, p) <= 0.3 )
	pTinCone += p.pT();
	}
	if (pTinCone/e.pT() < 0.18) cand4_e.push_back(e);
	}

	// apply muon isolation
	Particles cand4_mu;
	foreach ( const Particle & mu, cand3_mu ) {
	double pTinCone = -mu.perp();
	foreach ( const Particle & track, chg_tracks ) {
	if (track.pT() > 1*GeV && deltaR(mu, track) <= 0.3)
	pTinCone += track.pT();
	}
	if (pTinCone/mu.pT() < 0.12) cand4_mu.push_back(mu);
	}

	// same SOSF pairs m>12.
	Particles recon_e;
	foreach(const Particle& e, cand4_e) {
	bool veto = false;
	foreach(const Particle& e2, cand4_e) {
	if (e.pid()e2.pid() < 0 && (e.momentum()+e2.momentum()).mass() < 12GeV) {
	veto = true;
	break;
	}
	}
	if (!veto) recon_e.push_back(e);
	}
	Particles recon_mu;
	foreach(const Particle& mu, cand4_mu) {
	bool veto = false;
	foreach(const Particle& mu2, cand4_mu) {
	if (mu.pid()mu2.pid() < 0 && (mu.momentum()+mu2.momentum()).mass() < 12GeV) {
	veto = true;
	break;
	}
	}
	if (!veto) recon_mu.push_back(mu);
	}

	// now only use recon_jets, recon_mu, recon_e
	_hist_electrons->fill(recon_e.size(), weight);
	_hist_muons->fill(recon_mu.size(), weight);
	_hist_leptons->fill(recon_mu.size() + recon_e.size(), weight);
	if (recon_mu.size() + recon_e.size() > 3) {
	_hist_4leptons->fill(0.5, weight);
	}

	// reject events with less than 4 electrons and muons
	if (recon_mu.size() + recon_e.size() < 4) {
	MSG_DEBUG("To few charged leptons left after selection");
	vetoEvent;
	}


	// or two lepton trigger
	bool passDouble =
	(recon_mu.size()>=2 && ( (recon_mu[1].pT()>14*GeV) \|\|
	(recon_mu[0].pT()>18GeV && recon_mu[1].perp() > 10GeV) )) \|\|
	(recon_e.size() >=2 && ( (recon_e [1].pT()>14*GeV) \|\|
	(recon_e [0].pT()>25GeV && recon_e [1].perp() > 10GeV) )) \|\|
	(!recon_e.empty() && !recon_mu.empty() &&
	( (recon_e[0].pT() > 14GeV && recon_mu[0].pT() > 10GeV)\|\|
	(recon_e[0].pT() > 10GeV && recon_mu[0].pT() > 18GeV) ));

	// must pass a trigger
	if (!passDouble ) {
	MSG_DEBUG("Hardest lepton fails trigger");
	_hist_veto->fill(0.5, weight);
	vetoEvent;
	}

	// calculate meff
	double meff = eTmiss;
	foreach ( const Particle & e , recon_e ) meff += e.perp();
	foreach ( const Particle & mu, recon_mu ) meff += mu.perp();
	foreach ( const Jet & jet, recon_jets ) {
	const double pT = jet.pT();
	if (pT > 40*GeV) meff += pT;
	}

	// 2/3 leptons --> find 1 SFOS pair in range and veto event
	// 4+ leptons --> find 2 SFOS pairs and in range veto event
	for (size_t ix = 0; ix < recon_e.size(); ++ix) {
	for (size_t iy = ix+1; iy < recon_e.size(); ++iy) {
	if (recon_e[ix].pid()*recon_e[iy].pid() > 0) continue;
	const FourMomentum ppair = recon_e[ix].momentum() + recon_e[iy].momentum();
	if (inRange(ppair.mass(), 81.2GeV, 101.2GeV)) vetoEvent;

	// check triplets with electron
	for (size_t iz = 0; iz < recon_e.size(); ++iz) {
	if (iz == ix \|\| iz == iy) continue;
	if (inRange((ppair+recon_e[iz].momentum()).mass(), 81.2GeV, 101.2GeV)) vetoEvent;
	}

	// check triplets with muon
	for (size_t iz = 0; iz < recon_mu.size(); ++iz) {
	if (inRange((ppair+recon_mu[iz].momentum()).mass(), 81.2GeV, 101.2GeV)) vetoEvent;
	}

	// check quadruplets with electrons
	for (size_t iz = 0; iz < recon_e.size(); ++iz) {
	for (size_t iw = iz+1; iw < recon_e.size(); ++iw) {
	if (iz==ix \|\| iz==iy \|\| iw==ix \|\| iw==iy) continue;
	if (recon_e[iz].pid()*recon_e[iw].pid() > 0) continue;
	if (inRange((ppair+recon_e[iz].momentum()+recon_e[iw].momentum()).mass(), 81.2GeV, 101.2GeV)) vetoEvent;
	}
	}
	// check quadruplets with muons
	for (size_t iz = 0; iz < recon_mu.size(); ++iz) {
	for (size_t iw = iz+1; iw < recon_mu.size(); ++iw) {
	if (recon_mu[iz].pid()*recon_mu[iw].pid() > 0) continue;
	if (inRange((ppair+recon_mu[iz].momentum()+recon_mu[iw].momentum()).mass(), 81.2GeV, 101.2GeV)) vetoEvent;
	}
	}
	}
	}

	// Muon pairs
	for (size_t ix = 0; ix < recon_mu.size(); ++ix) {
	for (size_t iy = ix+1; iy < recon_mu.size(); ++iy) {
	if (recon_mu[ix].pid()*recon_mu[iy].pid()>0) continue;
	const FourMomentum ppair = recon_mu[ix].momentum()+recon_mu[iy].momentum();
	if (inRange(ppair.mass(), 81.2GeV, 101.2GeV)) vetoEvent;

	// check triplets with muon
	for (size_t iz = 0; iz < recon_mu.size(); ++iz) {
	if (iz==ix \|\| iz==iy) continue;
	if (inRange((ppair+recon_mu[iz].momentum()).mass(), 81.2GeV, 101.2GeV)) vetoEvent;
	}

	// check triplets with electron
	for (size_t iz = 0; iz < recon_e.size(); ++iz) {
	if (inRange((ppair+recon_e[iz].momentum()).mass(), 81.2GeV, 101.2GeV)) vetoEvent;
	}

	// check muon quadruplets
	for (size_t iz = 0; iz < recon_mu.size(); ++iz) {
	for (size_t iw = iz+1; iy < recon_mu.size(); ++iy) {
	if (iz==ix \|\| iz==iy \|\| iw==ix \|\| iw==iy) continue;
	if (recon_mu[iz].pid()*recon_mu[iw].pid() > 0) continue;
	if (inRange((ppair+recon_mu[iz].momentum()+recon_mu[iw].momentum()).mass(), 81.2GeV, 101.2GeV)) vetoEvent;
	}
	}
	}
	}

	// Make the control plots
	_hist_etmiss->fill(eTmiss,weight);
	_hist_meff ->fill(meff ,weight);
	// Finally the counts
	if (eTmiss > 50*GeV) _count_SR1->fill(0.5,weight);
	if (meff >0*GeV) _count_SR2->fill(0.5,weight);

	}

	//@}

	void finalize() {
	double norm = crossSection()/femtobarn*13./sumOfWeights();
	scale(_hist_etmiss,norm*20.);
	scale(_hist_meff ,norm*20.);
	scale(_count_SR1,norm);
	scale(_count_SR2,norm);
	}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _hist_electrons;
	Histo1DPtr _hist_muons;
	Histo1DPtr _hist_leptons;
	Histo1DPtr _hist_4leptons;
	Histo1DPtr _hist_veto;
	Histo1DPtr _hist_etmiss;
	Histo1DPtr _hist_meff;
	Histo1DPtr _count_SR1;
	Histo1DPtr _count_SR2;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_CONF_2012_153);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1082009.cc b/src/Analyses/ATLAS_2012_I1082009.cc
	--- a/src/Analyses/ATLAS_2012_I1082009.cc
	+++ b/src/Analyses/ATLAS_2012_I1082009.cc
	@@ -1,147 +1,147 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	class ATLAS_2012_I1082009 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2012_I1082009()
	: Analysis("ATLAS_2012_I1082009"),
	_weight25_30(0.),_weight30_40(0.),_weight40_50(0.),
	_weight50_60(0.),_weight60_70(0.),_weight25_70(0.)
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Input for the jets: No neutrinos, no muons
	VetoedFinalState veto;
	veto.addVetoPairId(PID::MUON);
	veto.vetoNeutrinos();
	FastJets jets(veto, FastJets::ANTIKT, 0.6);
	- addProjection(jets, "jets");
	+ declare(jets, "jets");
	// unstable final-state for D*
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");

	_h_pt25_30 = bookHisto1D( 8,1,1);
	_h_pt30_40 = bookHisto1D( 9,1,1);
	_h_pt40_50 = bookHisto1D(10,1,1);
	_h_pt50_60 = bookHisto1D(11,1,1);
	_h_pt60_70 = bookHisto1D(12,1,1);
	_h_pt25_70 = bookHisto1D(13,1,1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// get the jets
	Jets jets;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "jets").jetsByPt(25.0*GeV)) {
	+ foreach (const Jet& jet, apply<FastJets>(event, "jets").jetsByPt(25.0*GeV)) {
	if ( jet.abseta() < 2.5 ) jets.push_back(jet);
	}
	// get the D* mesons
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");
	Particles Dstar;
	foreach (const Particle& p, ufs.particles()) {
	const int id = p.abspid();
	if(id==413) Dstar.push_back(p);
	}

	// loop over the jobs
	foreach (const Jet& jet, jets ) {
	double perp = jet.perp();
	bool found = false;
	double z(0.);
	if(perp<25.\|\|perp>70.) continue;
	foreach(const Particle & p, Dstar) {
	if(p.perp()<7.5) continue;
	if(deltaR(p, jet.momentum())<0.6) {
	Vector3 axis = jet.p3().unit();
	z = axis.dot(p.p3())/jet.E();
	if(z<0.3) continue;
	found = true;
	break;
	}
	}
	_weight25_70 += weight;
	if(found) _h_pt25_70->fill(z,weight);
	if(perp>=25.&&perp<30.) {
	_weight25_30 += weight;
	if(found) _h_pt25_30->fill(z,weight);
	}
	else if(perp>=30.&&perp<40.) {
	_weight30_40 += weight;
	if(found) _h_pt30_40->fill(z,weight);
	}
	else if(perp>=40.&&perp<50.) {
	_weight40_50 += weight;
	if(found) _h_pt40_50->fill(z,weight);
	}
	else if(perp>=50.&&perp<60.) {
	_weight50_60 += weight;
	if(found) _h_pt50_60->fill(z,weight);
	}
	else if(perp>=60.&&perp<70.) {
	_weight60_70 += weight;
	if(found) _h_pt60_70->fill(z,weight);
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_pt25_30,1./_weight25_30);
	scale(_h_pt30_40,1./_weight30_40);
	scale(_h_pt40_50,1./_weight40_50);
	scale(_h_pt50_60,1./_weight50_60);
	scale(_h_pt60_70,1./_weight60_70);
	scale(_h_pt25_70,1./_weight25_70);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	double _weight25_30,_weight30_40,_weight40_50;
	double _weight50_60,_weight60_70,_weight25_70;

	Histo1DPtr _h_pt25_30;
	Histo1DPtr _h_pt30_40;
	Histo1DPtr _h_pt40_50;
	Histo1DPtr _h_pt50_60;
	Histo1DPtr _h_pt60_70;
	Histo1DPtr _h_pt25_70;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1082009);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1082936.cc b/src/Analyses/ATLAS_2012_I1082936.cc
	--- a/src/Analyses/ATLAS_2012_I1082936.cc
	+++ b/src/Analyses/ATLAS_2012_I1082936.cc
	@@ -1,130 +1,130 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	class ATLAS_2012_I1082936 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2012_I1082936()
	: Analysis("ATLAS_2012_I1082936")
	{
	}

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	const FinalState fs;
	- addProjection(fs,"FinalState");
	+ declare(fs,"FinalState");

	FastJets fj04(fs, FastJets::ANTIKT, 0.4);
	fj04.useInvisibles();
	- addProjection(fj04, "AntiKT04");
	+ declare(fj04, "AntiKT04");

	FastJets fj06(fs, FastJets::ANTIKT, 0.6);
	fj06.useInvisibles();
	- addProjection(fj06, "AntiKT06");
	+ declare(fj06, "AntiKT06");


	// Histogram booking copied from the previous analysis
	double ybins[] = { 0.0, 0.3, 0.8, 1.2, 2.1, 2.8, 3.6, 4.4 };
	double ystarbins[] = { 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.4};

	size_t ptDsOffset(0), massDsOffset(2);
	for (size_t alg = 0; alg < 2; ++alg) {
	for (size_t i = 0; i < 7; ++i) {
	_pThistos[alg].addHistogram(ybins[i], ybins[i+1], bookHisto1D(1 + ptDsOffset, 1, i+1));
	}
	ptDsOffset += 1;

	for (size_t i = 0; i < 9; ++i) {
	_mass[alg].addHistogram(ystarbins[i], ystarbins[i+1], bookHisto1D(1 + massDsOffset, 1, i+1));
	}
	massDsOffset += 1;
	}
	}

	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	Jets jetAr[2];
	- jetAr[AKT6] = applyProjection<FastJets>(event, "AntiKT06").jetsByPt(20*GeV);
	- jetAr[AKT4] = applyProjection<FastJets>(event, "AntiKT04").jetsByPt(20*GeV);
	+ jetAr[AKT6] = apply<FastJets>(event, "AntiKT06").jetsByPt(20*GeV);
	+ jetAr[AKT4] = apply<FastJets>(event, "AntiKT04").jetsByPt(20*GeV);

	// Loop over jet "radii" used in analysis
	for (size_t alg = 0; alg < 2; ++alg) {
	// Identify dijets
	vector<FourMomentum> leadjets;
	foreach (const Jet& jet, jetAr[alg]) {
	const double pT = jet.pT();
	const double absy = jet.absrap();
	_pThistos[alg].fill(absy, pT/GeV, weight);

	if (absy < 4.4 && leadjets.size() < 2) {
	if (leadjets.empty() && pT < 30*GeV) continue;
	leadjets.push_back(jet.momentum());
	}
	}
	// Make sure we have a leading jet with pT >30 GeV and a second to leading jet with pT>20 GeV
	if (leadjets.size() < 2) {
	MSG_DEBUG("Could not find two suitable leading jets");
	continue;
	}

	const double y1 = leadjets[0].rapidity();
	const double y2 = leadjets[1].rapidity();
	const double ystar = fabs(y1-y2)/2.;
	const double m = (leadjets[0] + leadjets[1]).mass();
	// Fill mass histogram
	_mass[alg].fill(ystar, m/TeV, weight);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t alg = 0; alg < 2; ++alg) {
	// factor 0.5 needed because it is differential in dy and not d\|y\|
	_pThistos[alg].scale(0.5*crossSectionPerEvent()/picobarn, this);
	_mass[alg].scale(crossSectionPerEvent()/picobarn, this);
	}
	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here

	enum Alg { AKT4=0, AKT6=1 };

	private:

	/// The inclusive pT spectrum for akt6 and akt4 jets (array index is jet type from enum above)
	BinnedHistogram<double> _pThistos[2];

	/// The di-jet mass spectrum binned in rapidity for akt6 and akt4 jets (array index is jet type from enum above)
	BinnedHistogram<double> _mass[2];
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1082936);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1083318.cc b/src/Analyses/ATLAS_2012_I1083318.cc
	--- a/src/Analyses/ATLAS_2012_I1083318.cc
	+++ b/src/Analyses/ATLAS_2012_I1083318.cc
	@@ -1,262 +1,262 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"

	namespace Rivet {




	/// ATLAS W + jets production at 7 TeV
	class ATLAS_2012_I1083318 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2012_I1083318()
	: Analysis("ATLAS_2012_I1083318")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	IdentifiedFinalState allleptons;
	allleptons.acceptIdPair(PID::ELECTRON);
	allleptons.acceptIdPair(PID::MUON);
	Cut cuts = Cuts::abseta < 2.5 && Cuts::pT > 20*GeV;
	DressedLeptons leptons(fs, allleptons, 0.1, cuts);
	- addProjection(leptons, "leptons");
	+ declare(leptons, "leptons");

	// Leading neutrinos for Etmiss
	LeadingParticlesFinalState neutrinos(fs);
	neutrinos.addParticleIdPair(PID::NU_E);
	neutrinos.addParticleIdPair(PID::NU_MU);
	neutrinos.setLeadingOnly(true);
	- addProjection(neutrinos, "neutrinos");
	+ declare(neutrinos, "neutrinos");

	// Input for the jets: "Neutrinos, electrons, and muons from decays of the
	// massive W boson were not used"
	VetoedFinalState veto;
	veto.addVetoOnThisFinalState(leptons);
	veto.addVetoOnThisFinalState(neutrinos);
	FastJets jets(veto, FastJets::ANTIKT, 0.4);
	jets.useInvisibles(true);
	- addProjection(jets, "jets");
	+ declare(jets, "jets");

	for (size_t i = 0; i < 2; ++i) {
	_h_NjetIncl[i] = bookHisto1D(1, 1, i+1);
	_h_RatioNjetIncl[i] = bookScatter2D(2, 1, i+1);
	_h_FirstJetPt_1jet[i] = bookHisto1D(3, 1, i+1);
	_h_FirstJetPt_2jet[i] = bookHisto1D(4, 1, i+1);
	_h_FirstJetPt_3jet[i] = bookHisto1D(5, 1, i+1);
	_h_FirstJetPt_4jet[i] = bookHisto1D(6, 1, i+1);
	_h_SecondJetPt_2jet[i] = bookHisto1D(7, 1, i+1);
	_h_SecondJetPt_3jet[i] = bookHisto1D(8, 1, i+1);
	_h_SecondJetPt_4jet[i] = bookHisto1D(9, 1, i+1);
	_h_ThirdJetPt_3jet[i] = bookHisto1D(10, 1, i+1);
	_h_ThirdJetPt_4jet[i] = bookHisto1D(11, 1, i+1);
	_h_FourthJetPt_4jet[i] = bookHisto1D(12, 1, i+1);
	_h_Ht_1jet[i] = bookHisto1D(13, 1, i+1);
	_h_Ht_2jet[i] = bookHisto1D(14, 1, i+1);
	_h_Ht_3jet[i] = bookHisto1D(15, 1, i+1);
	_h_Ht_4jet[i] = bookHisto1D(16, 1, i+1);
	_h_Minv_2jet[i] = bookHisto1D(17, 1, i+1);
	_h_Minv_3jet[i] = bookHisto1D(18, 1, i+1);
	_h_Minv_4jet[i] = bookHisto1D(19, 1, i+1);
	_h_JetRapidity[i] = bookHisto1D(20, 1, i+1);
	_h_DeltaYElecJet[i] = bookHisto1D(21, 1, i+1);
	_h_SumYElecJet[i] = bookHisto1D(22, 1, i+1);
	_h_DeltaR_2jet[i] = bookHisto1D(23, 1, i+1);
	_h_DeltaY_2jet[i] = bookHisto1D(24, 1, i+1);
	_h_DeltaPhi_2jet[i] = bookHisto1D(25, 1, i+1);
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const vector<DressedLepton>& leptons = applyProjection<DressedLeptons>(event, "leptons").dressedLeptons();
	- Particles neutrinos = applyProjection<FinalState>(event, "neutrinos").particlesByPt();
	+ const vector<DressedLepton>& leptons = apply<DressedLeptons>(event, "leptons").dressedLeptons();
	+ Particles neutrinos = apply<FinalState>(event, "neutrinos").particlesByPt();

	if (leptons.size() != 1 \|\| (neutrinos.size() == 0)) {
	vetoEvent;
	}

	FourMomentum lepton = leptons[0].momentum();
	FourMomentum p_miss = neutrinos[0].momentum();
	if (p_miss.Et() < 25.0*GeV) {
	vetoEvent;
	}

	double mT = sqrt(2.0 * lepton.pT() * p_miss.Et() * (1.0 - cos( lepton.phi()-p_miss.phi()) ) );
	if (mT < 40.0*GeV) {
	vetoEvent;
	}

	double jetcuts[] = { 30.0GeV, 20.0GeV };
	- const FastJets& jetpro = applyProjection<FastJets>(event, "jets");
	+ const FastJets& jetpro = apply<FastJets>(event, "jets");

	for (size_t i = 0; i < 2; ++i) {
	vector<FourMomentum> jets;
	double HT = lepton.pT() + p_miss.pT();
	foreach (const Jet& jet, jetpro.jetsByPt(jetcuts[i])) {
	if (jet.absrap() < 4.4 && deltaR(lepton, jet.momentum()) > 0.5) {
	jets.push_back(jet.momentum());
	HT += jet.pT();
	}
	}

	_h_NjetIncl[i]->fill(0.0, weight);

	// Njet>=1 observables
	if (jets.size() < 1) continue;
	_h_NjetIncl[i]->fill(1.0, weight);
	_h_FirstJetPt_1jet[i]->fill(jets[0].pT(), weight);
	_h_JetRapidity[i]->fill(jets[0].rapidity(), weight);
	_h_Ht_1jet[i]->fill(HT, weight);
	_h_DeltaYElecJet[i]->fill(lepton.rapidity()-jets[0].rapidity(), weight);
	_h_SumYElecJet[i]->fill(lepton.rapidity()+jets[0].rapidity(), weight);

	// Njet>=2 observables
	if (jets.size() < 2) continue;
	_h_NjetIncl[i]->fill(2.0, weight);
	_h_FirstJetPt_2jet[i]->fill(jets[0].pT(), weight);
	_h_SecondJetPt_2jet[i]->fill(jets[1].pT(), weight);
	_h_Ht_2jet[i]->fill(HT, weight);
	double m2_2jet = FourMomentum(jets[0]+jets[1]).mass2();
	_h_Minv_2jet[i]->fill(m2_2jet>0.0 ? sqrt(m2_2jet) : 0.0, weight);
	_h_DeltaR_2jet[i]->fill(deltaR(jets[0], jets[1]), weight);
	_h_DeltaY_2jet[i]->fill(jets[0].rapidity()-jets[1].rapidity(), weight);
	_h_DeltaPhi_2jet[i]->fill(deltaPhi(jets[0], jets[1]), weight);

	// Njet>=3 observables
	if (jets.size() < 3) continue;
	_h_NjetIncl[i]->fill(3.0, weight);
	_h_FirstJetPt_3jet[i]->fill(jets[0].pT(), weight);
	_h_SecondJetPt_3jet[i]->fill(jets[1].pT(), weight);
	_h_ThirdJetPt_3jet[i]->fill(jets[2].pT(), weight);
	_h_Ht_3jet[i]->fill(HT, weight);
	double m2_3jet = FourMomentum(jets[0]+jets[1]+jets[2]).mass2();
	_h_Minv_3jet[i]->fill(m2_3jet>0.0 ? sqrt(m2_3jet) : 0.0, weight);

	// Njet>=4 observables
	if (jets.size() < 4) continue;
	_h_NjetIncl[i]->fill(4.0, weight);
	_h_FirstJetPt_4jet[i]->fill(jets[0].pT(), weight);
	_h_SecondJetPt_4jet[i]->fill(jets[1].pT(), weight);
	_h_ThirdJetPt_4jet[i]->fill(jets[2].pT(), weight);
	_h_FourthJetPt_4jet[i]->fill(jets[3].pT(), weight);
	_h_Ht_4jet[i]->fill(HT, weight);
	double m2_4jet = FourMomentum(jets[0]+jets[1]+jets[2]+jets[3]).mass2();
	_h_Minv_4jet[i]->fill(m2_4jet>0.0 ? sqrt(m2_4jet) : 0.0, weight);

	// Njet>=5 observables
	if (jets.size() < 5) continue;
	_h_NjetIncl[i]->fill(5.0, weight);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t i = 0; i < 2; ++i) {

	// Construct jet multiplicity ratio
	for (size_t n = 1; n < _h_NjetIncl[i]->numBins(); ++n) {
	YODA::HistoBin1D& b0 = _h_NjetIncl[i]->bin(n-1);
	YODA::HistoBin1D& b1 = _h_NjetIncl[i]->bin(n);
	if (b0.height() == 0.0 \|\| b1.height() == 0.0) continue;
	_h_RatioNjetIncl[i]->addPoint(n, b1.height()/b0.height(), 0.5,
	b1.height()/b0.height() * (b0.relErr() + b1.relErr()));
	}

	// Scale all histos to the cross section
	const double factor = crossSection()/sumOfWeights();
	scale(_h_DeltaPhi_2jet[i], factor);
	scale(_h_DeltaR_2jet[i], factor);
	scale(_h_DeltaY_2jet[i], factor);
	scale(_h_DeltaYElecJet[i], factor);
	scale(_h_FirstJetPt_1jet[i], factor);
	scale(_h_FirstJetPt_2jet[i], factor);
	scale(_h_FirstJetPt_3jet[i], factor);
	scale(_h_FirstJetPt_4jet[i], factor);
	scale(_h_FourthJetPt_4jet[i], factor);
	scale(_h_Ht_1jet[i], factor);
	scale(_h_Ht_2jet[i], factor);
	scale(_h_Ht_3jet[i], factor);
	scale(_h_Ht_4jet[i], factor);
	scale(_h_JetRapidity[i], factor);
	scale(_h_Minv_2jet[i], factor);
	scale(_h_Minv_3jet[i], factor);
	scale(_h_Minv_4jet[i], factor);
	scale(_h_NjetIncl[i], factor);
	scale(_h_SecondJetPt_2jet[i], factor);
	scale(_h_SecondJetPt_3jet[i], factor);
	scale(_h_SecondJetPt_4jet[i], factor);
	scale(_h_SumYElecJet[i], factor);
	scale(_h_ThirdJetPt_3jet[i], factor);
	scale(_h_ThirdJetPt_4jet[i], factor);
	}
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_DeltaPhi_2jet[2];
	Histo1DPtr _h_DeltaR_2jet[2];
	Histo1DPtr _h_DeltaY_2jet[2];
	Histo1DPtr _h_DeltaYElecJet[2];
	Histo1DPtr _h_FirstJetPt_1jet[2];
	Histo1DPtr _h_FirstJetPt_2jet[2];
	Histo1DPtr _h_FirstJetPt_3jet[2];
	Histo1DPtr _h_FirstJetPt_4jet[2];
	Histo1DPtr _h_FourthJetPt_4jet[2];
	Histo1DPtr _h_Ht_1jet[2];
	Histo1DPtr _h_Ht_2jet[2];
	Histo1DPtr _h_Ht_3jet[2];
	Histo1DPtr _h_Ht_4jet[2];
	Histo1DPtr _h_JetRapidity[2];
	Histo1DPtr _h_Minv_2jet[2];
	Histo1DPtr _h_Minv_3jet[2];
	Histo1DPtr _h_Minv_4jet[2];
	Histo1DPtr _h_NjetIncl[2];
	Scatter2DPtr _h_RatioNjetIncl[2];
	Histo1DPtr _h_SecondJetPt_2jet[2];
	Histo1DPtr _h_SecondJetPt_3jet[2];
	Histo1DPtr _h_SecondJetPt_4jet[2];
	Histo1DPtr _h_SumYElecJet[2];
	Histo1DPtr _h_ThirdJetPt_3jet[2];
	Histo1DPtr _h_ThirdJetPt_4jet[2];
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1083318);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1084540.cc b/src/Analyses/ATLAS_2012_I1084540.cc
	--- a/src/Analyses/ATLAS_2012_I1084540.cc
	+++ b/src/Analyses/ATLAS_2012_I1084540.cc
	@@ -1,231 +1,231 @@
	// -- C++ --
	/**
	* @name ATLAS Diffractive Gaps Rivet Analysis
	* @author Tim Martin, tim.martin@cern.ch
	* @version 1.0
	* @date 16/01/2012
	* @see http://arxiv.org/abs/1201.2808
	* @note pp, sqrt(s) = 7 TeV
	* @note Rapidity gap finding algorithm designed to compliment
	* the ATLAS detector acceptance. Forward rapidity gap sizes
	* are calculated for each event, considering all stable
	* particles above pT cut values 200, 400, 600 and 800 MeV in
	* turn. A forward rapidity gap is defined to be the largest
	* continuous region stretching inward from either edge of the
	* detector at eta = \|4.9\| which contains zero particles above
	* pT Cut. Soft diffractive topologies are isolated at large
	* gap sizes.
	*
	*/
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	class ATLAS_2012_I1084540 : public Analysis {
	public:

	ATLAS_2012_I1084540() : Analysis("ATLAS_2012_I1084540") {}


	/// @name Analysis methods
	//@{
	/// Book histograms and initialise projections before the run
	void init() {
	//All final states. Rapidity range = ATLAS calorimetry. Lowest pT cut = 200 MeV.
	const FinalState cnfs2(-_etaMax, _etaMax, 0.2 * GeV);
	const FinalState cnfs4(-_etaMax, _etaMax, 0.4 * GeV);
	const FinalState cnfs6(-_etaMax, _etaMax, 0.6 * GeV);
	const FinalState cnfs8(-_etaMax, _etaMax, 0.8 * GeV);
	- addProjection(cnfs2, "CNFS2");
	- addProjection(cnfs4, "CNFS4");
	- addProjection(cnfs6, "CNFS6");
	- addProjection(cnfs8, "CNFS8");
	+ declare(cnfs2, "CNFS2");
	+ declare(cnfs4, "CNFS4");
	+ declare(cnfs6, "CNFS6");
	+ declare(cnfs8, "CNFS8");

	_etaBinSize = (2. * _etaMax)/(double)_etaBins;

	//Book histogram
	_h_DeltaEtaF_200 = bookHisto1D(1, 1, 1);
	_h_DeltaEtaF_400 = bookHisto1D(2, 1, 1);
	_h_DeltaEtaF_600 = bookHisto1D(3, 1, 1);
	_h_DeltaEtaF_800 = bookHisto1D(4, 1, 1);
	}

	private:
	void fillMap(const FinalState& fs, bool* energyMap, double pTcut) {
	// Fill true/false array by iterating over particles and compare their
	// pT with pTcut
	foreach (const Particle& p, fs.particles(cmpMomByEta)) {
	int checkBin = -1;
	double checkEta = -_etaMax;
	while (1) {
	checkEta += _etaBinSize;
	++checkBin;
	if (p.eta() < checkEta) {
	energyMap[checkBin] = (p.pT() > pTcut * GeV);
	break;
	}
	}
	}
	}

	public:
	/// Perform the per-event analysis
	void analyze(const Event& event) {
	static unsigned int event_count = 0;
	++event_count;
	const double weight = event.weight();
	- const FinalState& fs2 = applyProjection<FinalState>(event, "CNFS2");
	- const FinalState& fs4 = applyProjection<FinalState>(event, "CNFS4");
	- const FinalState& fs6 = applyProjection<FinalState>(event, "CNFS6");
	- const FinalState& fs8 = applyProjection<FinalState>(event, "CNFS8");
	+ const FinalState& fs2 = apply<FinalState>(event, "CNFS2");
	+ const FinalState& fs4 = apply<FinalState>(event, "CNFS4");
	+ const FinalState& fs6 = apply<FinalState>(event, "CNFS6");
	+ const FinalState& fs8 = apply<FinalState>(event, "CNFS8");

	// Set up Yes/No arrays for energy in each eta bin at each pT cut
	bool energyMap_200[_etaBins];
	bool energyMap_400[_etaBins];
	bool energyMap_600[_etaBins];
	bool energyMap_800[_etaBins];
	for (int i = 0; i < _etaBins; ++i) {
	energyMap_200[i] = false;
	energyMap_400[i] = false;
	energyMap_600[i] = false;
	energyMap_800[i] = false;
	}

	// Veto bins based on final state particles > Cut (Where Cut = 200 - 800 MeV pT)
	fillMap(fs2, energyMap_200, 0.2);
	fillMap(fs4, energyMap_400, 0.4);
	fillMap(fs6, energyMap_600, 0.6);
	fillMap(fs8, energyMap_800, 0.8);

	// Apply gap finding algorithm
	// Detector layout follows...
	// -Eta [Proton --- DetectorCSide --- DetectorBarrel --- DetectorASide --- Proton] +Eta
	bool gapDirectionAt200 = false; //False is gap on C size, True is gap on A side.
	double largestEdgeGap_200 = 0.;
	double largestEdgeGap_400 = 0.;
	double largestEdgeGap_600 = 0.;
	double largestEdgeGap_800 = 0.;

	for (int E = 200; E <= 800; E += 200) {
	double EdgeGapSizeA = -1, EdgeGapSizeC = -1;
	bool* energyMap = 0;
	switch (E) {
	case 200: energyMap = energyMap_200; break;
	case 400: energyMap = energyMap_400; break;
	case 600: energyMap = energyMap_600; break;
	case 800: energyMap = energyMap_800; break;
	}

	// Look left to right
	for (int a = 0; a < _etaBins; ++a) {
	if (energyMap[a] == true) {
	EdgeGapSizeA = (_etaBinSize * a);
	break;
	}
	}

	// And look right to left
	for (int c = _etaBins-1; c >= 0; --c) {
	if (energyMap[c] == true) {
	EdgeGapSizeC = (2 * _etaMax) - (_etaBinSize * (c+1));
	if (fuzzyEquals(EdgeGapSizeC, 4.47035e-08)) EdgeGapSizeC = 0.0;
	break;
	}
	}
	// Put your hands on your hips

	// Find the largest gap
	double largestEdgeGap = 0.;
	if (E == 200) {
	// If the 200 MeV pass, take the biggest of the two gaps. Make note of which side for higher pT cuts.
	largestEdgeGap = std::max(EdgeGapSizeA,EdgeGapSizeC);
	gapDirectionAt200 = (EdgeGapSizeA > EdgeGapSizeC);
	} else {
	// Use the direction from 200 MeV pass, most accurate measure of which side gap is on.
	if (gapDirectionAt200) {
	largestEdgeGap = EdgeGapSizeA;
	}
	else largestEdgeGap = EdgeGapSizeC;
	}

	// Check case of empty detector
	if (largestEdgeGap < 0.0) largestEdgeGap = 2.0 * _etaMax;

	// Fill bin centre
	switch (E) {
	case 200: _h_DeltaEtaF_200->fill(largestEdgeGap + _etaBinSize/2., weight); break;
	case 400: _h_DeltaEtaF_400->fill(largestEdgeGap + _etaBinSize/2., weight); break;
	case 600: _h_DeltaEtaF_600->fill(largestEdgeGap + _etaBinSize/2., weight); break;
	case 800: _h_DeltaEtaF_800->fill(largestEdgeGap + _etaBinSize/2., weight); break;
	}

	if (E == 200) largestEdgeGap_200 = largestEdgeGap;
	if (E == 400) largestEdgeGap_400 = largestEdgeGap;
	if (E == 600) largestEdgeGap_600 = largestEdgeGap;
	if (E == 800) largestEdgeGap_800 = largestEdgeGap;
	}

	// Algorithm result every 1000 events
	if (event_count % 1000 == 0) {
	for (int E = 200; E <= 800; E += 200) {
	bool* energyMap = 0;
	double largestEdgeGap = 0;
	switch (E) {
	case 200: energyMap = energyMap_200; largestEdgeGap = largestEdgeGap_200; break;
	case 400: energyMap = energyMap_400; largestEdgeGap = largestEdgeGap_400; break;
	case 600: energyMap = energyMap_600; largestEdgeGap = largestEdgeGap_600; break;
	case 800: energyMap = energyMap_800; largestEdgeGap = largestEdgeGap_800; break;
	}
	MSG_DEBUG("Largest Forward Gap at pT Cut " << E << " MeV=" << largestEdgeGap
	<< " eta, NFinalState pT > 200 in ATLAS acceptance:" << fs2.particles().size());
	std::string hitPattern = "Detector HitPattern=-4.9[";
	for (int a = 0; a < _etaBins; ++a) {
	if (energyMap[a] == true) hitPattern += "X";
	else hitPattern += "_";
	}
	hitPattern += "]4.9";
	MSG_DEBUG(hitPattern);
	std::string gapArrow = " ";
	if (!gapDirectionAt200) {
	int drawSpaces = (int)(_etaBins - (largestEdgeGap/_etaBinSize) + 0.5);
	for (int i = 0; i < drawSpaces; ++i) gapArrow += " ";
	}
	int drawArrows = (int)((largestEdgeGap/_etaBinSize) + 0.5);
	for (int i = 0; i < drawArrows; ++i) gapArrow += "^";
	MSG_DEBUG(gapArrow);
	}
	}
	}

	/// Normalise histograms after the run, Scale to cross section
	void finalize() {
	MSG_DEBUG("Cross Section=" << crossSection() / millibarn << "mb, SumOfWeights=" << sumOfWeights());
	scale(_h_DeltaEtaF_200, (crossSection() / millibarn)/sumOfWeights());
	scale(_h_DeltaEtaF_400, (crossSection() / millibarn)/sumOfWeights());
	scale(_h_DeltaEtaF_600, (crossSection() / millibarn)/sumOfWeights());
	scale(_h_DeltaEtaF_800, (crossSection() / millibarn)/sumOfWeights());
	}
	//@}

	private:
	/// @name Histograms
	//@{
	Histo1DPtr _h_DeltaEtaF_200;
	Histo1DPtr _h_DeltaEtaF_400;
	Histo1DPtr _h_DeltaEtaF_600;
	Histo1DPtr _h_DeltaEtaF_800;
	//@}
	/// @name Private variables
	//@{
	static constexpr int _etaBins = 49;
	static constexpr double _etaMax = 4.9;
	double _etaBinSize;
	//@}
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1084540);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1091481.cc b/src/Analyses/ATLAS_2012_I1091481.cc
	--- a/src/Analyses/ATLAS_2012_I1091481.cc
	+++ b/src/Analyses/ATLAS_2012_I1091481.cc
	@@ -1,179 +1,179 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class ATLAS_2012_I1091481 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1091481()
	: Analysis("ATLAS_2012_I1091481")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {

	ChargedFinalState cfs100(Cuts::abseta < 2.5 && Cuts::pT > 0.1*GeV);
	- addProjection(cfs100,"CFS100");
	+ declare(cfs100,"CFS100");
	ChargedFinalState cfs500(Cuts::abseta < 2.5 && Cuts::pT > 0.5*GeV);
	- addProjection(cfs500,"CFS500");
	+ declare(cfs500,"CFS500");

	// collision energy
	int isqrts = -1;
	if (fuzzyEquals(sqrtS(), 900*GeV)) isqrts = 2;
	if (fuzzyEquals(sqrtS(), 7*TeV)) isqrts = 1;
	assert(isqrts > 0);

	_sE_10_100 = bookHisto1D(isqrts, 1, 1);
	_sE_1_100 = bookHisto1D(isqrts, 1, 2);
	_sE_10_500 = bookHisto1D(isqrts, 1, 3);

	_sEta_10_100 = bookHisto1D(isqrts, 2, 1);
	_sEta_1_100 = bookHisto1D(isqrts, 2, 2);
	_sEta_10_500 = bookHisto1D(isqrts, 2, 3);

	norm_inclusive = 0.;
	norm_lowPt = 0.;
	norm_pt500 = 0.;
	}


	// Recalculate particle energy assuming pion mass
	double getPionEnergy(const Particle& p) {
	double m_pi = 0.1396*GeV;
	double p2 = p.p3().mod2()/(GeV*GeV);
	return sqrt(sqr(m_pi) + p2);
	}


	// S_eta core for one event
	//
	// -1 + 1/Nch * \|sum_j^Nch exp[i*(xi eta_j - Phi_j)]\|^2
	//
	double getSeta(const Particles& part, double xi) {
	std::complex<double> c_eta (0.0, 0.0);
	foreach (const Particle& p, part) {
	double eta = p.eta();
	double phi = p.phi();
	double arg = xi*eta-phi;
	std::complex<double> temp(cos(arg), sin(arg));
	c_eta += temp;
	}
	return std::norm(c_eta)/part.size() - 1.0;
	}


	// S_E core for one event
	//
	// -1 + 1/Nch * \|sum_j^Nch exp[i*(omega X_j - Phi_j)]\|^2
	//
	double getSE(const Particles& part, double omega) {
	double Xj = 0.0;
	std::complex<double> c_E (0.0, 0.0);
	for (unsigned int i=0; i < part.size(); ++i) {
	Xj += 0.5*getPionEnergy(part[i]);
	double phi = part[i].phi();
	double arg = omega*Xj - phi;
	std::complex<double> temp(cos(arg), sin(arg));
	c_E += temp;
	Xj += 0.5*getPionEnergy(part[i]);
	}
	return std::norm(c_E)/part.size() - 1.0;
	}


	// Convenient fill function
	void fillS(Histo1DPtr h, const Particles& part, double weight, bool SE=true) {
	// Loop over bins, take bin centers as parameter values
	for(size_t i=0; i < h->numBins(); ++i) {
	double x = h->bin(i).xMid();
	double width = h->bin(i).xMax() - h->bin(i).xMin();
	double y;
	if(SE) y = getSE(part, x);
	else y = getSeta(part, x);
	h->fill(x, y * width * weight);
	// Histo1D objects will be converted to Scatter2D objects for plotting
	// As part of this conversion, Rivet will divide by bin width
	// However, we want the (x,y) of the Scatter2D to be the (binCenter, sumW) of
	// the current Histo1D. This is why in the above line we multiply by bin width,
	// so as to undo later division by bin width.
	//
	// Could have used Scatter2D objects in the first place, but they cannot be merged
	// as easily as Histo1Ds can using yodamerge (missing ScaledBy attribute)
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	double weight = event.weight();

	// Charged fs
	- const ChargedFinalState& cfs100 = applyProjection<ChargedFinalState>(event, "CFS100");
	+ const ChargedFinalState& cfs100 = apply<ChargedFinalState>(event, "CFS100");
	const Particles part100 = cfs100.particles(cmpMomByEta);
	- const ChargedFinalState& cfs500 = applyProjection<ChargedFinalState>(event, "CFS500");
	+ const ChargedFinalState& cfs500 = apply<ChargedFinalState>(event, "CFS500");
	const Particles& part500 = cfs500.particles(cmpMomByEta);

	// Veto event if the most inclusive phase space has less than 10 particles and the max pT is > 10 GeV
	if (part100.size() < 11) vetoEvent;
	double ptmax = cfs100.particlesByPt()[0].pT()/GeV;
	if (ptmax > 10.0) vetoEvent;

	// Fill the pt>100, pTmax<10 GeV histos
	fillS(_sE_10_100, part100, weight, true);
	fillS(_sEta_10_100, part100, weight, false);
	norm_inclusive += weight;

	// Fill the pt>100, pTmax<1 GeV histos
	if (ptmax < 1.0) {
	fillS(_sE_1_100, part100, weight, true);
	fillS(_sEta_1_100, part100, weight, false);
	norm_lowPt += weight;
	}

	// Fill the pt>500, pTmax<10 GeV histos
	if (part500.size() > 10) {
	fillS(_sE_10_500, part500, weight, true );
	fillS(_sEta_10_500, part500, weight, false);
	norm_pt500 += weight;
	}
	}

	/// Normalise histograms etc., after the run
	void finalize() {
	// The scaling takes the multiple fills per event into account
	scale(_sE_10_100, 1.0/norm_inclusive);
	scale(_sE_1_100 , 1.0/norm_lowPt);
	scale(_sE_10_500, 1.0/norm_pt500);

	scale(_sEta_10_100, 1.0/norm_inclusive);
	scale(_sEta_1_100 , 1.0/norm_lowPt);
	scale(_sEta_10_500, 1.0/norm_pt500);
	}

	//@}


	private:

	Histo1DPtr _sE_10_100;
	Histo1DPtr _sE_1_100;
	Histo1DPtr _sE_10_500;

	Histo1DPtr _sEta_10_100;
	Histo1DPtr _sEta_1_100;
	Histo1DPtr _sEta_10_500;

	double norm_inclusive;
	double norm_lowPt;
	double norm_pt500;
	};


	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1091481);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1093734.cc b/src/Analyses/ATLAS_2012_I1093734.cc
	--- a/src/Analyses/ATLAS_2012_I1093734.cc
	+++ b/src/Analyses/ATLAS_2012_I1093734.cc
	@@ -1,320 +1,320 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"

	namespace Rivet {


	namespace {

	inline double sumAB(vector<double> vecX, vector<double> vecY, vector<double> vecW) {
	assert(vecX.size() == vecY.size() && vecX.size() == vecW.size());
	double sum(0);
	for (size_t i = 0; i < vecX.size(); i++) sum += vecW[i] * vecX[i] * vecY[i];
	return sum;
	}

	inline double sumA(vector<double> vecX, vector<double> vecW) {
	assert(vecX.size() == vecW.size());
	double sum(0);
	for (size_t i = 0; i < vecX.size(); i++) sum += vecX[i]*vecW[i];
	return sum;
	}

	inline double sumW(vector<double> vecW) {
	double sum(0);
	for (size_t i = 0; i < vecW.size(); i++) sum += vecW[i];
	return sum;
	}

	inline double mean(vector<double> vecX, vector<double> vecW) {
	return sumA(vecX, vecW) / sumW(vecW);
	}

	inline double standard_deviation(vector<double> vecX, vector<double> vecW) {
	const double x_bar = mean(vecX, vecW);
	double sum(0);
	for (size_t i = 0; i < vecX.size(); i++) {
	sum += vecW[i] * sqr(vecX[i] - x_bar);
	}
	return sqrt( sum / sumW(vecW) );
	}

	inline double a0_regression(vector<double> vecX, vector<double> vecY, vector<double> vecW) {
	const double numerator = sumA(vecY, vecW) * sumAB(vecX, vecX, vecW) - sumA(vecX, vecW) * sumAB(vecX, vecY, vecW);
	const double denominator = sumW(vecW) * sumAB(vecX, vecX, vecW) - sumA(vecX, vecW) * sumA(vecX, vecW);
	return numerator / denominator;
	}

	inline double a1_regression(vector<double> vecX, vector<double> vecY, vector<double> vecW) {
	const double numerator = sumW(vecW) * sumAB(vecX,vecY,vecW) - sumA(vecX, vecW) * sumA(vecY, vecW);
	const double denominator = sumW(vecW) * sumAB(vecX,vecX,vecW) - sumA(vecX, vecW) * sumA(vecX, vecW);
	return numerator/ denominator;
	}

	inline double a1_regression2(vector<double> vecX, vector<double> vecY, vector<double> vecW) {
	const double x_bar = mean(vecX, vecW);
	const double y_bar = mean(vecY, vecW);
	double sumXY(0);
	for (size_t i = 0; i < vecX.size(); i++) {
	sumXY += vecW[i] * (vecY[i]-y_bar) * (vecX[i]-x_bar);
	}
	return sumXY / ( standard_deviation(vecX, vecW) * standard_deviation(vecY, vecW) * sumW(vecW) );
	}

	inline double quadra_sum_residual(vector<double> vecX, vector<double> vecY, vector<double> vecW) {
	const double a0 = a0_regression(vecX, vecY, vecW);
	const double a1 = a1_regression(vecX, vecY, vecW);
	double sum(0);
	for (size_t i = 0; i < vecX.size(); i++) {
	const double y_est = a0 + a1*vecX[i];
	sum += vecW[i] * sqr(vecY[i] - y_est);
	}
	return sum;
	}

	inline double error_on_slope(vector<double> vecX, vector<double> vecY, vector<double> vecW) {
	const double quadra_sum_res = quadra_sum_residual(vecX, vecY, vecW);
	const double sqrt_quadra_sum_x = standard_deviation(vecX, vecW) * sqrt(sumW(vecW));
	return sqrt(quadra_sum_res/(sumW(vecW)-2)) / sqrt_quadra_sum_x;
	}

	}



	/// Forward-backward and azimuthal correlations in minimum bias events
	class ATLAS_2012_I1093734 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1093734()
	: Analysis("ATLAS_2012_I1093734")
	{
	// Stat convergence happens around 20k events, so it doesn't make sense to run this
	// analysis with much less than that. Given that, lets avoid some unnecessary vector
	// resizing by allocating sensible amounts in the first place.
	for (int ipt = 0; ipt < NPTBINS; ++ipt) {
	for (int k = 0; k < NETABINS; ++k) {
	_vecsNchF [ipt][k].reserve(10000);
	_vecsNchB [ipt][k].reserve(10000);
	_vecWeight[ipt][k].reserve(10000);
	if (ipt == 0) {
	_vecsSumptF[k].reserve(10000);
	_vecsSumptB[k].reserve(10000);
	}
	}
	}
	}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// FB correlations part

	// Projections
	for (int ipt = 0; ipt < NPTBINS; ++ipt) {
	const double ptmin = PTMINVALUES[ipt]*MeV;
	for (int ieta = 0; ieta < NETABINS; ++ieta) {
	- addProjection(ChargedFinalState(-ETAVALUES[ieta], -ETAVALUES[ieta]+0.5, ptmin), "Tracks"+ETABINNAMES[ieta]+"B"+PTBINNAMES[ipt]);
	- addProjection(ChargedFinalState( ETAVALUES[ieta]-0.5, ETAVALUES[ieta], ptmin), "Tracks"+ETABINNAMES[ieta]+"F"+PTBINNAMES[ipt]);
	+ declare(ChargedFinalState(-ETAVALUES[ieta], -ETAVALUES[ieta]+0.5, ptmin), "Tracks"+ETABINNAMES[ieta]+"B"+PTBINNAMES[ipt]);
	+ declare(ChargedFinalState( ETAVALUES[ieta]-0.5, ETAVALUES[ieta], ptmin), "Tracks"+ETABINNAMES[ieta]+"F"+PTBINNAMES[ipt]);
	}
	- addProjection(ChargedFinalState(-2.5, 2.5, ptmin), "CFS" + PTBINNAMES[ipt]);
	+ declare(ChargedFinalState(-2.5, 2.5, ptmin), "CFS" + PTBINNAMES[ipt]);
	}
	// Histos
	if (fuzzyEquals(sqrtS(), 7000*GeV, 1e-3)) {
	for (int ipt = 0; ipt < NPTBINS ; ++ipt ) _s_NchCorr_vsEta[ipt] = bookScatter2D(1+ipt, 2, 1, true);
	for (int ieta = 0; ieta < NETABINS; ++ieta) _s_NchCorr_vsPt [ieta] = bookScatter2D(8+ieta, 2, 1, true);
	_s_PtsumCorr = bookScatter2D(13, 2, 1, true);
	} else if (fuzzyEquals(sqrtS(), 900*GeV, 1e-3)) {
	_s_NchCorr_vsEta[0] = bookScatter2D(14, 2, 1, true);
	_s_PtsumCorr = bookScatter2D(15, 2, 1, true);
	}


	// Azimuthal correlations part
	// Projections
	const double ptmin = 500*MeV;
	- addProjection(ChargedFinalState(-2.5, 2.5, ptmin), "ChargedTracks25");
	- addProjection(ChargedFinalState(-2.0, 2.0, ptmin), "ChargedTracks20");
	- addProjection(ChargedFinalState(-1.0, 1.0, ptmin), "ChargedTracks10");
	+ declare(ChargedFinalState(-2.5, 2.5, ptmin), "ChargedTracks25");
	+ declare(ChargedFinalState(-2.0, 2.0, ptmin), "ChargedTracks20");
	+ declare(ChargedFinalState(-1.0, 1.0, ptmin), "ChargedTracks10");
	// Histos
	/// @todo Declare/book as temporary
	for (size_t ieta = 0; ieta < 3; ++ieta) {
	if (fuzzyEquals(sqrtS(), 7000*GeV, 1e-3)) {
	_s_dphiMin[ieta] = bookScatter2D(2+2*ieta, 1, 1, true);
	_s_diffSO[ieta] = bookScatter2D(8+2*ieta, 1, 1, true);
	_th_dphi[ieta] = YODA::Histo1D(refData(2+2*ieta, 1, 1));
	_th_same[ieta] = YODA::Histo1D(refData(8+2*ieta, 1, 1));
	_th_oppo[ieta] = YODA::Histo1D(refData(8+2*ieta, 1, 1));
	} else if (fuzzyEquals(sqrtS(), 900*GeV, 1e-3)) {
	_s_dphiMin[ieta] = bookScatter2D(1+2*ieta, 1, 1, true);
	_s_diffSO[ieta] = bookScatter2D(7+2*ieta, 1, 1, true);
	_th_dphi[ieta] = YODA::Histo1D(refData(1+2*ieta, 1, 1));
	_th_same[ieta] = YODA::Histo1D(refData(7+2*ieta, 1, 1));
	_th_oppo[ieta] = YODA::Histo1D(refData(7+2*ieta, 1, 1));
	}
	}

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	for (int ipt = 0; ipt < NPTBINS; ++ipt) {
	- const FinalState& charged = applyProjection<FinalState>(event, "CFS" + PTBINNAMES[ipt]);
	+ const FinalState& charged = apply<FinalState>(event, "CFS" + PTBINNAMES[ipt]);
	if (charged.particles().size() >= 2) {
	for (int ieta = 0; ieta < NETABINS; ++ieta) {
	const string fname = "Tracks" + ETABINNAMES[ieta] + "F" + PTBINNAMES[ipt];
	const string bname = "Tracks" + ETABINNAMES[ieta] + "B" + PTBINNAMES[ipt];
	- const ParticleVector particlesF = applyProjection<FinalState>(event, fname).particles();
	- const ParticleVector particlesB = applyProjection<FinalState>(event, bname).particles();
	+ const ParticleVector particlesF = apply<FinalState>(event, fname).particles();
	+ const ParticleVector particlesB = apply<FinalState>(event, bname).particles();
	_vecsNchF[ipt][ieta].push_back((double) particlesF.size());
	_vecsNchB[ipt][ieta].push_back((double) particlesB.size());
	_vecWeight[ipt][ieta].push_back(weight);

	// Sum pT only for 100 MeV particles
	if (ipt == 0) {
	double sumptF = 0;
	double sumptB = 0;
	foreach (const Particle& p, particlesF) sumptF += p.pT();
	foreach (const Particle& p, particlesB) sumptB += p.pT();
	_vecsSumptF[ieta].push_back(sumptF);
	_vecsSumptB[ieta].push_back(sumptB);
	}

	}
	}
	}


	string etabin[3] = { "10", "20", "25" };
	for (int ieta = 0; ieta < 3; ieta++) {
	const string fname = "ChargedTracks" + etabin[ieta];
	- const ParticleVector partTrks = applyProjection<FinalState>(event, fname).particlesByPt();
	+ const ParticleVector partTrks = apply<FinalState>(event, fname).particlesByPt();

	// Find the leading track and fill the temp histograms
	const Particle& plead = partTrks[0];
	foreach (const Particle& p, partTrks) {
	if (&plead == &p) continue; ///< Don't compare the lead particle to itself
	const double dphi = deltaPhi(p.momentum(), plead.momentum());
	_th_dphi[ieta].fill(dphi, weight);
	const bool sameside = (plead.eta() * p.eta() > 0);
	(sameside ? _th_same : _th_oppo)[ieta].fill(dphi, weight);
	}
	}
	}


	/// Finalize
	void finalize() {

	// FB part
	// @todo For 2D plots we will need _vecsNchF[i], _vecsNchB[j]
	for (int ipt = 0; ipt < NPTBINS; ++ipt) {
	for (int ieta = 0; ieta < NETABINS; ++ieta) {
	_s_NchCorr_vsEta[ipt]->point(ieta).setY(a1_regression2(_vecsNchF[ipt][ieta], _vecsNchB[ipt][ieta], _vecWeight[ipt][ieta]));
	_s_NchCorr_vsEta[ipt]->point(ieta).setYErr(error_on_slope(_vecsNchF[ipt][ieta], _vecsNchB[ipt][ieta], _vecWeight[ipt][ieta]));
	}
	// There is just one plot at 900 GeV so exit the loop here
	if (fuzzyEquals(sqrtS(), 900*GeV, 1e-3) && ipt == 0) break;
	}

	if (!fuzzyEquals(sqrtS(), 900*GeV, 1e-3)) { ///< No plots at 900 GeV
	for (int ieta = 0; ieta < NETABINS; ++ieta) {
	for (int ipt = 0; ipt < NPTBINS; ++ipt) {
	_s_NchCorr_vsPt[ieta]->point(ipt).setY(a1_regression2(_vecsNchF[ipt][ieta], _vecsNchB[ipt][ieta], _vecWeight[ipt][ieta]));
	_s_NchCorr_vsPt[ieta]->point(ipt).setYErr(error_on_slope(_vecsNchF[ipt][ieta], _vecsNchB[ipt][ieta], _vecWeight[ipt][ieta]));
	}
	}
	}

	// Sum pt only for 100 MeV particles
	for (int ieta = 0; ieta < NETABINS; ++ieta) {
	_s_PtsumCorr->point(ieta).setY(a1_regression2(_vecsSumptF[ieta], _vecsSumptB[ieta], _vecWeight[0][ieta]));
	_s_PtsumCorr->point(ieta).setYErr(error_on_slope(_vecsSumptF[ieta], _vecsSumptB[ieta], _vecWeight[0][ieta]));
	}


	// Azimuthal part
	for (int ieta = 0; ieta < 3; ieta++) {
	/// @note We don't just do a subtraction because of the risk of negative values and negative errors
	/// @todo Should the difference always be shown as positive?, i.e. y -> abs(y), etc.
	/// @todo Should the normalization be done _after_ the -ve value treatment?
	YODA::Histo1D hdiffSO = _th_same[ieta] - _th_oppo[ieta];
	hdiffSO.normalize(hdiffSO.bin(0).xWidth());
	for (size_t i = 0; i < hdiffSO.numBins(); ++i) {
	const double y = hdiffSO.bin(i).height() >= 0 ? hdiffSO.bin(i).height() : 0;
	const double yerr = hdiffSO.bin(i).heightErr() >= 0 ? hdiffSO.bin(i).heightErr() : 0;
	_s_diffSO[ieta]->point(i).setY(y, yerr);
	}

	// Extract minimal value
	double histMin = _th_dphi[ieta].bin(0).height();
	for (size_t iphi = 1; iphi < _th_dphi[ieta].numBins(); ++iphi) {
	histMin = std::min(histMin, _th_dphi[ieta].bin(iphi).height());
	}
	// Build scatter of differences
	double sumDiff = 0;
	for (size_t iphi = 0; iphi < _th_dphi[ieta].numBins(); ++iphi) {
	const double diff = _th_dphi[ieta].bin(iphi).height() - histMin;
	_s_dphiMin[ieta]->point(iphi).setY(diff, _th_dphi[ieta].bin(iphi).heightErr());
	sumDiff += diff;
	}
	// Normalize
	_s_dphiMin[ieta]->scale(1, 1/sumDiff);
	}

	}

	//@}


	private:

	static const int NPTBINS = 7;
	static const int NETABINS = 5;
	static const double PTMINVALUES[NPTBINS];
	static const string PTBINNAMES[NPTBINS];
	static const double ETAVALUES[NETABINS];
	static const string ETABINNAMES[NETABINS];

	vector<double> _vecWeight[NPTBINS][NETABINS];
	vector<double> _vecsNchF[NPTBINS][NETABINS];
	vector<double> _vecsNchB[NPTBINS][NETABINS];
	vector<double> _vecsSumptF[NETABINS];
	vector<double> _vecsSumptB[NETABINS];

	/// @name Histograms
	//@{
	Scatter2DPtr _s_NchCorr_vsEta[NPTBINS], _s_NchCorr_vsPt[NETABINS], _s_PtsumCorr;
	Scatter2DPtr _s_dphiMin[3], _s_diffSO[3];
	YODA::Histo1D _th_dphi[3], _th_same[3], _th_oppo[3];
	//@}

	};


	/// @todo Initialize these inline at declaration with C++11
	const double ATLAS_2012_I1093734::PTMINVALUES[] = {100, 200, 300, 500, 1000, 1500, 2000 };
	const string ATLAS_2012_I1093734::PTBINNAMES[] = { "100", "200", "300", "500", "1000", "1500", "2000" };
	const double ATLAS_2012_I1093734::ETAVALUES[] = {0.5, 1.0, 1.5, 2.0, 2.5};
	const string ATLAS_2012_I1093734::ETABINNAMES[] = { "05", "10", "15", "20", "25" };



	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1093734);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1093738.cc b/src/Analyses/ATLAS_2012_I1093738.cc
	--- a/src/Analyses/ATLAS_2012_I1093738.cc
	+++ b/src/Analyses/ATLAS_2012_I1093738.cc
	@@ -1,227 +1,200 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief Measurement of isolated gamma + jet + X differential cross-sections
	///
	/// Inclusive isolated gamma + jet cross-sections, differential in pT(gamma), for
	/// various photon and jet rapidity configurations.
	///
	/// @author Giovanni Marchiori
	class ATLAS_2012_I1093738 : public Analysis {
	public:

	// Constructor
	ATLAS_2012_I1093738()
	- : Analysis("ATLAS_2012_I1093738"),
	- _eta_bins_ph{0.0, 1.37, 1.52, 2.37},
	- _eta_bins_jet{0.0, 1.2, 2.8, 4.4}
	+ : Analysis("ATLAS_2012_I1093738")
	{ }


	// Book histograms and initialise projections before the run
	void init() {
	// Final state
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Voronoi eta-phi tessellation with KT jets, for ambient energy density calculation
	FastJets fj(fs, FastJets::KT, 0.5);
	fj.useJetArea(new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec()));
	- addProjection(fj, "KtJetsD05");
	+ declare(fj, "KtJetsD05");

	// Leading photon
	LeadingParticlesFinalState photonfs(FinalState(-1.37, 1.37, 25.0*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// FS excluding the leading photon
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(photonfs);
	- addProjection(vfs, "JetFS");
	+ declare(vfs, "JetFS");

	// Jets
	FastJets jetpro(vfs, FastJets::ANTIKT, 0.4);
	jetpro.useInvisibles();
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	_h_phbarrel_jetcentral_SS = bookHisto1D(1, 1, 1);
	_h_phbarrel_jetmedium_SS = bookHisto1D(2, 1, 1);
	_h_phbarrel_jetforward_SS = bookHisto1D(3, 1, 1);

	_h_phbarrel_jetcentral_OS = bookHisto1D(4, 1, 1);
	_h_phbarrel_jetmedium_OS = bookHisto1D(5, 1, 1);
	_h_phbarrel_jetforward_OS = bookHisto1D(6, 1, 1);
	}


	- /// @todo Use Rivet::binIndex()
	- int getEtaBin(double eta_w, int what) const {
	- double eta = fabs(eta_w);
	- int v_iter = 0;
	- if (what==0) {
	- for (v_iter=0; v_iter < (int)_eta_bins_ph.size()-1; v_iter++){
	- if (eta >= _eta_bins_ph.at(v_iter) && eta < _eta_bins_ph.at(v_iter+1))
	- break;
	- }
	- }
	- else if (what==1) {
	- for (v_iter=0; v_iter < (int)_eta_bins_jet.size()-1; v_iter++){
	- if (eta >= _eta_bins_jet.at(v_iter) && eta < _eta_bins_jet.at(v_iter+1))
	- break;
	- }
	- }
	- else {
	- for (v_iter=0; v_iter < (int)_eta_bins_areaoffset.size()-1; v_iter++){
	- if (eta >= _eta_bins_areaoffset.at(v_iter) && eta < _eta_bins_areaoffset.at(v_iter+1))
	- break;
	- }
	- }
	- return v_iter;
	+ int getEtaBin(double eta, int what) const {
	+ const double aeta = fabs(eta);
	+ if (what == 0) return binIndex(aeta, _eta_bins_ph);
	+ if (what == 1) return binIndex(aeta, _eta_bins_jet);
	+ return binIndex(aeta, _eta_bins_areaoffset);
	}


	// Perform the per-event analysis
	void analyze(const Event& event) {

	// Get the photon
	- const FinalState& photonfs = applyProjection<FinalState>(event, "LeadingPhoton");
	+ const FinalState& photonfs = apply<FinalState>(event, "LeadingPhoton");
	if (photonfs.particles().size() < 1) vetoEvent;
	const FourMomentum photon = photonfs.particles().front().momentum();

	// Get the jet
	- Jets jets = applyProjection<FastJets>(event, "Jets").jetsByPt(20.0*GeV);
	+ Jets jets = apply<FastJets>(event, "Jets").jetsByPt(20.0*GeV);
	if (jets.empty()) vetoEvent;
	FourMomentum leadingJet = jets[0].momentum();

	// Require jet separated from photon
	if (deltaR(photon, leadingJet) < 1.0) vetoEvent;

	// Veto if leading jet is outside plotted rapidity regions
	if (leadingJet.absrap() > 4.4) vetoEvent;

	- // Compute the median event energy density
	- const unsigned int skipnhardjets = 0;
	- _ptDensity.clear();
	- _sigma.clear();
	- _Njets.clear();
	+ // Compute the jet pT densities
	vector< vector<double> > ptDensities(_eta_bins_areaoffset.size()-1);
	-
	- FastJets fastjets = applyProjection<FastJets>(event, "KtJetsD05");
	+ FastJets fastjets = apply<FastJets>(event, "KtJetsD05");
	const shared_ptr<fastjet::ClusterSequenceArea> clust_seq_area = fastjets.clusterSeqArea();
	for (const Jet& jet : fastjets.jets()) {
	const double area = clust_seq_area->area(jet); //< Implicit call to pseudojet()
	- /// @todo Should be 1e-4?
	- if (area > 10e-4 && jet.abseta() < _eta_bins_areaoffset.back()) {
	- ptDensities.at(getEtaBin(jet.abseta(),2)).push_back(jet.pT()/area);
	+ if (area > 1e-4 && jet.abseta() < _eta_bins_areaoffset.back()) {
	+ ptDensities.at(getEtaBin(jet.abseta(), 2)) += jet.pT()/area;
	}
	}

	+ // Compute the median event energy density
	+ /// @todo This looks equivalent to median(ptDensities[b]) -- isn't SKIPNHARDJETS meant to be used as an offset?
	+ const unsigned int SKIPNHARDJETS = 0;
	+ vector<double> ptDensity;
	for (size_t b = 0; b < _eta_bins_areaoffset.size()-1; b++) {
	double median = 0.0;
	- double sigma = 0.0;
	- int Njets = 0;
	- if (ptDensities[b].size() > skipnhardjets) {
	+ if (ptDensities[b].size() > SKIPNHARDJETS) {
	std::sort(ptDensities[b].begin(), ptDensities[b].end());
	- int nDens = ptDensities[b].size() - skipnhardjets;
	+ const int nDens = ptDensities[b].size() - SKIPNHARDJETS;
	if (nDens % 2 == 0) {
	median = (ptDensities[b][nDens/2]+ptDensities[b][(nDens-2)/2])/2;
	} else {
	median = ptDensities[b][(nDens-1)/2];
	}
	- sigma = ptDensities[b][(int)(.15865*nDens)];
	- Njets = nDens;
	}
	- _ptDensity.push_back(median);
	- _sigma.push_back(sigma);
	- _Njets.push_back(Njets);
	+ ptDensity.push_back(median);
	}

	// Compute photon isolation with a standard ET cone
	- const Particles fs = applyProjection<FinalState>(event, "JetFS").particles();
	+ const Particles fs = apply<FinalState>(event, "JetFS").particles();
	FourMomentum mom_in_EtCone;
	const double ISO_DR = 0.4;
	const double CLUSTER_ETA_WIDTH = 0.25*5.0;
	const double CLUSTER_PHI_WIDTH = (PI/128.)*7.0;
	for (const Particle& p : fs) {
	// Check if it's in the cone of .4
	if (deltaR(photon, p) >= ISO_DR) continue;
	// Check if it's in the 5x7 central core
	if (fabs(deltaEta(photon, p)) < CLUSTER_ETA_WIDTH*0.5 &&
	fabs(deltaPhi(photon, p)) < CLUSTER_PHI_WIDTH*0.5) continue;
	// Increment sum
	mom_in_EtCone += p.momentum();
	}

	// Figure out the correction (area*density)
	- const double EtCone_area = PIISO_DRISO_DR - CLUSTER_ETA_WIDTH*CLUSTER_PHI_WIDTH;
	- const double correction = _ptDensity[getEtaBin(photon.abseta(),2)]*EtCone_area;
	+ const double ETCONE_AREA = PIISO_DRISO_DR - CLUSTER_ETA_WIDTH*CLUSTER_PHI_WIDTH;
	+ const double correction = ptDensity[getEtaBin(photon.abseta(),2)] * ETCONE_AREA;

	// Require photon to be isolated
	if (mom_in_EtCone.Et()-correction > 4.0*GeV) vetoEvent;

	const int photon_jet_sign = sign( leadingJet.rapidity() * photon.rapidity() );

	// Fill histos
	const double abs_jet_rapidity = fabs(leadingJet.rapidity());
	const double photon_pt = photon.pT()/GeV;
	const double abs_photon_eta = fabs(photon.eta());
	const double weight = event.weight();
	if (abs_photon_eta < 1.37) {
	if (abs_jet_rapidity < 1.2) {
	if (photon_jet_sign >= 1) {
	_h_phbarrel_jetcentral_SS->fill(photon_pt, weight);
	} else {
	_h_phbarrel_jetcentral_OS->fill(photon_pt, weight);
	}
	} else if (abs_jet_rapidity < 2.8) {
	if (photon_jet_sign >= 1) {
	_h_phbarrel_jetmedium_SS->fill(photon_pt, weight);
	} else {
	_h_phbarrel_jetmedium_OS->fill(photon_pt, weight);
	}
	} else if (abs_jet_rapidity < 4.4) {
	if (photon_jet_sign >= 1) {
	_h_phbarrel_jetforward_SS->fill(photon_pt, weight);
	} else {
	_h_phbarrel_jetforward_OS->fill(photon_pt, weight);
	}
	}
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_phbarrel_jetcentral_SS, crossSection()/sumOfWeights());
	scale(_h_phbarrel_jetcentral_OS, crossSection()/sumOfWeights());
	scale(_h_phbarrel_jetmedium_SS, crossSection()/sumOfWeights());
	scale(_h_phbarrel_jetmedium_OS, crossSection()/sumOfWeights());
	scale(_h_phbarrel_jetforward_SS, crossSection()/sumOfWeights());
	scale(_h_phbarrel_jetforward_OS, crossSection()/sumOfWeights());
	}


	private:

	Histo1DPtr _h_phbarrel_jetcentral_SS, _h_phbarrel_jetmedium_SS, _h_phbarrel_jetforward_SS;
	Histo1DPtr _h_phbarrel_jetcentral_OS, _h_phbarrel_jetmedium_OS, _h_phbarrel_jetforward_OS;

	- vector<float> _eta_bins_ph, _eta_bins_jet, _eta_bins_areaoffset;
	- vector<float> _ptDensity, _sigma, _Njets;
	+ const vector<double> _eta_bins_ph = {0.0, 1.37, 1.52, 2.37};
	+ const vector<double> _eta_bins_jet = {0.0, 1.2, 2.8, 4.4};
	+ const vector<double> _eta_bins_areaoffset = {0.0, 1.5, 3.0};

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1093738);


	}
	diff --git a/src/Analyses/ATLAS_2012_I1094061.cc b/src/Analyses/ATLAS_2012_I1094061.cc
	--- a/src/Analyses/ATLAS_2012_I1094061.cc
	+++ b/src/Analyses/ATLAS_2012_I1094061.cc
	@@ -1,346 +1,346 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class ATLAS_2012_I1094061 : public Analysis {

	////////////////////////////////////////////////////////////////////////////
	/**
	* Little container to hold a pair of foreground and background histos and then
	* divide them at the end of the analysis
	*/
	struct HistoPair{
	enum HistoType { FOREGROUND, BACKGROUND };

	HistoPair(): _analysis(0),
	_h_foreground(0), _h_background(0), _d_final(0)
	{ }

	void init(int ds, int xaxis, int yaxis, ATLAS_2012_I1094061* analysis){
	_ds = ds;
	_xaxis = xaxis;
	_yaxis = yaxis;
	_analysis = analysis;
	++HistoPair::_s_counter;
	const BinEdges& edges = _analysis->binEdges(_ds, _xaxis, _yaxis);
	string sCount = boost::lexical_cast<string>(HistoPair::_s_counter);
	_h_foreground = analysis->bookHistogram1D("tmpForeground" + sCount, edges);
	_h_background = analysis->bookHistogram1D("tmpBackground" + sCount, edges);
	}

	void fillForeground(double value, double weight){
	_h_foreground->fill(value, weight);
	_h_foreground->fill(-value, weight);
	}

	void fillBackground(double value, double weight){
	_h_background->fill(value, weight);
	_h_background->fill(-value, weight);
	}

	void fill(double value, double weight, HistoType type){

	switch(type){
	case FOREGROUND:
	fillForeground(value, weight);
	break;
	case BACKGROUND:
	fillBackground(value, weight);
	break;
	}
	}

	void finalize(double wgtSum, double bgWeight, double avNTracks){

	_h_foreground->scale(1. / wgtSum);
	_h_background->scale(1. / bgWeight);

	string histoPath = _analysis->histoPath(_ds, _xaxis, _yaxis);

	AIDA::IDataPointSet final = _analysis->histogramFactory().divide(histoPath, _h_foreground, *_h_background);

	for (int ii=0; ii!= final->size(); ++ii) {
	AIDA::IDataPoint* pt = final->point(ii);
	double y = pt->coordinate(1)->value();
	pt->coordinate(1)->setValue(y-(avNTracks - 1));
	}

	_analysis->histogramFactory().destroy(_h_foreground);
	_analysis->histogramFactory().destroy(_h_background);
	}

	private:

	int _ds, _xaxis, _yaxis;

	ATLAS_2012_I1094061 *_analysis;

	AIDA::IHistogram1D* _h_foreground;
	AIDA::IHistogram1D* _h_background;
	AIDA::IDataPointSet* _d_final;

	static short _s_counter;

	};


	////////////////////////////////////////////////////////////////////////////

	public:

	ATLAS_2012_I1094061(): Analysis("ATLAS_2012_I1094061"),
	_minpT(100.*MeV), _etaMax(2.5), _nVersions(5), _version(0),
	_etaCut(2.), _phiCut(0.5*M_PI),
	_historyInclusive(_nVersions, ParticleVector()), _historyN20(_nVersions, ParticleVector()),
	_historyInclusiveWgts(_nVersions, 0.), _historyN20Wgts(_nVersions, 0.),
	_particleCountInclusive(0.), _particleCountN20(0.),
	_weightInclusive(0.), _weightN20(0.),
	_bgWeightInclusive(0.), _bgWeightN20(0.){

	}

	////////////////////////////////////////////////////////////////////////////
	void init(){

	const ChargedFinalState cfs(-2.5, 2.5, _minpT);
	- addProjection(cfs, "ChargedParticles");
	+ declare(cfs, "ChargedParticles");

	// Only do the multiplicity > 20 plots for 7 TeV collisions
	_doN20 = (fabs(sqrtS() - 7000.GeV) < 0.1GeV);

	int yaxis = (_doN20)? 2: 1;

	_hp_DEta_0_pi.init(1, 1, yaxis, this);
	_hp_DEta_0_pi2.init(2, 1, yaxis, this);
	_hp_DEta_pi2_pi.init(3, 1, yaxis, this);

	_hp_DPhi_0_2.init(4, 1, yaxis, this);
	_hp_DPhi_2_5.init(5, 1, yaxis, this);

	if(_doN20){

	yaxis = 3;

	_hp_N20_DEta_0_pi.init(1, 1, yaxis, this);
	_hp_N20_DEta_0_pi2.init(2, 1, yaxis, this);
	_hp_N20_DEta_pi2_pi.init(3, 1, yaxis, this);

	_hp_N20_DPhi_0_2.init(4, 1, yaxis, this);
	_hp_N20_DPhi_2_5.init(5, 1, yaxis, this);

	}
	return;
	}

	////////////////////////////////////////////////////////////////////////////
	void analyze(const Event &evt){

	- const ChargedFinalState &cfsProj = applyProjection<ChargedFinalState>(evt, "ChargedParticles");
	+ const ChargedFinalState &cfsProj = apply<ChargedFinalState>(evt, "ChargedParticles");

	ParticleVector chargedParticles = cfsProj.particles();

	if(chargedParticles.size() < 2) vetoEvent;

	bool hasN20 = (_doN20 && chargedParticles.size() >= 20);

	double dMultiplicity = (double)chargedParticles.size();

	double multiplicityWeightIncr = dMultiplicity * evt.weight();

	_weightInclusive += evt.weight();
	_particleCountInclusive += multiplicityWeightIncr;

	if(hasN20){
	_weightN20 += evt.weight();
	_particleCountN20 += multiplicityWeightIncr;
	}

	double fgWeight = 2.*evt.weight() / dMultiplicity;

	for(ParticleVector::const_iterator p1 = chargedParticles.begin();
	p1 != chargedParticles.end(); ++p1){

	ParticleVector::const_iterator p2 = p1;
	++p2;

	// fill the foreground distributions
	while(p2 != chargedParticles.end()){
	fillHistosInclusive(p1, p2, fgWeight, HistoPair::FOREGROUND);
	if(hasN20) fillHistosN20(p1, p2, fgWeight, HistoPair::FOREGROUND);
	++p2;
	}// end filling the foreground distributions

	// loop over the history of particles from previous events and fill the background
	// by correlating those particles with the current event

	for(size_t version = 0; version != _nVersions; ++version){

	const ParticleVector &bgParticles = _historyInclusive[version];
	double bgWeight = evt.weight() * _historyInclusiveWgts[version];

	for(ParticleVector::const_iterator p2 = bgParticles.begin();
	p2 != bgParticles.end(); ++p2){
	fillHistosInclusive(p1, p2, bgWeight, HistoPair::BACKGROUND);
	_bgWeightInclusive += bgWeight;
	}

	if(!hasN20) continue;

	const ParticleVector &bgParticlesN20 = _historyN20[version];
	bgWeight = evt.weight() * _historyN20Wgts[version];

	for(ParticleVector::const_iterator p2 = bgParticlesN20.begin();
	p2 != bgParticlesN20.end(); ++p2){
	fillHistosN20(p1, p2, bgWeight, HistoPair::BACKGROUND);
	_bgWeightN20 += bgWeight;
	}

	}//end loop over particle history for background fill

	}// end particle loop

	// Overwrite the history for the version count number
	_historyInclusive[_version] = chargedParticles;
	_historyInclusiveWgts[_version] = evt.weight();

	if(hasN20){
	_historyN20[_version] = chargedParticles;
	_historyN20Wgts[_version] = evt.weight();
	}

	++_version;
	if(_version == _nVersions) _version = 0;

	return;
	}

	////////////////////////////////////////////////////////////////////////////
	void finalize(){

	double avMultiplicity = _particleCountInclusive / _weightInclusive;

	_hp_DEta_0_pi.finalize(_weightInclusive, _bgWeightInclusive, avMultiplicity);
	_hp_DEta_0_pi2.finalize(_weightInclusive, _bgWeightInclusive, avMultiplicity);
	_hp_DEta_pi2_pi.finalize(_weightInclusive,_bgWeightInclusive, avMultiplicity);

	_hp_DPhi_0_2.finalize(_weightInclusive, _bgWeightInclusive, avMultiplicity);
	_hp_DPhi_2_5.finalize(_weightInclusive, _bgWeightInclusive, avMultiplicity);

	if(_doN20){
	avMultiplicity = _particleCountN20 / _weightN20;
	_hp_N20_DEta_0_pi.finalize(_weightN20, _bgWeightN20, avMultiplicity);
	_hp_N20_DEta_0_pi2.finalize(_weightN20, _bgWeightN20, avMultiplicity);
	_hp_N20_DEta_pi2_pi.finalize(_weightN20, _bgWeightN20, avMultiplicity);

	_hp_N20_DPhi_0_2.finalize(_weightN20, _bgWeightN20, avMultiplicity);
	_hp_N20_DPhi_2_5.finalize(_weightN20, _bgWeightN20, avMultiplicity);
	}

	return;
	}

	////////////////////////////////////////////////////////////////////////////

	void fillHistos(const Particle &p1, const Particle &p2, double weight,
	HistoPair::HistoType type, bool inclusive){

	double dEta = fabs(p1.eta() - p2.eta());
	double dPhi = mapAngle0ToPi(p1.phi() - p2.phi());
	double dPhiShift = TWOPI - dPhi;

	HistoPair &dEta_0_pi = (inclusive)? _hp_DEta_0_pi :_hp_N20_DEta_0_pi;
	HistoPair &dPhi_0_2 = (inclusive)? _hp_DPhi_0_2 :_hp_N20_DPhi_0_2;
	HistoPair &dPhi_2_5 = (inclusive)? _hp_DPhi_2_5 :_hp_N20_DPhi_2_5;
	HistoPair &dEta_0_pi2 = (inclusive)? _hp_DEta_0_pi2 :_hp_N20_DEta_0_pi2;
	HistoPair &dEta_pi2_pi = (inclusive)? _hp_DEta_pi2_pi :_hp_N20_DEta_pi2_pi;

	dEta_0_pi.fill(dEta, weight, type);

	if(dEta < _etaCut){
	dPhi_0_2.fill(dPhi, weight, type);
	dPhi_0_2.fill(dPhiShift, weight, type);
	}else{
	dPhi_2_5.fill(dPhi, weight, type);
	dPhi_2_5.fill(dPhiShift, weight, type);
	}

	if(dPhi < _phiCut){
	dEta_0_pi2.fill(dEta, weight, type);
	}else{
	dEta_pi2_pi.fill(dEta, weight, type);
	}

	return;

	}
	////////////////////////////////////////////////////////////////////////////

	void fillHistosInclusive(const Particle &p1, const Particle &p2, double weight,
	HistoPair::HistoType type){

	fillHistos(p1, p2, weight, type, true);
	return;
	}

	void fillHistosN20(const Particle &p1, const Particle &p2, double weight,
	HistoPair::HistoType type){

	fillHistos(p1, p2, weight, type, false);
	return;
	}
	////////////////////////////////////////////////////////////////////////////


	double _minpT;
	double _etaMax;

	size_t _nVersions;
	size_t _version;

	double _etaCut;
	double _phiCut;

	/// The "history" vectors contain the history of particles from _nVersions previous events
	/// These are used to construct the background correlation.
	vector<ParticleVector> _historyInclusive;
	vector<ParticleVector> _historyN20;

	vector<double> _historyInclusiveWgts;
	vector<double> _historyN20Wgts;

	double _particleCountInclusive;
	double _particleCountN20;
	double _weightInclusive;
	double _weightN20;

	double _bgWeightInclusive;
	double _bgWeightN20;

	bool _doN20;

	HistoPair _hp_DEta_0_pi;
	HistoPair _hp_DEta_0_pi2;
	HistoPair _hp_DEta_pi2_pi;

	HistoPair _hp_DPhi_0_2;
	HistoPair _hp_DPhi_2_5;

	HistoPair _hp_N20_DEta_0_pi;
	HistoPair _hp_N20_DEta_0_pi2;
	HistoPair _hp_N20_DEta_pi2_pi;

	HistoPair _hp_N20_DPhi_0_2;
	HistoPair _hp_N20_DPhi_2_5;

	};


	short ATLAS_2012_I1094061::HistoPair::_s_counter = 0;


	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1094061);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1094564.cc b/src/Analyses/ATLAS_2012_I1094564.cc
	--- a/src/Analyses/ATLAS_2012_I1094564.cc
	+++ b/src/Analyses/ATLAS_2012_I1094564.cc
	@@ -1,342 +1,342 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	/// ATLAS jet substructure measurement
	class ATLAS_2012_I1094564 : public Analysis {
	public:

	ATLAS_2012_I1094564()
	: Analysis("ATLAS_2012_I1094564")
	{}


	// Returns constituents to make it easier to do the filtering
	PseudoJets splitjet(fastjet::PseudoJet jet, double& last_R, const FastJets& fj, bool& unclustered) const {

	// Build a new cluster sequence just using the constituents of this jet.
	fastjet::ClusterSequence cs(fj.clusterSeq()->constituents(jet), fastjet::JetDefinition(fastjet::cambridge_algorithm, M_PI/2.));

	// Get the jet back again
	vector<fastjet::PseudoJet> remadeJets = cs.inclusive_jets(0.);

	if ( remadeJets.size() != 1 ) return remadeJets;

	fastjet::PseudoJet remadeJet = remadeJets[0];
	fastjet::PseudoJet parent1, parent2;
	unclustered = false;

	while ( cs.has_parents(remadeJet, parent1, parent2) ) {
	if (parent1.squared_distance(parent2) < 0.09) break;
	if (parent1.m2() < parent2.m2()) {
	fastjet::PseudoJet tmp;
	tmp = parent1; parent1 = parent2; parent2 = tmp;
	}

	double ktdist = parent1.kt_distance(parent2);
	double rtycut2 = 0.3*0.3;
	if (parent1.m() < 0.67remadeJet.m() && ktdist > rtycut2remadeJet.m2()) {
	unclustered = true;
	break;
	} else {
	remadeJet = parent1;
	}
	}

	last_R = 0.5 * sqrt(parent1.squared_distance(parent2));
	return cs.constituents(remadeJet);
	}


	fastjet::PseudoJet filterjet(PseudoJets jets, double& stingy_R, const double def_R) const {
	if (stingy_R == 0.0) stingy_R = def_R;
	stingy_R = def_R < stingy_R ? def_R : stingy_R;
	fastjet::JetDefinition stingy_jet_def(fastjet::cambridge_algorithm, stingy_R);
	fastjet::ClusterSequence scs(jets, stingy_jet_def);
	vector<fastjet::PseudoJet> stingy_jets = sorted_by_pt(scs.inclusive_jets(0));
	fastjet::PseudoJet reconst_jet(0, 0, 0, 0);
	for (size_t isj = 0; isj < std::min((size_t) 3, stingy_jets.size()); ++isj) {
	reconst_jet += stingy_jets[isj];
	}
	return reconst_jet;
	}


	// These are custom functions for n-subjettiness.
	PseudoJets jetGetAxes(int n_jets, const PseudoJets& inputJets, double subR) const {
	// Sanity check
	if (inputJets.size() < (size_t) n_jets) {
	MSG_ERROR("Not enough input particles.");
	return inputJets;
	}

	// Get subjets, return
	fastjet::ClusterSequence sub_clust_seq(inputJets, fastjet::JetDefinition(fastjet::kt_algorithm, subR, fastjet::E_scheme, fastjet::Best));
	return sub_clust_seq.exclusive_jets(n_jets);
	}


	double jetTauValue(double beta, double jet_rad, const PseudoJets& particles, const PseudoJets& axes, double Rcut) const {
	double tauNum = 0.0;
	double tauDen = 0.0;

	if (particles.size() == 0) return 0.0;

	for (size_t i = 0; i < particles.size(); i++) {
	// find minimum distance (set R large to begin)
	double minR = 10000.0;
	for (size_t j = 0; j < axes.size(); j++) {
	double tempR = sqrt(particles[i].squared_distance(axes[j]));
	if (tempR < minR) minR = tempR;
	}
	if (minR > Rcut) minR = Rcut;
	// calculate nominator and denominator
	tauNum += particles[i].perp() * pow(minR,beta);
	tauDen += particles[i].perp() * pow(jet_rad,beta);
	}

	// return N-subjettiness (or 0 if denominator is 0)
	return safediv(tauNum, tauDen, 0);
	}


	void jetUpdateAxes(double beta, const PseudoJets& particles, PseudoJets& axes) const {
	vector<int> belongsto;
	for (size_t i = 0; i < particles.size(); i++) {
	// find minimum distance axis
	int assign = 0;
	double minR = 10000.0;
	for (size_t j = 0; j < axes.size(); j++) {
	double tempR = sqrt(particles[i].squared_distance(axes[j]));
	if (tempR < minR) {
	minR = tempR;
	assign = j;
	}
	}
	belongsto.push_back(assign);
	}

	// iterative step
	double deltaR2, distphi;
	vector<double> ynom, phinom, den;

	ynom.resize(axes.size());
	phinom.resize(axes.size());
	den.resize(axes.size());

	for (size_t i = 0; i < particles.size(); i++) {
	distphi = particles[i].phi() - axes[belongsto[i]].phi();
	deltaR2 = particles[i].squared_distance(axes[belongsto[i]]);
	if (deltaR2 == 0.) continue;
	if (abs(distphi) <= M_PI) phinom.at(belongsto[i]) += particles[i].perp() * particles[i].phi() * pow(deltaR2, (beta-2)/2);
	else if ( distphi > M_PI) phinom.at(belongsto[i]) += particles[i].perp() * (-2 * M_PI + particles[i].phi()) * pow(deltaR2, (beta-2)/2);
	else if ( distphi < M_PI) phinom.at(belongsto[i]) += particles[i].perp() * (+2 * M_PI + particles[i].phi()) * pow(deltaR2, (beta-2)/2);
	ynom.at(belongsto[i]) += particles[i].perp() * particles[i].rap() * pow(deltaR2, (beta-2)/2);
	den.at(belongsto[i]) += particles[i].perp() * pow(deltaR2, (beta-2)/2);
	}

	// reset to new axes
	for (size_t j = 0; j < axes.size(); j++) {
	if (den[j] == 0.) axes.at(j) = axes[j];
	else {
	double phi_new = fmod( 2M_PI + (phinom[j] / den[j]), 2M_PI );
	double pt_new = axes[j].perp();
	double y_new = ynom[j] / den[j];
	double px = pt_new * cos(phi_new);
	double py = pt_new * sin(phi_new);
	double pz = pt_new * sinh(y_new);
	axes.at(j).reset(px, py, pz, axes[j].perp()/2);
	}
	}
	}


	void init() {

	/// Projections:
	FinalState fs(-4.5, 4.5, 0.*GeV);
	- addProjection(fs, "FS");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 1.0), "AKT");
	- addProjection(FastJets(fs, FastJets::CAM, 1.2) , "CA" );
	+ declare(fs, "FS");
	+ declare(FastJets(fs, FastJets::ANTIKT, 1.0), "AKT");
	+ declare(FastJets(fs, FastJets::CAM, 1.2) , "CA" );

	/// Histograms:
	_h_camass.addHistogram(200, 300, bookHisto1D(1, 1, 1));
	_h_camass.addHistogram(300, 400, bookHisto1D(2, 1, 1));
	_h_camass.addHistogram(400, 500, bookHisto1D(3, 1, 1));
	_h_camass.addHistogram(500, 600, bookHisto1D(4, 1, 1));

	_h_filtmass.addHistogram(200, 300, bookHisto1D(5, 1, 1));
	_h_filtmass.addHistogram(300, 400, bookHisto1D(6, 1, 1));
	_h_filtmass.addHistogram(400, 500, bookHisto1D(7, 1, 1));
	_h_filtmass.addHistogram(500, 600, bookHisto1D(8, 1, 1));

	_h_ktmass.addHistogram(200, 300, bookHisto1D( 9, 1, 1));
	_h_ktmass.addHistogram(300, 400, bookHisto1D(10, 1, 1));
	_h_ktmass.addHistogram(400, 500, bookHisto1D(11, 1, 1));
	_h_ktmass.addHistogram(500, 600, bookHisto1D(12, 1, 1));

	_h_ktd12.addHistogram(200, 300, bookHisto1D(13, 1, 1));
	_h_ktd12.addHistogram(300, 400, bookHisto1D(14, 1, 1));
	_h_ktd12.addHistogram(400, 500, bookHisto1D(15, 1, 1));
	_h_ktd12.addHistogram(500, 600, bookHisto1D(16, 1, 1));

	_h_ktd23.addHistogram(200, 300, bookHisto1D(17, 1 ,1));
	_h_ktd23.addHistogram(300, 400, bookHisto1D(18, 1 ,1));
	_h_ktd23.addHistogram(400, 500, bookHisto1D(19, 1 ,1));
	_h_ktd23.addHistogram(500, 600, bookHisto1D(20, 1 ,1));

	_h_cat21.addHistogram(200, 300, bookHisto1D(21, 1, 1));
	_h_cat21.addHistogram(300, 400, bookHisto1D(22, 1, 1));
	_h_cat21.addHistogram(400, 500, bookHisto1D(23, 1, 1));
	_h_cat21.addHistogram(500, 600, bookHisto1D(24, 1, 1));

	_h_cat32.addHistogram(200, 300, bookHisto1D(25, 1, 1));
	_h_cat32.addHistogram(300, 400, bookHisto1D(26, 1, 1));
	_h_cat32.addHistogram(400, 500, bookHisto1D(27, 1, 1));
	_h_cat32.addHistogram(500, 600, bookHisto1D(28, 1, 1));

	_h_ktt21.addHistogram(200, 300, bookHisto1D(29, 1, 1));
	_h_ktt21.addHistogram(300, 400, bookHisto1D(30, 1, 1));
	_h_ktt21.addHistogram(400, 500, bookHisto1D(31, 1, 1));
	_h_ktt21.addHistogram(500, 600, bookHisto1D(32, 1, 1));

	_h_ktt32.addHistogram(200, 300, bookHisto1D(33, 1, 1));
	_h_ktt32.addHistogram(300, 400, bookHisto1D(34, 1, 1));
	_h_ktt32.addHistogram(400, 500, bookHisto1D(35, 1, 1));
	_h_ktt32.addHistogram(500, 600, bookHisto1D(36, 1, 1));
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	using namespace fastjet;

	// Get anti-kt jets with p_T > 200 GeV, check abs(y) < 2, and fill mass histograms
	- const FastJets& ktfj = applyProjection<FastJets>(event, "AKT");
	+ const FastJets& ktfj = apply<FastJets>(event, "AKT");
	PseudoJets ktjets = ktfj.pseudoJetsByPt(200*GeV);
	foreach (const PseudoJet ajet, ktjets) {
	if (abs(ajet.rap()) < 2) {
	_h_ktmass.fill(ajet.perp(), ajet.m(), weight);
	}
	}

	// Same as above but C/A jets
	- const FastJets& cafj = applyProjection<FastJets>(event, "CA");
	+ const FastJets& cafj = apply<FastJets>(event, "CA");
	PseudoJets cajets = cafj.pseudoJetsByPt(200*GeV);
	foreach (const PseudoJet ajet, cajets) {
	if (abs(ajet.rap()) < 2) {
	_h_camass.fill(ajet.perp(), ajet.m(), weight);
	}
	}

	// Split and filter.
	// Only do this to C/A jets in this analysis.
	foreach (const PseudoJet pjet, cajets) {
	if ( pjet.perp() > 600 \|\| abs(pjet.rap()) > 2) continue;
	double dR = 0;
	bool unclustered = false;
	PseudoJets split_jets = splitjet(pjet, dR, cafj, unclustered);
	if ( (dR < 0.15) \|\| (unclustered == false) ) continue;
	PseudoJet filt_jet = filterjet(split_jets, dR, 0.3);
	_h_filtmass.fill(filt_jet.perp(), filt_jet.m(), weight);
	}

	// Use the two last stages of clustering to get sqrt(d_12) and sqrt(d_23).
	// Only use anti-kt jets in this analysis.
	foreach (const PseudoJet pjet, ktjets) {
	if (pjet.perp() > 600 \|\| abs(pjet.rap()) > 2) continue;
	ClusterSequence subjet_cseq(ktfj.clusterSeq()->constituents(pjet), JetDefinition(kt_algorithm, M_PI/2.));
	double d_12 = subjet_cseq.exclusive_dmerge(1) * M_PI*M_PI/4.;
	double d_23 = subjet_cseq.exclusive_dmerge(2) * M_PI*M_PI/4.;
	_h_ktd12.fill(pjet.perp(), sqrt(d_12), weight);
	_h_ktd23.fill(pjet.perp(), sqrt(d_23), weight);
	}

	// N-subjettiness, use beta = 1 (no rationale given).
	// Uses the functions defined above.
	// C/A jets first, anti-kt after.
	double beta = 1.;
	//Rcut is used for particles that are very far from the closest axis. At 10
	//is has no impact on the outcome of the calculation
	double Rcut = 10.;
	foreach (const PseudoJet pjet, cajets) {
	if (pjet.perp() > 600*GeV \|\| fabs(pjet.rap()) > 2) continue;

	const PseudoJets constituents = cafj.clusterSeq()->constituents(pjet);
	if (constituents.size() < 3) continue;

	const PseudoJets axis1 = jetGetAxes(1, constituents, M_PI/2.0);
	const PseudoJets axis2 = jetGetAxes(2, constituents, M_PI/2.0);
	const PseudoJets axis3 = jetGetAxes(3, constituents, M_PI/2.0);

	const double radius = 1.2;
	const double tau1 = jetTauValue(beta, radius, constituents, axis1, Rcut);
	const double tau2 = jetTauValue(beta, radius, constituents, axis2, Rcut);
	const double tau3 = jetTauValue(beta, radius, constituents, axis3, Rcut);

	if (tau1 == 0 \|\| tau2 == 0) continue;
	_h_cat21.fill(pjet.perp(), tau2/tau1, weight);
	_h_cat32.fill(pjet.perp(), tau3/tau2, weight);
	}

	foreach (const PseudoJet pjet, ktjets) {
	if (pjet.perp() > 600*GeV \|\| fabs(pjet.rap()) > 2) continue;

	const PseudoJets constituents = ktfj.clusterSeq()->constituents(pjet);
	if (constituents.size() < 3) continue;

	const PseudoJets axis1 = jetGetAxes(1, constituents, M_PI/2.0);
	const PseudoJets axis2 = jetGetAxes(2, constituents, M_PI/2.0);
	const PseudoJets axis3 = jetGetAxes(3, constituents, M_PI/2.0);

	const double radius = 1.0;
	const double tau1 = jetTauValue(beta, radius, constituents, axis1, Rcut);
	const double tau2 = jetTauValue(beta, radius, constituents, axis2, Rcut);
	const double tau3 = jetTauValue(beta, radius, constituents, axis3, Rcut);
	if (tau1 == 0 \|\| tau2 == 0) continue;

	_h_ktt21.fill(pjet.perp(), tau2/tau1, weight);
	_h_ktt32.fill(pjet.perp(), tau3/tau2, weight);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	foreach (Histo1DPtr h, _h_camass.getHistograms()) normalize(h);
	foreach (Histo1DPtr h, _h_filtmass.getHistograms()) normalize(h);
	foreach (Histo1DPtr h, _h_ktmass.getHistograms()) normalize(h);
	foreach (Histo1DPtr h, _h_ktd12.getHistograms()) normalize(h);
	foreach (Histo1DPtr h, _h_ktd23.getHistograms()) normalize(h);
	foreach (Histo1DPtr h, _h_cat21.getHistograms()) normalize(h);
	foreach (Histo1DPtr h, _h_cat32.getHistograms()) normalize(h);
	foreach (Histo1DPtr h, _h_ktt21.getHistograms()) normalize(h);
	foreach (Histo1DPtr h, _h_ktt32.getHistograms()) normalize(h);
	}

	private:

	BinnedHistogram<double> _h_camass;
	BinnedHistogram<double> _h_filtmass;
	BinnedHistogram<double> _h_ktmass;
	BinnedHistogram<double> _h_ktd12;
	BinnedHistogram<double> _h_ktd23;
	BinnedHistogram<double> _h_cat21;
	BinnedHistogram<double> _h_cat32;
	BinnedHistogram<double> _h_ktt21;
	BinnedHistogram<double> _h_ktt32;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1094564);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1094568.cc b/src/Analyses/ATLAS_2012_I1094568.cc
	--- a/src/Analyses/ATLAS_2012_I1094568.cc
	+++ b/src/Analyses/ATLAS_2012_I1094568.cc
	@@ -1,367 +1,367 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/HadronicFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	struct ATLAS_2012_I1094568_Plots {
	// Track which veto region this is, to match the autobooked histograms
	int region_index;

	// Lower rapidity boundary or veto region
	double y_low;
	// Upper rapidity boundary or veto region
	double y_high;

	double vetoJetPt_Q0;
	double vetoJetPt_Qsum;

	// Histograms to store the veto jet pT and sum(veto jet pT) histograms.
	Histo1DPtr _h_vetoJetPt_Q0;
	Histo1DPtr _h_vetoJetPt_Qsum;

	// Scatter2Ds for the gap fractions
	Scatter2DPtr _d_gapFraction_Q0;
	Scatter2DPtr _d_gapFraction_Qsum;
	};



	/// Top pair production with central jet veto
	class ATLAS_2012_I1094568 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1094568()
	: Analysis("ATLAS_2012_I1094568")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {

	const FinalState fs(Cuts::abseta < 4.5);
	- addProjection(fs, "ALL_FS");
	+ declare(fs, "ALL_FS");

	/// Get electrons from truth record
	IdentifiedFinalState elec_fs(Cuts::abseta < 2.47 && Cuts::pT > 25*GeV);
	elec_fs.acceptIdPair(PID::ELECTRON);
	- addProjection(elec_fs, "ELEC_FS");
	+ declare(elec_fs, "ELEC_FS");

	/// Get muons which pass the initial kinematic cuts:
	IdentifiedFinalState muon_fs(Cuts::abseta < 2.5 && Cuts::pT > 20*GeV);
	muon_fs.acceptIdPair(PID::MUON);
	- addProjection(muon_fs, "MUON_FS");
	+ declare(muon_fs, "MUON_FS");

	/// Get all neutrinos. These will not be used to form jets.
	/// We'll use the highest 2 pT neutrinos to calculate the MET
	IdentifiedFinalState neutrino_fs(Cuts::abseta < 4.5);
	neutrino_fs.acceptNeutrinos();
	- addProjection(neutrino_fs, "NEUTRINO_FS");
	+ declare(neutrino_fs, "NEUTRINO_FS");

	// Final state used as input for jet-finding.
	// We include everything except the muons and neutrinos
	VetoedFinalState jet_input(fs);
	jet_input.vetoNeutrinos();
	jet_input.addVetoPairId(PID::MUON);
	- addProjection(jet_input, "JET_INPUT");
	+ declare(jet_input, "JET_INPUT");

	// Get the jets
	FastJets jets(jet_input, FastJets::ANTIKT, 0.4);
	- addProjection(jets, "JETS");
	+ declare(jets, "JETS");

	// Initialise weight counter
	m_total_weight = 0.0;

	// Init histogramming for the various regions
	m_plots[0].region_index = 1;
	m_plots[0].y_low = 0.0;
	m_plots[0].y_high = 0.8;
	initializePlots(m_plots[0]);
	//
	m_plots[1].region_index = 2;
	m_plots[1].y_low = 0.8;
	m_plots[1].y_high = 1.5;
	initializePlots(m_plots[1]);
	//
	m_plots[2].region_index = 3;
	m_plots[2].y_low = 1.5;
	m_plots[2].y_high = 2.1;
	initializePlots(m_plots[2]);
	//
	m_plots[3].region_index = 4;
	m_plots[3].y_low = 0.0;
	m_plots[3].y_high = 2.1;
	initializePlots(m_plots[3]);
	}


	void initializePlots(ATLAS_2012_I1094568_Plots& plots) {
	const string vetoPt_Q0_name = "TMP/vetoJetPt_Q0_" + to_str(plots.region_index);
	plots.vetoJetPt_Q0 = 0.0;
	plots._h_vetoJetPt_Q0 = bookHisto1D(vetoPt_Q0_name, 200, 0.0, 1000.0);
	plots._d_gapFraction_Q0 = bookScatter2D(plots.region_index, 1, 1);
	foreach (Point2D p, refData(plots.region_index, 1, 1).points()) {
	p.setY(0, 0);
	plots._d_gapFraction_Q0->addPoint(p);
	}

	const string vetoPt_Qsum_name = "TMP/vetoJetPt_Qsum_" + to_str(plots.region_index);
	plots._h_vetoJetPt_Qsum = bookHisto1D(vetoPt_Qsum_name, 200, 0.0, 1000.0);
	plots._d_gapFraction_Qsum = bookScatter2D(plots.region_index, 2, 1);
	plots.vetoJetPt_Qsum = 0.0;
	foreach (Point2D p, refData(plots.region_index, 2, 1).points()) {
	p.setY(0, 0);
	plots._d_gapFraction_Qsum->addPoint(p);
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	/// Get the various sets of final state particles
	- const Particles& elecFS = applyProjection<IdentifiedFinalState>(event, "ELEC_FS").particlesByPt();
	- const Particles& muonFS = applyProjection<IdentifiedFinalState>(event, "MUON_FS").particlesByPt();
	- const Particles& neutrinoFS = applyProjection<IdentifiedFinalState>(event, "NEUTRINO_FS").particlesByPt();
	+ const Particles& elecFS = apply<IdentifiedFinalState>(event, "ELEC_FS").particlesByPt();
	+ const Particles& muonFS = apply<IdentifiedFinalState>(event, "MUON_FS").particlesByPt();
	+ const Particles& neutrinoFS = apply<IdentifiedFinalState>(event, "NEUTRINO_FS").particlesByPt();

	// Get all jets with pT > 25 GeV
	- const Jets& jets = applyProjection<FastJets>(event, "JETS").jetsByPt(25.0*GeV);
	+ const Jets& jets = apply<FastJets>(event, "JETS").jetsByPt(25.0*GeV);

	// Keep any jets that pass the initial rapidity cut
	vector<const Jet*> central_jets;
	foreach(const Jet& j, jets) {
	if (j.absrap() < 2.4) central_jets.push_back(&j);
	}

	// For each of the jets that pass the rapidity cut, only keep those that are not
	// too close to any leptons
	vector<const Jet*> good_jets;
	foreach(const Jet* j, central_jets) {
	bool goodJet = true;

	foreach (const Particle& e, elecFS) {
	double elec_jet_dR = deltaR(e.momentum(), j->momentum());
	if (elec_jet_dR < 0.4) { goodJet = false; break; }
	}
	if (!goodJet) continue;
	if (!goodJet) continue;

	foreach (const Particle& m, muonFS) {
	double muon_jet_dR = deltaR(m.momentum(), j->momentum());
	if (muon_jet_dR < 0.4) { goodJet = false; break; }
	}
	if (!goodJet) continue;

	good_jets.push_back(j);
	}

	// Get b hadrons with pT > 5 GeV
	/// @todo This is a hack -- replace with UnstableFinalState
	vector<GenParticle const *> B_hadrons;
	vector<GenParticle const *> allParticles = particles(event.genEvent());
	for (size_t i = 0; i < allParticles.size(); i++) {
	const GenParticle* p = allParticles[i];
	if (!PID::isHadron(p->pdg_id()) \|\| !PID::hasBottom(p->pdg_id())) continue;
	if (p->momentum().perp() < 5*GeV) continue;
	B_hadrons.push_back(p);
	}

	// For each of the good jets, check whether any are b-jets (via dR matching)
	vector<const Jet*> b_jets;
	foreach (const Jet* j, good_jets) {
	bool isbJet = false;
	foreach (const GenParticle* b, B_hadrons) {
	if (deltaR(j->momentum(), FourMomentum(b->momentum())) < 0.3) isbJet = true;
	}
	if (isbJet) b_jets.push_back(j);
	}


	// Check the good jets again and keep track of the "additional jets"
	// i.e. those which are not either of the 2 highest pT b-jets
	vector<const Jet*> veto_jets;
	int n_bjets_matched = 0;
	foreach (const Jet* j, good_jets) {
	bool isBJet = false;
	foreach (const Jet* b, b_jets) {
	if (n_bjets_matched == 2) break;
	if (b == j){isBJet = true; ++ n_bjets_matched;}
	}
	if (!isBJet) veto_jets.push_back(j);
	}


	// Get the MET by taking the vector sum of all neutrinos
	/// @todo Use MissingMomentum instead?
	double MET = 0;
	FourMomentum p_MET;
	foreach (const Particle& p, neutrinoFS) {
	p_MET = p_MET + p.momentum();
	}
	MET = p_MET.pT();

	// Now we have everything we need to start doing the event selections
	bool passed_ee = false;
	vector<const Jet*> vetoJets_ee;

	// We want exactly 2 electrons...
	if (elecFS.size() == 2) {
	// ... with opposite sign charges.
	if (charge(elecFS[0]) != charge(elecFS[1])) {
	// Check the MET
	if (MET >= 40*GeV) {
	// Do some dilepton mass cuts
	const double dilepton_mass = (elecFS[0].momentum() + elecFS[1].momentum()).mass();
	if (dilepton_mass >= 15*GeV) {
	if (fabs(dilepton_mass - 91.0GeV) >= 10.0GeV) {
	// We need at least 2 b-jets
	if (b_jets.size() > 1) {
	// This event has passed all the cuts;
	passed_ee = true;
	}
	}
	}
	}
	}
	}

	bool passed_mumu = false;
	// Now do the same checks for the mumu channel
	vector<const Jet*> vetoJets_mumu;
	// So we now want 2 good muons...
	if (muonFS.size() == 2) {
	// ...with opposite sign charges.
	if (charge(muonFS[0]) != charge(muonFS[1])) {
	// Check the MET
	if (MET >= 40*GeV) {
	// and do some di-muon mass cuts
	const double dilepton_mass = (muonFS.at(0).momentum() + muonFS.at(1).momentum()).mass();
	if (dilepton_mass >= 15*GeV) {
	if (fabs(dilepton_mass - 91.0GeV) >= 10.0GeV) {
	// Need at least 2 b-jets
	if (b_jets.size() > 1) {
	// This event has passed all mumu-channel cuts
	passed_mumu = true;
	}
	}
	}
	}
	}
	}

	bool passed_emu = false;
	// Finally, the same again with the emu channel
	vector<const Jet*> vetoJets_emu;
	// We want exactly 1 electron and 1 muon
	if (elecFS.size() == 1 && muonFS.size() == 1) {
	// With opposite sign charges
	if (charge(elecFS[0]) != charge(muonFS[0])) {
	// Calculate HT: scalar sum of the pTs of the leptons and all good jets
	double HT = 0;
	HT += elecFS[0].pT();
	HT += muonFS[0].pT();
	foreach (const Jet* j, good_jets)
	HT += fabs(j->pT());
	// Keep events with HT > 130 GeV
	if (HT > 130.0*GeV) {
	// And again we want 2 or more b-jets
	if (b_jets.size() > 1) {
	passed_emu = true;
	}
	}
	}
	}

	if (passed_ee == true \|\| passed_mumu == true \|\| passed_emu == true) {
	// If the event passes the selection, we use it for all gap fractions
	m_total_weight += weight;

	// Loop over each veto jet
	foreach (const Jet* j, veto_jets) {
	const double pt = j->pT();
	const double rapidity = fabs(j->rapidity());
	// Loop over each region
	for (size_t i = 0; i < 4; ++i) {
	// If the jet falls into this region, get its pT and increment sum(pT)
	if (inRange(rapidity, m_plots[i].y_low, m_plots[i].y_high)) {
	m_plots[i].vetoJetPt_Qsum += pt;
	// If we've already got a veto jet, don't replace it
	if (m_plots[i].vetoJetPt_Q0 == 0.0) m_plots[i].vetoJetPt_Q0 = pt;
	}
	}
	}
	for (size_t i = 0; i < 4; ++i) {
	m_plots[i]._h_vetoJetPt_Q0->fill(m_plots[i].vetoJetPt_Q0, weight);
	m_plots[i]._h_vetoJetPt_Qsum->fill(m_plots[i].vetoJetPt_Qsum, weight);
	m_plots[i].vetoJetPt_Q0 = 0.0;
	m_plots[i].vetoJetPt_Qsum = 0.0;
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t i = 0; i < 4; ++i) {
	finalizeGapFraction(m_total_weight, m_plots[i]._d_gapFraction_Q0, m_plots[i]._h_vetoJetPt_Q0);
	finalizeGapFraction(m_total_weight, m_plots[i]._d_gapFraction_Qsum, m_plots[i]._h_vetoJetPt_Qsum);
	}
	}


	/// Convert temporary histos to cumulative efficiency scatters
	/// @todo Should be possible to replace this with a couple of YODA one-lines for diff -> integral and "efficiency division"
	void finalizeGapFraction(double total_weight, Scatter2DPtr gapFraction, Histo1DPtr vetoPt) {
	// Stores the cumulative frequency of the veto jet pT histogram
	double vetoPtWeightSum = 0.0;

	// Keep track of which gap fraction point we're currently populating (#final_points != #tmp_bins)
	size_t fgap_point = 0;
	for (size_t i = 0; i < vetoPt->numBins(); ++i) {
	// If we've done the last "final" point, stop
	if (fgap_point == gapFraction->numPoints()) break;

	// Increment the cumulative vetoPt counter for this temp histo bin
	/// @todo Get rid of this and use vetoPt->integral(i+1) when points and bins line up?
	vetoPtWeightSum += vetoPt->bin(i).sumW();

	// If this temp histo bin's upper edge doesn't correspond to the reference point, don't finalise the scatter.
	// Note that points are ON the bin edges and have no width: they represent the integral up to exactly that point.
	if ( !fuzzyEquals(vetoPt->bin(i).xMax(), gapFraction->point(fgap_point).x()) ) continue;

	// Calculate the gap fraction and its uncertainty
	const double frac = (total_weight != 0.0) ? vetoPtWeightSum/total_weight : 0;
	const double fracErr = (total_weight != 0.0) ? sqrt(frac*(1-frac)/total_weight) : 0;
	gapFraction->point(fgap_point).setY(frac, fracErr);

	++fgap_point;
	}
	}


	private:

	// Weight counter
	double m_total_weight;

	// Structs containing all the plots, for each event selection
	ATLAS_2012_I1094568_Plots m_plots[4];

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1094568);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1095236.cc b/src/Analyses/ATLAS_2012_I1095236.cc
	--- a/src/Analyses/ATLAS_2012_I1095236.cc
	+++ b/src/Analyses/ATLAS_2012_I1095236.cc
	@@ -1,327 +1,327 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @author Peter Richardson
	class ATLAS_2012_I1095236 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1095236()
	: Analysis("ATLAS_2012_I1095236")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// Projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// All tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0),"cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0),"cfs");

	// Used for pTmiss
	- addProjection(VisibleFinalState(-4.9,4.9),"vfs");
	+ declare(VisibleFinalState(-4.9,4.9),"vfs");

	// Book histograms
	_count_SR0_A1 = bookHisto1D("count_SR0_A1", 1, 0., 1.);
	_count_SR0_B1 = bookHisto1D("count_SR0_B1", 1, 0., 1.);
	_count_SR0_C1 = bookHisto1D("count_SR0_C1", 1, 0., 1.);
	_count_SR0_A2 = bookHisto1D("count_SR0_A2", 1, 0., 1.);
	_count_SR0_B2 = bookHisto1D("count_SR0_B2", 1, 0., 1.);
	_count_SR0_C2 = bookHisto1D("count_SR0_C2", 1, 0., 1.);
	_count_SR1_D = bookHisto1D("count_SR1_D" , 1, 0., 1.);
	_count_SR1_E = bookHisto1D("count_SR1_E" , 1, 0., 1.);

	_hist_meff_SR0_A1 = bookHisto1D("hist_m_eff_SR0_A1", 14, 400., 1800.);
	_hist_meff_SR0_A2 = bookHisto1D("hist_m_eff_SR0_A2", 14, 400., 1800.);
	_hist_meff_SR1_D_e = bookHisto1D("hist_meff_SR1_D_e" , 16, 600., 2200.);
	_hist_meff_SR1_D_mu = bookHisto1D("hist_meff_SR1_D_mu", 16, 600., 2200.);

	_hist_met_SR0_A1 = bookHisto1D("hist_met_SR0_A1", 14, 0., 700.);
	_hist_met_SR0_A2 = bookHisto1D("hist_met_SR0_A2", 14, 0., 700.);
	_hist_met_SR0_D_e = bookHisto1D("hist_met_SR1_D_e" , 15, 0., 600.);
	_hist_met_SR0_D_mu = bookHisto1D("hist_met_SR1_D_mu", 15, 0., 600.);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	Jets cand_jets;
	- const Jets jets = applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
	+ const Jets jets = apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
	foreach (const Jet& jet, jets) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	cand_jets.push_back(jet);
	}
	}

	- const Particles cand_e = applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ const Particles cand_e = apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	- const Particles cand_mu = applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt();
	+ const Particles cand_mu = apply<IdentifiedFinalState>(event, "muons").particlesByPt();
	// Resolve jet-lepton overlap for jets with \|eta\| < 2.8
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	if ( fabs( jet.eta() ) >= 2.8 ) continue;
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}

	// get the loose leptons used to define the 0 lepton channel
	Particles loose_e, loose_mu;
	foreach ( const Particle & e, cand_e ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away ) loose_e.push_back( e );
	}
	foreach ( const Particle & mu, cand_mu ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away ) loose_mu.push_back( mu );
	}
	// tight leptons for the 1-lepton channel
	Particles tight_mu;
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	foreach ( const Particle & mu, loose_mu) {
	if(mu.perp()<20.) continue;
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	tight_mu.push_back(mu);
	}
	Particles tight_e;
	foreach ( const Particle & e, loose_e ) {
	if(e.perp()<25.) continue;
	double pTinCone = -e.perp();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if (pTinCone/e.perp()<0.1) {
	tight_e.push_back(e);
	}
	}

	// pTmiss
	Particles vfs_particles =
	- applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// get the number of b-tagged jets
	unsigned int ntagged=0;
	foreach (const Jet & jet, recon_jets ) {
	if(jet.perp()>50. && abs(jet.eta())<2.5 &&
	jet.bTagged() && rand()/static_cast<double>(RAND_MAX)<=0.60)
	++ntagged;
	}

	// ATLAS calo problem
	if(rand()/static_cast<double>(RAND_MAX)<=0.42) {
	foreach ( const Jet & jet, recon_jets ) {
	double eta = jet.rapidity();
	double phi = jet.azimuthalAngle(MINUSPI_PLUSPI);
	if(jet.perp()>50 && eta>-0.1&&eta<1.5&&phi>-0.9&&phi<-0.5)
	vetoEvent;
	}
	}

	// at least 1 b tag
	if(ntagged==0) vetoEvent;

	// minumum Et miss
	if(eTmiss<80.) vetoEvent;

	// at least 3 jets pT > 50
	if(recon_jets.size()<3 \|\| recon_jets[2].perp()<50.)
	vetoEvent;

	// m_eff
	double m_eff = eTmiss;
	for(unsigned int ix=0;ix<3;++ix)
	m_eff += recon_jets[ix].perp();

	// delta Phi
	double min_dPhi = 999.999;
	double pTmiss_phi = pTmiss.phi();
	for(unsigned int ix=0;ix<3;++ix) {
	min_dPhi = min( min_dPhi, deltaPhi( pTmiss_phi, recon_jets[ix].phi() ) );
	}

	// 0-lepton channels
	if(loose_e.empty() && loose_mu.empty() &&
	recon_jets[0].perp()>130. && eTmiss>130. &&
	eTmiss/m_eff>0.25 && min_dPhi>0.4) {
	// jet charge cut
	bool jetCharge = true;
	for(unsigned int ix=0;ix<3;++ix) {
	if(fabs(recon_jets[ix].eta())>2.) continue;
	double trackpT=0;
	foreach(const Particle & p, recon_jets[ix].particles()) {
	if(PID::threeCharge(p.pid())==0) continue;
	trackpT += p.perp();
	}
	if(trackpT/recon_jets[ix].perp()<0.05)
	jetCharge = false;
	}
	if(jetCharge) {
	// SR0-A region
	if(m_eff>500.) {
	_count_SR0_A1->fill(0.5,weight);
	_hist_meff_SR0_A1->fill(m_eff,weight);
	_hist_met_SR0_A1 ->fill(eTmiss,weight);
	if(ntagged>=2) {
	_count_SR0_A2->fill(0.5,weight);
	_hist_meff_SR0_A2->fill(m_eff,weight);
	_hist_met_SR0_A2 ->fill(eTmiss,weight);
	}
	}
	// SR0-B
	if(m_eff>700.) {
	_count_SR0_B1->fill(0.5,weight);
	if(ntagged>=2) _count_SR0_B2->fill(0.5,weight);
	}
	// SR0-C
	if(m_eff>900.) {
	_count_SR0_C1->fill(0.5,weight);
	if(ntagged>=2) _count_SR0_C2->fill(0.5,weight);
	}
	}
	}

	// 1-lepton channels
	if(tight_e.size() + tight_mu.size() == 1 &&
	recon_jets.size()>=4 && recon_jets[3].perp()>50.&&
	recon_jets[0].perp()>60.) {
	Particle lepton = tight_e.empty() ? tight_mu[0] : tight_e[0];
	m_eff += lepton.perp() + recon_jets[3].perp();
	// transverse mass cut
	double mT = 2.(lepton.perp()eTmiss-
	lepton.px()*pTmiss.px()-
	lepton.py()*pTmiss.py());
	mT = sqrt(mT);
	if(mT>100.&&m_eff>700.) {
	// D region
	_count_SR1_D->fill(0.5,weight);
	if(lepton.abspid()==PID::ELECTRON) {
	_hist_meff_SR1_D_e->fill(m_eff,weight);
	_hist_met_SR0_D_e->fill(eTmiss,weight);
	}
	else {
	_hist_meff_SR1_D_mu->fill(m_eff,weight);
	_hist_met_SR0_D_mu->fill(eTmiss,weight);
	}
	// E region
	if(eTmiss>200.) {
	_count_SR1_E->fill(0.5,weight);
	}
	}
	}
	}


	void finalize() {

	double norm = crossSection()/femtobarn*2.05/sumOfWeights();
	// these are number of events at 2.05fb^-1 per 100 GeV
	scale( _hist_meff_SR0_A1 , 100. * norm );
	scale( _hist_meff_SR0_A2 , 100. * norm );
	scale( _hist_meff_SR1_D_e , 100. * norm );
	scale( _hist_meff_SR1_D_mu , 100. * norm );
	// these are number of events at 2.05fb^-1 per 50 GeV
	scale( _hist_met_SR0_A1, 50. * norm );
	scale( _hist_met_SR0_A2, 40. * norm );
	// these are number of events at 2.05fb^-1 per 40 GeV
	scale( _hist_met_SR0_D_e , 40. * norm );
	scale( _hist_met_SR0_D_mu, 40. * norm );
	// these are number of events at 2.05fb^-1
	scale(_count_SR0_A1,norm);
	scale(_count_SR0_B1,norm);
	scale(_count_SR0_C1,norm);
	scale(_count_SR0_A2,norm);
	scale(_count_SR0_B2,norm);
	scale(_count_SR0_C2,norm);
	scale(_count_SR1_D ,norm);
	scale(_count_SR1_E ,norm);
	}

	//@}


	private:

	Histo1DPtr _count_SR0_A1;
	Histo1DPtr _count_SR0_B1;
	Histo1DPtr _count_SR0_C1;
	Histo1DPtr _count_SR0_A2;
	Histo1DPtr _count_SR0_B2;
	Histo1DPtr _count_SR0_C2;
	Histo1DPtr _count_SR1_D;
	Histo1DPtr _count_SR1_E;

	Histo1DPtr _hist_meff_SR0_A1;
	Histo1DPtr _hist_meff_SR0_A2;
	Histo1DPtr _hist_meff_SR1_D_e;
	Histo1DPtr _hist_meff_SR1_D_mu;
	Histo1DPtr _hist_met_SR0_A1;
	Histo1DPtr _hist_met_SR0_A2;
	Histo1DPtr _hist_met_SR0_D_e;
	Histo1DPtr _hist_met_SR0_D_mu;

	};


	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1095236);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1112263.cc b/src/Analyses/ATLAS_2012_I1112263.cc
	--- a/src/Analyses/ATLAS_2012_I1112263.cc
	+++ b/src/Analyses/ATLAS_2012_I1112263.cc
	@@ -1,323 +1,323 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	/// @author Peter Richardson
	class ATLAS_2012_I1112263 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1112263()
	: Analysis("ATLAS_2012_I1112263")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 10*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");

	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);

	/// Jet finder
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0),"cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0),"cfs");

	// Book histograms
	_hist_leptonpT_SR1.push_back(bookHisto1D("hist_lepton_pT_1_SR1",11,0.,220.));
	_hist_leptonpT_SR1.push_back(bookHisto1D("hist_lepton_pT_2_SR1", 7,0.,140.));
	_hist_leptonpT_SR1.push_back(bookHisto1D("hist_lepton_pT_3_SR1", 8,0.,160.));
	_hist_leptonpT_SR2.push_back(bookHisto1D("hist_lepton_pT_1_SR2",11,0.,220.));
	_hist_leptonpT_SR2.push_back(bookHisto1D("hist_lepton_pT_2_SR2", 7,0.,140.));
	_hist_leptonpT_SR2.push_back(bookHisto1D("hist_lepton_pT_3_SR2", 8,0.,160.));
	_hist_etmiss_SR1_A = bookHisto1D("hist_etmiss_SR1_A",15,10.,310.);
	_hist_etmiss_SR1_B = bookHisto1D("hist_etmiss_SR1_B", 9,10.,190.);
	_hist_etmiss_SR2_A = bookHisto1D("hist_etmiss_SR2_A",15,10.,310.);
	_hist_etmiss_SR2_B = bookHisto1D("hist_etmiss_SR2_B", 9,10.,190.);
	_hist_mSFOS= bookHisto1D("hist_mSFOF",9,0.,180.);

	_count_SR1 = bookHisto1D("count_SR1", 1, 0., 1.);
	_count_SR2 = bookHisto1D("count_SR2", 1, 0., 1.);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Get the jet candidates
	Jets cand_jets;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ foreach (const Jet& jet, apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	cand_jets.push_back(jet);
	}
	}

	// Candidate muons
	Particles cand_mu;
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	- foreach ( const Particle & mu, applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	+ apply<ChargedFinalState>(event, "cfs").particles();
	+ foreach ( const Particle & mu, apply<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	cand_mu.push_back(mu);
	}

	// Candidate electrons
	Particles cand_e;
	- foreach ( const Particle & e, applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt() ) {
	+ foreach ( const Particle & e, apply<IdentifiedFinalState>(event, "elecs").particlesByPt() ) {
	double eta = e.eta();
	// Remove electrons with pT<15 in old veto region
	// (NOT EXPLICIT IN THIS PAPER BUT IN SIMILAR 4 LEPTON PAPER and THIS DESCRPITION
	// IS MUCH WORSE SO ASSUME THIS IS DONE)
	if ( fabs(eta)>1.37 && fabs(eta) < 1.52 && e.perp()< 15.*GeV)
	continue;
	double pTinCone = -e.perp();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if (pTinCone/e.perp()<0.1) {
	cand_e.push_back(e);
	}
	}

	// Resolve jet/lepton ambiguity
	// (NOT EXPLICIT IN THIS PAPER BUT IN SIMILAR 4 LEPTON PAPER and THIS DESCRPITION
	// IS MUCH WORSE SO ASSUME THIS IS DONE)
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e )
	recon_jets.push_back( jet );
	}

	// Only keep electrons more than R=0.4 from jets
	Particles recon_e;
	foreach ( const Particle & e, cand_e ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	// ... and 0.1 from any muons
	if ( ! away ) {
	foreach ( const Particle & mu, cand_e ) {
	if ( deltaR(mu.momentum(),e.momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	}
	if ( away )
	recon_e.push_back( e );
	}
	// Only keep muons more than R=0.4 from jets
	Particles recon_mu;
	foreach ( const Particle & mu, cand_mu ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	// ... and 0.1 from any electrona
	if ( ! away ) {
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(mu.momentum(),e.momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	}
	if ( away )
	recon_mu.push_back( mu );
	}

	// pTmiss
	Particles vfs_particles =
	- applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// Now only use recon_jets, recon_mu, recon_e

	// Reject events with wrong number of leptons
	if ( recon_mu.size() + recon_e.size() != 3 ) {
	MSG_DEBUG("To few charged leptons left after selection");
	vetoEvent;
	}

	// ATLAS calo problem
	if (rand()/static_cast<double>(RAND_MAX) <= 0.42) {
	foreach ( const Particle & e, recon_e ) {
	double eta = e.eta();
	double phi = e.azimuthalAngle(MINUSPI_PLUSPI);
	if (inRange(eta, -0.1, 1.5) && inRange(phi, -0.9, -0.5)) vetoEvent;
	}
	foreach ( const Jet & jet, recon_jets ) {
	const double eta = jet.rapidity();
	const double phi = jet.azimuthalAngle(MINUSPI_PLUSPI);
	if (jet.perp() > 40*GeV && inRange(eta, -0.1, 1.5) && inRange(phi, -0.9, -0.5)) vetoEvent;
	}
	}

	if ( !( !recon_e .empty() && recon_e[0] .perp() > 25*GeV) &&
	!( !recon_mu.empty() && recon_mu[0].perp() > 20*GeV) ) {
	MSG_DEBUG("Hardest lepton fails trigger");
	vetoEvent;
	}

	// eTmiss cut
	if (eTmiss < 50*GeV) vetoEvent;

	// Check at least 1 SFOS pair
	double mSFOS=1e30, mdiff=1e30*GeV;
	size_t nSFOS=0;
	for (size_t ix = 0; ix < recon_e.size(); ++ix) {
	for (size_t iy = ix+1; iy < recon_e.size(); ++iy) {
	if (recon_e[ix].pid()*recon_e[iy].pid() > 0) continue;
	++nSFOS;
	double mtest = (recon_e[ix].momentum() + recon_e[iy].momentum()).mass();
	// Veto is mass<20
	if (mtest < 20*GeV) vetoEvent;
	if (fabs(mtest - 90*GeV) < mdiff) {
	mSFOS = mtest;
	mdiff = fabs(mtest - 90*GeV);
	}
	}
	}
	for (size_t ix = 0; ix < recon_mu.size(); ++ix) {
	for (size_t iy = ix+1; iy < recon_mu.size(); ++iy) {
	if (recon_mu[ix].pid()*recon_mu[iy].pid() > 0) continue;
	++nSFOS;
	double mtest = (recon_mu[ix].momentum() + recon_mu[iy].momentum()).mass();
	// Veto is mass < 20*GeV
	if (mtest < 20*GeV) vetoEvent;
	if (fabs(mtest - 90*GeV) < mdiff) {
	mSFOS = mtest;
	mdiff = fabs(mtest - 90*GeV);
	}
	}
	}
	// Require at least 1 SFOS pair
	if (nSFOS == 0) vetoEvent;
	// b-jet veto in SR!
	if (mdiff > 10*GeV) {
	foreach (const Jet & jet, recon_jets ) {
	if (jet.bTagged() && rand()/static_cast<double>(RAND_MAX) <= 0.60) vetoEvent;
	}
	}

	// Histogram filling
	const double weight = event.weight();

	// Region SR1, Z depleted
	if (mdiff > 10*GeV) {
	_count_SR1->fill(0.5, weight);
	_hist_etmiss_SR1_A->fill(eTmiss, weight);
	_hist_etmiss_SR1_B->fill(eTmiss, weight);
	_hist_mSFOS->fill(mSFOS, weight);
	}
	// Region SR2, Z enriched
	else {
	_count_SR2->fill(0.5, weight);
	_hist_etmiss_SR2_A->fill(eTmiss, weight);
	_hist_etmiss_SR2_B->fill(eTmiss, weight);
	}
	// Make the control plots
	// lepton pT
	size_t ie=0, imu=0;
	for (size_t ix = 0; ix < 3; ++ix) {
	Histo1DPtr hist = (mdiff > 10*GeV) ? _hist_leptonpT_SR1[ix] : _hist_leptonpT_SR2[ix];
	double pTe = (ie < recon_e .size()) ? recon_e [ie ].perp() : -1*GeV;
	double pTmu = (imu < recon_mu.size()) ? recon_mu[imu].perp() : -1*GeV;
	if (pTe > pTmu) {
	hist->fill(pTe, weight);
	++ie;
	} else {
	hist->fill(pTmu, weight);
	++imu;
	}
	}

	}


	void finalize() {
	const double norm = crossSection()/femtobarn*2.06/sumOfWeights();
	// These are number of events at 2.06fb^-1 per 20 GeV
	for (size_t ix = 0; ix < 3; ++ix) {
	scale(_hist_leptonpT_SR1[ix], norm*20.);
	scale(_hist_leptonpT_SR2[ix], norm*20.);
	}
	scale(_hist_etmiss_SR1_A, norm*20.);
	scale(_hist_etmiss_SR1_B, norm*20.);
	scale(_hist_etmiss_SR2_A, norm*20.);
	scale(_hist_etmiss_SR2_B, norm*20.);
	scale(_hist_mSFOS, norm*20.);
	// These are number of events at 2.06fb^-1
	scale(_count_SR1, norm);
	scale(_count_SR2, norm);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	vector<Histo1DPtr> _hist_leptonpT_SR1, _hist_leptonpT_SR2;
	Histo1DPtr _hist_etmiss_SR1_A, _hist_etmiss_SR1_B, _hist_etmiss_SR2_A, _hist_etmiss_SR2_B;
	Histo1DPtr _hist_mSFOS, _count_SR1, _count_SR2;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1112263);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1117704.cc b/src/Analyses/ATLAS_2012_I1117704.cc
	--- a/src/Analyses/ATLAS_2012_I1117704.cc
	+++ b/src/Analyses/ATLAS_2012_I1117704.cc
	@@ -1,283 +1,283 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	class ATLAS_2012_I1117704 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2012_I1117704()
	: Analysis("ATLAS_2012_I1117704")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9), "vfs");

	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);

	/// Jet finder
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3),"cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3),"cfs");

	/// Book histograms
	_etmiss_HT_7j55 = bookHisto1D("etmiss_HT_7j55", 8, 0., 16.);
	_etmiss_HT_8j55 = bookHisto1D("etmiss_HT_8j55", 8, 0., 16.);
	_etmiss_HT_9j55 = bookHisto1D("etmiss_HT_9j55", 8, 0., 16.);
	_etmiss_HT_6j80 = bookHisto1D("etmiss_HT_6j80", 8, 0., 16.);
	_etmiss_HT_7j80 = bookHisto1D("etmiss_HT_7j80", 8, 0., 16.);
	_etmiss_HT_8j80 = bookHisto1D("etmiss_HT_8j80", 8, 0., 16.);

	_hist_njet55 = bookHisto1D("hist_njet55", 11, 2.5, 13.5);
	_hist_njet80 = bookHisto1D("hist_njet80", 11, 2.5, 13.5);

	_count_7j55 = bookHisto1D("count_7j55", 1, 0., 1.);
	_count_8j55 = bookHisto1D("count_8j55", 1, 0., 1.);
	_count_9j55 = bookHisto1D("count_9j55", 1, 0., 1.);
	_count_6j80 = bookHisto1D("count_6j80", 1, 0., 1.);
	_count_7j80 = bookHisto1D("count_7j80", 1, 0., 1.);
	_count_8j80 = bookHisto1D("count_8j80", 1, 0., 1.);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// get the jet candidates
	Jets cand_jets;
	foreach (const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	cand_jets.push_back(jet);
	}
	}

	// candidate muons
	Particles cand_mu;
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	foreach ( const Particle& mu,
	- applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	+ apply<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle& track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	cand_mu.push_back(mu);
	}

	// candidate electrons
	Particles cand_e =
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	// resolve jet/lepton ambiguity
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	// candidates after \|eta\| < 2.8
	if ( fabs( jet.eta() ) >= 2.8 ) continue;
	bool away_from_e = true;
	foreach ( const Particle& e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}

	// only keep electrons more than R=0.4 from jets
	Particles recon_e;
	foreach ( const Particle& e, cand_e ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away )
	recon_e.push_back( e );
	}

	// only keep muons more than R=0.4 from jets
	Particles recon_mu;
	foreach ( const Particle& mu, cand_mu ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away )
	recon_mu.push_back( mu );
	}

	// pTmiss
	Particles vfs_particles =
	- applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle& p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// now only use recon_jets, recon_mu, recon_e

	// reject events with electrons and muons
	if ( ! ( recon_mu.empty() && recon_e.empty() ) ) {
	MSG_DEBUG("Charged leptons left after selection");
	vetoEvent;
	}

	// calculate H_T
	double HT=0;
	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.pT() > 40 * GeV )
	HT += jet.pT() ;
	}

	// number of jets
	unsigned int njet55=0, njet80=0;
	for (unsigned int ix=0;ix<recon_jets.size();++ix) {
	if(recon_jets[ix].pT()>80.*GeV) ++njet80;
	if(recon_jets[ix].pT()>55.*GeV) ++njet55;
	}

	if(njet55==0) vetoEvent;

	double ratio = eTmiss/sqrt(HT);

	if(ratio>4.) {
	_hist_njet55->fill(njet55,weight);
	_hist_njet80->fill(njet80,weight);
	// 7j55
	if(njet55>=7)
	_count_7j55->fill( 0.5, weight);
	// 8j55
	if(njet55>=8)
	_count_8j55->fill( 0.5, weight) ;
	// 8j55
	if(njet55>=9)
	_count_9j55->fill( 0.5, weight) ;
	// 6j80
	if(njet80>=6)
	_count_6j80->fill( 0.5, weight) ;
	// 7j80
	if(njet80>=7)
	_count_7j80->fill( 0.5, weight) ;
	// 8j80
	if(njet80>=8)
	_count_8j80->fill( 0.5, weight) ;
	}

	if(njet55>=7)
	_etmiss_HT_7j55->fill( ratio, weight);
	// 8j55
	if(njet55>=8)
	_etmiss_HT_8j55->fill( ratio, weight) ;
	// 8j55
	if(njet55>=9)
	_etmiss_HT_9j55->fill( ratio, weight) ;
	// 6j80
	if(njet80>=6)
	_etmiss_HT_6j80->fill( ratio, weight) ;
	// 7j80
	if(njet80>=7)
	_etmiss_HT_7j80->fill( ratio, weight) ;
	// 8j80
	if(njet80>=8)
	_etmiss_HT_8j80->fill( ratio, weight) ;

	}

	//@}

	void finalize() {
	double norm = crossSection()/femtobarn*4.7/sumOfWeights();

	scale(_etmiss_HT_7j55,2.*norm);
	scale(_etmiss_HT_8j55,2.*norm);
	scale(_etmiss_HT_9j55,2.*norm);
	scale(_etmiss_HT_6j80,2.*norm);
	scale(_etmiss_HT_7j80,2.*norm);
	scale(_etmiss_HT_8j80,2.*norm);

	scale(_hist_njet55,norm);
	scale(_hist_njet80,norm);

	scale(_count_7j55,norm);
	scale(_count_8j55,norm);
	scale(_count_9j55,norm);
	scale(_count_6j80,norm);
	scale(_count_7j80,norm);
	scale(_count_8j80,norm);
	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _etmiss_HT_7j55;
	Histo1DPtr _etmiss_HT_8j55;
	Histo1DPtr _etmiss_HT_9j55;
	Histo1DPtr _etmiss_HT_6j80;
	Histo1DPtr _etmiss_HT_7j80;
	Histo1DPtr _etmiss_HT_8j80;

	Histo1DPtr _hist_njet55;
	Histo1DPtr _hist_njet80;

	Histo1DPtr _count_7j55;
	Histo1DPtr _count_8j55;
	Histo1DPtr _count_9j55;
	Histo1DPtr _count_6j80;
	Histo1DPtr _count_7j80;
	Histo1DPtr _count_8j80;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1117704);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1119557.cc b/src/Analyses/ATLAS_2012_I1119557.cc
	--- a/src/Analyses/ATLAS_2012_I1119557.cc
	+++ b/src/Analyses/ATLAS_2012_I1119557.cc
	@@ -1,293 +1,293 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	namespace { // unnamed namespace
	// Forward declarations of calculator functions: implementations at bottom of file
	double getWidth(const Jet& jet);
	/// @todo Re-enable eccentricity calculation
	// double getEcc(const Jet& jet);
	double getPFlow(const Jet& jet);
	double getAngularity(const Jet& jet);
	}


	class ATLAS_2012_I1119557 : public Analysis {
	public:

	ATLAS_2012_I1119557()
	: Analysis("ATLAS_2012_I1119557")
	{ }


	void init() {
	const FinalState fs;
	- addProjection(fs, "FinalState");
	+ declare(fs, "FinalState");

	FastJets fj06(fs, FastJets::ANTIKT, 0.6);
	- addProjection(fj06, "AntiKT06");
	+ declare(fj06, "AntiKT06");
	FastJets fj10(fs, FastJets::ANTIKT, 1.0);
	- addProjection(fj10, "AntiKT10");
	+ declare(fj10, "AntiKT10");

	for (size_t alg = 0; alg < 2; ++alg) {
	_hs_mass[alg] = bookHisto1D(1, alg+1, 1);
	_hs_width[alg] = bookHisto1D(2, alg+1, 1);
	/// @todo Commented eccentricity out for now: reinstate
	// _hs_eccentricity[alg] = bookHisto1D(3, alg+1, 1);
	}
	_h_planarFlow = bookHisto1D(4, 2, 1);
	_h_angularity = bookHisto1D(5, 1, 1);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	Jets jetAr[2];
	- jetAr[0] = applyProjection<FastJets>(event, "AntiKT06").jetsByPt(Cuts::pT > 300*GeV && Cuts::abseta < 2.0);
	- jetAr[1] = applyProjection<FastJets>(event, "AntiKT10").jetsByPt(Cuts::pT > 300*GeV && Cuts::abseta < 2.0);
	+ jetAr[0] = apply<FastJets>(event, "AntiKT06").jetsByPt(Cuts::pT > 300*GeV && Cuts::abseta < 2.0);
	+ jetAr[1] = apply<FastJets>(event, "AntiKT10").jetsByPt(Cuts::pT > 300*GeV && Cuts::abseta < 2.0);

	for (size_t alg = 0; alg < 2; ++alg) {
	// Require at least one jet
	if (jetAr[alg].size() < 1) continue;

	// The leading jet
	const Jet& jet = jetAr[alg][0];
	const double m = jet.mass();
	const double eta = jet.eta();

	_hs_mass[alg]->fill(m/GeV, weight);
	_hs_width[alg]->fill(getWidth(jet), weight);
	/// @todo Commented eccentricity out for now: reinstate
	// if (fabs(eta) < 0.7 && m > 100*GeV) _hs_eccentricity[alg]->fill(getEcc(jet), weight);

	if (fabs(eta) < 0.7) {
	if (alg == 0 && inRange(m/GeV, 100., 130.)) _h_angularity->fill(getAngularity(jet), weight);
	if (alg == 1 && inRange(m/GeV, 130., 210.)) _h_planarFlow->fill(getPFlow(jet), weight);
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t alg = 0; alg < 2; ++alg) {
	normalize(_hs_mass[alg]);
	normalize(_hs_width[alg]);
	/// @todo Commented eccentricity out for now: reinstate
	// normalize(_hs_eccentricity[alg]);
	}
	normalize(_h_planarFlow);
	normalize(_h_angularity);
	}


	private:

	Histo1DPtr _hs_mass[2];
	Histo1DPtr _hs_width[2];
	/// @todo Commented eccentricity out for now: reinstate
	// Histo1DPtr _hs_eccentricity[2];
	Histo1DPtr _h_planarFlow;
	Histo1DPtr _h_angularity;
	};


	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1119557);



	namespace { // unnamed namespace

	// Adapted code from Lily
	/// @todo Convert to use the Rivet rotation matrix code (should be simpler)
	FourMomentum RotateAxes(const Rivet::FourMomentum& p, double M[3][3]){
	double px_rot = M[0][0](p.px()) + M[0][1](p.py()) + M[0][2]*(p.pz());
	double py_rot = M[1][0](p.px()) + M[1][1](p.py()) + M[1][2]*(p.pz());
	double pz_rot = M[2][0](p.px()) + M[2][1](p.py()) + M[2][2]*(p.pz());
	return FourMomentum(p.E(), px_rot, py_rot, pz_rot);
	}

	// Untouched code from Lily
	/// @todo Convert to use the Rivet rotation matrix code (should be simpler)
	void CalcRotationMatrix(double nvec[3],double rot_mat[3][3]){
	// clear momentum tensor
	for (size_t i = 0; i < 3; i++) {
	for (size_t j = 0; j < 3; j++) {
	rot_mat[i][j] = 0.;
	}
	}
	double mag3 = sqrt(nvec[0]nvec[0] + nvec[1]nvec[1]+ nvec[2]*nvec[2]);
	double mag2 = sqrt(nvec[0]nvec[0] + nvec[1]nvec[1]);
	/// @todo cout is not a valid response to a numerical error! Is the error condition reported?!? Assert added by AB for Rivet 1.8.2
	assert(mag3 > 0);
	if (mag3 <= 0) {
	cout << "rotation axis is null" << endl;
	return;
	}

	double ctheta0 = nvec[2]/mag3;
	double stheta0 = mag2/mag3;
	double cphi0 = (mag2 > 0.) ? nvec[0]/mag2 : 0;
	double sphi0 = (mag2 > 0.) ? nvec[1]/mag2 : 0;

	rot_mat[0][0] = -ctheta0*cphi0;
	rot_mat[0][1] = -ctheta0*sphi0;
	rot_mat[0][2] = stheta0;
	rot_mat[1][0] = sphi0;
	rot_mat[1][1] = -1.*cphi0;
	rot_mat[1][2] = 0.;
	rot_mat[2][0] = stheta0*cphi0;
	rot_mat[2][1] = stheta0*sphi0;
	rot_mat[2][2] = ctheta0;
	}


	/// Jet width calculation
	double getWidth(const Jet& jet) {
	const double phi_jet = jet.phi();
	const double eta_jet = jet.eta();
	double width(0), pTsum(0);
	foreach (const Particle& p, jet.particles()) {
	double pT = p.pT();
	double eta = p.eta();
	double phi = p.phi();
	width += sqrt(pow(phi_jet - phi,2) + pow(eta_jet - eta, 2)) * pT;
	pTsum += pT;
	}
	const double rtn = (pTsum != 0.0) ? width/pTsum : -1;
	return rtn;
	}


	/// Eccentricity calculation, copied and adapted from Lily's code
	/// @todo Re-enable eccentricity calculation
	// double getEcc(const Jet& jet) {
	// vector<double> phis;
	// vector<double> etas;
	// vector<double> energies;

	// double etaSum(0), phiSum(0), eTot(0);
	// foreach (const Particle& p, jet.particles()) {
	// const double E = p.E();
	// const double eta = p.eta();

	// energies.push_back(E);
	// etas.push_back(jet.eta() - eta);

	// eTot += E;
	// etaSum += eta * E;

	// /// @todo Replace with the Rivet deltaPhi function (or the mapAngleTo* functions)
	// double dPhi = jet.phi() - p.phi();
	// //if DPhi does not lie within 0 < DPhi < PI take 2*PI off DPhi
	// //this covers cases where DPhi is greater than PI
	// if( fabs( dPhi - TWOPI ) < fabs(dPhi) ) dPhi -= TWOPI;
	// //if DPhi does not lie within -PI < DPhi < 0 add 2*PI to DPhi
	// //this covers cases where DPhi is less than -PI
	// else if( fabs(dPhi + TWOPI) < fabs(dPhi) ) dPhi += TWOPI;
	// phis.push_back(dPhi);

	// phiSum += dPhi * E;
	// }

	// //these are the "pull" away from the jet axis
	// etaSum = etaSum/eTot;
	// phiSum = phiSum/eTot;

	// // now for every cluster we alter its position by moving it:
	// // away from the new axis if it is in the direction of -ve pull
	// // closer to the new axis if it is in the direction of +ve pull
	// // the effect of this will be that the new energy weighted center will be on the old jet axis.
	// double little_x(0), little_y(0);
	// for (size_t k = 0; k < jet.particles().size(); ++k) {
	// little_x+= etas[k]-etaSum;
	// little_y+= phis[k]-phiSum;
	// etas[k] = etas[k]-etaSum;
	// phis[k] = phis[k]-phiSum;
	// }

	// double x1(0), x2(0);
	// for (size_t i = 0; i < jet.particles().size(); ++i) {
	// x1 += 2. * energies[i]* etas[i] * phis[i]; // this is 2XY
	// x2 += energies[i](phis[i] phis[i] - etas[i] * etas[i] ); // this is X^2 - Y^2
	// }

	// // Variance calculations
	// double theta = .5*atan2(x1, x2);
	// double sinTheta =sin(theta);
	// double cosTheta = cos(theta);
	// double theta2 = theta + 0.5*PI;
	// double sinThetaPrime = sin(theta2);
	// double cosThetaPrime = cos(theta2);

	// double varX(0), varY(0);
	// for (size_t i = 0; i < jet.particles().size(); i++) {
	// const double x = sinThetaetas[i] + cosThetaphis[i];
	// const double y = sinThetaPrimeetas[i] + cosThetaPrimephis[i];
	// varX += energies[i]* sqr(x);
	// varY += energies[i]* sqr(y);
	// }
	// const double varianceMax = max(varX, varY);
	// const double varianceMin = min(varX, varY);
	// const double ecc = (varianceMax != 0.0) ? 1 - varianceMin/varianceMax : -1;
	// return ecc;
	// }


	/// Planar flow calculation, copied and adapted from Lily's code
	double getPFlow(const Jet& jet) {
	const double phi0 = jet.phi();
	const double eta0 = jet.eta();

	double nref[3]; ///< @todo 3-vector to rotate x to? Use Rivet vector classes
	nref[0] = cos(phi0)/cosh(eta0);
	nref[1] = sin(phi0)/cosh(eta0);
	nref[2] = tanh(eta0);

	// Rotation matrix to align with nref
	double rotationMatrix[3][3];
	CalcRotationMatrix(nref, rotationMatrix);

	double iw00(0.), iw01(0.), iw11(0.), iw10(0.);
	foreach (const Particle& p, jet.particles()) {
	double a = 1./(p.E()*jet.mass());
	FourMomentum rotclus = RotateAxes(p.momentum(), rotationMatrix);
	iw00 += a*pow(rotclus.px(), 2);
	iw01 += arotclus.px()rotclus.py();
	iw10 += arotclus.py()rotclus.px();
	iw11 += a*pow(rotclus.py(), 2);
	}

	const double det = iw00iw11 - iw01iw10;
	const double trace = iw00 + iw11;

	const double pf = (trace != 0.0) ? (4.0*det)/sqr(trace) : -1;
	return pf;
	}


	/// Angularity calculation, copied and adapted from Lily's code
	double getAngularity(const Jet& jet) {
	double sum_a = 0.;
	// a can take any value < 2 (e.g. 1,0,-0.5 etc) for infrared safety
	const double a = -2.;
	foreach (const Particle& p, jet.particles()) {
	double e_i = p.E();
	double theta_i = jet.momentum().angle(p.momentum());
	double e_theta_i = e_i * pow(sin(theta_i), a) * pow(1-cos(theta_i), 1-a);
	sum_a += e_theta_i;
	}
	const double rtn = (jet.mass() != 0.0 && !std::isnan(sum_a)) ? sum_a/jet.mass() : -1;
	return rtn;
	}

	}


	}
	diff --git a/src/Analyses/ATLAS_2012_I1124167.cc b/src/Analyses/ATLAS_2012_I1124167.cc
	--- a/src/Analyses/ATLAS_2012_I1124167.cc
	+++ b/src/Analyses/ATLAS_2012_I1124167.cc
	@@ -1,239 +1,239 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/Sphericity.hh"

	namespace Rivet {


	/// Rivet analysis class for ATLAS min bias event shapes
	class ATLAS_2012_I1124167 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1124167()
	: Analysis("ATLAS_2012_I1124167") { }


	/// Initialization, called once before running
	void init() {
	// Projections
	ChargedFinalState cfs(-2.5, 2.5, 0.5*GeV);
	- addProjection(cfs, "CFS");
	- addProjection(Sphericity(cfs), "Sphericity");
	+ declare(cfs, "CFS");
	+ declare(Sphericity(cfs), "Sphericity");

	// Book histograms
	_hist_T_05_25 = bookHisto1D(1,1,1);
	_hist_T_05 = bookHisto1D(2,1,1);
	_hist_T_25_50 = bookHisto1D(1,1,2);
	_hist_T_25 = bookHisto1D(2,1,2);
	_hist_T_50_75 = bookHisto1D(1,1,3);
	_hist_T_50 = bookHisto1D(2,1,3);
	_hist_T_75_100= bookHisto1D(1,1,4);
	_hist_T_75 = bookHisto1D(2,1,4);
	_hist_T_100 = bookHisto1D(2,1,5);

	_hist_TM_05_25 = bookHisto1D(3,1,1);
	_hist_TM_05 = bookHisto1D(4,1,1);
	_hist_TM_25_50 = bookHisto1D(3,1,2);
	_hist_TM_25 = bookHisto1D(4,1,2);
	_hist_TM_50_75 = bookHisto1D(3,1,3);
	_hist_TM_50 = bookHisto1D(4,1,3);
	_hist_TM_75_100= bookHisto1D(3,1,4);
	_hist_TM_75 = bookHisto1D(4,1,4);
	_hist_TM_100 = bookHisto1D(4,1,5);

	_hist_S_05_25 = bookHisto1D(5,1,1);
	_hist_S_05 = bookHisto1D(6,1,1);
	_hist_S_25_50 = bookHisto1D(5,1,2);
	_hist_S_25 = bookHisto1D(6,1,2);
	_hist_S_50_75 = bookHisto1D(5,1,3);
	_hist_S_50 = bookHisto1D(6,1,3);
	_hist_S_75_100= bookHisto1D(5,1,4);
	_hist_S_75 = bookHisto1D(6,1,4);
	_hist_S_100 = bookHisto1D(6,1,5);


	_hist_T_N = bookProfile1D(7,1,1);
	_hist_TM_N = bookProfile1D(7,1,2);
	_hist_S_N = bookProfile1D(7,1,3);

	_hist_T_S = bookProfile1D(8,1,1);
	_hist_TM_S = bookProfile1D(8,1,2);
	_hist_S_S = bookProfile1D(8,1,3);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	// CFS projection and particles
	- const ChargedFinalState& cfs500 = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs500 = apply<ChargedFinalState>(event, "CFS");
	ParticleVector particles500 = cfs500.particlesByPt();

	// Require at least 6 charged particles
	if (cfs500.size() < 6) vetoEvent;

	// Preparation for Thrust calculation
	vector<Vector3> momenta;

	// Counters
	double num500 = 0;
	double ptSum500 = 0;

	double pTlead = particles500[0].pT()/GeV;

	// Loop over particles
	foreach (const Particle& p, particles500) {
	num500 += 1;
	ptSum500 += p.pT()/GeV;

	// Transverse Thrust calculation requires p_z to be set to 0
	Vector3 mom = p.p3();
	mom.setZ(0.0);
	momenta.push_back(mom);
	}

	// If only 2 particles, we need to use a ghost so that Thrust.calc() doesn't return 1.
	if (momenta.size() == 2) {
	momenta.push_back(Vector3(1e-10*MeV, 0., 0.));
	}

	// Actual thrust calculation
	Thrust thrust;
	thrust.calc(momenta);

	const double T = 1.0 - thrust.thrust();
	const double TM = thrust.thrustMajor();

	Sphericity sphericity;
	sphericity.calc(momenta);

	const double S = sphericity.transSphericity();

	// Fill histos, most inclusive first

	// pTlead > 0.5
	_hist_T_05->fill(T , weight);
	_hist_TM_05->fill(TM, weight);
	_hist_S_05->fill(S , weight);

	// pTlead 0.5 - 2.5
	if (pTlead <= 2.5) {
	_hist_T_05_25->fill(T , weight);
	_hist_TM_05_25->fill(TM, weight);
	_hist_S_05_25->fill(S , weight);
	}

	// pTlead > 2.5
	if (pTlead > 2.5) {
	_hist_T_25->fill(T , weight);
	_hist_TM_25->fill(TM, weight);
	_hist_S_25->fill(S , weight);
	}

	// pTlead 2.5 - .5
	if (inRange(pTlead, 2.5, 5.0)) {
	_hist_T_25_50->fill(T , weight);
	_hist_TM_25_50->fill(TM, weight);
	_hist_S_25_50->fill(S , weight);
	}

	// pTlead > 5
	if (pTlead > 5) {
	_hist_T_50->fill(T , weight);
	_hist_TM_50->fill(TM, weight);
	_hist_S_50->fill(S , weight);
	}

	// pTlead 5 - 7.5
	if (inRange(pTlead, 5.0, 7.5)) {
	_hist_T_50_75->fill(T , weight);
	_hist_TM_50_75->fill(TM, weight);
	_hist_S_50_75->fill(S , weight);
	}

	// pTlead > 7.5
	if (pTlead > 7.5) {
	_hist_T_75->fill(T , weight);
	_hist_TM_75->fill(TM, weight);
	_hist_S_75->fill(S , weight);
	}

	// pTlead 7.5 - 10
	if (inRange(pTlead, 7.5, 10)) {
	_hist_T_75_100->fill(T , weight);
	_hist_TM_75_100->fill(TM, weight);
	_hist_S_75_100->fill(S , weight);
	}

	// pTlead > 10
	if (pTlead > 10) {
	_hist_T_100->fill(T , weight);
	_hist_TM_100->fill(TM, weight);
	_hist_S_100->fill(S , weight);
	}


	// Profiles Nch vs. ES
	_hist_T_N->fill(num500, T, weight);
	_hist_TM_N->fill(num500, TM, weight);
	_hist_S_N->fill(num500, S, weight);

	// Profiles pTsum vs. ES
	_hist_T_S->fill(ptSum500, T, weight);
	_hist_TM_S->fill(ptSum500, TM, weight);
	_hist_S_S->fill(ptSum500, S, weight);
	}


	void finalize() {
	normalize(_hist_T_05_25);
	normalize(_hist_T_05);
	normalize(_hist_T_25_50);
	normalize(_hist_T_25);
	normalize(_hist_T_50_75);
	normalize(_hist_T_50);
	normalize(_hist_T_75_100);
	normalize(_hist_T_75);
	normalize(_hist_T_100);

	normalize(_hist_TM_05_25);
	normalize(_hist_TM_05);
	normalize(_hist_TM_25_50);
	normalize(_hist_TM_25);
	normalize(_hist_TM_50_75);
	normalize(_hist_TM_50);
	normalize(_hist_TM_75_100);
	normalize(_hist_TM_75);
	normalize(_hist_TM_100);

	normalize(_hist_S_05_25);
	normalize(_hist_S_05);
	normalize(_hist_S_25_50);
	normalize(_hist_S_25);
	normalize(_hist_S_50_75);
	normalize(_hist_S_50);
	normalize(_hist_S_75_100);
	normalize(_hist_S_75);
	normalize(_hist_S_100);
	}


	private:

	Histo1DPtr _hist_T_05_25, _hist_T_05, _hist_T_25_50, _hist_T_25, _hist_T_50_75, _hist_T_50, _hist_T_75_100, _hist_T_75, _hist_T_100;
	Histo1DPtr _hist_TM_05_25, _hist_TM_05, _hist_TM_25_50, _hist_TM_25, _hist_TM_50_75, _hist_TM_50, _hist_TM_75_100, _hist_TM_75, _hist_TM_100;
	Histo1DPtr _hist_S_05_25, _hist_S_05, _hist_S_25_50, _hist_S_25, _hist_S_50_75, _hist_S_50, _hist_S_75_100, _hist_S_75, _hist_S_100;
	Profile1DPtr _hist_T_N, _hist_TM_N, _hist_S_N;
	Profile1DPtr _hist_T_S, _hist_TM_S, _hist_S_S;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1124167);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1125575.cc b/src/Analyses/ATLAS_2012_I1125575.cc
	--- a/src/Analyses/ATLAS_2012_I1125575.cc
	+++ b/src/Analyses/ATLAS_2012_I1125575.cc
	@@ -1,240 +1,240 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	/// ATLAS charged particle jet underlying event and jet radius dependence
	class ATLAS_2012_I1125575 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2012_I1125575()
	: Analysis("ATLAS_2012_I1125575")
	{ }

	//@}


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	const ChargedFinalState jet_input(-2.5, 2.5, 0.5*GeV);
	- addProjection(jet_input, "JET_INPUT");
	+ declare(jet_input, "JET_INPUT");

	const ChargedFinalState track_input(-1.5, 1.5, 0.5*GeV);
	- addProjection(track_input, "TRACK_INPUT");
	+ declare(track_input, "TRACK_INPUT");

	const FastJets jets02(jet_input, FastJets::ANTIKT, 0.2);
	- addProjection(jets02, "JETS_02");
	+ declare(jets02, "JETS_02");

	const FastJets jets04(jet_input, FastJets::ANTIKT, 0.4);
	- addProjection(jets04, "JETS_04");
	+ declare(jets04, "JETS_04");

	const FastJets jets06(jet_input, FastJets::ANTIKT, 0.6);
	- addProjection(jets06, "JETS_06");
	+ declare(jets06, "JETS_06");

	const FastJets jets08(jet_input, FastJets::ANTIKT, 0.8);
	- addProjection(jets08, "JETS_08");
	+ declare(jets08, "JETS_08");

	const FastJets jets10(jet_input, FastJets::ANTIKT, 1.0);
	- addProjection(jets10, "JETS_10");
	+ declare(jets10, "JETS_10");

	// Mean number of tracks
	initializeProfiles(_h_meanNch, 1);

	// Mean of the average track pT in each region
	initializeProfiles(_h_meanPtAvg, 2);

	// Mean of the scalar sum of track pT in each region
	initializeProfiles(_h_meanPtSum, 3);

	// Distribution of Nch, in bins of leading track-jet pT
	initializeHistograms(_h_Nch, 4);

	// Distribution of average track-jet pT, in bins of leading track-jet pT
	initializeHistograms(_h_PtAvg, 5);

	// Distribution of sum of track-jet pT, in bins of leading track-jet pT
	initializeHistograms(_h_PtSum, 6);

	for (int i = 0; i < 5; ++i)
	_nEvents[i] = 0.0;
	}


	void initializeProfiles(Profile1DPtr plots[5][2], int distribution) {
	for (int i = 0; i < 5; ++i) {
	for (int j = 0; j < 2; ++j) {
	plots[i][j] = bookProfile1D(distribution, i+1, j+1);
	}
	}
	}


	void initializeHistograms(BinnedHistogram<double> plots[5][2], int distribution) {
	Scatter2D refscatter = refData(1, 1, 1);
	for (int i = 0; i < 5; ++i) {
	for (int y = 0; y < 2; ++y) {
	for (size_t j = 0; j < refscatter.numPoints(); ++j) {
	int histogram_number = ((j+1)*2)-((y+1)%2);
	double low_edge = refscatter.point(j).xMin();
	double high_edge = refscatter.point(j).xMax();
	plots[i][y].addHistogram(low_edge, high_edge, bookHisto1D(distribution, i+1, histogram_number));
	}
	}
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	vector<Jets*> all_jets;
	- Jets jets_02 = applyProjection<FastJets>(event, "JETS_02").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	+ Jets jets_02 = apply<FastJets>(event, "JETS_02").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	all_jets.push_back(&jets_02);
	- Jets jets_04 = applyProjection<FastJets>(event, "JETS_04").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	+ Jets jets_04 = apply<FastJets>(event, "JETS_04").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	all_jets.push_back(&jets_04);
	- Jets jets_06 = applyProjection<FastJets>(event, "JETS_06").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	+ Jets jets_06 = apply<FastJets>(event, "JETS_06").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	all_jets.push_back(&jets_06);
	- Jets jets_08 = applyProjection<FastJets>(event, "JETS_08").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	+ Jets jets_08 = apply<FastJets>(event, "JETS_08").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	all_jets.push_back(&jets_08);
	- Jets jets_10 = applyProjection<FastJets>(event, "JETS_10").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	+ Jets jets_10 = apply<FastJets>(event, "JETS_10").jetsByPt(Cuts::pT > 4*GeV && Cuts::abseta < 1.5);
	all_jets.push_back(&jets_10);

	// Count the number of tracks in the away and transverse regions, for each set of jets
	double n_ch[5][2] = { {0,0}, {0,0}, {0,0}, {0,0}, {0,0} };
	// Also add up the sum pT
	double sumpt[5][2] = { {0,0}, {0,0}, {0,0}, {0,0}, {0,0} };
	// ptmean = sumpt / n_ch
	double ptavg[5][2] = { {0,0}, {0,0}, {0,0}, {0,0}, {0,0} };
	// lead jet pT defines which bin we want to fill
	double lead_jet_pts[5] = {0.0};

	// Loop over each of the jet radii:
	for (int i = 0; i < 5; ++i) {
	if (all_jets[i]->size() < 1) continue;

	// Find the lead jet pT
	lead_jet_pts[i] = all_jets[i]->at(0).pT();

	// Loop over each of the charged particles
	- const Particles& tracks = applyProjection<ChargedFinalState>(event, "TRACK_INPUT").particlesByPt();
	+ const Particles& tracks = apply<ChargedFinalState>(event, "TRACK_INPUT").particlesByPt();
	foreach(const Particle& t, tracks) {

	// Get the delta-phi between the track and the leading jet
	double dphi = deltaPhi(all_jets[i]->at(0), t);

	// Find out which region this puts it in.
	// 0 = away region, 1 = transverse region, 2 = toward region
	int region = region_index(dphi);

	// If the track is in the toward region, ignore it.
	if (region == 2) continue;

	// Otherwise, increment the relevant counters
	++n_ch[i][region];
	sumpt[i][region] += t.pT();

	}
	// Calculate the pT_avg for the away and transverse regions.
	// (And make sure we don't try to divide by zero.)
	ptavg[i][0] = (n_ch[i][0] == 0 ? 0.0 : sumpt[i][0] / n_ch[i][0]);
	ptavg[i][1] = (n_ch[i][1] == 0 ? 0.0 : sumpt[i][1] / n_ch[i][1]);

	_nEvents[i] += weight;
	}

	fillProfiles(_h_meanNch, n_ch, lead_jet_pts, weight, 1.0 / (2*PI));
	fillProfiles(_h_meanPtAvg, ptavg, lead_jet_pts, weight, 1.0);
	fillProfiles(_h_meanPtSum, sumpt, lead_jet_pts, weight, 1.0 / (2*PI));

	fillHistograms(_h_Nch, n_ch, lead_jet_pts, weight);
	fillHistograms(_h_PtAvg, ptavg, lead_jet_pts, weight);
	fillHistograms(_h_PtSum, sumpt, lead_jet_pts, weight);
	}


	void fillProfiles(Profile1DPtr plots[5][2], double var[5][2], double lead_pt[5], double weight, double scale) {
	for (int i=0; i<5; ++i) {
	double pt = lead_pt[i];
	for (int j=0; j<2; ++j) {
	double v = var[i][j];
	plots[i][j]->fill(pt, v*scale, weight);
	}
	}
	}


	void fillHistograms(BinnedHistogram<double> plots[5][2], double var[5][2], double lead_pt[5], double weight) {
	for (int i=0; i<5; ++i) {
	double pt = lead_pt[i];
	for (int j=0; j<2; ++j) {
	double v = var[i][j];
	plots[i][j].fill(pt, v, weight);
	}
	}
	}


	int region_index(double dphi) {
	assert(inRange(dphi, 0.0, PI, CLOSED, CLOSED));
	if (dphi < PI/3.0) return 2;
	if (dphi < 2*PI/3.0) return 1;
	return 0;
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	finalizeHistograms(_h_Nch);
	finalizeHistograms(_h_PtAvg);
	finalizeHistograms(_h_PtSum);
	}


	void finalizeHistograms(BinnedHistogram<double> plots[5][2]) {
	for (int i = 0; i < 5; ++i) {
	for (int j = 0; j < 2; ++j) {
	vector<Histo1DPtr> histos = plots[i][j].getHistograms();
	foreach(Histo1DPtr h, histos) {
	scale(h, 1.0/_nEvents[i]);
	}
	}
	}
	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here
	double _nEvents[5];

	Profile1DPtr _h_meanNch[5][2];
	Profile1DPtr _h_meanPtAvg[5][2];
	Profile1DPtr _h_meanPtSum[5][2];

	BinnedHistogram<double> _h_Nch[5][2];
	BinnedHistogram<double> _h_PtAvg[5][2];
	BinnedHistogram<double> _h_PtSum[5][2];

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1125575);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1125961.cc b/src/Analyses/ATLAS_2012_I1125961.cc
	--- a/src/Analyses/ATLAS_2012_I1125961.cc
	+++ b/src/Analyses/ATLAS_2012_I1125961.cc
	@@ -1,316 +1,316 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {



	/// @author Peter Richardson
	class ATLAS_2012_I1125961 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1125961()
	: Analysis("ATLAS_2012_I1125961")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// Projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// All tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0), "cfs");

	// Used for pTmiss (N.B. the real 'vfs' extends beyond 4.5 to \|eta\| = 4.9)
	- addProjection(VisibleFinalState(Cuts::abseta < 4.5), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.5), "vfs");

	// Book histograms
	_count_A_tight = bookHisto1D("count_A_tight" , 1, 0., 1.);
	_count_A_medium = bookHisto1D("count_A_medium" , 1, 0., 1.);
	_count_Ap_medium = bookHisto1D("count_Ap_medium" , 1, 0., 1.);
	_count_B_tight = bookHisto1D("count_B_tight" , 1, 0., 1.);
	_count_C_tight = bookHisto1D("count_C_tight" , 1, 0., 1.);
	_count_C_medium = bookHisto1D("count_C_medium" , 1, 0., 1.);
	_count_C_loose = bookHisto1D("count_C_loose" , 1, 0., 1.);
	_count_D_tight = bookHisto1D("count_D_tight" , 1, 0., 1.);
	_count_E_tight = bookHisto1D("count_E_tight" , 1, 0., 1.);
	_count_E_medium = bookHisto1D("count_E_medium" , 1, 0., 1.);
	_count_E_loose = bookHisto1D("count_E_loose" , 1, 0., 1.);

	_hist_meff_A = bookHisto1D("hist_m_eff_A" , 30, 0., 3000.);
	_hist_meff_Ap = bookHisto1D("hist_m_eff_Ap", 30, 0., 3000.);
	_hist_meff_B = bookHisto1D("hist_m_eff_B" , 30, 0., 3000.);
	_hist_meff_C = bookHisto1D("hist_m_eff_C" , 30, 0., 3000.);
	_hist_meff_D = bookHisto1D("hist_m_eff_D" , 30, 0., 3000.);
	_hist_meff_E = bookHisto1D("hist_m_eff_E" , 30, 0., 3000.);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	Jets cand_jets;
	- const Jets jets = applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
	+ const Jets jets = apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV);
	foreach (const Jet& jet, jets) {
	if ( fabs( jet.eta() ) < 4.9 ) {
	cand_jets.push_back(jet);
	}
	}

	- const Particles cand_e = applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ const Particles cand_e = apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	// Muon isolation not mentioned in hep-exp 1109.6572 but assumed to still be applicable
	Particles cand_mu;
	- const Particles chg_tracks = applyProjection<ChargedFinalState>(event, "cfs").particles();
	- const Particles muons = applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt();
	+ const Particles chg_tracks = apply<ChargedFinalState>(event, "cfs").particles();
	+ const Particles muons = apply<IdentifiedFinalState>(event, "muons").particlesByPt();
	foreach (const Particle& mu, muons) {
	double pTinCone = -mu.pT();
	foreach (const Particle& track, chg_tracks) {
	if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 ) {
	pTinCone += track.pT();
	}
	}
	if ( pTinCone < 1.8*GeV ) cand_mu.push_back(mu);
	}

	// Resolve jet-lepton overlap for jets with \|eta\| < 2.8
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	if ( fabs( jet.eta() ) >= 2.8 ) continue;
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}

	Particles recon_e, recon_mu;

	foreach ( const Particle & e, cand_e ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away ) recon_e.push_back( e );
	}

	foreach ( const Particle & mu, cand_mu ) {
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if ( away ) recon_mu.push_back( mu );
	}

	// pTmiss
	// Based on all candidate electrons, muons and jets, plus everything else with \|eta\| < 4.5
	// i.e. everything in our projection "vfs" plus the jets with \|eta\| > 4.5
	- Particles vfs_particles = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ Particles vfs_particles = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	foreach ( const Jet& jet, cand_jets ) {
	if ( fabs( jet.eta() ) > 4.5 ) pTmiss -= jet.momentum();
	}
	double eTmiss = pTmiss.pT();

	// no electron pT> 20 or muons pT>10
	if ( !recon_mu.empty() \|\| !recon_e.empty() ) {
	MSG_DEBUG("Charged leptons left after selection");
	vetoEvent;
	}

	if ( eTmiss <= 160 * GeV ) {
	MSG_DEBUG("Not enough eTmiss: " << eTmiss << " < 130");
	vetoEvent;
	}

	if ( recon_jets.size()<2 \|\|
	recon_jets[0].pT() <= 130.0 * GeV \|\|
	recon_jets[0].pT() <= 60.0 * GeV ) {
	MSG_DEBUG("No hard leading jet in " << recon_jets.size() << " jets");
	vetoEvent;
	}

	// ==================== observables ====================

	int Njets = 0;
	double min_dPhi_All = 999.999;
	double min_dPhi_2 = 999.999;
	double min_dPhi_3 = 999.999;
	double pTmiss_phi = pTmiss.phi();
	foreach ( const Jet& jet, recon_jets ) {
	if ( jet.pT() < 40 * GeV ) continue;
	if ( Njets < 2 ) {
	min_dPhi_2 = min( min_dPhi_2, deltaPhi( pTmiss_phi, jet.phi() ) );
	}
	if( Njets < 3) {
	min_dPhi_3 = min( min_dPhi_3, deltaPhi( pTmiss_phi, jet.phi() ) );
	}
	min_dPhi_All = min( min_dPhi_All, deltaPhi( pTmiss_phi, jet.phi() ) );
	++Njets;
	}

	// inclusive meff
	double m_eff_inc = eTmiss;
	foreach ( const Jet& jet, recon_jets ) {
	double perp = jet.pT();
	if(perp>40.) m_eff_inc += perp;
	}

	// region A
	double m_eff_Nj = eTmiss + recon_jets[0].pT() + recon_jets[1].pT();
	if( min_dPhi_2 > 0.4 && eTmiss/m_eff_Nj > 0.3 ) {
	_hist_meff_A->fill(m_eff_inc,weight);
	if(m_eff_inc>1900.) _count_A_tight ->fill(0.5,weight);
	if(m_eff_inc>1400.) _count_A_medium->fill(0.5,weight);
	}

	// region A'
	if( min_dPhi_2 > 0.4 && eTmiss/m_eff_Nj > 0.4 ) {
	_hist_meff_Ap->fill(m_eff_inc,weight);
	if(m_eff_inc>1200.) _count_Ap_medium->fill(0.5,weight);
	}

	// for rest of regions 3 jets pT> 60 needed
	if(recon_jets.size()<3 \|\| recon_jets[2].perp()<60.)
	vetoEvent;

	// region B
	m_eff_Nj += recon_jets[2].perp();
	if( min_dPhi_3 > 0.4 && eTmiss/m_eff_Nj > 0.25 ) {
	_hist_meff_B->fill(m_eff_inc,weight);
	if(m_eff_inc>1900.) _count_B_tight ->fill(0.5,weight);
	}

	// for rest of regions 4 jets pT> 60 needed
	if(recon_jets.size()<4 \|\| recon_jets[3].perp()<60.)
	vetoEvent;

	// region C
	m_eff_Nj += recon_jets[3].perp();
	if( min_dPhi_3 > 0.4 && min_dPhi_All > 0.2 && eTmiss/m_eff_Nj > 0.25 ) {
	_hist_meff_C->fill(m_eff_inc,weight);
	if(m_eff_inc>1500.) _count_C_tight ->fill(0.5,weight);
	if(m_eff_inc>1200.) _count_C_medium->fill(0.5,weight);
	if(m_eff_inc> 900.) _count_C_loose ->fill(0.5,weight);
	}

	// for rest of regions 5 jets pT> 40 needed
	if(recon_jets.size()<5 \|\| recon_jets[4].perp()<40.)
	vetoEvent;

	// region D
	m_eff_Nj += recon_jets[4].perp();
	if( min_dPhi_3 > 0.4 && min_dPhi_All > 0.2 && eTmiss/m_eff_Nj > 0.2 ) {
	_hist_meff_D->fill(m_eff_inc,weight);
	if(m_eff_inc>1500.) _count_D_tight ->fill(0.5,weight);
	}

	// for rest of regions 6 jets pT> 40 needed
	if(recon_jets.size()<6 \|\| recon_jets[5].perp()<40.)
	vetoEvent;

	// region E
	m_eff_Nj += recon_jets[5].perp();
	if( min_dPhi_3 > 0.4 && min_dPhi_All > 0.2 && eTmiss/m_eff_Nj > 0.15 ) {
	_hist_meff_E->fill(m_eff_inc,weight);
	if(m_eff_inc>1400.) _count_E_tight ->fill(0.5,weight);
	if(m_eff_inc>1200.) _count_E_medium->fill(0.5,weight);
	if(m_eff_inc> 900.) _count_E_loose ->fill(0.5,weight);
	}
	}


	void finalize() {

	double norm = crossSection()/femtobarn*4.7/sumOfWeights();
	// these are number of events at 4.7fb^-1 per 100 GeV
	scale( _hist_meff_A , 100. * norm );
	scale( _hist_meff_Ap, 100. * norm );
	scale( _hist_meff_B , 100. * norm );
	scale( _hist_meff_C , 100. * norm );
	scale( _hist_meff_D , 100. * norm );
	scale( _hist_meff_E , 100. * norm );
	// these are number of events at 4.7fb^-1
	scale(_count_A_tight ,norm);
	scale(_count_A_medium ,norm);
	scale(_count_Ap_medium,norm);
	scale(_count_B_tight ,norm);
	scale(_count_C_tight ,norm);
	scale(_count_C_medium ,norm);
	scale(_count_C_loose ,norm);
	scale(_count_D_tight ,norm);
	scale(_count_E_tight ,norm);
	scale(_count_E_medium ,norm);
	scale(_count_E_loose ,norm);
	}

	//@}


	private:

	Histo1DPtr _count_A_tight;
	Histo1DPtr _count_A_medium;
	Histo1DPtr _count_Ap_medium;
	Histo1DPtr _count_B_tight;
	Histo1DPtr _count_C_tight;
	Histo1DPtr _count_C_medium;
	Histo1DPtr _count_C_loose;
	Histo1DPtr _count_D_tight;
	Histo1DPtr _count_E_tight;
	Histo1DPtr _count_E_medium;
	Histo1DPtr _count_E_loose;

	Histo1DPtr _hist_meff_A ;
	Histo1DPtr _hist_meff_Ap;
	Histo1DPtr _hist_meff_B ;
	Histo1DPtr _hist_meff_C ;
	Histo1DPtr _hist_meff_D ;
	Histo1DPtr _hist_meff_E ;

	};


	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1125961);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1126136.cc b/src/Analyses/ATLAS_2012_I1126136.cc
	--- a/src/Analyses/ATLAS_2012_I1126136.cc
	+++ b/src/Analyses/ATLAS_2012_I1126136.cc
	@@ -1,300 +1,300 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	class ATLAS_2012_I1126136 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1126136()
	: Analysis("ATLAS_2012_I1126136")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialize projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");

	// Book histograms
	_count_SR_A = bookHisto1D("count_SR_A" , 1, 0., 1.);
	_count_SR_B = bookHisto1D("count_SR_B" , 1, 0., 1.);

	_hist_mjjj1 = bookHisto1D("hist_mjjj1" , 30 , 0. , 600. );
	_hist_mjjj2 = bookHisto1D("hist_mjjj2" , 30 , 0. , 600. );
	_hist_ETmiss = bookHisto1D("hist_ETmiss", 20 , 100. , 600. );
	_hist_mT2 = bookHisto1D("hist_mT2" , 200, 0. , 1000. );

	}

	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// pTmiss
	FourMomentum pTmiss;
	- foreach (const Particle& p, applyProjection<VisibleFinalState>(event, "vfs").particles() ) {
	+ foreach (const Particle& p, apply<VisibleFinalState>(event, "vfs").particles() ) {
	pTmiss -= p.momentum();
	}
	double ETmiss = pTmiss.pT();

	// require eTmiss > 150
	if (ETmiss < 150*GeV) vetoEvent;

	// get the candiate jets
	Jets cand_jets;
	- foreach ( const Jet& jet, applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ foreach ( const Jet& jet, apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if (jet.abseta() < 4.5) cand_jets.push_back(jet);
	}

	// find the electrons
	Particles cand_e;
	- foreach( const Particle& e, applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	+ foreach( const Particle& e, apply<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	// remove any leptons within 0.4 of any candidate jets
	bool e_near_jet = false;
	foreach ( const Jet& jet, cand_jets ) {
	double dR = deltaR(e, jet);
	if (inRange(dR, 0.2, 0.4)) {
	e_near_jet = true;
	break;
	}
	}
	if ( e_near_jet ) continue;
	cand_e.push_back(e);
	}

	// find the muons
	Particles cand_mu;
	- foreach( const Particle& mu, applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	+ foreach( const Particle& mu, apply<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	// remove any leptons within 0.4 of any candidate jets
	bool mu_near_jet = false;
	foreach ( const Jet& jet, cand_jets ) {
	if ( deltaR(mu, jet) < 0.4 ) {
	mu_near_jet = true;
	break;
	}
	}
	if ( mu_near_jet ) continue;
	cand_mu.push_back(mu);
	}

	// veto events with leptons
	if( ! cand_e.empty() \|\| ! cand_mu.empty() )
	vetoEvent;

	// discard jets that overlap with electrons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	if (jet.abseta() > 2.8 \|\| jet.pT() < 30*GeV) continue;
	bool away_from_e = true;
	foreach (const Particle& e, cand_e ) {
	if ( deltaR(e, jet) < 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}

	// find b jets
	Jets tight_bjets,loose_bjets;
	foreach(const Jet& jet, recon_jets) {
	/// @todo Should be abseta?
	if (!jet.bTagged() && jet.eta()>2.5) continue;
	double prob = rand()/static_cast<double>(RAND_MAX);
	if (prob <= 0.60) tight_bjets.push_back(jet);
	if (prob <= 0.75) loose_bjets.push_back(jet);
	}

	// require >=1 tight or >=2 loose b-jets
	if (! ( !tight_bjets.empty() \|\| loose_bjets.size()>=2) )
	vetoEvent;

	// must be at least 6 jets with pT>30
	if (recon_jets.size()<6 ) vetoEvent;

	// hardest > 130
	if (recon_jets[0].perp() < 130. ) vetoEvent;

	// three hardest jets must be separated from etmiss
	for (unsigned int ix=0;ix<3;++ix) {
	if (deltaPhi(recon_jets[ix].momentum(),pTmiss)<0.2*PI)
	vetoEvent;
	}

	// remove events with tau like jets
	for (unsigned int ix=3;ix<recon_jets.size();++ix) {
	// skip jets seperated from eTmiss
	if (deltaPhi(recon_jets[ix].momentum(),pTmiss)>=0.2*PI)
	continue;
	// check the number of tracks between 1 and 4
	unsigned int ncharged=0;
	foreach ( const Particle & particle, recon_jets[ix].particles()) {
	if (PID::threeCharge(particle.pid())!=0) ++ncharged;
	}
	if (ncharged==0 \|\| ncharged>4) continue;
	// calculate transverse mass and reject if < 100
	double mT = 2.recon_jets[ix].perp()ETmiss
	-recon_jets[ix].px()*pTmiss.px()
	-recon_jets[ix].py()*pTmiss.py();
	if (mT<100.) vetoEvent;
	}

	// if 2 loose b-jets apply mT cut
	if (loose_bjets.size()>=2) {
	// find b-jet closest to eTmiss
	double minR(1e30);
	unsigned int ijet(0);
	for(unsigned int ix=0;ix<loose_bjets.size();++ix) {
	double dR = deltaR(loose_bjets[ix].momentum(),pTmiss);
	if(dR<minR) {
	minR=dR;
	ijet = ix;
	}
	}
	double mT = 2.loose_bjets[ijet].perp()ETmiss
	-loose_bjets[ijet].px()*pTmiss.px()
	-loose_bjets[ijet].py()*pTmiss.py();
	if(mT<170.) vetoEvent;
	}

	// 1 tight b-jet apply mT cut
	if(tight_bjets.size()==1) {
	for(unsigned int ix=0;ix<4;++ix) {
	double mT = 2.recon_jets[ix].perp()ETmiss
	-recon_jets[ix].px()*pTmiss.px()
	-recon_jets[ix].py()*pTmiss.py();
	if(mT<175.) vetoEvent;
	}
	}

	// find the closest triplet of jets in (eta,phi)
	unsigned int j1(0),j2(0),j3(0);
	double minR2(1e30);
	for(unsigned int i1=0;i1<recon_jets.size();++i1) {
	for(unsigned int i2=i1+1;i2<recon_jets.size();++i2) {
	for(unsigned int i3=i2+1;i3<recon_jets.size();++i3) {
	double delR2 =
	sqr(deltaR(recon_jets[i1].momentum(),recon_jets[i2].momentum())) +
	sqr(deltaR(recon_jets[i1].momentum(),recon_jets[i3].momentum())) +
	sqr(deltaR(recon_jets[i2].momentum(),recon_jets[i3].momentum()));
	if(delR2<minR2) {
	minR2=delR2;
	j1=i1;
	j2=i2;
	j3=i3;
	}
	}
	}
	}
	// 4-momentum and mass of first triplet
	FourMomentum pjjj1 = recon_jets[j1].momentum() +
	recon_jets[j2].momentum()+ recon_jets[j3].momentum();
	double mjjj1 = pjjj1.mass();

	// find the second triplet
	unsigned int j4(0),j5(0),j6(0);
	minR2=0.;
	for(unsigned int i1=0;i1<recon_jets.size();++i1) {
	if(i1==j1\|\|i1==j2\|\|i1==j3) continue;
	for(unsigned int i2=i1+1;i2<recon_jets.size();++i2) {
	if(i2==j1\|\|i2==j2\|\|i2==j3) continue;
	for(unsigned int i3=i2+1;i3<recon_jets.size();++i3) {
	if(i3==j1\|\|i3==j2\|\|i3==j3) continue;
	double delR2 =
	sqr(deltaR(recon_jets[i1].momentum(),recon_jets[i2].momentum())) +
	sqr(deltaR(recon_jets[i1].momentum(),recon_jets[i3].momentum())) +
	sqr(deltaR(recon_jets[i2].momentum(),recon_jets[i3].momentum()));
	if(delR2<minR2) {
	minR2=delR2;
	j4=i1;
	j5=i2;
	j6=i3;
	}
	}
	}
	}

	// 4-momentum and mass of first triplet
	FourMomentum pjjj2 = recon_jets[j4].momentum() +
	recon_jets[j5].momentum()+ recon_jets[j6].momentum();
	double mjjj2 = pjjj2.mass();

	_hist_mjjj1->fill(mjjj1,weight);
	_hist_mjjj2->fill(mjjj2,weight);
	// require triplets in 80<mjjj<270
	if(mjjj1<80.\|\|mjjj1>270.\|\|mjjj2<80.\|\|mjjj2>270.)
	vetoEvent;

	// counts in signal regions
	_count_SR_A->fill(0.5,weight);
	if(ETmiss>260.) _count_SR_B->fill(0.5,weight);

	_hist_ETmiss->fill(ETmiss,weight);
	double m_T2 = mT2::mT2( pjjj1,pjjj2,
	pTmiss,0.0 ); // zero mass invisibles
	_hist_mT2->fill(m_T2,weight);
	}
	//@}


	void finalize() {

	double norm = 4.7* crossSection()/sumOfWeights()/femtobarn;
	scale(_count_SR_A , norm );
	scale(_count_SR_B , norm );
	scale(_hist_mjjj1 , 20.*norm );
	scale(_hist_ETmiss, 50.*norm );
	scale(_hist_mjjj2 , 20.*norm );
	scale(_hist_mT2 , norm );

	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_SR_A;
	Histo1DPtr _count_SR_B;

	Histo1DPtr _hist_mjjj1;
	Histo1DPtr _hist_mjjj2;
	Histo1DPtr _hist_ETmiss;
	Histo1DPtr _hist_mT2;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1126136);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1180197.cc b/src/Analyses/ATLAS_2012_I1180197.cc
	--- a/src/Analyses/ATLAS_2012_I1180197.cc
	+++ b/src/Analyses/ATLAS_2012_I1180197.cc
	@@ -1,416 +1,416 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2012_I1180197 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1180197()
	: Analysis("ATLAS_2012_I1180197")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialize projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 7*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 6*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9), "vfs");

	// Book histograms
	_count_1l_3jet_all_channel = bookHisto1D("count_1l_3jet_all_channel", 1, 0., 1.);
	_count_1l_3jet_e_channel = bookHisto1D("count_1l_3jet_e_channel" , 1, 0., 1.);
	_count_1l_3jet_mu_channel = bookHisto1D("count_1l_3jet_mu_channel" , 1, 0., 1.);
	_count_1l_4jet_all_channel = bookHisto1D("count_1l_4jet_all_channel", 1, 0., 1.);
	_count_1l_4jet_e_channel = bookHisto1D("count_1l_4jet_e_channel" , 1, 0., 1.);
	_count_1l_4jet_mu_channel = bookHisto1D("count_1l_4jet_mu_channel" , 1, 0., 1.);
	_count_1l_soft_all_channel = bookHisto1D("count_1l_soft_all_channel", 1, 0., 1.);
	_count_1l_soft_e_channel = bookHisto1D("count_1l_soft_e_channel" , 1, 0., 1.);
	_count_1l_soft_mu_channel = bookHisto1D("count_1l_soft_mu_channel" , 1, 0., 1.);

	_count_2l_2jet_all_channel = bookHisto1D("count_2l_2jet_all_channel" , 1, 0., 1.);
	_count_2l_2jet_ee_channel = bookHisto1D("count_2l_2jet_ee_channel" , 1, 0., 1.);
	_count_2l_2jet_emu_channel = bookHisto1D("count_2l_2jet_emu_channel" , 1, 0., 1.);
	_count_2l_2jet_mumu_channel = bookHisto1D("count_2l_2jet_mumu_channel", 1, 0., 1.);
	_count_2l_4jet_all_channel = bookHisto1D("count_2l_4jet_all_channel" , 1, 0., 1.);
	_count_2l_4jet_ee_channel = bookHisto1D("count_2l_4jet_ee_channel" , 1, 0., 1.);
	_count_2l_4jet_emu_channel = bookHisto1D("count_2l_4jet_emu_channel" , 1, 0., 1.);
	_count_2l_4jet_mumu_channel = bookHisto1D("count_2l_4jet_mumu_channel", 1, 0., 1.);
	_hist_1l_m_eff_3jet = bookHisto1D("hist_1l_m_eff_3jet" , 6, 400., 1600.);
	_hist_1l_m_eff_4jet = bookHisto1D("hist_1l_m_eff_4jet" , 4, 800., 1600.);
	_hist_1l_eTmiss_m_eff_soft = bookHisto1D("hist_1l_eTmiss_m_eff_soft", 6, 0.1 , 0.7 );
	_hist_2l_m_eff_2jet = bookHisto1D("hist_2l_m_eff_2jet" , 5, 700., 1700.);
	_hist_2l_m_eff_4jet = bookHisto1D("hist_2l_m_eff_4jet" , 5, 600., 1600.);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// get the candiate jets
	Jets cand_jets;
	foreach ( const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 4.5 ) {
	cand_jets.push_back(jet);
	}
	}
	// charged tracks for isolation
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	// find the electrons
	Particles cand_soft_e,cand_hard_e;
	foreach( const Particle & e,
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	double pT = e.pT();
	double eta = e.eta();
	// remove any leptons within 0.4 of any candidate jets
	bool e_near_jet = false;
	foreach ( const Jet& jet, cand_jets ) {
	double dR = deltaR(e.momentum(),jet.momentum());
	if ( inRange(dR, 0.2, 0.4) ) {
	e_near_jet = true;
	break;
	}
	}
	if ( e_near_jet ) continue;
	// soft selection
	if(pT>7.&&!(fabs(eta)>1.37&&fabs(eta) < 1.52)) {
	cand_soft_e.push_back(e);
	}
	// hard selection
	if(pT>10.) cand_hard_e.push_back(e);
	}
	Particles cand_soft_mu,cand_hard_mu;
	foreach( const Particle & mu,
	- applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	+ apply<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	double pT = mu.pT();
	double eta = mu.eta();
	// remove any leptons within 0.4 of any candidate jets
	bool mu_near_jet = false;
	foreach ( const Jet& jet, cand_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	mu_near_jet = true;
	break;
	}
	}
	if ( mu_near_jet ) continue;
	// soft selection
	if (pT > 6*GeV && !inRange(fabs(eta), 1.37, 1.52)) {
	cand_soft_mu.push_back(mu);
	}
	// hard selection
	if (pT > 10*GeV) cand_hard_mu.push_back(mu);
	}
	// pTcone around muon track (hard)
	Particles recon_hard_mu;
	foreach ( const Particle & mu, cand_hard_mu ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV ) recon_hard_mu.push_back(mu);
	}
	// pTcone around muon track (soft)
	Particles recon_soft_mu;
	foreach ( const Particle & mu, cand_soft_mu ) {
	double pTinCone = -mu.pT();
	if(-pTinCone>20.) continue;
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV ) recon_soft_mu.push_back(mu);
	}
	// pTcone around electron track (hard)
	Particles recon_hard_e;
	foreach ( const Particle & e, cand_hard_e ) {
	double pTinCone = -e.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 0.1 * e.pT() ) recon_hard_e.push_back(e);
	}
	// pTcone around electron track (soft)
	Particles recon_soft_e;
	foreach ( const Particle & e, cand_soft_e ) {
	double pTinCone = -e.pT();
	if(-pTinCone>25.) continue;
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 0.1 * e.pT() ) recon_soft_e.push_back(e);
	}

	// pTmiss
	FourMomentum pTmiss;
	foreach ( const Particle & p,
	- applyProjection<VisibleFinalState>(event, "vfs").particles() ) {
	+ apply<VisibleFinalState>(event, "vfs").particles() ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// hard lepton selection
	if( ! recon_hard_e.empty() \|\| !recon_hard_mu.empty() ) {
	// discard jets that overlap with electrons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	if(jet.abseta()>2.5\|\|
	jet.pT() < 25*GeV) continue;
	bool away_from_e = true;
	foreach ( const Particle & e, cand_hard_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}
	// both selections require at least 2 jets
	// meff calculation
	double HT=0.;
	foreach( const Jet & jet, recon_jets) {
	HT += jet.pT();
	}
	double m_eff_inc = HT+eTmiss;
	unsigned int njet = recon_jets.size();
	// 1 lepton only
	if( recon_hard_e.size() + recon_hard_mu.size() == 1 && njet >=3 ) {
	// get the lepton
	Particle lepton = recon_hard_e.empty() ?
	recon_hard_mu[0] : recon_hard_e[0];
	// lepton variables
	double pT = lepton.pT();
	double mT = 2.(pTeTmiss -
	lepton.px()*pTmiss.px() -
	lepton.py()*pTmiss.py());
	mT = sqrt(mT);
	HT += pT;
	m_eff_inc += pT;
	// apply the cuts on the leptons and min no. of jets
	if( ( ( lepton.abspid() == PID::ELECTRON && pT > 25. ) \|\|
	( lepton.abspid() == PID::MUON && pT > 20. ) ) &&
	mT > 100. && eTmiss > 250. ) {
	double m_eff = pT+eTmiss;
	for (size_t ix = 0; ix < 3; ++ix)
	m_eff += recon_jets[ix].pT();
	// 3 jet channel
	if ( (njet == 3 \|\| recon_jets[3].pT() < 80*GeV ) &&
	recon_jets[0].pT() > 100*GeV ) {
	if (eTmiss/m_eff > 0.3) {
	if (m_eff_inc > 1200*GeV) {
	_count_1l_3jet_all_channel->fill(0.5,weight);
	if (lepton.abspid() == PID::ELECTRON )
	_count_1l_3jet_e_channel->fill(0.5, weight);
	else
	_count_1l_3jet_mu_channel->fill(0.5, weight);
	}
	_hist_1l_m_eff_3jet->fill(min(1599., m_eff_inc), weight);
	}
	}
	// 4 jet channel
	else if (njet >=4 && recon_jets[3].pT() > 80*GeV) {
	m_eff += recon_jets[3].pT();
	if (eTmiss/m_eff>0.2) {
	if (m_eff_inc > 800*GeV) {
	_count_1l_4jet_all_channel->fill(0.5, weight);
	if(lepton.abspid() == PID::ELECTRON )
	_count_1l_4jet_e_channel->fill(0.5, weight);
	else
	_count_1l_4jet_mu_channel->fill(0.5, weight);
	}
	_hist_1l_m_eff_4jet->fill(min(1599., m_eff_inc), weight);
	}
	}
	}
	}
	// multi lepton
	else if( recon_hard_e.size() + recon_hard_mu.size() >= 2 && njet >=2 ) {
	// get all the leptons and sort them by pT
	Particles leptons(recon_hard_e.begin(),recon_hard_e.end());
	leptons.insert(leptons.begin(),recon_hard_mu.begin(),recon_hard_mu.end());
	std::sort(leptons.begin(), leptons.end(), cmpMomByPt);
	double m_eff(0.0);
	for (size_t ix = 0; ix < leptons.size(); ++ix)
	m_eff += leptons[ix].pT();
	m_eff_inc += m_eff;
	m_eff += eTmiss;
	for (size_t ix = 0; ix < (size_t) min(4, int(recon_jets.size())); ++ix)
	m_eff += recon_jets[ix].pT();
	// require opposite sign leptons
	if (leptons[0].pid()*leptons[1].pid()<0) {
	// 2 jet
	if (recon_jets[1].pT()>200 &&
	( njet<4 \|\| (njet>=4 && recon_jets[3].pT() < 50GeV)) && eTmiss > 300GeV) {
	_count_2l_2jet_all_channel->fill(0.5, weight);
	if (leptons[0].abspid() == PID::ELECTRON && leptons[1].abspid() == PID::ELECTRON )
	_count_2l_2jet_ee_channel->fill(0.5, weight);
	else if (leptons[0].abspid() == PID::MUON && leptons[1].abspid() == PID::MUON )
	_count_2l_2jet_mumu_channel->fill(0.5, weight);
	else
	_count_2l_2jet_emu_channel->fill(0.5, weight);
	_hist_2l_m_eff_2jet->fill(min(1699., m_eff_inc), weight);
	}
	// 4 jet
	else if (njet >= 4 && recon_jets[3].pT() > 50*GeV &&
	eTmiss > 100*GeV && eTmiss/m_eff > 0.2) {
	if ( m_eff_inc > 650*GeV ) {
	_count_2l_4jet_all_channel->fill(0.5, weight);
	if (leptons[0].abspid() == PID::ELECTRON && leptons[1].abspid() == PID::ELECTRON )
	_count_2l_4jet_ee_channel->fill(0.5, weight);
	else if (leptons[0].abspid() == PID::MUON && leptons[1].abspid() == PID::MUON )
	_count_2l_4jet_mumu_channel->fill(0.5, weight);
	else
	_count_2l_4jet_emu_channel->fill(0.5, weight);
	}
	_hist_2l_m_eff_4jet->fill(min(1599., m_eff_inc), weight);
	}
	}
	}
	}
	// soft lepton selection
	if ( recon_soft_e.size() + recon_soft_mu.size() == 1 ) {
	// discard jets that overlap with electrons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	if (jet.abseta() > 2.5 \|\| jet.pT() < 25*GeV) continue;
	bool away_from_e = true;
	foreach ( const Particle & e, cand_soft_e ) {
	if ( deltaR(e.momentum(), jet.momentum()) < 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}
	// meff calculation
	double HT=0.;
	foreach (const Jet & jet, recon_jets) {
	HT += jet.pT();
	}
	double m_eff_inc = HT+eTmiss;
	// get the lepton
	Particle lepton = recon_soft_e.empty() ?
	recon_soft_mu[0] : recon_soft_e[0];
	// lepton variables
	double pT = lepton.pT();
	double mT = 2.(pTeTmiss -
	lepton.px()*pTmiss.px() -
	lepton.py()*pTmiss.py());
	mT = sqrt(mT);
	m_eff_inc += pT;
	double m_eff = pT+eTmiss;
	// apply final cuts
	if (recon_jets.size() >= 2 && recon_jets[0].pT()>130GeV && mT > 100GeV && eTmiss > 250*GeV) {
	for (size_t ix = 0; ix < 2; ++ix)
	m_eff += recon_jets[0].pT();
	if (eTmiss/m_eff > 0.3) {
	_count_1l_soft_all_channel->fill(0.5, weight);
	if (lepton.abspid() == PID::ELECTRON )
	_count_1l_soft_e_channel->fill(0.5, weight);
	else
	_count_1l_soft_mu_channel->fill(0.5, weight);
	}
	_hist_1l_eTmiss_m_eff_soft->fill( eTmiss/m_eff_inc, weight);
	}
	}
	}


	void finalize() {

	double norm = 4.7* crossSection()/sumOfWeights()/femtobarn;
	scale(_count_1l_3jet_all_channel ,norm);
	scale(_count_1l_3jet_e_channel ,norm);
	scale(_count_1l_3jet_mu_channel ,norm);
	scale(_count_1l_4jet_all_channel ,norm);
	scale(_count_1l_4jet_e_channel ,norm);
	scale(_count_1l_4jet_mu_channel ,norm);
	scale(_count_1l_soft_all_channel ,norm);
	scale(_count_1l_soft_e_channel ,norm);
	scale(_count_1l_soft_mu_channel ,norm);
	scale(_count_2l_2jet_all_channel ,norm);
	scale(_count_2l_2jet_ee_channel ,norm);
	scale(_count_2l_2jet_emu_channel ,norm);
	scale(_count_2l_2jet_mumu_channel ,norm);
	scale(_count_2l_4jet_all_channel ,norm);
	scale(_count_2l_4jet_ee_channel ,norm);
	scale(_count_2l_4jet_emu_channel ,norm);
	scale(_count_2l_4jet_mumu_channel ,norm);

	scale(_hist_1l_m_eff_3jet ,200.*norm);
	scale(_hist_1l_m_eff_4jet ,200.*norm);
	scale(_hist_1l_eTmiss_m_eff_soft ,0.1*norm);
	scale(_hist_2l_m_eff_2jet ,200.*norm);
	scale(_hist_2l_m_eff_4jet ,200.*norm);

	}

	private:

	/// @name Histos
	//@{
	Histo1DPtr _count_1l_3jet_all_channel;
	Histo1DPtr _count_1l_3jet_e_channel;
	Histo1DPtr _count_1l_3jet_mu_channel;
	Histo1DPtr _count_1l_4jet_all_channel;
	Histo1DPtr _count_1l_4jet_e_channel;
	Histo1DPtr _count_1l_4jet_mu_channel;
	Histo1DPtr _count_1l_soft_all_channel;
	Histo1DPtr _count_1l_soft_e_channel;
	Histo1DPtr _count_1l_soft_mu_channel;
	Histo1DPtr _count_2l_2jet_all_channel;
	Histo1DPtr _count_2l_2jet_ee_channel;
	Histo1DPtr _count_2l_2jet_emu_channel;
	Histo1DPtr _count_2l_2jet_mumu_channel;
	Histo1DPtr _count_2l_4jet_all_channel;
	Histo1DPtr _count_2l_4jet_ee_channel;
	Histo1DPtr _count_2l_4jet_emu_channel;
	Histo1DPtr _count_2l_4jet_mumu_channel;
	Histo1DPtr _hist_1l_m_eff_3jet;
	Histo1DPtr _hist_1l_m_eff_4jet;
	Histo1DPtr _hist_1l_eTmiss_m_eff_soft;
	Histo1DPtr _hist_2l_m_eff_2jet;
	Histo1DPtr _hist_2l_m_eff_4jet;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1180197);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1183818.cc b/src/Analyses/ATLAS_2012_I1183818.cc
	--- a/src/Analyses/ATLAS_2012_I1183818.cc
	+++ b/src/Analyses/ATLAS_2012_I1183818.cc
	@@ -1,241 +1,241 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"


	/// @author Peter Wijeratne <paw@hep.ucl.ac.uk>
	/// @author Robindra Prabhu <prabhu@cern.ch>
	namespace Rivet {

	// A very basic analysis sensitive to ET flow in minbias and dijet events
	class ATLAS_2012_I1183818 : public Analysis {

	public:

	ATLAS_2012_I1183818()
	: Analysis("ATLAS_2012_I1183818")
	{}


	public:

	void init() {

	const FinalState cnfs(-4.8, 4.8, 0*MeV);
	const ChargedFinalState cfs(-2.5, 2.5, 250*MeV);
	- addProjection(cnfs, "FS");
	- addProjection(cfs, "CFS");
	+ declare(cnfs, "FS");
	+ declare(cfs, "CFS");

	const FastJets jetsAntiKt4(cnfs, FastJets::ANTIKT, 0.4);
	- addProjection(jetsAntiKt4, "AntiKt4Jets");
	+ declare(jetsAntiKt4, "AntiKt4Jets");

	// ------- MINBIAS HISTOGRAMS --------
	//
	// MB event counter
	m_chargedEvents = 0.0;

	_h_ETflowEta = bookHisto1D(1, 1, 1);
	_h_SumETbin1 = bookHisto1D(3, 1, 1);
	_h_SumETbin2 = bookHisto1D(4, 1, 1);
	_h_SumETbin3 = bookHisto1D(5, 1, 1);
	_h_SumETbin4 = bookHisto1D(6, 1, 1);
	_h_SumETbin5 = bookHisto1D(7, 1, 1);
	_h_SumETbin6 = bookHisto1D(8, 1, 1);

	// ------- DIJET HISTOGRAMS --------
	//
	// Dijet event counter
	m_events_dijets = 0.0;

	// sumET
	_h_transETflowEta = bookHisto1D( 2, 1, 1);
	_h_transSumETbin1 = bookHisto1D( 9, 1, 1);
	_h_transSumETbin2 = bookHisto1D(10, 1, 1);
	_h_transSumETbin3 = bookHisto1D(11, 1, 1);
	_h_transSumETbin4 = bookHisto1D(12, 1, 1);
	_h_transSumETbin5 = bookHisto1D(13, 1, 1);
	_h_transSumETbin6 = bookHisto1D(14, 1, 1);


	}


	void analyze(const Event& event) {

	const double weight = event.weight();

	- const FinalState& cfs = applyProjection<FinalState>(event, "CFS");
	+ const FinalState& cfs = apply<FinalState>(event, "CFS");

	bool isCharged = false;
	if (cfs.size() >= 2) { // event selection: > 2 charged particles with pT > 250.MeV and \|eta\| < 2.5
	isCharged = true;
	m_chargedEvents += weight;
	}

	- const FinalState& cnfs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& cnfs = apply<FinalState>(event, "FS");

	Particles particles;
	foreach( const Particle& p, cnfs.particles() ) {
	// enforce truth selection representing detected particle sensitivity
	double pp = p.p3().mod();
	if (PID::threeCharge(p.pid()) != 0 && pp < 0.5*GeV) continue;
	if (PID::threeCharge(p.pid()) == 0 && pp < 0.2*GeV) continue;

	particles.push_back(p);
	}


	// get jets
	- const FastJets& jetsAntiKt4 = applyProjection<FastJets>(event, "AntiKt4Jets");
	+ const FastJets& jetsAntiKt4 = apply<FastJets>(event, "AntiKt4Jets");
	const Jets& jets = jetsAntiKt4.jetsByPt(20.0*GeV);

	// initialise sumET variables
	double sumETbin1 = 0;
	double sumETbin2 = 0;
	double sumETbin3 = 0;
	double sumETbin4 = 0;
	double sumETbin5 = 0;
	double sumETbin6 = 0;

	// if (passes event selection)
	if (isCharged) {

	foreach( const Particle& p, particles ) {

	///calculate variables
	double ET = p.Et()/GeV;
	double eta = p.abseta();

	// fill histograms
	_h_ETflowEta->fill(eta, weight*ET);

	if (eta < 0.8) sumETbin1 += ET;
	else if (eta < 1.6) sumETbin2 += ET;
	else if (eta < 2.4) sumETbin3 += ET;
	else if (eta < 3.2) sumETbin4 += ET;
	else if (eta < 4.0) sumETbin5 += ET;
	else if (eta <= 4.8) sumETbin6 += ET;

	} // end of foreach

	_h_SumETbin1->fill(sumETbin1, weight);
	_h_SumETbin2->fill(sumETbin2, weight);
	_h_SumETbin3->fill(sumETbin3, weight);
	_h_SumETbin4->fill(sumETbin4, weight);
	_h_SumETbin5->fill(sumETbin5, weight);
	_h_SumETbin6->fill(sumETbin6, weight);
	}

	// --- do dijet analysis ---

	if ( jets.size() >= 2 && // require at least two jets
	jets[0].Et() >= 20.*GeV && // require two leading jets to pass ET cuts
	jets[1].Et() >= 20.*GeV &&
	fabs(jets[0].eta()) < 2.5 && // require leading jets to be central
	fabs(jets[1].eta()) < 2.5 &&
	deltaPhi(jets[0], jets[1]) > 2.5 && // require back-to-back topology
	jets[1].Et()/jets[0].Et() >= 0.5) { //require ET-balance

	// found an event that satisfies dijet selection, now fill histograms...
	// initialise dijet sumET variables
	double trans_sumET_bin1 = 0.;
	double trans_sumET_bin2 = 0.;
	double trans_sumET_bin3 = 0.;
	double trans_sumET_bin4 = 0.;
	double trans_sumET_bin5 = 0.;
	double trans_sumET_bin6 = 0.;

	m_events_dijets += weight;

	// loop over all particles and check their relation to leading jet
	foreach( const Particle& particle, particles ) {

	// calculate variables
	double dPhi = deltaPhi( jets[0], particle.momentum() );
	double ET = particle.Et()/GeV;
	double eta = fabs(particle.eta());

	// Transverse region
	if ( dPhi > 1./3.M_PI && dPhi < 2./3.M_PI ) {
	_h_transETflowEta->fill( eta, weight*ET );
	if (eta < 0.8) { trans_sumET_bin1 += ET; }
	else if (eta < 1.6) { trans_sumET_bin2 += ET; }
	else if (eta < 2.4) { trans_sumET_bin3 += ET; }
	else if (eta < 3.2) { trans_sumET_bin4 += ET; }
	else if (eta < 4.0) { trans_sumET_bin5 += ET; }
	else if (eta <= 4.8) { trans_sumET_bin6 += ET; }
	}

	} // end loop over particles

	_h_transSumETbin1->fill( trans_sumET_bin1, weight);
	_h_transSumETbin2->fill( trans_sumET_bin2, weight);
	_h_transSumETbin3->fill( trans_sumET_bin3, weight);
	_h_transSumETbin4->fill( trans_sumET_bin4, weight);
	_h_transSumETbin5->fill( trans_sumET_bin5, weight);
	_h_transSumETbin6->fill( trans_sumET_bin6, weight);
	} // end of dijet selection cuts

	}


	void finalize() {
	/// several scale factors here:
	/// 1. nEvents (m_chargedEvents)
	/// 2. phase-space (2*M_PI)
	/// 3. double binning due to symmetrisation (2)
	scale( _h_ETflowEta, 1./m_chargedEvents/(4.*M_PI) );
	scale( _h_SumETbin1, 1./m_chargedEvents );
	scale( _h_SumETbin2, 1./m_chargedEvents );
	scale( _h_SumETbin3, 1./m_chargedEvents );
	scale( _h_SumETbin4, 1./m_chargedEvents );
	scale( _h_SumETbin5, 1./m_chargedEvents );
	scale( _h_SumETbin6, 1./m_chargedEvents );

	//Dijet analysis

	// Dijet scale factors:
	//1. number of events passing dijet selection
	//2. phase-space: 1. / 2/3*M_PI
	//3. double binning due to symmetrisation in \|eta\| plots : 1/2
	scale( _h_transETflowEta, 1./m_events_dijets * 1./(4./3.*M_PI) );
	scale( _h_transSumETbin1, 1./m_events_dijets );
	scale( _h_transSumETbin2, 1./m_events_dijets );
	scale( _h_transSumETbin3, 1./m_events_dijets );
	scale( _h_transSumETbin4, 1./m_events_dijets );
	scale( _h_transSumETbin5, 1./m_events_dijets );
	scale( _h_transSumETbin6, 1./m_events_dijets );
	}

	private:

	// Event counts
	double m_chargedEvents;
	double m_events_dijets;

	// Minbias-analysis: variable + histograms
	Histo1DPtr _h_ETflowEta;
	Histo1DPtr _h_SumETbin1;
	Histo1DPtr _h_SumETbin2;
	Histo1DPtr _h_SumETbin3;
	Histo1DPtr _h_SumETbin4;
	Histo1DPtr _h_SumETbin5;
	Histo1DPtr _h_SumETbin6;

	// Transverse region
	Histo1DPtr _h_transETflowEta;
	Histo1DPtr _h_transSumETbin1;
	Histo1DPtr _h_transSumETbin2;
	Histo1DPtr _h_transSumETbin3;
	Histo1DPtr _h_transSumETbin4;
	Histo1DPtr _h_transSumETbin5;
	Histo1DPtr _h_transSumETbin6;

	};


	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1183818);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1186556.cc b/src/Analyses/ATLAS_2012_I1186556.cc
	--- a/src/Analyses/ATLAS_2012_I1186556.cc
	+++ b/src/Analyses/ATLAS_2012_I1186556.cc
	@@ -1,233 +1,233 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	class ATLAS_2012_I1186556 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1186556()
	: Analysis("ATLAS_2012_I1186556")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialize projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3.0 && Cuts::pT > 1*GeV), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3.0 && Cuts::pT > 1*GeV), "cfs");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");

	// Book histograms
	_count_SR_SF = bookHisto1D("count_SR_SF" , 1, 0., 1.);
	_count_SR_OF = bookHisto1D("count_SR_OF" , 1, 0., 1.);

	_hist_mT2_SF_exp = bookHisto1D("hist_mT2_SF_exp", 40 , 0., 200. );
	_hist_mT2_OF_exp = bookHisto1D("hist_mT2_OF_exp", 40 , 0., 200. );
	_hist_mT2_SF_MC = bookHisto1D("hist_mT2_SF_MC" , 500, 0., 1000.);
	_hist_mT2_OF_MC = bookHisto1D("hist_mT2_OF_MC" , 500, 0., 1000.);

	}

	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// get the candiate jets
	Jets cand_jets;
	foreach ( const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 4.5 ) {
	cand_jets.push_back(jet);
	}
	}
	// charged tracks for isolation
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	// find the electrons
	Particles cand_e;
	foreach( const Particle & e,
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	// remove any leptons within 0.4 of any candidate jets
	bool e_near_jet = false;
	foreach ( const Jet& jet, cand_jets ) {
	double dR = deltaR(e.momentum(),jet.momentum());
	if ( dR < 0.4 && dR > 0.2 ) {
	e_near_jet = true;
	break;
	}
	}
	if ( e_near_jet ) continue;
	cand_e.push_back(e);
	}
	Particles cand_mu;
	foreach( const Particle & mu,
	- applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	+ apply<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	// remove any leptons within 0.4 of any candidate jets
	bool mu_near_jet = false;
	foreach ( const Jet& jet, cand_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	mu_near_jet = true;
	break;
	}
	}
	if ( mu_near_jet ) continue;
	cand_mu.push_back(mu);
	}
	// pTcone around muon track
	Particles recon_mu;
	foreach ( const Particle & mu, cand_mu ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV ) recon_mu.push_back(mu);
	}
	// pTcone around electron track
	Particles recon_e;
	foreach ( const Particle & e, cand_e ) {
	double pTinCone = -e.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 0.1 * e.pT() ) recon_e.push_back(e);
	}

	// pTmiss
	FourMomentum pTmiss;
	foreach ( const Particle & p,
	- applyProjection<VisibleFinalState>(event, "vfs").particles() ) {
	+ apply<VisibleFinalState>(event, "vfs").particles() ) {
	pTmiss -= p.momentum();
	}

	// discard jets that overlap with electrons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	if(jet.abseta()>2.5\|\|
	jet.perp()<20.) continue;
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}

	// put leptons into 1 vector and order by pT
	Particles leptons(recon_e.begin(),recon_e.end());
	leptons.insert(leptons.begin(),recon_mu.begin(),recon_mu.end());
	sort(leptons.begin(),leptons.end(),cmpMomByPt);

	// exactly two leptons
	if(leptons.size() !=2) vetoEvent;

	// hardest lepton pT greater the 25 (20) e(mu)
	if( (leptons[0].abspid()==PID::ELECTRON && leptons[0].perp()<25.) \|\|
	(leptons[0].abspid()==PID::ELECTRON && leptons[0].perp()<20.))
	vetoEvent;

	// require opposite sign
	if(leptons[0].pid()*leptons[1].pid()>0) vetoEvent;

	// and invariant mass > 20
	double mll = (leptons[0].momentum()+leptons[1].momentum()).mass();
	if(mll<20.) vetoEvent;

	// two jets 1st pT > 50 and second pT> 25
	if(recon_jets.size()<2 \|\| recon_jets[0].perp()<50. \|\|
	recon_jets[1].perp()<25.) vetoEvent;

	// calculate mT2
	double m_T2 = mT2::mT2( leptons[0].momentum(),leptons[1].momentum(),
	pTmiss,0.0 ); // zero mass invisibles

	// same flavour region
	if(leptons[0].pid()==-leptons[1].pid()) {
	// remove Z region
	if(mll>71.&&mll<111.) vetoEvent;
	// require at least 1 b jet
	unsigned int n_b=0;
	for(unsigned int ix=0;ix<recon_jets.size();++ix) {
	if(recon_jets[ix].bTagged() && rand()/static_cast<double>(RAND_MAX)<=0.60)
	++n_b;
	}
	if(n_b==0) vetoEvent;
	_hist_mT2_SF_exp->fill(m_T2,weight);
	_hist_mT2_SF_MC ->fill(m_T2,weight);
	if(m_T2>120.) _count_SR_SF->fill(0.5,weight);
	}
	// opposite flavour region
	else {
	_hist_mT2_OF_exp->fill(m_T2,weight);
	_hist_mT2_OF_MC ->fill(m_T2,weight);
	if(m_T2>120.) _count_SR_OF->fill(0.5,weight);
	}
	}
	//@}


	void finalize() {

	double norm = 4.7* crossSection()/sumOfWeights()/femtobarn;
	scale(_count_SR_SF , norm);
	scale(_count_SR_OF , norm);
	scale(_hist_mT2_SF_exp,5.*norm);
	scale(_hist_mT2_OF_exp,5.*norm);
	scale(_hist_mT2_SF_MC , norm/4.7);
	scale(_hist_mT2_OF_MC , norm/4.7);

	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_SR_SF;
	Histo1DPtr _count_SR_OF;

	Histo1DPtr _hist_mT2_SF_exp;
	Histo1DPtr _hist_mT2_OF_exp;
	Histo1DPtr _hist_mT2_SF_MC;
	Histo1DPtr _hist_mT2_OF_MC;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1186556);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1188891.cc b/src/Analyses/ATLAS_2012_I1188891.cc
	--- a/src/Analyses/ATLAS_2012_I1188891.cc
	+++ b/src/Analyses/ATLAS_2012_I1188891.cc
	@@ -1,146 +1,146 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Particle.hh"

	namespace Rivet {


	class ATLAS_2012_I1188891 : public Analysis {
	public:


	ATLAS_2012_I1188891()
	: Analysis("ATLAS_2012_I1188891")
	{ }


	void init() {

	const FinalState fs;
	FastJets fj04(fs, FastJets::ANTIKT, 0.4);
	- addProjection(fj04, "AntiKT04");
	+ declare(fj04, "AntiKT04");

	string histotitle[7]={"BBfraction","BCfraction","CCfraction","BUfraction","CUfraction","UUfraction","Total"};
	for (int i = 0 ; i < 7 ; i++){
	_h_temp[i] = bookHisto1D("TMP/"+histotitle[i],refData(1,1,1));
	if (i < 6) {
	_h_results[i] = bookScatter2D(i+1, 1, 1);
	}
	}
	}


	void analyze(const Event& event) {

	double weight = event.weight();
	double weight100 = event.weight() * 100.; //to get results in %

	//keeps jets with pt>20 geV and ordered in decreasing pt
	- Jets jetAr = applyProjection<FastJets>(event, "AntiKT04").jetsByPt(20*GeV);
	+ Jets jetAr = apply<FastJets>(event, "AntiKT04").jetsByPt(20*GeV);

	int flav[2]={1,1};
	vector<FourMomentum> leadjets;

	//get b/c-hadrons
	vector<GenParticle const *> B_hadrons, C_hadrons;
	vector<GenParticle const *> allParticles = particles(event.genEvent());
	for (size_t i = 0; i < allParticles.size(); i++) {
	const GenParticle* p = allParticles.at(i);
	if(p->momentum().perp()*GeV < 5) continue;
	if ( (Rivet::PID::isHadron ( p->pdg_id() ) &&
	Rivet::PID::hasBottom( p->pdg_id() ) ) ) {
	B_hadrons.push_back(p);
	}
	if ( (Rivet::PID::isHadron( p->pdg_id() ) &&
	Rivet::PID::hasCharm( p->pdg_id() ) ) ) {
	C_hadrons.push_back(p);
	}
	}

	//select dijet
	foreach (const Jet& jet, jetAr) {

	const double pT = jet.pT();
	const double absy = jet.absrap();

	bool isBjet = jet.bTagged();
	bool isCjet = jet.cTagged();

	int jetflav=1;
	if (isBjet)jetflav=5;
	else if (isCjet)jetflav=4;

	if (absy <= 2.1 && leadjets.size() < 2) {

	if (pT > 500*GeV) continue;
	if ((leadjets.empty() && pT < 40GeV) \|\| pT < 20GeV) continue;

	leadjets.push_back(jet.momentum());

	if (leadjets.size()==1) flav[0] = jetflav;
	if (leadjets.size()==2) flav[1] = jetflav;
	}
	}

	if (leadjets.size() < 2) vetoEvent;


	double pBinsLJ[7] = {40.,60.,80.,120.,160.,250.,500.};
	int iPBinLJ = -1;

	for (int k = 0 ; k < 7 ; k++) {
	if (leadjets[0].pT() > pBinsLJ[k]*GeV) iPBinLJ=k;
	else break;
	}

	bool c_ljpt = (iPBinLJ != -1);
	bool c_nljpt = leadjets[1].pT() > 20*GeV;
	bool c_dphi = fabs( deltaPhi(leadjets[0],leadjets[1]) ) > 2.1;
	bool isDijet = c_ljpt & c_nljpt & c_dphi;
	if (!isDijet) vetoEvent;

	_h_temp[6]->fill(leadjets[0].pT(), weight);

	if (flav[0]==5 && flav[1]==5) // BB dijet
	_h_temp[0]->fill(leadjets[0].pT(), weight100);

	if ((flav[0]==5 && flav[1]==4) \|\| (flav[0]==4 && flav[1]==5)) // BC dijet
	_h_temp[1]->fill(leadjets[0].pT(), weight100);

	if (flav[0]==4 && flav[1]==4) // CC dijet
	_h_temp[2]->fill(leadjets[0].pT(), weight100);

	if ((flav[0]==5 && flav[1]==1) \|\| (flav[0]==1 && flav[1]==5)) // B-light dijet
	_h_temp[3]->fill(leadjets[0].pT(), weight100);

	if ((flav[0]==4 && flav[1]==1) \|\| (flav[0]==1 && flav[1]==4)) // C-light dijet
	_h_temp[4]->fill(leadjets[0].pT(), weight100);

	if (flav[0]==1 && flav[1]==1) // light-light dijet
	_h_temp[5]->fill(leadjets[0].pT(), weight100);
	}


	void finalize() {
	divide(_h_temp[0], _h_temp[6], _h_results[0]);
	divide(_h_temp[1], _h_temp[6], _h_results[1]);
	divide(_h_temp[2], _h_temp[6], _h_results[2]);
	divide(_h_temp[3], _h_temp[6], _h_results[3]);
	divide(_h_temp[4], _h_temp[6], _h_results[4]);
	divide(_h_temp[5], _h_temp[6], _h_results[5]);
	}

	private:

	Histo1DPtr _h_temp[7];
	Scatter2DPtr _h_results[6];
	};


	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1188891);


	}
	diff --git a/src/Analyses/ATLAS_2012_I1190891.cc b/src/Analyses/ATLAS_2012_I1190891.cc
	--- a/src/Analyses/ATLAS_2012_I1190891.cc
	+++ b/src/Analyses/ATLAS_2012_I1190891.cc
	@@ -1,301 +1,301 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/RivetMT2.hh"

	namespace Rivet {


	/// @author Peter Richardson
	class ATLAS_2012_I1190891 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1190891()
	: Analysis("ATLAS_2012_I1190891")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 10*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");

	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);

	/// Jet finder
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(-3.0,3.0),"cfs");
	+ declare(ChargedFinalState(-3.0,3.0),"cfs");

	// Book histograms
	_hist_etmiss = bookHisto1D("hist_etmiss",10,0.,500.);
	_hist_meff = bookHisto1D("hist_m_eff",7,0.,1050.);
	_count_SR1 = bookHisto1D("count_SR1", 1, 0., 1.);
	_count_SR2 = bookHisto1D("count_SR2", 1, 0., 1.);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	// get the jet candidates
	Jets cand_jets;
	foreach (const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.5 ) {
	cand_jets.push_back(jet);
	}
	}

	// candidate muons
	Particles cand_mu;
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();
	foreach ( const Particle & mu,
	- applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	+ apply<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	double pTinCone = -mu.pT();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	cand_mu.push_back(mu);
	}

	// candidate electrons
	Particles cand_e;
	foreach ( const Particle & e,
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt() ) {
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt() ) {
	double pTinCone = -e.perp();
	foreach ( const Particle & track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) <= 0.2 )
	pTinCone += track.pT();
	}
	if (pTinCone/e.perp()<0.1) {
	cand_e.push_back(e);
	}
	}

	// resolve jet/lepton ambiguity
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_e = true;
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e )
	recon_jets.push_back( jet );
	}

	// only keep electrons more than R=0.4 from jets
	Particles cand2_e;
	for(unsigned int ie=0;ie<cand_e.size();++ie) {
	const Particle & e = cand_e[ie];
	// at least 0.4 from any jets
	bool away = true;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	// and 0.1 from any muons
	if ( away ) {
	foreach ( const Particle & mu, cand_mu ) {
	if ( deltaR(mu.momentum(),e.momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	}
	// and 0.1 from electrons ( keep higher energy)
	for(unsigned int ie2=0;ie2<cand_e.size();++ie2) {
	if(ie==ie2) continue;
	if ( deltaR(e.momentum(),cand_e[ie2].momentum()) < 0.1 &&
	e.E() < cand_e[ie2].E() ) {
	away = false;
	break;
	}
	}
	// if isolated keep it
	if ( away )
	cand2_e.push_back( e );
	}

	// remove e+e- pairs with mass < 20.
	Particles recon_e;
	for(unsigned int ie=0;ie<cand2_e.size();++ie) {
	bool pass = true;
	for(unsigned int ie2=0;ie2<cand2_e.size();++ie2) {
	if(cand2_e[ie].pid()*cand2_e[ie2].pid()>0) continue;
	double mtest = (cand2_e[ie].momentum()+cand2_e[ie2].momentum()).mass();
	if(mtest<=20.) {
	pass = false;
	break;
	}
	}
	if(pass) recon_e.push_back(cand2_e[ie]);
	}

	// only keep muons more than R=0.4 from jets
	Particles cand2_mu;
	for(unsigned int imu=0;imu<cand_mu.size();++imu) {
	const Particle & mu = cand_mu[imu];
	bool away = true;
	// at least 0.4 from any jets
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	// and 0.1 from any electrona
	if ( away ) {
	foreach ( const Particle & e, cand_e ) {
	if ( deltaR(mu.momentum(),e.momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	}
	if ( away )
	cand2_mu.push_back( mu );
	}

	// remove mu+mu- pairs with mass < 20.
	Particles recon_mu;
	for(unsigned int imu=0;imu<cand2_mu.size();++imu) {
	bool pass = true;
	for(unsigned int imu2=0;imu2<cand2_mu.size();++imu2) {
	if(cand2_mu[imu].pid()*cand2_mu[imu2].pid()>0) continue;
	double mtest = (cand2_mu[imu].momentum()+cand2_mu[imu2].momentum()).mass();
	if(mtest<=20.) {
	pass = false;
	break;
	}
	}
	if(pass) recon_mu.push_back(cand2_mu[imu]);
	}

	// pTmiss
	Particles vfs_particles =
	- applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// now only use recon_jets, recon_mu, recon_e

	// reject events with less than 4 electrons and muons
	if ( recon_mu.size() + recon_e.size() < 4 ) {
	MSG_DEBUG("To few charged leptons left after selection");
	vetoEvent;
	}

	// check if passes single lepton trigger
	bool passSingle =
	( !recon_e .empty() && recon_e[0] .perp()>25. )\|\|
	( !recon_mu.empty() && recon_mu[0].perp()>20.);

	// or two lepton trigger
	bool passDouble =
	( recon_mu.size()>=2 && recon_mu[1].perp()>12.) \|\|
	( recon_e .size()>=2 && recon_e [1].perp()>17.) \|\|
	( !recon_e.empty() && !recon_mu.empty() &&
	recon_e[0].perp()>15. && recon_mu[0].perp()>10.);

	// must pass a trigger
	if( !passSingle && !passDouble ) {
	MSG_DEBUG("Hardest lepton fails trigger");
	vetoEvent;
	}

	// calculate meff
	double meff = eTmiss;
	foreach ( const Particle & e , recon_e )
	meff += e.perp();
	foreach ( const Particle & mu, recon_mu )
	meff += mu.perp();
	foreach ( const Jet & jet, recon_jets ) {
	double pT = jet.perp();
	if(pT>40.) meff += pT;
	}

	// mass of SFOS pairs closest to the Z mass
	for(unsigned int ix=0;ix<recon_e.size();++ix) {
	for(unsigned int iy=ix+1;iy<recon_e.size();++iy) {
	if(recon_e[ix].pid()*recon_e[iy].pid()>0) continue;
	double mtest = (recon_e[ix].momentum()+recon_e[iy].momentum()).mass();
	if(mtest>81.2 && mtest<101.2) vetoEvent;
	}
	}
	for(unsigned int ix=0;ix<recon_mu.size();++ix) {
	for(unsigned int iy=ix+1;iy<recon_mu.size();++iy) {
	if(recon_mu[ix].pid()*recon_mu[iy].pid()>0) continue;
	double mtest = (recon_mu[ix].momentum()+recon_mu[iy].momentum()).mass();
	if(mtest>81.2 && mtest<101.2) vetoEvent;
	}
	}

	// make the control plots
	_hist_etmiss ->fill(eTmiss,weight);
	_hist_meff ->fill(meff ,weight);
	// finally the counts
	if(eTmiss>50.) _count_SR1->fill(0.5,weight);
	if(meff >300.) _count_SR2->fill(0.5,weight);
	}

	//@}

	void finalize() {
	double norm = crossSection()/femtobarn*4.7/sumOfWeights();
	scale(_hist_etmiss,norm* 50.);
	scale(_hist_meff ,norm*150.);
	scale(_count_SR1,norm);
	scale(_count_SR2,norm);
	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _hist_etmiss;
	Histo1DPtr _hist_meff;
	Histo1DPtr _count_SR1;
	Histo1DPtr _count_SR2;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1190891);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1199269.cc b/src/Analyses/ATLAS_2012_I1199269.cc
	--- a/src/Analyses/ATLAS_2012_I1199269.cc
	+++ b/src/Analyses/ATLAS_2012_I1199269.cc
	@@ -1,158 +1,142 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief Measurement of isolated diphoton + X differential cross-sections
	///
	/// Inclusive isolated gamma gamma cross-sections, differential in M(gg), pT(gg),
	/// dphi(gg), cos(theta*)_CS
	///
	/// @author Giovanni Marchiori
	///
	class ATLAS_2012_I1199269 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1199269()
	- : Analysis("ATLAS_2012_I1199269"),
	- _eta_bins_areaoffset{ 0.0, 1.5, 3.0 }
	+ : Analysis("ATLAS_2012_I1199269")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	FastJets fj(fs, FastJets::KT, 0.5);
	fj.useJetArea(new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec()));
	- addProjection(fj, "KtJetsD05");
	+ declare(fj, "KtJetsD05");

	IdentifiedFinalState photonfs(Cuts::abseta < 2.37 && Cuts::pT > 22*GeV);
	photonfs.acceptId(PID::PHOTON);
	- addProjection(photonfs, "Photon");
	+ declare(photonfs, "Photon");

	_h_M = bookHisto1D(1, 1, 1);
	_h_pT = bookHisto1D(2, 1, 1);
	_h_dPhi = bookHisto1D(3, 1, 1);
	_h_cosThetaStar = bookHisto1D(4, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Require at least 2 photons in final state
	- const Particles photons = applyProjection<IdentifiedFinalState>(event, "Photon").particlesByPt();
	+ const Particles photons = apply<IdentifiedFinalState>(event, "Photon").particlesByPt();
	if (photons.size() < 2) vetoEvent;

	// Get jets, and corresponding jet areas
	vector<vector<double> > ptDensities(_eta_bins_areaoffset.size()-1);
	- const auto clust_seq_area = applyProjection<FastJets>(event, "KtJetsD05").clusterSeqArea();
	- for (const Jet& jet : applyProjection<FastJets>(event, "KtJetsD05").jets()) {
	+ const auto clust_seq_area = apply<FastJets>(event, "KtJetsD05").clusterSeqArea();
	+ for (const Jet& jet : apply<FastJets>(event, "KtJetsD05").jets()) {
	const double area = clust_seq_area->area(jet); // implicit .pseudojet()
	if (area < 1e-3) continue;
	const int ieta = binIndex(jet.abseta(), _eta_bins_areaoffset);
	if (ieta != -1) ptDensities[ieta].push_back(jet.pT()/area);
	}

	// Compute median jet properties over the jets in the event
	vector<double> vptDensity; //, vsigma, vNjets;
	for (size_t b = 0; b < _eta_bins_areaoffset.size()-1; ++b) {
	- double median = 0.0;
	- // , sigma = 0.0;
	- // int Njets = 0;
	- if (ptDensities[b].size() > 0) {
	- std::sort(ptDensities[b].begin(), ptDensities[b].end());
	- int nDens = ptDensities[b].size();
	- median = (nDens % 2 == 0) ? (ptDensities[b][nDens/2]+ptDensities[b][(nDens-2)/2])/2 : ptDensities[b][(nDens-1)/2];
	- // sigma = ptDensities[b][(int)(.15865*nDens)];
	- // Njets = nDens;
	- }
	- vptDensity.push_back(median);
	- // vsigma.push_back(sigma);
	- // vNjets.push_back(Njets);
	+ vptDensity += ptDensities[b].empty() ? 0 : median(ptDensities[b]);
	}


	// Loop over photons and fill vector of isolated ones
	Particles isolated_photons;
	for (const Particle& photon : photons) {
	/// Remove photons in ECAL crack region
	if (inRange(photon.abseta(), 1.37, 1.52)) continue;
	- const double eta_P = photon.eta();
	- const double phi_P = photon.phi();
	-
	// Compute isolation via particles within an R=0.4 cone of the photon
	- Particles fs = applyProjection<FinalState>(event, "FS").particles();
	+ const Particles& fs = apply<FinalState>(event, "FS").particles();
	FourMomentum mom_in_EtCone;
	for (const Particle& p : fs) {
	// Reject if not in cone
	- if (deltaR(photon.momentum(), p.momentum()) > 0.4) continue;
	+ if (deltaR(photon, p) > 0.4) continue;
	// Reject if in the 5x7 cell central core
	- if (fabs(eta_P - p.eta()) < 0.025 * 5 * 0.5 &&
	- fabs(phi_P - p.phi()) < PI/128. * 7 * 0.5) continue;
	+ if (fabs(deltaEta(photon, p)) < 0.025 * 5 * 0.5 &&
	+ fabs(deltaPhi(photon, p)) < PI/128. * 7 * 0.5) continue;
	// Sum momentum
	mom_in_EtCone += p.momentum();
	}
	// Now figure out the correction (area*density)
	- const double EtCone_area = PIsqr(0.4) - (7.025)(5PI/128.); // cone area - central core rectangle
	- const double correction = vptDensity[binIndex(fabs(eta_P), _eta_bins_areaoffset)] * EtCone_area;
	+ const double ETCONE_AREA = PIsqr(0.4) - (7.025)(5PI/128.); // cone area - central core rectangle
	+ const double correction = vptDensity[binIndex(photon.abseta(), _eta_bins_areaoffset)] * ETCONE_AREA;

	// Discard the photon if there is more than 4 GeV of cone activity
	// NOTE: Shouldn't need to subtract photon itself (it's in the central core)
	// NOTE: using expected cut at hadron/particle level, not at reco level
	if (mom_in_EtCone.Et() - correction > 4*GeV) continue;
	// Add isolated photon to list
	isolated_photons.push_back(photon);
	}

	// Require at least two isolated photons and select leading pT pair
	if (isolated_photons.size() < 2) vetoEvent;
	sortByPt(isolated_photons);
	- FourMomentum y1 = isolated_photons[0].momentum();
	- FourMomentum y2 = isolated_photons[1].momentum();
	+ const FourMomentum& y1 = isolated_photons[0].momentum();
	+ const FourMomentum& y2 = isolated_photons[1].momentum();

	// Leading photon should have pT > 25 GeV
	if (y1.pT() < 25*GeV) vetoEvent;

	// Require the two photons to be separated by dR > 0.4
	if (deltaR(y1, y2) < 0.4) vetoEvent;

	// Compute diphoton vector and fill histos
	const double weight = event.weight();
	FourMomentum yy = y1 + y2;
	const double costhetayy = 2 * y1.pT() * y2.pT() * sinh(y1.eta() - y2.eta()) / yy.mass() / add_quad(yy.mass(), yy.pT());
	_h_M->fill(yy.mass()/GeV, weight);
	_h_pT->fill(yy.pT()/GeV, weight);
	_h_dPhi->fill(mapAngle0ToPi(y1.phi() - y2.phi()), weight);
	_h_cosThetaStar->fill(costhetayy, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_M, crossSection()/sumOfWeights());
	scale(_h_pT, crossSection()/sumOfWeights());
	scale(_h_dPhi, crossSection()/sumOfWeights());
	scale(_h_cosThetaStar, crossSection()/sumOfWeights());
	}


	private:

	Histo1DPtr _h_M, _h_pT, _h_dPhi, _h_cosThetaStar;

	- vector<double> _eta_bins, _eta_bins_areaoffset;
	+ const vector<double> _eta_bins_areaoffset = {0.0, 1.5, 3.0};

	};


	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1199269);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1203852.cc b/src/Analyses/ATLAS_2012_I1203852.cc
	--- a/src/Analyses/ATLAS_2012_I1203852.cc
	+++ b/src/Analyses/ATLAS_2012_I1203852.cc
	@@ -1,378 +1,378 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/MergedFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/InvMassFinalState.hh"

	#define ZMASS 91.1876 // GeV

	namespace Rivet {


	/// Generic Z candidate
	struct Zstate : public ParticlePair {
	Zstate() { }
	Zstate(ParticlePair _particlepair) : ParticlePair(_particlepair) { }
	FourMomentum mom() const { return first.momentum() + second.momentum(); }
	operator FourMomentum() const { return mom(); }
	static bool cmppT(const Zstate& lx, const Zstate& rx) { return lx.mom().pT() < rx.mom().pT(); }
	};


	/// 4l to ZZ assignment -- algorithm
	void identifyZstates(Zstate& Z1, Zstate& Z2, const Particles& leptons_sel4l) {

	/////////////////////////////////////////////////////////////////////////////
	/// ZZ->4l pairing
	/// - Exactly two same flavour opposite charged leptons
	/// - Ambiguities in pairing are resolved by choosing the combination
	/// that results in the smaller value of the sum \|mll - mZ\| for the two pairs
	/////////////////////////////////////////////////////////////////////////////

	Particles part_pos_el, part_neg_el, part_pos_mu, part_neg_mu;
	foreach (const Particle& l , leptons_sel4l) {
	if (l.abspid() == PID::ELECTRON) {
	if (l.pid() < 0) part_neg_el.push_back(l);
	if (l.pid() > 0) part_pos_el.push_back(l);
	}
	else if (l.abspid() == PID::MUON) {
	if (l.pid() < 0) part_neg_mu.push_back(l);
	if (l.pid() > 0) part_pos_mu.push_back(l);
	}
	}

	// ee/mm channel
	if ( part_neg_el.size() == 2 \|\| part_neg_mu.size() == 2) {

	Zstate Zcand_1, Zcand_2, Zcand_3, Zcand_4;
	if (part_neg_el.size() == 2) { // ee
	Zcand_1 = Zstate( ParticlePair( part_neg_el[0], part_pos_el[0] ) );
	Zcand_2 = Zstate( ParticlePair( part_neg_el[0], part_pos_el[1] ) );
	Zcand_3 = Zstate( ParticlePair( part_neg_el[1], part_pos_el[0] ) );
	Zcand_4 = Zstate( ParticlePair( part_neg_el[1], part_pos_el[1] ) );
	} else { // mumu
	Zcand_1 = Zstate( ParticlePair( part_neg_mu[0], part_pos_mu[0] ) );
	Zcand_2 = Zstate( ParticlePair( part_neg_mu[0], part_pos_mu[1] ) );
	Zcand_3 = Zstate( ParticlePair( part_neg_mu[1], part_pos_mu[0] ) );
	Zcand_4 = Zstate( ParticlePair( part_neg_mu[1], part_pos_mu[1] ) );
	}

	// We can have the following pairs: (Z1 + Z4) \|\| (Z2 + Z3)
	double minValue_1, minValue_2;
	minValue_1 = fabs( Zcand_1.mom().mass() - ZMASS ) + fabs( Zcand_4.mom().mass() - ZMASS);
	minValue_2 = fabs( Zcand_2.mom().mass() - ZMASS ) + fabs( Zcand_3.mom().mass() - ZMASS);
	if (minValue_1 < minValue_2 ) {
	Z1 = Zcand_1;
	Z2 = Zcand_4;
	} else {
	Z1 = Zcand_2;
	Z2 = Zcand_3;
	}

	// emu channel
	} else if (part_neg_mu.size() == 1 && part_neg_el.size() == 1) {
	Z1 = Zstate ( ParticlePair (part_neg_mu[0], part_pos_mu[0] ) );
	Z2 = Zstate ( ParticlePair (part_neg_el[0], part_pos_el[0] ) );
	}

	}


	/// @name ZZ analysis
	class ATLAS_2012_I1203852 : public Analysis {
	public:

	/// Default constructor
	ATLAS_2012_I1203852()
	: Analysis("ATLAS_2012_I1203852")
	{ }

	void init() {
	FinalState fs(-5.0, 5.0, 0.0*GeV);

	// Final states to form Z bosons
	vids.push_back(make_pair(PID::ELECTRON, PID::POSITRON));
	vids.push_back(make_pair(PID::MUON, PID::ANTIMUON));

	vnuids.push_back(make_pair(PID::NU_E, PID::NU_EBAR) );
	vnuids.push_back(make_pair(PID::NU_MU, PID::NU_MUBAR) );
	vnuids.push_back(make_pair(PID::NU_TAU, PID::NU_TAUBAR) );

	IdentifiedFinalState Photon(fs);
	Photon.acceptIdPair(PID::PHOTON);

	IdentifiedFinalState bare_EL(fs);
	bare_EL.acceptIdPair(PID::ELECTRON);

	IdentifiedFinalState bare_MU(fs);
	bare_MU.acceptIdPair(PID::MUON);


	// Selection 1: ZZ-> llll selection
	Cut etaranges_lep = Cuts::abseta < 3.16 && Cuts::pT > 7*GeV;

	DressedLeptons electron_sel4l(Photon, bare_EL, 0.1, etaranges_lep);
	- addProjection(electron_sel4l, "ELECTRON_sel4l");
	+ declare(electron_sel4l, "ELECTRON_sel4l");
	DressedLeptons muon_sel4l(Photon, bare_MU, 0.1, etaranges_lep);
	- addProjection(muon_sel4l, "MUON_sel4l");
	+ declare(muon_sel4l, "MUON_sel4l");


	// Selection 2: ZZ-> llnunu selection
	Cut etaranges_lep2 = Cuts::abseta < 2.5 && Cuts::pT > 10*GeV;

	DressedLeptons electron_sel2l2nu(Photon, bare_EL, 0.1, etaranges_lep2);
	- addProjection(electron_sel2l2nu, "ELECTRON_sel2l2nu");
	+ declare(electron_sel2l2nu, "ELECTRON_sel2l2nu");
	DressedLeptons muon_sel2l2nu(Photon, bare_MU, 0.1, etaranges_lep2);
	- addProjection(muon_sel2l2nu, "MUON_sel2l2nu");
	+ declare(muon_sel2l2nu, "MUON_sel2l2nu");


	/// Get all neutrinos. These will not be used to form jets.
	/// We'll use the highest 2 pT neutrinos to calculate the MET
	IdentifiedFinalState neutrino_fs(Cuts::abseta < 4.5);
	neutrino_fs.acceptNeutrinos();
	- addProjection(neutrino_fs, "NEUTRINO_FS");
	+ declare(neutrino_fs, "NEUTRINO_FS");

	VetoedFinalState jetinput;
	jetinput.addVetoOnThisFinalState(bare_MU);
	jetinput.addVetoOnThisFinalState(neutrino_fs);

	FastJets jetpro(fs, FastJets::ANTIKT, 0.4);
	- addProjection(jetpro, "jet");
	+ declare(jetpro, "jet");

	// Both ZZ on-shell histos
	_h_ZZ_xsect = bookHisto1D(1, 1, 1);
	_h_ZZ_ZpT = bookHisto1D(3, 1, 1);
	_h_ZZ_phill = bookHisto1D(5, 1, 1);
	_h_ZZ_mZZ = bookHisto1D(7, 1, 1);

	// One Z off-shell (ZZstar) histos
	_h_ZZs_xsect = bookHisto1D(1, 1, 2);

	// ZZ -> llnunu histos
	_h_ZZnunu_xsect = bookHisto1D(1, 1, 3);
	_h_ZZnunu_ZpT = bookHisto1D(4, 1, 1);
	_h_ZZnunu_phill = bookHisto1D(6, 1, 1);
	_h_ZZnunu_mZZ = bookHisto1D(8, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& e) {
	const double weight = e.weight();

	////////////////////////////////////////////////////////////////////
	// preselection of leptons for ZZ-> llll final state
	////////////////////////////////////////////////////////////////////

	Particles leptons_sel4l;

	- const vector<DressedLepton>& mu_sel4l = applyProjection<DressedLeptons>(e, "MUON_sel4l").dressedLeptons();
	- const vector<DressedLepton>& el_sel4l = applyProjection<DressedLeptons>(e, "ELECTRON_sel4l").dressedLeptons();
	+ const vector<DressedLepton>& mu_sel4l = apply<DressedLeptons>(e, "MUON_sel4l").dressedLeptons();
	+ const vector<DressedLepton>& el_sel4l = apply<DressedLeptons>(e, "ELECTRON_sel4l").dressedLeptons();

	vector<DressedLepton> leptonsFS_sel4l;
	leptonsFS_sel4l.insert( leptonsFS_sel4l.end(), mu_sel4l.begin(), mu_sel4l.end() );
	leptonsFS_sel4l.insert( leptonsFS_sel4l.end(), el_sel4l.begin(), el_sel4l.end() );

	////////////////////////////////////////////////////////////////////
	// OVERLAP removal dR(l,l)>0.2
	////////////////////////////////////////////////////////////////////
	foreach ( const DressedLepton& l1, leptonsFS_sel4l) {
	bool isolated = true;
	foreach (DressedLepton& l2, leptonsFS_sel4l) {
	const double dR = deltaR(l1, l2);
	if (dR < 0.2 && l1 != l2) { isolated = false; break; }
	}
	if (isolated) leptons_sel4l.push_back(l1);
	}

	//////////////////////////////////////////////////////////////////
	// Exactly two opposite charged leptons
	//////////////////////////////////////////////////////////////////

	// calculate total 'flavour' charge
	double totalcharge = 0;
	foreach (Particle& l, leptons_sel4l) totalcharge += l.pid();

	// Analyze 4 lepton events
	if (leptons_sel4l.size() == 4 && totalcharge == 0 ) {
	Zstate Z1, Z2;

	// Identifies Z states from 4 lepton pairs
	identifyZstates(Z1, Z2,leptons_sel4l);

	////////////////////////////////////////////////////////////////////////////
	// Z MASS WINDOW
	// -ZZ: for both Z: 66<mZ<116 GeV
	// -ZZ*: one Z on-shell: 66<mZ<116 GeV, one Z off-shell: mZ>20 GeV
	///////////////////////////////////////////////////////////////////////////

	Zstate leadPtZ = std::max(Z1, Z2, Zstate::cmppT);

	double mZ1 = Z1.mom().mass();
	double mZ2 = Z2.mom().mass();
	double ZpT = leadPtZ.mom().pT();
	double phill = fabs(deltaPhi(leadPtZ.first, leadPtZ.second));
	if (phill > M_PI) phill = 2*M_PI-phill;
	double mZZ = (Z1.mom() + Z2.mom()).mass();

	if (mZ1 > 20GeV && mZ2 > 20GeV) {
	// ZZ* selection
	if (inRange(mZ1, 66GeV, 116GeV) \|\| inRange(mZ2, 66GeV, 116GeV)) {
	_h_ZZs_xsect -> fill(sqrtS()*GeV, weight);
	}

	// ZZ selection
	if (inRange(mZ1, 66GeV, 116GeV) && inRange(mZ2, 66GeV, 116GeV)) {
	_h_ZZ_xsect -> fill(sqrtS()*GeV, weight);
	_h_ZZ_ZpT -> fill(ZpT , weight);
	_h_ZZ_phill -> fill(phill , weight);
	_h_ZZ_mZZ -> fill(mZZ , weight);
	}
	}
	}

	////////////////////////////////////////////////////////////////////
	/// preselection of leptons for ZZ-> llnunu final state
	////////////////////////////////////////////////////////////////////

	Particles leptons_sel2l2nu; // output
	- const vector<DressedLepton>& mu_sel2l2nu = applyProjection<DressedLeptons>(e, "MUON_sel2l2nu").dressedLeptons();
	- const vector<DressedLepton>& el_sel2l2nu = applyProjection<DressedLeptons>(e, "ELECTRON_sel2l2nu").dressedLeptons();
	+ const vector<DressedLepton>& mu_sel2l2nu = apply<DressedLeptons>(e, "MUON_sel2l2nu").dressedLeptons();
	+ const vector<DressedLepton>& el_sel2l2nu = apply<DressedLeptons>(e, "ELECTRON_sel2l2nu").dressedLeptons();

	vector<DressedLepton> leptonsFS_sel2l2nu;
	leptonsFS_sel2l2nu.insert( leptonsFS_sel2l2nu.end(), mu_sel2l2nu.begin(), mu_sel2l2nu.end() );
	leptonsFS_sel2l2nu.insert( leptonsFS_sel2l2nu.end(), el_sel2l2nu.begin(), el_sel2l2nu.end() );

	// Lepton preselection for ZZ-> llnunu
	if ((mu_sel2l2nu.empty() \|\| el_sel2l2nu.empty()) // cannot have opposite flavour
	&& (leptonsFS_sel2l2nu.size() == 2) // exactly two leptons
	&& (leptonsFS_sel2l2nu[0].charge() * leptonsFS_sel2l2nu[1].charge() < 1 ) // opposite charge
	&& (deltaR(leptonsFS_sel2l2nu[0], leptonsFS_sel2l2nu[1]) > 0.3) // overlap removal
	&& (leptonsFS_sel2l2nu[0].pT() > 20GeV && leptonsFS_sel2l2nu[1].pT() > 20GeV)) { // trigger requirement
	leptons_sel2l2nu.insert(leptons_sel2l2nu.end(), leptonsFS_sel2l2nu.begin(), leptonsFS_sel2l2nu.end());
	}
	if (leptons_sel2l2nu.empty()) vetoEvent; // no further analysis, fine to veto

	Particles leptons_sel2l2nu_jetveto;
	foreach (const DressedLepton& l, mu_sel2l2nu) leptons_sel2l2nu_jetveto.push_back(l.constituentLepton());
	foreach (const DressedLepton& l, el_sel2l2nu) leptons_sel2l2nu_jetveto.push_back(l.constituentLepton());
	double ptll = (leptons_sel2l2nu[0].momentum() + leptons_sel2l2nu[1].momentum()).pT();

	// Find Z1-> ll
	FinalState fs2(-3.2, 3.2);
	InvMassFinalState imfs(fs2, vids, 20*GeV, sqrtS());
	imfs.calc(leptons_sel2l2nu);
	if (imfs.particlePairs().size() != 1) vetoEvent;
	const ParticlePair& Z1constituents = imfs.particlePairs()[0];
	FourMomentum Z1 = Z1constituents.first.momentum() + Z1constituents.second.momentum();

	// Find Z2-> nunu
	- const Particles& neutrinoFS = applyProjection<IdentifiedFinalState>(e, "NEUTRINO_FS").particlesByPt();
	+ const Particles& neutrinoFS = apply<IdentifiedFinalState>(e, "NEUTRINO_FS").particlesByPt();
	FinalState fs3(-4.5, 4.5);
	InvMassFinalState imfs_Znunu(fs3, vnuids, 20*GeV, sqrtS(), ZMASS);
	imfs_Znunu.calc(neutrinoFS);
	if (imfs_Znunu.particlePairs().size() == 0 ) vetoEvent;

	// Z to neutrinos
	FourMomentum Z2 = imfs_Znunu.particlePairs()[0].first.momentum() + imfs_Znunu.particlePairs()[0].second.momentum();
	double met_Znunu = Z2.pT();

	// mTZZ
	const double mT2_1st_term = add_quad(ZMASS, ptll) + add_quad(ZMASS, met_Znunu);
	const double mT2_2nd_term = Z1.px() + Z2.px();
	const double mT2_3rd_term = Z1.py() + Z2.py();
	const double mTZZ = sqrt(sqr(mT2_1st_term) - sqr(mT2_2nd_term) - sqr(mT2_3rd_term));

	if (!inRange(Z2.mass(), 66GeV, 116GeV)) vetoEvent;
	if (!inRange(Z1.mass(), 76GeV, 106GeV)) vetoEvent;

	/////////////////////////////////////////////////////////////
	// AXIAL MET < 75 GeV
	////////////////////////////////////////////////////////////

	double dPhiZ1Z2 = fabs(deltaPhi(Z1, Z2));
	if (dPhiZ1Z2 > M_PI) dPhiZ1Z2 = 2*M_PI - dPhiZ1Z2;
	const double axialEtmiss = -Z2.pT()*cos(dPhiZ1Z2);
	if (axialEtmiss < 75*GeV) vetoEvent;

	const double ZpT = Z1.pT();
	double phill = fabs(deltaPhi(Z1constituents.first, Z1constituents.second));
	if (phill > M_PI) phill = 2*M_PI - phill;


	////////////////////////////////////////////////////////////////////////////
	// JETS
	// -"j": found by "jetpro" projection && pT() > 25 GeV && \|eta\| < 4.5
	// -"goodjets": "j" && dR(electron/muon,jet) > 0.3
	//
	// JETVETO: veto all events with at least one good jet
	///////////////////////////////////////////////////////////////////////////
	vector<Jet> good_jets;
	- foreach (const Jet& j, applyProjection<FastJets>(e, "jet").jetsByPt(25)) {
	+ foreach (const Jet& j, apply<FastJets>(e, "jet").jetsByPt(25)) {
	if (j.abseta() > 4.5) continue;
	bool isLepton = 0;
	foreach (const Particle& l, leptons_sel2l2nu_jetveto) {
	const double dR = deltaR(l.momentum(), j.momentum());
	if (dR < 0.3) { isLepton = true; break; }
	}
	if (!isLepton) good_jets.push_back(j);
	}
	size_t n_sel_jets = good_jets.size();
	if (n_sel_jets != 0) vetoEvent;


	/////////////////////////////////////////////////////////////
	// Fractional MET and lepton pair difference: "RatioMet"< 0.4
	////////////////////////////////////////////////////////////
	double ratioMet = fabs(Z2.pT() - Z1.pT()) / Z1.pT();
	if (ratioMet > 0.4 ) vetoEvent;


	// End of ZZllnunu selection: now fill histograms
	_h_ZZnunu_xsect->fill(sqrtS()/GeV, weight);
	_h_ZZnunu_ZpT ->fill(ZpT, weight);
	_h_ZZnunu_phill->fill(phill, weight);
	_h_ZZnunu_mZZ ->fill(mTZZ, weight);

	}


	/// Finalize
	void finalize() {
	const double norm = crossSection()/sumOfWeights()/femtobarn;

	scale(_h_ZZ_xsect, norm);
	normalize(_h_ZZ_ZpT);
	normalize(_h_ZZ_phill);
	normalize(_h_ZZ_mZZ);

	scale(_h_ZZs_xsect, norm);
	scale(_h_ZZnunu_xsect, norm);
	normalize(_h_ZZnunu_ZpT);
	normalize(_h_ZZnunu_phill);
	normalize(_h_ZZnunu_mZZ);
	}


	private:

	Histo1DPtr _h_ZZ_xsect, _h_ZZ_ZpT, _h_ZZ_phill, _h_ZZ_mZZ;
	Histo1DPtr _h_ZZs_xsect;
	Histo1DPtr _h_ZZnunu_xsect, _h_ZZnunu_ZpT, _h_ZZnunu_phill, _h_ZZnunu_mZZ;
	vector< pair<PdgId,PdgId> > vids, vnuids;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1203852);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1204447.cc b/src/Analyses/ATLAS_2012_I1204447.cc
	--- a/src/Analyses/ATLAS_2012_I1204447.cc
	+++ b/src/Analyses/ATLAS_2012_I1204447.cc
	@@ -1,1060 +1,1060 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2012_I1204447 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1204447()
	: Analysis("ATLAS_2012_I1204447") { }


	/// Book histograms and initialise projections before the run
	void init() {

	// To calculate the acceptance without having the fiducial lepton efficiencies included, this part can be turned off
	_use_fiducial_lepton_efficiency = true;

	// Random numbers for simulation of ATLAS detector reconstruction efficiency
	srand(160385);

	// Read in all signal regions
	_signal_regions = getSignalRegions();

	// Set number of events per signal region to 0
	for (size_t i = 0; i < _signal_regions.size(); i++)
	_eventCountsPerSR[_signal_regions[i]] = 0.0;

	// Final state including all charged and neutral particles
	const FinalState fs(-5.0, 5.0, 1*GeV);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Final state including all charged particles
	- addProjection(ChargedFinalState(Cuts::abseta < 2.5 && Cuts::pT > 1*GeV), "CFS");
	+ declare(ChargedFinalState(Cuts::abseta < 2.5 && Cuts::pT > 1*GeV), "CFS");

	// Final state including all visible particles (to calculate MET, Jets etc.)
	- addProjection(VisibleFinalState(Cuts::abseta < 5.0), "VFS");
	+ declare(VisibleFinalState(Cuts::abseta < 5.0), "VFS");

	// Final state including all AntiKt 04 Jets
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// Final state including all unstable particles (including taus)
	- addProjection(UnstableFinalState(Cuts::abseta < 5.0 && Cuts::pT > 5*GeV), "UFS");
	+ declare(UnstableFinalState(Cuts::abseta < 5.0 && Cuts::pT > 5*GeV), "UFS");

	// Final state including all electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 10*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// Final state including all muons
	IdentifiedFinalState muons(Cuts::abseta < 2.5 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// Book histograms
	_h_HTlep_all = bookHisto1D("HTlep_all" , 30, 0, 1500);
	_h_HTjets_all = bookHisto1D("HTjets_all", 30, 0, 1500);
	_h_MET_all = bookHisto1D("MET_all" , 20, 0, 1000);
	_h_Meff_all = bookHisto1D("Meff_all" , 30, 0, 3000);

	_h_e_n = bookHisto1D("e_n" , 10, -0.5, 9.5);
	_h_mu_n = bookHisto1D("mu_n" , 10, -0.5, 9.5);
	_h_tau_n = bookHisto1D("tau_n", 10, -0.5, 9.5);

	_h_pt_1_3l = bookHisto1D("pt_1_3l", 100, 0, 2000);
	_h_pt_2_3l = bookHisto1D("pt_2_3l", 100, 0, 2000);
	_h_pt_3_3l = bookHisto1D("pt_3_3l", 100, 0, 2000);
	_h_pt_1_2ltau = bookHisto1D("pt_1_2ltau", 100, 0, 2000);
	_h_pt_2_2ltau = bookHisto1D("pt_2_2ltau", 100, 0, 2000);
	_h_pt_3_2ltau = bookHisto1D("pt_3_2ltau", 100, 0, 2000);

	_h_excluded = bookHisto1D("excluded", 2, -0.5, 1.5);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Muons
	Particles muon_candidates;
	- const Particles charged_tracks = applyProjection<ChargedFinalState>(event, "CFS").particles();
	- const Particles visible_particles = applyProjection<VisibleFinalState>(event, "VFS").particles();
	- foreach (const Particle& mu, applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	+ const Particles charged_tracks = apply<ChargedFinalState>(event, "CFS").particles();
	+ const Particles visible_particles = apply<VisibleFinalState>(event, "VFS").particles();
	+ foreach (const Particle& mu, apply<IdentifiedFinalState>(event, "muons").particlesByPt()) {
	// Calculate pTCone30 variable (pT of all tracks within dR<0.3 - pT of muon itself)
	double pTinCone = -mu.pT();
	foreach (const Particle& track, charged_tracks) {
	if (deltaR(mu.momentum(), track.momentum()) < 0.3)
	pTinCone += track.pT();
	}

	// Calculate eTCone30 variable (pT of all visible particles within dR<0.3)
	double eTinCone = 0.;
	foreach (const Particle& visible_particle, visible_particles) {
	if (visible_particle.abspid() != PID::MUON && inRange(deltaR(mu.momentum(), visible_particle.momentum()), 0.1, 0.3))
	eTinCone += visible_particle.pT();
	}

	// Apply reconstruction efficiency and simulate reco
	int muon_id = 13;
	if ( mu.hasAncestor(15) \|\| mu.hasAncestor(-15)) muon_id = 14;
	const double eff = (_use_fiducial_lepton_efficiency) ? apply_reco_eff(muon_id, mu) : 1.0;
	const bool keep_muon = rand()/static_cast<double>(RAND_MAX) <= eff;

	// Keep muon if pTCone30/pT < 0.15 and eTCone30/pT < 0.2 and reconstructed
	if (keep_muon && pTinCone/mu.pT() <= 0.15 && eTinCone/mu.pT() < 0.2)
	muon_candidates.push_back(mu);
	}


	// Electrons
	Particles electron_candidates;
	- foreach (const Particle& e, applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	+ foreach (const Particle& e, apply<IdentifiedFinalState>(event, "elecs").particlesByPt()) {
	// Neglect electrons in crack regions
	if (inRange(e.abseta(), 1.37, 1.52)) continue;

	// Calculate pTCone30 variable (pT of all tracks within dR<0.3 - pT of electron itself)
	double pTinCone = -e.pT();
	foreach (const Particle& track, charged_tracks) {
	if (deltaR(e.momentum(), track.momentum()) < 0.3) pTinCone += track.pT();
	}

	// Calculate eTCone30 variable (pT of all visible particles (except muons) within dR<0.3)
	double eTinCone = 0.;
	foreach (const Particle& visible_particle, visible_particles) {
	if (visible_particle.abspid() != PID::MUON && inRange(deltaR(e.momentum(), visible_particle.momentum()), 0.1, 0.3))
	eTinCone += visible_particle.pT();
	}

	// Apply reconstruction efficiency and simulate reco
	int elec_id = 11;
	if (e.hasAncestor(15) \|\| e.hasAncestor(-15)) elec_id = 12;
	const double eff = (_use_fiducial_lepton_efficiency) ? apply_reco_eff(elec_id, e) : 1.0;
	const bool keep_elec = rand()/static_cast<double>(RAND_MAX) <= eff;

	// Keep electron if pTCone30/pT < 0.13 and eTCone30/pT < 0.2 and reconstructed
	if (keep_elec && pTinCone/e.pT() <= 0.13 && eTinCone/e.pT() < 0.2)
	electron_candidates.push_back(e);
	}


	// Taus
	/// @todo This could benefit from a tau finder projection
	Particles tau_candidates;
	- foreach (const Particle& tau, applyProjection<UnstableFinalState>(event, "UFS").particlesByPt()) {
	+ foreach (const Particle& tau, apply<UnstableFinalState>(event, "UFS").particlesByPt()) {
	// Only pick taus out of all unstable particles
	if (tau.abspid() != PID::TAU) continue;

	// Check that tau has decayed into daughter particles
	/// @todo Huh? Unstable taus with no decay vtx? Can use Particle.isStable()? But why in this situation?
	if (tau.genParticle()->end_vertex() == 0) continue;

	// Calculate visible tau pT from pT of tau neutrino in tau decay for pT and \|eta\| cuts
	FourMomentum daughter_tau_neutrino_momentum = get_tau_neutrino_mom(tau);
	Particle tau_vis = tau;
	tau_vis.setMomentum(tau.momentum()-daughter_tau_neutrino_momentum);
	// keep only taus in certain eta region and above 15 GeV of visible tau pT
	if ( tau_vis.pT() <= 15.0*GeV \|\| tau_vis.abseta() > 2.5) continue;

	// Get prong number (number of tracks) in tau decay and check if tau decays leptonically
	unsigned int nprong = 0;
	bool lep_decaying_tau = false;
	get_prong_number(tau.genParticle(), nprong, lep_decaying_tau);

	// Apply reconstruction efficiency
	int tau_id = 15;
	if (nprong == 1) tau_id = 15;
	else if (nprong == 3) tau_id = 16;

	// Get fiducial lepton efficiency simulate reco efficiency
	const double eff = (_use_fiducial_lepton_efficiency) ? apply_reco_eff(tau_id, tau_vis) : 1.0;
	const bool keep_tau = rand()/static_cast<double>(RAND_MAX) <= eff;

	// Keep tau if nprong = 1, it decays hadronically, and it's reconstructed by the detector
	if ( !lep_decaying_tau && nprong == 1 && keep_tau) tau_candidates.push_back(tau_vis);
	}


	// Jets (all anti-kt R=0.4 jets with pT > 25 GeV and eta < 4.9)
	Jets jet_candidates;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(25*GeV)) {
	+ foreach (const Jet& jet, apply<FastJets>(event, "AntiKtJets04").jetsByPt(25*GeV)) {
	if (jet.abseta() < 4.9) jet_candidates.push_back(jet);
	}


	// ETmiss
	- Particles vfs_particles = applyProjection<VisibleFinalState>(event, "VFS").particles();
	+ Particles vfs_particles = apply<VisibleFinalState>(event, "VFS").particles();
	FourMomentum pTmiss;
	foreach (const Particle& p, vfs_particles) pTmiss -= p.momentum();
	double eTmiss = pTmiss.pT()/GeV;


	//------------------
	// Overlap removal

	// electron - electron
	Particles electron_candidates_2;
	for (size_t ie = 0; ie < electron_candidates.size(); ++ie) {
	const Particle & e = electron_candidates[ie];
	bool away = true;
	// If electron pair within dR < 0.1: remove electron with lower pT
	for (size_t ie2=0; ie2 < electron_candidates_2.size(); ++ie2) {
	if ( deltaR( e.momentum(), electron_candidates_2[ie2].momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	// If isolated keep it
	if ( away )
	electron_candidates_2.push_back( e );
	}
	// jet - electron
	Jets recon_jets;
	foreach (const Jet& jet, jet_candidates) {
	bool away = true;
	// if jet within dR < 0.2 of electron: remove jet
	foreach (const Particle& e, electron_candidates_2) {
	if (deltaR(e.momentum(), jet.momentum()) < 0.2) {
	away = false;
	break;
	}
	}
	// jet - tau
	if (away) {
	// If jet within dR < 0.2 of tau: remove jet
	foreach (const Particle& tau, tau_candidates) {
	if (deltaR(tau.momentum(), jet.momentum()) < 0.2) {
	away = false;
	break;
	}
	}
	}
	// If isolated keep it
	if ( away )
	recon_jets.push_back( jet );
	}


	// electron - jet
	Particles recon_leptons, recon_e;
	for (size_t ie = 0; ie < electron_candidates_2.size(); ++ie) {
	const Particle& e = electron_candidates_2[ie];
	// If electron within 0.2 < dR < 0.4 from any jets: remove electron
	bool away = true;
	foreach (const Jet& jet, recon_jets) {
	if (deltaR(e.momentum(), jet.momentum()) < 0.4) {
	away = false;
	break;
	}
	}
	// electron - muon
	// if electron within dR < 0.1 of a muon: remove electron
	if (away) {
	foreach (const Particle& mu, muon_candidates) {
	if (deltaR(mu.momentum(), e.momentum()) < 0.1) {
	away = false;
	break;
	}
	}
	}
	// If isolated keep it
	if (away) {
	recon_e += e;
	recon_leptons += e;
	}
	}


	// tau - electron
	Particles recon_tau;
	foreach ( const Particle& tau, tau_candidates ) {
	bool away = true;
	// If tau within dR < 0.2 of an electron: remove tau
	foreach ( const Particle& e, recon_e ) {
	if (deltaR( tau.momentum(), e.momentum()) < 0.2) {
	away = false;
	break;
	}
	}
	// tau - muon
	// If tau within dR < 0.2 of a muon: remove tau
	if (away) {
	foreach (const Particle& mu, muon_candidates) {
	if (deltaR(tau.momentum(), mu.momentum()) < 0.2) {
	away = false;
	break;
	}
	}
	}
	// If isolated keep it
	if (away) recon_tau.push_back( tau );
	}

	// Muon - jet isolation
	Particles recon_mu, trigger_mu;
	// If muon within dR < 0.4 of a jet, remove muon
	foreach (const Particle& mu, muon_candidates) {
	bool away = true;
	foreach (const Jet& jet, recon_jets) {
	if ( deltaR( mu.momentum(), jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if (away) {
	recon_mu.push_back( mu );
	recon_leptons.push_back( mu );
	if (mu.abseta() < 2.4) trigger_mu.push_back( mu );
	}
	}

	// End overlap removal
	//------------------


	// Jet cleaning
	if (rand()/static_cast<double>(RAND_MAX) <= 0.42) {
	foreach (const Jet& jet, recon_jets) {
	const double eta = jet.rapidity();
	const double phi = jet.azimuthalAngle(MINUSPI_PLUSPI);
	if (jet.pT() > 25*GeV && inRange(eta, -0.1, 1.5) && inRange(phi, -0.9, -0.5)) vetoEvent;
	}
	}


	// Post-isolation event cuts
	// Require at least 3 charged tracks in event
	if (charged_tracks.size() < 3) vetoEvent;

	// And at least one e/mu passing trigger
	if (!( !recon_e .empty() && recon_e[0] .pT() > 25*GeV) &&
	!( !trigger_mu.empty() && trigger_mu[0].pT() > 25*GeV) ) {
	MSG_DEBUG("Hardest lepton fails trigger");
	vetoEvent;
	}

	// And only accept events with at least 2 electrons and muons and at least 3 leptons in total
	if (recon_mu.size() + recon_e.size() + recon_tau.size() < 3 \|\| recon_leptons.size() < 2) vetoEvent;

	// Now it's worth getting the event weight
	const double weight = event.weight();

	// Sort leptons by decreasing pT
	sortByPt(recon_leptons);
	sortByPt(recon_tau);

	// Calculate HTlep, fill lepton pT histograms & store chosen combination of 3 leptons
	double HTlep = 0.;
	Particles chosen_leptons;
	if ( recon_leptons.size() > 2 ) {
	_h_pt_1_3l->fill(recon_leptons[0].perp()/GeV, weight);
	_h_pt_2_3l->fill(recon_leptons[1].perp()/GeV, weight);
	_h_pt_3_3l->fill(recon_leptons[2].perp()/GeV, weight);
	HTlep = (recon_leptons[0].pT() + recon_leptons[1].pT() + recon_leptons[2].pT())/GeV;
	chosen_leptons.push_back( recon_leptons[0] );
	chosen_leptons.push_back( recon_leptons[1] );
	chosen_leptons.push_back( recon_leptons[2] );
	}
	else {
	_h_pt_1_2ltau->fill(recon_leptons[0].perp()/GeV, weight);
	_h_pt_2_2ltau->fill(recon_leptons[1].perp()/GeV, weight);
	_h_pt_3_2ltau->fill(recon_tau[0].perp()/GeV, weight);
	HTlep = (recon_leptons[0].pT() + recon_leptons[1].pT() + recon_tau[0].pT())/GeV ;
	chosen_leptons.push_back( recon_leptons[0] );
	chosen_leptons.push_back( recon_leptons[1] );
	chosen_leptons.push_back( recon_tau[0] );
	}

	// Number of prompt e/mu and had taus
	_h_e_n ->fill(recon_e.size() , weight);
	_h_mu_n ->fill(recon_mu.size() , weight);
	_h_tau_n->fill(recon_tau.size(), weight);

	// Calculate HTjets
	double HTjets = 0.;
	foreach ( const Jet & jet, recon_jets )
	HTjets += jet.perp()/GeV;

	// Calculate meff
	double meff = eTmiss + HTjets;
	Particles all_leptons;
	foreach ( const Particle & e , recon_e ) {
	meff += e.perp()/GeV;
	all_leptons.push_back( e );
	}
	foreach ( const Particle & mu, recon_mu ) {
	meff += mu.perp()/GeV;
	all_leptons.push_back( mu );
	}
	foreach ( const Particle & tau, recon_tau ) {
	meff += tau.perp()/GeV;
	all_leptons.push_back( tau );
	}

	// Fill histogram of kinematic variables
	_h_HTlep_all ->fill(HTlep , weight);
	_h_HTjets_all->fill(HTjets, weight);
	_h_MET_all ->fill(eTmiss, weight);
	_h_Meff_all ->fill(meff , weight);

	// Determine signal region (3l/2ltau, onZ/offZ)
	string basic_signal_region;
	if ( recon_mu.size() + recon_e.size() > 2 )
	basic_signal_region += "3l_";
	else if ( (recon_mu.size() + recon_e.size() == 2) && (recon_tau.size() > 0))
	basic_signal_region += "2ltau_";
	// Is there an OSSF pair or a three lepton combination with an invariant mass close to the Z mass
	int onZ = isonZ(chosen_leptons);
	if (onZ == 1) basic_signal_region += "onZ";
	else if (onZ == 0) basic_signal_region += "offZ";
	// Check in which signal regions this event falls and adjust event counters
	fillEventCountsPerSR(basic_signal_region, onZ, HTlep, eTmiss, HTjets, meff, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	// Normalize to an integrated luminosity of 1 fb-1
	double norm = crossSection()/femtobarn/sumOfWeights();
	string best_signal_region = "";
	double ratio_best_SR = 0.;

	// Loop over all signal regions and find signal region with best sensitivity (ratio signal events/visible cross-section)
	for (size_t i = 0; i < _signal_regions.size(); i++) {
	double signal_events = _eventCountsPerSR[_signal_regions[i]] * norm;
	// Use expected upper limits to find best signal region
	double UL95 = getUpperLimit(_signal_regions[i], false);
	double ratio = signal_events / UL95;
	if (ratio > ratio_best_SR) {
	best_signal_region = _signal_regions[i];
	ratio_best_SR = ratio;
	}
	}

	double signal_events_best_SR = _eventCountsPerSR[best_signal_region] * norm;
	double exp_UL_best_SR = getUpperLimit(best_signal_region, false);
	double obs_UL_best_SR = getUpperLimit(best_signal_region, true);

	// Print out result
	cout << "----------------------------------------------------------------------------------------" << endl;
	cout << "Best signal region: " << best_signal_region << endl;
	cout << "Normalized number of signal events in this best signal region (per fb-1): " << signal_events_best_SR << endl;
	cout << "Efficiency*Acceptance: " << _eventCountsPerSR[best_signal_region]/sumOfWeights() << endl;
	cout << "Cross-section [fb]: " << crossSection()/femtobarn << endl;
	cout << "Expected visible cross-section (per fb-1): " << exp_UL_best_SR << endl;
	cout << "Ratio (signal events / expected visible cross-section): " << ratio_best_SR << endl;
	cout << "Observed visible cross-section (per fb-1): " << obs_UL_best_SR << endl;
	cout << "Ratio (signal events / observed visible cross-section): " << signal_events_best_SR/obs_UL_best_SR << endl;
	cout << "----------------------------------------------------------------------------------------" << endl;

	cout << "Using the EXPECTED limits (visible cross-section) of the analysis: " << endl;
	if (signal_events_best_SR > exp_UL_best_SR) {
	cout << "Since the number of signal events > the visible cross-section, this model/grid point is EXCLUDED with 95% CL." << endl;
	_h_excluded->fill(1);
	}
	else {
	cout << "Since the number of signal events < the visible cross-section, this model/grid point is NOT EXCLUDED." << endl;
	_h_excluded->fill(0);
	}
	cout << "----------------------------------------------------------------------------------------" << endl;

	cout << "Using the OBSERVED limits (visible cross-section) of the analysis: " << endl;
	if (signal_events_best_SR > obs_UL_best_SR) {
	cout << "Since the number of signal events > the visible cross-section, this model/grid point is EXCLUDED with 95% CL." << endl;
	_h_excluded->fill(1);
	}
	else {
	cout << "Since the number of signal events < the visible cross-section, this model/grid point is NOT EXCLUDED." << endl;
	_h_excluded->fill(0);
	}
	cout << "----------------------------------------------------------------------------------------" << endl;


	// Normalize to cross section
	if (norm != 0) {
	scale(_h_HTlep_all, norm);
	scale(_h_HTjets_all, norm);
	scale(_h_MET_all, norm);
	scale(_h_Meff_all, norm);

	scale(_h_pt_1_3l, norm);
	scale(_h_pt_2_3l, norm);
	scale(_h_pt_3_3l, norm);
	scale(_h_pt_1_2ltau, norm);
	scale(_h_pt_2_2ltau, norm);
	scale(_h_pt_3_2ltau, norm);

	scale(_h_e_n, norm);
	scale(_h_mu_n, norm);
	scale(_h_tau_n, norm);

	scale(_h_excluded, signal_events_best_SR);
	}
	}


	/// Helper functions
	//@{

	/// Function giving a list of all signal regions
	vector<string> getSignalRegions() {

	// List of basic signal regions
	vector<string> basic_signal_regions;
	basic_signal_regions.push_back("3l_offZ");
	basic_signal_regions.push_back("3l_onZ");
	basic_signal_regions.push_back("2ltau_offZ");
	basic_signal_regions.push_back("2ltau_onZ");

	// List of kinematic variables
	vector<string> kinematic_variables;
	kinematic_variables.push_back("HTlep");
	kinematic_variables.push_back("METStrong");
	kinematic_variables.push_back("METWeak");
	kinematic_variables.push_back("Meff");
	kinematic_variables.push_back("MeffStrong");

	vector<string> signal_regions;
	// Loop over all kinematic variables and basic signal regions
	for (size_t i0 = 0; i0 < kinematic_variables.size(); i0++) {
	for (size_t i1 = 0; i1 < basic_signal_regions.size(); i1++) {
	// Is signal region onZ?
	int onZ = (basic_signal_regions[i1].find("onZ") != string::npos) ? 1 : 0;
	// Get cut values for this kinematic variable
	vector<int> cut_values = getCutsPerSignalRegion(kinematic_variables[i0], onZ);
	// Loop over all cut values
	for (size_t i2 = 0; i2 < cut_values.size(); i2++) {
	// push signal region into vector
	signal_regions.push_back( (kinematic_variables[i0] + "_" + basic_signal_regions[i1] + "_cut_" + toString(i2)) );
	}
	}
	}
	return signal_regions;
	}


	/// Function giving all cut vales per kinematic variable (taking onZ for MET into account)
	vector<int> getCutsPerSignalRegion(const string& signal_region, int onZ=0) {
	vector<int> cutValues;

	// Cut values for HTlep
	if (signal_region.compare("HTlep") == 0) {
	cutValues.push_back(0);
	cutValues.push_back(100);
	cutValues.push_back(150);
	cutValues.push_back(200);
	cutValues.push_back(300);
	}
	// Cut values for METStrong (HTjets > 100 GeV) and METWeak (HTjets < 100 GeV)
	else if (signal_region.compare("METStrong") == 0 \|\| signal_region.compare("METWeak") == 0) {
	if (onZ == 0) cutValues.push_back(0);
	else if (onZ == 1) cutValues.push_back(20);
	cutValues.push_back(50);
	cutValues.push_back(75);
	}
	// Cut values for Meff and MeffStrong (MET > 75 GeV)
	if (signal_region.compare("Meff") == 0 \|\| signal_region.compare("MeffStrong") == 0) {
	cutValues.push_back(0);
	cutValues.push_back(150);
	cutValues.push_back(300);
	cutValues.push_back(500);
	}

	return cutValues;
	}


	/// function fills map EventCountsPerSR by looping over all signal regions
	/// and looking if the event falls into this signal region
	void fillEventCountsPerSR(const string& basic_signal_region, int onZ,
	double HTlep, double eTmiss,
	double HTjets, double meff,
	double weight) {

	// Get cut values for HTlep, loop over them and add event if cut is passed
	vector<int> cut_values = getCutsPerSignalRegion("HTlep", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (HTlep > cut_values[i])
	_eventCountsPerSR[("HTlep_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for METStrong, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("METStrong", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (eTmiss > cut_values[i] && HTjets > 100.)
	_eventCountsPerSR[("METStrong_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for METWeak, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("METWeak", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (eTmiss > cut_values[i] && HTjets <= 100.)
	_eventCountsPerSR[("METWeak_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for Meff, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("Meff", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (meff > cut_values[i])
	_eventCountsPerSR[("Meff_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for MeffStrong, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("MeffStrong", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (meff > cut_values[i] && eTmiss > 75.)
	_eventCountsPerSR[("MeffStrong_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}
	}


	/// Function returning 4-vector of daughter-particle if it is a tau neutrino
	/// @todo Move to TauFinder and make less HepMC-ish
	FourMomentum get_tau_neutrino_mom(const Particle& p) {
	assert(p.abspid() == PID::TAU);
	const GenVertex* dv = p.genParticle()->end_vertex();
	assert(dv != NULL);
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	if (abs((pp)->pdg_id()) == PID::NU_TAU) return FourMomentum((pp)->momentum());
	}
	return FourMomentum();
	}


	/// Function calculating the prong number of taus
	/// @todo Move to TauFinder and make less HepMC-ish
	void get_prong_number(const GenParticle* p, unsigned int& nprong, bool& lep_decaying_tau) {
	assert(p != NULL);
	//const int tau_barcode = p->barcode();
	const GenVertex* dv = p->end_vertex();
	assert(dv != NULL);
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	// If they have status 1 and are charged they will produce a track and the prong number is +1
	if ((*pp)->status() == 1 ) {
	const int id = (*pp)->pdg_id();
	if (Rivet::PID::charge(id) != 0 ) ++nprong;
	// Check if tau decays leptonically
	// @todo Can a tau decay include a tau in its decay daughters?!
	if ((abs(id) == PID::ELECTRON \|\| abs(id) == PID::MUON \|\| abs(id) == PID::TAU) && abs(p->pdg_id()) == PID::TAU) lep_decaying_tau = true;
	}
	// If the status of the daughter particle is 2 it is unstable and the further decays are checked
	else if ((*pp)->status() == 2 ) {
	get_prong_number(*pp, nprong, lep_decaying_tau);
	}
	}
	}


	/// Function giving fiducial lepton efficiency
	double apply_reco_eff(int flavor, const Particle& p) {
	float pt = p.pT()/GeV;
	float eta = p.eta();

	double eff = 0.;
	//double err = 0.;

	if (flavor == 11) { // weight prompt electron -- now including data/MC ID SF in eff.
	//float rho = 0.820;
	float p0 = 7.34; float p1 = 0.8977;
	//float ep0= 0.5 ; float ep1= 0.0087;
	eff = p1 - p0/pt;

	//double err0 = ep0/pt; // d(eff)/dp0
	//double err1 = ep1; // d(eff)/dp1
	//err = sqrt(err0err0 + err1err1 - 2rhoerr0*err1);

	double avgrate = 0.6867;
	float wz_ele_eta[] = {0.588717,0.603674,0.666135,0.747493,0.762202,0.675051,0.751606,0.745569,0.665333,0.610432,0.592693,};
	//float ewz_ele_eta[] ={0.00292902,0.002476,0.00241209,0.00182319,0.00194339,0.00299785,0.00197339,0.00182004,0.00241793,0.00245997,0.00290394,};
	int ibin = 3;

	if (eta >= -2.5 && eta < -2.0) ibin = 0;
	if (eta >= -2.0 && eta < -1.5) ibin = 1;
	if (eta >= -1.5 && eta < -1.0) ibin = 2;
	if (eta >= -1.0 && eta < -0.5) ibin = 3;
	if (eta >= -0.5 && eta < -0.1) ibin = 4;
	if (eta >= -0.1 && eta < 0.1) ibin = 5;
	if (eta >= 0.1 && eta < 0.5) ibin = 6;
	if (eta >= 0.5 && eta < 1.0) ibin = 7;
	if (eta >= 1.0 && eta < 1.5) ibin = 8;
	if (eta >= 1.5 && eta < 2.0) ibin = 9;
	if (eta >= 2.0 && eta < 2.5) ibin = 10;

	double eff_eta = wz_ele_eta[ibin];
	//double err_eta = ewz_ele_eta[ibin];

	eff = (eff*eff_eta)/avgrate;
	}

	if (flavor == 12) { // weight electron from tau
	//float rho = 0.884;
	float p0 = 6.799; float p1 = 0.842;
	//float ep0= 0.664; float ep1= 0.016;
	eff = p1 - p0/pt;

	//double err0 = ep0/pt; // d(eff)/dp0
	//double err1 = ep1; // d(eff)/dp1
	//err = sqrt(err0err0 + err1err1 - 2rhoerr0*err1);

	double avgrate = 0.5319;
	float wz_elet_eta[] = {0.468945,0.465953,0.489545,0.58709,0.59669,0.515829,0.59284,0.575828,0.498181,0.463536,0.481738,};
	//float ewz_elet_eta[] ={0.00933795,0.00780868,0.00792679,0.00642083,0.00692652,0.0101568,0.00698452,0.00643524,0.0080002,0.00776238,0.0094699,};
	int ibin = 3;

	if (eta >= -2.5 && eta < -2.0) ibin = 0;
	if (eta >= -2.0 && eta < -1.5) ibin = 1;
	if (eta >= -1.5 && eta < -1.0) ibin = 2;
	if (eta >= -1.0 && eta < -0.5) ibin = 3;
	if (eta >= -0.5 && eta < -0.1) ibin = 4;
	if (eta >= -0.1 && eta < 0.1) ibin = 5;
	if (eta >= 0.1 && eta < 0.5) ibin = 6;
	if (eta >= 0.5 && eta < 1.0) ibin = 7;
	if (eta >= 1.0 && eta < 1.5) ibin = 8;
	if (eta >= 1.5 && eta < 2.0) ibin = 9;
	if (eta >= 2.0 && eta < 2.5) ibin = 10;

	double eff_eta = wz_elet_eta[ibin];
	//double err_eta = ewz_elet_eta[ibin];

	eff = (eff*eff_eta)/avgrate;

	}

	if (flavor == 13) {// weight prompt muon

	//if eta>0.1
	float p0 = -18.21; float p1 = 14.83; float p2 = 0.9312;
	//float ep0= 5.06; float ep1= 1.9; float ep2=0.00069;

	if ( fabs(eta) < 0.1) {
	p0 = 7.459; p1 = 2.615; p2 = 0.5138;
	//ep0 = 10.4; ep1 = 4.934; ep2 = 0.0034;
	}

	double arg = ( pt-p0 )/( 2.*p1 ) ;
	eff = 0.5 * p2 * (1.+erf(arg));
	//err = 0.1*eff;
	}

	if (flavor == 14) {// weight muon from tau

	if (fabs(eta) < 0.1) {
	float p0 = -1.756; float p1 = 12.38; float p2 = 0.4441;
	//float ep0= 10.39; float ep1= 7.9; float ep2=0.022;
	double arg = ( pt-p0 )/( 2.*p1 ) ;
	eff = 0.5 * p2 * (1.+erf(arg));
	//err = 0.1*eff;
	}
	else {
	float p0 = 2.102; float p1 = 0.8293;
	//float ep0= 0.271; float ep1= 0.0083;
	eff = p1 - p0/pt;
	//double err0 = ep0/pt; // d(eff)/dp0
	//double err1 = ep1; // d(eff)/dp1
	//err = sqrt(err0err0 + err1err1 - 2rhoerr0*err1);
	}
	}

	if (flavor == 15) {// weight hadronic tau 1p

	float wz_tau1p[] = {0.0249278,0.146978,0.225049,0.229212,0.21519,0.206152,0.201559,0.197917,0.209249,0.228336,0.193548,};
	//float ewz_tau1p[] ={0.00178577,0.00425252,0.00535052,0.00592126,0.00484684,0.00612941,0.00792099,0.0083006,0.0138307,0.015568,0.0501751,};
	int ibin = 0;
	if (pt > 15) ibin = 1;
	if (pt > 20) ibin = 2;
	if (pt > 25) ibin = 3;
	if (pt > 30) ibin = 4;
	if (pt > 40) ibin = 5;
	if (pt > 50) ibin = 6;
	if (pt > 60) ibin = 7;
	if (pt > 80) ibin = 8;
	if (pt > 100) ibin = 9;
	if (pt > 200) ibin = 10;

	eff = wz_tau1p[ibin];
	//err = ewz_tau1p[ibin];


	double avgrate = 0.1718;
	float wz_tau1p_eta[] = {0.162132,0.176393,0.139619,0.178813,0.185144,0.210027,0.203937,0.178688,0.137034,0.164216,0.163713,};
	//float ewz_tau1p_eta[] ={0.00706705,0.00617989,0.00506798,0.00525172,0.00581865,0.00865675,0.00599245,0.00529877,0.00506368,0.00617025,0.00726219,};

	ibin = 3;
	if (eta >= -2.5 && eta < -2.0) ibin = 0;
	if (eta >= -2.0 && eta < -1.5) ibin = 1;
	if (eta >= -1.5 && eta < -1.0) ibin = 2;
	if (eta >= -1.0 && eta < -0.5) ibin = 3;
	if (eta >= -0.5 && eta < -0.1) ibin = 4;
	if (eta >= -0.1 && eta < 0.1) ibin = 5;
	if (eta >= 0.1 && eta < 0.5) ibin = 6;
	if (eta >= 0.5 && eta < 1.0) ibin = 7;
	if (eta >= 1.0 && eta < 1.5) ibin = 8;
	if (eta >= 1.5 && eta < 2.0) ibin = 9;
	if (eta >= 2.0 && eta < 2.5) ibin = 10;

	double eff_eta = wz_tau1p_eta[ibin];
	//double err_eta = ewz_tau1p_eta[ibin];

	eff = (eff*eff_eta)/avgrate;
	}

	if (flavor == 16) { //weight hadronic tau 3p

	float wz_tau3p[] = {0.000587199,0.00247181,0.0013031,0.00280112,};
	//float ewz_tau3p[] ={0.000415091,0.000617187,0.000582385,0.00197792,};

	int ibin = 0;
	if (pt > 15) ibin = 1;
	if (pt > 20) ibin = 2;
	if (pt > 40) ibin = 3;
	if (pt > 80) ibin = 4;

	eff = wz_tau3p[ibin];
	//err = ewz_tau3p[ibin];
	}

	return eff;
	}


	/// Function giving observed upper limit (visible cross-section)
	double getUpperLimit(const string& signal_region, bool observed) {
	map<string,double> upperLimitsObserved;
	upperLimitsObserved["HTlep_3l_offZ_cut_0"] = 11.;
	upperLimitsObserved["HTlep_3l_offZ_cut_100"] = 8.7;
	upperLimitsObserved["HTlep_3l_offZ_cut_150"] = 4.0;
	upperLimitsObserved["HTlep_3l_offZ_cut_200"] = 4.4;
	upperLimitsObserved["HTlep_3l_offZ_cut_300"] = 1.6;
	upperLimitsObserved["HTlep_2ltau_offZ_cut_0"] = 25.;
	upperLimitsObserved["HTlep_2ltau_offZ_cut_100"] = 14.;
	upperLimitsObserved["HTlep_2ltau_offZ_cut_150"] = 6.1;
	upperLimitsObserved["HTlep_2ltau_offZ_cut_200"] = 3.3;
	upperLimitsObserved["HTlep_2ltau_offZ_cut_300"] = 1.2;
	upperLimitsObserved["HTlep_3l_onZ_cut_0"] = 48.;
	upperLimitsObserved["HTlep_3l_onZ_cut_100"] = 38.;
	upperLimitsObserved["HTlep_3l_onZ_cut_150"] = 14.;
	upperLimitsObserved["HTlep_3l_onZ_cut_200"] = 7.2;
	upperLimitsObserved["HTlep_3l_onZ_cut_300"] = 4.5;
	upperLimitsObserved["HTlep_2ltau_onZ_cut_0"] = 85.;
	upperLimitsObserved["HTlep_2ltau_onZ_cut_100"] = 53.;
	upperLimitsObserved["HTlep_2ltau_onZ_cut_150"] = 11.0;
	upperLimitsObserved["HTlep_2ltau_onZ_cut_200"] = 5.2;
	upperLimitsObserved["HTlep_2ltau_onZ_cut_300"] = 3.0;
	upperLimitsObserved["METStrong_3l_offZ_cut_0"] = 2.6;
	upperLimitsObserved["METStrong_3l_offZ_cut_50"] = 2.1;
	upperLimitsObserved["METStrong_3l_offZ_cut_75"] = 2.1;
	upperLimitsObserved["METStrong_2ltau_offZ_cut_0"] = 4.2;
	upperLimitsObserved["METStrong_2ltau_offZ_cut_50"] = 3.1;
	upperLimitsObserved["METStrong_2ltau_offZ_cut_75"] = 2.6;
	upperLimitsObserved["METStrong_3l_onZ_cut_20"] = 11.0;
	upperLimitsObserved["METStrong_3l_onZ_cut_50"] = 6.4;
	upperLimitsObserved["METStrong_3l_onZ_cut_75"] = 5.1;
	upperLimitsObserved["METStrong_2ltau_onZ_cut_20"] = 5.9;
	upperLimitsObserved["METStrong_2ltau_onZ_cut_50"] = 3.4;
	upperLimitsObserved["METStrong_2ltau_onZ_cut_75"] = 1.2;
	upperLimitsObserved["METWeak_3l_offZ_cut_0"] = 11.;
	upperLimitsObserved["METWeak_3l_offZ_cut_50"] = 5.3;
	upperLimitsObserved["METWeak_3l_offZ_cut_75"] = 3.1;
	upperLimitsObserved["METWeak_2ltau_offZ_cut_0"] = 23.;
	upperLimitsObserved["METWeak_2ltau_offZ_cut_50"] = 4.3;
	upperLimitsObserved["METWeak_2ltau_offZ_cut_75"] = 3.1;
	upperLimitsObserved["METWeak_3l_onZ_cut_20"] = 41.;
	upperLimitsObserved["METWeak_3l_onZ_cut_50"] = 16.;
	upperLimitsObserved["METWeak_3l_onZ_cut_75"] = 8.0;
	upperLimitsObserved["METWeak_2ltau_onZ_cut_20"] = 80.;
	upperLimitsObserved["METWeak_2ltau_onZ_cut_50"] = 4.4;
	upperLimitsObserved["METWeak_2ltau_onZ_cut_75"] = 1.8;
	upperLimitsObserved["Meff_3l_offZ_cut_0"] = 11.;
	upperLimitsObserved["Meff_3l_offZ_cut_150"] = 8.1;
	upperLimitsObserved["Meff_3l_offZ_cut_300"] = 3.1;
	upperLimitsObserved["Meff_3l_offZ_cut_500"] = 2.1;
	upperLimitsObserved["Meff_2ltau_offZ_cut_0"] = 25.;
	upperLimitsObserved["Meff_2ltau_offZ_cut_150"] = 12.;
	upperLimitsObserved["Meff_2ltau_offZ_cut_300"] = 3.9;
	upperLimitsObserved["Meff_2ltau_offZ_cut_500"] = 2.2;
	upperLimitsObserved["Meff_3l_onZ_cut_0"] = 48.;
	upperLimitsObserved["Meff_3l_onZ_cut_150"] = 37.;
	upperLimitsObserved["Meff_3l_onZ_cut_300"] = 11.;
	upperLimitsObserved["Meff_3l_onZ_cut_500"] = 4.8;
	upperLimitsObserved["Meff_2ltau_onZ_cut_0"] = 85.;
	upperLimitsObserved["Meff_2ltau_onZ_cut_150"] = 28.;
	upperLimitsObserved["Meff_2ltau_onZ_cut_300"] = 5.9;
	upperLimitsObserved["Meff_2ltau_onZ_cut_500"] = 1.9;
	upperLimitsObserved["MeffStrong_3l_offZ_cut_0"] = 3.8;
	upperLimitsObserved["MeffStrong_3l_offZ_cut_150"] = 3.8;
	upperLimitsObserved["MeffStrong_3l_offZ_cut_300"] = 2.8;
	upperLimitsObserved["MeffStrong_3l_offZ_cut_500"] = 2.1;
	upperLimitsObserved["MeffStrong_2ltau_offZ_cut_0"] = 3.9;
	upperLimitsObserved["MeffStrong_2ltau_offZ_cut_150"] = 4.0;
	upperLimitsObserved["MeffStrong_2ltau_offZ_cut_300"] = 2.9;
	upperLimitsObserved["MeffStrong_2ltau_offZ_cut_500"] = 1.5;
	upperLimitsObserved["MeffStrong_3l_onZ_cut_0"] = 10.0;
	upperLimitsObserved["MeffStrong_3l_onZ_cut_150"] = 10.0;
	upperLimitsObserved["MeffStrong_3l_onZ_cut_300"] = 6.8;
	upperLimitsObserved["MeffStrong_3l_onZ_cut_500"] = 3.9;
	upperLimitsObserved["MeffStrong_2ltau_onZ_cut_0"] = 1.6;
	upperLimitsObserved["MeffStrong_2ltau_onZ_cut_150"] = 1.4;
	upperLimitsObserved["MeffStrong_2ltau_onZ_cut_300"] = 1.5;
	upperLimitsObserved["MeffStrong_2ltau_onZ_cut_500"] = 0.9;

	// Expected upper limits are also given but not used in this analysis
	map<string,double> upperLimitsExpected;
	upperLimitsExpected["HTlep_3l_offZ_cut_0"] = 11.;
	upperLimitsExpected["HTlep_3l_offZ_cut_100"] = 8.5;
	upperLimitsExpected["HTlep_3l_offZ_cut_150"] = 4.6;
	upperLimitsExpected["HTlep_3l_offZ_cut_200"] = 3.6;
	upperLimitsExpected["HTlep_3l_offZ_cut_300"] = 1.9;
	upperLimitsExpected["HTlep_2ltau_offZ_cut_0"] = 23.;
	upperLimitsExpected["HTlep_2ltau_offZ_cut_100"] = 14.;
	upperLimitsExpected["HTlep_2ltau_offZ_cut_150"] = 6.4;
	upperLimitsExpected["HTlep_2ltau_offZ_cut_200"] = 3.6;
	upperLimitsExpected["HTlep_2ltau_offZ_cut_300"] = 1.5;
	upperLimitsExpected["HTlep_3l_onZ_cut_0"] = 33.;
	upperLimitsExpected["HTlep_3l_onZ_cut_100"] = 25.;
	upperLimitsExpected["HTlep_3l_onZ_cut_150"] = 12.;
	upperLimitsExpected["HTlep_3l_onZ_cut_200"] = 6.5;
	upperLimitsExpected["HTlep_3l_onZ_cut_300"] = 3.1;
	upperLimitsExpected["HTlep_2ltau_onZ_cut_0"] = 94.;
	upperLimitsExpected["HTlep_2ltau_onZ_cut_100"] = 61.;
	upperLimitsExpected["HTlep_2ltau_onZ_cut_150"] = 9.9;
	upperLimitsExpected["HTlep_2ltau_onZ_cut_200"] = 4.5;
	upperLimitsExpected["HTlep_2ltau_onZ_cut_300"] = 1.9;
	upperLimitsExpected["METStrong_3l_offZ_cut_0"] = 3.1;
	upperLimitsExpected["METStrong_3l_offZ_cut_50"] = 2.4;
	upperLimitsExpected["METStrong_3l_offZ_cut_75"] = 2.3;
	upperLimitsExpected["METStrong_2ltau_offZ_cut_0"] = 4.8;
	upperLimitsExpected["METStrong_2ltau_offZ_cut_50"] = 3.3;
	upperLimitsExpected["METStrong_2ltau_offZ_cut_75"] = 2.1;
	upperLimitsExpected["METStrong_3l_onZ_cut_20"] = 8.7;
	upperLimitsExpected["METStrong_3l_onZ_cut_50"] = 4.9;
	upperLimitsExpected["METStrong_3l_onZ_cut_75"] = 3.8;
	upperLimitsExpected["METStrong_2ltau_onZ_cut_20"] = 7.3;
	upperLimitsExpected["METStrong_2ltau_onZ_cut_50"] = 2.8;
	upperLimitsExpected["METStrong_2ltau_onZ_cut_75"] = 1.5;
	upperLimitsExpected["METWeak_3l_offZ_cut_0"] = 10.;
	upperLimitsExpected["METWeak_3l_offZ_cut_50"] = 4.7;
	upperLimitsExpected["METWeak_3l_offZ_cut_75"] = 3.0;
	upperLimitsExpected["METWeak_2ltau_offZ_cut_0"] = 21.;
	upperLimitsExpected["METWeak_2ltau_offZ_cut_50"] = 4.0;
	upperLimitsExpected["METWeak_2ltau_offZ_cut_75"] = 2.6;
	upperLimitsExpected["METWeak_3l_onZ_cut_20"] = 30.;
	upperLimitsExpected["METWeak_3l_onZ_cut_50"] = 10.;
	upperLimitsExpected["METWeak_3l_onZ_cut_75"] = 5.4;
	upperLimitsExpected["METWeak_2ltau_onZ_cut_20"] = 88.;
	upperLimitsExpected["METWeak_2ltau_onZ_cut_50"] = 5.5;
	upperLimitsExpected["METWeak_2ltau_onZ_cut_75"] = 2.2;
	upperLimitsExpected["Meff_3l_offZ_cut_0"] = 11.;
	upperLimitsExpected["Meff_3l_offZ_cut_150"] = 8.8;
	upperLimitsExpected["Meff_3l_offZ_cut_300"] = 3.7;
	upperLimitsExpected["Meff_3l_offZ_cut_500"] = 2.1;
	upperLimitsExpected["Meff_2ltau_offZ_cut_0"] = 23.;
	upperLimitsExpected["Meff_2ltau_offZ_cut_150"] = 13.;
	upperLimitsExpected["Meff_2ltau_offZ_cut_300"] = 4.9;
	upperLimitsExpected["Meff_2ltau_offZ_cut_500"] = 2.4;
	upperLimitsExpected["Meff_3l_onZ_cut_0"] = 33.;
	upperLimitsExpected["Meff_3l_onZ_cut_150"] = 25.;
	upperLimitsExpected["Meff_3l_onZ_cut_300"] = 9.;
	upperLimitsExpected["Meff_3l_onZ_cut_500"] = 3.9;
	upperLimitsExpected["Meff_2ltau_onZ_cut_0"] = 94.;
	upperLimitsExpected["Meff_2ltau_onZ_cut_150"] = 35.;
	upperLimitsExpected["Meff_2ltau_onZ_cut_300"] = 6.8;
	upperLimitsExpected["Meff_2ltau_onZ_cut_500"] = 2.5;
	upperLimitsExpected["MeffStrong_3l_offZ_cut_0"] = 3.9;
	upperLimitsExpected["MeffStrong_3l_offZ_cut_150"] = 3.9;
	upperLimitsExpected["MeffStrong_3l_offZ_cut_300"] = 3.0;
	upperLimitsExpected["MeffStrong_3l_offZ_cut_500"] = 2.0;
	upperLimitsExpected["MeffStrong_2ltau_offZ_cut_0"] = 3.8;
	upperLimitsExpected["MeffStrong_2ltau_offZ_cut_150"] = 3.9;
	upperLimitsExpected["MeffStrong_2ltau_offZ_cut_300"] = 3.1;
	upperLimitsExpected["MeffStrong_2ltau_offZ_cut_500"] = 1.6;
	upperLimitsExpected["MeffStrong_3l_onZ_cut_0"] = 6.9;
	upperLimitsExpected["MeffStrong_3l_onZ_cut_150"] = 7.1;
	upperLimitsExpected["MeffStrong_3l_onZ_cut_300"] = 4.9;
	upperLimitsExpected["MeffStrong_3l_onZ_cut_500"] = 3.0;
	upperLimitsExpected["MeffStrong_2ltau_onZ_cut_0"] = 2.4;
	upperLimitsExpected["MeffStrong_2ltau_onZ_cut_150"] = 2.5;
	upperLimitsExpected["MeffStrong_2ltau_onZ_cut_300"] = 2.0;
	upperLimitsExpected["MeffStrong_2ltau_onZ_cut_500"] = 1.1;

	if (observed) return upperLimitsObserved[signal_region];
	else return upperLimitsExpected[signal_region];
	}


	/// Function checking if there is an OSSF lepton pair or a combination of 3 leptons with an invariant mass close to the Z mass
	/// @todo Should the reference Z mass be 91.2?
	int isonZ (const Particles& particles) {
	int onZ = 0;
	double best_mass_2 = 999.;
	double best_mass_3 = 999.;

	// Loop over all 2 particle combinations to find invariant mass of OSSF pair closest to Z mass
	foreach ( const Particle& p1, particles ) {
	foreach ( const Particle& p2, particles ) {
	double mass_difference_2_old = fabs(91.0 - best_mass_2);
	double mass_difference_2_new = fabs(91.0 - (p1.momentum() + p2.momentum()).mass()/GeV);

	// If particle combination is OSSF pair calculate mass difference to Z mass
	if ( (p1.pid()p2.pid() == -121 \|\| p1.pid()p2.pid() == -169) ) {

	// Get invariant mass closest to Z mass
	if (mass_difference_2_new < mass_difference_2_old)
	best_mass_2 = (p1.momentum() + p2.momentum()).mass()/GeV;

	// In case there is an OSSF pair take also 3rd lepton into account (e.g. from FSR and photon to electron conversion)
	foreach ( const Particle & p3 , particles ) {
	double mass_difference_3_old = fabs(91.0 - best_mass_3);
	double mass_difference_3_new = fabs(91.0 - (p1.momentum() + p2.momentum() + p3.momentum()).mass()/GeV);
	if (mass_difference_3_new < mass_difference_3_old)
	best_mass_3 = (p1.momentum() + p2.momentum() + p3.momentum()).mass()/GeV;
	}
	}
	}
	}

	// Pick the minimum invariant mass of the best OSSF pair combination and the best 3 lepton combination
	// If this mass is in a 20 GeV window around the Z mass, the event is classified as onZ
	double best_mass = min(best_mass_2, best_mass_3);
	if (fabs(91.0 - best_mass) < 20) onZ = 1;
	return onZ;
	}

	//@}


	private:

	/// Histograms
	//@{
	Histo1DPtr _h_HTlep_all, _h_HTjets_all, _h_MET_all, _h_Meff_all;
	Histo1DPtr _h_pt_1_3l, _h_pt_2_3l, _h_pt_3_3l, _h_pt_1_2ltau, _h_pt_2_2ltau, _h_pt_3_2ltau;
	Histo1DPtr _h_e_n, _h_mu_n, _h_tau_n;
	Histo1DPtr _h_excluded;
	//@}

	/// Fiducial efficiencies to model the effects of the ATLAS detector
	bool _use_fiducial_lepton_efficiency;

	/// List of signal regions and event counts per signal region
	vector<string> _signal_regions;
	map<string, double> _eventCountsPerSR;

	};



	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1204447);

	}
	diff --git a/src/Analyses/ATLAS_2012_I1204784.cc b/src/Analyses/ATLAS_2012_I1204784.cc
	--- a/src/Analyses/ATLAS_2012_I1204784.cc
	+++ b/src/Analyses/ATLAS_2012_I1204784.cc
	@@ -1,146 +1,146 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {




	/// ATLAS Z phi* measurement
	class ATLAS_2012_I1204784 : public Analysis {
	public:

	/// Constructor
	ATLAS_2012_I1204784()
	: Analysis("ATLAS_2012_I1204784")
	{ }


	public:

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs;
	Cut cuts = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;
	ZFinder zfinder_dressed_el(fs, cuts, PID::ELECTRON, 66GeV, 116GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_dressed_el, "ZFinder_dressed_el");
	+ declare(zfinder_dressed_el, "ZFinder_dressed_el");
	ZFinder zfinder_bare_el(fs, cuts, PID::ELECTRON, 66GeV, 116GeV, 0.0, ZFinder::NOCLUSTER);
	- addProjection(zfinder_bare_el, "ZFinder_bare_el");
	+ declare(zfinder_bare_el, "ZFinder_bare_el");
	ZFinder zfinder_dressed_mu(fs, cuts, PID::MUON, 66GeV, 116GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder_dressed_mu, "ZFinder_dressed_mu");
	+ declare(zfinder_dressed_mu, "ZFinder_dressed_mu");
	ZFinder zfinder_bare_mu(fs, cuts, PID::MUON, 66GeV, 116GeV, 0.0, ZFinder::NOCLUSTER);
	- addProjection(zfinder_bare_mu, "ZFinder_bare_mu");
	+ declare(zfinder_bare_mu, "ZFinder_bare_mu");

	// Book histograms
	// Single-differential plots
	_hist_zphistar_el_bare = bookHisto1D(1, 1, 1);
	_hist_zphistar_mu_bare = bookHisto1D(1, 1, 2);
	_hist_zphistar_el_dressed = bookHisto1D(2, 1, 1);
	_hist_zphistar_mu_dressed = bookHisto1D(2, 1, 2);

	// Double-differential plots
	_h_phistar_el_bare.addHistogram(0.0, 0.8, bookHisto1D(3, 1, 1));
	_h_phistar_el_bare.addHistogram(0.8, 1.6, bookHisto1D(3, 1, 2));
	_h_phistar_el_bare.addHistogram(1.6, 10.0, bookHisto1D(3, 1, 3));

	_h_phistar_el_dressed.addHistogram(0.0, 0.8, bookHisto1D(3, 2, 1));
	_h_phistar_el_dressed.addHistogram(0.8, 1.6, bookHisto1D(3, 2, 2));
	_h_phistar_el_dressed.addHistogram(1.6, 10.0, bookHisto1D(3, 2, 3));

	_h_phistar_mu_bare.addHistogram(0.0, 0.8, bookHisto1D(4, 1, 1));
	_h_phistar_mu_bare.addHistogram(0.8, 1.6, bookHisto1D(4, 1, 2));
	_h_phistar_mu_bare.addHistogram(1.6, 10.0, bookHisto1D(4, 1, 3));

	_h_phistar_mu_dressed.addHistogram(0.0, 0.8, bookHisto1D(4, 2, 1));
	_h_phistar_mu_dressed.addHistogram(0.8, 1.6, bookHisto1D(4, 2, 2));
	_h_phistar_mu_dressed.addHistogram(1.6, 10.0, bookHisto1D(4, 2, 3));
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ZFinder& zfinder_dressed_el = applyProjection<ZFinder>(event, "ZFinder_dressed_el");
	- const ZFinder& zfinder_bare_el = applyProjection<ZFinder>(event, "ZFinder_bare_el");
	- const ZFinder& zfinder_dressed_mu = applyProjection<ZFinder>(event, "ZFinder_dressed_mu");
	- const ZFinder& zfinder_bare_mu = applyProjection<ZFinder>(event, "ZFinder_bare_mu");
	+ const ZFinder& zfinder_dressed_el = apply<ZFinder>(event, "ZFinder_dressed_el");
	+ const ZFinder& zfinder_bare_el = apply<ZFinder>(event, "ZFinder_bare_el");
	+ const ZFinder& zfinder_dressed_mu = apply<ZFinder>(event, "ZFinder_dressed_mu");
	+ const ZFinder& zfinder_bare_mu = apply<ZFinder>(event, "ZFinder_bare_mu");

	fillPlots(zfinder_dressed_el, _hist_zphistar_el_dressed, _h_phistar_el_dressed, weight);
	fillPlots(zfinder_bare_el, _hist_zphistar_el_bare, _h_phistar_el_bare, weight);
	fillPlots(zfinder_dressed_mu, _hist_zphistar_mu_dressed, _h_phistar_mu_dressed, weight);
	fillPlots(zfinder_bare_mu, _hist_zphistar_mu_bare, _h_phistar_mu_bare, weight);
	}


	void fillPlots(const ZFinder& zfind, Histo1DPtr hist, BinnedHistogram<double>& binnedHist, double weight) {
	if (zfind.bosons().size() != 1) return;
	Particles leptons = zfind.constituents(cmpMomByPt);

	const FourMomentum lminus = leptons[0].charge() < 0 ? leptons[0].momentum() : leptons[1].momentum();
	const FourMomentum lplus = leptons[0].charge() < 0 ? leptons[1].momentum() : leptons[0].momentum();

	const double phi_acop = M_PI - deltaPhi(lminus, lplus);
	const double costhetastar = tanh((lminus.eta()-lplus.eta())/2.0);
	const double sin2thetastar = (costhetastar <= 1) ? 1.0 - sqr(costhetastar) : 0;
	const double phistar = tan(phi_acop/2.0) * sqrt(sin2thetastar);
	hist->fill(phistar, weight);

	binnedHist.fill(zfind.bosons()[0].absrap(), phistar, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	normalize(_hist_zphistar_el_dressed);
	normalize(_hist_zphistar_el_bare);
	normalize(_hist_zphistar_mu_dressed);
	normalize(_hist_zphistar_mu_bare);

	foreach (Histo1DPtr hist, _h_phistar_mu_dressed.getHistograms()) { normalize(hist); }
	foreach (Histo1DPtr hist, _h_phistar_mu_bare.getHistograms()) { normalize(hist); }
	foreach (Histo1DPtr hist, _h_phistar_el_bare.getHistograms()) { normalize(hist); }
	foreach (Histo1DPtr hist, _h_phistar_el_dressed.getHistograms()) { normalize(hist); }
	}

	//@}


	private:

	BinnedHistogram<double> _h_phistar_mu_dressed;
	BinnedHistogram<double> _h_phistar_mu_bare;
	BinnedHistogram<double> _h_phistar_el_dressed;
	BinnedHistogram<double> _h_phistar_el_bare;

	Histo1DPtr _hist_zphistar_el_dressed;
	Histo1DPtr _hist_zphistar_el_bare;

	Histo1DPtr _hist_zphistar_mu_dressed;
	Histo1DPtr _hist_zphistar_mu_bare;

	Histo1DPtr _hist_zphistar_el_bare_1;
	Histo1DPtr _hist_zphistar_el_bare_2;
	Histo1DPtr _hist_zphistar_el_bare_3;

	Histo1DPtr _hist_zphistar_el_dressed_1;
	Histo1DPtr _hist_zphistar_el_dressed_2;
	Histo1DPtr _hist_zphistar_el_dressed_3;

	Histo1DPtr _hist_zphistar_mu_bare_1;
	Histo1DPtr _hist_zphistar_mu_bare_2;
	Histo1DPtr _hist_zphistar_mu_bare_3;

	Histo1DPtr _hist_zphistar_mu_dressed_1;
	Histo1DPtr _hist_zphistar_mu_dressed_2;
	Histo1DPtr _hist_zphistar_mu_dressed_3;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I1204784);

	}
	diff --git a/src/Analyses/ATLAS_2012_I943401.cc b/src/Analyses/ATLAS_2012_I943401.cc
	--- a/src/Analyses/ATLAS_2012_I943401.cc
	+++ b/src/Analyses/ATLAS_2012_I943401.cc
	@@ -1,457 +1,457 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	class ATLAS_2012_I943401 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor

	ATLAS_2012_I943401()
	: Analysis("ATLAS_2012_I943401")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// projection to find the electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// projection to find the muons
	IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");

	// jet finder
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// all tracks (to do deltaR with leptons)
	- addProjection(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");
	+ declare(ChargedFinalState(Cuts::abseta < 3 && Cuts::pT > 0.5*GeV), "cfs");

	// for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.5), "vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.5), "vfs");

	// book histograms

	// counts in signal regions
	_count_OS_SR1 = bookHisto1D("count_OS_SR1", 1, 0., 1.);
	_count_OS_SR2 = bookHisto1D("count_OS_SR2", 1, 0., 1.);
	_count_OS_SR3 = bookHisto1D("count_OS_SR3", 1, 0., 1.);
	_count_SS_SR1 = bookHisto1D("count_SS_SR1", 1, 0., 1.);
	_count_SS_SR2 = bookHisto1D("count_SS_SR2", 1, 0., 1.);
	_count_FS_SR1 = bookHisto1D("count_FS_SR1", 1, 0., 1.);
	_count_FS_SR2 = bookHisto1D("count_FS_SR2", 1, 0., 1.);
	_count_FS_SR3 = bookHisto1D("count_FS_SR3", 1, 0., 1.);

	// histograms from paper

	_hist_mll_SS_D = bookHisto1D( 1,1,1);
	_hist_mll_SS_B = bookHisto1D( 1,1,2);
	_hist_eTmiss_SS_D = bookHisto1D( 2,1,1);
	_hist_eTmiss_SS_B = bookHisto1D( 2,1,2);
	_hist_mll_SS_2Jet_D = bookHisto1D( 3,1,1);
	_hist_mll_SS_2Jet_B = bookHisto1D( 3,1,2);
	_hist_njet_SS_D = bookHisto1D( 5,1,1);
	_hist_njet_SS_B = bookHisto1D( 5,1,2);
	_hist_pT_j1_SS_D = bookHisto1D( 6,1,1);
	_hist_pT_j1_SS_B = bookHisto1D( 6,1,2);
	_hist_pT_j2_SS_D = bookHisto1D( 7,1,1);
	_hist_pT_j2_SS_B = bookHisto1D( 7,1,2);
	_hist_pT_l1_SS_D = bookHisto1D( 8,1,1);
	_hist_pT_l1_SS_B = bookHisto1D( 8,1,2);
	_hist_pT_l2_SS_D = bookHisto1D( 9,1,1);
	_hist_pT_l2_SS_B = bookHisto1D( 9,1,2);
	_hist_mll_OS_D = bookHisto1D(10,1,1);
	_hist_mll_OS_B = bookHisto1D(10,1,2);
	_hist_eTmiss_OS_D = bookHisto1D(11,1,1);
	_hist_eTmiss_OS_B = bookHisto1D(11,1,2);
	_hist_eTmiss_3Jet_OS_D = bookHisto1D(12,1,1);
	_hist_eTmiss_3Jet_OS_B = bookHisto1D(12,1,2);
	_hist_eTmiss_4Jet_OS_D = bookHisto1D(13,1,1);
	_hist_eTmiss_4Jet_OS_B = bookHisto1D(13,1,2);
	_hist_njet_OS_D = bookHisto1D(14,1,1);
	_hist_njet_OS_B = bookHisto1D(14,1,2);
	_hist_pT_j1_OS_D = bookHisto1D(15,1,1);
	_hist_pT_j1_OS_B = bookHisto1D(15,1,2);
	_hist_pT_j2_OS_D = bookHisto1D(16,1,1);
	_hist_pT_j2_OS_B = bookHisto1D(16,1,2);
	_hist_pT_l1_OS_D = bookHisto1D(17,1,1);
	_hist_pT_l1_OS_B = bookHisto1D(17,1,2);
	_hist_pT_l2_OS_D = bookHisto1D(18,1,1);
	_hist_pT_l2_OS_B = bookHisto1D(18,1,2);
	//????
	// <dataPointSet name="d04-x01-y01" dimension="2" path="/REF/ATLAS_2011_I943401" title="EVENTS/10 GEV" >
	// <dataPointSet name="d04-x01-y02" dimension="2" path="/REF/ATLAS_2011_I943401" title="EVENTS/10 GEV" >
	}

	/// Perform the event analysis
	void analyze(const Event& event) {
	// event weight
	const double weight = event.weight();

	// get the jet candidates
	Jets cand_jets;
	foreach (const Jet& jet,
	- applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	+ apply<FastJets>(event, "AntiKtJets04").jetsByPt(20.0*GeV) ) {
	if ( fabs( jet.eta() ) < 2.8 ) {
	cand_jets.push_back(jet);
	}
	}

	// electron candidates
	Particles cand_e =
	- applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "elecs").particlesByPt();

	// Discard jets that overlap with electrons
	Jets recon_jets;
	foreach ( const Jet& jet, cand_jets ) {
	bool away_from_e = true;
	foreach ( const Particle& e, cand_e ) {
	if ( deltaR(e.momentum(),jet.momentum()) <= 0.2 ) {
	away_from_e = false;
	break;
	}
	}
	if ( away_from_e ) recon_jets.push_back( jet );
	}
	// get the charged tracks for isolation
	Particles chg_tracks =
	- applyProjection<ChargedFinalState>(event, "cfs").particles();
	+ apply<ChargedFinalState>(event, "cfs").particles();

	// Reconstructed electrons
	Particles recon_e;
	foreach ( const Particle& e, cand_e ) {
	// check not near a jet
	bool e_near_jet = false;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(e.momentum(),jet.momentum()) < 0.4 ) {
	e_near_jet = true;
	break;
	}
	}
	if ( e_near_jet ) continue;
	// check the isolation
	double pTinCone = -e.pT();
	foreach ( const Particle& track, chg_tracks ) {
	if ( deltaR(e.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 0.1*e.perp() )
	recon_e.push_back(e);
	}

	// Reconstructed Muons
	Particles recon_mu;
	Particles cand_mu =
	- applyProjection<IdentifiedFinalState>(event,"muons").particlesByPt();
	+ apply<IdentifiedFinalState>(event,"muons").particlesByPt();
	foreach ( const Particle& mu, cand_mu ) {
	// check not near a jet
	bool mu_near_jet = false;
	foreach ( const Jet& jet, recon_jets ) {
	if ( deltaR(mu.momentum(),jet.momentum()) < 0.4 ) {
	mu_near_jet = true;
	break;
	}
	}
	if ( mu_near_jet ) continue;
	// isolation
	double pTinCone = -mu.pT();
	foreach ( const Particle& track, chg_tracks ) {
	if ( deltaR(mu.momentum(),track.momentum()) < 0.2 )
	pTinCone += track.pT();
	}
	if ( pTinCone < 1.8*GeV )
	recon_mu.push_back(mu);
	}

	// pTmiss
	Particles vfs_particles
	- = applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ = apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle& p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	// ATLAS calo problem
	if(rand()/static_cast<double>(RAND_MAX)<=0.42) {
	foreach ( const Particle& e, recon_e ) {
	double eta = e.eta();
	double phi = e.azimuthalAngle(MINUSPI_PLUSPI);
	if (inRange(eta, -0.1, 1.5) && inRange(phi, -0.9, -0.5)) vetoEvent;
	}
	foreach ( const Jet& jet, recon_jets ) {
	double eta = jet.rapidity();
	double phi = jet.azimuthalAngle(MINUSPI_PLUSPI);
	if (jet.pT() > 40*GeV && inRange(eta, -0.1, 1.5) && inRange(phi, -0.9, -0.5)) vetoEvent;
	}
	}

	// Exactly two leptons for each event
	if ( recon_mu.size() + recon_e.size() != 2) vetoEvent;
	// two electrons highest pT > 25
	Particles recon_leptons;
	if (recon_e.size()==2 && recon_e[0].pT()>25*GeV) {
	recon_leptons = recon_e;
	}
	// two muons highest pT > 20
	else if (recon_mu.size()==2 && recon_mu[0].pT() > 20*GeV) {
	recon_leptons = recon_mu;
	} else if (recon_e.size()==1 && recon_mu.size()==1 &&
	(recon_e[0].pT() > 25GeV \|\| recon_mu[0].pT() > 20GeV )) {
	if (recon_mu[0].pT() < recon_e[0].pT()) {
	recon_leptons.push_back(recon_e [0]);
	recon_leptons.push_back(recon_mu[0]);
	} else {
	recon_leptons.push_back(recon_mu[0]);
	recon_leptons.push_back(recon_e [0]);
	}
	}
	// fails trigger
	else vetoEvent;

	double mll = (recon_leptons[0].momentum()+recon_leptons[1].momentum()).mass();
	// lepton pair mass > 12.
	if (mll < 12*GeV) vetoEvent;

	// same sign or opposite sign event
	int sign = recon_leptons[0].pid()*recon_leptons[1].pid();

	// same sign leptons
	if(sign>0) {
	_hist_mll_SS_D ->fill(mll ,weight);
	_hist_mll_SS_B ->fill(mll ,weight);
	_hist_eTmiss_SS_D->fill(eTmiss,weight);
	_hist_eTmiss_SS_B->fill(eTmiss,weight);
	if(recon_jets.size()>=2) {
	_hist_mll_SS_2Jet_D ->fill(mll ,weight);
	_hist_mll_SS_2Jet_B ->fill(mll ,weight);
	}
	_hist_njet_SS_D ->fill(recon_jets.size(),weight);
	_hist_njet_SS_B ->fill(recon_jets.size(),weight);
	if(!recon_jets.empty()) {
	_hist_pT_j1_SS_D->fill(recon_jets[0].perp(),weight);
	_hist_pT_j1_SS_B->fill(recon_jets[0].perp(),weight);
	}
	if(recon_jets.size()>2) {
	_hist_pT_j2_SS_D->fill(recon_jets[1].perp(),weight);
	_hist_pT_j2_SS_B->fill(recon_jets[1].perp(),weight);
	}
	_hist_pT_l1_SS_D->fill(recon_leptons[0].perp(),weight);
	_hist_pT_l1_SS_B->fill(recon_leptons[0].perp(),weight);
	_hist_pT_l2_SS_D->fill(recon_leptons[1].perp(),weight);
	_hist_pT_l2_SS_B->fill(recon_leptons[1].perp(),weight);
	// SS-SR1
	if(eTmiss>100.) {
	_count_SS_SR1->fill(0.5,weight);
	}
	// SS-SR2
	if(eTmiss>80. && recon_jets.size()>=2 &&
	recon_jets[1].perp()>50.) {
	_count_SS_SR2->fill(0.5,weight);
	}
	}
	// opposite sign
	else {
	_hist_mll_OS_D->fill(mll ,weight);
	_hist_mll_OS_B->fill(mll ,weight);
	_hist_eTmiss_OS_D->fill(eTmiss,weight);
	_hist_eTmiss_OS_B->fill(eTmiss,weight);
	if(recon_jets.size()>=3){
	_hist_eTmiss_3Jet_OS_D->fill(eTmiss,weight);
	_hist_eTmiss_3Jet_OS_B->fill(eTmiss,weight);
	}
	if(recon_jets.size()>=4){
	_hist_eTmiss_4Jet_OS_D->fill(eTmiss,weight);
	_hist_eTmiss_4Jet_OS_B->fill(eTmiss,weight);
	}
	_hist_njet_OS_D->fill(recon_jets.size(),weight);
	_hist_njet_OS_B->fill(recon_jets.size(),weight);
	if(!recon_jets.empty()) {
	_hist_pT_j1_OS_D->fill(recon_jets[0].perp(),weight);
	_hist_pT_j1_OS_B->fill(recon_jets[0].perp(),weight);
	}
	if(recon_jets.size()>2) {
	_hist_pT_j2_OS_D->fill(recon_jets[1].perp(),weight);
	_hist_pT_j2_OS_B->fill(recon_jets[1].perp(),weight);
	}
	_hist_pT_l1_OS_D->fill(recon_leptons[0].perp(),weight);
	_hist_pT_l1_OS_B->fill(recon_leptons[0].perp(),weight);
	_hist_pT_l2_OS_D->fill(recon_leptons[1].perp(),weight);
	_hist_pT_l2_OS_B->fill(recon_leptons[1].perp(),weight);
	// different signal regions
	// OS-SR1
	if(eTmiss>250.) {
	_count_OS_SR1->fill(0.5,weight);
	}
	// OS-SR2
	if(eTmiss>220. && recon_jets.size()>=3 &&
	recon_jets[0].perp()>80. &&
	recon_jets[2].perp()>40.) {
	_count_OS_SR2->fill(0.5,weight);
	}
	// OS-SR3
	if(eTmiss>100. && recon_jets.size()>=4 &&
	recon_jets[0].perp()>100. &&
	recon_jets[3].perp()>70.) {
	_count_OS_SR3->fill(0.5,weight);
	}
	// same flavour analysis
	static const double beta = 0.75;
	static const double tau_e = 0.96;
	static const double tau_mu = 0.816;
	double fs_weight = weight;
	if (recon_leptons[0].abspid() == PID::ELECTRON && recon_leptons[1].abspid() == PID::ELECTRON) {
	fs_weight /= beta*(1.-sqr(1.-tau_e));
	} else if (recon_leptons[0].abspid() == PID::MUON && recon_leptons[1].abspid()==PID::MUON) {
	fs_weight *= beta/(1.-sqr(1.-tau_mu));
	} else {
	fs_weight /= -(1.-(1.-tau_e)*(1.-tau_mu));
	}
	// FS-SR1
	if(eTmiss>80.&& (mll<80.\|\|mll>100.)) {
	_count_FS_SR1->fill(0.5,fs_weight);
	}
	// FS-SR2
	if(eTmiss>80.&&recon_jets.size()>=2) {
	_count_FS_SR2->fill(0.5,fs_weight);
	}
	// FS-SR3
	if(eTmiss>250.) {
	_count_FS_SR3->fill(0.5,fs_weight);
	}
	}
	}

	//@}


	void finalize() {

	double norm = crossSection()/femtobarn*1.04/sumOfWeights();
	// event counts
	scale(_count_OS_SR1,norm);
	scale(_count_OS_SR2,norm);
	scale(_count_OS_SR3,norm);
	scale(_count_SS_SR1,norm);
	scale(_count_SS_SR2,norm);
	scale(_count_FS_SR1,norm);
	scale(_count_FS_SR2,norm);
	scale(_count_FS_SR3,norm);
	// histograms
	scale(_hist_mll_SS_D ,norm*20.);
	scale(_hist_mll_SS_B ,norm*20.);
	scale(_hist_eTmiss_SS_D ,norm*20.);
	scale(_hist_eTmiss_SS_B ,norm*20.);
	scale(_hist_mll_SS_2Jet_D,norm*50.);
	scale(_hist_mll_SS_2Jet_B,norm*50.);
	scale(_hist_njet_SS_D ,norm );
	scale(_hist_njet_SS_B ,norm );
	scale(_hist_pT_j1_SS_D ,norm*20.);
	scale(_hist_pT_j1_SS_B ,norm*20.);
	scale(_hist_pT_j2_SS_D ,norm*20.);
	scale(_hist_pT_j2_SS_B ,norm*20.);
	scale(_hist_pT_l1_SS_D ,norm*5. );
	scale(_hist_pT_l1_SS_B ,norm*5. );
	scale(_hist_pT_l2_SS_D ,norm*5. );
	scale(_hist_pT_l2_SS_B ,norm*5. );

	scale(_hist_mll_OS_D ,norm*10.);
	scale(_hist_mll_OS_B ,norm*10.);
	scale(_hist_eTmiss_OS_D ,norm*10.);
	scale(_hist_eTmiss_OS_B ,norm*10.);
	scale(_hist_eTmiss_3Jet_OS_D,norm*10.);
	scale(_hist_eTmiss_3Jet_OS_B,norm*10.);
	scale(_hist_eTmiss_4Jet_OS_D,norm*10.);
	scale(_hist_eTmiss_4Jet_OS_B,norm*10.);
	scale(_hist_njet_OS_D ,norm );
	scale(_hist_njet_OS_B ,norm );
	scale(_hist_pT_j1_OS_D ,norm*20.);
	scale(_hist_pT_j1_OS_B ,norm*20.);
	scale(_hist_pT_j2_OS_D ,norm*20.);
	scale(_hist_pT_j2_OS_B ,norm*20.);
	scale(_hist_pT_l1_OS_D ,norm*20.);
	scale(_hist_pT_l1_OS_B ,norm*20.);
	scale(_hist_pT_l2_OS_D ,norm*20.);
	scale(_hist_pT_l2_OS_B ,norm*20.);
	}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _count_OS_SR1;
	Histo1DPtr _count_OS_SR2;
	Histo1DPtr _count_OS_SR3;
	Histo1DPtr _count_SS_SR1;
	Histo1DPtr _count_SS_SR2;
	Histo1DPtr _count_FS_SR1;
	Histo1DPtr _count_FS_SR2;
	Histo1DPtr _count_FS_SR3;

	Histo1DPtr _hist_mll_SS_D;
	Histo1DPtr _hist_mll_SS_B;
	Histo1DPtr _hist_eTmiss_SS_D;
	Histo1DPtr _hist_eTmiss_SS_B;
	Histo1DPtr _hist_mll_SS_2Jet_D;
	Histo1DPtr _hist_mll_SS_2Jet_B;
	Histo1DPtr _hist_njet_SS_D;
	Histo1DPtr _hist_njet_SS_B;
	Histo1DPtr _hist_pT_j1_SS_D;
	Histo1DPtr _hist_pT_j1_SS_B;
	Histo1DPtr _hist_pT_j2_SS_D;
	Histo1DPtr _hist_pT_j2_SS_B;
	Histo1DPtr _hist_pT_l1_SS_D;
	Histo1DPtr _hist_pT_l1_SS_B;
	Histo1DPtr _hist_pT_l2_SS_D;
	Histo1DPtr _hist_pT_l2_SS_B;

	Histo1DPtr _hist_mll_OS_D;
	Histo1DPtr _hist_mll_OS_B;
	Histo1DPtr _hist_eTmiss_OS_D;
	Histo1DPtr _hist_eTmiss_OS_B;
	Histo1DPtr _hist_eTmiss_3Jet_OS_D;
	Histo1DPtr _hist_eTmiss_3Jet_OS_B;
	Histo1DPtr _hist_eTmiss_4Jet_OS_D;
	Histo1DPtr _hist_eTmiss_4Jet_OS_B;
	Histo1DPtr _hist_njet_OS_D ;
	Histo1DPtr _hist_njet_OS_B ;
	Histo1DPtr _hist_pT_j1_OS_D;
	Histo1DPtr _hist_pT_j1_OS_B;
	Histo1DPtr _hist_pT_j2_OS_D;
	Histo1DPtr _hist_pT_j2_OS_B;
	Histo1DPtr _hist_pT_l1_OS_D;
	Histo1DPtr _hist_pT_l1_OS_B;
	Histo1DPtr _hist_pT_l2_OS_D;
	Histo1DPtr _hist_pT_l2_OS_B;
	//@}
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I943401);

	}
	diff --git a/src/Analyses/ATLAS_2012_I946427.cc b/src/Analyses/ATLAS_2012_I946427.cc
	--- a/src/Analyses/ATLAS_2012_I946427.cc
	+++ b/src/Analyses/ATLAS_2012_I946427.cc
	@@ -1,141 +1,141 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @author Peter Richardson
	class ATLAS_2012_I946427 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2012_I946427()
	: Analysis("ATLAS_2012_I946427")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// photons
	IdentifiedFinalState photonfs(Cuts::abseta < 1.81 && Cuts::pT > 25*GeV);
	photonfs.acceptId(PID::PHOTON);
	- addProjection(photonfs, "Photon");
	+ declare(photonfs, "Photon");

	//
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Used for pTmiss
	- addProjection(VisibleFinalState(Cuts::abseta < 4.9),"vfs");
	+ declare(VisibleFinalState(Cuts::abseta < 4.9),"vfs");

	// Book histograms
	_count_SR = bookHisto1D("count_SR", 1, 0., 1.);

	_hist_ET_photon = bookHisto1D("hist_ET_photon", 48 , 20., 500.);
	_hist_met = bookHisto1D("hist_met" , 100, 0., 500.);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	// require at least 2 photons in final state
	Particles photons =
	- applyProjection<IdentifiedFinalState>(event, "Photon").particlesByPt();
	+ apply<IdentifiedFinalState>(event, "Photon").particlesByPt();
	if (photons.size() < 2) {
	vetoEvent;
	}

	// Loop over photons and fill vector of isolated ones
	- Particles fs = applyProjection<FinalState>(event, "FS").particles();
	+ Particles fs = apply<FinalState>(event, "FS").particles();
	Particles isolated_photons;
	foreach (const Particle& photon, photons) {
	// remove photons in crack
	double eta_P = photon.eta();
	if (fabs(eta_P)>=1.37 && fabs(eta_P)<1.52) continue;

	double phi_P = photon.phi();

	FourMomentum mom_in_EtCone = -photon.momentum();
	foreach (const Particle& p, fs) {
	// check if it's in the cone of .2
	if (deltaR(eta_P, phi_P, p.eta(),
	p.phi()) >= 0.2) continue;
	mom_in_EtCone += p.momentum();
	}
	// apply isolation
	if(mom_in_EtCone.Et()>5.) continue;

	// add photon to list of isolated ones
	isolated_photons.push_back(photon);
	}

	// need two isolated photons
	if(isolated_photons.size() < 2 ) {
	vetoEvent;
	}

	// pTmiss
	Particles vfs_particles =
	- applyProjection<VisibleFinalState>(event, "vfs").particles();
	+ apply<VisibleFinalState>(event, "vfs").particles();
	FourMomentum pTmiss;
	foreach ( const Particle & p, vfs_particles ) {
	pTmiss -= p.momentum();
	}
	double eTmiss = pTmiss.pT();

	_hist_ET_photon->fill(isolated_photons[0].Et(),weight);
	_hist_met ->fill(eTmiss ,weight);

	if(eTmiss>125.) _count_SR->fill(0.5,weight);
	}


	void finalize() {

	double norm = crossSection()/femtobarn*1.07/sumOfWeights();
	// these are number of events at 1.07fb^-1 per 10 GeV
	scale( _hist_ET_photon, 10. * norm );
	// these are number of events at 1.07fb^-1 per 5 GeV
	scale( _hist_met, 5. * norm );
	// these are number of events at 1.07fb^-1
	scale(_count_SR,norm);
	}

	//@}


	private:

	Histo1DPtr _count_SR;
	Histo1DPtr _hist_ET_photon;
	Histo1DPtr _hist_met;

	};


	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2012_I946427);

	}
	diff --git a/src/Analyses/ATLAS_2013_I1190187.cc b/src/Analyses/ATLAS_2013_I1190187.cc
	--- a/src/Analyses/ATLAS_2013_I1190187.cc
	+++ b/src/Analyses/ATLAS_2013_I1190187.cc
	@@ -1,261 +1,261 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/MissingMomentum.hh"

	namespace Rivet {


	/// ATLAS Wee Wemu Wmumu analysis at Z TeV
	class ATLAS_2013_I1190187 : public Analysis {
	public:

	/// Default constructor
	ATLAS_2013_I1190187()
	: Analysis("ATLAS_2013_I1190187")
	{ }


	void init() {
	FinalState fs;

	Cut etaRanges_EL = (Cuts::abseta < 1.37 \|\| Cuts::absetaIn(1.52, 2.47)) && Cuts::pT > 20*GeV;
	Cut etaRanges_MU = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;

	MissingMomentum met(fs);
	- addProjection(met, "MET");
	+ declare(met, "MET");

	IdentifiedFinalState Photon(fs);
	Photon.acceptIdPair(PID::PHOTON);

	IdentifiedFinalState bare_EL(fs);
	bare_EL.acceptIdPair(PID::ELECTRON);

	IdentifiedFinalState bare_MU(fs);
	bare_MU.acceptIdPair(PID::MUON);

	IdentifiedFinalState neutrinoFS(fs);
	neutrinoFS.acceptNeutrinos();
	- addProjection(neutrinoFS, "Neutrinos");
	+ declare(neutrinoFS, "Neutrinos");

	////////////////////////////////////////////////////////
	// DRESSED LEPTONS
	// 3.arg: 0.1 = dR(lep,phot)
	// 4.arg: true = do clustering
	// 7.arg: false = ignore photons from hadron or tau
	//
	//////////////////////////////////////////////////////////
	DressedLeptons electronFS(Photon, bare_EL, 0.1, etaRanges_EL);
	- addProjection(electronFS, "ELECTRON_FS");
	+ declare(electronFS, "ELECTRON_FS");

	DressedLeptons muonFS(Photon, bare_MU, 0.1, etaRanges_MU);
	- addProjection(muonFS, "MUON_FS");
	+ declare(muonFS, "MUON_FS");

	VetoedFinalState jetinput;
	jetinput.addVetoOnThisFinalState(bare_MU);
	jetinput.addVetoOnThisFinalState(neutrinoFS);

	FastJets jetpro(jetinput, FastJets::ANTIKT, 0.4);
	- addProjection(jetpro, "jet");
	+ declare(jetpro, "jet");

	// Book histograms
	_h_Wl1_pT_mumu = bookHisto1D(1, 1, 2);
	_h_Wl1_pT_ee = bookHisto1D(1, 1, 1);
	_h_Wl1_pT_emu = bookHisto1D(1, 1, 3);
	_h_Wl1_pT_inclusive = bookHisto1D(4, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& e) {

	- const vector<DressedLepton>& muonFS = applyProjection<DressedLeptons>(e, "MUON_FS").dressedLeptons();
	- const vector<DressedLepton>& electronFS = applyProjection<DressedLeptons>(e, "ELECTRON_FS").dressedLeptons();
	- const MissingMomentum& met = applyProjection<MissingMomentum>(e, "MET");
	+ const vector<DressedLepton>& muonFS = apply<DressedLeptons>(e, "MUON_FS").dressedLeptons();
	+ const vector<DressedLepton>& electronFS = apply<DressedLeptons>(e, "ELECTRON_FS").dressedLeptons();
	+ const MissingMomentum& met = apply<MissingMomentum>(e, "MET");

	vector<DressedLepton> dressed_lepton, isolated_lepton, fiducial_lepton;
	dressed_lepton.insert(dressed_lepton.end(), muonFS.begin(), muonFS.end());
	dressed_lepton.insert(dressed_lepton.end(), electronFS.begin(), electronFS.end());

	////////////////////////////////////////////////////////////////////////////
	// OVERLAP REMOVAL
	// -electrons with dR(e,mu)<0.1 are removed
	// -lower pT electrons with dR(e,e)<0.1 are removed
	//
	////////////////////////////////////////////////////////////////////////////
	foreach (DressedLepton& l1, dressed_lepton) {
	bool l_isolated = true;
	foreach (DressedLepton& l2, dressed_lepton) {
	if (l1 != l2 && l2.constituentLepton().abspid() == PID::ELECTRON) {
	double overlapControl_ll= deltaR(l1.constituentLepton(),l2.constituentLepton());
	if (overlapControl_ll < 0.1) {
	l_isolated = false;
	// e/e overlap removal
	if (l1.constituentLepton().abspid() == PID::ELECTRON) {
	if (l1.constituentLepton().pT()>l2.constituentLepton().pT()) {
	isolated_lepton.push_back(l1);//keep e with highest pT
	} else {
	isolated_lepton.push_back(l2);//keep e with highest pT
	}
	}
	// e/mu overlap removal
	if (l1.constituentLepton().abspid() == PID::MUON) isolated_lepton.push_back(l1); //keep mu
	}
	}
	}
	if (l_isolated) isolated_lepton.push_back(l1);
	}


	///////////////////////////////////////////////////////////////////////////////////////////////////////////
	// PRESELECTION:
	// "isolated_lepton:"
	// * electron: pt>20 GeV, \|eta\|<1.37, 1.52<\|eta\|<2.47, dR(electron,muon)>0.1
	// * muon: pt>20 GeV, \|eta\|<2.4
	// * dR(l,l)>0.1
	//
	// "fiducial_lepton"= isolated_lepton with
	// * 2 leptons (e or mu)
	// * leading lepton pt (pT_l1) >25 GeV
	// * opposite charged leptons
	//
	///////////////////////////////////////////////////////////////////////////////////////////////////////////
	if (isolated_lepton.size() != 2) vetoEvent;
	sort(isolated_lepton.begin(), isolated_lepton.end(), cmpMomByPt);
	if (isolated_lepton[0].pT() > 25*GeV && threeCharge(isolated_lepton[0]) != threeCharge(isolated_lepton[1])) {
	fiducial_lepton.insert(fiducial_lepton.end(), isolated_lepton.begin(), isolated_lepton.end());
	}
	if (fiducial_lepton.size() == 0) vetoEvent;
	double pT_l1 = fiducial_lepton[0].pT();
	double M_l1l2 = (fiducial_lepton[0].momentum() + fiducial_lepton[1].momentum()).mass();
	double pT_l1l2 = (fiducial_lepton[0].momentum() + fiducial_lepton[1].momentum()).pT();


	/////////////////////////////////////////////////////////////////////////
	// JETS
	// -"alljets": found by "jetpro" projection && pT()>25 GeV && \|y\|<4.5
	// -"vetojets": "alljets" && dR(electron,jet)>0.3
	//
	/////////////////////////////////////////////////////////////////////////
	Jets alljets, vetojets;
	- foreach (const Jet& j, applyProjection<FastJets>(e, "jet").jetsByPt(25)) {
	+ foreach (const Jet& j, apply<FastJets>(e, "jet").jetsByPt(25)) {
	if (j.absrap() > 4.5 ) continue;
	alljets.push_back(j);
	bool deltaRcontrol = true;
	foreach (DressedLepton& fl,fiducial_lepton) {
	if (fl.constituentLepton().abspid() == PID::ELECTRON) { //electrons
	double deltaRjets = deltaR(fl.constituentLepton().momentum(), j.momentum(), RAPIDITY);
	if (deltaRjets <= 0.3) deltaRcontrol = false; //false if at least one electron is in the overlap region
	}
	}
	if (deltaRcontrol) vetojets.push_back(j);
	}


	/////////////////////////////////////////////////////////////////////////////////////////////////
	// MISSING ETrel
	// -"mismom": fourvector of invisible momentum found by "met" projection
	// -"delta_phi": delta phi between mismom and the nearest "fiducial_lepton" or "vetojet"
	// -"MET_rel": missing transverse energy defined as:
	// "mismom" for "delta_phi" >= (0.5pi)
	// "mismom.pT()sin(delta_phi)" for "delta_phi" < (0.5*pi)
	//
	/////////////////////////////////////////////////////////////////////////////////////////////////
	FourMomentum mismom;
	double MET_rel = 0, delta_phi = 0;
	mismom = -met.visibleMomentum();
	vector<double> vL_MET_angle, vJet_MET_angle;
	vL_MET_angle.push_back(fabs(deltaPhi(fiducial_lepton[0].momentum(), mismom)));
	vL_MET_angle.push_back(fabs(deltaPhi(fiducial_lepton[1].momentum(), mismom)));
	foreach (double& lM, vL_MET_angle) if (lM > M_PI) lM = 2*M_PI - lM;

	std::sort(vL_MET_angle.begin(), vL_MET_angle.end());
	if (vetojets.size() == 0) delta_phi = vL_MET_angle[0];
	if (vetojets.size() > 0) {
	foreach (Jet& vj, vetojets) {
	double jet_MET_angle = fabs(deltaPhi(vj.momentum(), mismom));
	if (jet_MET_angle > M_PI) jet_MET_angle = 2*M_PI - jet_MET_angle;
	vJet_MET_angle.push_back(jet_MET_angle);
	}
	std::sort(vJet_MET_angle.begin(), vJet_MET_angle.end());
	if (vL_MET_angle[0] <= vJet_MET_angle[0]) delta_phi = vL_MET_angle[0];
	if (vL_MET_angle[0] > vJet_MET_angle[0]) delta_phi = vJet_MET_angle[0];
	}

	if (delta_phi >= (0.5M_PI)) delta_phi = 0.5M_PI;
	MET_rel = mismom.pT()*sin(delta_phi);


	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// CUTS
	// -jetveto: event with at least one vetojet is vetoed
	// -M_Z: Z mass M_Z=91.1876*GeV
	//
	// * ee channel: MET_rel > 45 GeV, M_l1l2 > 15 GeV, \|M_l1l2-M_Z\| > 15 GeV, jetveto, pT_l1l2 > 30 GeV
	// * mumu channel: MET_rel > 45 GeV, M_l1l2 > 15 GeV, \|M_l1l2-M_Z\| > 15 GeV, jetveto, pT_l1l2 > 30 GeV
	// * emu channel: MET_rel > 25 GeV, M_l1l2 > 10 GeV, \|M_l1l2-M_Z\| > 0 GeV, jetveto, pT_l1l2 > 30 GeV
	//
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	// Get event weight for histo filling
	const double weight = e.weight();

	// ee channel
	if (fiducial_lepton[0].abspid() == PID::ELECTRON && fiducial_lepton[1].abspid() == PID::ELECTRON) {
	if (MET_rel <= 45*GeV) vetoEvent;
	if (M_l1l2 <= 15*GeV) vetoEvent;
	if (fabs(M_l1l2 - 91.1876GeV) <= 15GeV) vetoEvent;
	if (vetojets.size() != 0) vetoEvent;
	if (pT_l1l2 <= 30*GeV) vetoEvent;
	_h_Wl1_pT_ee->fill(sqrtS()*GeV, weight);
	_h_Wl1_pT_inclusive->fill(pT_l1, weight);
	}

	// mumu channel
	else if (fiducial_lepton[0].abspid() == PID::MUON && fiducial_lepton[1].abspid() == PID::MUON) {
	if (MET_rel <= 45*GeV) vetoEvent;
	if (M_l1l2 <= 15*GeV) vetoEvent;
	if (fabs(M_l1l2-91.1876GeV) <= 15GeV) vetoEvent;
	if (vetojets.size() != 0) vetoEvent;
	if (pT_l1l2 <= 30*GeV) vetoEvent;
	_h_Wl1_pT_mumu->fill(sqrtS()*GeV, weight);
	_h_Wl1_pT_inclusive->fill(pT_l1, weight);
	}

	// emu channel
	else if (fiducial_lepton[0].abspid() != fiducial_lepton[1].abspid()) {
	if (MET_rel <= 25*GeV) vetoEvent;
	if (M_l1l2 <= 10*GeV) vetoEvent;
	if (vetojets.size() != 0) vetoEvent;
	if (pT_l1l2 <= 30*GeV) vetoEvent;
	_h_Wl1_pT_emu->fill(sqrtS()*GeV, weight);
	_h_Wl1_pT_inclusive->fill(pT_l1, weight);
	}
	}


	/// Finalize
	void finalize() {
	const double norm = crossSection()/sumOfWeights()/femtobarn;
	scale(_h_Wl1_pT_ee, norm);
	scale(_h_Wl1_pT_mumu, norm);
	scale(_h_Wl1_pT_emu, norm);
	normalize(_h_Wl1_pT_inclusive, 1);
	}


	private:

	Histo1DPtr _h_Wl1_pT_ee, _h_Wl1_pT_mumu, _h_Wl1_pT_emu, _h_Wl1_pT_inclusive;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1190187);

	}
	diff --git a/src/Analyses/ATLAS_2013_I1216670.cc b/src/Analyses/ATLAS_2013_I1216670.cc
	--- a/src/Analyses/ATLAS_2013_I1216670.cc
	+++ b/src/Analyses/ATLAS_2013_I1216670.cc
	@@ -1,122 +1,122 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {

	/// @brief MPI sensitive di-jet balance variables for W->ejj or W->mujj events.
	class ATLAS_2013_I1216670 : public Analysis {
	public:

	/// @name Constructor
	ATLAS_2013_I1216670()
	: Analysis("ATLAS_2013_I1216670")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms, set up projections for W and jets
	void init() {

	_h_delta_jets_n = bookHisto1D(1, 1, 1);
	_h_delta_jets = bookHisto1D(2, 1, 1);

	FinalState fs;

	Cut cuts = Cuts::abseta < 2.5 && Cuts::pT >= 20*GeV;

	WFinder w_e_finder(fs, cuts, PID::ELECTRON, 40GeV, MAXDOUBLE, 0.0GeV, 0.0, WFinder::CLUSTERNODECAY,
	WFinder::NOTRACK, WFinder::TRANSMASS);
	- addProjection(w_e_finder, "W_E_FINDER");
	+ declare(w_e_finder, "W_E_FINDER");

	WFinder w_mu_finder(fs, cuts, PID::MUON, 40GeV, MAXDOUBLE, 0.0GeV, 0.0, WFinder::CLUSTERNODECAY,
	WFinder::NOTRACK, WFinder::TRANSMASS);
	- addProjection(w_mu_finder, "W_MU_FINDER");
	+ declare(w_mu_finder, "W_MU_FINDER");

	VetoedFinalState jet_fs(fs);
	jet_fs.addVetoOnThisFinalState(getProjection<WFinder>("W_E_FINDER"));
	jet_fs.addVetoOnThisFinalState(getProjection<WFinder>("W_MU_FINDER"));
	FastJets jets(jet_fs, FastJets::ANTIKT, 0.4);
	- addProjection(jets, "JETS");
	+ declare(jets, "JETS");

	}

	/// Do the analysis
	void analyze(const Event &e) {

	double weight = e.weight();

	- const WFinder& w_e_finder = applyProjection<WFinder>(e, "W_E_FINDER" );
	- const WFinder& w_mu_finder = applyProjection<WFinder>(e, "W_MU_FINDER");
	+ const WFinder& w_e_finder = apply<WFinder>(e, "W_E_FINDER" );
	+ const WFinder& w_mu_finder = apply<WFinder>(e, "W_MU_FINDER");
	Particle lepton, neutrino;
	Jets all_jets, jets;

	// Find exactly 1 W->e or W->mu boson
	if(w_e_finder.bosons().size() == 1 && w_mu_finder.bosons().size() == 0) {
	MSG_DEBUG(" Event identified as W->e nu.");
	if( !(w_e_finder.mT() > 40GeV && w_e_finder.constituentNeutrino().Et() > 25.0GeV) ) vetoEvent;
	lepton = w_e_finder.constituentLepton();
	} else if(w_mu_finder.bosons().size() == 1 && w_e_finder.bosons().size() == 0) {
	MSG_DEBUG(" Event identified as W->mu nu.");
	if( !(w_mu_finder.mT() > 40GeV && w_mu_finder.constituentNeutrino().Et() > 25.0GeV) ) vetoEvent;
	lepton = w_mu_finder.constituentLepton();
	} else {
	MSG_DEBUG(" No W found passing cuts.");
	vetoEvent;
	}

	- all_jets = applyProjection<FastJets>(e, "JETS").jetsByPt(Cuts::pt>20.0*GeV && Cuts::absrap<2.8);
	+ all_jets = apply<FastJets>(e, "JETS").jetsByPt(Cuts::pt>20.0*GeV && Cuts::absrap<2.8);

	// Remove jets DeltaR < 0.5 from W lepton
	for(Jets::iterator it = all_jets.begin(); it != all_jets.end(); ++it) {
	double distance = deltaR( lepton, (*it) );
	if(distance < 0.5) {
	MSG_DEBUG(" Veto jet DeltaR " << distance << " from W lepton");
	} else {
	jets.push_back(*it);
	}
	}

	// Exactly two jets required
	if( jets.size() != 2 ) vetoEvent;

	// Calculate analysis quantities from the two jets
	double delta_jets = (jets.front().momentum() + jets.back().momentum()).pT();
	double total_pt = jets.front().momentum().pT() + jets.back().momentum().pT();
	double delta_jets_n = delta_jets / total_pt;

	_h_delta_jets->fill( delta_jets, weight ); // Jet pT balance
	_h_delta_jets_n->fill( delta_jets_n, weight ); // Jet pT balance, normalised by scalar dijet pT

	}

	/// Finalize
	void finalize() {

	// Data is normalised to 0.03 and 3
	normalize(_h_delta_jets_n, 0.03);
	normalize(_h_delta_jets , 3.0 );

	}

	//@}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_delta_jets_n;
	Histo1DPtr _h_delta_jets;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1216670);

	}
	diff --git a/src/Analyses/ATLAS_2013_I1217863_W.cc b/src/Analyses/ATLAS_2013_I1217863_W.cc
	--- a/src/Analyses/ATLAS_2013_I1217863_W.cc
	+++ b/src/Analyses/ATLAS_2013_I1217863_W.cc
	@@ -1,200 +1,200 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	class ATLAS_2013_I1217863_W : public Analysis {
	public:

	/// Constructor
	ATLAS_2013_I1217863_W(string name="ATLAS_2013_I1217863_W")
	: Analysis(name)
	{
	// the electron mode is used by default
	_mode = 1;
	}


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	Cut cuts = Cuts::abseta < 2.47 && Cuts::pT > 25*GeV;

	// W finder for electrons and muons
	WFinder wf(fs, cuts, _mode==3? PID::MUON : PID::ELECTRON, 0.0GeV, 1000.0GeV, 35.0*GeV, 0.1,
	WFinder::CLUSTERNODECAY, WFinder::NOTRACK, WFinder::TRANSMASS);
	- addProjection(wf, "WF");
	+ declare(wf, "WF");

	// leading photon
	LeadingParticlesFinalState photonfs(FinalState(Cuts::abseta < 2.37 && Cuts::pT > 15*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// jets
	VetoedFinalState jet_fs(fs);
	jet_fs.addVetoOnThisFinalState(getProjection<WFinder>("WF"));
	jet_fs.addVetoOnThisFinalState(getProjection<LeadingParticlesFinalState>("LeadingPhoton"));
	FastJets jets(jet_fs, FastJets::ANTIKT, 0.4);
	jets.useInvisibles(true);
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	// FS excluding the leading photon
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(photonfs);
	- addProjection(vfs, "isolatedFS");
	+ declare(vfs, "isolatedFS");


	// Book histograms
	_hist_EgammaT_incl = bookHisto1D( 7, 1, _mode); // dSigma / dE^gamma_T for Njet >= 0
	_hist_EgammaT_excl = bookHisto1D( 8, 1, _mode); // dSigma / dE^gamma_T for Njet = 0
	_hist_Njet_EgammaT15 = bookHisto1D(15, 1, _mode); // dSigma / dNjet for E^gamma_T > 15
	_hist_Njet_EgammaT60 = bookHisto1D(16, 1, _mode); // dSigma / dNjet for E^gamma_T > 60
	_hist_mWgammaT = bookHisto1D(19, 1, _mode); // dSigma / dm^{Wgamma}_T

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	// retrieve leading photon
	- Particles photons = applyProjection<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	+ Particles photons = apply<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	if (photons.size() != 1) vetoEvent;
	const Particle& leadingPhoton = photons[0];
	if (leadingPhoton.Et() < 15.0*GeV) vetoEvent;
	if (leadingPhoton.abseta() > 2.37) vetoEvent;

	// check photon isolation
	double coneEnergy(0.0);
	- Particles fs = applyProjection<VetoedFinalState>(event, "isolatedFS").particles();
	+ Particles fs = apply<VetoedFinalState>(event, "isolatedFS").particles();
	foreach(const Particle& p, fs) {
	if ( deltaR(leadingPhoton, p) < 0.4 ) coneEnergy += p.E();
	}
	if ( coneEnergy / leadingPhoton.E() >= 0.5 ) vetoEvent;

	// retrieve W boson candidate
	- const WFinder& wf = applyProjection<WFinder>(event, "WF");
	+ const WFinder& wf = apply<WFinder>(event, "WF");
	if ( wf.bosons().size() != 1 ) vetoEvent; // only one W boson candidate
	//const Particle& Wboson = wf.boson();

	// retrieve constituent neutrino
	const Particle& neutrino = wf.constituentNeutrino();
	if ( !(neutrino.pT() > 35.0*GeV) ) vetoEvent;

	// retrieve constituent lepton
	const Particle& lepton = wf.constituentLepton();
	if ( !(lepton.pT() > 25.0*GeV && lepton.abseta() < 2.47) ) vetoEvent;

	// check photon-lepton overlap
	if ( !(deltaR(leadingPhoton, lepton) > 0.7) ) vetoEvent;

	// count jets
	- const FastJets& jetfs = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetfs = apply<FastJets>(event, "Jets");
	Jets jets = jetfs.jets(cmpMomByEt);
	int goodJets = 0;
	foreach (const Jet& j, jets) {
	if ( !(j.Et() > 30.0*GeV) ) break;
	if ( (j.abseta() < 4.4) && \
	(deltaR(leadingPhoton, j) > 0.3) && \
	(deltaR(lepton, j) > 0.3) ) ++goodJets;
	}

	double Njets = double(goodJets) + 0.5;
	double photonEt = leadingPhoton.Et()*GeV;

	const FourMomentum& lep_gamma = lepton.momentum() + leadingPhoton.momentum();
	double term1 = sqrt(lep_gamma.mass2() + lep_gamma.pT2()) + neutrino.Et();
	double term2 = (lep_gamma + neutrino.momentum()).pT2();
	double mWgammaT = sqrt(term1 * term1 - term2) * GeV;

	_hist_EgammaT_incl->fill(photonEt, weight);

	_hist_Njet_EgammaT15->fill(Njets, weight);

	if ( !goodJets ) _hist_EgammaT_excl->fill(photonEt, weight);

	if (photonEt > 40.0*GeV) {
	_hist_mWgammaT->fill(mWgammaT, weight);
	if (photonEt > 60.0*GeV) _hist_Njet_EgammaT60->fill(Njets, weight);
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {

	const double xs_fb = crossSection()/femtobarn;
	const double sumw = sumOfWeights();
	const double sf = xs_fb / sumw;

	scale(_hist_EgammaT_excl, sf);
	scale(_hist_EgammaT_incl, sf);

	normalize(_hist_Njet_EgammaT15);
	normalize(_hist_Njet_EgammaT60);
	normalize(_hist_mWgammaT);

	}

	//@}

	protected:

	size_t _mode;

	private:

	/// @name Histograms
	//@{

	Histo1DPtr _hist_EgammaT_incl;
	Histo1DPtr _hist_EgammaT_excl;
	Histo1DPtr _hist_Njet_EgammaT15;
	Histo1DPtr _hist_Njet_EgammaT60;
	Histo1DPtr _hist_mWgammaT;

	//@}

	};


	class ATLAS_2013_I1217863_W_EL : public ATLAS_2013_I1217863_W {
	public:
	ATLAS_2013_I1217863_W_EL()
	: ATLAS_2013_I1217863_W("ATLAS_2013_I1217863_W_EL")
	{
	_mode = 2;
	}
	};


	class ATLAS_2013_I1217863_W_MU : public ATLAS_2013_I1217863_W {
	public:
	ATLAS_2013_I1217863_W_MU()
	: ATLAS_2013_I1217863_W("ATLAS_2013_I1217863_W_MU")
	{
	_mode = 3;
	}
	};


	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1217863_W);
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1217863_W_EL);
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1217863_W_MU);

	}
	diff --git a/src/Analyses/ATLAS_2013_I1217863_Z.cc b/src/Analyses/ATLAS_2013_I1217863_Z.cc
	--- a/src/Analyses/ATLAS_2013_I1217863_Z.cc
	+++ b/src/Analyses/ATLAS_2013_I1217863_Z.cc
	@@ -1,195 +1,195 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	class ATLAS_2013_I1217863_Z : public Analysis {
	public:

	/// Constructor
	ATLAS_2013_I1217863_Z(string name="ATLAS_2013_I1217863_Z")
	: Analysis(name)
	{
	// the electron mode is used by default
	_mode = 1;
	}


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	Cut cuts = Cuts::abseta < 2.47 && Cuts::pT > 25*GeV;

	// Z finder
	ZFinder zf(fs, cuts, _mode==3? PID::MUON : PID::ELECTRON, 40.0GeV, 1000.0GeV, 0.1, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);
	- addProjection(zf, "ZF");
	+ declare(zf, "ZF");

	// leading photon
	LeadingParticlesFinalState photonfs(FinalState(Cuts::abseta < 2.37 && Cuts::pT > 15*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// jets
	VetoedFinalState jet_fs(fs);
	jet_fs.addVetoOnThisFinalState(getProjection<ZFinder>("ZF"));
	jet_fs.addVetoOnThisFinalState(getProjection<LeadingParticlesFinalState>("LeadingPhoton"));
	FastJets jets(jet_fs, FastJets::ANTIKT, 0.4);
	jets.useInvisibles(true);
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	// FS excluding the leading photon
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(photonfs);
	- addProjection(vfs, "isolatedFS");
	+ declare(vfs, "isolatedFS");


	// Book histograms
	_hist_EgammaT_incl = bookHisto1D(11, 1, _mode); // dSigma / dE^gamma_T for Njet >= 0
	_hist_EgammaT_excl = bookHisto1D(12, 1, _mode); // dSigma / dE^gamma_T for Njet = 0
	_hist_Njet_EgammaT15 = bookHisto1D(17, 1, _mode); // dSigma / dNjet for E^gamma_T >= 15
	_hist_Njet_EgammaT60 = bookHisto1D(18, 1, _mode); // dSigma / dNjet for E^gamma_T >= 60
	_hist_mZgamma = bookHisto1D(20, 1, _mode); // dSigma / dm^{Zgamma}

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	// retrieve leading photon
	- Particles photons = applyProjection<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	+ Particles photons = apply<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	if (photons.size() != 1) vetoEvent;
	const Particle& leadingPhoton = photons[0];
	if (leadingPhoton.Et() < 15.0*GeV) vetoEvent;
	if (leadingPhoton.abseta() > 2.37) vetoEvent;

	// check photon isolation
	double coneEnergy(0.0);
	- Particles fs = applyProjection<VetoedFinalState>(event, "isolatedFS").particles();
	+ Particles fs = apply<VetoedFinalState>(event, "isolatedFS").particles();
	foreach(const Particle& p, fs) {
	if ( deltaR(leadingPhoton, p) < 0.4 ) coneEnergy += p.E();
	}
	if (coneEnergy / leadingPhoton.E() >= 0.5 ) vetoEvent;

	// retrieve Z boson candidate
	- const ZFinder& zf = applyProjection<ZFinder>(event, "ZF");
	+ const ZFinder& zf = apply<ZFinder>(event, "ZF");
	if ( zf.bosons().size() != 1 ) vetoEvent; // only one Z boson candidate
	const Particle& Zboson = zf.boson();
	if ( !(Zboson.mass() > 40.0*GeV) ) vetoEvent;

	// check charge of constituent leptons
	const ParticleVector& leptons = zf.constituents();
	if (leptons.size() != 2 \|\| leptons[0].charge() * leptons[1].charge() > 0.) vetoEvent;

	// check photon-lepton overlap
	foreach(const Particle& p, leptons) {
	if ( !(p.pT() > 25.0*GeV && p.abseta() < 2.47 && deltaR(leadingPhoton, p) > 0.7) ) vetoEvent;
	}

	// count jets
	- const FastJets& jetfs = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetfs = apply<FastJets>(event, "Jets");
	Jets jets = jetfs.jets(cmpMomByEt);
	int goodJets = 0;
	foreach (const Jet& j, jets) {
	if ( !(j.Et() > 30.0*GeV) ) break;
	if ( (j.abseta() < 4.4) && \
	(deltaR(leadingPhoton, j) > 0.3) && \
	(deltaR(leptons[0], j) > 0.3) && \
	(deltaR(leptons[1], j) > 0.3) ) ++goodJets;
	}

	double Njets = double(goodJets) + 0.5;
	double photonEt = leadingPhoton.Et()*GeV;
	double mZgamma = (Zboson.momentum() + leadingPhoton.momentum()).mass() * GeV;

	_hist_EgammaT_incl->fill(photonEt, weight);

	_hist_Njet_EgammaT15->fill(Njets, weight);

	if ( !goodJets ) _hist_EgammaT_excl->fill(photonEt, weight);

	if (photonEt >= 40.0*GeV) {
	_hist_mZgamma->fill(mZgamma, weight);
	if (photonEt >= 60.0*GeV) _hist_Njet_EgammaT60->fill(Njets, weight);
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {

	const double xs_fb = crossSection()/femtobarn;
	const double sumw = sumOfWeights();
	const double sf = xs_fb / sumw;

	scale(_hist_EgammaT_excl, sf);
	scale(_hist_EgammaT_incl, sf);

	normalize(_hist_Njet_EgammaT15);
	normalize(_hist_Njet_EgammaT60);
	normalize(_hist_mZgamma);

	}

	//@}

	protected:

	size_t _mode;

	private:

	/// @name Histograms
	//@{

	Histo1DPtr _hist_EgammaT_incl;
	Histo1DPtr _hist_EgammaT_excl;
	Histo1DPtr _hist_Njet_EgammaT15;
	Histo1DPtr _hist_Njet_EgammaT60;
	Histo1DPtr _hist_mZgamma;

	//@}

	};


	class ATLAS_2013_I1217863_Z_EL : public ATLAS_2013_I1217863_Z {
	public:
	ATLAS_2013_I1217863_Z_EL()
	: ATLAS_2013_I1217863_Z("ATLAS_2013_I1217863_Z_EL")
	{
	_mode = 2;
	}
	};


	class ATLAS_2013_I1217863_Z_MU : public ATLAS_2013_I1217863_Z {
	public:
	ATLAS_2013_I1217863_Z_MU()
	: ATLAS_2013_I1217863_Z("ATLAS_2013_I1217863_Z_MU")
	{
	_mode = 3;
	}
	};


	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1217863_Z);
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1217863_Z_EL);
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1217863_Z_MU);

	}
	diff --git a/src/Analyses/ATLAS_2013_I1217867.cc b/src/Analyses/ATLAS_2013_I1217867.cc
	--- a/src/Analyses/ATLAS_2013_I1217867.cc
	+++ b/src/Analyses/ATLAS_2013_I1217867.cc
	@@ -1,155 +1,155 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {



	class ATLAS_2013_I1217867 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2013_I1217867()
	: Analysis("ATLAS_2013_I1217867")
	{
	m_njet = 4;
	_h_dI.resize(2, std::vector<Histo1DPtr>(m_njet));
	_h_dI_ratio.resize(2, std::vector<Histo1DPtr>(m_njet-1));
	}

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	// Initialise projections

	FinalState fs(Cuts::abseta < 5.0);

	IdentifiedFinalState bareElectrons(fs);
	bareElectrons.acceptIdPair(PID::ELECTRON);

	Cut cuts = (Cuts::absetaIn(0, 1.37) \|\| Cuts::absetaIn(1.52, 2.47)) && Cuts::pT > 20*GeV;

	DressedLeptons electronClusters(fs, bareElectrons, 0.1, cuts);
	- addProjection(electronClusters, "electronClusters");
	+ declare(electronClusters, "electronClusters");

	IdentifiedFinalState bareMuons(fs);
	bareMuons.acceptIdPair(PID::MUON);
	Cut mucuts = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;
	DressedLeptons muonClusters(fs, bareMuons, 0.1, mucuts);
	- addProjection(muonClusters, "muonClusters");
	+ declare(muonClusters, "muonClusters");

	IdentifiedFinalState neutrinos(Cuts::pT > 25*GeV);
	neutrinos.acceptNeutrinos();
	- addProjection(neutrinos, "neutrinos");
	+ declare(neutrinos, "neutrinos");

	VetoedFinalState jetFS(fs);
	jetFS.addVetoOnThisFinalState(electronClusters);
	jetFS.addVetoOnThisFinalState(muonClusters);
	jetFS.addVetoOnThisFinalState(neutrinos);
	FastJets jetpro(jetFS, FastJets::KT, 0.6);
	jetpro.useInvisibles(true);
	- addProjection(jetpro, "jets");
	+ declare(jetpro, "jets");

	// Book histograms
	for (size_t flav = 0; flav < 2; ++flav) {
	for (size_t i = 0; i < m_njet; ++i) _h_dI[flav][i] = bookHisto1D(i+1, 1, flav+1);
	for (size_t i = 0; i < m_njet-1; ++i) _h_dI_ratio[flav][i] = bookHisto1D(4+i+1, 1, flav+1);
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& e) {
	const double weight = e.weight();

	- const DressedLeptons& electronClusters = applyProjection<DressedLeptons>(e, "electronClusters");
	- const DressedLeptons& muonClusters = applyProjection<DressedLeptons>(e, "muonClusters");
	+ const DressedLeptons& electronClusters = apply<DressedLeptons>(e, "electronClusters");
	+ const DressedLeptons& muonClusters = apply<DressedLeptons>(e, "muonClusters");
	int ne = electronClusters.dressedLeptons().size();
	int nmu = muonClusters.dressedLeptons().size();

	FourMomentum lepton;
	size_t flav = 2;
	if (ne==1) {
	lepton=electronClusters.dressedLeptons()[0].momentum();
	flav = 0;
	if (nmu > 0) vetoEvent;
	}
	else if (nmu == 1) {
	lepton=muonClusters.dressedLeptons()[0].momentum();
	flav = 1;
	if (ne > 0) vetoEvent;
	}
	else {
	vetoEvent;
	}

	- const Particles& neutrinos = applyProjection<FinalState>(e, "neutrinos").particlesByPt();
	+ const Particles& neutrinos = apply<FinalState>(e, "neutrinos").particlesByPt();
	if (neutrinos.size() < 1) vetoEvent;
	FourMomentum neutrino = neutrinos[0].momentum();

	double mtW=sqrt(2.0lepton.pT()neutrino.pT()*(1-cos(lepton.phi()-neutrino.phi())));
	if (mtW<40.0*GeV) vetoEvent;

	- const shared_ptr<fastjet::ClusterSequence> seq = applyProjection<FastJets>(e, "jets").clusterSeq();
	+ const shared_ptr<fastjet::ClusterSequence> seq = apply<FastJets>(e, "jets").clusterSeq();
	if (seq) {
	for (size_t i = 0; i < min(m_njet,(size_t)seq->n_particles()); ++i) {
	double d_ij = sqrt(seq->exclusive_dmerge_max(i));
	_h_dI[flav][i]->fill(d_ij, weight);

	if (i<m_njet-1) {
	if (d_ij>20.0*GeV) {
	double d_ijplus1 = sqrt(seq->exclusive_dmerge_max(i+1));
	_h_dI_ratio[flav][i]->fill(d_ijplus1/d_ij, weight);
	}
	}
	}
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t flav = 0; flav < 2; ++flav) {
	for (size_t i = 0; i < m_njet; ++i) {
	normalize(_h_dI[flav][i], 1.0, false);
	if (i < m_njet-1) normalize(_h_dI_ratio[flav][i], 1.0, false);
	}
	}
	}

	//@}


	private:

	/// @name Histograms
	//@{
	vector< vector<Histo1DPtr> > _h_dI;
	vector< vector<Histo1DPtr> > _h_dI_ratio;
	//@}

	size_t m_njet;
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1217867);


	}
	diff --git a/src/Analyses/ATLAS_2013_I1219109.cc b/src/Analyses/ATLAS_2013_I1219109.cc
	--- a/src/Analyses/ATLAS_2013_I1219109.cc
	+++ b/src/Analyses/ATLAS_2013_I1219109.cc
	@@ -1,159 +1,159 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/HeavyHadrons.hh"

	namespace Rivet {


	/// @brief ATLAS W+b measurement
	class ATLAS_2013_I1219109: public Analysis {
	public:

	ATLAS_2013_I1219109(string name = "ATLAS_2013_I1219109")
	: Analysis(name)
	{
	// the electron mode is used by default
	_mode = 1;
	}


	void init() {
	FinalState fs;
	- addProjection(fs, "FinalState");
	+ declare(fs, "FinalState");

	Cut cuts = Cuts::abseta < 2.5 && Cuts::pT >= 25*GeV;

	// W finder for electrons and muons
	WFinder wf(fs, cuts, _mode==3? PID::MUON : PID::ELECTRON, 0.0*GeV, MAXDOUBLE, 0.0, 0.1,
	WFinder::CLUSTERNODECAY, WFinder::NOTRACK, WFinder::TRANSMASS);
	- addProjection(wf, "WF");
	+ declare(wf, "WF");

	// jets
	VetoedFinalState jet_fs(fs);
	jet_fs.addVetoOnThisFinalState(getProjection<WFinder>("WF"));
	FastJets fj(jet_fs, FastJets::ANTIKT, 0.4);
	fj.useInvisibles();
	- addProjection(fj, "Jets");
	- addProjection(HeavyHadrons(Cuts::abseta < 2.5 && Cuts::pT > 5*GeV), "BHadrons");
	+ declare(fj, "Jets");
	+ declare(HeavyHadrons(Cuts::abseta < 2.5 && Cuts::pT > 5*GeV), "BHadrons");


	// book histograms
	_njet = bookHisto1D(1, 1, _mode); // dSigma / dNjet
	_jet1_bPt = bookHisto1D(2, 1, _mode); // dSigma / dBjetPt for Njet = 1
	_jet2_bPt = bookHisto1D(2, 2, _mode); // dSigma / dBjetPt for Njet = 2

	}


	void analyze(const Event& event) {

	const double weight = event.weight();

	// retrieve W boson candidate
	- const WFinder& wf = applyProjection<WFinder>(event, "WF");
	+ const WFinder& wf = apply<WFinder>(event, "WF");
	if( wf.bosons().size() != 1 ) vetoEvent; // only one W boson candidate
	if( !(wf.mT() > 60.0*GeV) ) vetoEvent;
	//const Particle& Wboson = wf.boson();


	// retrieve constituent neutrino
	const Particle& neutrino = wf.constituentNeutrino();
	if( !(neutrino.pT() > 25.0*GeV) ) vetoEvent;

	// retrieve constituent lepton
	const Particle& lepton = wf.constituentLepton();

	// count good jets, check if good jet contains B hadron
	- const Particles& bHadrons = applyProjection<HeavyHadrons>(event, "BHadrons").bHadrons();
	- const Jets& jets = applyProjection<JetAlg>(event, "Jets").jetsByPt(25*GeV);
	+ const Particles& bHadrons = apply<HeavyHadrons>(event, "BHadrons").bHadrons();
	+ const Jets& jets = apply<JetAlg>(event, "Jets").jetsByPt(25*GeV);
	int goodjets = 0, bjets = 0;
	double bPt = 0.;
	foreach(const Jet& j, jets) {
	if( (j.abseta() < 2.1) && (deltaR(lepton, j) > 0.5) ) {
	// this jet passes the selection!
	++goodjets;
	// j.bTagged() uses ghost association which is
	// more elegant, but not what has been used in
	// this analysis originally, will match B had-
	// rons in eta-phi space instead
	foreach(const Particle& b, bHadrons) {
	if( deltaR(j, b) < 0.3 ) {
	// jet matched to B hadron!
	if(!bPt) bPt = j.pT() * GeV; // leading b-jet pT
	++bjets; // count number of b-jets
	break;
	}
	}
	}
	}
	if( goodjets > 2 ) vetoEvent; // at most two jets
	if( !bjets ) vetoEvent; // at least one of them b-tagged

	double njets = double(goodjets);
	double ncomb = 3.0;
	_njet->fill(njets, weight);
	_njet->fill(ncomb, weight);

	if( goodjets == 1) _jet1_bPt->fill(bPt, weight);
	else if(goodjets == 2) _jet2_bPt->fill(bPt, weight);
	}


	void finalize() {

	// Print summary info
	const double xs_pb(crossSection() / picobarn);
	const double sumw(sumOfWeights());
	MSG_INFO("Cross-Section/pb: " << xs_pb );
	MSG_INFO("Sum of weights : " << sumw );
	MSG_INFO("nEvents : " << numEvents());

	const double sf(xs_pb / sumw);

	scale(_njet, sf);
	scale(_jet1_bPt, sf);
	scale(_jet2_bPt, sf);
	}

	protected:

	size_t _mode;

	private:

	Histo1DPtr _njet;
	Histo1DPtr _jet1_bPt;
	Histo1DPtr _jet2_bPt;

	//bool _isMuon;

	};

	class ATLAS_2013_I1219109_EL : public ATLAS_2013_I1219109 {
	public:
	ATLAS_2013_I1219109_EL()
	: ATLAS_2013_I1219109("ATLAS_2013_I1219109_EL")
	{
	_mode = 2;
	}
	};

	class ATLAS_2013_I1219109_MU : public ATLAS_2013_I1219109 {
	public:
	ATLAS_2013_I1219109_MU()
	: ATLAS_2013_I1219109("ATLAS_2013_I1219109_MU")
	{
	_mode = 3;
	}
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1219109);
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1219109_EL);
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1219109_MU);

	}
	diff --git a/src/Analyses/ATLAS_2013_I1230812.cc b/src/Analyses/ATLAS_2013_I1230812.cc
	--- a/src/Analyses/ATLAS_2013_I1230812.cc
	+++ b/src/Analyses/ATLAS_2013_I1230812.cc
	@@ -1,332 +1,332 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// Z + jets in pp at 7 TeV (combined channel / base class)
	/// @note This base class contains a "mode" variable for combined, e, and mu channel derived classes
	class ATLAS_2013_I1230812 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2013_I1230812(string name="ATLAS_2013_I1230812")
	: Analysis(name)
	{
	// This class uses the combined e+mu mode
	_mode = 1;
	}

	//@}


	/// Book histograms and initialise projections before the run
	void init() {
	// Determine the e/mu decay channels used
	/// @todo Note that Zs are accepted with any rapidity: the cuts are on the e/mu: is this correct?
	Cut pt20 = Cuts::pT >= 20.0*GeV;
	if (_mode == 1) {
	// Combined
	ZFinder zfinder(FinalState(-2.5, 2.5), pt20, PID::ELECTRON, 66GeV, 116GeV);
	- addProjection(zfinder, "zfinder");
	+ declare(zfinder, "zfinder");
	} else if (_mode == 2) {
	// Electron
	Cut eta_e = Cuts::abseta < 1.37 \|\| Cuts::absetaIn(1.52, 2.47);
	ZFinder zfinder(FinalState(eta_e), pt20, PID::ELECTRON, 66GeV, 116GeV);
	- addProjection(zfinder, "zfinder");
	+ declare(zfinder, "zfinder");
	} else if (_mode == 3) {
	// Muon
	ZFinder zfinder(FinalState(Cuts::abseta < 2.4), pt20, PID::MUON, 66GeV, 116GeV);
	- addProjection(zfinder, "zfinder");
	+ declare(zfinder, "zfinder");
	} else {
	MSG_ERROR("Unknown decay channel mode!!!");
	}

	// Define veto FS in order to prevent Z-decay products entering the jet algorithm
	VetoedFinalState had_fs;
	had_fs.addVetoOnThisFinalState(getProjection<ZFinder>("zfinder"));
	FastJets jets(had_fs, FastJets::ANTIKT, 0.4);
	jets.useInvisibles(true);
	- addProjection(jets, "jets");
	+ declare(jets, "jets");

	_h_njet_incl = bookHisto1D( 1, 1, _mode);
	_h_njet_incl_ratio = bookScatter2D(2, 1, _mode, true);
	_h_njet_excl = bookHisto1D( 3, 1, _mode);
	_h_njet_excl_ratio = bookScatter2D(4, 1, _mode, true);
	_h_njet_excl_pt150 = bookHisto1D( 5, 1, _mode);
	_h_njet_excl_pt150_ratio = bookScatter2D(6, 1, _mode, true);
	_h_njet_excl_vbf = bookHisto1D ( 7, 1, _mode);
	_h_njet_excl_vbf_ratio = bookScatter2D(8, 1, _mode, true);
	_h_ptlead = bookHisto1D( 9, 1, _mode);
	_h_ptseclead = bookHisto1D( 10, 1, _mode);
	_h_ptthirdlead = bookHisto1D( 11, 1, _mode);
	_h_ptfourthlead = bookHisto1D( 12, 1, _mode);
	_h_ptlead_excl = bookHisto1D( 13, 1, _mode);
	_h_pt_ratio = bookHisto1D( 14, 1, _mode);
	_h_pt_z = bookHisto1D( 15, 1, _mode);
	_h_pt_z_excl = bookHisto1D( 16, 1, _mode);
	_h_ylead = bookHisto1D( 17, 1, _mode);
	_h_yseclead = bookHisto1D( 18, 1, _mode);
	_h_ythirdlead = bookHisto1D( 19, 1, _mode);
	_h_yfourthlead = bookHisto1D( 20, 1, _mode);
	_h_deltay = bookHisto1D( 21, 1, _mode);
	_h_mass = bookHisto1D( 22, 1, _mode);
	_h_deltaphi = bookHisto1D( 23, 1, _mode);
	_h_deltaR = bookHisto1D( 24, 1, _mode);
	_h_ptthirdlead_vbf = bookHisto1D( 25, 1, _mode);
	_h_ythirdlead_vbf = bookHisto1D( 26, 1, _mode);
	_h_ht = bookHisto1D( 27, 1, _mode);
	_h_st = bookHisto1D( 28, 1, _mode);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "zfinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "zfinder");
	if (zfinder.constituents().size()!=2) vetoEvent;

	FourMomentum z = zfinder.bosons()[0].momentum();
	FourMomentum lp = zfinder.constituents()[0].momentum();
	FourMomentum lm = zfinder.constituents()[1].momentum();
	if (deltaR(lp, lm)<0.2) vetoEvent;

	Jets jets;
	/// @todo Replace with a Cut passed to jetsByPt
	- foreach(const Jet& jet, applyProjection<FastJets>(event, "jets").jetsByPt(30*GeV)) {
	+ foreach(const Jet& jet, apply<FastJets>(event, "jets").jetsByPt(30*GeV)) {
	FourMomentum jmom = jet.momentum();
	if (jmom.absrap() < 4.4 && deltaR(lp, jmom) > 0.5 && deltaR(lm, jmom) > 0.5) {
	jets.push_back(jet);
	}
	}

	const double weight = event.weight();

	// Fill jet multiplicities
	for (size_t ijet = 0; ijet <= jets.size(); ++ijet) {
	_h_njet_incl->fill(ijet, weight);
	}
	_h_njet_excl->fill(jets.size(), weight);

	// Require at least one jet
	if (jets.size() >= 1) {
	// Leading jet histos
	const double ptlead = jets[0].pT()/GeV;
	const double yabslead = fabs(jets[0].rapidity());
	const double ptz = z.pT()/GeV;
	_h_ptlead->fill(ptlead, weight);
	_h_ylead ->fill(yabslead, weight);
	_h_pt_z ->fill(ptz, weight);
	// Fill jet multiplicities
	if (ptlead > 150) _h_njet_excl_pt150->fill(jets.size(), weight);

	// Loop over selected jets, fill inclusive distributions
	double st=0;
	double ht=lp.pT()/GeV+lm.pT()/GeV;
	for (size_t ijet = 0; ijet < jets.size(); ++ijet) {
	ht+=jets[ijet].pT()/GeV;
	st+=jets[ijet].pT()/GeV;
	}
	_h_ht->fill(ht, weight);
	_h_st->fill(st, weight);

	// Require exactly one jet
	if (jets.size() == 1) {
	_h_ptlead_excl->fill(ptlead, weight);
	_h_pt_z_excl ->fill(ptz, weight);
	}
	}


	// Require at least two jets
	if (jets.size() >= 2) {
	// Second jet histos
	const double ptlead = jets[0].pT()/GeV;
	const double pt2ndlead = jets[1].pT()/GeV;
	const double ptratio = pt2ndlead/ptlead;
	const double yabs2ndlead = fabs(jets[1].rapidity());
	_h_ptseclead->fill(pt2ndlead, weight);
	_h_yseclead->fill( yabs2ndlead, weight);
	_h_pt_ratio->fill( ptratio, weight);

	// Dijet histos
	const double deltaphi = fabs(deltaPhi(jets[1], jets[0]));
	const double deltarap = fabs(jets[0].rapidity() - jets[1].rapidity()) ;
	const double deltar = fabs(deltaR(jets[0], jets[1], RAPIDITY));
	const double mass = (jets[0].momentum() + jets[1].momentum()).mass()/GeV;
	_h_mass->fill( mass, weight);
	_h_deltay->fill( deltarap, weight);
	_h_deltaphi->fill(deltaphi, weight);
	_h_deltaR->fill( deltar, weight);

	if (mass > 350 && deltarap > 3) _h_njet_excl_vbf->fill(jets.size(), weight);
	}

	// Require at least three jets
	if (jets.size() >= 3) {
	// Third jet histos
	const double pt3rdlead = jets[2].pT()/GeV;
	const double yabs3rdlead = fabs(jets[2].rapidity());
	_h_ptthirdlead->fill(pt3rdlead, weight);
	_h_ythirdlead->fill( yabs3rdlead, weight);

	//Histos after VBF preselection
	const double deltarap = fabs(jets[0].rapidity() - jets[1].rapidity()) ;
	const double mass = (jets[0].momentum() + jets[1].momentum()).mass();
	if (mass > 350 && deltarap > 3) {
	_h_ptthirdlead_vbf->fill(pt3rdlead, weight);
	_h_ythirdlead_vbf->fill( yabs3rdlead, weight);
	}
	}

	// Require at least four jets
	if (jets.size() >= 4) {
	// Fourth jet histos
	const double pt4thlead = jets[3].pT()/GeV;
	const double yabs4thlead = fabs(jets[3].rapidity());
	_h_ptfourthlead->fill(pt4thlead, weight);
	_h_yfourthlead->fill( yabs4thlead, weight);
	}
	}

	/// @name Ratio calculator util functions
	//@{

	/// Calculate the efficiency error, being careful about div-by-zero
	double err_incl(const HistoBin1D &M, const HistoBin1D &N, bool hasWeights) {
	double r = safediv(M.sumW(), N.sumW());
	if (hasWeights) { // use F. James's approximation for weighted events
	return sqrt( safediv((1 - 2 * r) * M.sumW2() + r * r * N.sumW2(), N.sumW() * N.sumW()) );
	}
	return sqrt( safediv(r * (1 - r), N.sumW()) );
	}

	/// Calculate the ratio error, being careful about div-by-zero
	double err_excl(const HistoBin1D &A, const HistoBin1D &B) {
	double r = safediv(A.sumW(), B.sumW());
	double dAsquared = safediv(A.sumW2(), A.sumW() * A.sumW()); // squared relative error of A
	double dBsquared = safediv(B.sumW2(), B.sumW() * B.sumW()); // squared relative error of B
	return r * sqrt(dAsquared + dBsquared);
	}


	//@}

	void finalize() {
	bool hasWeights = _h_njet_incl->effNumEntries() != _h_njet_incl->numEntries();
	for (size_t i = 0; i < 6; ++i) {
	_h_njet_incl_ratio->point(i).setY(safediv(_h_njet_incl->bin(i + 1).sumW(), _h_njet_incl->bin(i).sumW()),
	err_incl(_h_njet_incl->bin(i + 1), _h_njet_incl->bin(i), hasWeights));
	_h_njet_excl_ratio->point(i).setY(safediv(_h_njet_excl->bin(i + 1).sumW(), _h_njet_excl->bin(i).sumW()),
	err_excl(_h_njet_excl->bin(i + 1), _h_njet_excl->bin(i)));
	if (i >= 1) {
	_h_njet_excl_pt150_ratio->point(i - 1).setY(safediv(_h_njet_excl_pt150->bin(i).sumW(), _h_njet_excl_pt150->bin(i - 1).sumW()),
	err_excl(_h_njet_excl_pt150->bin(i), _h_njet_excl_pt150->bin(i - 1)));
	if (i >= 2) {
	_h_njet_excl_vbf_ratio->point(i - 2).setY(safediv(_h_njet_excl_vbf->bin(i).sumW(), _h_njet_excl_vbf->bin(i - 1).sumW()),
	err_excl(_h_njet_excl_vbf->bin(i), _h_njet_excl_vbf->bin(i - 1)));
	}
	}
	}

	const double xs = crossSectionPerEvent()/picobarn;
	scale(_h_njet_incl , xs);
	scale(_h_njet_excl , xs);
	scale(_h_njet_excl_pt150, xs);
	scale(_h_njet_excl_vbf , xs);
	scale(_h_ptlead , xs);
	scale(_h_ptseclead , xs);
	scale(_h_ptthirdlead , xs);
	scale(_h_ptfourthlead , xs);
	scale(_h_ptlead_excl , xs);
	scale(_h_pt_ratio , xs);
	scale(_h_pt_z , xs);
	scale(_h_pt_z_excl , xs);
	scale(_h_ylead , xs);
	scale(_h_yseclead , xs);
	scale(_h_ythirdlead , xs);
	scale(_h_yfourthlead , xs);
	scale(_h_deltay , xs);
	scale(_h_mass , xs);
	scale(_h_deltaphi , xs);
	scale(_h_deltaR , xs);
	scale(_h_ptthirdlead_vbf, xs);
	scale(_h_ythirdlead_vbf , xs);
	scale(_h_ht , xs);
	scale(_h_st , xs);
	}

	//@}


	protected:

	size_t _mode;


	private:

	Scatter2DPtr _h_njet_incl_ratio;
	Scatter2DPtr _h_njet_excl_ratio;
	Scatter2DPtr _h_njet_excl_pt150_ratio;
	Scatter2DPtr _h_njet_excl_vbf_ratio;
	Histo1DPtr _h_njet_incl;
	Histo1DPtr _h_njet_excl;
	Histo1DPtr _h_njet_excl_pt150;
	Histo1DPtr _h_njet_excl_vbf;
	Histo1DPtr _h_ptlead;
	Histo1DPtr _h_ptseclead;
	Histo1DPtr _h_ptthirdlead;
	Histo1DPtr _h_ptfourthlead;
	Histo1DPtr _h_ptlead_excl;
	Histo1DPtr _h_pt_ratio;
	Histo1DPtr _h_pt_z;
	Histo1DPtr _h_pt_z_excl;
	Histo1DPtr _h_ylead;
	Histo1DPtr _h_yseclead;
	Histo1DPtr _h_ythirdlead;
	Histo1DPtr _h_yfourthlead;
	Histo1DPtr _h_deltay;
	Histo1DPtr _h_mass;
	Histo1DPtr _h_deltaphi;
	Histo1DPtr _h_deltaR;
	Histo1DPtr _h_ptthirdlead_vbf;
	Histo1DPtr _h_ythirdlead_vbf;
	Histo1DPtr _h_ht;
	Histo1DPtr _h_st;
	};



	class ATLAS_2013_I1230812_EL : public ATLAS_2013_I1230812 {
	public:
	ATLAS_2013_I1230812_EL()
	: ATLAS_2013_I1230812("ATLAS_2013_I1230812_EL")
	{
	_mode = 2;
	}
	};



	class ATLAS_2013_I1230812_MU : public ATLAS_2013_I1230812 {
	public:
	ATLAS_2013_I1230812_MU()
	: ATLAS_2013_I1230812("ATLAS_2013_I1230812_MU")
	{
	_mode = 3;
	}
	};



	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1230812);
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1230812_EL);
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1230812_MU);
	}
	diff --git a/src/Analyses/ATLAS_2013_I1243871.cc b/src/Analyses/ATLAS_2013_I1243871.cc
	--- a/src/Analyses/ATLAS_2013_I1243871.cc
	+++ b/src/Analyses/ATLAS_2013_I1243871.cc
	@@ -1,280 +1,280 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/ParticleIdUtils.hh"
	#include "Rivet/Particle.hh"

	namespace Rivet {


	class ATLAS_2013_I1243871 : public Analysis {
	public:

	/// Constructor
	ATLAS_2013_I1243871()
	: Analysis("ATLAS_2013_I1243871")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {
	// Set up projections
	const FinalState fs(-4.5, 4.5);
	- addProjection(fs, "ALL_FS");
	+ declare(fs, "ALL_FS");

	/// Get electrons from truth record
	IdentifiedFinalState elec_fs(Cuts::abseta < 2.47 && Cuts::pT > 25*GeV);
	elec_fs.acceptIdPair(PID::ELECTRON);
	- addProjection(elec_fs, "ELEC_FS");
	+ declare(elec_fs, "ELEC_FS");

	/// Get muons which pass the initial kinematic cuts:
	IdentifiedFinalState muon_fs(Cuts::abseta < 2.5 && Cuts::pT > 20*GeV);
	muon_fs.acceptIdPair(PID::MUON);
	- addProjection(muon_fs, "MUON_FS");
	+ declare(muon_fs, "MUON_FS");

	// Final state used as input for jet-finding.
	// We include everything except the muons and neutrinos
	VetoedFinalState jet_input(fs);
	jet_input.vetoNeutrinos();
	jet_input.addVetoPairId(PID::MUON);
	- addProjection(jet_input, "JET_INPUT");
	+ declare(jet_input, "JET_INPUT");

	// Get the jets
	FastJets jets(jet_input, FastJets::ANTIKT, 0.4);
	- addProjection(jets, "JETS");
	+ declare(jets, "JETS");

	// Book histograms
	for (size_t d = 0; d < 5; ++d) {
	_p_b_rho[d] = bookProfile1D(d+1, 1, 1);
	_p_l_rho[d] = bookProfile1D(d+1, 2, 1);
	_p_b_Psi[d] = bookProfile1D(d+1, 1, 2);
	_p_l_Psi[d] = bookProfile1D(d+1, 2, 2);
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	/// Get the various sets of final state particles
	- const ParticleVector& elecFS = applyProjection<IdentifiedFinalState>(event, "ELEC_FS").particlesByPt();
	- const ParticleVector& muonFS = applyProjection<IdentifiedFinalState>(event, "MUON_FS").particlesByPt();
	+ const ParticleVector& elecFS = apply<IdentifiedFinalState>(event, "ELEC_FS").particlesByPt();
	+ const ParticleVector& muonFS = apply<IdentifiedFinalState>(event, "MUON_FS").particlesByPt();

	// Get all jets with pT > 7 GeV (ATLAS standard jet collection)
	/// @todo Why rewrite the jets collection as a vector of pointers?
	- const Jets& jets = applyProjection<FastJets>(event, "JETS").jetsByPt(7*GeV);
	+ const Jets& jets = apply<FastJets>(event, "JETS").jetsByPt(7*GeV);
	vector<const Jet*> allJets;
	foreach(const Jet& j, jets) allJets.push_back(&j);

	// Keep any jets that pass the pt cut
	vector<const Jet*> pt_jets;
	foreach (const Jet* j, allJets) {
	/// @todo Use direct kinematics access
	const double pt = j->momentum().pT();
	const double eta = j->momentum().eta();
	if (pt > 25*GeV && fabs(eta) < 2.5) pt_jets.push_back(j);
	}

	// Remove jets too close to an electron
	vector<const Jet*> good_jets;
	foreach (const Jet* j, pt_jets) {
	bool isElectron = 0;
	foreach (const Particle& e, elecFS) {
	const double elec_jet_dR = deltaR(e.momentum(), j->momentum());
	if (elec_jet_dR < 0.2) { isElectron = true; break; }
	}
	if (!isElectron) good_jets.push_back(j);
	}

	// Classify the event type
	const size_t nElec = elecFS.size();
	const size_t nMuon = muonFS.size();
	bool isSemilepton = false, isDilepton = false;
	if (nElec == 1 && nMuon == 0) {
	isSemilepton = true;
	} else if (nElec == 0 && nMuon == 1) {
	isSemilepton = true;
	} else if (nElec == 2 && nMuon == 0) {
	if (charge(elecFS[0]) != charge(elecFS[1])) isDilepton = true;
	} else if (nElec == 1 && nMuon == 1) {
	if (charge(elecFS[0]) != charge(muonFS[0])) isDilepton = true;
	} else if (nElec == 0 && nMuon == 2) {
	if (charge(muonFS[0]) != charge(muonFS[1])) isDilepton = true;
	}
	const bool isGoodEvent = (isSemilepton && good_jets.size() >= 4) \|\| (isDilepton && good_jets.size() >= 2);
	if (!isGoodEvent) vetoEvent;

	// Select b-hadrons
	/// @todo Use built-in identification on Particle, avoid HepMC
	vector<const GenParticle *> b_hadrons;
	vector<const GenParticle *> allParticles = particles(event.genEvent());
	for (size_t i = 0; i < allParticles.size(); i++) {
	const GenParticle* p = allParticles.at(i);
	if ( !(PID::isHadron( p->pdg_id() ) && PID::hasBottom( p->pdg_id() )) ) continue;
	if (p->momentum().perp() < 5*GeV) continue;
	b_hadrons.push_back(p);
	}

	// Select b-jets as those containing a b-hadron
	/// @todo Use built-in dR < 0.3 Jet tagging, avoid HepMC
	vector<const Jet*> b_jets;
	foreach (const Jet* j, good_jets) {
	bool isbJet = false;
	foreach (const GenParticle* b, b_hadrons) {
	/// @todo Use direct momentum accessor / delta functions
	const FourMomentum hadron = b->momentum();
	const double hadron_jet_dR = deltaR(j->momentum(), hadron);
	if (hadron_jet_dR < 0.3) { isbJet = true; break; }
	}
	// Check if it is overlapped to any other jet
	bool isOverlapped = false;
	foreach (const Jet* k, allJets) {
	if (j == k) continue;
	double dRjj = deltaR(j->momentum(), k->momentum());
	if (dRjj < 0.8) { isOverlapped = true; break; }
	}
	if (isbJet && !isOverlapped) b_jets.push_back(j);
	}
	MSG_DEBUG(b_jets.size() << " b-jets selected");


	// Select light-jets as the pair of non-b-jets with invariant mass closest to the W mass
	/// @todo Use built-in b-tagging (dR < 0.3 defn), avoid HepMC
	const double nominalW = 80.4*GeV;
	double deltaM = 500*GeV;
	const Jet* light1 = NULL; const Jet* light2 = NULL; // NB: const Jets, not const pointers!
	foreach (const Jet* i, good_jets) {
	bool isbJet1 = false;
	foreach (const GenParticle* b, b_hadrons) {
	/// @todo Use direct momentum accessor / delta functions
	const FourMomentum hadron = b->momentum();
	const double hadron_jet_dR = deltaR(i->momentum(), hadron);
	if (hadron_jet_dR < 0.3) { isbJet1 = true; break; }
	}
	if (isbJet1) continue;
	foreach (const Jet* j, good_jets) {
	bool isbJet2 = false;
	foreach (const GenParticle* b, b_hadrons) {
	FourMomentum hadron = b->momentum();
	double hadron_jet_dR = deltaR(j->momentum(), hadron);
	if (hadron_jet_dR < 0.3) { isbJet2 = true; break; }
	}
	if (isbJet2) continue;
	double invMass = (i->momentum()+j->momentum()).mass();
	if (fabs(invMass-nominalW) < deltaM){
	deltaM = fabs(invMass - nominalW);
	light1 = i;
	light2 = j;
	}
	}
	}

	// Check that both jets are not overlapped, and populate the light jets list
	vector<const Jet*> light_jets;
	const bool hasGoodLight = light1 != NULL && light2 != NULL && light1 != light2;
	if (hasGoodLight) {
	bool isOverlap1 = false, isOverlap2 = false;
	foreach (const Jet* j, allJets) {
	if (light1 == j) continue;
	const double dR1j = deltaR(light1->momentum(), j->momentum());
	if (dR1j < 0.8) { isOverlap1 = true; break; }
	}
	foreach (const Jet* j, allJets) {
	if (light2 == j) continue;
	const double dR2j = deltaR(light2->momentum(), j->momentum());
	if (dR2j < 0.8) { isOverlap2 = true; break; }
	}
	if (!isOverlap1 && !isOverlap2) {
	light_jets.push_back(light1);
	light_jets.push_back(light2);
	}
	}
	MSG_DEBUG(light_jets.size() << " light jets selected");


	// Calculate the jet shapes
	/// @todo Use C++11 vector/array initialization
	const double binWidth = 0.04; // -> 10 bins from 0.0-0.4
	vector<double> ptEdges; ptEdges += {{ 30, 40, 50, 70, 100, 150 }};

	// b-jet shapes
	MSG_DEBUG("Filling b-jet shapes");
	foreach (const Jet* bJet, b_jets) {
	// Work out jet pT bin and skip this jet if out of range
	const double jetPt = bJet->momentum().pT();
	MSG_DEBUG("Jet pT = " << jetPt/GeV << " GeV");
	if (!inRange(jetPt/GeV, 30., 150.)) continue;
	/// @todo Use YODA bin index lookup tools
	size_t ipt; for (ipt = 0; ipt < 5; ++ipt) if (inRange(jetPt/GeV, ptEdges[ipt], ptEdges[ipt+1])) break;
	MSG_DEBUG("Jet pT index = " << ipt);

	// Calculate jet shape
	vector<double> rings(10, 0);
	foreach (const Particle& p, bJet->particles()) {
	const double dR = deltaR(bJet->momentum(), p.momentum());
	const size_t idR = (size_t) floor(dR/binWidth);
	for (size_t i = idR; i < 10; ++i) rings[i] += p.pT();
	}

	// Fill each dR bin of the histos for this jet pT
	for (int iBin = 0; iBin < 10; ++iBin) {
	const double rcenter = 0.02 + iBin*binWidth;
	const double rhoval = (iBin != 0 ? (rings[iBin]-rings[iBin-1]) : rings[iBin]) / binWidth / rings[9];
	const double psival = rings[iBin] / rings[9];
	MSG_DEBUG(rcenter << ", " << rhoval << ", " << psival);
	_p_b_rho[ipt]->fill(rcenter, rhoval, weight);
	_p_b_Psi[ipt]->fill(rcenter, psival, weight);
	}
	}

	// Light jet shapes
	MSG_DEBUG("Filling light jet shapes");
	foreach (const Jet* lJet, light_jets) {
	// Work out jet pT bin and skip this jet if out of range
	const double jetPt = lJet->momentum().pT();
	MSG_DEBUG("Jet pT = " << jetPt/GeV << " GeV");
	if (!inRange(jetPt/GeV, 30., 150.)) continue;
	/// @todo Use YODA bin index lookup tools
	size_t ipt; for (ipt = 0; ipt < 5; ++ipt) if (inRange(jetPt/GeV, ptEdges[ipt], ptEdges[ipt+1])) break;
	MSG_DEBUG("Jet pT index = " << ipt);

	// Calculate jet shape
	vector<double> rings(10, 0);
	foreach (const Particle& p, lJet->particles()) {
	const double dR = deltaR(lJet->momentum(), p.momentum());
	const size_t idR = (size_t) floor(dR/binWidth);
	for (size_t i = idR; i < 10; ++i) rings[i] += p.pT();
	}

	// Fill each dR bin of the histos for this jet pT
	for (int iBin = 0; iBin < 10; ++iBin) {
	const double rcenter = 0.02 + iBin*binWidth;
	const double rhoval = (iBin != 0 ? (rings[iBin]-rings[iBin-1]) : rings[iBin]) / binWidth / rings[9];
	const double psival = rings[iBin] / rings[9];
	_p_l_rho[ipt]->fill(rcenter, rhoval, weight);
	_p_l_Psi[ipt]->fill(rcenter, psival, weight);
	}
	}

	}


	private:

	Profile1DPtr _p_b_rho[5];
	Profile1DPtr _p_l_rho[5];
	Profile1DPtr _p_b_Psi[5];
	Profile1DPtr _p_l_Psi[5];

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1243871);

	}
	diff --git a/src/Analyses/ATLAS_2013_I1244522.cc b/src/Analyses/ATLAS_2013_I1244522.cc
	--- a/src/Analyses/ATLAS_2013_I1244522.cc
	+++ b/src/Analyses/ATLAS_2013_I1244522.cc
	@@ -1,174 +1,164 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/PromptFinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief Measurement of isolated gamma + jet + X differential cross-sections
	class ATLAS_2013_I1244522 : public Analysis {
	public:

	// Constructor
	ATLAS_2013_I1244522()
	- : Analysis("ATLAS_2013_I1244522"),
	- _eta_bins_areaoffset{0.0, 1.5, 3.0}
	+ : Analysis("ATLAS_2013_I1244522")
	{ }


	// Book histograms and initialise projections before the run
	void init() {
	FinalState fs;

	// Voronoi eta-phi tassellation with KT jets, for ambient energy density calculation
	FastJets fj(fs, FastJets::KT, 0.5);
	fj.useJetArea(new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec()));
	- addProjection(fj, "KtJetsD05");
	+ declare(fj, "KtJetsD05");

	// Leading photon
	LeadingParticlesFinalState photonfs(PromptFinalState(FinalState(-2.37, 2.37, 45.0*GeV)));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// FS excluding the leading photon
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(photonfs);
	- addProjection(vfs, "JetFS");
	+ declare(vfs, "JetFS");

	// Jets
	FastJets jetpro(vfs, FastJets::ANTIKT, 0.6);
	jetpro.useInvisibles();
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	+ // Histograms
	_h_ph_pt = bookHisto1D(1, 1, 1);
	_h_jet_pt = bookHisto1D(2, 1, 1);
	_h_jet_rap = bookHisto1D(3, 1, 1);
	_h_dphi_phjet = bookHisto1D(4, 1, 1);
	-
	_h_costheta_biased_phjet = bookHisto1D(5, 1, 1);
	_h_mass_phjet = bookHisto1D(6, 1, 1);
	_h_costheta_phjet = bookHisto1D(7, 1, 1);

	}


	- size_t getEtaBin(double eta_w) const {
	- const double eta = fabs(eta_w);
	- return binIndex(eta, _eta_bins_areaoffset);
	+ size_t getEtaBin(double eta) const {
	+ const double aeta = fabs(eta);
	+ return binIndex(aeta, _eta_bins_areaoffset);
	}


	// Perform the per-event analysis
	void analyze(const Event& event) {
	- const double weight = event.weight();

	// Get the photon
	- Particles photons = applyProjection<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	+ Particles photons = apply<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	if (photons.size() != 1 ) vetoEvent;
	const Particle& photon = photons[0];

	if (inRange(photon.abseta(), 1.37, 1.52)) vetoEvent;

	//Compute isolation energy in cone of radius .4 around photon (all particles)
	FourMomentum mom_in_EtCone;
	- const Particles& fs = applyProjection<VetoedFinalState>(event, "JetFS").particles();
	+ const Particles& fs = apply<VetoedFinalState>(event, "JetFS").particles();
	for (const Particle& p : fs) {
	// Check if it's outside the cone of 0.4
	if (deltaR(photon, p) >= 0.4) continue;
	// Increment isolation energy
	mom_in_EtCone += p.momentum();
	}

	// Get the jets
	- Jets alljets = applyProjection<FastJets>(event, "Jets").jetsByPt(40.0*GeV);
	+ Jets alljets = apply<FastJets>(event, "Jets").jetsByPt(40.0*GeV);
	Jets jets;
	for (const Jet& jet : alljets)
	if (deltaR(photon, jet) > 1.0) jets += jet;
	if (jets.empty()) vetoEvent;
	Jet leadingJet = jets[0];
	if (leadingJet.absrap() > 2.37) vetoEvent;

	// Get the area-filtered jet inputs for computing median energy density, etc.
	- vector<double> ptDensity, sigma, Njets;
	+ vector<double> ptDensity;
	vector< vector<double> > ptDensities(_eta_bins_areaoffset.size()-1);
	- FastJets fast_jets = applyProjection<FastJets>(event, "KtJetsD05");
	+ FastJets fast_jets = apply<FastJets>(event, "KtJetsD05");
	const auto clust_seq_area = fast_jets.clusterSeqArea();
	foreach (const Jet& jet, fast_jets.jets()) {
	const double area = clust_seq_area->area(jet);
	- if (area > 10e-4 && jet.abseta() < _eta_bins_areaoffset.back())
	+ if (area > 1e-4 && jet.abseta() < _eta_bins_areaoffset.back())
	ptDensities.at( getEtaBin(jet.abseta()) ).push_back(jet.pT()/area);
	}

	// Compute the median energy density, etc.
	for (size_t b = 0; b < _eta_bins_areaoffset.size() - 1; ++b) {
	const int njets = ptDensities[b].size();
	- const double ptmedian = (njets > 0) ? median(ptDensities[b]) : 0;
	- const double ptsigma = (njets > 0) ? ptDensities[b][(size_t)(0.15865*njets)] : 0;
	- ptDensity.push_back(ptmedian);
	- sigma.push_back(ptsigma);
	- Njets.push_back(njets);
	+ ptDensity += (njets > 0) ? median(ptDensities[b]) : 0;
	}

	// Compute the isolation energy correction (cone area*energy density)
	const double etCone_area = PIsqr(0.4) - (5.0.025)(7.0PI/128.);
	const double correction = ptDensity[getEtaBin(photon.abseta())] * etCone_area;

	// Apply isolation cut on area-corrected value
	if (mom_in_EtCone.Et() - correction >= 4*GeV) vetoEvent;

	// Fill histos
	- const double photon_pt = photon.pT() / GeV;
	- const double jet_pt = leadingJet.pT() / GeV;
	- const double jet_y = leadingJet.absrap();
	- const double dphi_phj = deltaPhi(photon, leadingJet);
	+ const double weight = event.weight();
	const double dy = deltaRap(photon, leadingJet);
	- const double mass_phj = (photon.momentum() + leadingJet.momentum()).mass() / GeV;
	- const double costheta_phj = tanh(dy/2);
	-
	- _h_ph_pt->fill(photon_pt, weight);
	- _h_jet_pt->fill(jet_pt, weight);
	- _h_jet_rap->fill(jet_y, weight);
	- _h_dphi_phjet->fill(dphi_phj, weight);
	- _h_costheta_biased_phjet->fill(costheta_phj, weight);
	-
	- if (mass_phj > 160.939) {
	- if (fabs(photon.eta() + leadingJet.rap()) < 2.37) {
	- if (costheta_phj < 0.829022) {
	- _h_mass_phjet->fill(mass_phj, weight);
	- _h_costheta_phjet->fill(costheta_phj, weight);
	+ const double costheta_yj = tanh(dy/2);
	+ _h_ph_pt->fill(photon.pT()/GeV, weight);
	+ _h_jet_pt->fill(leadingJet.pT()/GeV, weight);
	+ _h_jet_rap->fill(leadingJet.absrap(), weight);
	+ _h_dphi_phjet->fill(deltaPhi(photon, leadingJet), weight);
	+ _h_costheta_biased_phjet->fill(costheta_yj, weight);
	+ if (costheta_yj < 0.829022) {
	+ const FourMomentum yj = photon.momentum() + leadingJet.momentum();
	+ if (yj.mass() > 160.939*GeV) {
	+ if (fabs(photon.eta() + leadingJet.rap()) < 2.37) {
	+ _h_mass_phjet->fill(yj.mass()/GeV, weight);
	+ _h_costheta_phjet->fill(costheta_yj, weight);
	}
	}
	}
	}

	+
	/// Normalise histograms etc., after the run
	void finalize() {
	- const double sf = crossSection() / sumOfWeights();
	+ const double sf = crossSection() / picobarn / sumOfWeights();
	scale(_h_ph_pt, sf);
	scale(_h_jet_pt, sf);
	scale(_h_jet_rap, sf);
	scale(_h_dphi_phjet, sf);
	scale(_h_costheta_biased_phjet, sf);
	scale(_h_mass_phjet, sf);
	scale(_h_costheta_phjet, sf);
	}


	private:

	Histo1DPtr _h_ph_pt, _h_jet_pt, _h_jet_rap, _h_dphi_phjet, _h_costheta_biased_phjet, _h_mass_phjet, _h_costheta_phjet;

	- vector<double> _eta_bins_areaoffset;
	+ const vector<double> _eta_bins_areaoffset = {0.0, 1.5, 3.0};

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1244522);


	}
	diff --git a/src/Analyses/ATLAS_2013_I1263495.cc b/src/Analyses/ATLAS_2013_I1263495.cc
	--- a/src/Analyses/ATLAS_2013_I1263495.cc
	+++ b/src/Analyses/ATLAS_2013_I1263495.cc
	@@ -1,139 +1,133 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// Inclusive isolated prompt photon analysis with 2011 LHC data
	class ATLAS_2013_I1263495 : public Analysis {
	public:

	/// Constructor
	ATLAS_2013_I1263495()
	: Analysis("ATLAS_2013_I1263495"),
	- _eta_bins{ 0.00, 1.37, 1.52, 2.37},
	+ _eta_bins{0.00, 1.37, 1.52, 2.37},
	_eta_bins_areaoffset{0.0, 1.5, 3.0}
	{ }


	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Consider the final state jets for the energy density calculation
	FastJets fj(fs, FastJets::KT, 0.5);
	fj.useJetArea(new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec()));
	- addProjection(fj, "KtJetsD05");
	+ declare(fj, "KtJetsD05");

	// Consider the leading pt photon with \|eta\| < 2.37 and pT > 100 GeV
	LeadingParticlesFinalState photonfs(FinalState(Cuts::abseta < 2.37 && Cuts::pT > 100*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// Book the dsigma/dEt (in eta bins) histograms
	for (size_t i = 0; i < _eta_bins.size() - 1; i++) {
	if (fuzzyEquals(_eta_bins[i], 1.37)) continue; // skip this bin
	_h_Et_photon[i] = bookHisto1D(1, 1, i+1);
	}

	// Book the dsigma/d\|eta\| histogram
	_h_eta_photon = bookHisto1D(1,2,1);
	}


	/// Return eta bin for either dsigma/dET histogram (area_eta=false) or energy density correction (area_eta=true)
	size_t _getEtaBin(double eta_w, bool area_eta) const {
	const double eta = fabs(eta_w);
	if (!area_eta) {
	return binIndex(eta, _eta_bins);
	} else {
	return binIndex(eta, _eta_bins_areaoffset);
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	// Retrieve leading photon
	- Particles photons = applyProjection<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	+ Particles photons = apply<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	if (photons.size() != 1) vetoEvent;
	const Particle& leadingPhoton = photons[0];

	// Veto events with photon in ECAL crack
	if (inRange(leadingPhoton.abseta(), 1.37, 1.52)) vetoEvent;

	// Compute isolation energy in cone of radius .4 around photon (all particles)
	FourMomentum mom_in_EtCone;
	- Particles fs = applyProjection<FinalState>(event, "FS").particles();
	+ Particles fs = apply<FinalState>(event, "FS").particles();
	for (const Particle& p : fs) {
	// Check if it's outside the cone of 0.4
	if (deltaR(leadingPhoton, p) >= 0.4) continue;
	// Don't count particles in the 5x7 central core
	if (deltaEta(leadingPhoton, p) < .0255.00.5 &&
	deltaPhi(leadingPhoton, p) < (PI/128.)7.00.5) continue;
	// Increment isolation energy
	mom_in_EtCone += p.momentum();
	}

	// Get the area-filtered jet inputs for computing median energy density, etc.
	- vector<double> ptDensity, ptSigma, nJets;
	+ vector<double> ptDensity;
	vector< vector<double> > ptDensities(_eta_bins_areaoffset.size()-1);
	- FastJets fast_jets =applyProjection<FastJets>(event, "KtJetsD05");
	+ FastJets fast_jets =apply<FastJets>(event, "KtJetsD05");
	const shared_ptr<fastjet::ClusterSequenceArea> clust_seq_area = fast_jets.clusterSeqArea();
	foreach (const Jet& jet, fast_jets.jets()) {
	const double area = clust_seq_area->area(jet);
	- /// @todo Should be 1e-4 or 1e-3?
	- if (area > 10e-4 && jet.abseta() < _eta_bins_areaoffset.back())
	+ if (area > 1e-4 && jet.abseta() < _eta_bins_areaoffset.back())
	ptDensities.at( _getEtaBin(jet.abseta(), true) ).push_back(jet.pT()/area);
	}
	// Compute the median energy density, etc.
	for (size_t b = 0; b < _eta_bins_areaoffset.size()-1; b++) {
	- const int njets = ptDensities[b].size();
	- const double ptmedian = (njets > 0) ? median(ptDensities[b]) : 0;
	- const double ptsigma = (njets > 0) ? ptDensities[b][(size_t)(0.15865*njets)] : 0;
	- nJets.push_back(njets);
	- ptDensity.push_back(ptmedian);
	- ptSigma.push_back(ptsigma);
	+ ptDensity += ptDensities[b].empty() ? 0 : median(ptDensities[b]);
	}
	// Compute the isolation energy correction (cone area*energy density)
	const double etCone_area = PIsqr(0.4) - (7.0.025)(5.0PI/128.);
	const double correction = ptDensity[_getEtaBin(leadingPhoton.abseta(), true)]*etCone_area;

	// Apply isolation cut on area-corrected value
	if (mom_in_EtCone.Et() - correction > 7*GeV) vetoEvent;

	// Fill histograms
	const size_t eta_bin = _getEtaBin(leadingPhoton.abseta(), false);
	_h_Et_photon[eta_bin]->fill(leadingPhoton.Et(), event.weight());
	_h_eta_photon->fill(leadingPhoton.abseta(), event.weight());
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t i = 0; i < _eta_bins.size()-1; i++) {
	if (fuzzyEquals(_eta_bins[i], 1.37)) continue;
	scale(_h_Et_photon[i], crossSection()/picobarn/sumOfWeights());
	}
	scale(_h_eta_photon, crossSection()/picobarn/sumOfWeights());
	}


	private:

	Histo1DPtr _h_Et_photon[3];
	Histo1DPtr _h_eta_photon;

	vector<double> _eta_bins, _eta_bins_areaoffset;

	};


	DECLARE_RIVET_PLUGIN(ATLAS_2013_I1263495);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1268975.cc b/src/Analyses/ATLAS_2014_I1268975.cc
	--- a/src/Analyses/ATLAS_2014_I1268975.cc
	+++ b/src/Analyses/ATLAS_2014_I1268975.cc
	@@ -1,108 +1,108 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	/// Jet mass as a function of ystar
	class ATLAS_2014_I1268975 : public Analysis {
	public:

	/// Constructor
	ATLAS_2014_I1268975()
	: Analysis("ATLAS_2014_I1268975")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	const FinalState fs;
	- addProjection(fs,"FinalState");
	+ declare(fs,"FinalState");

	FastJets fj04(fs, FastJets::ANTIKT, 0.4);
	fj04.useInvisibles();
	- addProjection(fj04, "AntiKT04");
	+ declare(fj04, "AntiKT04");

	FastJets fj06(fs, FastJets::ANTIKT, 0.6);
	fj06.useInvisibles();
	- addProjection(fj06, "AntiKT06");
	+ declare(fj06, "AntiKT06");

	double ystarbins[] = { 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0};

	size_t massDsOffset(0);
	for (size_t alg = 0; alg < 2; ++alg) {
	for (size_t i = 0; i < 6; ++i) {
	_mass[alg].addHistogram(ystarbins[i], ystarbins[i+1], bookHisto1D(1 + massDsOffset, 1, i+1));
	}
	massDsOffset += 1;
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	Jets jetAr[2];
	- jetAr[AKT4] = applyProjection<FastJets>(event, "AntiKT04").jetsByPt(50*GeV);
	- jetAr[AKT6] = applyProjection<FastJets>(event, "AntiKT06").jetsByPt(50*GeV);
	+ jetAr[AKT4] = apply<FastJets>(event, "AntiKT04").jetsByPt(50*GeV);
	+ jetAr[AKT6] = apply<FastJets>(event, "AntiKT06").jetsByPt(50*GeV);

	// Loop over jet "radii" used in analysis
	for (size_t alg = 0; alg < 2; ++alg) {

	// Identify dijets
	vector<FourMomentum> leadjets;
	foreach (const Jet& jet, jetAr[alg]) {
	if (jet.absrap() < 3.0 && leadjets.size() < 2) {
	if (leadjets.empty() && jet.pT() < 100*GeV) continue;
	leadjets.push_back(jet.momentum());
	}
	}

	// Make sure we have a leading jet with pT > 100 GeV and a second to leading jet with pT > 50 GeV
	if (leadjets.size() < 2) {
	MSG_DEBUG("Could not find two suitable leading jets");
	continue;
	}

	const double y1 = leadjets[0].rapidity();
	const double y2 = leadjets[1].rapidity();
	const double ystar = fabs(y1-y2) / 2.;
	const double m = (leadjets[0] + leadjets[1]).mass();

	// Fill mass histogram
	_mass[alg].fill(ystar, m/TeV, event.weight());
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t alg = 0; alg < 2; ++alg) {
	_mass[alg].scale(crossSectionPerEvent()/picobarn, this);
	}
	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here
	enum Alg { AKT4=0, AKT6=1 };

	/// The di-jet mass spectrum binned in rapidity for akt6 and akt4 jets (array index is jet type from enum above)
	BinnedHistogram<double> _mass[2];

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1268975);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1279489.cc b/src/Analyses/ATLAS_2014_I1279489.cc
	--- a/src/Analyses/ATLAS_2014_I1279489.cc
	+++ b/src/Analyses/ATLAS_2014_I1279489.cc
	@@ -1,396 +1,396 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/DressedLeptons.hh"

	namespace Rivet {


	struct Plots {
	string label;

	Histo1DPtr h_dy;
	Histo1DPtr h_mjj;
	Histo1DPtr h_njets;
	Histo1DPtr h_dphijj;
	Histo1DPtr h_ptbal;

	Histo1DPtr h_jetveto_mjj_veto;
	Histo1DPtr h_jetveto_mjj_inc;
	Histo1DPtr h_jetveto_dy_veto;
	Histo1DPtr h_jetveto_dy_inc;

	Histo1DPtr h_ptbaleff_mjj_veto;
	Histo1DPtr h_ptbaleff_mjj_inc;
	Histo1DPtr h_ptbaleff_dy_veto;
	Histo1DPtr h_ptbaleff_dy_inc;

	Profile1DPtr p_avgnjets_dy;
	Profile1DPtr p_avgnjets_mjj;
	};


	struct Variables {

	Variables(const vector<const Jet>& jets, const Particle lep1, const Particle* lep2) {
	FourMomentum j1 = jets.at(0)->momentum();
	FourMomentum j2 = jets.at(1)->momentum();
	jet1pt = j1.pT();
	jet2pt = j2.pT();
	assert(jet1pt > jet2pt);

	zpt = (lep1->mom() + lep2->mom()).pT();

	deltay = fabs(j1.rapidity() - j2.rapidity());
	mjj = (j1 + j2).mass();
	deltaphijj = deltaPhi(j1, j2) / PI;

	FourMomentum gapjet(0., 0., 0., 0.);
	ngapjets = _getNumGapJets(jets, gapjet);

	double ptbal_vec = (j1 + j2 + lep1->mom() + lep2->mom()).pT();
	double ptbal_sc = j1.pT() + j2.pT() + lep1->pT() + lep2->pT();
	ptbalance2 = ptbal_vec / ptbal_sc;

	double ptbal3_vec = (j1 + j2 + gapjet + lep1->mom() + lep2->mom()).pT();
	double ptbal3_sc = j1.pT() + j2.pT() + gapjet.pT() + lep1->pT() + lep2->pT();
	ptbalance3 = ptbal3_vec / ptbal3_sc;

	pass_jetveto = gapjet.pT() < 25.0*GeV;
	pass_ptbaleff = ptbalance2 < 0.15;
	}


	double jet1pt;
	double jet2pt;
	double zpt;

	double deltay;
	double mjj;
	double deltaphijj;
	double ptbalance2;
	double ptbalance3;
	int ngapjets;

	double dilepton_dr;

	bool pass_jetveto;
	bool pass_ptbaleff;


	private:

	bool _isBetween(const Jet* probe, const Jet* boundary1, const Jet* boundary2) {
	double y_p = probe->rapidity();
	double y_b1 = boundary1->rapidity();
	double y_b2 = boundary2->rapidity();

	double y_min = std::min(y_b1, y_b2);
	double y_max = std::max(y_b1, y_b2);

	if (y_p > y_min && y_p < y_max) return true;
	else return false;
	}

	int _getNumGapJets(const vector<const Jet*>& jets, FourMomentum& thirdJet) {
	if (jets.size() < 2) return 0;
	// The vector of jets is already sorted by pT. So the boundary jets will be the first two.
	const Jet* bj1 = jets.at(0);
	const Jet* bj2 = jets.at(1);

	int n_between = 0;
	// Start loop at the 3rd hardest pT jet
	for (size_t i = 2; i < jets.size(); ++i) {
	const Jet* j = jets.at(i);
	// If this jet is between the boundary jets and is hard enough, increment counter
	if (_isBetween(j, bj1, bj2)) {
	if (n_between == 0) thirdJet = j->momentum();
	++n_between;
	}
	}
	return n_between;
	}

	};



	class ATLAS_2014_I1279489 : public Analysis {
	public:

	/// Constructor
	ATLAS_2014_I1279489()
	: Analysis("ATLAS_2014_I1279489")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs(-5.0, 5.0);

	IdentifiedFinalState photon_fs(fs);
	photon_fs.acceptIdPair(PID::PHOTON);

	IdentifiedFinalState electron_fs(fs);
	electron_fs.acceptIdPair(PID::ELECTRON);

	IdentifiedFinalState muon_fs(fs);
	muon_fs.acceptIdPair(PID::MUON);

	DressedLeptons dressed_electrons(photon_fs, electron_fs, 0.1, Cuts::abseta < 2.47 && Cuts::pT > 25*GeV);
	- addProjection(dressed_electrons, "DressedElectrons");
	+ declare(dressed_electrons, "DressedElectrons");

	DressedLeptons dressed_muons(photon_fs, muon_fs, 0.1, Cuts::abseta < 2.47 && Cuts::pT > 25*GeV);
	- addProjection(dressed_muons, "DressedMuons");
	+ declare(dressed_muons, "DressedMuons");

	FastJets jets(fs, FastJets::ANTIKT, 0.4);
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	initialisePlots(baseline_plots, "baseline");
	initialisePlots(highpt_plots, "highpt");
	initialisePlots(search_plots, "search");
	initialisePlots(control_plots, "control");
	initialisePlots(highmass_plots, "highmass");
	}


	void initialisePlots(Plots& plots, const string& phase_space){
	/****************************************
	* Plot labeling: *
	* format = d0_-x0_-y0_ *
	* d01 = baseline fiducial region *
	* d02 = high-pt fiducial region *
	* d03 = search fiducial region *
	* d04 = control fiducial region *
	* d05 = high-mass fiducial region *
	* *
	* x01 = mjj on x-axis *
	* x02 = delta-y on x-axis *
	* x03 = njets on x-axis *
	* x04 = dphijj on x-axis *
	* x05 = ptbalance on x-axis *
	* *
	* y01 = differential cross-section *
	* y02 = jet veto efficiency *
	* y03 = ptbalance efficiency *
	* y04 = average njets *
	****************************************/
	plots.label = phase_space;

	if (phase_space=="baseline") {
	plots.h_mjj = bookHisto1D(1, 1, 1);
	plots.h_dy = bookHisto1D(1, 2, 1);

	plots.h_jetveto_mjj_veto = bookHisto1D("jetveto_mjj_baseline_veto", refData(1,1,2));
	plots.h_jetveto_mjj_inc = bookHisto1D("jetveto_mjj_baseline_inc", refData(1,1,2));
	plots.h_jetveto_dy_veto = bookHisto1D("jetveto_dy_baseline_veto", refData(1,2,2));
	plots.h_jetveto_dy_inc = bookHisto1D("jetveto_dy_baseline_inc", refData(1,2,2));

	plots.h_ptbaleff_mjj_veto = bookHisto1D("ptbaleff_mjj_baseline_veto", refData(1,1,3));
	plots.h_ptbaleff_mjj_inc = bookHisto1D("ptbaleff_mjj_baseline_inc", refData(1,1,3));
	plots.h_ptbaleff_dy_veto = bookHisto1D("ptbaleff_dy_baseline_veto", refData(1,2,3));
	plots.h_ptbaleff_dy_inc = bookHisto1D("ptbaleff_dy_baseline_inc", refData(1,2,3));

	plots.p_avgnjets_mjj = bookProfile1D(1,1,4);
	plots.p_avgnjets_dy = bookProfile1D(1,2,4);
	}

	if (phase_space=="highpt") {
	plots.h_mjj = bookHisto1D(2, 1, 1);
	plots.h_dy = bookHisto1D(2, 2, 1);

	plots.h_jetveto_mjj_veto = bookHisto1D("jetveto_mjj_highpt_veto", refData(2,1,2));
	plots.h_jetveto_mjj_inc = bookHisto1D("jetveto_mjj_highpt_inc", refData(2,1,2));
	plots.h_jetveto_dy_veto = bookHisto1D("jetveto_dy_highpt_veto", refData(2,2,2));
	plots.h_jetveto_dy_inc = bookHisto1D("jetveto_dy_highpt_inc", refData(2,2,2));

	plots.h_ptbaleff_mjj_veto = bookHisto1D("ptbaleff_mjj_highpt_veto", refData(2,1,3));
	plots.h_ptbaleff_mjj_inc = bookHisto1D("ptbaleff_mjj_highpt_inc", refData(2,1,3));
	plots.h_ptbaleff_dy_veto = bookHisto1D("ptbaleff_dy_highpt_veto", refData(2,2,3));
	plots.h_ptbaleff_dy_inc = bookHisto1D("ptbaleff_dy_highpt_inc", refData(2,2,3));

	plots.p_avgnjets_mjj = bookProfile1D(2,1,4);
	plots.p_avgnjets_dy = bookProfile1D(2,2,4);
	}

	if (phase_space=="search") {
	plots.h_mjj = bookHisto1D(3,1,1);
	plots.h_dy = bookHisto1D(3,2,1);
	}

	if (phase_space=="control") {
	plots.h_mjj = bookHisto1D(4,1,1);
	plots.h_dy = bookHisto1D(4,2,1);
	}

	if (phase_space=="highmass") {
	plots.h_njets = bookHisto1D(5, 3, 1);
	plots.h_dphijj = bookHisto1D(5, 4, 1);
	plots.h_ptbal = bookHisto1D(5, 5, 1);
	}
	}



	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Make sure that we have a Z-candidate:
	const Particle lep1 = NULL, lep2 = NULL;
	//
	- const vector<DressedLepton>& muons = applyProjection<DressedLeptons>(event, "DressedMuons").dressedLeptons();
	+ const vector<DressedLepton>& muons = apply<DressedLeptons>(event, "DressedMuons").dressedLeptons();
	if (muons.size() == 2) {
	const FourMomentum dimuon = muons[0].mom() + muons[1].mom();
	if ( inRange(dimuon.mass()/GeV, 81.0, 101.0) && muons[0].threeCharge() != muons[1].threeCharge() ) {
	lep1 = &muons[0];
	lep2 = &muons[1];
	}
	}
	//
	- const vector<DressedLepton>& electrons = applyProjection<DressedLeptons>(event, "DressedElectrons").dressedLeptons();
	+ const vector<DressedLepton>& electrons = apply<DressedLeptons>(event, "DressedElectrons").dressedLeptons();
	if (electrons.size() == 2) {
	const FourMomentum dielectron = electrons[0].mom() + electrons[1].mom();
	if ( inRange(dielectron.mass()/GeV, 81.0, 101.0) && electrons[0].threeCharge() != electrons[1].threeCharge() ) {
	if (lep1 && lep2) {
	MSG_INFO("Found Z candidates using both electrons and muons! Continuing with the muon-channel candidate");
	} else {
	lep1 = &electrons[0];
	lep2 = &electrons[1];
	}
	}
	}
	// If there's no Z-candidate, we won't use this event:
	if (!lep1 \|\| !lep2) vetoEvent;


	// Do lepton-jet overlap removal:
	vector<const Jet*> good_jets;
	- const Jets& jets = applyProjection<FastJets>(event, "Jets").jetsByPt(Cuts::pT > 25*GeV && Cuts::absrap < 4.4);
	+ const Jets& jets = apply<FastJets>(event, "Jets").jetsByPt(Cuts::pT > 25*GeV && Cuts::absrap < 4.4);
	foreach(const Jet& j, jets) {
	bool nearby_lepton = false;
	foreach (const Particle& m, muons)
	if (deltaR(j, m) < 0.3) nearby_lepton = true;
	foreach (const Particle& e, electrons)
	if (deltaR(j, e) < 0.3) nearby_lepton = true;
	if (!nearby_lepton)
	good_jets.push_back(&j);
	}
	// If we don't have at least 2 good jets, we won't use this event.
	if (good_jets.size() < 2) vetoEvent;


	// Plotting, using variables and histo classes calculated by the Variables object constructor
	Variables vars(good_jets, lep1, lep2);
	bool pass_baseline = (vars.jet1pt > 55.0GeV && vars.jet2pt > 45.0GeV);
	bool pass_highpt = (vars.jet1pt > 85.0GeV && vars.jet2pt > 75.0GeV);
	bool pass_highmass = (pass_baseline && vars.mjj > 1000.0*GeV);
	bool pass_search = (pass_baseline && vars.zpt > 20.0GeV && vars.ngapjets == 0 && vars.ptbalance2 < 0.15 && vars.mjj > 250.0GeV);
	bool pass_control = (pass_baseline && vars.zpt > 20.0GeV && vars.ngapjets > 0 && vars.ptbalance3 < 0.15 && vars.mjj > 250.0GeV);
	//
	const double weight = event.weight();
	if (pass_baseline) fillPlots(vars, baseline_plots, "baseline", weight);
	if (pass_highpt) fillPlots(vars, highpt_plots, "highpt", weight);
	if (pass_highmass) fillPlots(vars, highmass_plots, "highmass", weight);
	if (pass_search) fillPlots(vars, search_plots, "search", weight);
	if (pass_control) fillPlots(vars, control_plots, "control", weight);
	}


	void fillPlots(const Variables& vars, Plots& plots, string phase_space, double weight) {
	if (phase_space == "baseline" \|\| phase_space == "highpt" \|\| phase_space == "search" \|\| phase_space == "control") {
	plots.h_dy->fill(vars.deltay, weight);
	plots.h_mjj->fill(vars.mjj, weight);
	}

	if (phase_space == "baseline" \|\| phase_space == "highpt") {
	if (vars.pass_jetveto) {
	plots.h_jetveto_dy_veto->fill(vars.deltay, weight);
	plots.h_jetveto_mjj_veto->fill(vars.mjj, weight);
	}
	plots.h_jetveto_dy_inc->fill(vars.deltay, weight);
	plots.h_jetveto_mjj_inc->fill(vars.mjj, weight);

	if (vars.pass_ptbaleff) {
	plots.h_ptbaleff_mjj_veto->fill(vars.mjj, weight);
	plots.h_ptbaleff_dy_veto->fill(vars.deltay, weight);
	}
	plots.h_ptbaleff_mjj_inc->fill(vars.mjj, weight);
	plots.h_ptbaleff_dy_inc->fill(vars.deltay, weight);

	plots.p_avgnjets_dy->fill(vars.deltay, vars.ngapjets, weight);
	plots.p_avgnjets_mjj->fill(vars.mjj, vars.ngapjets, weight);
	}

	if (phase_space == "highmass") {
	plots.h_njets->fill(vars.ngapjets, weight);
	plots.h_dphijj->fill(vars.deltaphijj, weight);
	plots.h_ptbal->fill(vars.ptbalance2, weight);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	finalizePlots(baseline_plots);
	finalizePlots(highpt_plots);
	finalizePlots(search_plots);
	finalizePlots(control_plots);
	finalizePlots(highmass_plots);
	finalizeEfficiencies(baseline_plots);
	finalizeEfficiencies(highpt_plots);
	}

	void finalizePlots(Plots& plots) {
	if (plots.h_dy) normalize(plots.h_dy);
	if (plots.h_mjj) normalize(plots.h_mjj);
	if (plots.h_dphijj) normalize(plots.h_dphijj);
	if (plots.h_njets) normalize(plots.h_njets);
	if (plots.h_ptbal) normalize(plots.h_ptbal);
	}

	void finalizeEfficiencies(Plots& plots) {
	int region_index = 0;
	if (plots.label=="baseline") region_index = 1;
	else if (plots.label=="highpt") region_index = 2;
	else return;

	if (plots.h_jetveto_mjj_veto && plots.h_jetveto_mjj_inc) divide(plots.h_jetveto_mjj_veto, plots.h_jetveto_mjj_inc, bookScatter2D(region_index, 1, 2));
	getScatter2D(region_index, 1, 2)->addAnnotation("InclusiveSumWeights", plots.h_jetveto_mjj_inc->integral());
	removeAnalysisObject(plots.h_jetveto_mjj_veto); removeAnalysisObject(plots.h_jetveto_mjj_inc);

	if (plots.h_jetveto_dy_veto && plots.h_jetveto_dy_inc) divide(plots.h_jetveto_dy_veto, plots.h_jetveto_dy_inc, bookScatter2D(region_index, 2, 2));
	getScatter2D(region_index, 2, 2)->addAnnotation("InclusiveSumWeights", plots.h_jetveto_dy_inc->integral());
	removeAnalysisObject(plots.h_jetveto_dy_veto); removeAnalysisObject(plots.h_jetveto_dy_inc);

	if (plots.h_ptbaleff_mjj_veto && plots.h_ptbaleff_mjj_inc) divide(plots.h_ptbaleff_mjj_veto, plots.h_ptbaleff_mjj_inc, bookScatter2D(region_index, 1, 3));
	getScatter2D(region_index, 1, 3)->addAnnotation("InclusiveSumWeights", plots.h_ptbaleff_mjj_inc->integral());
	removeAnalysisObject(plots.h_ptbaleff_mjj_veto); removeAnalysisObject(plots.h_ptbaleff_mjj_inc);

	if (plots.h_ptbaleff_dy_veto && plots.h_ptbaleff_dy_inc) divide(plots.h_ptbaleff_dy_veto, plots.h_ptbaleff_dy_inc, bookScatter2D(region_index, 2, 3));
	getScatter2D(region_index, 2, 3)->addAnnotation("InclusiveSumWeights", plots.h_ptbaleff_dy_inc->integral());
	removeAnalysisObject(plots.h_ptbaleff_dy_veto); removeAnalysisObject(plots.h_ptbaleff_dy_inc);
	}

	//@}


	private:

	//Variables* vars;

	Plots baseline_plots;
	Plots highpt_plots;
	Plots search_plots;
	Plots control_plots;
	Plots highmass_plots;

	};


	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1279489);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1282441.cc b/src/Analyses/ATLAS_2014_I1282441.cc
	--- a/src/Analyses/ATLAS_2014_I1282441.cc
	+++ b/src/Analyses/ATLAS_2014_I1282441.cc
	@@ -1,94 +1,94 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {


	class ATLAS_2014_I1282441 : public Analysis {
	public:

	ATLAS_2014_I1282441()
	: Analysis("ATLAS_2014_I1282441")
	{ }


	void init() {

	// Use a large eta range such that we can discriminate on y
	/// @todo Convert to use a y-cut directly
	UnstableFinalState ufs(Cuts::abseta < 10 && Cuts::pT > 500*MeV);
	IdentifiedFinalState phis(ufs);
	phis.acceptIdPair(PID::PHI);
	- addProjection(phis, "Phis");
	+ declare(phis, "Phis");

	IdentifiedFinalState kpms(Cuts::abseta < 2.0 && Cuts::pT > 230*MeV);
	kpms.acceptIdPair(PID::KPLUS);
	- addProjection(kpms, "Kpms");
	+ declare(kpms, "Kpms");

	_h_phi_rapidity = bookHisto1D(1,1,1);
	_h_phi_pT = bookHisto1D(2,1,1);
	}


	void analyze(const Event& event) {
	- const Particles& ks_all = applyProjection<IdentifiedFinalState>(event, "Kpms").particles();
	+ const Particles& ks_all = apply<IdentifiedFinalState>(event, "Kpms").particles();
	Particles kp, km;
	foreach (const Particle& p, ks_all) {
	if (!p.hasAncestor(PID::PHI)) { MSG_DEBUG("-- K not from phi."); continue; }
	if (p.p3().mod() > 800*MeV) { MSG_DEBUG("-- p K too high."); continue; }
	(p.charge() > 0 ? kp : km).push_back(p);
	}

	- const Particles& phis_all = applyProjection<FinalState>(event, "Phis").particles();
	+ const Particles& phis_all = apply<FinalState>(event, "Phis").particles();
	Particles phis;
	/// @todo Use particles(Cuts&) instead
	foreach (const Particle& p, phis_all) {
	if ( p.absrap() > 0.8 ) { MSG_DEBUG("-- phi Y too high."); continue; }
	if ( p.pT() > 1.2*GeV ) { MSG_DEBUG("-- phi pT too high."); continue; }
	phis.push_back(p);
	}

	// Find Phi -> KK decays through matching of the kinematics
	if (!kp.empty() && !km.empty() && !phis.empty()) {
	const double w = event.weight();
	MSG_DEBUG("Numbers of particles: #phi=" << phis.size() << ", #K+=" << kp.size() << ", #K-=" << km.size());
	for (size_t ip = 0; ip < phis.size(); ++ip) {
	const Particle& phi = phis[ip];
	for (size_t ikm = 0; ikm < km.size(); ++ikm) {
	for (size_t ikp = 0; ikp < kp.size(); ++ikp) {
	const FourMomentum mom = kp[ikp].mom() + km[ikm].mom();
	if ( fuzzyEquals(mom.mass(), phi.mass(), 1e-5) ) {
	MSG_DEBUG("Accepted combinatoric: phi#:" << ip << " K+#:" << ikp << " K-#:" << ikm);
	_h_phi_rapidity->fill(phi.absrap(), w);
	_h_phi_pT->fill(phi.pT()/MeV, w);
	} else {
	MSG_DEBUG("Rejected combinatoric: phi#:" << ip << " K+#:" << ikp << " K-#:" << ikm << " Mass difference is " << mom.mass()-phi.mass());
	}
	}
	}
	}
	}

	}


	void finalize() {
	scale(_h_phi_rapidity, crossSection()/microbarn/sumOfWeights());
	scale(_h_phi_pT, crossSection()/microbarn/sumOfWeights());
	}


	private:

	Histo1DPtr _h_phi_rapidity, _h_phi_pT;

	};



	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1282441);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1282447.cc b/src/Analyses/ATLAS_2014_I1282447.cc
	--- a/src/Analyses/ATLAS_2014_I1282447.cc
	+++ b/src/Analyses/ATLAS_2014_I1282447.cc
	@@ -1,596 +1,596 @@
	// -- C++ --
	// ATLAS W+c analysis

	//////////////////////////////////////////////////////////////////////////
	/*
	Description of rivet analysis ATLAS_2014_I1282447 W+c production

	This rivet routine implements the ATLAS W+c analysis.
	Apart from those histograms, described and published on HEP Data, here
	are some helper histograms defined, these are:

	d02-x01-y01, d02-x01-y02 and d08-x01-y01 are ratios, the nominator ("_plus")
	and denominator ("_minus") histograms are also given, so that the ratios can
	be reconstructed if need be (e.g. when running on separate samples).

	d05 and d06 are ratios over inclusive W production.
	The routine has to be run on a sample for inclusive W production in order to
	make sure the denominator ("_winc") is correctly filled.

	The ratios can be constructed using the following sample code:
	python divideWCharm.py

	import yoda
	hists_wc = yoda.read("Rivet_Wc.yoda")
	hists_winc = yoda.read("Rivet_Winc.yoda")

	## division histograms --> ONLY for different plus minus runs
	# (merge before using yodamerge Rivet_plus.yoda Rivet_minus.yoda > Rivet_Wc.yoda)

	d02y01_plus = hists_wc["/ATLAS_2014_I1282447/d02-x01-y01_plus"]
	d02y01_minus = hists_wc["/ATLAS_2014_I1282447/d02-x01-y01_minus"]
	ratio_d02y01 = d02y01_plus.divide(d02y01_minus)
	ratio_d02y01.path = "/ATLAS_2014_I1282447/d02-x01-y01"

	d02y02_plus = hists_wc["/ATLAS_2014_I1282447/d02-x01-y02_plus"]
	d02y02_minus = hists_wc["/ATLAS_2014_I1282447/d02-x01-y02_minus"]
	ratio_d02y02= d02y02_plus.divide(d02y02_minus)
	ratio_d02y02.path = "/ATLAS_2014_I1282447/d02-x01-y02"

	d08y01_plus = hists_wc["/ATLAS_2014_I1282447/d08-x01-y01_plus"]
	d08y01_minus = hists_wc["/ATLAS_2014_I1282447/d08-x01-y01_minus"]
	ratio_d08y01= d08y01_plus.divide(d08y01_minus)
	ratio_d08y01.path = "/ATLAS_2014_I1282447/d08-x01-y01"

	# inclusive cross section
	h_winc = hists_winc["/ATLAS_2014_I1282447/d05-x01-y01"]
	h_d = hists_wc["/ATLAS_2014_I1282447/d01-x01-y02"]
	h_dstar= hists_wc["/ATLAS_2014_I1282447/d01-x01-y03"]

	ratio_wd = h_d.divide(h_winc)
	ratio_wd.path = "/ATLAS_2014_I1282447/d05-x01-y02"

	ratio_wdstar = h_d.divide(h_winc)
	ratio_wdstar.path = "/ATLAS_2014_I1282447/d05-x01-y03"

	# pT differential
	h_winc_plus = hists_winc["/ATLAS_2014_I1282447/d06-x01-y01_winc"]
	h_winc_minus = hists_winc["/ATLAS_2014_I1282447/d06-x01-y02_winc"]

	h_wd_plus = hists_wc["/ATLAS_2014_I1282447/d06-x01-y01_wplus"]
	h_wd_minus = hists_wc["/ATLAS_2014_I1282447/d06-x01-y02_wminus"]
	h_wdstar_plus = hists_wc["/ATLAS_2014_I1282447/d06-x01-y03_wplus"]
	h_wdstar_minus = hists_wc["/ATLAS_2014_I1282447/d06-x01-y04_wminus"]

	ratio_wd_plus = h_wd_plus.divide(h_winc_plus)
	ratio_wd_plus.path = "/ATLAS_2014_I1282447/d06-x01-y01"
	ratio_wd_minus = h_wd_plus.divide(h_winc_minus)
	ratio_wd_minus.path = "/ATLAS_2014_I1282447/d06-x01-y02"

	ratio_wdstar_plus = h_wdstar_plus.divide(h_winc_plus)
	ratio_wdstar_plus.path = "/ATLAS_2014_I1282447/d06-x01-y03"
	ratio_wdstar_minus = h_wdstar_plus.divide(h_winc_minus)
	ratio_wdstar_minus.path = "/ATLAS_2014_I1282447/d06-x01-y04"

	ratio_wd_plus = h_wd_plus.divide(h_winc_plus)
	ratio_wd_plus.path = "/ATLAS_2014_I1282447/d06-x01-y01"
	ratio_wd_minus = h_wd_plus.divide(h_winc_minus)
	ratio_wd_minus.path = "/ATLAS_2014_I1282447/d06-x01-y02"

	h_winc_plus= hists_winc["/ATLAS_2014_I1282447/d06-x01-y01_winc"]
	h_winc_minus= hists_winc["/ATLAS_2014_I1282447/d06-x01-y02_winc"]

	## copy other histograms for plotting

	d01x01y01= hists_wc["/ATLAS_2014_I1282447/d01-x01-y01"]
	d01x01y01.path = "/ATLAS_2014_I1282447/d01-x01-y01"

	d01x01y02= hists_wc["/ATLAS_2014_I1282447/d01-x01-y02"]
	d01x01y02.path = "/ATLAS_2014_I1282447/d01-x01-y02"

	d01x01y03= hists_wc["/ATLAS_2014_I1282447/d01-x01-y03"]
	d01x01y03.path = "/ATLAS_2014_I1282447/d01-x01-y03"

	d03x01y01= hists_wc["/ATLAS_2014_I1282447/d03-x01-y01"]
	d03x01y01.path = "/ATLAS_2014_I1282447/d03-x01-y01"

	d03x01y02= hists_wc["/ATLAS_2014_I1282447/d03-x01-y02"]
	d03x01y02.path = "/ATLAS_2014_I1282447/d03-x01-y02"

	d04x01y01= hists_wc["/ATLAS_2014_I1282447/d04-x01-y01"]
	d04x01y01.path = "/ATLAS_2014_I1282447/d04-x01-y01"

	d04x01y02= hists_wc["/ATLAS_2014_I1282447/d04-x01-y02"]
	d04x01y02.path = "/ATLAS_2014_I1282447/d04-x01-y02"

	d04x01y03= hists_wc["/ATLAS_2014_I1282447/d04-x01-y03"]
	d04x01y03.path = "/ATLAS_2014_I1282447/d04-x01-y03"

	d04x01y04= hists_wc["/ATLAS_2014_I1282447/d04-x01-y04"]
	d04x01y04.path = "/ATLAS_2014_I1282447/d04-x01-y04"

	d07x01y01= hists_wc["/ATLAS_2014_I1282447/d07-x01-y01"]
	d07x01y01.path = "/ATLAS_2014_I1282447/d07-x01-y01"

	yoda.write([ratio_d02y01,ratio_d02y02,ratio_d08y01, ratio_wd ,ratio_wdstar,ratio_wd_plus,ratio_wd_minus ,ratio_wdstar_plus,ratio_wdstar_minus,d01x01y01,d01x01y02,d01x01y03,d03x01y01,d03x01y02,d04x01y01,d04x01y02,d04x01y03,d04x01y04,d07x01y01],"validation.yoda")

	*/
	//////////////////////////////////////////////////////////////////////////

	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {

	class ATLAS_2014_I1282447 : public Analysis {

	public:

	/// Constructor
	ATLAS_2014_I1282447() : Analysis("ATLAS_2014_I1282447")
	{
	setNeedsCrossSection(true);
	}

	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// @todo Initialise and register projections here
	UnstableFinalState fs;

	Cut cuts = Cuts::etaIn(-2.5, 2.5) & (Cuts::pT > 20*GeV);

	/// should use sample WITHOUT QED radiation off the electron
	WFinder wfinder_born_el(fs, cuts, PID::ELECTRON, 25GeV, 8000GeV, 15*GeV, 0.1, WFinder::CLUSTERALL, WFinder::TRACK);
	- addProjection(wfinder_born_el, "WFinder_born_el");
	+ declare(wfinder_born_el, "WFinder_born_el");

	WFinder wfinder_born_mu(fs, cuts, PID::MUON , 25GeV, 8000GeV, 15*GeV, 0.1, WFinder::CLUSTERALL, WFinder::TRACK);
	- addProjection(wfinder_born_mu, "WFinder_born_mu");
	+ declare(wfinder_born_mu, "WFinder_born_mu");

	// all hadrons that could be coming from a charm decay --
	// -- for safety, use region -3.5 - 3.5
	- addProjection(UnstableFinalState(Cuts::abseta <3.5), "hadrons");
	+ declare(UnstableFinalState(Cuts::abseta <3.5), "hadrons");

	// Input for the jets: no neutrinos, no muons, and no electron which passed the electron cuts
	// also: NO electron, muon or tau (needed due to ATLAS jet truth reconstruction feature)
	VetoedFinalState veto;

	veto.addVetoOnThisFinalState(wfinder_born_el);
	veto.addVetoOnThisFinalState(wfinder_born_mu);
	veto.addVetoPairId(PID::ELECTRON);
	veto.addVetoPairId(PID::MUON);
	veto.addVetoPairId(PID::TAU);

	FastJets jets(veto, FastJets::ANTIKT, 0.4);
	- addProjection(jets, "jets");
	+ declare(jets, "jets");

	// Book histograms

	// charge separated integrated cross sections
	_hist_wcjet_charge = bookHisto1D("d01-x01-y01");
	_hist_wd_charge = bookHisto1D("d01-x01-y02");
	_hist_wdstar_charge = bookHisto1D("d01-x01-y03");

	// charge integrated total cross sections
	_hist_wcjet_ratio = bookScatter2D("d02-x01-y01");
	_hist_wd_ratio = bookScatter2D("d02-x01-y02");

	_hist_wcjet_minus = bookHisto1D("d02-x01-y01_minus");
	_hist_wd_minus = bookHisto1D("d02-x01-y02_minus");

	_hist_wcjet_plus = bookHisto1D("d02-x01-y01_plus");
	_hist_wd_plus = bookHisto1D("d02-x01-y02_plus");

	// eta distributions
	_hist_wplus_wcjet_eta_lep = bookHisto1D("d03-x01-y01");
	_hist_wminus_wcjet_eta_lep = bookHisto1D("d03-x01-y02");

	_hist_wplus_wdminus_eta_lep = bookHisto1D("d04-x01-y01");
	_hist_wminus_wdplus_eta_lep = bookHisto1D("d04-x01-y02");
	_hist_wplus_wdstar_eta_lep = bookHisto1D("d04-x01-y03");
	_hist_wminus_wdstar_eta_lep = bookHisto1D("d04-x01-y04");

	// ratio of cross section (WD over W inclusive) // postprocess!
	_hist_w_inc = bookHisto1D("d05-x01-y01");
	_hist_wd_winc_ratio = bookScatter2D("d05-x01-y02");
	_hist_wdstar_winc_ratio = bookScatter2D("d05-x01-y03");

	// ratio of cross section (WD over W inclusive -- function of pT of D meson)
	_hist_wplusd_wplusinc_pt_ratio = bookScatter2D("d06-x01-y01");
	_hist_wminusd_wminusinc_pt_ratio = bookScatter2D("d06-x01-y02");
	_hist_wplusdstar_wplusinc_pt_ratio = bookScatter2D("d06-x01-y03");
	_hist_wminusdstar_wminusinc_pt_ratio = bookScatter2D("d06-x01-y04");

	// could use for postprocessing!
	_hist_wplusd_wplusinc_pt = bookHisto1D("d06-x01-y01_wplus");
	_hist_wminusd_wminusinc_pt = bookHisto1D("d06-x01-y02_wminus");
	_hist_wplusdstar_wplusinc_pt = bookHisto1D("d06-x01-y03_wplus");
	_hist_wminusdstar_wminusinc_pt = bookHisto1D("d06-x01-y04_wminus");

	_hist_wplus_winc = bookHisto1D("d06-x01-y01_winc");
	_hist_wminus_winc = bookHisto1D("d06-x01-y02_winc");

	// jet multiplicity of charge integrated W+cjet cross section (+0 or +1 jet in addition to the charm jet)
	_hist_wcjet_jets = bookHisto1D("d07-x01-y01");

	// jet multiplicity of W+cjet cross section ratio (+0 or +1 jet in addition to the charm jet)
	_hist_wcjet_jets_ratio = bookScatter2D("d08-x01-y01");
	_hist_wcjet_jets_plus = bookHisto1D("d08-x01-y01_plus");
	_hist_wcjet_jets_minus = bookHisto1D("d08-x01-y01_minus");

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	double charge_weight = 0; // account for OS/SS events

	int lepton_charge = 0;
	double lepton_eta = 0.;

	/// Find leptons
	- const WFinder& wfinder_born_el = applyProjection<WFinder>(event, "WFinder_born_el");
	- const WFinder& wfinder_born_mu = applyProjection<WFinder>(event, "WFinder_born_mu");
	+ const WFinder& wfinder_born_el = apply<WFinder>(event, "WFinder_born_el");
	+ const WFinder& wfinder_born_mu = apply<WFinder>(event, "WFinder_born_mu");

	if(wfinder_born_el.empty() && wfinder_born_mu.empty() ) {
	MSG_DEBUG("No W bosons found");
	vetoEvent;
	}

	bool keepevent = false;

	//check electrons
	if(!wfinder_born_el.empty()) {
	const FourMomentum& nu = wfinder_born_el.constituentNeutrinos()[0].momentum();
	if(wfinder_born_el.mT() > 40GeV && nu.pT() > 25GeV) {
	keepevent = true;
	lepton_charge = wfinder_born_el.constituentLeptons()[0].charge();
	lepton_eta = fabs(wfinder_born_el.constituentLeptons()[0].pseudorapidity());
	}
	}

	//check muons
	if(!wfinder_born_mu.empty()) {
	const FourMomentum& nu = wfinder_born_mu.constituentNeutrinos()[0].momentum();
	if(wfinder_born_mu.mT() > 40GeV && nu.pT() > 25GeV) {
	keepevent = true;
	lepton_charge = wfinder_born_mu.constituentLeptons()[0].charge();
	lepton_eta = fabs(wfinder_born_mu.constituentLeptons()[0].pseudorapidity());
	}
	}

	if(!keepevent) {
	MSG_DEBUG("event does not pass mT and MET cuts");
	vetoEvent;
	}

	if (lepton_charge > 0) {
	_hist_wplus_winc->fill(10., weight);
	_hist_wplus_winc->fill(16., weight);
	_hist_wplus_winc->fill(30., weight);
	_hist_wplus_winc->fill(60., weight);
	_hist_w_inc->fill(+1, weight);
	}
	else if (lepton_charge < 0) {
	_hist_wminus_winc->fill(10., weight);
	_hist_wminus_winc->fill(16., weight);
	_hist_wminus_winc->fill(30., weight);
	_hist_wminus_winc->fill(60., weight);
	_hist_w_inc->fill(-1, weight);
	}

	// Find hadrons in the event
	- const UnstableFinalState& fs = applyProjection<UnstableFinalState>(event, "hadrons");
	+ const UnstableFinalState& fs = apply<UnstableFinalState>(event, "hadrons");

	/// FIND Different channels
	// 1: wcjet
	// get jets
	- const Jets& jets = applyProjection<FastJets>(event, "jets").jetsByPt(Cuts::pT>25.0*GeV && Cuts::abseta<2.5);
	+ const Jets& jets = apply<FastJets>(event, "jets").jetsByPt(Cuts::pT>25.0*GeV && Cuts::abseta<2.5);
	// loop over jets to select jets used to match to charm
	Jets js;
	int matched_charmHadron = 0;
	double charm_charge = 0.;
	int njets = 0;
	int nj = 0;
	bool mat_jet = false;

	double ptcharm = 0;

	if(matched_charmHadron > -1) {
	foreach(const Jet& j, jets) {
	mat_jet = false;
	njets++;
	foreach(const Particle& p, fs.particles()) {
	const GenParticle* part = p.genParticle();
	if(p.hasCharm()) {
	//if(isFromBDecay(p)) continue;
	if(p.fromBottom()) continue;
	if(p.pT() < 5*GeV ) continue;
	if(hasCharmedChildren(part)) continue;
	if(deltaR(p, j) < 0.3) {
	mat_jet = true;
	if(p.pT() > ptcharm) {
	charm_charge = part->pdg_id();
	ptcharm = p.pT();
	}
	}
	}
	}
	if(mat_jet) nj++;
	}

	if (charm_charge * lepton_charge > 0) charge_weight = -1;
	else charge_weight = +1;

	if(nj == 1) {
	if (lepton_charge > 0) {
	_hist_wcjet_charge ->fill( 1, weight*charge_weight);
	_hist_wcjet_plus ->fill( 0, weight*charge_weight);
	_hist_wplus_wcjet_eta_lep ->fill(lepton_eta, weight*charge_weight);
	_hist_wcjet_jets_plus ->fill(njets-1 , weight*charge_weight);
	}
	else if (lepton_charge < 0) {
	_hist_wcjet_charge ->fill( -1, weight*charge_weight);
	_hist_wcjet_minus ->fill( 0, weight*charge_weight);
	_hist_wminus_wcjet_eta_lep->fill(lepton_eta, weight*charge_weight);
	_hist_wcjet_jets_minus ->fill(njets-1 , weight*charge_weight);
	}

	_hist_wcjet_jets->fill(njets-1, weight*charge_weight);
	}
	}

	// // 1/2: w+d(*) meson

	foreach(const Particle& p, fs.particles()) {

	const GenParticle* part = p.genParticle();
	if(p.pT() < 8*GeV) continue;
	if(fabs(p.eta()) > 2.2) continue;

	// W+D
	if(abs(part->pdg_id()) == 411) {
	if(lepton_charge * part->pdg_id() > 0) charge_weight = -1;
	else charge_weight = +1;

	// fill histos
	if (lepton_charge > 0) {
	_hist_wd_charge ->fill( 1, weight*charge_weight);
	_hist_wd_plus ->fill( 0, weight*charge_weight);
	_hist_wplus_wdminus_eta_lep->fill(lepton_eta, weight*charge_weight);
	_hist_wplusd_wplusinc_pt ->fill( p.pT(), weight*charge_weight);
	}
	else if (lepton_charge < 0) {
	_hist_wd_charge ->fill( -1, weight*charge_weight);
	_hist_wd_minus ->fill( 0, weight*charge_weight);
	_hist_wminus_wdplus_eta_lep->fill(lepton_eta, weight*charge_weight);
	_hist_wminusd_wminusinc_pt ->fill(p.pT() , weight*charge_weight);
	}
	}

	// W+Dstar
	if( abs(part->pdg_id()) == 413 ) {
	if (lepton_charge*part->pdg_id() > 0) charge_weight = -1;
	else charge_weight = +1;

	if (lepton_charge > 0) {
	_hist_wdstar_charge->fill(+1, weight*charge_weight);
	_hist_wd_plus->fill( 0, weight*charge_weight);
	_hist_wplus_wdstar_eta_lep->fill( lepton_eta, weight*charge_weight);
	_hist_wplusdstar_wplusinc_pt->fill( p.pT(), weight*charge_weight);
	}
	else if (lepton_charge < 0) {
	_hist_wdstar_charge->fill(-1, weight*charge_weight);
	_hist_wd_minus->fill(0, weight*charge_weight);
	_hist_wminus_wdstar_eta_lep->fill(lepton_eta, weight*charge_weight);
	_hist_wminusdstar_wminusinc_pt->fill(p.pT(), weight*charge_weight);
	}
	}
	}
	}// end of analyse function


	/// Normalise histograms etc., after the run
	void finalize() {

	/// @todo Normalise, scale and otherwise manipulate histograms here
	const double sf( crossSection() / sumOfWeights() );

	// norm to cross section
	// d01
	scale(_hist_wcjet_charge, sf);
	scale(_hist_wd_charge, sf);
	scale(_hist_wdstar_charge, sf);

	//d02
	scale(_hist_wcjet_plus, sf);
	scale(_hist_wcjet_minus, sf);
	scale(_hist_wd_plus, sf);
	scale(_hist_wd_minus, sf);

	divide(_hist_wcjet_plus, _hist_wcjet_minus, _hist_wcjet_ratio);
	divide(_hist_wd_plus, _hist_wd_minus, _hist_wd_ratio );

	//d03
	scale(_hist_wplus_wcjet_eta_lep, sf);
	scale(_hist_wminus_wcjet_eta_lep, sf);

	//d04
	scale(_hist_wplus_wdminus_eta_lep, crossSection()/sumOfWeights());
	scale(_hist_wminus_wdplus_eta_lep, crossSection()/sumOfWeights());

	scale(_hist_wplus_wdstar_eta_lep , crossSection()/sumOfWeights());
	scale(_hist_wminus_wdstar_eta_lep, crossSection()/sumOfWeights());

	//d05
	scale(_hist_w_inc, 0.01 * sf); // in percent --> /100
	divide(_hist_wd_charge, _hist_w_inc, _hist_wd_winc_ratio );
	divide(_hist_wdstar_charge, _hist_w_inc, _hist_wdstar_winc_ratio);

	//d06, in percentage!
	scale(_hist_wplusd_wplusinc_pt, sf);
	scale(_hist_wminusd_wminusinc_pt, sf);
	scale(_hist_wplusdstar_wplusinc_pt, sf);
	scale(_hist_wminusdstar_wminusinc_pt, sf);

	scale(_hist_wplus_winc, 0.01 * sf); // in percent --> /100
	scale(_hist_wminus_winc, 0.01 * sf); // in percent --> /100

	divide(_hist_wplusd_wplusinc_pt, _hist_wplus_winc , _hist_wplusd_wplusinc_pt_ratio );
	divide(_hist_wminusd_wminusinc_pt, _hist_wminus_winc, _hist_wminusd_wminusinc_pt_ratio );
	divide(_hist_wplusdstar_wplusinc_pt, _hist_wplus_winc , _hist_wplusdstar_wplusinc_pt_ratio );
	divide(_hist_wminusdstar_wminusinc_pt, _hist_wminus_winc, _hist_wminusdstar_wminusinc_pt_ratio);


	//d07
	scale(_hist_wcjet_jets, sf);

	//d08
	scale(_hist_wcjet_jets_minus, sf);
	scale(_hist_wcjet_jets_plus, sf);
	divide(_hist_wcjet_jets_plus, _hist_wcjet_jets_minus , _hist_wcjet_jets_ratio);
	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here

	// Check whether particle comes from b-decay
	bool isFromBDecay(const Particle& p) {

	bool isfromB = false;

	if(p.genParticle() == NULL) return false;

	const GenParticle* part = p.genParticle();
	const GenVertex* ivtx = const_cast<const GenVertex*>(part->production_vertex());
	while(ivtx) {
	if(ivtx->particles_in_size() < 1) {
	isfromB = false;
	break;
	}
	const HepMC::GenVertex::particles_in_const_iterator iPart_invtx = ivtx->particles_in_const_begin();
	part = (*iPart_invtx);
	if(!part) {
	isfromB = false;
	break;
	}
	isfromB = PID::hasBottom(part->pdg_id());
	if(isfromB == true) break;
	ivtx = const_cast<const GenVertex*>(part->production_vertex());
	if( part->pdg_id() == 2212 \|\| !ivtx ) break; // reached beam
	}
	return isfromB;
	}


	// Check whether particle has charmed children
	bool hasCharmedChildren(const GenParticle *part) {

	bool hasCharmedChild = false;
	if(part == NULL) return false;

	const GenVertex* ivtx = const_cast<const GenVertex*>(part->end_vertex());
	if(ivtx == NULL) return false;

	// if (ivtx->particles_out_size() < 2) return false;
	HepMC::GenVertex::particles_out_const_iterator iPart_invtx = ivtx->particles_out_const_begin();
	HepMC::GenVertex::particles_out_const_iterator end_invtx = ivtx->particles_out_const_end();

	for( ; iPart_invtx != end_invtx; iPart_invtx++ ) {
	const GenParticle* p2 = (*iPart_invtx);
	if( p2 == part) continue;
	hasCharmedChild = PID::hasCharm(p2->pdg_id());
	if(hasCharmedChild == true) break;
	hasCharmedChild = hasCharmedChildren(p2);
	if(hasCharmedChild == true) break;
	}
	return hasCharmedChild;
	}


	private:

	/// @name Histograms
	//@{

	//d01-x01-
	Histo1DPtr _hist_wcjet_charge;
	Histo1DPtr _hist_wd_charge;
	Histo1DPtr _hist_wdstar_charge;

	//d02-x01-
	Scatter2DPtr _hist_wcjet_ratio;
	Scatter2DPtr _hist_wd_ratio;
	Histo1DPtr _hist_wcjet_plus;
	Histo1DPtr _hist_wd_plus;

	Histo1DPtr _hist_wcjet_minus;
	Histo1DPtr _hist_wd_minus;

	//d03-x01-
	Histo1DPtr _hist_wplus_wcjet_eta_lep;
	Histo1DPtr _hist_wminus_wcjet_eta_lep;

	//d04-x01-
	Histo1DPtr _hist_wplus_wdminus_eta_lep;
	Histo1DPtr _hist_wminus_wdplus_eta_lep;

	//d05-x01-
	Histo1DPtr _hist_wplus_wdstar_eta_lep;
	Histo1DPtr _hist_wminus_wdstar_eta_lep;


	// postprocessing histos
	//d05-x01
	Histo1DPtr _hist_w_inc;
	Scatter2DPtr _hist_wd_winc_ratio;
	Scatter2DPtr _hist_wdstar_winc_ratio;

	//d06-x01
	Histo1DPtr _hist_wplus_winc;
	Histo1DPtr _hist_wminus_winc;

	Scatter2DPtr _hist_wplusd_wplusinc_pt_ratio;
	Scatter2DPtr _hist_wminusd_wminusinc_pt_ratio;
	Scatter2DPtr _hist_wplusdstar_wplusinc_pt_ratio;
	Scatter2DPtr _hist_wminusdstar_wminusinc_pt_ratio;

	Histo1DPtr _hist_wplusd_wplusinc_pt ;
	Histo1DPtr _hist_wminusd_wminusinc_pt;
	Histo1DPtr _hist_wplusdstar_wplusinc_pt;
	Histo1DPtr _hist_wminusdstar_wminusinc_pt;

	// d07-x01
	Histo1DPtr _hist_wcjet_jets ;

	//d08-x01
	Scatter2DPtr _hist_wcjet_jets_ratio ;
	Histo1DPtr _hist_wcjet_jets_plus ;
	Histo1DPtr _hist_wcjet_jets_minus;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1282447);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1288706.cc b/src/Analyses/ATLAS_2014_I1288706.cc
	--- a/src/Analyses/ATLAS_2014_I1288706.cc
	+++ b/src/Analyses/ATLAS_2014_I1288706.cc
	@@ -1,111 +1,111 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Particle.fhh"

	namespace Rivet {


	class ATLAS_2014_I1288706 : public Analysis {
	public:

	/// Constructor
	ATLAS_2014_I1288706()
	: Analysis("ATLAS_2014_I1288706")
	{
	_sumw_ext_mu_dressed = 0;
	_sumw_mu_dressed = 0;
	_sumw_el_dressed = 0;
	}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Set up projections
	FinalState fs;

	ZFinder zfinder_ext_dressed_mu(fs, Cuts::abseta<2.4 && Cuts::pT>6.0GeV, PID::MUON, 12.0GeV, 66.0*GeV, 0.1);
	- addProjection(zfinder_ext_dressed_mu, "ZFinder_ext_dressed_mu");
	+ declare(zfinder_ext_dressed_mu, "ZFinder_ext_dressed_mu");

	ZFinder zfinder_dressed_mu(fs, Cuts::abseta<2.4 && Cuts::pT>12GeV, PID::MUON, 26.0GeV, 66.0*GeV, 0.1);
	- addProjection(zfinder_dressed_mu, "ZFinder_dressed_mu");
	+ declare(zfinder_dressed_mu, "ZFinder_dressed_mu");

	ZFinder zfinder_dressed_el(fs, Cuts::abseta<2.4 && Cuts::pT>12GeV, PID::ELECTRON, 26.0GeV, 66.0*GeV, 0.1);
	- addProjection(zfinder_dressed_el, "ZFinder_dressed_el");
	+ declare(zfinder_dressed_el, "ZFinder_dressed_el");

	_hist_ext_mu_dressed = bookHisto1D(1, 1, 1); // muon, dressed level, extended phase space
	_hist_mu_dressed = bookHisto1D(2, 1, 1); // muon, dressed level, nominal phase space
	_hist_el_dressed = bookHisto1D(2, 1, 2); // electron, dressed level, nominal phase space
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ZFinder& zfinder_ext_dressed_mu = applyProjection<ZFinder>(event, "ZFinder_ext_dressed_mu");
	- const ZFinder& zfinder_dressed_mu = applyProjection<ZFinder>(event, "ZFinder_dressed_mu" );
	- const ZFinder& zfinder_dressed_el = applyProjection<ZFinder>(event, "ZFinder_dressed_el" );
	+ const ZFinder& zfinder_ext_dressed_mu = apply<ZFinder>(event, "ZFinder_ext_dressed_mu");
	+ const ZFinder& zfinder_dressed_mu = apply<ZFinder>(event, "ZFinder_dressed_mu" );
	+ const ZFinder& zfinder_dressed_el = apply<ZFinder>(event, "ZFinder_dressed_el" );

	FillPlots(zfinder_ext_dressed_mu, _hist_ext_mu_dressed, 9.0, weight);
	FillPlots(zfinder_dressed_mu, _hist_mu_dressed, 15.0, weight);
	FillPlots(zfinder_dressed_el, _hist_el_dressed, 15.0, weight);
	}


	void FillPlots(const ZFinder& zfinder, Histo1DPtr hist, double leading_pT, double weight) {

	if(zfinder.bosons().size() != 1) return;

	const FourMomentum el1 = zfinder.particles()[0].momentum();
	const FourMomentum el2 = zfinder.particles()[1].momentum();

	if (el1.pT() > leading_pTGeV \|\| el2.pT() > leading_pTGeV) {
	double mass = zfinder.bosons()[0].mass()/GeV;
	hist->fill(mass, weight);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	scale(_hist_ext_mu_dressed, crossSection()/sumOfWeights());
	scale(_hist_mu_dressed, crossSection()/sumOfWeights());
	scale(_hist_el_dressed, crossSection()/sumOfWeights());

	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here
	double _sumw_ext_mu_dressed;
	double _sumw_mu_dressed;
	double _sumw_el_dressed;

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _hist_ext_mu_dressed;
	Histo1DPtr _hist_mu_dressed;
	Histo1DPtr _hist_el_dressed;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1288706);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1298023.cc b/src/Analyses/ATLAS_2014_I1298023.cc
	--- a/src/Analyses/ATLAS_2014_I1298023.cc
	+++ b/src/Analyses/ATLAS_2014_I1298023.cc
	@@ -1,128 +1,128 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedLeptons.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/DressedLeptons.hh"

	namespace Rivet {

	/// ATLAS same-sign WW production at 8 TeV (PRL)
	class ATLAS_2014_I1298023 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{
	ATLAS_2014_I1298023()
	: Analysis("ATLAS_2014_I1298023")
	{
	setNeedsCrossSection(true);
	}
	//@}


	public:

	/// @name Analysis methods
	//@{

	void init() {

	const FinalState fs;

	// bare leptons
	ChargedLeptons bare_leptons(fs);

	// dressed leptons
	Cut cuts = (Cuts::abseta < 2.5) & (Cuts::pT > 25*GeV);
	DressedLeptons leptons(fs, bare_leptons, 0.1, cuts);
	- addProjection(leptons, "leptons");
	+ declare(leptons, "leptons");

	// MET
	- addProjection(MissingMomentum(fs), "MissingET");
	+ declare(MissingMomentum(fs), "MissingET");

	// jets
	VetoedFinalState vfs(fs);
	vfs.addVetoPairId(PID::MUON);
	vfs.vetoNeutrinos();
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "jets");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "jets");

	// book histogram
	_hist = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const vector<DressedLepton>& leptons = applyProjection<DressedLeptons>(event, "leptons").dressedLeptons();
	+ const vector<DressedLepton>& leptons = apply<DressedLeptons>(event, "leptons").dressedLeptons();
	if ( leptons.size() < 2 ) vetoEvent;

	double minDR_ll = MAXDOUBLE, mll = -1.0;
	for (unsigned int i = 0; i < leptons.size(); ++i) {
	DressedLepton lep1 = leptons[i];
	for (unsigned int j = i + 1; j < leptons.size(); ++j) {
	DressedLepton lep2 = leptons[j];
	double dr = deltaR(lep1, lep2);
	if ( dr < minDR_ll ) minDR_ll = dr;
	double m = (lep1.momentum() + lep2.momentum()).mass();
	if ( mll < 0. \|\| m < mll ) mll = m;
	}
	}
	if ( minDR_ll <= 0.3 \|\| mll <= 20*GeV ) vetoEvent;

	if ( leptons[0].charge() * leptons[1].charge() < 0.0 ) vetoEvent;

	- const MissingMomentum& met = applyProjection<MissingMomentum>(event, "MissingET");
	+ const MissingMomentum& met = apply<MissingMomentum>(event, "MissingET");
	if ( met.vectorEt().mod() <= 40*GeV ) vetoEvent;

	- const Jets& all_jets = applyProjection<FastJets>(event, "jets").jetsByPt( (Cuts::abseta < 4.5) && (Cuts::pT > 30*GeV) );
	+ const Jets& all_jets = apply<FastJets>(event, "jets").jetsByPt( (Cuts::abseta < 4.5) && (Cuts::pT > 30*GeV) );
	Jets jets;
	double minDR_overall = MAXDOUBLE;
	foreach (const Jet& jet, all_jets) {
	double minDR_jet = MAXDOUBLE, minDR_electrons = MAXDOUBLE;
	foreach( DressedLepton lep, leptons ) {
	double dr = deltaR(jet, lep);
	if ( dr < minDR_jet ) minDR_jet = dr;
	if ( lep.abspid() == 11 && dr < minDR_electrons ) minDR_electrons = dr;
	}
	if ( minDR_electrons < 0.05 ) continue; // veto jet if it overlaps with electron
	if ( minDR_jet < minDR_overall ) minDR_overall = minDR_jet;
	jets += jet;
	}
	if ( jets.size() < 2 \|\| minDR_overall <= 0.3 ) vetoEvent;

	FourMomentum dijet = jets[0].momentum() + jets[1].momentum();
	if ( dijet.mass() <= 500*GeV ) vetoEvent;

	// inclusive region
	_hist->fill(0.5, weight);

	// VBS region
	if ( deltaRap(jets[0], jets[1]) > 2.4 ) _hist->fill(1.5, weight);
	}

	/// Normalise histograms etc., after the run
	void finalize() {

	const double scalefactor( crossSection() / sumOfWeights() );
	scale(_hist, scalefactor);

	}
	//@}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _hist;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1298023);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1298811.cc b/src/Analyses/ATLAS_2014_I1298811.cc
	--- a/src/Analyses/ATLAS_2014_I1298811.cc
	+++ b/src/Analyses/ATLAS_2014_I1298811.cc
	@@ -1,199 +1,199 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2014_I1298811 : public Analysis {
	public:


	ATLAS_2014_I1298811()
	: Analysis("ATLAS_2014_I1298811") { }


	void init() {
	// Configure projections
	const FinalState fs(-4.8, 4.8, 0*MeV);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	const FastJets jets(fs, FastJets::ANTIKT, 0.4);
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	// Book histograms
	for (size_t itopo = 0; itopo < 2; ++itopo) {
	// Profiles
	for (size_t iregion = 0; iregion < 3; ++iregion) {
	_p_ptsumch_vs_ptlead[itopo][iregion] = bookProfile1D(1+iregion, 1, itopo+1);
	_p_nch_vs_ptlead[itopo][iregion] = bookProfile1D(4+iregion, 1, itopo+1);
	}
	_p_etsum25_vs_ptlead_trans[itopo] = bookProfile1D(7, 1, itopo+1);
	_p_etsum48_vs_ptlead_trans[itopo] = bookProfile1D(8, 1, itopo+1);
	_p_chratio_vs_ptlead_trans[itopo] = bookProfile1D(9, 1, itopo+1);
	_p_ptmeanch_vs_ptlead_trans[itopo] = bookProfile1D(10, 1, itopo+1);
	_p_ptmeanch_vs_nch_trans[0] = bookProfile1D(11, 1, 1);
	_p_ptmeanch_vs_nch_trans[1] = bookProfile1D(12, 1, 1);
	// 1D histos
	for (size_t iregion = 0; iregion < 3; ++iregion) {
	for (size_t ipt = 0; ipt < 4; ++ipt) {
	_h_ptsumch[ipt][itopo][iregion] = bookHisto1D(13+3*ipt+iregion, 1, itopo+1);
	_h_nch[ipt][itopo][iregion] = bookHisto1D(25+3*ipt+iregion, 1, itopo+1);
	}
	}
	}

	}



	void analyze(const Event& event) {
	// Find the jets with pT > 20 GeV and rapidity within 2.8
	/// @todo Use Cuts instead rather than an eta cut in the proj and a y cut after
	- const Jets alljets = applyProjection<FastJets>(event, "Jets").jetsByPt(20*GeV);
	+ const Jets alljets = apply<FastJets>(event, "Jets").jetsByPt(20*GeV);
	Jets jets;
	foreach (const Jet& j, alljets)
	if (j.absrap() < 2.8) jets.push_back(j);
	// Require at least one jet in the event
	if (jets.empty()) vetoEvent;

	// Get the event weight since we will be filling some histos
	const double weight = event.weight();

	// Identify the leading jet and its phi and pT
	const FourMomentum plead = jets[0].momentum();
	const double philead = plead.phi();
	const double etalead = plead.eta();
	const double ptlead = plead.pT();
	MSG_DEBUG("Leading object: pT = " << ptlead << ", eta = " << etalead << ", phi = " << philead);

	// Sum particle properties in the transverse regions
	int tmpnch[2] = {0,0};
	double tmpptsum[2] = {0,0};
	double tmpetsum48[2] = {0,0};
	double tmpetsum25[2] = {0,0};
	- const Particles particles = applyProjection<FinalState>(event, "FS").particles();
	+ const Particles particles = apply<FinalState>(event, "FS").particles();
	foreach (const Particle& p, particles) {
	// Only consider the transverse region(s), not toward or away
	if (!inRange(deltaPhi(p.phi(), philead), PI/3.0, TWOPI/3.0)) continue;
	// Work out which transverse side this particle is on
	const size_t iside = (mapAngleMPiToPi(p.phi() - philead) > 0) ? 0 : 1;
	MSG_TRACE(p.phi() << " vs. " << philead << ": " << iside);
	// Charged or neutral particle?
	const bool charged = PID::threeCharge(p.pdgId()) != 0;
	// Track observables
	if (charged && fabs(p.eta()) < 2.5 && p.pT() > 500*MeV) {
	tmpnch[iside] += 1;
	tmpptsum[iside] += p.pT();
	}
	// Cluster observables
	if ((charged && p.p3().mod() > 200MeV) \|\| (!charged && p.p3().mod() > 500MeV)) {
	tmpetsum48[iside] += p.pT();
	if (fabs(p.eta()) < 2.5) tmpetsum25[iside] += p.pT();
	}
	}

	// Construct tot/max/min counts (for trans/max/min, indexed by iregion)
	const int nch[3] = { tmpnch[0] + tmpnch[1],
	std::max(tmpnch[0], tmpnch[1]),
	std::min(tmpnch[0], tmpnch[1]) };
	const double ptsum[3] = { tmpptsum[0] + tmpptsum[1],
	std::max(tmpptsum[0], tmpptsum[1]),
	std::min(tmpptsum[0], tmpptsum[1]) };
	const double etsum48[3] = { tmpetsum48[0] + tmpetsum48[1],
	std::max(tmpetsum48[0], tmpetsum48[1]),
	std::min(tmpetsum48[0], tmpetsum48[1]) };
	const double etsum25[3] = { tmpetsum25[0] + tmpetsum25[1],
	std::max(tmpetsum25[0], tmpetsum25[1]),
	std::min(tmpetsum25[0], tmpetsum25[1]) };


	//////////////////////////////////////////////////////////
	// Now fill the histograms with the computed quantities

	// phi sizes of each trans/max/min region (for indexing by iregion)
	const double dphi[3] = { 2*PI/3.0, PI/3.0, PI/3.0 };

	// Loop over inclusive jet and exclusive dijet configurations
	for (size_t itopo = 0; itopo < 2; ++itopo) {

	// Exit early if in the exclusive dijet iteration and the exclusive dijet cuts are not met
	if (itopo == 1) {
	if (jets.size() != 2) continue;
	const FourMomentum psublead = jets[1].momentum();
	// Delta(phi) cut
	const double phisublead = psublead.phi();
	if (deltaPhi(philead, phisublead) < 2.5) continue;
	// pT fraction cut
	const double ptsublead = psublead.pT();
	if (ptsublead < 0.5*ptlead) continue;
	MSG_DEBUG("Exclusive dijet event");
	}

	// Plot profiles and distributions which have no max/min region definition
	_p_etsum25_vs_ptlead_trans[itopo]->fill(ptlead/GeV, etsum25[0]/5.0/dphi[0]/GeV, weight);
	_p_etsum48_vs_ptlead_trans[itopo]->fill(ptlead/GeV, etsum48[0]/9.6/dphi[0]/GeV, weight);
	if (etsum25[0] > 0) {
	_p_chratio_vs_ptlead_trans[itopo]->fill(ptlead/GeV, ptsum[0]/etsum25[0], weight);
	}
	const double ptmean = safediv(ptsum[0], nch[0], -1); ///< Return -1 if div by zero
	if (ptmean >= 0) {
	_p_ptmeanch_vs_ptlead_trans[itopo]->fill(ptlead/GeV, ptmean/GeV, weight);
	_p_ptmeanch_vs_nch_trans[itopo]->fill(nch[0], ptmean/GeV, weight);
	}

	// Plot remaining profile and 1D observables, which are defined in all 3 tot/max/min regions
	for (size_t iregion = 0; iregion < 3; ++iregion) {
	_p_ptsumch_vs_ptlead[itopo][iregion]->fill(ptlead/GeV, ptsum[iregion]/5.0/dphi[iregion]/GeV, weight);
	_p_nch_vs_ptlead[itopo][iregion]->fill(ptlead/GeV, nch[iregion]/5.0/dphi[iregion], weight);
	for (size_t ipt = 0; ipt < 4; ++ipt) {
	if (ipt == 1 && !inRange(ptlead/GeV, 20, 60)) continue;
	if (ipt == 2 && !inRange(ptlead/GeV, 60, 210)) continue;
	if (ipt == 3 && ptlead/GeV < 210) continue;
	_h_ptsumch[ipt][itopo][iregion]->fill(ptsum[iregion]/5.0/dphi[iregion]/GeV, weight);
	_h_nch[ipt][itopo][iregion]->fill(nch[iregion]/5.0/dphi[iregion], weight);
	}
	}
	}

	}



	void finalize() {
	for (size_t iregion = 0; iregion < 3; ++iregion) {
	for (size_t itopo = 0; itopo < 2; ++itopo) {
	for (size_t ipt = 0; ipt < 4; ++ipt) {
	normalize(_h_ptsumch[ipt][itopo][iregion], 1.0);
	normalize(_h_nch[ipt][itopo][iregion], 1.0);
	}
	}
	}
	}


	private:

	/// @name Histogram arrays
	//@{

	Profile1DPtr _p_ptsumch_vs_ptlead[2][3];
	Profile1DPtr _p_nch_vs_ptlead[2][3];
	Profile1DPtr _p_ptmeanch_vs_ptlead_trans[2];
	Profile1DPtr _p_etsum25_vs_ptlead_trans[2];
	Profile1DPtr _p_etsum48_vs_ptlead_trans[2];
	Profile1DPtr _p_chratio_vs_ptlead_trans[2];
	Profile1DPtr _p_ptmeanch_vs_nch_trans[2];
	Histo1DPtr _h_ptsumch[4][2][3];
	Histo1DPtr _h_nch[4][2][3];

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1298811);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1300647.cc b/src/Analyses/ATLAS_2014_I1300647.cc
	--- a/src/Analyses/ATLAS_2014_I1300647.cc
	+++ b/src/Analyses/ATLAS_2014_I1300647.cc
	@@ -1,134 +1,134 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	/// @todo Include more projections as required, e.g. ChargedFinalState, FastJets, ZFinder...

	namespace Rivet {


	class ATLAS_2014_I1300647 : public Analysis {
	public:

	/// Constructor
	ATLAS_2014_I1300647()
	: Analysis("ATLAS_2014_I1300647")
	{ }


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;

	ZFinder zfinder_dressed_el(fs, Cuts::abseta<2.4 && Cuts::pT>20.0GeV, PID::ELECTRON, 66.0GeV, 116.0*GeV, 0.1);
	- addProjection(zfinder_dressed_el, "ZFinder_dressed_el");
	+ declare(zfinder_dressed_el, "ZFinder_dressed_el");

	ZFinder zfinder_bare_el(fs, Cuts::abseta<2.4 && Cuts::pT>20.0GeV, PID::ELECTRON, 66.0GeV, 116.0*GeV, 0.0);
	- addProjection(zfinder_bare_el, "ZFinder_bare_el");
	+ declare(zfinder_bare_el, "ZFinder_bare_el");

	ZFinder zfinder_dressed_mu(fs, Cuts::abseta<2.4 && Cuts::pT>20.0GeV, PID::MUON, 66.0GeV, 116.0*GeV, 0.1);
	- addProjection(zfinder_dressed_mu, "ZFinder_dressed_mu");
	+ declare(zfinder_dressed_mu, "ZFinder_dressed_mu");

	ZFinder zfinder_bare_mu(fs, Cuts::abseta<2.4 && Cuts::pT>20.0GeV, PID::MUON, 66.0GeV, 116.0*GeV, 0.0);
	- addProjection(zfinder_bare_mu, "ZFinder_bare_mu");
	+ declare(zfinder_bare_mu, "ZFinder_bare_mu");

	// Book histograms
	_hist_zpt_el_dressed = bookHisto1D(1, 1, 1); // electron "dressed"
	_hist_zpt_mu_dressed = bookHisto1D(1, 1, 2); // muon "dressed"
	_hist_zpt_el_bare = bookHisto1D(1, 2, 1); // electron "bare"
	_hist_zpt_mu_bare = bookHisto1D(1, 2, 2); // muon "bare"

	//double-differential plots
	_h_zpt_el_mu_dressed.addHistogram(0.0, 1.0, bookHisto1D(3, 1, 2));
	_h_zpt_el_mu_dressed.addHistogram(1.0, 2.0, bookHisto1D(3, 1, 4));
	_h_zpt_el_mu_dressed.addHistogram(2.0, 2.4, bookHisto1D(3, 1, 6));

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	- const ZFinder& zfinder_dressed_el = applyProjection<ZFinder>(event, "ZFinder_dressed_el");
	- const ZFinder& zfinder_bare_el = applyProjection<ZFinder>(event, "ZFinder_bare_el");
	- const ZFinder& zfinder_dressed_mu = applyProjection<ZFinder>(event, "ZFinder_dressed_mu");
	- const ZFinder& zfinder_bare_mu = applyProjection<ZFinder>(event, "ZFinder_bare_mu");
	+ const ZFinder& zfinder_dressed_el = apply<ZFinder>(event, "ZFinder_dressed_el");
	+ const ZFinder& zfinder_bare_el = apply<ZFinder>(event, "ZFinder_bare_el");
	+ const ZFinder& zfinder_dressed_mu = apply<ZFinder>(event, "ZFinder_dressed_mu");
	+ const ZFinder& zfinder_bare_mu = apply<ZFinder>(event, "ZFinder_bare_mu");

	FillPlots1d(zfinder_dressed_el, _hist_zpt_el_dressed, weight);

	FillPlots1d(zfinder_bare_el, _hist_zpt_el_bare, weight);

	FillPlots1d(zfinder_dressed_mu, _hist_zpt_mu_dressed, weight);

	FillPlots1d(zfinder_bare_mu, _hist_zpt_mu_bare, weight);

	FillPlots3d(zfinder_dressed_el, _h_zpt_el_mu_dressed, weight);
	FillPlots3d(zfinder_dressed_mu, _h_zpt_el_mu_dressed, weight);

	}

	void FillPlots1d(const ZFinder& zfinder, Histo1DPtr hist, double weight) {
	if(zfinder.bosons().size() != 1) return;
	const FourMomentum pZ = zfinder.bosons()[0].momentum();
	hist->fill(pZ.pT()/GeV, weight);
	return;
	}

	void FillPlots3d(const ZFinder& zfinder, BinnedHistogram<double>& binnedHist, double weight) {
	if(zfinder.bosons().size() != 1) return;
	const FourMomentum pZ = zfinder.bosons()[0].momentum();
	binnedHist.fill(pZ.rapidity(), pZ.pT()/GeV, weight);
	return;
	}

	/// Normalise histograms etc., after the run
	void finalize() {

	normalize(_hist_zpt_el_dressed);
	normalize(_hist_zpt_el_bare);

	normalize(_hist_zpt_mu_dressed);
	normalize(_hist_zpt_mu_bare);

	foreach (Histo1DPtr hist, _h_zpt_el_mu_dressed.getHistograms()) { normalize(hist); }

	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here


	private:

	/// @name Histograms
	//@{
	BinnedHistogram<double> _h_zpt_el_mu_dressed;


	Histo1DPtr _hist_zpt_el_dressed;
	Histo1DPtr _hist_zpt_el_bare;
	Histo1DPtr _hist_zpt_mu_dressed;
	Histo1DPtr _hist_zpt_mu_bare;

	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1300647);
	}
	diff --git a/src/Analyses/ATLAS_2014_I1304688.cc b/src/Analyses/ATLAS_2014_I1304688.cc
	--- a/src/Analyses/ATLAS_2014_I1304688.cc
	+++ b/src/Analyses/ATLAS_2014_I1304688.cc
	@@ -1,326 +1,326 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/PromptFinalState.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include <bitset>

	namespace Rivet {




	/// @brief ATLAS 7 TeV jets in ttbar events analysis
	///
	/// @author W. H. Bell <W.Bell@cern.ch>
	/// @author A. Grohsjean <alexander.grohsjean@desy.de>
	class ATLAS_2014_I1304688 : public Analysis {
	public:

	ATLAS_2014_I1304688():
	Analysis("ATLAS_2014_I1304688"),
	_jet_ntag(0),
	_met_et(0.),
	_met_phi(0.),
	_hMap(),
	//_chanLimit(3),
	_histLimit(6)
	{ }


	void init() {
	// Eta ranges
	/// @todo 1 MeV? Really?
	Cut eta_full = Cuts::abseta < 5.0 && Cuts::pT > 1.0*MeV;
	Cut eta_lep = Cuts::abseta < 2.5;

	// All final state particles
	FinalState fs(eta_full);

	// Get photons to dress leptons
	IdentifiedFinalState photons(fs);
	photons.acceptIdPair(PID::PHOTON);

	// Projection to find the electrons
	IdentifiedFinalState el_id(fs);
	el_id.acceptIdPair(PID::ELECTRON);
	PromptFinalState electrons(el_id);
	electrons.acceptTauDecays(true);
	- addProjection(electrons, "electrons");
	+ declare(electrons, "electrons");
	DressedLeptons dressedelectrons(photons, electrons, 0.1, eta_lep && Cuts::pT > 25*GeV, true, true);
	- addProjection(dressedelectrons, "dressedelectrons");
	+ declare(dressedelectrons, "dressedelectrons");
	DressedLeptons vetodressedelectrons(photons, electrons, 0.1, eta_lep && Cuts::pT >= 15*GeV, true, true);
	- addProjection(vetodressedelectrons, "vetodressedelectrons");
	+ declare(vetodressedelectrons, "vetodressedelectrons");
	DressedLeptons ewdressedelectrons(photons, electrons, 0.1, eta_full, true, true);
	- addProjection(ewdressedelectrons, "ewdressedelectrons");
	+ declare(ewdressedelectrons, "ewdressedelectrons");

	// Projection to find the muons
	IdentifiedFinalState mu_id(fs);
	mu_id.acceptIdPair(PID::MUON);
	PromptFinalState muons(mu_id);
	muons.acceptTauDecays(true);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");
	vector<pair<double, double> > eta_muon;
	DressedLeptons dressedmuons(photons, muons, 0.1, eta_lep && Cuts::pT >= 25*GeV, true, true);
	- addProjection(dressedmuons, "dressedmuons");
	+ declare(dressedmuons, "dressedmuons");
	DressedLeptons vetodressedmuons(photons, muons, 0.1, eta_lep && Cuts::pT >= 15*GeV, true, true);
	- addProjection(vetodressedmuons, "vetodressedmuons");
	+ declare(vetodressedmuons, "vetodressedmuons");
	DressedLeptons ewdressedmuons(photons, muons, 0.1, eta_full, true, true);
	- addProjection(ewdressedmuons, "ewdressedmuons");
	+ declare(ewdressedmuons, "ewdressedmuons");

	// Projection to find neutrinos and produce MET
	IdentifiedFinalState nu_id;
	nu_id.acceptNeutrinos();
	PromptFinalState neutrinos(nu_id);
	neutrinos.acceptTauDecays(true);
	- addProjection(neutrinos, "neutrinos");
	+ declare(neutrinos, "neutrinos");

	// Jet clustering.
	VetoedFinalState vfs;
	vfs.addVetoOnThisFinalState(ewdressedelectrons);
	vfs.addVetoOnThisFinalState(ewdressedmuons);
	vfs.addVetoOnThisFinalState(neutrinos);
	FastJets jets(vfs, FastJets::ANTIKT, 0.4);
	jets.useInvisibles();
	- addProjection(jets, "jets");
	+ declare(jets, "jets");

	// Book histograms
	for (unsigned int ihist = 0; ihist < _histLimit ; ihist++) {
	const unsigned int threshLimit = _thresholdLimit(ihist);
	for (unsigned int ithres = 0; ithres < threshLimit; ithres++) {
	_histogram(ihist, ithres); // Create all histograms
	}
	}
	}


	void analyze(const Event& event) {

	// Get the selected objects, using the projections.
	- _dressedelectrons = sortByPt(applyProjection<DressedLeptons>(event, "dressedelectrons").dressedLeptons());
	- _vetodressedelectrons = applyProjection<DressedLeptons>(event, "vetodressedelectrons").dressedLeptons();
	+ _dressedelectrons = sortByPt(apply<DressedLeptons>(event, "dressedelectrons").dressedLeptons());
	+ _vetodressedelectrons = apply<DressedLeptons>(event, "vetodressedelectrons").dressedLeptons();

	- _dressedmuons = sortByPt(applyProjection<DressedLeptons>(event, "dressedmuons").dressedLeptons());
	- _vetodressedmuons = applyProjection<DressedLeptons>(event, "vetodressedmuons").dressedLeptons();
	+ _dressedmuons = sortByPt(apply<DressedLeptons>(event, "dressedmuons").dressedLeptons());
	+ _vetodressedmuons = apply<DressedLeptons>(event, "vetodressedmuons").dressedLeptons();

	- _neutrinos = applyProjection<PromptFinalState>(event, "neutrinos").particlesByPt();
	+ _neutrinos = apply<PromptFinalState>(event, "neutrinos").particlesByPt();

	- _jets = applyProjection<FastJets>(event, "jets").jetsByPt(Cuts::pT > 25*GeV && Cuts::abseta < 2.5);
	+ _jets = apply<FastJets>(event, "jets").jetsByPt(Cuts::pT > 25*GeV && Cuts::abseta < 2.5);


	// Calculate the missing ET, using the prompt neutrinos only (really?)
	/// @todo Why not use MissingMomentum?
	FourMomentum pmet;
	foreach (const Particle& p, _neutrinos) pmet += p.momentum();
	_met_et = pmet.pT();
	_met_phi = pmet.phi();

	// Check overlap of jets/leptons.
	unsigned int i,j;
	_jet_ntag = 0;
	_overlap = false;
	for (i = 0; i < _jets.size(); i++) {
	const Jet& jet = _jets[i];
	// If dR(el,jet) < 0.4 skip the event
	foreach (const DressedLepton& el, _dressedelectrons) {
	if (deltaR(jet, el) < 0.4) _overlap = true;
	}
	// If dR(mu,jet) < 0.4 skip the event
	foreach (const DressedLepton& mu, _dressedmuons) {
	if (deltaR(jet, mu) < 0.4) _overlap = true;
	}
	// If dR(jet,jet) < 0.5 skip the event
	for (j = 0; j < _jets.size(); j++) {
	const Jet& jet2 = _jets[j];
	if (i == j) continue; // skip the diagonal
	if (deltaR(jet, jet2) < 0.5) _overlap = true;
	}
	// Count the number of b-tags
	if (!jet.bTags().empty()) _jet_ntag += 1;
	}

	// Evaluate basic event selection
	unsigned int ejets_bits = 0, mujets_bits = 0;
	bool pass_ejets = _ejets(ejets_bits);
	bool pass_mujets = _mujets(mujets_bits);

	// Remove events with object overlap
	if (_overlap) vetoEvent;
	// basic event selection requirements
	if (!pass_ejets && !pass_mujets) vetoEvent;

	// Check if the additional pT threshold requirements are passed
	bool pass_jetPt = _additionalJetCuts();

	// Count the jet multiplicity for 25, 40, 60 and 80GeV
	unsigned int ithres, jet_n[4];
	for (ithres = 0; ithres < 4; ithres++) {
	jet_n[ithres] = _countJets(ithres);
	}

	// Fill histograms
	const double weight = event.weight();
	for (unsigned int ihist = 0; ihist < 6; ihist++) {
	if (ihist > 0 && !pass_jetPt) continue; // additional pT threshold cuts for pT plots
	unsigned int threshLimit = _thresholdLimit(ihist);
	for (ithres = 0; ithres < threshLimit; ithres++) {
	if (jet_n[ithres] < 3) continue; // 3 or more jets for ljets
	// Fill
	if (ihist == 0) _histogram(ihist, ithres)->fill(jet_n[ithres], weight); // njets
	else if (ihist == 1) _histogram(ihist, ithres)->fill(_jets[0].pT(), weight); // leading jet pT
	else if (ihist == 2) _histogram(ihist, ithres)->fill(_jets[1].pT(), weight); // 2nd jet pT
	else if (ihist == 3 && jet_n[ithres] >= 3) _histogram(ihist, ithres)->fill(_jets[2].pT(), weight); // 3rd jet pT
	else if (ihist == 4 && jet_n[ithres] >= 4) _histogram(ihist, ithres)->fill(_jets[3].pT(), weight); // 4th jet pT
	else if (ihist == 5 && jet_n[ithres] >= 5) _histogram(ihist, ithres)->fill(_jets[4].pT(), weight); // 5th jet pT
	}
	}
	}


	void finalize() {
	// Normalize to cross-section
	const double norm = crossSection()/sumOfWeights();
	typedef map<unsigned int, Histo1DPtr>::value_type IDtoHisto1DPtr; ///< @todo Remove when C++11 allowed
	foreach (IDtoHisto1DPtr ihpair, _hMap) scale(ihpair.second, norm); ///< @todo Use normalize(ihpair.second, crossSection())
	// Calc averages
	for (unsigned int ihist = 0; ihist < _histLimit ; ihist++) {
	unsigned int threshLimit = _thresholdLimit(ihist);
	for (unsigned int ithres = 0; ithres < threshLimit; ithres++) {
	scale(_histogram(ihist, ithres), 0.5);
	}
	}
	}



	private:


	/// @name Cut helper functions
	//@{

	// Event selection functions
	bool _ejets(unsigned int& cutBits) {
	// 1. More than zero good electrons
	cutBits += 1; if (_dressedelectrons.size() == 0) return false;
	// 2. No additional electrons passing the veto selection
	cutBits += 1 << 1; if (_vetodressedelectrons.size() > 1) return false;
	// 3. No muons passing the veto selection
	cutBits += 1 << 2; if (_vetodressedmuons.size() > 0) return false;
	// 4. total neutrino pT > 30 GeV
	cutBits += 1 << 3; if (_met_et <= 30.0*GeV) return false;
	// 5. MTW > 35 GeV
	cutBits += 1 << 4;
	if (_transMass(_dressedelectrons[0].pT(), _dressedelectrons[0].phi(), _met_et, _met_phi) <= 35*GeV) return false;
	// 6. At least one b-tagged jet
	cutBits += 1 << 5; if (_jet_ntag < 1) return false;
	// 7. At least three good jets
	cutBits += 1 << 6; if (_jets.size() < 3) return false;
	cutBits += 1 << 7;
	return true;
	}

	bool _mujets(unsigned int& cutBits) {
	// 1. More than zero good muons
	cutBits += 1; if (_dressedmuons.size() == 0) return false;
	// 2. No additional muons passing the veto selection
	cutBits += 1 << 1; if (_vetodressedmuons.size() > 1) return false;
	// 3. No electrons passing the veto selection
	cutBits += 1 << 2; if (_vetodressedelectrons.size() > 0) return false;
	// 4. total neutrino pT > 30 GeV
	cutBits += 1 << 3; if (_met_et <= 30*GeV) return false;
	// 5. MTW > 35 GeV
	cutBits += 1 << 4;
	if (_transMass(_dressedmuons[0].pT(), _dressedmuons[0].phi(), _met_et, _met_phi) <= 35*GeV) return false;
	// 6. At least one b-tagged jet
	cutBits += 1 << 5; if (_jet_ntag < 1) return false;
	// 7. At least three good jets
	cutBits += 1 << 6; if (_jets.size() < 3) return false;
	cutBits += 1 << 7;
	return true;
	}

	bool _additionalJetCuts() {
	if (_jets.size() < 2) return false;
	if (_jets[0].pT() <= 50GeV \|\| _jets[1].pT() <= 35GeV) return false;
	return true;
	}

	//@}


	/// @name Histogram helper functions
	//@{

	unsigned int _thresholdLimit(unsigned int histId) {
	if (histId == 0) return 4;
	return 1;
	}

	Histo1DPtr _histogram(unsigned int histId, unsigned int thresholdId) {
	assert(histId < _histLimit);
	assert(thresholdId < _thresholdLimit(histId));

	const unsigned int hInd = (histId == 0) ? thresholdId : (_thresholdLimit(0) + (histId-1) + thresholdId);
	if (_hMap.find(hInd) != _hMap.end()) return _hMap[hInd];

	if (histId == 0) _hMap.insert(make_pair(hInd,bookHisto1D(1,thresholdId+1,1)));
	else _hMap.insert(make_pair(hInd,bookHisto1D(2,histId,1)));
	return _hMap[hInd];
	}

	//@}


	/// @name Physics object helper functions
	//@{

	double _transMass(double ptLep, double phiLep, double met, double phiMet) {
	return sqrt(2.0ptLepmet*(1 - cos(phiLep-phiMet)));
	}

	unsigned int _countJets(unsigned int ithres) {
	if (ithres > 4) assert(0);
	double pTcut[4] = {25.,40.,60.,80.};
	unsigned int i, jet_n = 0;
	for (i = 0; i < _jets.size(); i++) {
	if (_jets[i].pT() > pTcut[ithres]) jet_n++;
	}
	unsigned int ncutoff[4] = {8,7,6,5};
	if (jet_n > ncutoff[ithres]) jet_n = ncutoff[ithres];
	return jet_n;
	}

	//@}


	private:

	/// @name Objects that are used by the event selection decisions
	//@{
	vector<DressedLepton> _dressedelectrons;
	vector<DressedLepton> _vetodressedelectrons;
	vector<DressedLepton> _dressedmuons;
	vector<DressedLepton> _vetodressedmuons;
	Particles _neutrinos;
	Jets _jets;
	unsigned int _jet_ntag;
	/// @todo Why not store the whole MET FourMomentum?
	double _met_et, _met_phi;
	bool _overlap;

	map<unsigned int, Histo1DPtr> _hMap;
	//unsigned int _chanLimit;
	unsigned int _histLimit;
	//@}

	};



	// Declare the class as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1304688);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1306294.cc b/src/Analyses/ATLAS_2014_I1306294.cc
	--- a/src/Analyses/ATLAS_2014_I1306294.cc
	+++ b/src/Analyses/ATLAS_2014_I1306294.cc
	@@ -1,233 +1,233 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/HeavyHadrons.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {

	class ATLAS_2014_I1306294 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructors
	ATLAS_2014_I1306294(std::string name="ATLAS_2014_I1306294")
	: Analysis(name)
	{
	_mode = 1;
	setNeedsCrossSection(true);
	}

	//@}

	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;

	Cut cuts = Cuts::etaIn(-2.5,2.5) & (Cuts::pT > 20.0*GeV);

	ZFinder zfinder(fs, cuts, _mode==1? PID::ELECTRON : PID::MUON, 76.0GeV, 106.0GeV, 0.1, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	//FastJets jetpro1( getProjection<ZFinder>("ZFinder").remainingFinalState(), FastJets::ANTIKT, 0.4);
	VetoedFinalState jet_fs(fs);
	jet_fs.addVetoOnThisFinalState(getProjection<ZFinder>("ZFinder"));
	FastJets jetpro1(jet_fs, FastJets::ANTIKT, 0.4);
	jetpro1.useInvisibles();
	- addProjection(jetpro1, "AntiKtJets04");
	- addProjection(HeavyHadrons(), "BHadrons");
	+ declare(jetpro1, "AntiKtJets04");
	+ declare(HeavyHadrons(), "BHadrons");

	//Histograms with data binning
	_h_bjet_Pt = bookHisto1D( 3, 1, 1);
	_h_bjet_Y = bookHisto1D( 5, 1, 1);
	_h_bjet_Yboost = bookHisto1D( 7, 1, 1);
	_h_bjet_DY20 = bookHisto1D( 9, 1, 1);
	_h_bjet_ZdPhi20 = bookHisto1D(11, 1, 1);
	_h_bjet_ZdR20 = bookHisto1D(13, 1, 1);
	_h_bjet_ZPt = bookHisto1D(15, 1, 1);
	_h_bjet_ZY = bookHisto1D(17, 1, 1);
	_h_2bjet_dR = bookHisto1D(21, 1, 1);
	_h_2bjet_Mbb = bookHisto1D(23, 1, 1);
	_h_2bjet_ZPt = bookHisto1D(25, 1, 1);
	_h_2bjet_ZY = bookHisto1D(27, 1, 1);
	}

	//==========================================================================================


	/// Perform the per-event analysis
	void analyze(const Event& e) {


	//---------------------------
	const double weight = e.weight();

	// -- check we have a Z:
	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");

	if(zfinder.bosons().size() != 1) vetoEvent;

	const ParticleVector boson_s = zfinder.bosons();
	const Particle boson_f = boson_s[0] ;
	const ParticleVector zleps = zfinder.constituents();
	//---------------------------


	//---------------------------
	//------------- stop processing the event if no true b-partons or hadrons are found
	- const Particles& allBs = applyProjection<HeavyHadrons>(e, "BHadrons").bHadrons(5.0*GeV);
	+ const Particles& allBs = apply<HeavyHadrons>(e, "BHadrons").bHadrons(5.0*GeV);
	Particles stableBs;
	foreach(Particle p, allBs) {
	if(p.abseta() < 2.5) stableBs += p;
	}
	if( stableBs.empty() ) vetoEvent;


	//---------------------------
	// -- get the b-jets:
	- const Jets& jets = applyProjection<JetAlg>(e, "AntiKtJets04").jetsByPt(Cuts::pT >20.0*GeV && Cuts::abseta <2.4);
	+ const Jets& jets = apply<JetAlg>(e, "AntiKtJets04").jetsByPt(Cuts::pT >20.0*GeV && Cuts::abseta <2.4);
	Jets b_jets;
	foreach(const Jet& jet, jets) {
	//veto overlaps with Z leptons:
	bool veto = false;
	foreach(const Particle& zlep, zleps) {
	if(deltaR(jet, zlep) < 0.5) veto = true;
	}
	if(veto) continue;

	foreach(const Particle& bhadron, stableBs) {
	if( deltaR(jet, bhadron) <= 0.3 ) {
	b_jets.push_back(jet);
	break; // match
	}
	} // end loop on b-hadrons
	}

	//and make sure we have at least 1:
	if(b_jets.empty()) vetoEvent;

	//---------------------------
	// fill the plots:
	const double ZpT = boson_f.pT()/GeV;
	const double ZY = boson_f.absrap();

	_h_bjet_ZPt->fill(ZpT, weight);
	_h_bjet_ZY ->fill(ZY, weight);

	foreach(const Jet& jet, b_jets) {

	_h_bjet_Pt->fill(jet.pT()/GeV, weight );
	_h_bjet_Y ->fill(jet.absrap(), weight );

	const double Yboost = 0.5 * fabs(boson_f.rapidity() + jet.rapidity());

	_h_bjet_Yboost->fill(Yboost, weight );

	if(ZpT > 20.) {

	const double ZBDY = fabs( boson_f.rapidity() - jet.rapidity() );
	const double ZBDPHI = fabs( deltaPhi(jet.phi(), boson_f.phi()) );
	const double ZBDR = deltaR(jet, boson_f, RAPIDITY);
	_h_bjet_DY20->fill( ZBDY, weight);
	_h_bjet_ZdPhi20->fill(ZBDPHI, weight);
	_h_bjet_ZdR20->fill( ZBDR, weight);
	}

	} //loop over b-jets

	if (b_jets.size() < 2) return;

	_h_2bjet_ZPt->fill(ZpT, weight);
	_h_2bjet_ZY ->fill(ZY, weight);

	const double BBDR = deltaR(b_jets[0], b_jets[1], RAPIDITY);
	const double Mbb = (b_jets[0].momentum() + b_jets[1].momentum()).mass();

	_h_2bjet_dR ->fill(BBDR, weight);
	_h_2bjet_Mbb->fill(Mbb, weight);

	} // end of analysis loop


	/// Normalise histograms etc., after the run
	void finalize() {

	const double normfac = crossSection() / sumOfWeights();

	scale( _h_bjet_Pt, normfac);
	scale( _h_bjet_Y, normfac);
	scale( _h_bjet_Yboost, normfac);
	scale( _h_bjet_DY20, normfac);
	scale( _h_bjet_ZdPhi20, normfac);
	scale( _h_bjet_ZdR20, normfac);
	scale( _h_bjet_ZPt, normfac);
	scale( _h_bjet_ZY, normfac);
	scale( _h_2bjet_dR, normfac);
	scale( _h_2bjet_Mbb, normfac);
	scale( _h_2bjet_ZPt, normfac);
	scale( _h_2bjet_ZY, normfac);
	}

	//@}


	protected:

	// Data members like post-cuts event weight counters go here
	size_t _mode;


	private:

	Histo1DPtr _h_bjet_Pt;
	Histo1DPtr _h_bjet_Y;
	Histo1DPtr _h_bjet_Yboost;
	Histo1DPtr _h_bjet_DY20;
	Histo1DPtr _h_bjet_ZdPhi20;
	Histo1DPtr _h_bjet_ZdR20;
	Histo1DPtr _h_bjet_ZPt;
	Histo1DPtr _h_bjet_ZY;
	Histo1DPtr _h_2bjet_dR;
	Histo1DPtr _h_2bjet_Mbb;
	Histo1DPtr _h_2bjet_ZPt;
	Histo1DPtr _h_2bjet_ZY;

	};


	class ATLAS_2014_I1306294_EL : public ATLAS_2014_I1306294 {
	public:
	ATLAS_2014_I1306294_EL()
	: ATLAS_2014_I1306294("ATLAS_2014_I1306294_EL")
	{
	_mode = 1;
	}
	};

	class ATLAS_2014_I1306294_MU : public ATLAS_2014_I1306294 {
	public:
	ATLAS_2014_I1306294_MU()
	: ATLAS_2014_I1306294("ATLAS_2014_I1306294_MU")
	{
	_mode = 2;
	}
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1306294);
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1306294_MU);
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1306294_EL);

	}

	diff --git a/src/Analyses/ATLAS_2014_I1306615.cc b/src/Analyses/ATLAS_2014_I1306615.cc
	--- a/src/Analyses/ATLAS_2014_I1306615.cc
	+++ b/src/Analyses/ATLAS_2014_I1306615.cc
	@@ -1,487 +1,487 @@
	/*
	* Rivet routine for H->yy differential cross-sections measurement
	* arXiv: http://arxiv.org/abs/ARXIV:1407.4222
	* HepData: http://hepdata.cedar.ac.uk/view/ins1306615
	* Author: Michaela Queitsch-Maitland <michaela.queitsch-maitland@cern.ch>
	*/

	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {

	class ATLAS_2014_I1306615 : public Analysis {
	public:

	// Constructor
	ATLAS_2014_I1306615()
	: Analysis("ATLAS_2014_I1306615")
	{ }

	public:

	// Book histograms and initialise projections before the run
	void init() {

	// Final state
	// All particles within \|eta\| < 5.0
	const FinalState FS(Cuts::abseta<5.0);
	- addProjection(FS,"FS");
	+ declare(FS,"FS");

	// Project photons with pT > 25 GeV and \|eta\| < 2.37
	IdentifiedFinalState ph_FS(Cuts::abseta<2.37 && Cuts::pT>25.0*GeV);
	ph_FS.acceptIdPair(PID::PHOTON);
	- addProjection(ph_FS, "PH_FS");
	+ declare(ph_FS, "PH_FS");

	// Project photons for dressing
	IdentifiedFinalState ph_dressing_FS(FS);
	ph_dressing_FS.acceptIdPair(PID::PHOTON);

	// Project bare electrons
	IdentifiedFinalState el_bare_FS(FS);
	el_bare_FS.acceptIdPair(PID::ELECTRON);
	- addProjection(el_bare_FS,"el_bare_FS");
	+ declare(el_bare_FS,"el_bare_FS");

	// Project dressed electrons with pT > 15 GeV and \|eta\| < 2.47
	DressedLeptons el_dressed_FS(ph_dressing_FS, el_bare_FS, 0.1, Cuts::abseta < 2.47 && Cuts::pT > 15*GeV, true, false);
	- addProjection(el_dressed_FS,"EL_DRESSED_FS");
	+ declare(el_dressed_FS,"EL_DRESSED_FS");

	// Project bare muons
	IdentifiedFinalState mu_bare_FS(FS);
	mu_bare_FS.acceptIdPair(PID::MUON);

	// Project dressed muons with pT > 15 GeV and \|eta\| < 2.47
	//DressedLeptons mu_dressed_FS(ph_dressing_FS, mu_bare_FS, 0.1, true, -2.47, 2.47, 15.0*GeV, false);
	DressedLeptons mu_dressed_FS(ph_dressing_FS, mu_bare_FS, 0.1, Cuts::abseta < 2.47 && Cuts::pT > 15*GeV, true, false);
	- addProjection(mu_dressed_FS,"MU_DRESSED_FS");
	+ declare(mu_dressed_FS,"MU_DRESSED_FS");

	// Final state excluding muons and neutrinos (for jet building and photon isolation)
	VetoedFinalState veto_mu_nu_FS(FS);
	veto_mu_nu_FS.vetoNeutrinos();
	veto_mu_nu_FS.addVetoPairId(PID::MUON);
	- addProjection(veto_mu_nu_FS, "VETO_MU_NU_FS");
	+ declare(veto_mu_nu_FS, "VETO_MU_NU_FS");

	// Build the anti-kT R=0.4 jets, using FinalState particles (vetoing muons and neutrinos)
	FastJets jets(veto_mu_nu_FS, FastJets::ANTIKT, 0.4);
	- addProjection(jets, "JETS");
	+ declare(jets, "JETS");

	// Book histograms
	// 1D distributions
	_h_pT_yy = bookHisto1D(1,1,1);
	_h_y_yy = bookHisto1D(2,1,1);
	_h_Njets30 = bookHisto1D(3,1,1);
	_h_Njets50 = bookHisto1D(4,1,1);
	_h_pT_j1 = bookHisto1D(5,1,1);
	_h_y_j1 = bookHisto1D(6,1,1);
	_h_HT = bookHisto1D(7,1,1);
	_h_pT_j2 = bookHisto1D(8,1,1);
	_h_Dy_jj = bookHisto1D(9,1,1);
	_h_Dphi_yy_jj = bookHisto1D(10,1,1);
	_h_cosTS_CS = bookHisto1D(11,1,1);
	_h_cosTS_CS_5bin = bookHisto1D(12,1,1);
	_h_Dphi_jj = bookHisto1D(13,1,1);
	_h_pTt_yy = bookHisto1D(14,1,1);
	_h_Dy_yy = bookHisto1D(15,1,1);
	_h_tau_jet = bookHisto1D(16,1,1);
	_h_sum_tau_jet = bookHisto1D(17,1,1);
	_h_y_j2 = bookHisto1D(18,1,1);
	_h_pT_j3 = bookHisto1D(19,1,1);
	_h_m_jj = bookHisto1D(20,1,1);
	_h_pT_yy_jj = bookHisto1D(21,1,1);

	// 2D distributions of cosTS_CS x pT_yy
	_h_cosTS_pTyy_low = bookHisto1D(22,1,1);
	_h_cosTS_pTyy_high = bookHisto1D(22,1,2);
	_h_cosTS_pTyy_rest = bookHisto1D(22,1,3);

	// 2D distributions of Njets x pT_yy
	_h_pTyy_Njets0 = bookHisto1D(23,1,1);
	_h_pTyy_Njets1 = bookHisto1D(23,1,2);
	_h_pTyy_Njets2 = bookHisto1D(23,1,3);

	_h_pTj1_excl = bookHisto1D(24,1,1);

	// Fiducial regions
	_h_fidXSecs = bookHisto1D(29,1,1);
	}

	// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();
	_weight = weight;

	// Get final state particles
	- const ParticleVector& FS_ptcls = applyProjection<FinalState>(event, "FS").particles();
	- const ParticleVector& ptcls_veto_mu_nu = applyProjection<VetoedFinalState>(event, "VETO_MU_NU_FS").particles();
	- const ParticleVector& photons = applyProjection<IdentifiedFinalState>(event, "PH_FS").particlesByPt();
	- const vector<DressedLepton>& el_dressed = applyProjection<DressedLeptons>(event, "EL_DRESSED_FS").dressedLeptons();
	- const vector<DressedLepton>& mu_dressed = applyProjection<DressedLeptons>(event, "MU_DRESSED_FS").dressedLeptons();
	+ const ParticleVector& FS_ptcls = apply<FinalState>(event, "FS").particles();
	+ const ParticleVector& ptcls_veto_mu_nu = apply<VetoedFinalState>(event, "VETO_MU_NU_FS").particles();
	+ const ParticleVector& photons = apply<IdentifiedFinalState>(event, "PH_FS").particlesByPt();
	+ const vector<DressedLepton>& el_dressed = apply<DressedLeptons>(event, "EL_DRESSED_FS").dressedLeptons();
	+ const vector<DressedLepton>& mu_dressed = apply<DressedLeptons>(event, "MU_DRESSED_FS").dressedLeptons();

	// For isolation calculation
	float dR_iso = 0.4;
	float ETcut_iso = 14.0;
	FourMomentum ET_iso;

	// Fiducial selection: pT > 25 GeV, \|eta\| < 2.37 and isolation (in cone deltaR = 0.4) is < 14 GeV
	vector<const Particle*> fid_photons;
	foreach (const Particle& ph, photons) {

	// Veto photons from hadron or tau decay
	if ( fromHadronDecay(ph) ) continue;

	// Calculate isolation
	ET_iso = - ph.momentum();
	// Loop over fs truth particles (excluding muons and neutrinos)
	foreach (const Particle& p, ptcls_veto_mu_nu) {
	// Check if the truth particle is in a cone of 0.4
	if ( deltaR(ph.momentum(), p.momentum()) < dR_iso )
	ET_iso += p.momentum();
	}

	// Check isolation
	if ( ET_iso.Et() > ETcut_iso ) continue;

	// Fill vector of photons passing fiducial selection
	fid_photons.push_back(&ph);
	}

	if(fid_photons.size() < 2) vetoEvent;

	const FourMomentum& y1 = fid_photons[0]->momentum();
	const FourMomentum& y2 = fid_photons[1]->momentum();

	double m_yy = (y1 + y2).mass();

	// Relative pT cuts
	if ( y1.pT() < 0.35 * m_yy \|\| y2.pT() < 0.25 * m_yy ) vetoEvent;

	// Mass window cut
	if ( m_yy < 105 \|\| m_yy > 160 ) vetoEvent;

	// -------------------------------------------- //
	// Passed diphoton baseline fiducial selection! //
	// -------------------------------------------- //

	// Electron selection
	vector<const Particle*> good_el;
	foreach(const DressedLepton& els, el_dressed) {

	const Particle& el = els.constituentLepton();
	if ( el.momentum().pT() < 15 ) continue;
	if ( fabs(el.momentum().eta()) > 2.47 ) continue;
	if ( deltaR(el.momentum(), y1) < 0.4 ) continue;
	if ( deltaR(el.momentum(), y2) < 0.4 ) continue;
	if ( fromHadronDecay(el) ) continue; // Veto electrons from hadron or tau decay
	good_el.push_back(&el);
	}

	// Muon selection
	vector<const Particle*> good_mu;
	foreach(const DressedLepton& mus, mu_dressed) {

	const Particle& mu = mus.constituentLepton();
	if ( mu.momentum().pT() < 15 ) continue;
	if ( fabs(mu.momentum().eta()) > 2.47 ) continue;
	if ( deltaR(mu.momentum(), y1) < 0.4 ) continue;
	if ( deltaR(mu.momentum(), y2) < 0.4 ) continue;
	if ( fromHadronDecay(mu) ) continue; // Veto muons from hadron or tau decay
	good_mu.push_back(&mu);
	}

	// Find prompt, invisible particles for missing ET calculation
	// Based on VisibleFinalState projection
	FourMomentum invisible(0,0,0,0);
	foreach (const Particle& p, FS_ptcls) {

	// Veto non-prompt particles (from hadron or tau decay)
	if ( fromHadronDecay(p) ) continue;
	// Charged particles are visible
	if ( PID::threeCharge( p.pid() ) != 0 ) continue;
	// Neutral hadrons are visible
	if ( PID::isHadron( p.pid() ) ) continue;
	// Photons are visible
	if ( p.pid() == PID::PHOTON ) continue;
	// Gluons are visible (for parton level analyses)
	if ( p.pid() == PID::GLUON ) continue;
	// Everything else is invisible
	invisible += p.momentum();
	}
	double MET = invisible.Et();

	// Jet selection
	// Get jets with pT > 25 GeV and \|rapidity\| < 4.4
	- //const Jets& jets = applyProjection<FastJets>(event, "JETS").jetsByPt(25.0*GeV, MAXDOUBLE, -4.4, 4.4, RAPIDITY);
	- const Jets& jets = applyProjection<FastJets>(event, "JETS").jetsByPt(Cuts::pT>25.0*GeV && Cuts::absrap <4.4);
	+ //const Jets& jets = apply<FastJets>(event, "JETS").jetsByPt(25.0*GeV, MAXDOUBLE, -4.4, 4.4, RAPIDITY);
	+ const Jets& jets = apply<FastJets>(event, "JETS").jetsByPt(Cuts::pT>25.0*GeV && Cuts::absrap <4.4);

	vector<const Jet*> jets_25;
	vector<const Jet*> jets_30;
	vector<const Jet*> jets_50;

	foreach (const Jet& jet, jets) {

	bool passOverlap = true;
	// Overlap with leading photons
	if ( deltaR(y1, jet.momentum()) < 0.4 ) passOverlap = false;
	if ( deltaR(y2, jet.momentum()) < 0.4 ) passOverlap = false;

	// Overlap with good electrons
	foreach (const Particle* el, good_el)
	if ( deltaR(el->momentum(), jet.momentum()) < 0.2 ) passOverlap = false;

	if ( ! passOverlap ) continue;

	if ( fabs(jet.momentum().eta()) < 2.4 \|\| ( fabs(jet.momentum().eta()) > 2.4 && jet.momentum().pT() > 30 ) ) jets_25.push_back(&jet);
	if ( jet.momentum().pT() > 30 ) jets_30.push_back(&jet);
	if ( jet.momentum().pT() > 50 ) jets_50.push_back(&jet);
	}

	// Fiducial regions
	_h_fidXSecs->fill(1,_weight);
	if ( jets_30.size() >= 1 ) _h_fidXSecs->fill(2, _weight);
	if ( jets_30.size() >= 2 ) _h_fidXSecs->fill(3, _weight);
	if ( jets_30.size() >= 3 ) _h_fidXSecs->fill(4, _weight);
	if ( jets_30.size() >= 2 && passVBFCuts(y1 + y2, jets_30.at(0)->momentum(), jets_30.at(1)->momentum()) ) _h_fidXSecs->fill(5, _weight);
	if ( (good_el.size() + good_mu.size()) > 0 ) _h_fidXSecs->fill(6, _weight);
	if ( MET > 80 ) _h_fidXSecs->fill(7, _weight);

	// Fill histograms
	// Inclusive variables
	_pT_yy = (y1 + y2).pT();
	_y_yy = fabs( (y1 + y2).rapidity() );
	_cosTS_CS = cosTS_CS(y1, y2);
	_pTt_yy = pTt(y1, y2);
	_Dy_yy = fabs( deltaRap(y1, y2) );

	_Njets30 = jets_30.size() > 3 ? 3 : jets_30.size();
	_Njets50 = jets_50.size() > 3 ? 3 : jets_50.size();
	_h_Njets30->fill(_Njets30, _weight);
	_h_Njets50->fill(_Njets50, _weight);

	_pT_j1 = jets_30.size() > 0 ? jets_30.at(0)->momentum().pT() : 0.;
	_pT_j2 = jets_30.size() > 1 ? jets_30.at(1)->momentum().pT() : 0.;
	_pT_j3 = jets_30.size() > 2 ? jets_30.at(2)->momentum().pT() : 0.;

	_HT = 0.0;
	foreach (const Jet* jet, jets_30)
	_HT += jet->momentum().pT();

	_tau_jet = tau_jet_max(y1 + y2, jets_25);
	_sum_tau_jet = sum_tau_jet(y1 + y2, jets_25);

	_h_pT_yy ->fill(_pT_yy ,_weight);
	_h_y_yy ->fill(_y_yy ,_weight);
	_h_pT_j1 ->fill(_pT_j1 ,_weight);
	_h_cosTS_CS ->fill(_cosTS_CS ,_weight);
	_h_cosTS_CS_5bin->fill(_cosTS_CS ,_weight);
	_h_HT ->fill(_HT ,_weight);
	_h_pTt_yy ->fill(_pTt_yy ,_weight);
	_h_Dy_yy ->fill(_Dy_yy ,_weight);
	_h_tau_jet ->fill(_tau_jet ,_weight);
	_h_sum_tau_jet ->fill(_sum_tau_jet,_weight);

	// >=1 jet variables
	if ( jets_30.size() >= 1 ) {
	FourMomentum j1 = jets_30[0]->momentum();
	_y_j1 = fabs( j1.rapidity() );

	_h_pT_j2->fill(_pT_j2 ,_weight);
	_h_y_j1 ->fill(_y_j1 ,_weight);
	}

	// >=2 jet variables
	if ( jets_30.size() >= 2 ) {
	FourMomentum j1 = jets_30[0]->momentum();
	FourMomentum j2 = jets_30[1]->momentum();

	_Dy_jj = fabs( deltaRap(j1, j2) );
	_Dphi_jj = fabs( deltaPhi(j1, j2) );
	_Dphi_yy_jj = fabs( deltaPhi(y1 + y2, j1 + j2) );
	_m_jj = (j1 + j2).mass();
	_pT_yy_jj = (y1 + y2 + j1 + j2).pT();
	_y_j2 = fabs( j2.rapidity() );

	_h_Dy_jj ->fill(_Dy_jj ,_weight);
	_h_Dphi_jj ->fill(_Dphi_jj ,_weight);
	_h_Dphi_yy_jj ->fill(_Dphi_yy_jj,_weight);
	_h_m_jj ->fill(_m_jj ,_weight);
	_h_pT_yy_jj ->fill(_pT_yy_jj ,_weight);
	_h_pT_j3 ->fill(_pT_j3 ,_weight);
	_h_y_j2 ->fill(_y_j2 ,_weight);
	}

	// 2D distributions of cosTS_CS x pT_yy
	if ( _pT_yy < 80 )
	_h_cosTS_pTyy_low->fill(_cosTS_CS, _weight);
	else if ( _pT_yy > 80 && _pT_yy < 200 )
	_h_cosTS_pTyy_high->fill(_cosTS_CS,_weight);
	else if ( _pT_yy > 200 )
	_h_cosTS_pTyy_rest->fill(_cosTS_CS,_weight);

	// 2D distributions of pT_yy x Njets
	if ( _Njets30 == 0 )
	_h_pTyy_Njets0->fill(_pT_yy, _weight);
	else if ( _Njets30 == 1 )
	_h_pTyy_Njets1->fill(_pT_yy, _weight);
	else if ( _Njets30 >= 2 )
	_h_pTyy_Njets2->fill(_pT_yy, _weight);

	if ( _Njets30 == 1 ) _h_pTj1_excl->fill(_pT_j1, _weight);

	}

	// Normalise histograms after the run
	void finalize() {

	const double xs = crossSectionPerEvent()/femtobarn;

	scale(_h_pT_yy, xs);
	scale(_h_y_yy, xs);
	scale(_h_pT_j1, xs);
	scale(_h_y_j1, xs);
	scale(_h_HT, xs);
	scale(_h_pT_j2, xs);
	scale(_h_Dy_jj, xs);
	scale(_h_Dphi_yy_jj, xs);
	scale(_h_cosTS_CS, xs);
	scale(_h_cosTS_CS_5bin, xs);
	scale(_h_Dphi_jj, xs);
	scale(_h_pTt_yy, xs);
	scale(_h_Dy_yy, xs);
	scale(_h_tau_jet, xs);
	scale(_h_sum_tau_jet, xs);
	scale(_h_y_j2, xs);
	scale(_h_pT_j3, xs);
	scale(_h_m_jj, xs);
	scale(_h_pT_yy_jj, xs);
	scale(_h_cosTS_pTyy_low, xs);
	scale(_h_cosTS_pTyy_high, xs);
	scale(_h_cosTS_pTyy_rest, xs);
	scale(_h_pTyy_Njets0, xs);
	scale(_h_pTyy_Njets1, xs);
	scale(_h_pTyy_Njets2, xs);
	scale(_h_pTj1_excl, xs);
	scale(_h_Njets30, xs);
	scale(_h_Njets50, xs);
	scale(_h_fidXSecs, xs);
	}

	// Trace event record to see if particle came from a hadron (or a tau from a hadron decay)
	// Based on fromDecay() function
	bool fromHadronDecay(const Particle& p ) {
	const GenVertex* prodVtx = p.genParticle()->production_vertex();
	if (prodVtx == NULL) return false;
	foreach (const GenParticle* ancestor, particles(prodVtx, HepMC::ancestors)) {
	const PdgId pid = ancestor->pdg_id();
	if (ancestor->status() == 2 && PID::isHadron(pid)) return true;
	if (ancestor->status() == 2 && (abs(pid) == PID::TAU && fromHadronDecay(ancestor))) return true;
	}
	return false;
	}

	// VBF-enhanced dijet topology selection cuts
	bool passVBFCuts(const FourMomentum &H, const FourMomentum &j1, const FourMomentum &j2) {
	return ( fabs(deltaRap(j1, j2)) > 2.8 && (j1 + j2).mass() > 400 && fabs(deltaPhi(H, j1 + j2)) > 2.6 );
	}

	// Cosine of the decay angle in the Collins-Soper frame
	double cosTS_CS(const FourMomentum &y1, const FourMomentum &y2) {
	return fabs( ( (y1.E() + y1.pz())* (y2.E() - y2.pz()) - (y1.E() - y1.pz()) * (y2.E() + y2.pz()) )
	/ ((y1 + y2).mass() * sqrt(pow((y1 + y2).mass(), 2) + pow((y1 + y2).pt(), 2)) ) );
	}

	// Diphoton pT along thrust axis
	double pTt(const FourMomentum &y1, const FourMomentum &y2) {
	return fabs(y1.px() * y2.py() - y2.px() * y1.py()) / (y1 - y2).pT()*2;
	}

	// Tau of jet (see paper for description)
	// tau_jet = mT/(2cosh(y)), where mT = pT (+) m, and y* = rapidty in Higgs rest frame
	double tau_jet( const FourMomentum &H, const FourMomentum &jet ) {
	return sqrt( pow(jet.pT(),2) + pow(jet.mass(),2) ) / (2.0 * cosh( jet.rapidity() - H.rapidity() ) );
	}

	// Maximal (leading) tau_jet (see paper for description)
	double tau_jet_max( const FourMomentum &H, const vector<const Jet*> jets, double tau_jet_cut = 8. ) {
	double max_tj = 0;
	for (size_t i=0; i < jets.size(); ++i) {
	FourMomentum jet = jets[i]->momentum();
	if ( tau_jet(H, jet) > tau_jet_cut )
	max_tj = max( tau_jet(H, jet), max_tj );
	}
	return max_tj;
	}

	// Scalar sum of tau for all jets (see paper for description)
	double sum_tau_jet( const FourMomentum &H, const vector<const Jet*> jets, double tau_jet_cut = 8. ) {
	double sum_tj = 0;
	for (size_t i=0; i < jets.size(); ++i) {
	FourMomentum jet = jets[i]->momentum();
	if ( tau_jet(H, jet) > tau_jet_cut )
	sum_tj += tau_jet(H, jet);
	}
	return sum_tj;
	}

	private:

	Histo1DPtr _h_pT_yy;
	Histo1DPtr _h_y_yy;
	Histo1DPtr _h_Njets30;
	Histo1DPtr _h_Njets50;
	Histo1DPtr _h_pT_j1;
	Histo1DPtr _h_y_j1;
	Histo1DPtr _h_HT;
	Histo1DPtr _h_pT_j2;
	Histo1DPtr _h_Dy_jj;
	Histo1DPtr _h_Dphi_yy_jj;
	Histo1DPtr _h_cosTS_CS;
	Histo1DPtr _h_cosTS_CS_5bin;
	Histo1DPtr _h_Dphi_jj;
	Histo1DPtr _h_pTt_yy;
	Histo1DPtr _h_Dy_yy;
	Histo1DPtr _h_tau_jet;
	Histo1DPtr _h_sum_tau_jet;
	Histo1DPtr _h_y_j2;
	Histo1DPtr _h_pT_j3;
	Histo1DPtr _h_m_jj;
	Histo1DPtr _h_pT_yy_jj;
	Histo1DPtr _h_cosTS_pTyy_low;
	Histo1DPtr _h_cosTS_pTyy_high;
	Histo1DPtr _h_cosTS_pTyy_rest;
	Histo1DPtr _h_pTyy_Njets0;
	Histo1DPtr _h_pTyy_Njets1;
	Histo1DPtr _h_pTyy_Njets2;
	Histo1DPtr _h_pTj1_excl;
	Histo1DPtr _h_fidXSecs;

	double _weight;
	int _Njets30;
	int _Njets50;
	double _pT_yy;
	double _y_yy;
	double _cosTS_CS;
	double _pT_j1;
	double _m_jj;
	double _y_j1;
	double _HT;
	double _pT_j2;
	double _y_j2;
	double _Dphi_yy_jj;
	double _pT_yy_jj;
	double _Dphi_jj;
	double _Dy_jj;
	double _pT_j3;
	double _pTt_yy;
	double _Dy_yy;
	double _tau_jet;
	double _sum_tau_jet;
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1306615);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1307243.cc b/src/Analyses/ATLAS_2014_I1307243.cc
	--- a/src/Analyses/ATLAS_2014_I1307243.cc
	+++ b/src/Analyses/ATLAS_2014_I1307243.cc
	@@ -1,244 +1,244 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	/// @brief ATLAS azimuthal decorrelation with jet veto analysis
	/// @author James Robinson <james.robinson@cern.ch>
	class ATLAS_2014_I1307243 : public Analysis {
	public:

	/// Constructor
	ATLAS_2014_I1307243()
	: Analysis("ATLAS_2014_I1307243"),
	_fiducialRegions{2010, 2011},
	_vetoScale{20GeV, 30GeV},
	_yFiducial{4.4, 2.4},
	_gapCategories{"inclusive", "gap"},
	_dy_max(8),
	_nEventsInAcceptance(0),
	_sumOfAcceptedWeights(0.)
	{ }


	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections here
	FinalState fs;
	FastJets fastJets(fs, FastJets::ANTIKT, 0.6);
	fastJets.useInvisibles(true);
	- addProjection(fastJets, "AntiKt6JetsWithInvisibles");
	+ declare(fastJets, "AntiKt6JetsWithInvisibles");


	/// Book histograms
	foreach (const string& gapCategory, _gapCategories ) {
	const int gapCategoryOffset = (gapCategory == "inclusive") ? 0 : 1;

	// Temporary inclusive and gap histograms
	_h_tmp_events_dy[gapCategory] = bookHisto1D(1, 1, 1);
	_h_tmp_events_dy[gapCategory]->setPath("/TMP/" + toString(gapCategory) + "_events_dy");
	_h_tmp_events_pTbar[gapCategory] = bookHisto1D(2, 1, 1);
	_h_tmp_events_pTbar[gapCategory]->setPath("/TMP/" + toString(gapCategory) + "_events_pTbar");

	// Azimuthal moment histograms
	_h_profiled_cosDeltaPhi_dy[gapCategory] = bookProfile1D( 5+4*gapCategoryOffset, 1, 1);
	_h_profiled_cosDeltaPhi_pTbar[gapCategory] = bookProfile1D( 6+4*gapCategoryOffset, 1, 1);
	_h_C2C1_dy[gapCategory] = bookScatter2D( 7+4*gapCategoryOffset, 1, 1, false);
	_h_C2C1_pTbar[gapCategory] = bookScatter2D( 8+4*gapCategoryOffset, 1, 1, false);
	_h_profiled_cosTwoDeltaPhi_dy[gapCategory] = bookProfile1D(37+2*gapCategoryOffset, 1, 1);
	_h_profiled_cosTwoDeltaPhi_pTbar[gapCategory] = bookProfile1D(38+2*gapCategoryOffset, 1, 1);

	// Gap fraction vs. Q0 and cross-section in dy slices
	for (size_t dyLow = 0; dyLow < _dy_max; ++dyLow ) {
	Histo1DPtr _h_tmp_events_Q0_single_dySlice = bookHisto1D( 29+dyLow, 1, 1);
	_h_tmp_events_Q0_single_dySlice->setPath("/TMP/" + toString(gapCategory) + "_events_dySlice_" + toString(dyLow) + "_" + toString(dyLow+1) + "_Q0");
	_h_tmp_events_Q0_dySlices[gapCategory].addHistogram( dyLow, dyLow+1, _h_tmp_events_Q0_single_dySlice );
	_h_crossSection_dphi_dySlices[gapCategory].addHistogram( dyLow, dyLow+1, bookHisto1D( 13+(_dy_max*gapCategoryOffset)+dyLow, 1, 1));
	}

	}

	// Number of jets in rapidity interval
	_h_profiled_nJets_rapidity_interval_dy = bookProfile1D( 3, 1, 1);
	_h_profiled_nJets_rapidity_interval_pTbar = bookProfile1D( 4, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Get the event weight
	const double weight( event.weight() );
	bool eventAccepted( false );

	for (int iFiducialRegion = 0; iFiducialRegion < 2; ++iFiducialRegion ) {

	// Retrieve all anti-kt R=0.6 jets above _pTMin and inside \|_yFiducial\|
	- const Jets akt6Jets = applyProjection<JetAlg>(event, "AntiKt6JetsWithInvisibles").jetsByPt( Cuts::absrap < _yFiducial.at(iFiducialRegion) );
	+ const Jets akt6Jets = apply<JetAlg>(event, "AntiKt6JetsWithInvisibles").jetsByPt( Cuts::absrap < _yFiducial.at(iFiducialRegion) );
	// If there are fewer than 2 jets then bail
	if ( akt6Jets.size() < 2 ) { vetoEvent; }

	// Require jets to be above {60, 50} GeV
	if ( akt6Jets.at(0).momentum().pT() < 60.GeV \|\| akt6Jets.at(1).momentum().pT() < 50.GeV ) { vetoEvent; }

	// Identify gap boundaries
	double yMin( std::min( akt6Jets.at(0).momentum().rapidity(), akt6Jets.at(1).momentum().rapidity() ) );
	double yMax( std::max( akt6Jets.at(0).momentum().rapidity(), akt6Jets.at(1).momentum().rapidity() ) );

	// Determine azimuthal decorrelation quantities
	const double dy( yMax - yMin );
	const double dphi( mapAngle0ToPi( akt6Jets.at(0).momentum().phi() - akt6Jets.at(1).momentum().phi() ) );
	const double pTbar( (akt6Jets.at(0).momentum().pT() + akt6Jets.at(1).momentum().pT())/2.0 );

	// Impose minimum dy for the 2011 phase space
	if ( _fiducialRegions.at(iFiducialRegion) == 2011 && dy < 1.0 ) { vetoEvent; }

	// Construct gap candidates sample
	Jets gapCandidates;
	foreach( const Jet &j, akt6Jets ) {
	if ( inRange( j.momentum().rapidity(), yMin, yMax, OPEN, OPEN ) ) {
	gapCandidates.push_back( j );
	}
	}

	// Determine gap quantities
	unsigned int nJets_rapidity_interval( 0 );
	double maximumGapQ0( 0. );
	foreach( const Jet &jet, gapCandidates ) {
	const double pT( jet.momentum().pT() );
	if ( pT > _vetoScale.at(iFiducialRegion) ) { ++nJets_rapidity_interval; }
	if ( pT > maximumGapQ0 ) { maximumGapQ0 = pT; }
	}

	// Fill histograms
	if ( weight < 0.0 ) {
	MSG_DEBUG( "Negative weight " << weight << "found!" );
	}
	fillHistograms( _fiducialRegions.at(iFiducialRegion), dy, pTbar, dphi, nJets_rapidity_interval, maximumGapQ0, weight );
	eventAccepted = true;
	}

	// Count number of accepted events
	if ( eventAccepted ) {
	_nEventsInAcceptance++;
	_sumOfAcceptedWeights += weight;
	}
	return;
	}

	void fillHistograms( const unsigned int &fiducialRegion, const double &dy, const double &pTbar, const double &dphi, const double &nJets_rapidity_interval, const double &maximumGapQ0, const double &weight) {
	// Determine gap category
	- vector<string> eventGapCategories = boost::assign::list_of("inclusive");
	- if ( nJets_rapidity_interval == 0 ) { eventGapCategories.push_back("gap"); }
	+ vector<string> eventGapCategories{{"inclusive"}};
	+ if ( nJets_rapidity_interval == 0 ) { eventGapCategories += string("gap"); }

	// Fill histograms relevant for comparison with 2010 data
	if ( fiducialRegion == _fiducialRegions.at(0) ) {
	// Fill inclusive and gap histograms
	foreach( const string &gapCategory, eventGapCategories ) {
	_h_tmp_events_dy[gapCategory]->fill( dy, weight );
	_h_crossSection_dphi_dySlices[gapCategory].fill( dy, dphi / M_PI, weight );
	_h_profiled_cosDeltaPhi_dy[gapCategory]->fill( dy, cos(M_PI - dphi), weight );
	_h_profiled_cosTwoDeltaPhi_dy[gapCategory]->fill( dy, cos(2.0 * dphi), weight );
	}
	// Fill profiled nJets_rapidity_interval
	_h_profiled_nJets_rapidity_interval_dy->fill( dy, nJets_rapidity_interval, weight );
	// Fill Q0 histograms - can fill multiple points per event
	foreach( const YODA::HistoBin1D Q0_bin, _h_tmp_events_Q0_dySlices["inclusive"].getHistograms().at(0)->bins() ) {
	const double Q0( Q0_bin.xMid() );
	_h_tmp_events_Q0_dySlices["inclusive"].fill(dy, Q0, weight);
	if ( maximumGapQ0 <= Q0 ) { _h_tmp_events_Q0_dySlices["gap"].fill(dy, Q0, weight); }
	}

	// Fill histograms relevant for comparison with 2011 data
	} else if ( fiducialRegion == _fiducialRegions.at(1) ) {
	// Fill inclusive and gap histograms
	foreach( const string &gapCategory, eventGapCategories ) {
	_h_tmp_events_pTbar[gapCategory]->fill( pTbar, weight );
	_h_profiled_cosDeltaPhi_pTbar[gapCategory]->fill( pTbar, cos(M_PI - dphi), weight );
	_h_profiled_cosTwoDeltaPhi_pTbar[gapCategory]->fill( pTbar, cos(2.0 * dphi), weight );
	}
	// Fill profiled nJets_rapidity_interval
	_h_profiled_nJets_rapidity_interval_pTbar->fill( pTbar, nJets_rapidity_interval, weight );
	}
	return;
	}

	/// Normalise histograms etc., after the run
	void finalize() {
	// Normalise cross-section plots to correct cross-section
	const double xs_pb( crossSection()/picobarn );
	const double nEventsGenerated( sumOfWeights() );
	double xs_norm_factor( xs_pb/nEventsGenerated );
	const double ySpan(1); // all dy spans are 1
	foreach (const string& gapCategory, _gapCategories ) {
	_h_crossSection_dphi_dySlices[gapCategory].scale(xs_norm_factor/ySpan/M_PI, this);
	}

	// Create C2/C1 scatter from profiles
	foreach (const string& gapCategory, _gapCategories ) {
	divide( _h_profiled_cosTwoDeltaPhi_dy[gapCategory], _h_profiled_cosDeltaPhi_dy[gapCategory], _h_C2C1_dy[gapCategory] );
	divide( _h_profiled_cosTwoDeltaPhi_pTbar[gapCategory], _h_profiled_cosDeltaPhi_pTbar[gapCategory], _h_C2C1_pTbar[gapCategory] );
	}

	// Fill simple gap fractions
	Scatter2DPtr h_gap_fraction_dy = bookScatter2D( 1, 1, 1);
	Scatter2DPtr h_gap_fraction_pTbar = bookScatter2D( 2, 1, 1, false);
	Rivet::Analysis::efficiency( _h_tmp_events_dy["gap"].get(), _h_tmp_events_dy["inclusive"].get(), h_gap_fraction_dy );
	Rivet::Analysis::efficiency( _h_tmp_events_pTbar["gap"].get(), _h_tmp_events_pTbar["inclusive"].get(), h_gap_fraction_pTbar );

	// Register and fill Q0 gap fractions
	for (unsigned int dyLow = 0; dyLow < _dy_max; ++dyLow ) {
	Scatter2DPtr h_gap_fraction_Q0 = bookScatter2D( 29+dyLow, 1, 1, false);
	Rivet::Analysis::efficiency( _h_tmp_events_Q0_dySlices["gap"].getHistograms().at(dyLow).get(), _h_tmp_events_Q0_dySlices["inclusive"].getHistograms().at(dyLow).get(), h_gap_fraction_Q0 );
	}

	/// Print summary information
	MSG_INFO( "Cross-Section/pb : " << xs_pb );
	MSG_INFO( "Sum of weights : " << sumOfWeights() << " (" << _sumOfAcceptedWeights << " accepted)" );
	MSG_INFO( "nEvents : " << numEvents() << " (" << _nEventsInAcceptance << " accepted)" );
	MSG_INFO( "Normalisation factor : " << xs_norm_factor );
	}


	private:

	/// Member variables
	vector<unsigned int> _fiducialRegions;
	vector<double> _vetoScale, _yFiducial;
	vector<string> _gapCategories;

	unsigned int _dy_max;
	unsigned int _nEventsInAcceptance;
	double _sumOfAcceptedWeights;

	/// Histograms
	// Number of events : gap and non-gap : necessary input for gap fractions but not saved as output
	map<string, Histo1DPtr> _h_tmp_events_dy;
	map<string, Histo1DPtr> _h_tmp_events_pTbar;
	map<string, BinnedHistogram<double> > _h_tmp_events_Q0_dySlices;

	// Number of jets in rapidity interval
	Profile1DPtr _h_profiled_nJets_rapidity_interval_dy;
	Profile1DPtr _h_profiled_nJets_rapidity_interval_pTbar;

	// Azimuthal moment histograms
	map<string, Profile1DPtr> _h_profiled_cosDeltaPhi_dy;
	map<string, Profile1DPtr> _h_profiled_cosDeltaPhi_pTbar;
	map<string, Profile1DPtr> _h_profiled_cosTwoDeltaPhi_dy;
	map<string, Profile1DPtr> _h_profiled_cosTwoDeltaPhi_pTbar;
	map<string, Scatter2DPtr> _h_C2C1_dy;
	map<string, Scatter2DPtr> _h_C2C1_pTbar;

	// Cross-section vs. #Delta#phi
	map<string, BinnedHistogram<double> > _h_crossSection_dphi_dySlices;
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1307243);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1307756.cc b/src/Analyses/ATLAS_2014_I1307756.cc
	--- a/src/Analyses/ATLAS_2014_I1307756.cc
	+++ b/src/Analyses/ATLAS_2014_I1307756.cc
	@@ -1,172 +1,154 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class ATLAS_2014_I1307756 : public Analysis {
	public:

	/// Constructor
	ATLAS_2014_I1307756()
	- : Analysis("ATLAS_2014_I1307756"),
	- _eta_bins_areaoffset{0.0, 1.5, 3.0}
	+ : Analysis("ATLAS_2014_I1307756")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections here
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	FastJets fj(fs, FastJets::KT, 0.5);
	fj.useJetArea(new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec()));
	- addProjection(fj, "KtJetsD05");
	+ declare(fj, "KtJetsD05");

	IdentifiedFinalState photonfs(Cuts::abseta < 2.37 && Cuts::pT > 22*GeV);
	photonfs.acceptId(PID::PHOTON);
	- addProjection(photonfs, "photons");
	+ declare(photonfs, "photons");

	// Initialize event count here:
	_fidWeights = 0.;
	}


	- /// Utility to compute ambiant energy density per eta bin
	- /// @todo Use bin index lookup util instead...
	- int getEtaBin(double eta_w) const {
	- double eta = fabs(eta_w);
	- int v_iter = 0;
	- for (v_iter = 0; v_iter < (int)_eta_bins_areaoffset.size()-1; ++v_iter) {
	- if (inRange(eta, _eta_bins_areaoffset[v_iter], _eta_bins_areaoffset[v_iter+1]))
	- break;
	- }
	- return v_iter;
	+ int getEtaBin(double eta) const {
	+ double aeta = fabs(eta);
	+ return binIndex(aeta, _eta_bins_areaoffset);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	/// Require at least 2 photons in final state
	- Particles photons = applyProjection<IdentifiedFinalState>(event, "photons").particlesByPt();
	+ Particles photons = apply<IdentifiedFinalState>(event, "photons").particlesByPt();
	if (photons.size() < 2) vetoEvent;

	- /// compute the median energy density per eta bin
	- vector<double> ptDensity;
	+ // Get jet pT densities
	vector< vector<double> > ptDensities(_eta_bins_areaoffset.size()-1);
	-
	- const auto clust_seq_area = applyProjection<FastJets>(event, "KtJetsD05").clusterSeqArea();
	- for (const Jet& jet : applyProjection<FastJets>(event, "KtJetsD05").jets()) {
	+ const auto clust_seq_area = apply<FastJets>(event, "KtJetsD05").clusterSeqArea();
	+ for (const Jet& jet : apply<FastJets>(event, "KtJetsD05").jets()) {
	const double area = clust_seq_area->area(jet);
	if (area > 1e-4 && jet.abseta() < _eta_bins_areaoffset.back()) {
	- ptDensities.at(getEtaBin(jet.abseta())).push_back(jet.pT()/area);
	+ ptDensities.at(getEtaBin(jet.abseta())) += jet.pT()/area;
	}
	}

	+ /// Compute the median energy density per eta bin
	+ vector<double> ptDensity;
	for (size_t b = 0; b < _eta_bins_areaoffset.size()-1; ++b) {
	- double median = 0.0;
	- if (ptDensities[b].size() > 0) {
	- std::sort(ptDensities[b].begin(), ptDensities[b].end());
	- const int nDens = ptDensities[b].size();
	- if (nDens % 2 == 0) {
	- median = (ptDensities[b][nDens/2] + ptDensities[b][(nDens-2)/2]) / 2;
	- } else {
	- median = ptDensities[b][(nDens-1)/2];
	- }
	- }
	- ptDensity.push_back(median);
	+ ptDensity += ptDensities[b].empty() ? 0 : median(ptDensities[b]);
	}

	// Loop over photons and find isolated ones
	Particles isolated_photons;
	for (const Particle& ph : photons) {
	- Particles fs = applyProjection<FinalState>(event, "FS").particles();
	+ Particles fs = apply<FinalState>(event, "FS").particles();
	FourMomentum mom_in_EtCone;
	for (const Particle& p : fs) {

	// Reject if the particle is not in DR=0.4 cone
	if (deltaR(ph.momentum(), p.momentum()) > 0.4) continue;

	// Reject if the particle falls in the photon core
	if (fabs(ph.eta() - p.eta()) < 0.025 * 7 * 0.5 &&
	fabs(ph.phi() - p.phi()) < PI/128. * 5 * 0.5) continue;

	// Reject if the particle is a neutrino (muons are kept)
	if (p.isNeutrino()) continue;

	// Sum momenta
	mom_in_EtCone += p.momentum();
	}

	// Subtract the UE correction (area*density)
	- double EtCone_area = M_PI.4.4 - (7.0.025)(5.0*M_PI/128.);
	- double correction = ptDensity[getEtaBin(ph.eta())]*EtCone_area;
	+ const double ETCONE_AREA = M_PI.4.4 - (7.0.025)(5.0*M_PI/128.);
	+ const double correction = ptDensity[getEtaBin(ph.eta())] * ETCONE_AREA;

	// Add isolated photon to list
	if (mom_in_EtCone.Et() - correction > 12*GeV) continue;
	isolated_photons.push_back(ph);
	}

	// Require at least two isolated photons
	if (isolated_photons.size() < 2) vetoEvent ;

	// Select leading pT pair
	std::sort(isolated_photons.begin(), isolated_photons.end(), cmpMomByPt);
	- FourMomentum y1 = isolated_photons[0].momentum();
	- FourMomentum y2 = isolated_photons[1].momentum();
	+ const FourMomentum& y1 = isolated_photons[0].momentum();
	+ const FourMomentum& y2 = isolated_photons[1].momentum();

	// Compute invariant mass
	- FourMomentum yy = y1 + y2;
	- double Myy = yy.mass();
	+ const FourMomentum yy = y1 + y2;
	+ const double Myy = yy.mass();

	// If Myy >= 110 GeV, apply relative cuts
	- if (Myy/GeV >= 110 && (y1.Et()/Myy < 0.4 \|\| y2.Et()/Myy < 0.3) ) vetoEvent;
	+ if (Myy >= 110*GeV && (y1.Et()/Myy < 0.4 \|\| y2.Et()/Myy < 0.3) ) vetoEvent;

	// Add to cross-section
	_fidWeights += event.weight();
	}


	/// @todo Add to the YODA output rather than print to log
	void finalize() {

	// Compute selection efficiency & statistical error
	const double eff = _fidWeights/sumOfWeights();
	const double err = sqrt(eff*(1-eff)/numEvents());

	// Compute fiducial cross-section in fb
	const double fidCrossSection = eff * crossSection()/femtobarn;

	// Print out result
	MSG_INFO("==================================================");
	MSG_INFO("==== Total cross-section: " << crossSection()/femtobarn<< " fb");
	MSG_INFO("==== Fiducial cross-section: " << fidCrossSection << " fb");
	MSG_INFO("==================================================");
	MSG_INFO("==== Selection efficiency: " << eff << " +/- " << err << " (statistical error)");
	MSG_INFO("==================================================");
	}

	//@}


	private:

	- vector<double> _eta_bins_areaoffset;
	- float _fidWeights;
	+ const vector<double> _eta_bins_areaoffset = {0.0, 1.5, 3.0};
	+ double _fidWeights;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1307756);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1312627.cc b/src/Analyses/ATLAS_2014_I1312627.cc
	--- a/src/Analyses/ATLAS_2014_I1312627.cc
	+++ b/src/Analyses/ATLAS_2014_I1312627.cc
	@@ -1,258 +1,258 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// Measurement of V+jets distributions, taken as ratios between W and Z channels
	class ATLAS_2014_I1312627 : public Analysis {
	public:

	/// @name Plotting helper types
	//@{

	struct Plots {
	string ref;
	Histo1DPtr comp[2]; // (de)nominator components
	Scatter2DPtr ratio; // Rjets plot
	};

	typedef map<string, Plots> PlotMap;
	typedef PlotMap::value_type PlotMapPair;

	//@}


	/// Constructor
	ATLAS_2014_I1312627(std::string name="ATLAS_2014_I1312627")
	: Analysis(name)
	{
	_mode = 0; // using electron channel for combined data by default
	setNeedsCrossSection(true);
	}


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Set up cuts
	Cut cuts;
	if (_mode == 2) { // muon channel
	cuts = (Cuts::pT > 25.0*GeV) & Cuts::etaIn(-2.4, 2.4);
	} else if (_mode) { // electron channel
	cuts = (Cuts::pT > 25.0*GeV) & ( Cuts::etaIn(-2.47, -1.52) \| Cuts::etaIn(-1.37, 1.37) \| Cuts::etaIn(1.52, 2.47) );
	} else { // combined data extrapolated to common phase space
	cuts = (Cuts::pT > 25.0*GeV) & Cuts::etaIn(-2.5, 2.5);
	}

	// Boson finders
	FinalState fs;
	WFinder wfinder(fs, cuts, _mode > 1? PID::MUON : PID::ELECTRON, 40.0GeV, MAXDOUBLE, 0.0GeV, 0.1,
	WFinder::CLUSTERNODECAY, WFinder::NOTRACK, WFinder::TRANSMASS);
	- addProjection(wfinder, "WF");
	+ declare(wfinder, "WF");

	ZFinder zfinder(fs, cuts, _mode > 1? PID::MUON : PID::ELECTRON, 66.0GeV, 116.0GeV, 0.1, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);
	- addProjection(zfinder, "ZF");
	+ declare(zfinder, "ZF");

	// Jets
	VetoedFinalState jet_fs(fs);
	jet_fs.addVetoOnThisFinalState(getProjection<WFinder>("WF"));
	jet_fs.addVetoOnThisFinalState(getProjection<ZFinder>("ZF"));
	FastJets jets(jet_fs, FastJets::ANTIKT, 0.4);
	jets.useInvisibles(true);
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");


	// Book Rjets plots
	_suff = string("-y0") + to_str(_mode + 1);
	hInit("Njets_incl", "d01"); // inclusive number of jets
	hInit("Njets_excl", "d04"); // exclusive number of jets
	hInit("Pt1_N1incl", "d05"); // leading jet pT, at least 1 jet
	hInit("Pt1_N1excl", "d06"); // leading jet pT, exactly 1 jet
	hInit("Pt1_N2incl", "d07"); // leading jet pT, at least 2 jets
	hInit("Pt1_N3incl", "d08"); // leading jet pT, at least 3 jets
	hInit("Pt2_N2incl", "d09"); // subleading jet pT, at least 2 jets
	hInit("Pt3_N3incl", "d10"); // sub-subleading jet pT, at least 3 jets
	hInit("ST_N2incl", "d11"); // scalar jet pT sum, at least 2 jets
	hInit("ST_N2excl", "d12"); // scalar jet pT sum, exactly 2 jets
	hInit("ST_N3incl", "d13"); // scalar jet pT sum, at least 3 jets
	hInit("ST_N3excl", "d14"); // scalar jet pT sum, exactly 3 jets
	hInit("DR_N2incl", "d15"); // deltaR(j1, j2), at least 2 jets
	hInit("DPhi_N2incl", "d16"); // deltaPhi(j1, j2), at least 2 jets
	hInit("Mjj_N2incl", "d17"); // mjj, at least 2 jets
	hInit("Rap1_N1incl", "d18"); // leading jet rapidity, at least 1 jet
	hInit("Rap2_N2incl", "d19"); // subleading jet rapidity, at least 2 jets
	hInit("Rap3_N3incl", "d20"); // sub-subleading jet rapidity, at least 3 jets

	// Also book numerator and denominator for Rjets plots
	foreach (PlotMapPair& str_plot, _plots) {
	str_plot.second.comp[0] = bookHisto1D( str_plot.second.ref + "2" + _suff, *(str_plot.second.ratio) );
	str_plot.second.comp[1] = bookHisto1D( str_plot.second.ref + "3" + _suff, *(str_plot.second.ratio) );
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Retrieve boson candidate
	- const WFinder& wf = applyProjection<WFinder>(event, "WF");
	- const ZFinder& zf = applyProjection<ZFinder>(event, "ZF");
	+ const WFinder& wf = apply<WFinder>(event, "WF");
	+ const ZFinder& zf = apply<ZFinder>(event, "ZF");
	if (wf.empty() && zf.empty()) vetoEvent;

	// Retrieve jets
	- const JetAlg& jetfs = applyProjection<JetAlg>(event, "Jets");
	+ const JetAlg& jetfs = apply<JetAlg>(event, "Jets");
	Jets all_jets = jetfs.jetsByPt(Cuts::pT > 30*GeV && Cuts::absrap < 4.4);

	// Apply boson cuts and fill histograms
	const double weight = event.weight();
	if (zf.size() == 2) {
	const Particles& leptons = zf.constituents();
	if (oppSign(leptons[0], leptons[1]) && deltaR(leptons[0], leptons[1]) > 0.2)
	fillPlots(leptons, all_jets, weight, 1);
	}
	if (!wf.empty()) {
	const Particles& leptons = wf.constituentLeptons();
	if (wf.constituentNeutrino().pT() > 25GeV && wf.mT() > 40GeV )
	fillPlots(leptons, all_jets, weight, 0);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	/// Normalise, scale and otherwise manipulate histograms here
	const double sf( crossSection() / sumOfWeights() );
	foreach (PlotMapPair& str_plot, _plots) {
	scale(str_plot.second.comp[0], sf);
	scale(str_plot.second.comp[1], sf);
	divide(str_plot.second.comp[0], str_plot.second.comp[1], str_plot.second.ratio);
	}
	}
	//@}


	/// Analysis helper functions
	//@{

	/// Histogram filling function, to avoid duplication
	void fillPlots(const Particles& leptons, Jets& all_jets, const double& weight, int isZ) {
	// Do jet-lepton overlap removal
	Jets jets;
	foreach (const Jet& j, all_jets) {
	/// @todo A nice place for a lambda and any() logic when C++11 is available
	bool keep = true;
	foreach (const Particle& l, leptons) keep &= deltaR(j, l) > 0.5;
	if (keep) jets.push_back(j);
	}

	// Calculate jet ST
	const size_t njets = jets.size();
	double ST = 0.0; // scalar pT sum of all selected jets
	for (size_t i = 0; i < njets; ++i)
	ST += jets[i].pT() * GeV;

	// Fill jet histos
	_plots["Njets_excl"].comp[isZ]->fill(njets + 0.5, weight);
	for (size_t i = 0; i <= njets; ++i)
	_plots["Njets_incl"].comp[isZ]->fill(i + 0.5, weight);

	if (njets > 0) {
	const double pT1 = jets[0].pT()/GeV;
	const double rap1 = jets[0].absrap();
	_plots["Pt1_N1incl" ].comp[isZ]->fill(pT1, weight);
	_plots["Rap1_N1incl"].comp[isZ]->fill(rap1, weight);

	if (njets == 1) {
	_plots["Pt1_N1excl"].comp[isZ]->fill(pT1, weight);
	} else if (njets > 1) {
	const double pT2 = jets[1].pT()/GeV;
	const double rap2 = jets[1].absrap();
	const double dR = deltaR(jets[0], jets[1]);
	const double dPhi = deltaPhi(jets[0], jets[1]);
	const double mjj = (jets[0].momentum() + jets[1].momentum()).mass()/GeV;
	_plots["Pt1_N2incl" ].comp[isZ]->fill(pT1, weight);
	_plots["Pt2_N2incl" ].comp[isZ]->fill(pT2, weight);
	_plots["Rap2_N2incl"].comp[isZ]->fill(rap2, weight);
	_plots["DR_N2incl" ].comp[isZ]->fill(dR, weight);
	_plots["DPhi_N2incl"].comp[isZ]->fill(dPhi, weight);
	_plots["Mjj_N2incl" ].comp[isZ]->fill(mjj, weight);
	_plots["ST_N2incl" ].comp[isZ]->fill(ST, weight);

	if (njets == 2) {
	_plots["ST_N2excl"].comp[isZ]->fill(ST, weight);
	} else if (njets > 2) {
	const double pT3 = jets[2].pT()/GeV;
	const double rap3 = jets[2].absrap();
	_plots["Pt1_N3incl" ].comp[isZ]->fill(pT1, weight);
	_plots["Pt3_N3incl" ].comp[isZ]->fill(pT3, weight);
	_plots["Rap3_N3incl"].comp[isZ]->fill(rap3, weight);
	_plots["ST_N3incl" ].comp[isZ]->fill(ST, weight);

	if (njets == 3)
	_plots["ST_N3excl"].comp[isZ]->fill(ST, weight);
	}
	}
	}
	}


	/// Helper for histogram initialisation
	void hInit(string label, string ident) {
	string pre = ident + "-x0";
	_plots[label].ref = pre;
	_plots[label].ratio = bookScatter2D(pre + "1" + _suff, true);
	}

	//@}


	protected:

	// Data members
	size_t _mode;
	string _suff;


	private:

	/// @name Map of histograms
	PlotMap _plots;

	};



	/// Electron-specific version of the ATLAS_2014_I1312627 R-jets analysis
	class ATLAS_2014_I1312627_EL : public ATLAS_2014_I1312627 {
	public:
	ATLAS_2014_I1312627_EL()
	: ATLAS_2014_I1312627("ATLAS_2014_I1312627_EL")
	{ _mode = 1; }
	};


	/// Muon-specific version of the ATLAS_2014_I1312627 R-jets analysis
	class ATLAS_2014_I1312627_MU : public ATLAS_2014_I1312627 {
	public:
	ATLAS_2014_I1312627_MU()
	: ATLAS_2014_I1312627("ATLAS_2014_I1312627_MU")
	{ _mode = 2; }
	};


	// Hooks for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1312627);
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1312627_EL);
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1312627_MU);


	}
	diff --git a/src/Analyses/ATLAS_2014_I1315949.cc b/src/Analyses/ATLAS_2014_I1315949.cc
	--- a/src/Analyses/ATLAS_2014_I1315949.cc
	+++ b/src/Analyses/ATLAS_2014_I1315949.cc
	@@ -1,233 +1,226 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	-//#include "Rivet/Projections/VetoedFinalState.hh"
	-#include "Rivet/ParticleName.hh"
	#include "Rivet/Projections/ZFinder.hh"

	-#include <utility>
	-
	-#include <cstdlib>
	-
	namespace Rivet {

	- using namespace Cuts;

	class ATLAS_2014_I1315949 : public Analysis {
	public:

	/// Constructor
	- ATLAS_2014_I1315949()
	+ ATLAS_2014_I1315949()
	: Analysis("ATLAS_2014_I1315949")
	{ }

	void init() {

	FinalState fs;

	ZFinder zfinder(fs, Cuts::abseta<2.4 && Cuts::pT>20.0GeV, PID::MUON, 66GeV, 116*GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	ChargedFinalState cfs( zfinder.remainingFinalState() );
	- addProjection(cfs, "cfs");
	+ declare(cfs, "cfs");


	_h_pTsum_tow = bookProfile1D( 1, 1, 1);
	_h_pTsum_trv = bookProfile1D( 1, 1, 2);
	_h_pTsum_away = bookProfile1D( 1, 1, 3);
	_h_pTsum_tmin = bookProfile1D( 1, 1, 4);
	_h_pTsum_tmax = bookProfile1D( 1, 1, 5);
	_h_pTsum_tdif = bookProfile1D( 1, 1, 6);

	_h_Nchg_tow = bookProfile1D( 2, 1, 1);
	_h_Nchg_trv = bookProfile1D( 2, 1, 2);
	_h_Nchg_away = bookProfile1D( 2, 1, 3);
	_h_Nchg_tmin = bookProfile1D( 2, 1, 4);
	_h_Nchg_tmax = bookProfile1D( 2, 1, 5);
	_h_Nchg_tdif = bookProfile1D( 2, 1, 6);

	_h_pTavg_tow = bookProfile1D( 3, 1, 1);
	_h_pTavg_trv = bookProfile1D( 3, 1, 2);
	_h_pTavg_away = bookProfile1D( 3, 1, 3);

	_h_pTavgvsmult_tow = bookProfile1D( 4, 1, 1);
	_h_pTavgvsmult_trv = bookProfile1D( 4, 1, 2);
	_h_pTavgvsmult_away = bookProfile1D( 4, 1, 3);


	// Book sumpt and nch histos
	for (int i_reg = 0; i_reg < 4; i_reg++) {
	for (int i_bin = 0; i_bin < 6.; i_bin++) {
	_h_ptSum_1D[i_reg][i_bin] = bookHisto1D (5, i_reg+1 , i_bin+1);
	_h_Nchg_1D[i_reg][i_bin] = bookHisto1D (6, i_reg+1 , i_bin+1);
	}
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();
	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");

	if (zfinder.bosons().size() != 1) vetoEvent;

	double Zpt = zfinder.bosons()[0].momentum().pT()/GeV;
	double Zphi = zfinder.bosons()[0].momentum().phi();
	double Zmass = zfinder.bosons()[0].momentum().mass()/GeV;
	if(Zmass < 66. \|\| Zmass > 116.) vetoEvent;

	// Initialise counters for Nch and sumPt for all regions
	int nTowards(0), nTransverse(0), nLeft(0), nRight(0), nTrmin(0), nTrmax(0), nAway(0);
	double ptSumTowards(0.0), ptSumTransverse(0.0), ptSumLeft(0.0), ptSumRight(0.0),
	ptSumTrmin(0.0), ptSumTrmax(0.0), ptSumAway(0.0);
	-
	+
	// The charged particles
	- ParticleVector particles = applyProjection<ChargedFinalState>(event, "cfs").particlesByPt(
	+ ParticleVector particles = apply<ChargedFinalState>(event, "cfs").particlesByPt(
	Cuts::pT > 0.5*GeV && Cuts::abseta <2.5);

	// Loop over charged particles with pT>500 MeV and \|eta\|<2.5
	foreach(const Particle& p, particles) {
	double dphi = p.momentum().phi() - Zphi,
	pT = p.momentum().pT();

	// Get multiples of 2pi right
	for(; std::fabs(dphi) > M_PI; dphi += (dphi > 0. ? -2.M_PI : 2.M_PI) );

	// Towards region
	if( std::fabs(dphi) < M_PI/3. ) {
	nTowards++;
	ptSumTowards += pT;
	- }
	+ }
	// Transverse region
	else if( std::fabs(dphi) < 2.*M_PI/3. ) {
	nTransverse++;
	ptSumTransverse += pT;
	if(dphi > 0.) {
	nRight++;
	ptSumRight += pT;
	}
	else {
	nLeft++;
	ptSumLeft += pT;
	}
	- }
	+ }
	// Away region
	else {
	nAway++;
	ptSumAway += pT;
	}
	}

	// TransMAX, TransMIN regions
	if (ptSumLeft > ptSumRight) {
	ptSumTrmax = ptSumLeft;
	ptSumTrmin = ptSumRight;
	nTrmax = nLeft;
	nTrmin = nRight;
	}
	else {
	ptSumTrmax = ptSumRight;
	ptSumTrmin = ptSumLeft;
	nTrmax = nRight;
	nTrmin = nLeft;
	}

	// min max regions have difference are than all other regions
	const double area = 5.2./3.M_PI;

	// Fill sumPt vs. Zpt region profiles
	_h_pTsum_tow->fill( Zpt, ptSumTowards/area, weight);
	_h_pTsum_trv->fill( Zpt, ptSumTransverse/area, weight);
	_h_pTsum_away->fill(Zpt, ptSumAway/area, weight);
	_h_pTsum_tmin->fill(Zpt, ptSumTrmin/(0.5*area), weight);
	_h_pTsum_tmax->fill(Zpt, ptSumTrmax/(0.5*area), weight);
	_h_pTsum_tdif->fill(Zpt, (ptSumTrmax - ptSumTrmin)/(0.5*area), weight);

	// Fill Nch vs. Zpt region profiles
	_h_Nchg_tow->fill( Zpt, nTowards/area, weight);
	_h_Nchg_trv->fill( Zpt, nTransverse/area, weight);
	_h_Nchg_away->fill(Zpt, nAway/area, weight);
	_h_Nchg_tmin->fill(Zpt, nTrmin/(0.5*area), weight);
	_h_Nchg_tmax->fill(Zpt, nTrmax/(0.5*area), weight);
	_h_Nchg_tdif->fill(Zpt, (nTrmax - nTrmin)/(0.5*area), weight);


	// Fill <pT> vs. ZpT profiles
	_h_pTavg_tow->fill( Zpt, nTowards > 0.? ptSumTowards/nTowards : 0., weight);
	_h_pTavg_trv->fill( Zpt, nTransverse > 0.? ptSumTransverse/nTransverse : 0., weight);
	_h_pTavg_away->fill(Zpt, nAway > 0.? ptSumAway/nAway : 0., weight);
	-
	+
	// Fill <Nch> vs. ZpT profiles
	_h_pTavgvsmult_tow->fill( nTowards, nTowards > 0.? ptSumTowards/nTowards : 0., weight);
	_h_pTavgvsmult_trv->fill( nTransverse, nTransverse > 0.? ptSumTransverse/nTransverse : 0., weight);
	_h_pTavgvsmult_away->fill(nAway, nAway > 0.? ptSumAway/nAway : 0., weight);

	// Determine Zpt region histo to fill
	int i_bin(0);
	if (inRange(Zpt,0,5) ) i_bin=0;
	if (inRange(Zpt,5,10) ) i_bin=1;
	- if (inRange(Zpt,10,20) ) i_bin=2;
	+ if (inRange(Zpt,10,20) ) i_bin=2;
	if (inRange(Zpt,20,50) ) i_bin=3;
	if (inRange(Zpt,50,110) ) i_bin=4;
	if (Zpt>110) i_bin=5;

	// SumPt histos for Zpt region
	_h_ptSum_1D[0][i_bin]->fill(ptSumTowards/area, weight);
	_h_ptSum_1D[1][i_bin]->fill(ptSumTransverse/area, weight);
	_h_ptSum_1D[2][i_bin]->fill(ptSumTrmin/(0.5*area), weight);
	_h_ptSum_1D[3][i_bin]->fill(ptSumTrmax/(0.5*area), weight);

	// Nch histos for Zpt region
	_h_Nchg_1D[0][i_bin]->fill(nTowards/area, weight);
	_h_Nchg_1D[1][i_bin]->fill(nTransverse/area, weight);
	_h_Nchg_1D[2][i_bin]->fill(nTrmin/(0.5*area), weight);
	_h_Nchg_1D[3][i_bin]->fill(nTrmax/(0.5*area), weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for(int i_reg = 0; i_reg < 4; i_reg++) {
	for(int i_bin = 0; i_bin < 6; i_bin++) {
	normalize( _h_ptSum_1D[i_reg][i_bin] );
	normalize( _h_Nchg_1D[ i_reg][i_bin] );
	}
	}
	}


	private:

	Profile1DPtr _h_pTsum_tow,
	_h_pTsum_trv,
	_h_pTsum_away,
	_h_pTsum_tmin,
	_h_pTsum_tmax,
	_h_pTsum_tdif,

	_h_Nchg_tow,
	_h_Nchg_trv,
	_h_Nchg_away,
	_h_Nchg_tmin,
	_h_Nchg_tmax,
	_h_Nchg_tdif,

	_h_pTavg_tow,
	_h_pTavg_trv,
	_h_pTavg_away,
	_h_pTavgvsmult_tow,
	_h_pTavgvsmult_trv,
	_h_pTavgvsmult_away;
	-
	+
	Histo1DPtr _h_ptSum_1D[4][6], _h_Nchg_1D[4][6];
	-
	+

	};

	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1315949);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1319490.cc b/src/Analyses/ATLAS_2014_I1319490.cc
	--- a/src/Analyses/ATLAS_2014_I1319490.cc
	+++ b/src/Analyses/ATLAS_2014_I1319490.cc
	@@ -1,232 +1,232 @@
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	class ATLAS_2014_I1319490 : public Analysis {
	public:

	ATLAS_2014_I1319490(string name = "ATLAS_2014_I1319490")
	: Analysis(name)
	{
	_mode = 0; // using electron channel for combined data by default
	setNeedsCrossSection(true);
	}


	// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;

	Cut cuts;
	if (_mode == 2) { // muon channel
	cuts = (Cuts::pT > 25.0*GeV) & Cuts::etaIn(-2.4, 2.4);
	} else if (_mode) { // electron channel
	cuts = (Cuts::pT > 25.0*GeV) & ( Cuts::etaIn(-2.47, -1.52) \| Cuts::etaIn(-1.37, 1.37) \| Cuts::etaIn(1.52, 2.47) );
	} else { // combined data extrapolated to common phase space
	cuts = (Cuts::pT > 25.0*GeV) & Cuts::etaIn(-2.5, 2.5);
	}

	// bosons
	WFinder wfinder(fs, cuts, _mode > 1? PID::MUON : PID::ELECTRON, 40.0GeV, MAXDOUBLE, 0.0GeV, 0.1,
	WFinder::CLUSTERNODECAY, WFinder::NOTRACK, WFinder::TRANSMASS);
	- addProjection(wfinder, "WF");
	+ declare(wfinder, "WF");

	// jets
	VetoedFinalState jet_fs(fs);
	jet_fs.addVetoOnThisFinalState(getProjection<WFinder>("WF"));
	FastJets jets(jet_fs, FastJets::ANTIKT, 0.4);
	jets.useInvisibles(true);
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	// book histograms
	histos["h_N_incl"] = bookHisto1D(1,1,_mode+1);
	histos["h_N"] = bookHisto1D(4,1,_mode+1);
	histos["h_pt_jet1_1jet"] = bookHisto1D(5,1,_mode+1);
	histos["h_pt_jet1_1jet_excl"] = bookHisto1D(6,1,_mode+1);
	histos["h_pt_jet1_2jet"] = bookHisto1D(7,1,_mode+1);
	histos["h_pt_jet1_3jet"] = bookHisto1D(8,1,_mode+1);
	histos["h_pt_jet2_2jet"] = bookHisto1D(9,1,_mode+1);
	histos["h_pt_jet3_3jet"] = bookHisto1D(10,1,_mode+1);
	histos["h_pt_jet4_4jet"] = bookHisto1D(11,1,_mode+1);
	histos["h_pt_jet5_5jet"] = bookHisto1D(12,1,_mode+1);
	histos["h_y_jet1_1jet"] = bookHisto1D(13,1,_mode+1);
	histos["h_y_jet2_2jet"] = bookHisto1D(14,1,_mode+1);
	histos["h_HT_1jet"] = bookHisto1D(15,1,_mode+1);
	histos["h_HT_1jet_excl"] = bookHisto1D(16,1,_mode+1);
	histos["h_HT_2jet"] = bookHisto1D(17,1,_mode+1);
	histos["h_HT_2jet_excl"] = bookHisto1D(18,1,_mode+1);
	histos["h_HT_3jet"] = bookHisto1D(19,1,_mode+1);
	histos["h_HT_3jet_excl"] = bookHisto1D(20,1,_mode+1);
	histos["h_HT_4jet"] = bookHisto1D(21,1,_mode+1);
	histos["h_HT_5jet"] = bookHisto1D(22,1,_mode+1);
	histos["h_deltaPhi_jet12"] = bookHisto1D(23,1,_mode+1);
	histos["h_deltaRap_jet12"] = bookHisto1D(24,1,_mode+1);
	histos["h_deltaR_jet12"] = bookHisto1D(25,1,_mode+1);
	histos["h_M_Jet12_2jet"] = bookHisto1D(26,1,_mode+1);
	histos["h_y_jet3_3jet"] = bookHisto1D(27,1,_mode+1);
	histos["h_y_jet4_4jet"] = bookHisto1D(28,1,_mode+1);
	histos["h_y_jet5_5jet"] = bookHisto1D(29,1,_mode+1);
	histos["h_ST_1jet"] = bookHisto1D(30,1,_mode+1);
	histos["h_ST_2jet"] = bookHisto1D(31,1,_mode+1);
	histos["h_ST_2jet_excl"] = bookHisto1D(32,1,_mode+1);
	histos["h_ST_3jet"] = bookHisto1D(33,1,_mode+1);
	histos["h_ST_3jet_excl"] = bookHisto1D(34,1,_mode+1);
	histos["h_ST_4jet"] = bookHisto1D(35,1,_mode+1);
	histos["h_ST_5jet"] = bookHisto1D(36,1,_mode+1);
	}


	void fillPlots(const Particle& lepton, const double& missET, Jets& all_jets, const double& weight) {
	// do jet-lepton overlap removal
	Jets jets;
	double ST = 0.0; // scalar pT sum of all selected jets
	foreach (const Jet &j, all_jets) {
	if (deltaR(j, lepton) > 0.5) {
	jets += j;
	ST += j.pT() / GeV;
	}
	}

	const size_t njets = jets.size();

	const double HT = ST + lepton.pT() / GeV + missET;

	histos["h_N"]->fill(njets + 0.5, weight);
	for (size_t i = 0; i <= njets; ++i) {
	histos["h_N_incl"]->fill(i + 0.5, weight);
	}

	if (njets) {
	const double pT1 = jets[0].pT() / GeV;
	const double rap1 = jets[0].absrap();
	histos["h_pt_jet1_1jet" ]->fill(pT1, weight);
	histos["h_y_jet1_1jet"]->fill(rap1, weight);
	histos["h_HT_1jet"]->fill(HT, weight);
	histos["h_ST_1jet"]->fill(ST, weight);
	if (njets == 1) {
	histos["h_pt_jet1_1jet_excl"]->fill(pT1, weight);
	histos["h_HT_1jet_excl"]->fill(HT, weight);
	} else {
	const double pT2 = jets[1].pT() / GeV;
	const double rap2 = jets[1].absrap();
	const double dR = deltaR(jets[0], jets[1]);
	const double dRap = deltaRap(jets[0], jets[1]);
	const double dPhi = deltaPhi(jets[0], jets[1]);
	const double mjj = (jets[0].momentum() + jets[1].momentum()).mass() / GeV;
	histos["h_pt_jet1_2jet"]->fill(pT1, weight);
	histos["h_pt_jet2_2jet"]->fill(pT2, weight);
	histos["h_y_jet2_2jet"]->fill(rap2, weight);
	histos["h_M_Jet12_2jet"]->fill(mjj, weight);
	histos["h_HT_2jet"]->fill(HT, weight);
	histos["h_ST_2jet"]->fill(ST, weight);
	histos["h_deltaPhi_jet12"]->fill(dPhi, weight);
	histos["h_deltaRap_jet12"]->fill(dRap, weight);
	histos["h_deltaR_jet12"]->fill(dR, weight);
	if (njets == 2) {
	histos["h_ST_2jet_excl"]->fill(ST, weight);
	histos["h_HT_2jet_excl"]->fill(HT, weight);
	} else {
	const double pT3 = jets[2].pT() / GeV;
	const double rap3 = jets[2].absrap();
	histos["h_pt_jet1_3jet"]->fill(pT1, weight);
	histos["h_pt_jet3_3jet"]->fill(pT3, weight);
	histos["h_y_jet3_3jet"]->fill(rap3, weight);
	histos["h_HT_3jet"]->fill(HT, weight);
	histos["h_ST_3jet"]->fill(ST, weight);
	if(njets == 3) {
	histos["h_ST_3jet_excl"]->fill(ST, weight);
	histos["h_HT_3jet_excl"]->fill(HT, weight);
	} else {
	const double pT4 = jets[3].pT() / GeV;
	const double rap4 = jets[3].absrap();
	histos["h_pt_jet4_4jet"]->fill(pT4, weight);
	histos["h_y_jet4_4jet"]->fill(rap4, weight);
	histos["h_HT_4jet"]->fill(HT, weight);
	histos["h_ST_4jet"]->fill(ST, weight);
	if (njets > 4) {
	const double pT5 = jets[4].pT() / GeV;
	const double rap5 = jets[4].absrap();
	histos["h_pt_jet5_5jet"]->fill(pT5, weight);
	histos["h_y_jet5_5jet"]->fill(rap5, weight);
	histos["h_HT_5jet"]->fill(HT, weight);
	histos["h_ST_5jet"]->fill(ST, weight);
	}
	}
	}
	}
	}
	}


	// Perform the per-event analysis
	void analyze(const Event& event) {
	// Retrieve boson candidate
	- const WFinder& wf = applyProjection<WFinder>(event, "WF");
	+ const WFinder& wf = apply<WFinder>(event, "WF");
	if (wf.empty()) vetoEvent;

	// Retrieve jets
	- const JetAlg& jetfs = applyProjection<JetAlg>(event, "Jets");
	+ const JetAlg& jetfs = apply<JetAlg>(event, "Jets");
	Jets all_jets = jetfs.jetsByPt(Cuts::pT > 30.0*GeV && Cuts::absrap < 4.4);

	const Particles& leptons = wf.constituentLeptons();
	const double missET = wf.constituentNeutrino().pT() / GeV;
	if (leptons.size() == 1 && missET > 25.0 && wf.mT() > 40.0*GeV) {
	const Particle& lep = leptons[0];
	fillPlots(lep, missET, all_jets, event.weight());
	}
	}


	void finalize() {
	const double scalefactor(crossSection() / sumOfWeights());
	/// @todo Update to use C++11 range-for
	for (map<string, Histo1DPtr>::iterator hit = histos.begin(); hit != histos.end(); ++hit) {
	scale(hit->second, scalefactor);
	}
	}


	protected:

	size_t _mode;


	private:

	map<string, Histo1DPtr> histos;

	};


	class ATLAS_2014_I1319490_EL : public ATLAS_2014_I1319490 {
	public:
	ATLAS_2014_I1319490_EL()
	: ATLAS_2014_I1319490("ATLAS_2014_I1319490_EL")
	{
	_mode = 1;
	}
	};


	class ATLAS_2014_I1319490_MU : public ATLAS_2014_I1319490 {
	public:
	ATLAS_2014_I1319490_MU()
	: ATLAS_2014_I1319490("ATLAS_2014_I1319490_MU")
	{
	_mode = 2;
	}
	};


	// The hooks for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1319490);
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1319490_EL);
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1319490_MU);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1325553.cc b/src/Analyses/ATLAS_2014_I1325553.cc
	--- a/src/Analyses/ATLAS_2014_I1325553.cc
	+++ b/src/Analyses/ATLAS_2014_I1325553.cc
	@@ -1,106 +1,106 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	/// Jet mass as a function of ystar
	class ATLAS_2014_I1325553 : public Analysis {
	public:

	/// Constructor
	ATLAS_2014_I1325553()
	: Analysis("ATLAS_2014_I1325553")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	const FinalState fs;
	- addProjection(fs,"FinalState");
	+ declare(fs,"FinalState");

	FastJets fj04(fs, FastJets::ANTIKT, 0.4);
	fj04.useInvisibles();
	- addProjection(fj04, "AntiKT04");
	+ declare(fj04, "AntiKT04");

	FastJets fj06(fs, FastJets::ANTIKT, 0.6);
	fj06.useInvisibles();
	- addProjection(fj06, "AntiKT06");
	+ declare(fj06, "AntiKT06");

	double ybins[] = {0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0};

	size_t ptDsOffset(0);
	for (size_t alg = 0; alg < 2; ++alg) {
	for (size_t i = 0; i < 6; ++i) {
	_pt[alg].addHistogram(ybins[i], ybins[i + 1], bookHisto1D(1 + ptDsOffset, 1, i + 1));
	}
	ptDsOffset += 1;
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	Jets jetAr[2];
	- jetAr[AKT4] = applyProjection<FastJets>(event, "AntiKT04").jetsByPt(Cuts::pT > 100*GeV && Cuts::absrap < 3.0);
	- jetAr[AKT6] = applyProjection<FastJets>(event, "AntiKT06").jetsByPt(Cuts::pT > 100*GeV && Cuts::absrap < 3.0);
	+ jetAr[AKT4] = apply<FastJets>(event, "AntiKT04").jetsByPt(Cuts::pT > 100*GeV && Cuts::absrap < 3.0);
	+ jetAr[AKT6] = apply<FastJets>(event, "AntiKT06").jetsByPt(Cuts::pT > 100*GeV && Cuts::absrap < 3.0);

	// Loop over jet "radii" used in analysis
	for (size_t alg = 0; alg < 2; ++alg) {

	// fill the 1D pt histograms with all the jets passing the cuts
	foreach (const Jet& jet, jetAr[alg]) {
	const double absrap = jet.absrap();
	if (absrap < 3.0) {
	const double pt = jet.pT();
	if (pt/GeV > 100*GeV) {
	_pt[alg].fill(absrap, pt/GeV, event.weight());
	}
	}
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {


	/// Print summary info
	const double xs_pb( crossSection() / picobarn );
	const double sumW( sumOfWeights() );
	const double xs_norm_factor( 0.5*xs_pb / sumW );
	MSG_INFO( "Cross-Section/pb : " << xs_pb );
	MSG_INFO( "Sum of weights : " << sumW );
	MSG_INFO( "nEvents : " << numEvents() );

	for (size_t alg = 0; alg < 2; ++alg) {
	_pt[alg].scale(xs_norm_factor, this);
	}
	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here
	enum Alg { AKT4=0, AKT6=1 };

	/// The inclusive jet spectrum binned in rapidity for akt6 and akt4 jets (array index is jet type from enum above)
	BinnedHistogram<double> _pt[2];

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1325553);

	}
	diff --git a/src/Analyses/ATLAS_2014_I1326641.cc b/src/Analyses/ATLAS_2014_I1326641.cc
	--- a/src/Analyses/ATLAS_2014_I1326641.cc
	+++ b/src/Analyses/ATLAS_2014_I1326641.cc
	@@ -1,120 +1,120 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	class ATLAS_2014_I1326641 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2014_I1326641()
	: Analysis("ATLAS_2014_I1326641")
	{
	setNeedsCrossSection(true);
	}

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	//std::cout << " HELLO ANALYSIS : init " << std::endl;
	const FinalState fs;

	FastJets fj04(fs, FastJets::ANTIKT, 0.4);
	fj04.useInvisibles();
	- addProjection(fj04, "AntiKT04");
	+ declare(fj04, "AntiKT04");

	FastJets fj06(fs, FastJets::ANTIKT, 0.6);
	fj06.useInvisibles();
	- addProjection(fj06, "AntiKT06");
	+ declare(fj06, "AntiKT06");

	double ystarBins[] = { 0.0, 2.0, 4.0, 6.0, 8.0, 10.0 };

	size_t massDsOffset(0);
	for (size_t alg = 0; alg < 2; ++alg) {
	for (size_t i = 0; i < 5; ++i) {
	h_trijet_Mass[alg].addHistogram(ystarBins[i], ystarBins[i+1], bookHisto1D(1 + massDsOffset, 1, 1));
	massDsOffset += 1;
	}
	}
	}

	/// Perform the per-event analysis
	void analyze(const Event& event) {

	Jets jetAr[2];
	- jetAr[AKT4] = applyProjection<FastJets>(event, "AntiKT04").jetsByPt(Cuts::pT > 50*GeV);
	- jetAr[AKT6] = applyProjection<FastJets>(event, "AntiKT06").jetsByPt(Cuts::pT > 50*GeV);
	+ jetAr[AKT4] = apply<FastJets>(event, "AntiKT04").jetsByPt(Cuts::pT > 50*GeV);
	+ jetAr[AKT6] = apply<FastJets>(event, "AntiKT06").jetsByPt(Cuts::pT > 50*GeV);

	const size_t nJets = 3;
	double ptCut[nJets] = { 150., 100., 50.};

	// Loop over jet "radii" used in analysis
	for (size_t alg = 0; alg < 2; ++alg) {
	// Identify 3jets
	vector<FourMomentum> leadJets;
	foreach (const Jet& jet, jetAr[alg]) {
	if (jet.absrap() < 3.0 && leadJets.size() < nJets){
	int filledJets = leadJets.size();
	if (jet.pT() < ptCut[filledJets]) continue;
	leadJets.push_back(jet.momentum());
	}
	}

	if (leadJets.size() < nJets) {
	MSG_DEBUG("Could not find three suitable leading jets");
	continue;
	}

	const double y1 = leadJets[0].rapidity();
	const double y2 = leadJets[1].rapidity();
	const double y3 = leadJets[2].rapidity();

	const double yStar = fabs(y1-y2) + fabs(y2-y3) + fabs(y1-y3);
	const double m = (leadJets[0] + leadJets[1] + leadJets[2]).mass();
	h_trijet_Mass[alg].fill(yStar, m, event.weight());
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	//const double sf( 0.5 * crossSection() / sumOfWeights() );
	const double sf( crossSection() / sumOfWeights() );
	for (size_t alg = 0; alg < 2; ++alg) {
	h_trijet_Mass[alg].scale(sf, this);
	}

	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here
	enum Alg { AKT4=0, AKT6=1 };

	private:

	// The 3 jets mass spectrum for anti-kt 4 and anti-kt 6 jets (array index is jet type from enum above)
	BinnedHistogram<double> h_trijet_Mass[2];
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1326641);
	}
	diff --git a/src/Analyses/ATLAS_2014_I1327229.cc b/src/Analyses/ATLAS_2014_I1327229.cc
	--- a/src/Analyses/ATLAS_2014_I1327229.cc
	+++ b/src/Analyses/ATLAS_2014_I1327229.cc
	@@ -1,1327 +1,1330 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"


	namespace Rivet {


	class ATLAS_2014_I1327229 : public Analysis {
	public:

	/// Constructor
	ATLAS_2014_I1327229()
	: Analysis("ATLAS_2014_I1327229") { }


	/// Book histograms and initialise projections before the run
	void init() {

	// To calculate the acceptance without having the fiducial lepton efficiencies included, this part can be turned off
	_use_fiducial_lepton_efficiency = true;

	// Random numbers for simulation of ATLAS detector reconstruction efficiency
	- srand (160385);
	+ /// @todo Replace with SmearedParticles etc.
	+ srand(160385);

	// Read in all signal regions
	_signal_regions = getSignalRegions();

	// Set number of events per signal region to 0
	for (size_t i = 0; i < _signal_regions.size(); i++)
	_eventCountsPerSR[_signal_regions[i]] = 0.0;

	// Final state including all charged and neutral particles
	const FinalState fs(-5.0, 5.0, 1*GeV);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Final state including all charged particles
	- addProjection(ChargedFinalState(-2.5, 2.5, 1*GeV), "CFS");
	+ declare(ChargedFinalState(-2.5, 2.5, 1*GeV), "CFS");

	// Final state including all visible particles (to calculate MET, Jets etc.)
	- addProjection(VisibleFinalState(-5.0,5.0),"VFS");
	+ declare(VisibleFinalState(-5.0,5.0),"VFS");

	// Final state including all AntiKt 04 Jets
	VetoedFinalState vfs;
	vfs.addVetoPairId(PID::MUON);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "AntiKtJets04");

	// Final state including all unstable particles (including taus)
	- addProjection(UnstableFinalState(Cuts::abseta < 5.0 && Cuts::pT > 5*GeV),"UFS");
	+ declare(UnstableFinalState(Cuts::abseta < 5.0 && Cuts::pT > 5*GeV),"UFS");

	// Final state including all electrons
	IdentifiedFinalState elecs(Cuts::abseta < 2.47 && Cuts::pT > 10*GeV);
	elecs.acceptIdPair(PID::ELECTRON);
	- addProjection(elecs, "elecs");
	+ declare(elecs, "elecs");

	// Final state including all muons
	IdentifiedFinalState muons(Cuts::abseta < 2.5 && Cuts::pT > 10*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "muons");
	+ declare(muons, "muons");



	/// Book histograms:
	_h_HTlep_all = bookHisto1D("HTlep_all", 30,0,3000);
	_h_HTjets_all = bookHisto1D("HTjets_all", 30,0,3000);
	_h_MET_all = bookHisto1D("MET_all", 30,0,1500);
	_h_Meff_all = bookHisto1D("Meff_all", 50,0,5000);
	_h_min_pT_all = bookHisto1D("min_pT_all", 50, 0, 2000);
	_h_mT_all = bookHisto1D("mT_all", 50, 0, 2000);

	_h_e_n = bookHisto1D("e_n", 10, -0.5, 9.5);
	_h_mu_n = bookHisto1D("mu_n", 10, -0.5, 9.5);
	_h_tau_n = bookHisto1D("tau_n", 10, -0.5, 9.5);

	_h_pt_1_3l = bookHisto1D("pt_1_3l", 100, 0, 2000);
	_h_pt_2_3l = bookHisto1D("pt_2_3l", 100, 0, 2000);
	_h_pt_3_3l = bookHisto1D("pt_3_3l", 100, 0, 2000);
	_h_pt_1_2ltau = bookHisto1D("pt_1_2ltau", 100, 0, 2000);
	_h_pt_2_2ltau = bookHisto1D("pt_2_2ltau", 100, 0, 2000);
	_h_pt_3_2ltau = bookHisto1D("pt_3_2ltau", 100, 0, 2000);

	_h_excluded = bookHisto1D("excluded", 2, -0.5, 1.5);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Muons
	Particles muon_candidates;
	- const Particles charged_tracks = applyProjection<ChargedFinalState>(event, "CFS").particles();
	- const Particles visible_particles = applyProjection<VisibleFinalState>(event, "VFS").particles();
	- foreach (const Particle& mu, applyProjection<IdentifiedFinalState>(event, "muons").particlesByPt() ) {
	+ const Particles charged_tracks = apply<ChargedFinalState>(event, "CFS").particles();
	+ const Particles visible_particles = apply<VisibleFinalState>(event, "VFS").particles();
	+ for (const Particle& mu : apply<IdentifiedFinalState>(event, "muons").particlesByPt() ) {

	// Calculate pTCone30 variable (pT of all tracks within dR<0.3 - pT of muon itself)
	double pTinCone = -mu.pT();
	- foreach (const Particle& track, charged_tracks ) {
	+ for (const Particle& track : charged_tracks ) {
	if (deltaR(mu.momentum(),track.momentum()) < 0.3 )
	pTinCone += track.pT();
	}

	// Calculate eTCone30 variable (pT of all visible particles within dR<0.3)
	double eTinCone = 0.;
	- foreach (const Particle& visible_particle, visible_particles) {
	+ for (const Particle& visible_particle : visible_particles) {
	if (visible_particle.abspid() != PID::MUON && inRange(deltaR(mu.momentum(),visible_particle.momentum()), 0.1, 0.3))
	eTinCone += visible_particle.pT();
	}

	// Apply reconstruction efficiency and simulate reconstruction
	int muon_id = 13;
	if (mu.hasAncestor(PID::TAU) \|\| mu.hasAncestor(-PID::TAU)) muon_id = 14;
	const double eff = (_use_fiducial_lepton_efficiency) ? apply_reco_eff(muon_id,mu) : 1.0;
	const bool keep_muon = rand()/static_cast<double>(RAND_MAX)<=eff;

	// Keep muon if pTCone30/pT < 0.15 and eTCone30/pT < 0.2 and reconstructed
	if (keep_muon && pTinCone/mu.pT() <= 0.1 && eTinCone/mu.pT() < 0.1)
	muon_candidates.push_back(mu);
	}

	// Electrons
	Particles electron_candidates;
	- foreach (const Particle& e, applyProjection<IdentifiedFinalState>(event, "elecs").particlesByPt() ) {
	+ for (const Particle& e : apply<IdentifiedFinalState>(event, "elecs").particlesByPt() ) {
	// Neglect electrons in crack regions
	if (inRange(e.abseta(), 1.37, 1.52)) continue;

	// Calculate pTCone30 variable (pT of all tracks within dR<0.3 - pT of electron itself)
	double pTinCone = -e.pT();
	- foreach (const Particle& track, charged_tracks) {
	+ for (const Particle& track : charged_tracks) {
	if (deltaR(e.momentum(), track.momentum()) < 0.3 ) pTinCone += track.pT();
	}

	// Calculate eTCone30 variable (pT of all visible particles (except muons) within dR<0.3)
	double eTinCone = 0.;
	- foreach (const Particle& visible_particle, visible_particles) {
	+ for (const Particle& visible_particle : visible_particles) {
	if (visible_particle.abspid() != PID::MUON && inRange(deltaR(e.momentum(),visible_particle.momentum()), 0.1, 0.3))
	eTinCone += visible_particle.pT();
	}

	// Apply reconstruction efficiency and simulate reconstruction
	int elec_id = 11;
	if (e.hasAncestor(15) \|\| e.hasAncestor(-15)) elec_id = 12;
	const double eff = (_use_fiducial_lepton_efficiency) ? apply_reco_eff(elec_id,e) : 1.0;
	const bool keep_elec = rand()/static_cast<double>(RAND_MAX)<=eff;

	// Keep electron if pTCone30/pT < 0.13 and eTCone30/pT < 0.2 and reconstructed
	if (keep_elec && pTinCone/e.pT() <= 0.1 && eTinCone/e.pT() < 0.1)
	electron_candidates.push_back(e);
	}


	// Taus
	Particles tau_candidates;
	- foreach (const Particle& tau, applyProjection<UnstableFinalState>(event, "UFS").particles() ) {
	+ for (const Particle& tau : apply<UnstableFinalState>(event, "UFS").particles() ) {
	// Only pick taus out of all unstable particles
	if ( tau.abspid() != PID::TAU) continue;
	// Check that tau has decayed into daughter particles
	if (tau.genParticle()->end_vertex() == 0) continue;
	// Calculate visible tau momentum using the tau neutrino momentum in the tau decay
	FourMomentum daughter_tau_neutrino_momentum = get_tau_neutrino_momentum(tau);
	Particle tau_vis = tau;
	tau_vis.setMomentum(tau.momentum()-daughter_tau_neutrino_momentum);
	// keep only taus in certain eta region and above 15 GeV of visible tau pT
	if ( tau_vis.pT()/GeV <= 15.0 \|\| tau_vis.abseta() > 2.5) continue;

	// Get prong number (number of tracks) in tau decay and check if tau decays leptonically
	unsigned int nprong = 0;
	bool lep_decaying_tau = false;
	get_prong_number(tau.genParticle(),nprong,lep_decaying_tau);

	// Apply reconstruction efficiency and simulate reconstruction
	int tau_id = 15;
	if (nprong == 1) tau_id = 15;
	else if (nprong == 3) tau_id = 16;


	const double eff = (_use_fiducial_lepton_efficiency) ? apply_reco_eff(tau_id,tau_vis) : 1.0;
	const bool keep_tau = rand()/static_cast<double>(RAND_MAX)<=eff;

	// Keep tau if nprong = 1, it decays hadronically and it is reconstructed
	if ( !lep_decaying_tau && nprong == 1 && keep_tau) tau_candidates.push_back(tau_vis);
	}

	// Jets (all anti-kt R=0.4 jets with pT > 30 GeV and eta < 4.9
	Jets jet_candidates;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "AntiKtJets04").jetsByPt(30.0*GeV) ) {
	+ for (const Jet& jet : apply<FastJets>(event, "AntiKtJets04").jetsByPt(30.0*GeV) ) {
	if (jet.abseta() < 4.9 ) jet_candidates.push_back(jet);
	}

	// ETmiss
	- Particles vfs_particles = applyProjection<VisibleFinalState>(event, "VFS").particles();
	+ Particles vfs_particles = apply<VisibleFinalState>(event, "VFS").particles();
	FourMomentum pTmiss;
	- foreach (const Particle& p, vfs_particles ) pTmiss -= p.momentum();
	+ for (const Particle& p : vfs_particles)
	+ pTmiss -= p.momentum();
	double eTmiss = pTmiss.pT()/GeV;


	// -------------------------
	// Overlap removal

	// electron - electron
	Particles electron_candidates_2;
	for(size_t ie = 0; ie < electron_candidates.size(); ++ie) {
	const Particle& e = electron_candidates[ie];
	bool away = true;
	// If electron pair within dR < 0.1: remove electron with lower pT
	for(size_t ie2 = 0; ie2 < electron_candidates_2.size(); ++ie2) {
	if (deltaR(e.momentum(),electron_candidates_2[ie2].momentum()) < 0.1 ) {
	away = false;
	break;
	}
	}
	// If isolated keep it
	if ( away )
	electron_candidates_2.push_back( e );
	}

	// jet - electron
	Jets recon_jets;
	- foreach (const Jet& jet, jet_candidates) {
	+ for (const Jet& jet : jet_candidates) {
	bool away = true;
	// If jet within dR < 0.2 of electron: remove jet
	- foreach (const Particle& e, electron_candidates_2) {
	+ for (const Particle& e : electron_candidates_2) {
	if (deltaR(e.momentum(), jet.momentum()) < 0.2 ) {
	away = false;
	break;
	}
	}

	// jet - tau
	if ( away ) {
	// If jet within dR < 0.2 of tau: remove jet
	- foreach (const Particle& tau, tau_candidates) {
	+ for (const Particle& tau : tau_candidates) {
	if (deltaR(tau.momentum(), jet.momentum()) < 0.2 ) {
	away = false;
	break;
	}
	}
	}
	// If isolated keep it
	if ( away )
	recon_jets.push_back( jet );
	}

	// electron - jet
	Particles recon_leptons, recon_e;
	for (size_t ie = 0; ie < electron_candidates_2.size(); ++ie) {
	const Particle& e = electron_candidates_2[ie];
	// If electron within 0.2 < dR < 0.4 from any jets: remove electron
	bool away = true;
	- foreach (const Jet& jet, recon_jets) {
	+ for (const Jet& jet : recon_jets) {
	if (deltaR(e.momentum(), jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	// electron - muon
	// If electron within dR < 0.1 of a muon: remove electron
	if (away) {
	- foreach (const Particle& mu, muon_candidates) {
	+ for (const Particle& mu : muon_candidates) {
	if (deltaR(mu.momentum(),e.momentum()) < 0.1) {
	away = false;
	break;
	}
	}
	}
	// If isolated keep it
	if ( away ) {
	recon_e.push_back( e );
	recon_leptons.push_back( e );
	}
	}

	// tau - electron
	Particles recon_tau;
	- foreach (const Particle& tau, tau_candidates) {
	+ for (const Particle& tau : tau_candidates) {
	bool away = true;
	// If tau within dR < 0.2 of an electron: remove tau
	- foreach (const Particle & e, recon_e) {
	+ for (const Particle & e : recon_e) {
	if (deltaR(tau.momentum(),e.momentum()) < 0.2 ) {
	away = false;
	break;
	}
	}
	// tau - muon
	// If tau within dR < 0.2 of a muon: remove tau
	if (away) {
	- foreach (const Particle& mu, muon_candidates) {
	+ for (const Particle& mu : muon_candidates) {
	if (deltaR(tau.momentum(), mu.momentum()) < 0.2 ) {
	away = false;
	break;
	}
	}
	}
	// If isolated keep it
	if (away) recon_tau.push_back( tau );
	}

	// muon - jet
	Particles recon_mu, trigger_mu;
	// If muon within dR < 0.4 of a jet: remove muon
	- foreach (const Particle& mu, muon_candidates ) {
	+ for (const Particle& mu : muon_candidates ) {
	bool away = true;
	- foreach (const Jet& jet, recon_jets) {
	+ for (const Jet& jet : recon_jets) {
	if (deltaR(mu.momentum(), jet.momentum()) < 0.4 ) {
	away = false;
	break;
	}
	}
	if (away) {
	recon_mu.push_back( mu );
	recon_leptons.push_back( mu );
	if (mu.abseta() < 2.4) trigger_mu.push_back( mu );
	}
	}

	// End overlap removal
	// ---------------------

	// Jet cleaning
	if (rand()/static_cast<double>(RAND_MAX) <= 0.42) {
	- foreach (const Jet& jet, recon_jets ) {
	+ for (const Jet& jet : recon_jets ) {
	const double eta = jet.rapidity();
	const double phi = jet.azimuthalAngle(MINUSPI_PLUSPI);
	if(jet.pT() > 25*GeV && inRange(eta,-0.1,1.5) && inRange(phi,-0.9,-0.5)) vetoEvent;
	}
	}

	// Event selection
	// Require at least 3 charged tracks in event
	if (charged_tracks.size() < 3) vetoEvent;

	// And at least one e/mu passing trigger
	if( !( !recon_e.empty() && recon_e[0].pT()>26.*GeV) &&
	!( !trigger_mu.empty() && trigger_mu[0].pT()>26.*GeV) ) {
	MSG_DEBUG("Hardest lepton fails trigger");
	vetoEvent;
	}

	// And only accept events with at least 2 electrons and muons and at least 3 leptons in total
	if (recon_mu.size() + recon_e.size() + recon_tau.size() < 3 \|\| recon_leptons.size() < 2) vetoEvent;

	// Getting the event weight
	const double weight = event.weight();

	// Sort leptons by decreasing pT
	sortByPt(recon_leptons);
	sortByPt(recon_tau);

	// Calculate HTlep, fill lepton pT histograms & store chosen combination of 3 leptons
	double HTlep = 0.;
	Particles chosen_leptons;
	if (recon_leptons.size() > 2) {
	_h_pt_1_3l->fill(recon_leptons[0].pT()/GeV, weight);
	_h_pt_2_3l->fill(recon_leptons[1].pT()/GeV, weight);
	_h_pt_3_3l->fill(recon_leptons[2].pT()/GeV, weight);
	HTlep = (recon_leptons[0].pT() + recon_leptons[1].pT() + recon_leptons[2].pT())/GeV;
	chosen_leptons.push_back( recon_leptons[0] );
	chosen_leptons.push_back( recon_leptons[1] );
	chosen_leptons.push_back( recon_leptons[2] );
	}
	else {
	_h_pt_1_2ltau->fill(recon_leptons[0].pT()/GeV, weight);
	_h_pt_2_2ltau->fill(recon_leptons[1].pT()/GeV, weight);
	_h_pt_3_2ltau->fill(recon_tau[0].pT()/GeV, weight);
	HTlep = recon_leptons[0].pT()/GeV + recon_leptons[1].pT()/GeV + recon_tau[0].pT()/GeV;
	chosen_leptons.push_back( recon_leptons[0] );
	chosen_leptons.push_back( recon_leptons[1] );
	chosen_leptons.push_back( recon_tau[0] );
	}

	// Calculate mT and mTW variable
	Particles mT_leptons;
	Particles mTW_leptons;
	for (size_t i1 = 0; i1 < 3; i1 ++) {
	for (size_t i2 = i1+1; i2 < 3; i2 ++) {
	double OSSF_inv_mass = isOSSF_mass(chosen_leptons[i1],chosen_leptons[i2]);
	if (OSSF_inv_mass != 0.) {
	for (size_t i3 = 0; i3 < 3 ; i3 ++) {
	if (i3 != i2 && i3 != i1) {
	mT_leptons.push_back(chosen_leptons[i3]);
	if ( fabs(91.0 - OSSF_inv_mass) < 20. )
	mTW_leptons.push_back(chosen_leptons[i3]);
	}
	}
	}
	else {
	mT_leptons.push_back(chosen_leptons[0]);
	mTW_leptons.push_back(chosen_leptons[0]);
	}
	}
	}

	sortByPt(mT_leptons);
	sortByPt(mTW_leptons);

	double mT = sqrt(2pTmiss.pT()/GeVmT_leptons[0].pT()/GeV*(1-cos(pTmiss.phi()-mT_leptons[0].phi())));
	double mTW = sqrt(2pTmiss.pT()/GeVmTW_leptons[0].pT()/GeV*(1-cos(pTmiss.phi()-mTW_leptons[0].phi())));

	// Calculate Min pT variable
	double min_pT = chosen_leptons[2].pT()/GeV;

	// Number of prompt e/mu and had taus
	_h_e_n->fill(recon_e.size(),weight);
	_h_mu_n->fill(recon_mu.size(),weight);
	_h_tau_n->fill(recon_tau.size(),weight);

	// Calculate HTjets variable
	double HTjets = 0.;
	- foreach (const Jet& jet, recon_jets)
	+ for (const Jet& jet : recon_jets)
	HTjets += jet.pT()/GeV;

	// Calculate meff variable
	double meff = eTmiss + HTjets;
	Particles all_leptons;
	- foreach (const Particle& e, recon_e ) {
	+ for (const Particle& e : recon_e ) {
	meff += e.pT()/GeV;
	all_leptons.push_back( e );
	}
	- foreach (const Particle& mu, recon_mu) {
	+ for (const Particle& mu : recon_mu) {
	meff += mu.pT()/GeV;
	all_leptons.push_back( mu );
	}
	- foreach (const Particle& tau, recon_tau) {
	+ for (const Particle& tau : recon_tau) {
	meff += tau.pT()/GeV;
	all_leptons.push_back( tau );
	}

	// Fill histograms of kinematic variables
	_h_HTlep_all->fill(HTlep,weight);
	_h_HTjets_all->fill(HTjets,weight);
	_h_MET_all->fill(eTmiss,weight);
	_h_Meff_all->fill(meff,weight);
	_h_min_pT_all->fill(min_pT,weight);
	_h_mT_all->fill(mT,weight);

	// Determine signal region (3l / 2ltau , onZ / offZ OSSF / offZ no-OSSF)
	// 3l vs. 2ltau
	string basic_signal_region;
	if (recon_mu.size() + recon_e.size() > 2)
	basic_signal_region += "3l_";
	else if ( (recon_mu.size() + recon_e.size() == 2) && (recon_tau.size() > 0))
	basic_signal_region += "2ltau_";

	// Is there an OSSF pair or a three lepton combination with an invariant mass close to the Z mass
	int onZ = isonZ(chosen_leptons);
	if (onZ == 1) basic_signal_region += "onZ";
	else if (onZ == 0) {
	bool OSSF = isOSSF(chosen_leptons);
	if (OSSF) basic_signal_region += "offZ_OSSF";
	else basic_signal_region += "offZ_noOSSF";
	}

	// Check in which signal regions this event falls and adjust event counters
	// INFO: The b-jet signal regions of the paper are not included in this Rivet implementation
	fillEventCountsPerSR(basic_signal_region,onZ,HTlep,eTmiss,HTjets,meff,min_pT,mTW,weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	// Normalize to an integrated luminosity of 1 fb-1
	double norm = crossSection()/femtobarn/sumOfWeights();

	string best_signal_region = "";
	double ratio_best_SR = 0.;

	// Loop over all signal regions and find signal region with best sensitivity (ratio signal events/visible cross-section)
	for (size_t i = 0; i < _signal_regions.size(); i++) {
	double signal_events = _eventCountsPerSR[_signal_regions[i]] * norm;
	// Use expected upper limits to find best signal region:
	double UL95 = getUpperLimit(_signal_regions[i],false);
	double ratio = signal_events / UL95;
	if (ratio > ratio_best_SR) {
	best_signal_region = _signal_regions.at(i);
	ratio_best_SR = ratio;
	}
	}

	double signal_events_best_SR = _eventCountsPerSR[best_signal_region] * norm;
	double exp_UL_best_SR = getUpperLimit(best_signal_region, false);
	double obs_UL_best_SR = getUpperLimit(best_signal_region, true);


	// Print out result
	cout << "----------------------------------------------------------------------------------------" << endl;
	cout << "Number of total events: " << sumOfWeights() << endl;
	cout << "Best signal region: " << best_signal_region << endl;
	cout << "Normalized number of signal events in this best signal region (per fb-1): " << signal_events_best_SR << endl;
	cout << "Efficiency*Acceptance: " << _eventCountsPerSR[best_signal_region]/sumOfWeights() << endl;
	cout << "Cross-section [fb]: " << crossSection()/femtobarn << endl;
	cout << "Expected visible cross-section (per fb-1): " << exp_UL_best_SR << endl;
	cout << "Ratio (signal events / expected visible cross-section): " << ratio_best_SR << endl;
	cout << "Observed visible cross-section (per fb-1): " << obs_UL_best_SR << endl;
	cout << "Ratio (signal events / observed visible cross-section): " << signal_events_best_SR/obs_UL_best_SR << endl;
	cout << "----------------------------------------------------------------------------------------" << endl;

	cout << "Using the EXPECTED limits (visible cross-section) of the analysis: " << endl;
	if (signal_events_best_SR > exp_UL_best_SR) {
	cout << "Since the number of signal events > the visible cross-section, this model/grid point is EXCLUDED with 95% C.L." << endl;
	_h_excluded->fill(1);
	}
	else {
	cout << "Since the number of signal events < the visible cross-section, this model/grid point is NOT EXCLUDED." << endl;
	_h_excluded->fill(0);
	}
	cout << "----------------------------------------------------------------------------------------" << endl;

	cout << "Using the OBSERVED limits (visible cross-section) of the analysis: " << endl;
	if (signal_events_best_SR > obs_UL_best_SR) {
	cout << "Since the number of signal events > the visible cross-section, this model/grid point is EXCLUDED with 95% C.L." << endl;
	_h_excluded->fill(1);
	}
	else {
	cout << "Since the number of signal events < the visible cross-section, this model/grid point is NOT EXCLUDED." << endl;
	_h_excluded->fill(0);
	}
	cout << "----------------------------------------------------------------------------------------" << endl;
	cout << "INFO: The b-jet signal regions of the paper are not included in this Rivet implementation." << endl;
	cout << "----------------------------------------------------------------------------------------" << endl;


	/// Normalize to cross section

	if (norm != 0) {
	scale(_h_HTlep_all, norm);
	scale(_h_HTjets_all, norm);
	scale(_h_MET_all, norm);
	scale(_h_Meff_all, norm);
	scale(_h_min_pT_all, norm);
	scale(_h_mT_all, norm);

	scale(_h_pt_1_3l, norm);
	scale(_h_pt_2_3l, norm);
	scale(_h_pt_3_3l, norm);
	scale(_h_pt_1_2ltau, norm);
	scale(_h_pt_2_2ltau, norm);
	scale(_h_pt_3_2ltau, norm);

	scale(_h_e_n, norm);
	scale(_h_mu_n, norm);
	scale(_h_tau_n, norm);

	scale(_h_excluded, norm);
	}

	}


	/// Helper functions
	//@{
	/// Function giving a list of all signal regions
	vector<string> getSignalRegions() {

	// List of basic signal regions
	vector<string> basic_signal_regions;
	basic_signal_regions.push_back("3l_offZ_OSSF");
	basic_signal_regions.push_back("3l_offZ_noOSSF");
	basic_signal_regions.push_back("3l_onZ");
	basic_signal_regions.push_back("2ltau_offZ_OSSF");
	basic_signal_regions.push_back("2ltau_offZ_noOSSF");
	basic_signal_regions.push_back("2ltau_onZ");

	// List of kinematic variables
	vector<string> kinematic_variables;
	kinematic_variables.push_back("HTlep");
	kinematic_variables.push_back("METStrong");
	kinematic_variables.push_back("METWeak");
	kinematic_variables.push_back("Meff");
	kinematic_variables.push_back("MeffStrong");
	kinematic_variables.push_back("MeffMt");
	kinematic_variables.push_back("MinPt");

	vector<string> signal_regions;
	// Loop over all kinematic variables and basic signal regions
	for (size_t i0 = 0; i0 < kinematic_variables.size(); i0++) {
	for (size_t i1 = 0; i1 < basic_signal_regions.size(); i1++) {
	// Is signal region onZ?
	int onZ = (basic_signal_regions[i1].find("onZ") != string::npos) ? 1 : 0;
	// Get cut values for this kinematic variable
	vector<int> cut_values = getCutsPerSignalRegion(kinematic_variables[i0], onZ);
	// Loop over all cut values
	for (size_t i2 = 0; i2 < cut_values.size(); i2++) {
	// Push signal region into vector
	signal_regions.push_back( kinematic_variables[i0] + "_" + basic_signal_regions[i1] + "_cut_" + toString(cut_values[i2]) );
	}
	}
	}
	return signal_regions;
	}



	/// Function giving all cut values per kinematic variable
	vector<int> getCutsPerSignalRegion(const string& signal_region, int onZ = 0) {
	vector<int> cutValues;

	// Cut values for HTlep
	if (signal_region.compare("HTlep") == 0) {
	cutValues.push_back(0);
	cutValues.push_back(200);
	cutValues.push_back(500);
	cutValues.push_back(800);
	}
	// Cut values for MinPt
	else if (signal_region.compare("MinPt") == 0) {
	cutValues.push_back(0);
	cutValues.push_back(50);
	cutValues.push_back(100);
	cutValues.push_back(150);
	}
	// Cut values for METStrong (HTjets > 150 GeV) and METWeak (HTjets < 150 GeV)
	else if (signal_region.compare("METStrong") == 0 \|\| signal_region.compare("METWeak") == 0) {
	cutValues.push_back(0);
	cutValues.push_back(100);
	cutValues.push_back(200);
	cutValues.push_back(300);
	}
	// Cut values for Meff
	if (signal_region.compare("Meff") == 0) {
	cutValues.push_back(0);
	cutValues.push_back(600);
	cutValues.push_back(1000);
	cutValues.push_back(1500);
	}
	// Cut values for MeffStrong (MET > 100 GeV)
	if ((signal_region.compare("MeffStrong") == 0 \|\| signal_region.compare("MeffMt") == 0) && onZ ==1) {
	cutValues.push_back(0);
	cutValues.push_back(600);
	cutValues.push_back(1200);
	}

	return cutValues;
	}

	/// function fills map _eventCountsPerSR by looping over all signal regions
	/// and looking if the event falls into this signal region
	void fillEventCountsPerSR(const string& basic_signal_region, int onZ,
	double HTlep, double eTmiss, double HTjets,
	double meff, double min_pT, double mTW,
	double weight) {

	// Get cut values for HTlep, loop over them and add event if cut is passed
	vector<int> cut_values = getCutsPerSignalRegion("HTlep", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (HTlep > cut_values[i])
	_eventCountsPerSR[("HTlep_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for MinPt, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("MinPt", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (min_pT > cut_values[i])
	_eventCountsPerSR[("MinPt_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for METStrong, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("METStrong", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (eTmiss > cut_values[i] && HTjets > 150.)
	_eventCountsPerSR[("METStrong_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for METWeak, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("METWeak", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (eTmiss > cut_values[i] && HTjets <= 150.)
	_eventCountsPerSR[("METWeak_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for Meff, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("Meff", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (meff > cut_values[i])
	_eventCountsPerSR[("Meff_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for MeffStrong, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("MeffStrong", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (meff > cut_values[i] && eTmiss > 100.)
	_eventCountsPerSR[("MeffStrong_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	// Get cut values for MeffMt, loop over them and add event if cut is passed
	cut_values = getCutsPerSignalRegion("MeffMt", onZ);
	for (size_t i = 0; i < cut_values.size(); i++) {
	if (meff > cut_values[i] && mTW > 100. && onZ == 1)
	_eventCountsPerSR[("MeffMt_" + basic_signal_region + "_cut_" + toString(cut_values[i]))] += weight;
	}

	}

	/// Function returning 4-momentum of daughter-particle if it is a tau neutrino
	FourMomentum get_tau_neutrino_momentum(const Particle& p) {
	assert(p.abspid() == PID::TAU);
	const GenVertex* dv = p.genParticle()->end_vertex();
	assert(dv != NULL);
	// Loop over all daughter particles
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	if (abs((pp)->pdg_id()) == PID::NU_TAU) return FourMomentum((pp)->momentum());
	}
	return FourMomentum();
	}

	/// Function calculating the prong number of taus
	void get_prong_number(const GenParticle* p, unsigned int& nprong, bool& lep_decaying_tau) {
	assert(p != NULL);
	const GenVertex* dv = p->end_vertex();
	assert(dv != NULL);
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	// If they have status 1 and are charged they will produce a track and the prong number is +1
	if ((*pp)->status() == 1 ) {
	const int id = (*pp)->pdg_id();
	if (Rivet::PID::charge(id) != 0 ) ++nprong;
	// Check if tau decays leptonically
	if (( abs(id) == PID::ELECTRON \|\| abs(id) == PID::MUON \|\| abs(id) == PID::TAU ) && abs(p->pdg_id()) == PID::TAU) lep_decaying_tau = true;
	}
	// If the status of the daughter particle is 2 it is unstable and the further decays are checked
	else if ((*pp)->status() == 2 ) {
	get_prong_number((*pp),nprong,lep_decaying_tau);
	}
	}
	}

	/// Function giving fiducial lepton efficiency
	double apply_reco_eff(int flavor, const Particle& p) {
	- float pt = p.pT()/GeV;
	- float eta = p.eta();
	+ double pt = p.pT()/GeV;
	+ double eta = p.eta();

	double eff = 0.;

	if (flavor == 11) { // weight prompt electron -- now including data/MC ID SF in eff.
	double avgrate = 0.685;
	- float wz_ele[] = {0.0256,0.522,0.607,0.654,0.708,0.737,0.761,0.784,0.815,0.835,0.851,0.841,0.898};
	- // float ewz_ele[] = {0.000257,0.00492,0.00524,0.00519,0.00396,0.00449,0.00538,0.00513,0.00773,0.00753,0.0209,0.0964,0.259};
	+ const static double wz_ele[] = {0.0256,0.522,0.607,0.654,0.708,0.737,0.761,0.784,0.815,0.835,0.851,0.841,0.898};
	+ // double ewz_ele[] = {0.000257,0.00492,0.00524,0.00519,0.00396,0.00449,0.00538,0.00513,0.00773,0.00753,0.0209,0.0964,0.259};
	int ibin = 0;
	if(pt > 10 && pt < 15) ibin = 0;
	if(pt > 15 && pt < 20) ibin = 1;
	if(pt > 20 && pt < 25) ibin = 2;
	if(pt > 25 && pt < 30) ibin = 3;
	if(pt > 30 && pt < 40) ibin = 4;
	if(pt > 40 && pt < 50) ibin = 5;
	if(pt > 50 && pt < 60) ibin = 6;
	if(pt > 60 && pt < 80) ibin = 7;
	if(pt > 80 && pt < 100) ibin = 8;
	if(pt > 100 && pt < 200) ibin = 9;
	if(pt > 200 && pt < 400) ibin = 10;
	if(pt > 400 && pt < 600) ibin = 11;
	if(pt > 600) ibin = 12;
	double eff_pt = 0.;
	eff_pt = wz_ele[ibin];

	eta = fabs(eta);

	- float wz_ele_eta[] = {0.65,0.714,0.722,0.689,0.635,0.615};
	- // float ewz_ele_eta[] = {0.00642,0.00355,0.00335,0.004,0.00368,0.00422};
	+ const static double wz_ele_eta[] = {0.65,0.714,0.722,0.689,0.635,0.615};
	+ // double ewz_ele_eta[] = {0.00642,0.00355,0.00335,0.004,0.00368,0.00422};
	ibin = 0;
	if(eta > 0 && eta < 0.1) ibin = 0;
	if(eta > 0.1 && eta < 0.5) ibin = 1;
	if(eta > 0.5 && eta < 1.0) ibin = 2;
	if(eta > 1.0 && eta < 1.5) ibin = 3;
	if(eta > 1.5 && eta < 2.0) ibin = 4;
	if(eta > 2.0 && eta < 2.5) ibin = 5;
	double eff_eta = 0.;
	eff_eta = wz_ele_eta[ibin];

	eff = (eff_pt * eff_eta) / avgrate;
	}

	if (flavor == 12) { // weight electron from tau
	double avgrate = 0.476;
	- float wz_ele[] = {0.00855,0.409,0.442,0.55,0.632,0.616,0.615,0.642,0.72,0.617};
	- // float ewz_ele[] = {0.000573,0.0291,0.0366,0.0352,0.0363,0.0474,0.0628,0.0709,0.125,0.109};
	+ const static double wz_ele[] = {0.00855,0.409,0.442,0.55,0.632,0.616,0.615,0.642,0.72,0.617};
	+ // double ewz_ele[] = {0.000573,0.0291,0.0366,0.0352,0.0363,0.0474,0.0628,0.0709,0.125,0.109};
	int ibin = 0;
	if(pt > 10 && pt < 15) ibin = 0;
	if(pt > 15 && pt < 20) ibin = 1;
	if(pt > 20 && pt < 25) ibin = 2;
	if(pt > 25 && pt < 30) ibin = 3;
	if(pt > 30 && pt < 40) ibin = 4;
	if(pt > 40 && pt < 50) ibin = 5;
	if(pt > 50 && pt < 60) ibin = 6;
	if(pt > 60 && pt < 80) ibin = 7;
	if(pt > 80 && pt < 100) ibin = 8;
	if(pt > 100) ibin = 9;
	double eff_pt = 0.;
	eff_pt = wz_ele[ibin];

	eta = fabs(eta);

	- float wz_ele_eta[] = {0.546,0.5,0.513,0.421,0.47,0.433};
	- //float ewz_ele_eta[] = {0.0566,0.0257,0.0263,0.0263,0.0303,0.0321};
	+ const static double wz_ele_eta[] = {0.546,0.5,0.513,0.421,0.47,0.433};
	+ //double ewz_ele_eta[] = {0.0566,0.0257,0.0263,0.0263,0.0303,0.0321};
	ibin = 0;
	if(eta > 0 && eta < 0.1) ibin = 0;
	if(eta > 0.1 && eta < 0.5) ibin = 1;
	if(eta > 0.5 && eta < 1.0) ibin = 2;
	if(eta > 1.0 && eta < 1.5) ibin = 3;
	if(eta > 1.5 && eta < 2.0) ibin = 4;
	if(eta > 2.0 && eta < 2.5) ibin = 5;
	double eff_eta = 0.;
	eff_eta = wz_ele_eta[ibin];

	eff = (eff_pt * eff_eta) / avgrate;
	}

	if (flavor == 13) { // weight prompt muon
	int ibin = 0;
	if(pt > 10 && pt < 15) ibin = 0;
	if(pt > 15 && pt < 20) ibin = 1;
	if(pt > 20 && pt < 25) ibin = 2;
	if(pt > 25 && pt < 30) ibin = 3;
	if(pt > 30 && pt < 40) ibin = 4;
	if(pt > 40 && pt < 50) ibin = 5;
	if(pt > 50 && pt < 60) ibin = 6;
	if(pt > 60 && pt < 80) ibin = 7;
	if(pt > 80 && pt < 100) ibin = 8;
	if(pt > 100 && pt < 200) ibin = 9;
	if(pt > 200 && pt < 400) ibin = 10;
	if(pt > 400) ibin = 11;
	if(fabs(eta) < 0.1) {
	- float wz_mu[] = {0.00705,0.402,0.478,0.49,0.492,0.499,0.527,0.512,0.53,0.528,0.465,0.465};
	- //float ewz_mu[] = {0.000298,0.0154,0.017,0.0158,0.0114,0.0123,0.0155,0.0133,0.0196,0.0182,0.0414,0.0414};
	+ const static double wz_mu[] = {0.00705,0.402,0.478,0.49,0.492,0.499,0.527,0.512,0.53,0.528,0.465,0.465};
	+ //double ewz_mu[] = {0.000298,0.0154,0.017,0.0158,0.0114,0.0123,0.0155,0.0133,0.0196,0.0182,0.0414,0.0414};
	double eff_pt = 0.;
	eff_pt = wz_mu[ibin];
	eff = eff_pt;
	}
	if(fabs(eta) > 0.1) {
	- float wz_mu[] = {0.0224,0.839,0.887,0.91,0.919,0.923,0.925,0.925,0.922,0.918,0.884,0.834};
	- //float ewz_mu[] = {0.000213,0.00753,0.0074,0.007,0.00496,0.00534,0.00632,0.00583,0.00849,0.00804,0.0224,0.0963};
	+ const static double wz_mu[] = {0.0224,0.839,0.887,0.91,0.919,0.923,0.925,0.925,0.922,0.918,0.884,0.834};
	+ //double ewz_mu[] = {0.000213,0.00753,0.0074,0.007,0.00496,0.00534,0.00632,0.00583,0.00849,0.00804,0.0224,0.0963};
	double eff_pt = 0.;
	eff_pt = wz_mu[ibin];
	eff = eff_pt;
	}
	}

	if (flavor == 14) { // weight muon from tau
	int ibin = 0;
	if(pt > 10 && pt < 15) ibin = 0;
	if(pt > 15 && pt < 20) ibin = 1;
	if(pt > 20 && pt < 25) ibin = 2;
	if(pt > 25 && pt < 30) ibin = 3;
	if(pt > 30 && pt < 40) ibin = 4;
	if(pt > 40 && pt < 50) ibin = 5;
	if(pt > 50 && pt < 60) ibin = 6;
	if(pt > 60 && pt < 80) ibin = 7;
	if(pt > 80 && pt < 100) ibin = 8;
	if(pt > 100) ibin = 9;

	if(fabs(eta) < 0.1) {
	- float wz_mu[] = {0.0,0.664,0.124,0.133,0.527,0.283,0.495,0.25,0.5,0.331};
	- //float ewz_mu[] = {0.0,0.192,0.0437,0.0343,0.128,0.107,0.202,0.125,0.25,0.191};
	+ const static double wz_mu[] = {0.0,0.664,0.124,0.133,0.527,0.283,0.495,0.25,0.5,0.331};
	+ //double ewz_mu[] = {0.0,0.192,0.0437,0.0343,0.128,0.107,0.202,0.125,0.25,0.191};
	double eff_pt = 0.;
	eff_pt = wz_mu[ibin];
	eff = eff_pt;
	}
	if(fabs(eta) > 0.1) {
	- float wz_mu[] = {0.0,0.617,0.655,0.676,0.705,0.738,0.712,0.783,0.646,0.745};
	- //float ewz_mu[] = {0.0,0.043,0.0564,0.0448,0.0405,0.0576,0.065,0.0825,0.102,0.132};
	+ const static double wz_mu[] = {0.0,0.617,0.655,0.676,0.705,0.738,0.712,0.783,0.646,0.745};
	+ //double ewz_mu[] = {0.0,0.043,0.0564,0.0448,0.0405,0.0576,0.065,0.0825,0.102,0.132};
	double eff_pt = 0.;
	eff_pt = wz_mu[ibin];
	eff = eff_pt;
	}
	}

	if (flavor == 15) { // weight hadronic tau 1p
	double avgrate = 0.16;
	- float wz_tau1p[] = {0.0,0.0311,0.148,0.229,0.217,0.292,0.245,0.307,0.227,0.277};
	- //float ewz_tau1p[] = {0.0,0.00211,0.0117,0.0179,0.0134,0.0248,0.0264,0.0322,0.0331,0.0427};
	+ const static double wz_tau1p[] = {0.0,0.0311,0.148,0.229,0.217,0.292,0.245,0.307,0.227,0.277};
	+ //double ewz_tau1p[] = {0.0,0.00211,0.0117,0.0179,0.0134,0.0248,0.0264,0.0322,0.0331,0.0427};
	int ibin = 0;
	if(pt > 10 && pt < 15) ibin = 0;
	if(pt > 15 && pt < 20) ibin = 1;
	if(pt > 20 && pt < 25) ibin = 2;
	if(pt > 25 && pt < 30) ibin = 3;
	if(pt > 30 && pt < 40) ibin = 4;
	if(pt > 40 && pt < 50) ibin = 5;
	if(pt > 50 && pt < 60) ibin = 6;
	if(pt > 60 && pt < 80) ibin = 7;
	if(pt > 80 && pt < 100) ibin = 8;
	if(pt > 100) ibin = 9;
	double eff_pt = 0.;
	eff_pt = wz_tau1p[ibin];

	- float wz_tau1p_eta[] = {0.166,0.15,0.188,0.175,0.142,0.109};
	- //float ewz_tau1p_eta[] ={0.0166,0.00853,0.0097,0.00985,0.00949,0.00842};
	+ const static double wz_tau1p_eta[] = {0.166,0.15,0.188,0.175,0.142,0.109};
	+ //double ewz_tau1p_eta[] ={0.0166,0.00853,0.0097,0.00985,0.00949,0.00842};
	ibin = 0;
	if(eta > 0.0 && eta < 0.1) ibin = 0;
	if(eta > 0.1 && eta < 0.5) ibin = 1;
	if(eta > 0.5 && eta < 1.0) ibin = 2;
	if(eta > 1.0 && eta < 1.5) ibin = 3;
	if(eta > 1.5 && eta < 2.0) ibin = 4;
	if(eta > 2.0 && eta < 2.5) ibin = 5;
	double eff_eta = 0.;
	eff_eta = wz_tau1p_eta[ibin];

	eff = (eff_pt * eff_eta) / avgrate;
	}

	return eff;
	}

	+
	/// Function giving observed and expected upper limits (on the visible cross-section)
	double getUpperLimit(const string& signal_region, bool observed) {

	map<string,double> upperLimitsObserved;
	map<string,double> upperLimitsExpected;

	upperLimitsObserved["HTlep_3l_offZ_OSSF_cut_0"] = 2.435;
	upperLimitsObserved["HTlep_3l_offZ_OSSF_cut_200"] = 0.704;
	upperLimitsObserved["HTlep_3l_offZ_OSSF_cut_500"] = 0.182;
	upperLimitsObserved["HTlep_3l_offZ_OSSF_cut_800"] = 0.147;
	upperLimitsObserved["HTlep_2ltau_offZ_OSSF_cut_0"] = 13.901;
	upperLimitsObserved["HTlep_2ltau_offZ_OSSF_cut_200"] = 1.677;
	upperLimitsObserved["HTlep_2ltau_offZ_OSSF_cut_500"] = 0.141;
	upperLimitsObserved["HTlep_2ltau_offZ_OSSF_cut_800"] = 0.155;
	upperLimitsObserved["HTlep_3l_offZ_noOSSF_cut_0"] = 1.054;
	upperLimitsObserved["HTlep_3l_offZ_noOSSF_cut_200"] = 0.341;
	upperLimitsObserved["HTlep_3l_offZ_noOSSF_cut_500"] = 0.221;
	upperLimitsObserved["HTlep_3l_offZ_noOSSF_cut_800"] = 0.140;
	upperLimitsObserved["HTlep_2ltau_offZ_noOSSF_cut_0"] = 4.276;
	upperLimitsObserved["HTlep_2ltau_offZ_noOSSF_cut_200"] = 0.413;
	upperLimitsObserved["HTlep_2ltau_offZ_noOSSF_cut_500"] = 0.138;
	upperLimitsObserved["HTlep_2ltau_offZ_noOSSF_cut_800"] = 0.150;
	upperLimitsObserved["HTlep_3l_onZ_cut_0"] = 29.804;
	upperLimitsObserved["HTlep_3l_onZ_cut_200"] = 3.579;
	upperLimitsObserved["HTlep_3l_onZ_cut_500"] = 0.466;
	upperLimitsObserved["HTlep_3l_onZ_cut_800"] = 0.298;
	upperLimitsObserved["HTlep_2ltau_onZ_cut_0"] = 205.091;
	upperLimitsObserved["HTlep_2ltau_onZ_cut_200"] = 3.141;
	upperLimitsObserved["HTlep_2ltau_onZ_cut_500"] = 0.290;
	upperLimitsObserved["HTlep_2ltau_onZ_cut_800"] = 0.157;
	upperLimitsObserved["METStrong_3l_offZ_OSSF_cut_0"] = 1.111;
	upperLimitsObserved["METStrong_3l_offZ_OSSF_cut_100"] = 0.354;
	upperLimitsObserved["METStrong_3l_offZ_OSSF_cut_200"] = 0.236;
	upperLimitsObserved["METStrong_3l_offZ_OSSF_cut_300"] = 0.150;
	upperLimitsObserved["METStrong_2ltau_offZ_OSSF_cut_0"] = 1.881;
	upperLimitsObserved["METStrong_2ltau_offZ_OSSF_cut_100"] = 0.406;
	upperLimitsObserved["METStrong_2ltau_offZ_OSSF_cut_200"] = 0.194;
	upperLimitsObserved["METStrong_2ltau_offZ_OSSF_cut_300"] = 0.134;
	upperLimitsObserved["METStrong_3l_offZ_noOSSF_cut_0"] = 0.770;
	upperLimitsObserved["METStrong_3l_offZ_noOSSF_cut_100"] = 0.295;
	upperLimitsObserved["METStrong_3l_offZ_noOSSF_cut_200"] = 0.149;
	upperLimitsObserved["METStrong_3l_offZ_noOSSF_cut_300"] = 0.140;
	upperLimitsObserved["METStrong_2ltau_offZ_noOSSF_cut_0"] = 2.003;
	upperLimitsObserved["METStrong_2ltau_offZ_noOSSF_cut_100"] = 0.806;
	upperLimitsObserved["METStrong_2ltau_offZ_noOSSF_cut_200"] = 0.227;
	upperLimitsObserved["METStrong_2ltau_offZ_noOSSF_cut_300"] = 0.138;
	upperLimitsObserved["METStrong_3l_onZ_cut_0"] = 6.383;
	upperLimitsObserved["METStrong_3l_onZ_cut_100"] = 0.959;
	upperLimitsObserved["METStrong_3l_onZ_cut_200"] = 0.549;
	upperLimitsObserved["METStrong_3l_onZ_cut_300"] = 0.182;
	upperLimitsObserved["METStrong_2ltau_onZ_cut_0"] = 10.658;
	upperLimitsObserved["METStrong_2ltau_onZ_cut_100"] = 0.637;
	upperLimitsObserved["METStrong_2ltau_onZ_cut_200"] = 0.291;
	upperLimitsObserved["METStrong_2ltau_onZ_cut_300"] = 0.227;
	upperLimitsObserved["METWeak_3l_offZ_OSSF_cut_0"] = 1.802;
	upperLimitsObserved["METWeak_3l_offZ_OSSF_cut_100"] = 0.344;
	upperLimitsObserved["METWeak_3l_offZ_OSSF_cut_200"] = 0.189;
	upperLimitsObserved["METWeak_3l_offZ_OSSF_cut_300"] = 0.148;
	upperLimitsObserved["METWeak_2ltau_offZ_OSSF_cut_0"] = 12.321;
	upperLimitsObserved["METWeak_2ltau_offZ_OSSF_cut_100"] = 0.430;
	upperLimitsObserved["METWeak_2ltau_offZ_OSSF_cut_200"] = 0.137;
	upperLimitsObserved["METWeak_2ltau_offZ_OSSF_cut_300"] = 0.134;
	upperLimitsObserved["METWeak_3l_offZ_noOSSF_cut_0"] = 0.562;
	upperLimitsObserved["METWeak_3l_offZ_noOSSF_cut_100"] = 0.153;
	upperLimitsObserved["METWeak_3l_offZ_noOSSF_cut_200"] = 0.154;
	upperLimitsObserved["METWeak_3l_offZ_noOSSF_cut_300"] = 0.141;
	upperLimitsObserved["METWeak_2ltau_offZ_noOSSF_cut_0"] = 2.475;
	upperLimitsObserved["METWeak_2ltau_offZ_noOSSF_cut_100"] = 0.244;
	upperLimitsObserved["METWeak_2ltau_offZ_noOSSF_cut_200"] = 0.141;
	upperLimitsObserved["METWeak_2ltau_offZ_noOSSF_cut_300"] = 0.142;
	upperLimitsObserved["METWeak_3l_onZ_cut_0"] = 24.769;
	upperLimitsObserved["METWeak_3l_onZ_cut_100"] = 0.690;
	upperLimitsObserved["METWeak_3l_onZ_cut_200"] = 0.198;
	upperLimitsObserved["METWeak_3l_onZ_cut_300"] = 0.138;
	upperLimitsObserved["METWeak_2ltau_onZ_cut_0"] = 194.360;
	upperLimitsObserved["METWeak_2ltau_onZ_cut_100"] = 0.287;
	upperLimitsObserved["METWeak_2ltau_onZ_cut_200"] = 0.144;
	upperLimitsObserved["METWeak_2ltau_onZ_cut_300"] = 0.130;
	upperLimitsObserved["Meff_3l_offZ_OSSF_cut_0"] = 2.435;
	upperLimitsObserved["Meff_3l_offZ_OSSF_cut_600"] = 0.487;
	upperLimitsObserved["Meff_3l_offZ_OSSF_cut_1000"] = 0.156;
	upperLimitsObserved["Meff_3l_offZ_OSSF_cut_1500"] = 0.140;
	upperLimitsObserved["Meff_2ltau_offZ_OSSF_cut_0"] = 13.901;
	upperLimitsObserved["Meff_2ltau_offZ_OSSF_cut_600"] = 0.687;
	upperLimitsObserved["Meff_2ltau_offZ_OSSF_cut_1000"] = 0.224;
	upperLimitsObserved["Meff_2ltau_offZ_OSSF_cut_1500"] = 0.155;
	upperLimitsObserved["Meff_3l_offZ_noOSSF_cut_0"] = 1.054;
	upperLimitsObserved["Meff_3l_offZ_noOSSF_cut_600"] = 0.249;
	upperLimitsObserved["Meff_3l_offZ_noOSSF_cut_1000"] = 0.194;
	upperLimitsObserved["Meff_3l_offZ_noOSSF_cut_1500"] = 0.145;
	upperLimitsObserved["Meff_2ltau_offZ_noOSSF_cut_0"] = 4.276;
	upperLimitsObserved["Meff_2ltau_offZ_noOSSF_cut_600"] = 0.772;
	upperLimitsObserved["Meff_2ltau_offZ_noOSSF_cut_1000"] = 0.218;
	upperLimitsObserved["Meff_2ltau_offZ_noOSSF_cut_1500"] = 0.204;
	upperLimitsObserved["Meff_3l_onZ_cut_0"] = 29.804;
	upperLimitsObserved["Meff_3l_onZ_cut_600"] = 2.933;
	upperLimitsObserved["Meff_3l_onZ_cut_1000"] = 0.912;
	upperLimitsObserved["Meff_3l_onZ_cut_1500"] = 0.225;
	upperLimitsObserved["Meff_2ltau_onZ_cut_0"] = 205.091;
	upperLimitsObserved["Meff_2ltau_onZ_cut_600"] = 1.486;
	upperLimitsObserved["Meff_2ltau_onZ_cut_1000"] = 0.641;
	upperLimitsObserved["Meff_2ltau_onZ_cut_1500"] = 0.204;
	upperLimitsObserved["MeffStrong_3l_offZ_OSSF_cut_0"] = 0.479;
	upperLimitsObserved["MeffStrong_3l_offZ_OSSF_cut_600"] = 0.353;
	upperLimitsObserved["MeffStrong_3l_offZ_OSSF_cut_1200"] = 0.187;
	upperLimitsObserved["MeffStrong_2ltau_offZ_OSSF_cut_0"] = 0.617;
	upperLimitsObserved["MeffStrong_2ltau_offZ_OSSF_cut_600"] = 0.320;
	upperLimitsObserved["MeffStrong_2ltau_offZ_OSSF_cut_1200"] = 0.281;
	upperLimitsObserved["MeffStrong_3l_offZ_noOSSF_cut_0"] = 0.408;
	upperLimitsObserved["MeffStrong_3l_offZ_noOSSF_cut_600"] = 0.240;
	upperLimitsObserved["MeffStrong_3l_offZ_noOSSF_cut_1200"] = 0.150;
	upperLimitsObserved["MeffStrong_2ltau_offZ_noOSSF_cut_0"] = 0.774;
	upperLimitsObserved["MeffStrong_2ltau_offZ_noOSSF_cut_600"] = 0.417;
	upperLimitsObserved["MeffStrong_2ltau_offZ_noOSSF_cut_1200"] = 0.266;
	upperLimitsObserved["MeffStrong_3l_onZ_cut_0"] = 1.208;
	upperLimitsObserved["MeffStrong_3l_onZ_cut_600"] = 0.837;
	upperLimitsObserved["MeffStrong_3l_onZ_cut_1200"] = 0.269;
	upperLimitsObserved["MeffStrong_2ltau_onZ_cut_0"] = 0.605;
	upperLimitsObserved["MeffStrong_2ltau_onZ_cut_600"] = 0.420;
	upperLimitsObserved["MeffStrong_2ltau_onZ_cut_1200"] = 0.141;
	upperLimitsObserved["MeffMt_3l_onZ_cut_0"] = 1.832;
	upperLimitsObserved["MeffMt_3l_onZ_cut_600"] = 0.862;
	upperLimitsObserved["MeffMt_3l_onZ_cut_1200"] = 0.222;
	upperLimitsObserved["MeffMt_2ltau_onZ_cut_0"] = 1.309;
	upperLimitsObserved["MeffMt_2ltau_onZ_cut_600"] = 0.481;
	upperLimitsObserved["MeffMt_2ltau_onZ_cut_1200"] = 0.146;
	upperLimitsObserved["MinPt_3l_offZ_OSSF_cut_0"] = 2.435;
	upperLimitsObserved["MinPt_3l_offZ_OSSF_cut_50"] = 0.500;
	upperLimitsObserved["MinPt_3l_offZ_OSSF_cut_100"] = 0.203;
	upperLimitsObserved["MinPt_3l_offZ_OSSF_cut_150"] = 0.128;
	upperLimitsObserved["MinPt_2ltau_offZ_OSSF_cut_0"] = 13.901;
	upperLimitsObserved["MinPt_2ltau_offZ_OSSF_cut_50"] = 0.859;
	upperLimitsObserved["MinPt_2ltau_offZ_OSSF_cut_100"] = 0.158;
	upperLimitsObserved["MinPt_2ltau_offZ_OSSF_cut_150"] = 0.155;
	upperLimitsObserved["MinPt_3l_offZ_noOSSF_cut_0"] = 1.054;
	upperLimitsObserved["MinPt_3l_offZ_noOSSF_cut_50"] = 0.295;
	upperLimitsObserved["MinPt_3l_offZ_noOSSF_cut_100"] = 0.148;
	upperLimitsObserved["MinPt_3l_offZ_noOSSF_cut_150"] = 0.137;
	upperLimitsObserved["MinPt_2ltau_offZ_noOSSF_cut_0"] = 4.276;
	upperLimitsObserved["MinPt_2ltau_offZ_noOSSF_cut_50"] = 0.314;
	upperLimitsObserved["MinPt_2ltau_offZ_noOSSF_cut_100"] = 0.134;
	upperLimitsObserved["MinPt_2ltau_offZ_noOSSF_cut_150"] = 0.140;
	upperLimitsObserved["MinPt_3l_onZ_cut_0"] = 29.804;
	upperLimitsObserved["MinPt_3l_onZ_cut_50"] = 1.767;
	upperLimitsObserved["MinPt_3l_onZ_cut_100"] = 0.690;
	upperLimitsObserved["MinPt_3l_onZ_cut_150"] = 0.301;
	upperLimitsObserved["MinPt_2ltau_onZ_cut_0"] = 205.091;
	upperLimitsObserved["MinPt_2ltau_onZ_cut_50"] = 1.050;
	upperLimitsObserved["MinPt_2ltau_onZ_cut_100"] = 0.155;
	upperLimitsObserved["MinPt_2ltau_onZ_cut_150"] = 0.146;
	upperLimitsObserved["nbtag_3l_offZ_OSSF_cut_0"] = 2.435;
	upperLimitsObserved["nbtag_3l_offZ_OSSF_cut_1"] = 0.865;
	upperLimitsObserved["nbtag_3l_offZ_OSSF_cut_2"] = 0.474;
	upperLimitsObserved["nbtag_2ltau_offZ_OSSF_cut_0"] = 13.901;
	upperLimitsObserved["nbtag_2ltau_offZ_OSSF_cut_1"] = 1.566;
	upperLimitsObserved["nbtag_2ltau_offZ_OSSF_cut_2"] = 0.426;
	upperLimitsObserved["nbtag_3l_offZ_noOSSF_cut_0"] = 1.054;
	upperLimitsObserved["nbtag_3l_offZ_noOSSF_cut_1"] = 0.643;
	upperLimitsObserved["nbtag_3l_offZ_noOSSF_cut_2"] = 0.321;
	upperLimitsObserved["nbtag_2ltau_offZ_noOSSF_cut_0"] = 4.276;
	upperLimitsObserved["nbtag_2ltau_offZ_noOSSF_cut_1"] = 2.435;
	upperLimitsObserved["nbtag_2ltau_offZ_noOSSF_cut_2"] = 1.073;
	upperLimitsObserved["nbtag_3l_onZ_cut_0"] = 29.804;
	upperLimitsObserved["nbtag_3l_onZ_cut_1"] = 3.908;
	upperLimitsObserved["nbtag_3l_onZ_cut_2"] = 0.704;
	upperLimitsObserved["nbtag_2ltau_onZ_cut_0"] = 205.091;
	upperLimitsObserved["nbtag_2ltau_onZ_cut_1"] = 9.377;
	upperLimitsObserved["nbtag_2ltau_onZ_cut_2"] = 0.657;
	upperLimitsExpected["HTlep_3l_offZ_OSSF_cut_0"] = 2.893;
	upperLimitsExpected["HTlep_3l_offZ_OSSF_cut_200"] = 1.175;
	upperLimitsExpected["HTlep_3l_offZ_OSSF_cut_500"] = 0.265;
	upperLimitsExpected["HTlep_3l_offZ_OSSF_cut_800"] = 0.155;
	upperLimitsExpected["HTlep_2ltau_offZ_OSSF_cut_0"] = 14.293;
	upperLimitsExpected["HTlep_2ltau_offZ_OSSF_cut_200"] = 1.803;
	upperLimitsExpected["HTlep_2ltau_offZ_OSSF_cut_500"] = 0.159;
	upperLimitsExpected["HTlep_2ltau_offZ_OSSF_cut_800"] = 0.155;
	upperLimitsExpected["HTlep_3l_offZ_noOSSF_cut_0"] = 0.836;
	upperLimitsExpected["HTlep_3l_offZ_noOSSF_cut_200"] = 0.340;
	upperLimitsExpected["HTlep_3l_offZ_noOSSF_cut_500"] = 0.218;
	upperLimitsExpected["HTlep_3l_offZ_noOSSF_cut_800"] = 0.140;
	upperLimitsExpected["HTlep_2ltau_offZ_noOSSF_cut_0"] = 4.132;
	upperLimitsExpected["HTlep_2ltau_offZ_noOSSF_cut_200"] = 0.599;
	upperLimitsExpected["HTlep_2ltau_offZ_noOSSF_cut_500"] = 0.146;
	upperLimitsExpected["HTlep_2ltau_offZ_noOSSF_cut_800"] = 0.148;
	upperLimitsExpected["HTlep_3l_onZ_cut_0"] = 32.181;
	upperLimitsExpected["HTlep_3l_onZ_cut_200"] = 4.879;
	upperLimitsExpected["HTlep_3l_onZ_cut_500"] = 0.473;
	upperLimitsExpected["HTlep_3l_onZ_cut_800"] = 0.266;
	upperLimitsExpected["HTlep_2ltau_onZ_cut_0"] = 217.801;
	upperLimitsExpected["HTlep_2ltau_onZ_cut_200"] = 3.676;
	upperLimitsExpected["HTlep_2ltau_onZ_cut_500"] = 0.235;
	upperLimitsExpected["HTlep_2ltau_onZ_cut_800"] = 0.150;
	upperLimitsExpected["METStrong_3l_offZ_OSSF_cut_0"] = 1.196;
	upperLimitsExpected["METStrong_3l_offZ_OSSF_cut_100"] = 0.423;
	upperLimitsExpected["METStrong_3l_offZ_OSSF_cut_200"] = 0.208;
	upperLimitsExpected["METStrong_3l_offZ_OSSF_cut_300"] = 0.158;
	upperLimitsExpected["METStrong_2ltau_offZ_OSSF_cut_0"] = 2.158;
	upperLimitsExpected["METStrong_2ltau_offZ_OSSF_cut_100"] = 0.461;
	upperLimitsExpected["METStrong_2ltau_offZ_OSSF_cut_200"] = 0.186;
	upperLimitsExpected["METStrong_2ltau_offZ_OSSF_cut_300"] = 0.138;
	upperLimitsExpected["METStrong_3l_offZ_noOSSF_cut_0"] = 0.495;
	upperLimitsExpected["METStrong_3l_offZ_noOSSF_cut_100"] = 0.284;
	upperLimitsExpected["METStrong_3l_offZ_noOSSF_cut_200"] = 0.150;
	upperLimitsExpected["METStrong_3l_offZ_noOSSF_cut_300"] = 0.146;
	upperLimitsExpected["METStrong_2ltau_offZ_noOSSF_cut_0"] = 1.967;
	upperLimitsExpected["METStrong_2ltau_offZ_noOSSF_cut_100"] = 0.732;
	upperLimitsExpected["METStrong_2ltau_offZ_noOSSF_cut_200"] = 0.225;
	upperLimitsExpected["METStrong_2ltau_offZ_noOSSF_cut_300"] = 0.147;
	upperLimitsExpected["METStrong_3l_onZ_cut_0"] = 7.157;
	upperLimitsExpected["METStrong_3l_onZ_cut_100"] = 1.342;
	upperLimitsExpected["METStrong_3l_onZ_cut_200"] = 0.508;
	upperLimitsExpected["METStrong_3l_onZ_cut_300"] = 0.228;
	upperLimitsExpected["METStrong_2ltau_onZ_cut_0"] = 12.441;
	upperLimitsExpected["METStrong_2ltau_onZ_cut_100"] = 0.534;
	upperLimitsExpected["METStrong_2ltau_onZ_cut_200"] = 0.243;
	upperLimitsExpected["METStrong_2ltau_onZ_cut_300"] = 0.218;
	upperLimitsExpected["METWeak_3l_offZ_OSSF_cut_0"] = 2.199;
	upperLimitsExpected["METWeak_3l_offZ_OSSF_cut_100"] = 0.391;
	upperLimitsExpected["METWeak_3l_offZ_OSSF_cut_200"] = 0.177;
	upperLimitsExpected["METWeak_3l_offZ_OSSF_cut_300"] = 0.144;
	upperLimitsExpected["METWeak_2ltau_offZ_OSSF_cut_0"] = 12.431;
	upperLimitsExpected["METWeak_2ltau_offZ_OSSF_cut_100"] = 0.358;
	upperLimitsExpected["METWeak_2ltau_offZ_OSSF_cut_200"] = 0.150;
	upperLimitsExpected["METWeak_2ltau_offZ_OSSF_cut_300"] = 0.135;
	upperLimitsExpected["METWeak_3l_offZ_noOSSF_cut_0"] = 0.577;
	upperLimitsExpected["METWeak_3l_offZ_noOSSF_cut_100"] = 0.214;
	upperLimitsExpected["METWeak_3l_offZ_noOSSF_cut_200"] = 0.155;
	upperLimitsExpected["METWeak_3l_offZ_noOSSF_cut_300"] = 0.140;
	upperLimitsExpected["METWeak_2ltau_offZ_noOSSF_cut_0"] = 2.474;
	upperLimitsExpected["METWeak_2ltau_offZ_noOSSF_cut_100"] = 0.382;
	upperLimitsExpected["METWeak_2ltau_offZ_noOSSF_cut_200"] = 0.144;
	upperLimitsExpected["METWeak_2ltau_offZ_noOSSF_cut_300"] = 0.146;
	upperLimitsExpected["METWeak_3l_onZ_cut_0"] = 26.305;
	upperLimitsExpected["METWeak_3l_onZ_cut_100"] = 1.227;
	upperLimitsExpected["METWeak_3l_onZ_cut_200"] = 0.311;
	upperLimitsExpected["METWeak_3l_onZ_cut_300"] = 0.188;
	upperLimitsExpected["METWeak_2ltau_onZ_cut_0"] = 205.198;
	upperLimitsExpected["METWeak_2ltau_onZ_cut_100"] = 0.399;
	upperLimitsExpected["METWeak_2ltau_onZ_cut_200"] = 0.166;
	upperLimitsExpected["METWeak_2ltau_onZ_cut_300"] = 0.140;
	upperLimitsExpected["Meff_3l_offZ_OSSF_cut_0"] = 2.893;
	upperLimitsExpected["Meff_3l_offZ_OSSF_cut_600"] = 0.649;
	upperLimitsExpected["Meff_3l_offZ_OSSF_cut_1000"] = 0.252;
	upperLimitsExpected["Meff_3l_offZ_OSSF_cut_1500"] = 0.150;
	upperLimitsExpected["Meff_2ltau_offZ_OSSF_cut_0"] = 14.293;
	upperLimitsExpected["Meff_2ltau_offZ_OSSF_cut_600"] = 0.657;
	upperLimitsExpected["Meff_2ltau_offZ_OSSF_cut_1000"] = 0.226;
	upperLimitsExpected["Meff_2ltau_offZ_OSSF_cut_1500"] = 0.154;
	upperLimitsExpected["Meff_3l_offZ_noOSSF_cut_0"] = 0.836;
	upperLimitsExpected["Meff_3l_offZ_noOSSF_cut_600"] = 0.265;
	upperLimitsExpected["Meff_3l_offZ_noOSSF_cut_1000"] = 0.176;
	upperLimitsExpected["Meff_3l_offZ_noOSSF_cut_1500"] = 0.146;
	upperLimitsExpected["Meff_2ltau_offZ_noOSSF_cut_0"] = 4.132;
	upperLimitsExpected["Meff_2ltau_offZ_noOSSF_cut_600"] = 0.678;
	upperLimitsExpected["Meff_2ltau_offZ_noOSSF_cut_1000"] = 0.243;
	upperLimitsExpected["Meff_2ltau_offZ_noOSSF_cut_1500"] = 0.184;
	upperLimitsExpected["Meff_3l_onZ_cut_0"] = 32.181;
	upperLimitsExpected["Meff_3l_onZ_cut_600"] = 3.219;
	upperLimitsExpected["Meff_3l_onZ_cut_1000"] = 0.905;
	upperLimitsExpected["Meff_3l_onZ_cut_1500"] = 0.261;
	upperLimitsExpected["Meff_2ltau_onZ_cut_0"] = 217.801;
	upperLimitsExpected["Meff_2ltau_onZ_cut_600"] = 1.680;
	upperLimitsExpected["Meff_2ltau_onZ_cut_1000"] = 0.375;
	upperLimitsExpected["Meff_2ltau_onZ_cut_1500"] = 0.178;
	upperLimitsExpected["MeffStrong_3l_offZ_OSSF_cut_0"] = 0.571;
	upperLimitsExpected["MeffStrong_3l_offZ_OSSF_cut_600"] = 0.386;
	upperLimitsExpected["MeffStrong_3l_offZ_OSSF_cut_1200"] = 0.177;
	upperLimitsExpected["MeffStrong_2ltau_offZ_OSSF_cut_0"] = 0.605;
	upperLimitsExpected["MeffStrong_2ltau_offZ_OSSF_cut_600"] = 0.335;
	upperLimitsExpected["MeffStrong_2ltau_offZ_OSSF_cut_1200"] = 0.249;
	upperLimitsExpected["MeffStrong_3l_offZ_noOSSF_cut_0"] = 0.373;
	upperLimitsExpected["MeffStrong_3l_offZ_noOSSF_cut_600"] = 0.223;
	upperLimitsExpected["MeffStrong_3l_offZ_noOSSF_cut_1200"] = 0.150;
	upperLimitsExpected["MeffStrong_2ltau_offZ_noOSSF_cut_0"] = 0.873;
	upperLimitsExpected["MeffStrong_2ltau_offZ_noOSSF_cut_600"] = 0.428;
	upperLimitsExpected["MeffStrong_2ltau_offZ_noOSSF_cut_1200"] = 0.210;
	upperLimitsExpected["MeffStrong_3l_onZ_cut_0"] = 2.034;
	upperLimitsExpected["MeffStrong_3l_onZ_cut_600"] = 1.093;
	upperLimitsExpected["MeffStrong_3l_onZ_cut_1200"] = 0.293;
	upperLimitsExpected["MeffStrong_2ltau_onZ_cut_0"] = 0.690;
	upperLimitsExpected["MeffStrong_2ltau_onZ_cut_600"] = 0.392;
	upperLimitsExpected["MeffStrong_2ltau_onZ_cut_1200"] = 0.156;
	upperLimitsExpected["MeffMt_3l_onZ_cut_0"] = 2.483;
	upperLimitsExpected["MeffMt_3l_onZ_cut_600"] = 0.845;
	upperLimitsExpected["MeffMt_3l_onZ_cut_1200"] = 0.255;
	upperLimitsExpected["MeffMt_2ltau_onZ_cut_0"] = 1.448;
	upperLimitsExpected["MeffMt_2ltau_onZ_cut_600"] = 0.391;
	upperLimitsExpected["MeffMt_2ltau_onZ_cut_1200"] = 0.146;
	upperLimitsExpected["MinPt_3l_offZ_OSSF_cut_0"] = 2.893;
	upperLimitsExpected["MinPt_3l_offZ_OSSF_cut_50"] = 0.703;
	upperLimitsExpected["MinPt_3l_offZ_OSSF_cut_100"] = 0.207;
	upperLimitsExpected["MinPt_3l_offZ_OSSF_cut_150"] = 0.143;
	upperLimitsExpected["MinPt_2ltau_offZ_OSSF_cut_0"] = 14.293;
	upperLimitsExpected["MinPt_2ltau_offZ_OSSF_cut_50"] = 0.705;
	upperLimitsExpected["MinPt_2ltau_offZ_OSSF_cut_100"] = 0.149;
	upperLimitsExpected["MinPt_2ltau_offZ_OSSF_cut_150"] = 0.155;
	upperLimitsExpected["MinPt_3l_offZ_noOSSF_cut_0"] = 0.836;
	upperLimitsExpected["MinPt_3l_offZ_noOSSF_cut_50"] = 0.249;
	upperLimitsExpected["MinPt_3l_offZ_noOSSF_cut_100"] = 0.135;
	upperLimitsExpected["MinPt_3l_offZ_noOSSF_cut_150"] = 0.136;
	upperLimitsExpected["MinPt_2ltau_offZ_noOSSF_cut_0"] = 4.132;
	upperLimitsExpected["MinPt_2ltau_offZ_noOSSF_cut_50"] = 0.339;
	upperLimitsExpected["MinPt_2ltau_offZ_noOSSF_cut_100"] = 0.149;
	upperLimitsExpected["MinPt_2ltau_offZ_noOSSF_cut_150"] = 0.145;
	upperLimitsExpected["MinPt_3l_onZ_cut_0"] = 32.181;
	upperLimitsExpected["MinPt_3l_onZ_cut_50"] = 2.260;
	upperLimitsExpected["MinPt_3l_onZ_cut_100"] = 0.438;
	upperLimitsExpected["MinPt_3l_onZ_cut_150"] = 0.305;
	upperLimitsExpected["MinPt_2ltau_onZ_cut_0"] = 217.801;
	upperLimitsExpected["MinPt_2ltau_onZ_cut_50"] = 1.335;
	upperLimitsExpected["MinPt_2ltau_onZ_cut_100"] = 0.162;
	upperLimitsExpected["MinPt_2ltau_onZ_cut_150"] = 0.149;
	upperLimitsExpected["nbtag_3l_offZ_OSSF_cut_0"] = 2.893;
	upperLimitsExpected["nbtag_3l_offZ_OSSF_cut_1"] = 0.923;
	upperLimitsExpected["nbtag_3l_offZ_OSSF_cut_2"] = 0.452;
	upperLimitsExpected["nbtag_2ltau_offZ_OSSF_cut_0"] = 14.293;
	upperLimitsExpected["nbtag_2ltau_offZ_OSSF_cut_1"] = 1.774;
	upperLimitsExpected["nbtag_2ltau_offZ_OSSF_cut_2"] = 0.549;
	upperLimitsExpected["nbtag_3l_offZ_noOSSF_cut_0"] = 0.836;
	upperLimitsExpected["nbtag_3l_offZ_noOSSF_cut_1"] = 0.594;
	upperLimitsExpected["nbtag_3l_offZ_noOSSF_cut_2"] = 0.298;
	upperLimitsExpected["nbtag_2ltau_offZ_noOSSF_cut_0"] = 4.132;
	upperLimitsExpected["nbtag_2ltau_offZ_noOSSF_cut_1"] = 2.358;
	upperLimitsExpected["nbtag_2ltau_offZ_noOSSF_cut_2"] = 0.958;
	upperLimitsExpected["nbtag_3l_onZ_cut_0"] = 32.181;
	upperLimitsExpected["nbtag_3l_onZ_cut_1"] = 3.868;
	upperLimitsExpected["nbtag_3l_onZ_cut_2"] = 0.887;
	upperLimitsExpected["nbtag_2ltau_onZ_cut_0"] = 217.801;
	upperLimitsExpected["nbtag_2ltau_onZ_cut_1"] = 9.397;
	upperLimitsExpected["nbtag_2ltau_onZ_cut_2"] = 0.787;



	if (observed) return upperLimitsObserved[signal_region];
	else return upperLimitsExpected[signal_region];
	}


	/// Function checking if there is an OSSF lepton pair or a combination of 3 leptons with an invariant mass close to the Z mass
	int isonZ (const Particles& particles) {
	int onZ = 0;
	double best_mass_2 = 999.;
	double best_mass_3 = 999.;

	// Loop over all 2 particle combinations to find invariant mass of OSSF pair closest to Z mass
	- foreach (const Particle& p1, particles) {
	- foreach (const Particle& p2, particles) {
	+ for (const Particle& p1 : particles) {
	+ for (const Particle& p2 : particles) {
	double mass_difference_2_old = fabs(91.0 - best_mass_2);
	double mass_difference_2_new = fabs(91.0 - (p1.momentum() + p2.momentum()).mass()/GeV);

	// If particle combination is OSSF pair calculate mass difference to Z mass
	if ((p1.pid()p2.pid() == -121 \|\| p1.pid()p2.pid() == -169)) {

	// Get invariant mass closest to Z mass
	if (mass_difference_2_new < mass_difference_2_old)
	best_mass_2 = (p1.momentum() + p2.momentum()).mass()/GeV;
	// In case there is an OSSF pair take also 3rd lepton into account (e.g. from FSR and photon to electron conversion)
	- foreach (const Particle& p3 , particles ) {
	+ for (const Particle& p3 : particles ) {
	double mass_difference_3_old = fabs(91.0 - best_mass_3);
	double mass_difference_3_new = fabs(91.0 - (p1.momentum() + p2.momentum() + p3.momentum()).mass()/GeV);
	if (mass_difference_3_new < mass_difference_3_old)
	best_mass_3 = (p1.momentum() + p2.momentum() + p3.momentum()).mass()/GeV;
	}
	}
	}
	}

	// Pick the minimum invariant mass of the best OSSF pair combination and the best 3 lepton combination
	double best_mass = min(best_mass_2,best_mass_3);
	// if this mass is in a 20 GeV window around the Z mass, the event is classified as onZ
	if ( fabs(91.0 - best_mass) < 20. ) onZ = 1;
	return onZ;
	}

	/// function checking if two leptons are an OSSF lepton pair and giving out the invariant mass (0 if no OSSF pair)
	double isOSSF_mass (const Particle& p1, const Particle& p2) {
	double inv_mass = 0.;
	// Is particle combination OSSF pair?
	if ((p1.pid()p2.pid() == -121 \|\| p1.pid()p2.pid() == -169)) {
	// Get invariant mass
	inv_mass = (p1.momentum() + p2.momentum()).mass()/GeV;
	}
	return inv_mass;
	}

	/// Function checking if there is an OSSF lepton pair
	bool isOSSF (const Particles& particles) {
	for (size_t i1=0 ; i1 < 3 ; i1 ++) {
	for (size_t i2 = i1+1 ; i2 < 3 ; i2 ++) {
	if ((particles[i1].pid()particles[i2].pid() == -121 \|\| particles[i1].pid()particles[i2].pid() == -169)) {
	return true;
	}
	}
	}
	return false;
	}

	//@}

	private:

	/// Histograms
	//@{
	Histo1DPtr _h_HTlep_all, _h_HTjets_all, _h_MET_all, _h_Meff_all, _h_min_pT_all, _h_mT_all;
	Histo1DPtr _h_pt_1_3l, _h_pt_2_3l, _h_pt_3_3l, _h_pt_1_2ltau, _h_pt_2_2ltau, _h_pt_3_2ltau;
	Histo1DPtr _h_e_n, _h_mu_n, _h_tau_n;
	Histo1DPtr _h_excluded;
	//@}

	/// Fiducial efficiencies to model the effects of the ATLAS detector
	bool _use_fiducial_lepton_efficiency;

	/// List of signal regions and event counts per signal region
	vector<string> _signal_regions;
	map<string, double> _eventCountsPerSR;

	};


	DECLARE_RIVET_PLUGIN(ATLAS_2014_I1327229);

	}
	diff --git a/src/Analyses/ATLAS_2015_CONF_2015_041.cc b/src/Analyses/ATLAS_2015_CONF_2015_041.cc
	--- a/src/Analyses/ATLAS_2015_CONF_2015_041.cc
	+++ b/src/Analyses/ATLAS_2015_CONF_2015_041.cc
	@@ -1,160 +1,160 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// Z + jets in pp at 13 TeV
	/// @note This base class contains a "mode" variable for combined, e, and mu channel derived classes
	class ATLAS_2015_CONF_2015_041 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	ATLAS_2015_CONF_2015_041(string name="ATLAS_2015_CONF_2015_041")
	: Analysis(name),
	_weights(5, 0.0)
	{
	// This class uses the combined e+mu mode
	_mode = 0;
	}

	//@}


	/// Book histograms and initialise projections before the run
	void init() {
	const FinalState fs;

	Cut cuts = (Cuts::pT > 25*GeV) & (Cuts::abseta < 2.5);
	ZFinder zfinder(fs, cuts, _mode? PID::MUON : PID::ELECTRON, 66GeV, 116GeV);
	- addProjection(zfinder, "zfinder");
	+ declare(zfinder, "zfinder");

	// Define veto FS in order to prevent Z-decay products entering the jet algorithm
	VetoedFinalState had_fs;
	had_fs.addVetoOnThisFinalState(zfinder);
	FastJets jets(had_fs, FastJets::ANTIKT, 0.4);
	jets.useInvisibles(true);
	- addProjection(jets, "jets");
	+ declare(jets, "jets");

	// individual channels
	_hNjets = bookHisto1D(1, 1, _mode + 1);
	_hNjetsRatio = bookScatter2D(2, 1, _mode + 1, true);
	// combination
	_hNjets_comb = bookHisto1D(1, 2, _mode + 1);
	_hNjetsRatio_comb = bookScatter2D(2, 2, _mode + 1, true);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "zfinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "zfinder");
	const Particles& leptons = zfinder.constituents();
	if (leptons.size() != 2) vetoEvent;

	Jets jets;
	- foreach (Jet j, applyProjection<JetAlg>(event, "jets").jetsByPt(Cuts::pT > 30*GeV && Cuts::absrap < 2.5)) {
	+ foreach (Jet j, apply<JetAlg>(event, "jets").jetsByPt(Cuts::pT > 30*GeV && Cuts::absrap < 2.5)) {
	bool keep = true;
	foreach(const Particle& l, leptons) keep &= deltaR(j, l) > 0.4;
	if (keep) jets += j;
	}

	size_t njets = jets.size();

	for(size_t i = 0; i <= njets; ++i) {
	_hNjets->fill(i + 0.5, weight);
	_hNjets_comb->fill(i + 0.5, weight);
	}

	for (size_t i = 0; i < 5; ++i) {
	if (njets >= i) _weights[i] += weight;
	}

	}

	/// @name Ratio calculator util functions
	//@{

	/// Calculate the ratio, being careful about div-by-zero
	double ratio(double a, double b) {
	return (b != 0) ? a/b : 0;
	}

	/// Calculate the ratio error, being careful about div-by-zero
	double ratio_err(double a, double b) {
	return (b != 0) ? sqrt(a/b*(1-a/b)/b) : 0;
	}

	//@}

	void finalize() {
	for (size_t i = 0; i < 4; ++i) {
	double n = _hNjets->bin(i + 1).sumW();
	double dN = _hNjets->bin(i + 1).sumW2();
	double d = _hNjets->bin(i).sumW();
	double dD = _hNjets->bin(i).sumW2();
	double r = safediv(n, d);
	double e = sqrt( safediv(r * (1 - r), d) );
	if ( _hNjets->effNumEntries() != _hNjets->numEntries() ) {
	// use F. James's approximation for weighted events:
	e = sqrt( safediv((1 - 2 * r) * dN + r * r * dD, d * d) );
	}
	_hNjetsRatio->point(i).setY(r, e);
	_hNjetsRatio_comb->point(i).setY(r, e);
	}

	scale(_hNjets, crossSectionPerEvent() );
	scale(_hNjets_comb, crossSectionPerEvent() );
	}

	//@}


	protected:

	size_t _mode;


	private:

	vector<double> _weights;
	Scatter2DPtr _hNjetsRatio, _hNjetsRatio_comb;
	Histo1DPtr _hNjets, _hNjets_comb;
	};



	class ATLAS_2015_CONF_2015_041_EL : public ATLAS_2015_CONF_2015_041 {
	public:
	ATLAS_2015_CONF_2015_041_EL()
	: ATLAS_2015_CONF_2015_041("ATLAS_2015_CONF_2015_041_EL")
	{
	_mode = 0;
	}
	};



	class ATLAS_2015_CONF_2015_041_MU : public ATLAS_2015_CONF_2015_041 {
	public:
	ATLAS_2015_CONF_2015_041_MU()
	: ATLAS_2015_CONF_2015_041("ATLAS_2015_CONF_2015_041_MU")
	{
	_mode = 1;
	}
	};



	DECLARE_RIVET_PLUGIN(ATLAS_2015_CONF_2015_041);
	DECLARE_RIVET_PLUGIN(ATLAS_2015_CONF_2015_041_EL);
	DECLARE_RIVET_PLUGIN(ATLAS_2015_CONF_2015_041_MU);
	}
	diff --git a/src/Analyses/ATLAS_2015_I1345452.cc b/src/Analyses/ATLAS_2015_I1345452.cc
	--- a/src/Analyses/ATLAS_2015_I1345452.cc
	+++ b/src/Analyses/ATLAS_2015_I1345452.cc
	@@ -1,292 +1,288 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/PromptFinalState.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {

	/// @brief ATLAS 7 TeV pseudo-top analysis
	///
	/// @author K .Finelli <kevin.finelli@cern.ch>
	/// @author A. Saavedra <a.saavedra@physics.usyd.edu.au>
	/// @author L. Lan <llan@physics.usyd.edu.au>
	class ATLAS_2015_I1345452 : public Analysis {
	- public:
	+ public:

	- /// Constructor
	- ATLAS_2015_I1345452()
	- : Analysis("ATLAS_2015_I1345452")
	- {
	- setNeedsCrossSection(true);
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1345452);
	+
	+
	+ void init() {
	+ // Eta ranges
	+ Cut eta_full = (Cuts::abseta < 5.0) & (Cuts::pT >= 1.0*MeV);
	+ Cut eta_lep = (Cuts::abseta < 2.5);
	+
	+ // All final state particles
	+ FinalState fs(eta_full);
	+
	+ // Get photons to dress leptons
	+ IdentifiedFinalState photons(fs);
	+ photons.acceptIdPair(PID::PHOTON);
	+
	+ // Projection to find the electrons
	+ IdentifiedFinalState el_id(fs);
	+ el_id.acceptIdPair(PID::ELECTRON);
	+
	+ PromptFinalState electrons(el_id);
	+ electrons.acceptTauDecays(true);
	+ declare(electrons, "electrons");
	+
	+ DressedLeptons dressedelectrons(photons, electrons, 0.1, eta_lep & (Cuts::pT >= 25.0*GeV), true, true);
	+ declare(dressedelectrons, "dressedelectrons");
	+
	+ DressedLeptons ewdressedelectrons(photons, electrons, 0.1, eta_full, true, true);
	+ declare(ewdressedelectrons, "ewdressedelectrons");
	+
	+ DressedLeptons vetodressedelectrons(photons, electrons, 0.1, eta_lep & (Cuts::pT >= 15.0*GeV), true, true);
	+ declare(vetodressedelectrons, "vetodressedelectrons");
	+
	+ // Projection to find the muons
	+ IdentifiedFinalState mu_id(fs);
	+ mu_id.acceptIdPair(PID::MUON);
	+ PromptFinalState muons(mu_id);
	+ muons.acceptTauDecays(true);
	+ declare(muons, "muons");
	+ DressedLeptons dressedmuons(photons, muons, 0.1, eta_lep & (Cuts::pT >= 25.0*GeV), true, true);
	+ declare(dressedmuons, "dressedmuons");
	+ DressedLeptons ewdressedmuons(photons, muons, 0.1, eta_full, true, true);
	+ declare(ewdressedmuons, "ewdressedmuons");
	+ DressedLeptons vetodressedmuons(photons, muons, 0.1, eta_lep & (Cuts::pT >= 15.0*GeV), true, true);
	+ declare(vetodressedmuons, "vetodressedmuons");
	+
	+ // Projection to find neutrinos and produce MET
	+ IdentifiedFinalState nu_id;
	+ nu_id.acceptNeutrinos();
	+ PromptFinalState neutrinos(nu_id);
	+ neutrinos.acceptTauDecays(true);
	+ declare(neutrinos, "neutrinos");
	+
	+ // Jet clustering.
	+ VetoedFinalState vfs;
	+ vfs.addVetoOnThisFinalState(ewdressedelectrons);
	+ vfs.addVetoOnThisFinalState(ewdressedmuons);
	+ vfs.addVetoOnThisFinalState(neutrinos);
	+ FastJets jets(vfs, FastJets::ANTIKT, 0.4);
	+ jets.useInvisibles();
	+ declare(jets, "jets");
	+
	+ //pseudotop leptons and hadrons
	+ _h["ptpseudotophadron_mu"] = bookHisto1D( 1, 1, 2);
	+ _h["ptpseudotophadron_el"] = bookHisto1D( 2, 1, 2);
	+ _h["absrappseudotophadron_mu"] = bookHisto1D( 3, 1, 2);
	+ _h["absrappseudotophadron_el"] = bookHisto1D( 4, 1, 2);
	+ _h["ptpseudotoplepton_mu"] = bookHisto1D( 5, 1, 2);
	+ _h["ptpseudotoplepton_el"] = bookHisto1D( 6, 1, 2);
	+ _h["absrappseudotoplepton_mu"] = bookHisto1D( 7, 1, 2);
	+ _h["absrappseudotoplepton_el"] = bookHisto1D( 8, 1, 2);
	+ _h["ptttbar_mu"] = bookHisto1D( 9, 1, 2);
	+ _h["ptttbar_el"] = bookHisto1D(10, 1, 2);
	+ _h["absrapttbar_mu"] = bookHisto1D(11, 1, 2);
	+ _h["absrapttbar_el"] = bookHisto1D(12, 1, 2);
	+ _h["ttbarmass_mu"] = bookHisto1D(13, 1, 2);
	+ _h["ttbarmass_el"] = bookHisto1D(14, 1, 2);
	+ _h["ptpseudotophadron"] = bookHisto1D(15, 1, 2);
	+ _h["absrappseudotophadron"] = bookHisto1D(16, 1, 2);
	+ _h["ptpseudotoplepton"] = bookHisto1D(17, 1, 2);
	+ _h["absrappseudotoplepton"] = bookHisto1D(18, 1, 2);
	+ _h["ptttbar"] = bookHisto1D(19, 1, 2);
	+ _h["absrapttbar"] = bookHisto1D(20, 1, 2);
	+ _h["ttbarmass"] = bookHisto1D(21, 1, 2);
	+
	+ }
	+
	+ void analyze(const Event& event) {
	+
	+ // Get the selected objects, using the projections.
	+ _dressedelectrons = apply<DressedLeptons>( event, "dressedelectrons").dressedLeptons();
	+ _vetodressedelectrons = apply<DressedLeptons>( event, "vetodressedelectrons").dressedLeptons();
	+ _dressedmuons = apply<DressedLeptons>( event, "dressedmuons").dressedLeptons();
	+ _vetodressedmuons = apply<DressedLeptons>( event, "vetodressedmuons").dressedLeptons();
	+ _neutrinos = apply<PromptFinalState>(event, "neutrinos").particlesByPt();
	+ const Jets& all_jets = apply<FastJets>( event, "jets").jetsByPt(Cuts::pT > 25.0*GeV && Cuts::abseta < 2.5);
	+
	+ //get true l+jets events by removing events with more than 1 electron\|\|muon neutrino
	+ unsigned int n_elmu_neutrinos = 0;
	+ foreach (const Particle p, _neutrinos) {
	+ if (p.abspid() == 12 \|\| p.abspid() == 14) ++n_elmu_neutrinos;
	+ }
	+ if (n_elmu_neutrinos != 1) vetoEvent;
	+
	+ DressedLepton *lepton;
	+ if ( _dressedelectrons.size()) lepton = &_dressedelectrons[0];
	+ else if (_dressedmuons.size()) lepton = &_dressedmuons[0];
	+ else vetoEvent;
	+
	+ // Calculate the missing ET, using the prompt neutrinos only (really?)
	+ /// @todo Why not use MissingMomentum?
	+ FourMomentum met;
	+ foreach (const Particle& p, _neutrinos) met += p.momentum();
	+
	+ //remove jets if they are within dR < 0.2 of lepton
	+ Jets jets;
	+ foreach(const Jet& jet, all_jets) {
	+ bool keep = true;
	+ foreach (const DressedLepton& el, _vetodressedelectrons) {
	+ keep &= deltaR(jet, el) >= 0.2;
	+ }
	+ if (keep) jets += jet;
	}

	-
	- void init() {
	- // Eta ranges
	- Cut eta_full = (Cuts::abseta < 5.0) & (Cuts::pT >= 1.0*MeV);
	- Cut eta_lep = (Cuts::abseta < 2.5);
	-
	- // All final state particles
	- FinalState fs(eta_full);
	-
	- // Get photons to dress leptons
	- IdentifiedFinalState photons(fs);
	- photons.acceptIdPair(PID::PHOTON);
	-
	- // Projection to find the electrons
	- IdentifiedFinalState el_id(fs);
	- el_id.acceptIdPair(PID::ELECTRON);
	-
	- PromptFinalState electrons(el_id);
	- electrons.acceptTauDecays(true);
	- addProjection(electrons, "electrons");
	-
	- DressedLeptons dressedelectrons(photons, electrons, 0.1, eta_lep & (Cuts::pT >= 25.0*GeV), true, true);
	- addProjection(dressedelectrons, "dressedelectrons");
	-
	- DressedLeptons ewdressedelectrons(photons, electrons, 0.1, eta_full, true, true);
	- addProjection(ewdressedelectrons, "ewdressedelectrons");
	-
	- DressedLeptons vetodressedelectrons(photons, electrons, 0.1, eta_lep & (Cuts::pT >= 15.0*GeV), true, true);
	- addProjection(vetodressedelectrons, "vetodressedelectrons");
	-
	- // Projection to find the muons
	- IdentifiedFinalState mu_id(fs);
	- mu_id.acceptIdPair(PID::MUON);
	- PromptFinalState muons(mu_id);
	- muons.acceptTauDecays(true);
	- addProjection(muons, "muons");
	- DressedLeptons dressedmuons(photons, muons, 0.1, eta_lep & (Cuts::pT >= 25.0*GeV), true, true);
	- addProjection(dressedmuons, "dressedmuons");
	- DressedLeptons ewdressedmuons(photons, muons, 0.1, eta_full, true, true);
	- addProjection(ewdressedmuons, "ewdressedmuons");
	- DressedLeptons vetodressedmuons(photons, muons, 0.1, eta_lep & (Cuts::pT >= 15.0*GeV), true, true);
	- addProjection(vetodressedmuons, "vetodressedmuons");
	-
	- // Projection to find neutrinos and produce MET
	- IdentifiedFinalState nu_id;
	- nu_id.acceptNeutrinos();
	- PromptFinalState neutrinos(nu_id);
	- neutrinos.acceptTauDecays(true);
	- addProjection(neutrinos, "neutrinos");
	-
	- // Jet clustering.
	- VetoedFinalState vfs;
	- vfs.addVetoOnThisFinalState(ewdressedelectrons);
	- vfs.addVetoOnThisFinalState(ewdressedmuons);
	- vfs.addVetoOnThisFinalState(neutrinos);
	- FastJets jets(vfs, FastJets::ANTIKT, 0.4);
	- jets.useInvisibles();
	- addProjection(jets, "jets");
	-
	- //pseudotop leptons and hadrons
	- _h["ptpseudotophadron_mu"] = bookHisto1D( 1, 1, 2);
	- _h["ptpseudotophadron_el"] = bookHisto1D( 2, 1, 2);
	- _h["absrappseudotophadron_mu"] = bookHisto1D( 3, 1, 2);
	- _h["absrappseudotophadron_el"] = bookHisto1D( 4, 1, 2);
	- _h["ptpseudotoplepton_mu"] = bookHisto1D( 5, 1, 2);
	- _h["ptpseudotoplepton_el"] = bookHisto1D( 6, 1, 2);
	- _h["absrappseudotoplepton_mu"] = bookHisto1D( 7, 1, 2);
	- _h["absrappseudotoplepton_el"] = bookHisto1D( 8, 1, 2);
	- _h["ptttbar_mu"] = bookHisto1D( 9, 1, 2);
	- _h["ptttbar_el"] = bookHisto1D(10, 1, 2);
	- _h["absrapttbar_mu"] = bookHisto1D(11, 1, 2);
	- _h["absrapttbar_el"] = bookHisto1D(12, 1, 2);
	- _h["ttbarmass_mu"] = bookHisto1D(13, 1, 2);
	- _h["ttbarmass_el"] = bookHisto1D(14, 1, 2);
	- _h["ptpseudotophadron"] = bookHisto1D(15, 1, 2);
	- _h["absrappseudotophadron"] = bookHisto1D(16, 1, 2);
	- _h["ptpseudotoplepton"] = bookHisto1D(17, 1, 2);
	- _h["absrappseudotoplepton"] = bookHisto1D(18, 1, 2);
	- _h["ptttbar"] = bookHisto1D(19, 1, 2);
	- _h["absrapttbar"] = bookHisto1D(20, 1, 2);
	- _h["ttbarmass"] = bookHisto1D(21, 1, 2);
	-
	+ bool overlap = false;
	+ Jets bjets, lightjets;
	+ for (unsigned int i = 0; i < jets.size(); ++i) {
	+ const Jet& jet = jets[i];
	+ foreach (const DressedLepton& el, _dressedelectrons) overlap \|= deltaR(jet, el) < 0.4;
	+ foreach (const DressedLepton& mu, _dressedmuons) overlap \|= deltaR(jet, mu) < 0.4;
	+ for (unsigned int j = i + 1; j < jets.size(); ++j) {
	+ overlap \|= deltaR(jet, jets[j]) < 0.5;
	+ }
	+ //// Count the number of b-tags
	+ bool b_tagged = false; // This is closer to the
	+ Particles bTags = jet.bTags(); // analysis. Something
	+ foreach ( Particle b, bTags ) { // about ghost-associated
	+ b_tagged \|= b.pT() > 5*GeV; // B-hadrons
	+ } //
	+ if ( b_tagged ) bjets += jet;
	+ else lightjets += jet;
	}

	- void analyze(const Event& event) {
	+ // remove events with object overlap
	+ if (overlap) vetoEvent;

	- // Get the selected objects, using the projections.
	- _dressedelectrons = applyProjection<DressedLeptons>( event, "dressedelectrons").dressedLeptons();
	- _vetodressedelectrons = applyProjection<DressedLeptons>( event, "vetodressedelectrons").dressedLeptons();
	- _dressedmuons = applyProjection<DressedLeptons>( event, "dressedmuons").dressedLeptons();
	- _vetodressedmuons = applyProjection<DressedLeptons>( event, "vetodressedmuons").dressedLeptons();
	- _neutrinos = applyProjection<PromptFinalState>(event, "neutrinos").particlesByPt();
	- const Jets& all_jets = applyProjection<FastJets>( event, "jets").jetsByPt(Cuts::pT > 25.0*GeV && Cuts::abseta < 2.5);
	+ if (bjets.size() < 2 \|\| lightjets.size() < 2) vetoEvent;

	- //get true l+jets events by removing events with more than 1 electron\|\|muon neutrino
	- unsigned int n_elmu_neutrinos = 0;
	- foreach (const Particle p, _neutrinos) {
	- if (p.abspid() == 12 \|\| p.abspid() == 14) ++n_elmu_neutrinos;
	- }
	- if (n_elmu_neutrinos != 1) vetoEvent;
	-
	- DressedLepton *lepton;
	- if ( _dressedelectrons.size()) lepton = &_dressedelectrons[0];
	- else if (_dressedmuons.size()) lepton = &_dressedmuons[0];
	- else vetoEvent;
	-
	- // Calculate the missing ET, using the prompt neutrinos only (really?)
	- /// @todo Why not use MissingMomentum?
	- FourMomentum met;
	- foreach (const Particle& p, _neutrinos) met += p.momentum();
	-
	- //remove jets if they are within dR < 0.2 of lepton
	- Jets jets;
	- foreach(const Jet& jet, all_jets) {
	- bool keep = true;
	- foreach (const DressedLepton& el, _vetodressedelectrons) {
	- keep &= deltaR(jet, el) >= 0.2;
	- }
	- if (keep) jets += jet;
	- }
	-
	- bool overlap = false;
	- Jets bjets, lightjets;
	- for (unsigned int i = 0; i < jets.size(); ++i) {
	- const Jet& jet = jets[i];
	- foreach (const DressedLepton& el, _dressedelectrons) overlap \|= deltaR(jet, el) < 0.4;
	- foreach (const DressedLepton& mu, _dressedmuons) overlap \|= deltaR(jet, mu) < 0.4;
	- for (unsigned int j = i + 1; j < jets.size(); ++j) {
	- overlap \|= deltaR(jet, jets[j]) < 0.5;
	- }
	- //// Count the number of b-tags
	- bool b_tagged = false; // This is closer to the
	- Particles bTags = jet.bTags(); // analysis. Something
	- foreach ( Particle b, bTags ) { // about ghost-associated
	- b_tagged \|= b.pT() > 5*GeV; // B-hadrons
	- } //
	- if ( b_tagged ) bjets += jet;
	- else lightjets += jet;
	- }
	-
	- // remove events with object overlap
	- if (overlap) vetoEvent;
	-
	- if (bjets.size() < 2 \|\| lightjets.size() < 2) vetoEvent;
	-
	- FourMomentum pbjet1; //Momentum of bjet1
	- FourMomentum pbjet2; //Momentum of bjet2
	- if ( deltaR(bjets[0], lepton) <= deltaR(bjets[1], lepton) ) {
	- pbjet1 = bjets[0].momentum();
	- pbjet2 = bjets[1].momentum();
	- } else {
	- pbjet1 = bjets[1].momentum();
	- pbjet2 = bjets[0].momentum();
	- }
	-
	- FourMomentum pjet1; // Momentum of jet1
	- if (lightjets.size()) pjet1 = lightjets[0].momentum();
	-
	- FourMomentum pjet2; // Momentum of jet 2
	- if (lightjets.size() > 1) pjet2 = lightjets[1].momentum();
	-
	- double pz = computeneutrinoz(lepton->momentum(), met);
	- FourMomentum ppseudoneutrino( sqrt(sqr(met.px()) + sqr(met.py()) + sqr(pz)), met.px(), met.py(), pz);
	-
	- //compute leptonic, hadronic, combined pseudo-top
	- FourMomentum ppseudotoplepton = lepton->momentum() + ppseudoneutrino + pbjet1;
	- FourMomentum ppseudotophadron = pbjet2 + pjet1 + pjet2;
	- FourMomentum pttbar = ppseudotoplepton + ppseudotophadron;
	-
	- // Evaluate basic event selection
	- bool pass_eljets = (_dressedelectrons.size() == 1) &&
	- (_vetodressedelectrons.size() < 2) &&
	- (_vetodressedmuons.empty()) &&
	- (met.pT() > 30*GeV) &&
	- (_mT(_dressedelectrons[0].momentum(), met) > 35*GeV) &&
	- (jets.size() >= 4);
	- bool pass_mujets = (_dressedmuons.size() == 1) &&
	- (_vetodressedmuons.size() < 2) &&
	- (_vetodressedelectrons.empty()) &&
	- (met.pT() > 30*GeV) &&
	- (_mT(_dressedmuons[0].momentum(), met) > 35*GeV) &&
	- (jets.size() >= 4);
	-
	- // basic event selection requirements
	- if (!pass_eljets && !pass_mujets) vetoEvent;
	-
	- // Fill histograms
	- const double weight = event.weight();
	-
	- //pseudotop hadrons and leptons fill histogram
	- _h["ptpseudotoplepton"]->fill( ppseudotoplepton.pt(), weight); //pT of pseudo top lepton
	- _h["absrappseudotoplepton"]->fill(ppseudotoplepton.absrap(), weight); //absolute rapidity of pseudo top lepton
	- _h["ptpseudotophadron"]->fill( ppseudotophadron.pt(), weight); //pT of pseudo top hadron
	- _h["absrappseudotophadron"]->fill(ppseudotophadron.absrap(), weight); //absolute rapidity of pseudo top hadron
	- _h["absrapttbar"]->fill( pttbar.absrap(), weight); //absolute rapidity of ttbar
	- _h["ttbarmass"]->fill( pttbar.mass(), weight); //mass of ttbar
	- _h["ptttbar"]->fill( pttbar.pt(), weight); //fill pT of ttbar in combined channel
	-
	- if (pass_eljets) { // electron channel fill histogram
	- _h["ptpseudotoplepton_el"]->fill( ppseudotoplepton.pt(), weight); //pT of pseudo top lepton
	- _h["absrappseudotoplepton_el"]->fill(ppseudotoplepton.absrap(), weight); //absolute rapidity of pseudo top lepton
	- _h["ptpseudotophadron_el"]->fill( ppseudotophadron.pt(), weight); //pT of pseudo top hadron
	- _h["absrappseudotophadron_el"]->fill(ppseudotophadron.absrap(), weight); //absolute rapidity of pseudo top hadron
	- _h["absrapttbar_el"]->fill( pttbar.absrap(), weight); //absolute rapidity of ttbar
	- _h["ttbarmass_el"]->fill( pttbar.mass(), weight); // fill electron channel ttbar mass
	- _h["ptttbar_el"]->fill( pttbar.pt(), weight); //fill pT of ttbar in electron channel
	- }
	- else { // muon channel fill histogram
	- _h["ptpseudotoplepton_mu"]->fill( ppseudotoplepton.pt(), weight); //pT of pseudo top lepton
	- _h["absrappseudotoplepton_mu"]->fill(ppseudotoplepton.absrap(), weight); //absolute rapidity of pseudo top lepton
	- _h["ptpseudotophadron_mu"]->fill( ppseudotophadron.pt(), weight); //pT of pseudo top hadron
	- _h["absrappseudotophadron_mu"]->fill(ppseudotophadron.absrap(), weight); //absolute rapidity of pseudo top hadron
	- _h["absrapttbar_mu"]->fill( pttbar.absrap(), weight); //absolute rapidity of ttbar
	- _h["ttbarmass_mu"]->fill( pttbar.mass(), weight); //fill muon channel histograms
	- _h["ptttbar_mu"]->fill( pttbar.pt(), weight); //fill pT of ttbar in electron channel
	- }
	- }
	-
	- void finalize() {
	- // Normalize to cross-section
	- const double scalefactor(crossSection() / sumOfWeights());
	- for (map<string, Histo1DPtr>::iterator hit = _h.begin(); hit != _h.end(); ++hit) {
	- double sf = scalefactor;
	- if ( (hit->first).find("_") == std::string::npos ) sf *= 0.5;
	- scale(hit->second, sf);
	- }
	+ FourMomentum pbjet1; //Momentum of bjet1
	+ FourMomentum pbjet2; //Momentum of bjet2
	+ if ( deltaR(bjets[0], lepton) <= deltaR(bjets[1], lepton) ) {
	+ pbjet1 = bjets[0].momentum();
	+ pbjet2 = bjets[1].momentum();
	+ } else {
	+ pbjet1 = bjets[1].momentum();
	+ pbjet2 = bjets[0].momentum();
	}

	- private:
	+ FourMomentum pjet1; // Momentum of jet1
	+ if (lightjets.size()) pjet1 = lightjets[0].momentum();

	+ FourMomentum pjet2; // Momentum of jet 2
	+ if (lightjets.size() > 1) pjet2 = lightjets[1].momentum();

	- double computeneutrinoz(const FourMomentum& lepton, FourMomentum& met) const {
	- //computing z component of neutrino momentum given lepton and met
	- double pzneutrino;
	- double m_W = 80.399; // in GeV, given in the paper
	- double k = (( sqr( m_W ) - sqr( lepton.mass() ) ) / 2 ) + (lepton.px() * met.px() + lepton.py() * met.py());
	- double a = sqr ( lepton.E() )- sqr ( lepton.pz() );
	- double b = -2klepton.pz();
	- double c = sqr( lepton.E() ) * sqr( met.pT() ) - sqr( k );
	- double discriminant = sqr(b) - 4 * a * c;
	- double quad[2] = { (- b - sqrt(discriminant)) / (2 * a), (- b + sqrt(discriminant)) / (2 * a) }; //two possible quadratic solns
	- if (discriminant < 0) pzneutrino = - b / (2 * a); //if the discriminant is negative
	- else { //if the discriminant is greater than or equal to zero, take the soln with smallest absolute value
	- double absquad[2];
	- for (int n=0; n<2; ++n) absquad[n] = fabs(quad[n]);
	- if (absquad[0] < absquad[1]) pzneutrino = quad[0];
	- else pzneutrino = quad[1];
	- }
	- if ( !std::isfinite(pzneutrino) ) std::cout << "Found non-finite value" << std::endl;
	- return pzneutrino;
	+ double pz = computeneutrinoz(lepton->momentum(), met);
	+ FourMomentum ppseudoneutrino( sqrt(sqr(met.px()) + sqr(met.py()) + sqr(pz)), met.px(), met.py(), pz);
	+
	+ //compute leptonic, hadronic, combined pseudo-top
	+ FourMomentum ppseudotoplepton = lepton->momentum() + ppseudoneutrino + pbjet1;
	+ FourMomentum ppseudotophadron = pbjet2 + pjet1 + pjet2;
	+ FourMomentum pttbar = ppseudotoplepton + ppseudotophadron;
	+
	+ // Evaluate basic event selection
	+ bool pass_eljets = (_dressedelectrons.size() == 1) &&
	+ (_vetodressedelectrons.size() < 2) &&
	+ (_vetodressedmuons.empty()) &&
	+ (met.pT() > 30*GeV) &&
	+ (_mT(_dressedelectrons[0].momentum(), met) > 35*GeV) &&
	+ (jets.size() >= 4);
	+ bool pass_mujets = (_dressedmuons.size() == 1) &&
	+ (_vetodressedmuons.size() < 2) &&
	+ (_vetodressedelectrons.empty()) &&
	+ (met.pT() > 30*GeV) &&
	+ (_mT(_dressedmuons[0].momentum(), met) > 35*GeV) &&
	+ (jets.size() >= 4);
	+
	+ // basic event selection requirements
	+ if (!pass_eljets && !pass_mujets) vetoEvent;
	+
	+ // Fill histograms
	+ const double weight = event.weight();
	+
	+ //pseudotop hadrons and leptons fill histogram
	+ _h["ptpseudotoplepton"]->fill( ppseudotoplepton.pt(), weight); //pT of pseudo top lepton
	+ _h["absrappseudotoplepton"]->fill(ppseudotoplepton.absrap(), weight); //absolute rapidity of pseudo top lepton
	+ _h["ptpseudotophadron"]->fill( ppseudotophadron.pt(), weight); //pT of pseudo top hadron
	+ _h["absrappseudotophadron"]->fill(ppseudotophadron.absrap(), weight); //absolute rapidity of pseudo top hadron
	+ _h["absrapttbar"]->fill( pttbar.absrap(), weight); //absolute rapidity of ttbar
	+ _h["ttbarmass"]->fill( pttbar.mass(), weight); //mass of ttbar
	+ _h["ptttbar"]->fill( pttbar.pt(), weight); //fill pT of ttbar in combined channel
	+
	+ if (pass_eljets) { // electron channel fill histogram
	+ _h["ptpseudotoplepton_el"]->fill( ppseudotoplepton.pt(), weight); //pT of pseudo top lepton
	+ _h["absrappseudotoplepton_el"]->fill(ppseudotoplepton.absrap(), weight); //absolute rapidity of pseudo top lepton
	+ _h["ptpseudotophadron_el"]->fill( ppseudotophadron.pt(), weight); //pT of pseudo top hadron
	+ _h["absrappseudotophadron_el"]->fill(ppseudotophadron.absrap(), weight); //absolute rapidity of pseudo top hadron
	+ _h["absrapttbar_el"]->fill( pttbar.absrap(), weight); //absolute rapidity of ttbar
	+ _h["ttbarmass_el"]->fill( pttbar.mass(), weight); // fill electron channel ttbar mass
	+ _h["ptttbar_el"]->fill( pttbar.pt(), weight); //fill pT of ttbar in electron channel
	}
	+ else { // muon channel fill histogram
	+ _h["ptpseudotoplepton_mu"]->fill( ppseudotoplepton.pt(), weight); //pT of pseudo top lepton
	+ _h["absrappseudotoplepton_mu"]->fill(ppseudotoplepton.absrap(), weight); //absolute rapidity of pseudo top lepton
	+ _h["ptpseudotophadron_mu"]->fill( ppseudotophadron.pt(), weight); //pT of pseudo top hadron
	+ _h["absrappseudotophadron_mu"]->fill(ppseudotophadron.absrap(), weight); //absolute rapidity of pseudo top hadron
	+ _h["absrapttbar_mu"]->fill( pttbar.absrap(), weight); //absolute rapidity of ttbar
	+ _h["ttbarmass_mu"]->fill( pttbar.mass(), weight); //fill muon channel histograms
	+ _h["ptttbar_mu"]->fill( pttbar.pt(), weight); //fill pT of ttbar in electron channel
	+ }
	+ }

	- double _mT(const FourMomentum &l, FourMomentum &nu) const {
	- return sqrt( 2 * l.pT() * nu.pT() * (1 - cos(deltaPhi(l, nu))) );
	+ void finalize() {
	+ // Normalize to cross-section
	+ const double scalefactor(crossSection() / sumOfWeights());
	+ for (map<string, Histo1DPtr>::iterator hit = _h.begin(); hit != _h.end(); ++hit) {
	+ double sf = scalefactor;
	+ if ( (hit->first).find("_") == std::string::npos ) sf *= 0.5;
	+ scale(hit->second, sf);
	}
	+ }

	- /// @name Objects that are used by the event selection decisions
	- vector<DressedLepton> _dressedelectrons, _vetodressedelectrons, _dressedmuons, _vetodressedmuons;
	- Particles _neutrinos;
	- map<string, Histo1DPtr> _h;
	+ private:
	+
	+
	+ double computeneutrinoz(const FourMomentum& lepton, FourMomentum& met) const {
	+ //computing z component of neutrino momentum given lepton and met
	+ double pzneutrino;
	+ double m_W = 80.399; // in GeV, given in the paper
	+ double k = (( sqr( m_W ) - sqr( lepton.mass() ) ) / 2 ) + (lepton.px() * met.px() + lepton.py() * met.py());
	+ double a = sqr ( lepton.E() )- sqr ( lepton.pz() );
	+ double b = -2klepton.pz();
	+ double c = sqr( lepton.E() ) * sqr( met.pT() ) - sqr( k );
	+ double discriminant = sqr(b) - 4 * a * c;
	+ double quad[2] = { (- b - sqrt(discriminant)) / (2 * a), (- b + sqrt(discriminant)) / (2 * a) }; //two possible quadratic solns
	+ if (discriminant < 0) pzneutrino = - b / (2 * a); //if the discriminant is negative
	+ else { //if the discriminant is greater than or equal to zero, take the soln with smallest absolute value
	+ double absquad[2];
	+ for (int n=0; n<2; ++n) absquad[n] = fabs(quad[n]);
	+ if (absquad[0] < absquad[1]) pzneutrino = quad[0];
	+ else pzneutrino = quad[1];
	+ }
	+ if ( !std::isfinite(pzneutrino) ) std::cout << "Found non-finite value" << std::endl;
	+ return pzneutrino;
	+ }
	+
	+ double _mT(const FourMomentum &l, FourMomentum &nu) const {
	+ return sqrt( 2 * l.pT() * nu.pT() * (1 - cos(deltaPhi(l, nu))) );
	+ }
	+
	+ /// @name Objects that are used by the event selection decisions
	+ vector<DressedLepton> _dressedelectrons, _vetodressedelectrons, _dressedmuons, _vetodressedmuons;
	+ Particles _neutrinos;
	+ map<string, Histo1DPtr> _h;
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2015_I1345452);

	}
	diff --git a/src/Analyses/ATLAS_2015_I1351916.cc b/src/Analyses/ATLAS_2015_I1351916.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2015_I1351916.cc
	@@ -0,0 +1,150 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/DressedLeptons.hh"
	+
	+namespace Rivet {
	+
	+
	+ class ATLAS_2015_I1351916 : public Analysis {
	+ public:
	+
	+ /// @name Constructors etc.
	+ //@{
	+
	+ /// Constructors
	+ ATLAS_2015_I1351916(string name="ATLAS_2015_I1351916", size_t mode=0)
	+ : Analysis(name), _mode(mode) // pick electron channel by default
	+ { }
	+
	+ //@}
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ const FinalState fs;
	+
	+ IdentifiedFinalState bareleptons(fs);
	+ bareleptons.acceptIdPair(_mode? PID::MUON : PID::ELECTRON);
	+
	+ const Cut cuts = (_mode == 0) ? (Cuts::pT > 25GeV && Cuts::abseta < 4.9) : (Cuts::pT > 20GeV && Cuts::abseta < 2.47);
	+ DressedLeptons leptons(fs, bareleptons, 0.1, cuts, true, true);
	+ declare(leptons, "leptons");
	+
	+
	+ // Book dummy histograms for heterogeneous merging
	+ /// @todo AB: Don't we have a nicer way to book dummy/tmp histos from ref?
	+ string label = "NCC";
	+ string hname = "d01-x01-y01";
	+ const Scatter2D& ref = refData(hname);
	+ hname = "d01-x01-y02";
	+ _h[label + "_pos"] = bookHisto1D(hname, ref);
	+ hname = "d01-x01-y03";
	+ _h[label + "_neg"] = bookHisto1D(hname, ref);
	+ if (_mode == 0) {
	+ label = "NCF";
	+ hname = "d01-x02-y01";
	+ const Scatter2D& ref_cf = refData(hname);
	+ hname = "d01-x02-y02";
	+ _h[label + "_pos"] = bookHisto1D(hname, ref_cf);
	+ hname = "d01-x02-y03";
	+ _h[label + "_neg"] = bookHisto1D(hname, ref_cf);
	+ }
	+
	+ // Book asymmetry scatter plots
	+ _s["CC"] = bookScatter2D(1, 1, 1, true);
	+ if (_mode == 0) _s["CF"] = bookScatter2D(1, 2, 1, true);
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& e) {
	+
	+ // Get and cut on dressed leptons
	+ const vector<DressedLepton>& leptons = apply<DressedLeptons>(e, "leptons").dressedLeptons();
	+ if (leptons.size() != 2) vetoEvent; // require exactly two leptons
	+ if (leptons[0].threeCharge() * leptons[1].threeCharge() > 0) vetoEvent; // require opposite charge
	+
	+ // Identify lepton vs antilepton
	+ const Particle& lpos = leptons[(leptons[0].threeCharge() > 0) ? 0 : 1];
	+ const Particle& lneg = leptons[(leptons[0].threeCharge() < 0) ? 0 : 1];
	+
	+ string label = "N";
	+ if (_mode == 1) {// electron channel
	+ label += "CC"; // only central-central for muons
	+ } else { // electron channel
	+ const double eta1 = lpos.abseta();
	+ const double eta2 = lneg.abseta();
	+ if ( (eta1 < 2.47 && inRange(eta2, 2.5, 4.9)) \|\| (eta2 < 2.47 && inRange(eta1, 2.5, 4.9)) )
	+ label += "CF"; // central-forward
	+ else if (eta1 < 2.47 && eta2 < 2.47)
	+ label += "CC"; // central-central
	+ else vetoEvent; // ain't no forward-forward
	+ }
	+
	+ const double cosThetaStar = cosCollinsSoper(lneg, lpos);
	+ const double mll = (lpos.mom() + lneg.mom()).mass();
	+ label += cosThetaStar < 0.0? "_neg" : "_pos";
	+ _h[label]->fill(mll/GeV, e.weight());
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ const double sf = crossSectionPerEvent() / picobarn;
	+ for (const auto& key_hist : _h) scale(key_hist.second, sf);
	+ divide(_h["NCC_pos"] - _h["NCC_neg"], _h["NCC_pos"] + _h["NCC_neg"], _s["CC"]);
	+ if (!_mode) divide(_h["NCF_pos"] - _h["NCF_neg"], _h["NCF_pos"] + _h["NCF_neg"], _s["CF"]);
	+ }
	+
	+
	+ // Cosine of the decay angle in the Collins-Soper frame
	+ double cosCollinsSoper(const FourMomentum& l1, const FourMomentum& l2) {
	+ const FourMomentum ll = l1 + l2;
	+ const double nom = (l1.E() + l1.pz()) * (l2.E() - l2.pz()) - (l1.E() - l1.pz()) * (l2.E() + l2.pz());
	+ const double denom = ll.mass() * sqrt( sqr(ll.mass()) + sqr(ll.pt()) );
	+ return sign(ll.pz()) * safediv(nom, denom); // protect against division by zero, you never know...
	+ }
	+
	+ //@}
	+
	+
	+ protected:
	+
	+ /// Electron or muon mode = 0 or 1, for use by derived _EL, _MU analysis classes
	+ size_t _mode;
	+
	+
	+ private:
	+
	+ /// Histograms
	+ map<string, Histo1DPtr> _h;
	+ /// Asymmetries
	+ map<string, Scatter2DPtr> _s;
	+
	+ };
	+
	+
	+
	+ class ATLAS_2015_I1351916_EL : public ATLAS_2015_I1351916 {
	+ public:
	+ ATLAS_2015_I1351916_EL() : ATLAS_2015_I1351916("ATLAS_2015_I1351916_EL", 0) { }
	+ };
	+
	+
	+ class ATLAS_2015_I1351916_MU : public ATLAS_2015_I1351916 {
	+ public:
	+ ATLAS_2015_I1351916_MU() : ATLAS_2015_I1351916("ATLAS_2015_I1351916_MU", 1) { }
	+ };
	+
	+
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1351916);
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1351916_EL);
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1351916_MU);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2015_I1364361.cc b/src/Analyses/ATLAS_2015_I1364361.cc
	--- a/src/Analyses/ATLAS_2015_I1364361.cc
	+++ b/src/Analyses/ATLAS_2015_I1364361.cc
	@@ -1,139 +1,137 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief Higgs differential cross-section combination between the ATLAS measurements in the yy and 4l channels
	///
	/// Computes Higgs transverse momentum, rapidity, jet multiplicity and leading jet pT.
	///
	/// @author Michaela Queitsch-Maitland <michaela.queitsch-maitland@cern.ch>
	/// @author Dag Gillberg <dag.gillberg@cern.ch>
	/// @author Florian Bernlochner <florian.bernlochner@cern.ch>
	/// @author Sarah Heim <sarah.heim@cern.ch>
	class ATLAS_2015_I1364361 : public Analysis {
	public:

	/// Constructor
	- ATLAS_2015_I1364361()
	- : Analysis("ATLAS_2015_I1364361")
	- { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1364361);


	/// Book histograms and initialise projections before the run
	void init() {

	// All final state particles
	const FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Histograms with data bins
	_h_pTH_incl = bookHisto1D(1,1,1);
	_h_yH_incl = bookHisto1D(2,1,1);
	_h_Njets_incl = bookHisto1D(3,1,1);
	_h_pTj1_incl = bookHisto1D(4,1,1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Get the final state particles ordered by pT
	- const Particles& fs = applyProjection<FinalState>(event, "FS").particlesByPt();
	+ const Particles& fs = apply<FinalState>(event, "FS").particlesByPt();

	// Find a stable Higgs (mandatory)
	const auto higgsiter = std::find_if(fs.begin(), fs.end(), [](const Particle& p){ return p.pid() == PID::HIGGSBOSON; });
	if (higgsiter == fs.end()) vetoEvent;
	const Particle& higgs = *higgsiter;

	// bool stable_higgs = false;
	// const Particle* higgs = 0;
	// for (const Particle& p : fs) {
	// if (p.pid() == PID::HIGGSBOSON) {
	// stable_higgs = true;
	// higgs = &p;
	// break;
	// }
	// }
	// if (!stable_higgs) {
	// MSG_WARNING("FATAL: No stable Higgs found in event record.\n");
	// vetoEvent;
	// }


	// Loop over final state particles and fill various particle vectors
	Particles leptons, photons, jet_ptcls;
	foreach ( const Particle& ptcl, fs ) {
	// Do not include the Higgs in jet finding!
	if ( ptcl.pid() == PID::HIGGSBOSON ) continue;
	// Neutrinos not from hadronisation
	if ( ptcl.isNeutrino() && !ptcl.fromHadron() ) continue;
	// Electrons and muons not from hadronisation
	if ( ( ptcl.abspid() == PID::ELECTRON \|\| ptcl.abspid() == PID::MUON ) && !ptcl.fromHadron() ) {
	leptons.push_back(ptcl);
	continue;
	}
	// Photons not from hadronisation
	if ( ptcl.abspid() == PID::PHOTON && !ptcl.fromHadron() ) {
	photons.push_back(ptcl);
	continue;
	}
	// Add particle to jet inputs
	jet_ptcls.push_back(ptcl);
	}

	// Match FS photons to leptons within cone R=0.1
	// If they are not 'dressing' photons, add to jet particle vector
	foreach ( const Particle& ph, photons ) {
	bool fsr_photon = false;
	foreach ( const Particle& lep, leptons ) {
	if ( deltaR(ph.momentum(),lep.momentum()) < 0.1 ){
	fsr_photon=true;
	continue;
	}
	}
	if ( !fsr_photon ) jet_ptcls.push_back(ph);
	}

	// Let's build the jets! By hand...
	const PseudoJets pjs_in = mkPseudoJets(jet_ptcls);
	const fastjet::JetDefinition jdef(fastjet::antikt_algorithm, 0.4);
	const Jets alljets = mkJets(fastjet::ClusterSequence(pjs_in, jdef).inclusive_jets());
	const Jets jets = sortByPt(filterBy(alljets, Cuts::pT > 30*GeV && Cuts::absrap < 4.4));
	// FastJets jet_pro(FastJets::ANTIKT, 0.4);
	// jet_pro.calc(jet_ptcls);
	// Jets jets = jet_pro.jetsByPt(Cuts::pT > 30*GeV && Cuts::absrap < 4.4);

	const double weight = event.weight();
	_h_pTH_incl->fill(higgs.pT(), weight);
	_h_yH_incl->fill(higgs.absrap(), weight);
	_h_Njets_incl->fill(jets.size() > 3 ? 3 : jets.size(), weight);
	_h_pTj1_incl->fill(jets.empty() ? 0 : jets[0].pT(), weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double xs = crossSectionPerEvent();
	scale(_h_pTH_incl, xs);
	scale(_h_yH_incl, xs);
	scale(_h_Njets_incl, xs);
	scale(_h_pTj1_incl, xs);
	}


	private:

	Histo1DPtr _h_pTH_incl, _h_yH_incl, _h_Njets_incl, _h_pTj1_incl;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2015_I1364361);


	}
	diff --git a/src/Analyses/ATLAS_2015_I1376945.cc b/src/Analyses/ATLAS_2015_I1376945.cc
	--- a/src/Analyses/ATLAS_2015_I1376945.cc
	+++ b/src/Analyses/ATLAS_2015_I1376945.cc
	@@ -1,220 +1,223 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/PromptFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {

	+
	+ /// @brief Colour flow in hadronic top decay at 8 TeV
	class ATLAS_2015_I1376945 : public Analysis {
	public:

	/// Constructor
	- ATLAS_2015_I1376945()
	- : Analysis("ATLAS_2015_I1376945")
	- { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1376945);


	- public:
	-
	/// @name Analysis methods
	+ //@{

	/// Book histograms and initialise projections before the run
	void init() {

	const FinalState fs;

	PromptFinalState promptFs(fs);
	promptFs.acceptTauDecays(true);
	promptFs.acceptMuonDecays(false);

	IdentifiedFinalState neutrino_fs(promptFs);
	neutrino_fs.acceptNeutrinos();
	- addProjection(neutrino_fs, "NEUTRINO_FS");
	+ declare(neutrino_fs, "NEUTRINO_FS");

	IdentifiedFinalState Photon(fs);
	Photon.acceptIdPair(PID::PHOTON);

	IdentifiedFinalState bare_muons_fs(promptFs);
	bare_muons_fs.acceptIdPair(PID::MUON);

	IdentifiedFinalState bare_elecs_fs(promptFs);
	bare_elecs_fs.acceptIdPair(PID::ELECTRON);

	Cut lep_cuts = (Cuts::abseta < 2.5) & (Cuts::pT > 1*MeV);
	DressedLeptons muons(Photon, bare_muons_fs, 0.1, lep_cuts, true, false);
	- addProjection(muons, "MUONS");
	+ declare(muons, "MUONS");

	DressedLeptons elecs(Photon, bare_elecs_fs, 0.1, lep_cuts, true, false);
	- addProjection(elecs, "ELECS");
	+ declare(elecs, "ELECS");

	VetoedFinalState vfs;
	vfs.addVetoOnThisFinalState(muons);
	vfs.addVetoOnThisFinalState(elecs);
	vfs.addVetoOnThisFinalState(neutrino_fs);

	FastJets fjets(vfs, FastJets::ANTIKT, 0.4);
	fjets.useInvisibles();
	- addProjection(fjets, "jets");
	+ declare(fjets, "jets");

	h_pull_all = bookHisto1D(4,1,1);
	h_pull_charged = bookHisto1D(5,1,1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	/**************
	* JETS *
	**************/
	- const Jets& allJets = applyProjection<FastJets>(event, "jets").jetsByPt(Cuts::pT > 25.0*GeV && Cuts::absrap < 2.5);
	- const vector<DressedLepton>& all_elecs = applyProjection<DressedLeptons>(event, "ELECS").dressedLeptons();
	- const vector<DressedLepton>& all_muons = applyProjection<DressedLeptons>(event, "MUONS").dressedLeptons();
	+ const Jets& allJets = apply<FastJets>(event, "jets").jetsByPt(Cuts::pT > 25.0*GeV && Cuts::absrap < 2.5);
	+ const vector<DressedLepton>& all_elecs = apply<DressedLeptons>(event, "ELECS").dressedLeptons();
	+ const vector<DressedLepton>& all_muons = apply<DressedLeptons>(event, "MUONS").dressedLeptons();
	Jets goodJets;
	foreach (const Jet j, allJets) {
	bool keep = true;
	foreach (const DressedLepton el, all_elecs) keep &= deltaR(j, el) >= 0.2;
	if (keep) goodJets += j;
	}
	if ( goodJets.size() < 4 ) vetoEvent;

	/****************
	* LEPTONS *
	****************/
	vector<DressedLepton> muons, vetoMuons;
	foreach (const DressedLepton mu, all_muons) {
	bool keep = true;
	foreach (const Jet j, goodJets) keep &= deltaR(j, mu) >= 0.4;
	if (keep && mu.pt() > 15*GeV) {
	vetoMuons.push_back(mu);
	if (mu.pt() > 25*GeV) muons.push_back(mu);
	}
	}

	vector<DressedLepton> elecs, vetoElecs;
	foreach (const DressedLepton el, all_elecs) {
	bool keep = true;
	foreach (const Jet j, goodJets) keep &= deltaR(j, el) >= 0.4;
	if (keep && el.pt() > 15*GeV) {
	vetoElecs.push_back(el);
	if (el.pt() > 25*GeV) elecs.push_back(el);
	}
	}

	if (muons.empty() && elecs.empty()) vetoEvent;

	bool muCandidate = !( muons.size() < 1 \|\| vetoMuons.size() > 1 \|\| vetoElecs.size() > 0 );
	bool elCandidate = !( elecs.size() < 1 \|\| vetoElecs.size() > 1 \|\| vetoMuons.size() > 0 );

	if (!elCandidate && !muCandidate) vetoEvent;

	/******************************
	* ELECTRON-MUON OVERLAP *
	******************************/
	foreach (const DressedLepton electron, elecs) {
	foreach (const DressedLepton muon, muons) {
	double d_theta = fabs(muon.theta() - electron.theta());
	double d_phi = deltaPhi(muon.phi(), electron.phi());
	if (d_theta < 0.005 && d_phi < 0.005) vetoEvent;
	}
	}

	/****************
	* NEUTRINOS *
	****************/
	- const Particles& neutrinos = applyProjection<IdentifiedFinalState>(event, "NEUTRINO_FS").particlesByPt();
	+ const Particles& neutrinos = apply<IdentifiedFinalState>(event, "NEUTRINO_FS").particlesByPt();
	FourMomentum metVector = FourMomentum(0.,0.,0.,0.);
	foreach (const Particle& n, neutrinos) {
	metVector += n.momentum();
	}
	double met = metVector.pt();
	if (met <= 20*GeV) vetoEvent;

	if ( (_mT(muCandidate? muons[0] : elecs[0], metVector) + met) <= 60. ) vetoEvent;

	/****************
	* B-JETS *
	****************/
	Jets bJets, wJets;
	foreach(Jet j, goodJets) {
	bool b_tagged = false;
	Particles bTags = j.bTags();
	foreach ( Particle b, bTags ) {
	b_tagged \|= b.pT() > 5*GeV;
	}
	if (b_tagged) bJets += j;
	if (!b_tagged && j.abseta() < 2.1) wJets += j;
	}

	if ( bJets.size() < 2 \|\| wJets.size() < 2 ) vetoEvent;

	double pull_angle = fabs(CalculatePullAngle(wJets[0], wJets[1], 0));
	h_pull_all->fill(pull_angle / Rivet::PI, weight);

	double pull_angle_charged = fabs(CalculatePullAngle(wJets[0], wJets[1], 1));
	h_pull_charged->fill(pull_angle_charged / Rivet::PI, weight);

	}

	Vector3 CalculatePull(Jet& jet, bool &isCharged) {
	Vector3 pull(0.0, 0.0, 0.0);
	double PT = jet.pT();
	Particles& constituents = jet.particles();
	Particles charged_constituents;
	if (isCharged) {
	foreach (Particle p, constituents) {
	if (p.threeCharge() != 0) charged_constituents += p;
	}
	constituents = charged_constituents;
	}
	// calculate axis
	FourMomentum axis;
	foreach (Particle p, constituents) axis += p.momentum();
	Vector3 J(axis.rap(), axis.phi(MINUSPI_PLUSPI), 0.0);
	// calculate pull
	foreach (Particle p, constituents) {
	Vector3 ri = Vector3(p.rap(), p.phi(MINUSPI_PLUSPI), 0.0) - J;
	while (ri.y() > Rivet::PI) ri.setY(ri.y() - Rivet::TWOPI);
	while (ri.y() < -Rivet::PI) ri.setY(ri.y() + Rivet::TWOPI);
	pull.setX(pull.x() + (ri.mod() * ri.x() * p.pT()) / PT);
	pull.setY(pull.y() + (ri.mod() * ri.y() * p.pT()) / PT);
	}
	return pull;
	}

	double CalculatePullAngle(Jet& jet1, Jet& axisjet, bool isCharged) {
	Vector3 pull_vector = CalculatePull(jet1, isCharged);
	pull_vector = Vector3(1000.pull_vector.x(), 1000.pull_vector.y(), 0.);
	double drap = axisjet.rap() - jet1.rap();
	double dphi = axisjet.phi(MINUSPI_PLUSPI) - jet1.phi(MINUSPI_PLUSPI);
	Vector3 j2_vector(drap, dphi, 0.0);
	return mapAngleMPiToPi(deltaPhi(pull_vector, j2_vector));
	}

	double _mT(const FourMomentum &l, FourMomentum &nu) const {
	return sqrt( 2 * l.pT() * nu.pT() * (1 - cos(deltaPhi(l, nu))) );
	}

	/// Normalise histograms etc., after the run
	void finalize() {
	normalize(h_pull_all);
	normalize(h_pull_charged);
	}

	- private:
	+ //@}

	- // Data members like post-cuts event weight counters go here
	+
	+ private:
	+
	Histo1DPtr h_pull_all;
	Histo1DPtr h_pull_charged;

	};

	+
	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2015_I1376945);
	+
	}
	diff --git a/src/Analyses/ATLAS_2015_I1387176.cc b/src/Analyses/ATLAS_2015_I1387176.cc
	--- a/src/Analyses/ATLAS_2015_I1387176.cc
	+++ b/src/Analyses/ATLAS_2015_I1387176.cc
	@@ -1,93 +1,92 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {

	/// Rivet analysis class for ATLAS_2015_I1387176 dataset
	class ATLAS_2015_I1387176 : public Analysis {
	public:

	/// Constructor
	- ATLAS_2015_I1387176()
	- : Analysis("ATLAS_2015_I1387176") { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1387176);


	/// Initialization, called once before running
	void init() {
	// Projections
	FastJets jets(FinalState(), FastJets::ANTIKT, 0.4);
	jets.useInvisibles();
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	// Book histograms
	_hist_EEC = bookHisto1D(1, 1, 1);
	_hist_AEEC = bookScatter2D(2, 1, 1);

	// add dummy histogram for heterogenous merging
	string hname = "d01-x01-y01";
	const Scatter2D& ref = refData(hname);
	hname = "d01-x01-y02";
	_hist_dummy = bookHisto1D(hname, ref);
	}

	void analyze(const Event& event) {

	const double evtWeight = event.weight();
	- const Jets& jets = applyProjection<FastJets>(event, "Jets").jetsByPt(Cuts::pT > 50.0*GeV && Cuts::abseta < 2.5);
	+ const Jets& jets = apply<FastJets>(event, "Jets").jetsByPt(Cuts::pT > 50.0*GeV && Cuts::abseta < 2.5);

	if (jets.size() < 2) vetoEvent;
	if (jets[0].pT() + jets[1].pT() < 500*GeV) vetoEvent;

	double sumEt = 0.0;
	foreach (Jet j, jets) sumEt += j.E() / cosh(j.eta());

	foreach (Jet j1, jets) {
	double et1 = j1.E() / cosh(j1.eta());

	foreach (Jet j2, jets) {
	double et2 = j2.E() / cosh(j2.eta());
	double etWeight = et1 * et2 / ( sumEt * sumEt );
	double dPhi = deltaPhi(j1, j2);
	double cosPhi = cos(dPhi);
	if (cosPhi == 1.0) cosPhi = 0.9999;

	_hist_EEC->fill(cosPhi, etWeight * evtWeight);
	_hist_dummy->fill(cosPhi, etWeight * evtWeight);
	}
	}
	}

	void finalize() {

	scale(_hist_dummy, crossSectionPerEvent());
	normalize(_hist_EEC);

	vector<Point2D> points;
	size_t nBins = _hist_EEC->numBins();
	for (size_t k = 0; k < nBins/2; ++k) {
	double x = _hist_EEC->bin(k).midpoint();
	double y = _hist_EEC->bin(k).height() - _hist_EEC->bin(nBins-(k+1)).height();
	double ex = _hist_EEC->bin(k).xWidth()/2;
	double e1 = _hist_EEC->bin(k).heightErr();
	double e2 = _hist_EEC->bin(nBins-(k+1)).heightErr();
	double ey = sqrt( e1 * e1 + e2 * e2 );
	points.push_back(Point2D(x, y, ex, ey));
	}

	_hist_AEEC->addPoints(points);
	}

	private:
	Histo1DPtr _hist_EEC;
	Histo1DPtr _hist_dummy;
	Scatter2DPtr _hist_AEEC;
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2015_I1387176);

	}
	diff --git a/src/Analyses/ATLAS_2015_I1390114.cc b/src/Analyses/ATLAS_2015_I1390114.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2015_I1390114.cc
	@@ -0,0 +1,170 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/VetoedFinalState.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/DressedLeptons.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+
	+ // ATLAS $tt+b(b)$ at 8~TeV
	+ class ATLAS_2015_I1390114 : public Analysis {
	+ public:
	+
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1390114);
	+
	+
	+ void init() {
	+
	+ // Eta ranges
	+ Cut eta_full = Cuts::abseta < 5.0 && Cuts::pT >= 1.0*MeV;
	+ Cut eta_lep = Cuts::abseta < 2.5;
	+
	+ // All final state particles
	+ FinalState fs(eta_full);
	+
	+ // Get photons to dress leptons
	+ IdentifiedFinalState photons(fs);
	+ photons.acceptIdPair(PID::PHOTON);
	+
	+ // Projection to find the electrons
	+ IdentifiedFinalState el_id(fs);
	+ el_id.acceptIdPair(PID::ELECTRON);
	+ PromptFinalState electrons(el_id);
	+ electrons.acceptTauDecays(true);
	+ declare(electrons, "electrons");
	+ DressedLeptons dressedelectrons(photons, electrons, 0.1, eta_lep && (Cuts::pT >= 25*GeV), true, true);
	+ declare(dressedelectrons, "dressedelectrons");
	+ DressedLeptons ewdressedelectrons(photons, electrons, 0.1, eta_full, true, true);
	+
	+ // Projection to find the muons
	+ IdentifiedFinalState mu_id(fs);
	+ mu_id.acceptIdPair(PID::MUON);
	+ PromptFinalState muons(mu_id);
	+ muons.acceptTauDecays(true);
	+ declare(muons, "muons");
	+ DressedLeptons dressedmuons(photons, muons, 0.1, eta_lep && (Cuts::pT >= 25*GeV), true, true);
	+ declare(dressedmuons, "dressedmuons");
	+ DressedLeptons ewdressedmuons(photons, muons, 0.1, eta_full, true, true);
	+
	+ // Projection to find neutrinos and produce MET
	+ IdentifiedFinalState nu_id;
	+ nu_id.acceptNeutrinos();
	+ PromptFinalState neutrinos(nu_id);
	+ neutrinos.acceptTauDecays(true);
	+
	+ // Jet clustering.
	+ VetoedFinalState vfs;
	+ vfs.addVetoOnThisFinalState(ewdressedelectrons);
	+ vfs.addVetoOnThisFinalState(ewdressedmuons);
	+ vfs.addVetoOnThisFinalState(neutrinos);
	+ FastJets jets(vfs,FastJets::ANTIKT, 0.4);
	+ jets.useInvisibles();
	+ declare(jets, "jets");
	+
	+ _histo = bookHisto1D(1,1,1);
	+ _ratio = bookScatter2D(2,1,1, true);
	+ _aux = bookHisto1D("_aux", 1, 0.5, 1.5);
	+ }
	+
	+
	+ void analyze(const Event& event) {
	+
	+ const double weight = event.weight();
	+
	+ // Get the selected objects, using the projections.
	+ vector<DressedLepton> electrons = apply<DressedLeptons>(event, "dressedelectrons").dressedLeptons();
	+ vector<DressedLepton> muons = apply<DressedLeptons>(event, "dressedmuons").dressedLeptons();
	+ if (electrons.empty() && muons.empty()) vetoEvent;
	+
	+ Jets jets = apply<FastJets>(event, "jets").jets((Cuts::pT>20*GeV) && (Cuts::abseta < 2.5), cmpMomByPt);
	+ Jets bjets;
	+
	+ // Check overlap of jets/leptons.
	+ foreach (Jet jet, jets) {
	+ // if dR(el,jet) < 0.4 skip the event
	+ foreach (DressedLepton el, electrons) {
	+ if (deltaR(jet, el) < 0.4) vetoEvent;
	+ }
	+ // if dR(mu,jet) < 0.4 skip the event
	+ foreach (DressedLepton mu, muons) {
	+ if (deltaR(jet, mu) < 0.4) vetoEvent;
	+ }
	+ // Count the number of b-tags
	+ // We have to check that the ghost-matched B hadrons have pT > 5 GeV
	+ // By default jet.bTags() returns all B hadrons without cuts
	+ bool btagged = jet.bTags(Cuts::pT >= 5*GeV).size();
	+ if (btagged) bjets += jet;
	+ }
	+
	+ // Evaluate basic event selection
	+ bool pass_1lep = (electrons.size() == 1 && muons.empty()) \|\| (muons.size() == 1 && electrons.empty());
	+ if (pass_1lep && bjets.size() >= 3 && jets.size() >= 5) _histo->fill(1, weight);
	+
	+ if (muons.size() == 1 && electrons.size() == 1 && bjets.size() >= 3) {
	+ if (muons[0].charge() * electrons[0].charge() < 0.0) _histo->fill(2, weight);
	+ }
	+
	+ DressedLepton lep1 = NULL, lep2 = NULL;
	+ bool zveto = false;
	+ if (electrons.size() == 2 && muons.empty()) {
	+ lep1 = &electrons[0];
	+ lep2 = &electrons[1];
	+ }
	+ else if (muons.size() == 2 && electrons.empty()) {
	+ lep1 = &muons[0];
	+ lep2 = &muons[1];
	+ }
	+ else if (electrons.size() == 1 && muons.size() == 1) {
	+ lep1 = &electrons[0];
	+ lep2 = &muons[0];
	+ zveto = true;
	+ }
	+ if (lep1 && lep2 && lep1->charge() * lep2->charge() < 0.0 && bjets.size() >= 2) {
	+ double mass = (lep1->momentum() + lep2->momentum()).mass();
	+ bool pass_2lep = mass > 15GeV && (zveto \|\| !(mass > 81GeV && mass < 101*GeV));
	+ if ( pass_2lep && bjets.size() >= 4) {
	+ _histo->fill(3, weight);
	+ _histo->fill(4, weight);
	+ }
	+ if ( pass_2lep && jets.size() >= 4) {
	+ _aux->fill(1, weight);
	+ }
	+ }
	+ }
	+
	+
	+ void finalize() {
	+ const double sf(crossSection()/sumOfWeights()/femtobarn);
	+ scale(_histo, sf);
	+ scale(_aux, sf);
	+
	+ // construct ratio
	+ const double n = _histo->bin(3).sumW();
	+ const double dN = _histo->bin(3).sumW2();
	+ const double d = _aux->bin(0).sumW();
	+ const double dD = _aux->bin(0).sumW2();
	+ const double r = safediv(n, d);
	+ double e = sqrt( safediv(r * (1 - r), d) );
	+ if ( _aux->effNumEntries() != _aux->numEntries() ) {
	+ // use F. James's approximation for weighted events:
	+ e = sqrt( safediv((1 - 2 * r) * dN + r * r * dD, d * d) );
	+ }
	+ _ratio->point(0).setY(100.0 * r, 100.0 * e); // convert into percentage
	+ }
	+
	+
	+ private:
	+
	+ Histo1DPtr _histo, _aux;
	+ Scatter2DPtr _ratio;
	+
	+ };
	+
	+
	+ // Hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1390114);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2015_I1393758.cc b/src/Analyses/ATLAS_2015_I1393758.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2015_I1393758.cc
	@@ -0,0 +1,143 @@
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+ class ATLAS_2015_I1393758 : public Analysis {
	+
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1393758);
	+
	+ public:
	+
	+ void init() {
	+
	+ addProjection(FastJets(FinalState(), FastJets::ANTIKT, 0.4), "Jets");
	+
	+ forward_kappa3 = bookProfile1D(1, 1, 1);
	+ forward_kappa5 = bookProfile1D(2, 1, 1);
	+ forward_kappa7 = bookProfile1D(3, 1, 1);
	+
	+ central_kappa3 = bookProfile1D(4, 1, 1);
	+ central_kappa5 = bookProfile1D(5, 1, 1);
	+ central_kappa7 = bookProfile1D(6, 1, 1);
	+
	+ forwardRMS_kappa3 = bookScatter2D("d07-x01-y01", true);
	+ forwardRMS_kappa5 = bookScatter2D("d08-x01-y01", true);
	+ forwardRMS_kappa7 = bookScatter2D("d09-x01-y01", true);
	+
	+ centralRMS_kappa3 = bookScatter2D("d10-x01-y01", true);
	+ centralRMS_kappa5 = bookScatter2D("d11-x01-y01", true);
	+ centralRMS_kappa7 = bookScatter2D("d12-x01-y01", true);
	+
	+ }
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+ const double weight = event.weight();
	+
	+ Jets m_goodJets = applyProjection<JetAlg>(event, "Jets").jetsByPt(Cuts::pT > 25*GeV && Cuts::abseta < 2.1);
	+
	+ if (m_goodJets.size() < 2) vetoEvent;
	+ if (m_goodJets[0].pT() < 50*GeV) vetoEvent;
	+ if (m_goodJets[1].pT() < 50*GeV) vetoEvent;
	+ if (fabs(1.0 - m_goodJets[0].pT()/m_goodJets[1].pT()) > 0.5) vetoEvent;
	+
	+ bool check = m_goodJets[0].abseta() < m_goodJets[1].abseta();
	+ int pos_f = int(check);
	+ int pos_c = int(!check);
	+
	+ double kappa3_f = CalculateJetCharge(m_goodJets[pos_f], 0.3, 0.5, 1.8);
	+ double kappa5_f = CalculateJetCharge(m_goodJets[pos_f], 0.5, 0.5, 1.2);
	+ double kappa7_f = CalculateJetCharge(m_goodJets[pos_f], 0.7, 0.5, 0.9);
	+ double pT_f = m_goodJets[pos_f].pT();
	+
	+ double kappa3_c = CalculateJetCharge(m_goodJets[pos_c], 0.3, 0.5, 1.8);
	+ double kappa5_c = CalculateJetCharge(m_goodJets[pos_c], 0.5, 0.5, 1.2);
	+ double kappa7_c = CalculateJetCharge(m_goodJets[pos_c], 0.7, 0.5, 0.9);
	+ double pT_c = m_goodJets[pos_c].pT();
	+
	+ forward_kappa3->fill(pT_f, kappa3_f, weight);
	+ forward_kappa5->fill(pT_f, kappa5_f, weight);
	+ forward_kappa7->fill(pT_f, kappa7_f, weight);
	+
	+ central_kappa3->fill(pT_c, kappa3_c, weight);
	+ central_kappa5->fill(pT_c, kappa5_c, weight);
	+ central_kappa7->fill(pT_c, kappa7_c, weight);
	+ }
	+
	+ double CalculateJetCharge(Jet& jet, double kappa=0.5, double pTcut=0.5, double Qmax=1.2) {
	+ double PTkap = pow(jet.momentum().pT(),kappa);
	+ double jetcharge = 0.;
	+ foreach (const Particle& p, jet.particles()) {
	+ if (p.pT() < pTcut) continue;
	+ if (p.threeCharge()) jetcharge += (p.threeCharge()/3.)*pow(p.pT(),kappa)/PTkap;
	+ }
	+ //Overflow and underflow
	+ if (jetcharge > Qmax) jetcharge = Qmax*0.9999;
	+ if (jetcharge < -Qmax) jetcharge = -Qmax*0.9999;
	+ return jetcharge;
	+ }
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ if (numEvents() > 2) {
	+ for (unsigned int i = 0; i < forward_kappa3->numBins(); ++i) {
	+ double stdv_fkappa3 = forward_kappa3->bin(i).numEntries() > 1? forward_kappa3->bin(i).stdDev() : 0.0;
	+ //See Eq. 3 for the factor of two: https://web.eecs.umich.edu/~fessler/papers/files/tr/stderr.pdf
	+ double yerr_fkappa3 = safediv(sqrt(forward_kappa3->bin(i).sumW2()), 2.*forward_kappa3->bin(i).sumW());
	+ forwardRMS_kappa3->point(i).setY(stdv_fkappa3, yerr_fkappa3);
	+
	+ double stdv_fkappa5 = forward_kappa5->bin(i).numEntries() > 1? forward_kappa5->bin(i).stdDev() : 0.0;
	+ double yerr_fkappa5 = safediv(sqrt(forward_kappa5->bin(i).sumW2()), 2.*forward_kappa5->bin(i).sumW());
	+ forwardRMS_kappa5->point(i).setY(stdv_fkappa5, yerr_fkappa5);
	+
	+ double stdv_fkappa7 = forward_kappa7->bin(i).numEntries() > 1? forward_kappa7->bin(i).stdDev() : 0.0;
	+ double yerr_fkappa7 = safediv(sqrt(forward_kappa7->bin(i).sumW2()), 2.*forward_kappa7->bin(i).sumW());
	+ forwardRMS_kappa7->point(i).setY(stdv_fkappa7, yerr_fkappa7);
	+
	+ double stdv_ckappa3 = central_kappa3->bin(i).numEntries() > 1? central_kappa3->bin(i).stdDev() : 0.0;
	+ double yerr_ckappa3 = safediv(sqrt(central_kappa3->bin(i).sumW2()), 2.*central_kappa3->bin(i).sumW());
	+ centralRMS_kappa3->point(i).setY(stdv_ckappa3, yerr_ckappa3);
	+
	+ double stdv_ckappa5 = central_kappa5->bin(i).numEntries() > 1? central_kappa5->bin(i).stdDev() : 0.0;
	+ double yerr_ckappa5 = safediv(sqrt(central_kappa5->bin(i).sumW2()), 2.*central_kappa5->bin(i).sumW());
	+ centralRMS_kappa5->point(i).setY(stdv_ckappa5, yerr_ckappa5);
	+
	+ double stdv_ckappa7 = central_kappa7->bin(i).numEntries() > 1? central_kappa7->bin(i).stdDev() : 0.0;
	+ double yerr_ckappa7 = safediv(sqrt(central_kappa7->bin(i).sumW2()), 2.*central_kappa7->bin(i).sumW());
	+ centralRMS_kappa7->point(i).setY(stdv_ckappa7, yerr_ckappa7);
	+
	+ }
	+ }
	+
	+ }
	+
	+
	+ private:
	+
	+ Profile1DPtr forward_kappa3;
	+ Profile1DPtr forward_kappa5;
	+ Profile1DPtr forward_kappa7;
	+
	+ Profile1DPtr central_kappa3;
	+ Profile1DPtr central_kappa5;
	+ Profile1DPtr central_kappa7;
	+
	+ Scatter2DPtr forwardRMS_kappa3;
	+ Scatter2DPtr forwardRMS_kappa5;
	+ Scatter2DPtr forwardRMS_kappa7;
	+
	+ Scatter2DPtr centralRMS_kappa3;
	+ Scatter2DPtr centralRMS_kappa5;
	+ Scatter2DPtr centralRMS_kappa7;
	+
	+ };
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1393758);
	+}
	diff --git a/src/Analyses/ATLAS_2015_I1394679.cc b/src/Analyses/ATLAS_2015_I1394679.cc
	--- a/src/Analyses/ATLAS_2015_I1394679.cc
	+++ b/src/Analyses/ATLAS_2015_I1394679.cc
	@@ -1,205 +1,203 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// Differential multijet cross-section measurement in different variables
	class ATLAS_2015_I1394679 : public Analysis {
	public:

	/// Constructor
	- ATLAS_2015_I1394679()
	- : Analysis("ATLAS_2015_I1394679")
	- { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1394679);


	/// @name Analysis methods
	//@

	/// Book histograms and initialise projections before the run
	void init() {

	// Initialise and register projections here
	const FinalState fs;
	- addProjection(fs, "FinalState");
	+ declare(fs, "FinalState");
	FastJets fj04(fs, FastJets::ANTIKT, 0.4, JetAlg::ALL_MUONS, JetAlg::DECAY_INVISIBLES);
	- addProjection(fj04, "AntiKt4jets");
	+ declare(fj04, "AntiKt4jets");

	// Histograms
	_h["pt1"] = bookHisto1D(1, 1, 1);
	_h["pt2"] = bookHisto1D(2, 1, 1);
	_h["pt3"] = bookHisto1D(3, 1, 1);
	_h["pt4"] = bookHisto1D(4, 1, 1);
	_h["HT"] = bookHisto1D(5, 1, 1);
	_h["M4j"] = bookHisto1D(6, 1, 1);

	// Histograms with different pt/m4j cuts
	for (size_t i_hist = 0; i_hist < 4; ++i_hist) {
	_h["M2jratio_"+to_str(i_hist)] = bookHisto1D( 7 + i_hist, 1, 1);
	_h["dPhiMin2j_"+to_str(i_hist)] = bookHisto1D(11 + i_hist, 1, 1);
	_h["dPhiMin3j_"+to_str(i_hist)] = bookHisto1D(15 + i_hist, 1, 1);
	_h["dYMin2j_"+to_str(i_hist)] = bookHisto1D(19 + i_hist, 1, 1);
	_h["dYMin3j_"+to_str(i_hist)] = bookHisto1D(23 + i_hist, 1, 1);
	_h["dYMax2j_"+to_str(i_hist)] = bookHisto1D(27 + i_hist, 1, 1);
	for (size_t ygap = 0; ygap < 4; ++ygap) {
	_h["sumPtCent_"+to_str(ygap)+to_str(i_hist)] = bookHisto1D(31 + i_hist + ygap * 4, 1, 1);
	}
	}

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	- const Jets& alljetskt4 = applyProjection<FastJets>(event, "AntiKt4jets").jetsByPt(Cuts::pT > 60*GeV && Cuts::absrap < 2.8);
	+ const Jets& alljetskt4 = apply<FastJets>(event, "AntiKt4jets").jetsByPt(Cuts::pT > 60*GeV && Cuts::absrap < 2.8);

	// Require 4 jets with rap < 2.8 and passing pT cuts
	int nJets = alljetskt4.size();
	if (nJets < 4) vetoEvent;
	Jets leadingJetskt4 = alljetskt4; leadingJetskt4.resize(4);
	Jet jet1(leadingJetskt4[0]), jet2(leadingJetskt4[1]), jet3(leadingJetskt4[2]), jet4(leadingJetskt4[3]);
	if (jet1.pT() < 100*GeV) vetoEvent;
	if (jet4.pT() < 64*GeV) vetoEvent;

	// dR cut
	const double dRcut = 0.65;
	double drmin = 9999;
	for (int ijet = 0; ijet < 4; ++ijet) {
	for (int jjet = ijet + 1; jjet < 4; ++jjet) {
	double myDR = deltaR(alljetskt4[ijet], alljetskt4[jjet], RAPIDITY);
	if (myDR < drmin) drmin = myDR;
	}
	}
	if (drmin < dRcut) vetoEvent;

	// Variables for calculation in loops over jets
	FourMomentum sum_alljets;
	double HT = 0; // scalar sum of pt of 4 leading jets
	double Mjj = 99999; // minimum combined mass of 2 jets
	double minDphi_ij = 999, minDphi_ijk = 999; // minimum azimuthal distance btw 2 & 3 jets
	double maxDrap_ij = -999; // maximum rapidity distance btw 2 jets
	double minDrap_ij = 999, minDrap_ijk = 999; // minimum rapidity distance btw 2 & 3 jets
	size_t maxY_i = -1, maxY_j = -1;

	// Loop over 4 leading jets
	for (size_t ij = 0; ij< 4; ++ij) {
	Jet& jeti = leadingJetskt4.at(ij);
	sum_alljets += jeti.mom();
	HT += jeti.pT();

	for (size_t jj = 0; jj< 4; ++jj) {
	if ( ij == jj ) continue;
	Jet& jetj = leadingJetskt4.at(jj);

	const double auxDphi = fabs(deltaPhi(jeti, jetj));
	minDphi_ij = std::min(auxDphi, minDphi_ij);

	const double auxDrap = fabs(deltaRap(jeti, jetj));
	minDrap_ij = std::min(auxDrap, minDrap_ij);
	if (auxDrap > maxDrap_ij) {
	maxDrap_ij = auxDrap;
	maxY_i = ij;
	maxY_j = jj;
	}

	FourMomentum sum_twojets = jeti.mom() + jetj.mom();
	Mjj = std::min(Mjj, sum_twojets.mass());

	for (size_t kj = 0; kj < 4; ++kj) {
	if (kj == ij \|\| kj == jj) continue;
	Jet& jetk = leadingJetskt4.at(kj);

	const double auxDphi2 = auxDphi + fabs(deltaPhi(jeti, jetk));
	minDphi_ijk = std::min(auxDphi2, minDphi_ijk);

	const double auxDrap2 = auxDrap + fabs(deltaRap(jeti, jetk));
	minDrap_ijk = std::min(auxDrap2, minDrap_ijk);
	}
	}
	} //end loop over 4 leading jets


	// Combined mass of 4 leading jets
	const double Mjjjj = sum_alljets.mass();

	// Sum of central jets pT
	double sumpt_twojets_cent = 0; // Scalar sum pt of central jets, with different rapidity gaps
	for (size_t ijet = 0; ijet < 4; ++ijet) {
	if (ijet == maxY_i \|\| ijet == maxY_j) continue; // these are the forward jets
	sumpt_twojets_cent += leadingJetskt4.at(ijet).pT();
	}


	// Fill histos
	// Mass and pT cuts in which the analysis tables are split; values are in GeV and cuts are inclusive
	const double m4jcuts[4] = {500, 1000, 1500, 2000};
	const double pt1cutA[4] = {100, 400, 700, 1000};
	const double pt1cutB[4] = {100, 250, 400, 550};
	const double rapGapCut[4] = {1, 2, 3, 4};
	const double weight = event.weight();

	_h["pt1"]->fill(jet1.pt(), weight);
	_h["pt2"]->fill(jet2.pt(), weight);
	_h["pt3"]->fill(jet3.pt(), weight);
	_h["pt4"]->fill(jet4.pt(), weight);
	_h["HT"] ->fill(HT, weight);
	_h["M4j"]->fill(Mjjjj, weight);

	for (size_t i_cut = 0; i_cut < 4; ++i_cut) {
	const string icutstr = to_str(i_cut);

	if (Mjjjj > m4jcuts[i_cut])
	_h["M2jratio_"+icutstr]->fill( Mjj/Mjjjj , weight);

	if (jet1.pT() > pt1cutA[i_cut]) {
	_h["dPhiMin2j_"+icutstr]->fill(minDphi_ij , weight);
	_h["dPhiMin3j_"+icutstr]->fill(minDphi_ijk, weight);
	_h["dYMin2j_"+icutstr]->fill(minDrap_ij , weight);
	_h["dYMin3j_"+icutstr]->fill(minDrap_ijk, weight);
	}

	if (jet1.pt() > pt1cutB[i_cut]) {
	_h["dYMax2j_"+icutstr]->fill( maxDrap_ij , weight);
	for (size_t yy = 0; yy < 4; ++yy) {
	if (maxDrap_ij > rapGapCut[yy])
	_h["sumPtCent_"+to_str(yy)+icutstr]->fill(sumpt_twojets_cent, weight);
	}
	}

	} //end loop over pt/m4j cuts

	}



	/// Normalise histograms etc., after the run
	void finalize() {
	const double sf = crossSection() / sumOfWeights();
	/// @todo Migrate to C++11 range-for loop
	for (map<string, Histo1DPtr>::iterator hit = _h.begin(); hit != _h.end(); ++hit) {
	scale(hit->second, sf);
	}
	}

	//@


	private:

	/// @name Histograms
	//@{
	map<string, Histo1DPtr> _h;
	//@}


	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(ATLAS_2015_I1394679);

	}
	diff --git a/src/Analyses/ATLAS_2015_I1397635.cc b/src/Analyses/ATLAS_2015_I1397635.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2015_I1397635.cc
	@@ -0,0 +1,135 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/VetoedFinalState.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/DressedLeptons.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// $Wt$ at 8 TeV
	+ class ATLAS_2015_I1397635 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1397635);
	+
	+
	+ void init() {
	+
	+ // Eta ranges
	+ Cut eta_full = Cuts::abseta < 5.0 && Cuts::pT >= 1.0*MeV;
	+ Cut eta_lep = Cuts::abseta < 2.5;
	+
	+ // All final state particles
	+ FinalState fs(eta_full);
	+
	+ // Get photons to dress leptons
	+ IdentifiedFinalState photons(fs);
	+ photons.acceptIdPair(PID::PHOTON);
	+
	+ // Projection to find the electrons
	+ IdentifiedFinalState el_id(fs);
	+ el_id.acceptIdPair(PID::ELECTRON);
	+ PromptFinalState electrons(el_id);
	+ electrons.acceptTauDecays(true);
	+ declare(electrons, "electrons");
	+ DressedLeptons dressedelectrons(photons, electrons, 0.1, eta_lep && Cuts::pT >= 25*GeV, true, true);
	+ declare(dressedelectrons, "dressedelectrons");
	+ DressedLeptons ewdressedelectrons(photons, electrons, 0.1, eta_full, true, true);
	+
	+ // Projection to find the muons
	+ IdentifiedFinalState mu_id(fs);
	+ mu_id.acceptIdPair(PID::MUON);
	+ PromptFinalState muons(mu_id);
	+ muons.acceptTauDecays(true);
	+ declare(muons, "muons");
	+ DressedLeptons dressedmuons(photons, muons, 0.1, eta_lep && Cuts::pT >= 25*GeV, true, true);
	+ declare(dressedmuons, "dressedmuons");
	+ DressedLeptons ewdressedmuons(photons, muons, 0.1, eta_full, true, true);
	+
	+ // Projection to find neutrinos and produce MET
	+ IdentifiedFinalState nu_id;
	+ nu_id.acceptNeutrinos();
	+ PromptFinalState neutrinos(nu_id);
	+ neutrinos.acceptTauDecays(true);
	+ declare(neutrinos, "neutrinos");
	+
	+
	+ // Jet clustering.
	+ VetoedFinalState vfs;
	+ vfs.addVetoOnThisFinalState(ewdressedelectrons);
	+ vfs.addVetoOnThisFinalState(ewdressedmuons);
	+ vfs.addVetoOnThisFinalState(neutrinos);
	+ FastJets jets(vfs,FastJets::ANTIKT, 0.4);
	+ jets.useInvisibles();
	+ declare(jets, "jets");
	+
	+ _histo = bookHisto1D(1,1,1);
	+ }
	+
	+
	+ void analyze(const Event& event) {
	+
	+ // Get the selected objects, using the projections.
	+ vector<DressedLepton> electrons = apply<DressedLeptons>(event, "dressedelectrons").dressedLeptons();
	+ vector<DressedLepton> muons = apply<DressedLeptons>(event, "dressedmuons").dressedLeptons();
	+ // also make basic event selection cuts for leptons
	+ if (electrons.empty() && muons.empty()) vetoEvent;
	+ if (electrons.size() + muons.size() != 2) vetoEvent;
	+
	+ // next selection cuts for jets
	+ const Jets jets = apply<FastJets>(event, "jets").jets(Cuts::pT>20*GeV && Cuts::abseta < 2.5, cmpMomByPt);
	+ if (jets.size() != 1) vetoEvent;
	+
	+ // and selection cuts for b-tagging
	+ Jets bjets;
	+ // Check overlap of jets/leptons.
	+ foreach (Jet jet, jets) {
	+ // if dR(el,jet) < 0.4 skip the event
	+ foreach (DressedLepton el, electrons) {
	+ if (deltaR(jet, el) < 0.4) vetoEvent;
	+ }
	+ // if dR(mu,jet) < 0.4 skip the event
	+ foreach (DressedLepton mu, muons) {
	+ if (deltaR(jet, mu) < 0.4) vetoEvent;
	+ }
	+ // Count the number of b-tags
	+ // We have to check that the ghost-matched B hadrons have pT > 5 GeV
	+ // By default jet.bTags() returns all B hadrons without cuts
	+ bool btagged = jet.bTags(Cuts::pT >= 5*GeV).size();
	+ if (btagged) bjets += jet;
	+ }
	+ if (bjets.size() != 1) vetoEvent;
	+
	+ // Now evaluate MET selection
	+ // Get the neutrinos from the event record (they have pT > 0.0 and \|eta\| < 4.5 at this stage
	+ const Particles& neutrinos = apply<PromptFinalState>(event, "neutrinos").particlesByPt();
	+ FourMomentum met;
	+ foreach (const Particle& nu, neutrinos) met += nu.momentum();
	+ if (met.pT() <= 20*GeV) vetoEvent;
	+
	+ // Make the plot
	+ _histo->fill(1, event.weight());
	+ }
	+
	+
	+ // Normalise histograms etc., after the run
	+ void finalize() {
	+ scale(_histo, crossSection() / femtobarn / sumOfWeights());
	+ }
	+
	+
	+ private:
	+
	+ Histo1DPtr _histo;
	+
	+ };
	+
	+
	+ // Hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1397635);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2015_I1397637.cc b/src/Analyses/ATLAS_2015_I1397637.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2015_I1397637.cc
	@@ -0,0 +1,218 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+#include "Rivet/Projections/VetoedFinalState.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/DressedLeptons.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+
	+ class ATLAS_2015_I1397637 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1397637);
	+
	+
	+ /// Book projections and histograms
	+ void init() {
	+
	+ // Base final state definition
	+ const FinalState fs(Cuts::abseta < 4.5);
	+
	+ // Neutrinos for MET
	+ IdentifiedFinalState nu_id;
	+ nu_id.acceptNeutrinos();
	+ PromptFinalState neutrinos(nu_id);
	+ neutrinos.acceptTauDecays(true);
	+ declare(neutrinos, "neutrinos");
	+
	+ // Get photons used to dress leptons
	+ IdentifiedFinalState photons(fs);
	+ photons.acceptId(PID::PHOTON);
	+
	+ // Use all bare muons as input to the DressedMuons projection
	+ IdentifiedFinalState mu_id(fs);
	+ mu_id.acceptIdPair(PID::MUON);
	+ PromptFinalState bare_mu(mu_id);
	+ bare_mu.acceptTauDecays(true);
	+
	+ // Use all bare electrons as input to the DressedElectrons projection
	+ IdentifiedFinalState el_id(fs);
	+ el_id.acceptIdPair(PID::ELECTRON);
	+ PromptFinalState bare_el(el_id);
	+ bare_el.acceptTauDecays(true);
	+
	+ // Use all bare leptons including taus for single-lepton filter
	+ IdentifiedFinalState lep_id(fs);
	+ lep_id.acceptIdPair(PID::MUON);
	+ lep_id.acceptIdPair(PID::ELECTRON);
	+ PromptFinalState bare_lep(lep_id);
	+ declare(bare_lep, "bare_lep");
	+
	+ // Tau finding
	+ /// @todo Use TauFinder
	+ UnstableFinalState ufs;
	+ IdentifiedFinalState tau_id(ufs);
	+ tau_id.acceptIdPair(PID::TAU);
	+ PromptFinalState bare_tau(tau_id);
	+ declare(bare_tau, "bare_tau");
	+
	+ // Muons and electrons must have \|eta\| < 2.5
	+ Cut eta_ranges = Cuts::abseta < 2.5;
	+
	+ // Get dressed muons and the good muons (pt>25GeV)
	+ DressedLeptons all_dressed_mu(photons, bare_mu, 0.1, eta_ranges, true, true);
	+ DressedLeptons dressed_mu(photons, bare_mu, 0.1, eta_ranges & (Cuts::pT > 25.0*GeV), true, true);
	+ declare(dressed_mu, "muons");
	+
	+ // Get dressed electrons and the good electrons (pt>25GeV)
	+ DressedLeptons all_dressed_el(photons, bare_el, 0.1, eta_ranges, true, true);
	+ DressedLeptons dressed_el(photons, bare_el, 0.1, eta_ranges & (Cuts::pT > 25.0*GeV), true, true);
	+ declare(dressed_el, "electrons");
	+
	+ // Jet clustering
	+ VetoedFinalState vfs(fs);
	+ vfs.addVetoOnThisFinalState(all_dressed_el);
	+ vfs.addVetoOnThisFinalState(all_dressed_mu);
	+ vfs.addVetoOnThisFinalState(neutrinos);
	+
	+ // Small-R jets
	+ /// @todo Use extra constructor args
	+ FastJets jets(vfs, FastJets::ANTIKT, 0.4);
	+ jets.useInvisibles(JetAlg::ALL_INVISIBLES);
	+ jets.useMuons(JetAlg::DECAY_MUONS);
	+ declare(jets, "jets");
	+
	+ // Large-R jets
	+ /// @todo Use extra constructor args
	+ FastJets large_jets(vfs, FastJets::ANTIKT, 1.0);
	+ large_jets.useInvisibles(JetAlg::ALL_INVISIBLES);
	+ large_jets.useMuons(JetAlg::DECAY_MUONS);
	+ declare(large_jets, "fat_jets");
	+
	+
	+ /// Book histogram
	+ _h_pttop = bookHisto1D(1, 1, 1);
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Single lepton filter on bare leptons with no cuts
	+ const Particles& bare_lep = apply<PromptFinalState>(event, "bare_lep").particles();
	+ const Particles& bare_tau = apply<PromptFinalState>(event, "bare_tau").particles();
	+ if (bare_lep.size() + bare_tau.size() != 1) vetoEvent;
	+
	+ // Electrons and muons
	+ const vector<DressedLepton>& electrons = apply<DressedLeptons>(event, "electrons").dressedLeptons();
	+ const vector<DressedLepton>& muons = apply<DressedLeptons>(event, "muons").dressedLeptons();
	+ if (electrons.size() + muons.size() != 1) vetoEvent;
	+ const DressedLepton& lepton = muons.empty() ? electrons[0] : muons[0];
	+
	+ // Get the neutrinos from the event record (they have pT > 0.0 and \|eta\| < 4.5 at this stage
	+ const Particles& neutrinos = apply<PromptFinalState>(event, "neutrinos").particlesByPt();
	+ FourMomentum met;
	+ for (const Particle& nu : neutrinos) met += nu.momentum();
	+ if (met.pT() < 20*GeV) vetoEvent;
	+
	+
	+ // Thin jets and trimmed fat jets
	+ /// @todo Use Rivet built-in FJ trimming support
	+ const Jets& jets = apply<FastJets>(event, "jets").jetsByPt(Cuts::pT > 25*GeV && Cuts::abseta < 2.5);
	+ const PseudoJets& fat_pjets = apply<FastJets>(event, "fat_jets").pseudoJetsByPt();
	+ const double Rfilt = 0.3, ptFrac_min = 0.05; ///< @todo Need to be careful about the units for the pT cut passed to FJ?
	+ PseudoJets trimmed_fat_pjets;
	+ fastjet::Filter trimmer(fastjet::JetDefinition(fastjet::kt_algorithm, Rfilt), fastjet::SelectorPtFractionMin(ptFrac_min));
	+ for (const PseudoJet& pjet : fat_pjets) trimmed_fat_pjets += trimmer(pjet);
	+ trimmed_fat_pjets = fastjet::sorted_by_pt(trimmed_fat_pjets);
	+
	+ // Jet reclustering
	+ // Use a kT cluster sequence to recluster the trimmed jets so that a d12 can then be obtained from the reclustered jet
	+ vector<double> splittingScales;
	+ for (const PseudoJet& tpjet : trimmed_fat_pjets) {
	+ const PseudoJets tpjet_constits = tpjet.constituents();
	+ const fastjet::ClusterSequence kt_cs(tpjet_constits, fastjet::JetDefinition(fastjet::kt_algorithm, 1.5, fastjet::E_scheme, fastjet::Best));
	+ const PseudoJets kt_jets = kt_cs.inclusive_jets();
	+ const double d12 = 1.5 * sqrt(kt_jets[0].exclusive_subdmerge(1));
	+ splittingScales += d12;
	+ }
	+ Jets trimmed_fat_jets;
	+ for (size_t i = 0; i < trimmed_fat_pjets.size(); ++i) {
	+ const Jet tj = trimmed_fat_pjets[i];
	+ if (tj.mass() <= 100*GeV) continue;
	+ if (tj.pT() <= 300*GeV) continue;
	+ if (splittingScales[i] <= 40*GeV) continue;
	+ if (tj.abseta() >= 2.0) continue;
	+ trimmed_fat_jets += tj;
	+ }
	+ if (trimmed_fat_jets.empty()) vetoEvent;
	+
	+ // Jet b-tagging
	+ Jets bjets, non_bjets;
	+ for (const Jet& jet : jets)
	+ (jet.bTagged() ? bjets : non_bjets) += jet;
	+ if (bjets.empty()) vetoEvent;
	+
	+
	+ // Boosted selection: lepton/jet overlap
	+ const double transmass = sqrt( 2 * lepton.pT() * met.pT() * (1 - cos(deltaPhi(lepton, met))) );
	+ if (transmass + met.pt() <= 60*GeV) vetoEvent;
	+ int lepJetIndex = -1;
	+ for (size_t i = 0; i < jets.size(); ++i) {
	+ const Jet& jet = jets[i];
	+ if (deltaR(jet, lepton) < 1.5) {
	+ lepJetIndex = i;
	+ break;
	+ }
	+ }
	+ if (lepJetIndex < 0) vetoEvent;
	+ const Jet& ljet = jets[lepJetIndex];
	+
	+ // Boosted selection: lepton-jet/fat-jet matching
	+ int fatJetIndex = -1;
	+ for (size_t j = 0; j < trimmed_fat_jets.size(); ++j) {
	+ const Jet& fjet = trimmed_fat_jets[j];
	+ const double dR_fatjet = deltaR(ljet, fjet);
	+ const double dPhi_fatjet = deltaPhi(lepton, fjet);
	+ if (dR_fatjet > 1.5 && dPhi_fatjet > 2.3) {
	+ fatJetIndex = j;
	+ break;
	+ }
	+ }
	+ if (fatJetIndex < 0) vetoEvent;
	+ const Jet& fjet = trimmed_fat_jets[fatJetIndex];
	+
	+ // Boosted selection: b-tag matching
	+ const bool lepbtag = ljet.bTagged();
	+ bool hadbtag = false;
	+ for (const Jet& bjet : bjets) {
	+ hadbtag \|= (deltaR(fjet, bjet) < 1.0);
	+ }
	+
	+ // Fill histo if selection passed
	+ if (hadbtag \|\| lepbtag) _h_pttop->fill(fjet.pT()/GeV, event.weight());
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ scale(_h_pttop, crossSection()/femtobarn / sumOfWeights());
	+ }
	+
	+
	+ private:
	+
	+ Histo1DPtr _h_pttop;
	+
	+ };
	+
	+
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1397637);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2015_I1404878.cc b/src/Analyses/ATLAS_2015_I1404878.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2015_I1404878.cc
	@@ -0,0 +1,256 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/VetoedFinalState.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/DressedLeptons.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/VisibleFinalState.hh"
	+
	+namespace Rivet {
	+
	+ class ATLAS_2015_I1404878 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2015_I1404878);
	+
	+ void init() {
	+ // Eta ranges
	+ Cut eta_full = (Cuts::abseta < 4.2) & (Cuts::pT >= 1.0*MeV);
	+ Cut lep_cuts = (Cuts::abseta < 2.5) && (Cuts::pT > 25*GeV);
	+
	+ // All final state particles
	+ FinalState fs(eta_full);
	+
	+ // Get photons to dress leptons
	+ IdentifiedFinalState photons(fs);
	+ photons.acceptIdPair(PID::PHOTON);
	+
	+ // Projection to find the electrons
	+ IdentifiedFinalState el_id(fs);
	+ el_id.acceptIdPair(PID::ELECTRON);
	+
	+ PromptFinalState electrons(el_id);
	+ electrons.acceptTauDecays(true);
	+ declare(electrons, "electrons");
	+
	+ DressedLeptons dressedelectrons(photons, electrons, 0.1, lep_cuts, true, true);
	+ declare(dressedelectrons, "dressedelectrons");
	+
	+ DressedLeptons ewdressedelectrons(photons, electrons, 0.1, eta_full, true, true);
	+ declare(ewdressedelectrons, "ewdressedelectrons");
	+
	+ // Projection to find the muons
	+ IdentifiedFinalState mu_id(fs);
	+ mu_id.acceptIdPair(PID::MUON);
	+
	+ PromptFinalState muons(mu_id);
	+ muons.acceptTauDecays(true);
	+ declare(muons, "muons");
	+
	+ DressedLeptons dressedmuons(photons, muons, 0.1, lep_cuts, true, true);
	+ declare(dressedmuons, "dressedmuons");
	+
	+ DressedLeptons ewdressedmuons(photons, muons, 0.1, eta_full, true, true);
	+ declare(ewdressedmuons, "ewdressedmuons");
	+
	+ // Projection to find neutrinos
	+ IdentifiedFinalState nu_id;
	+ nu_id.acceptNeutrinos();
	+ PromptFinalState neutrinos(nu_id);
	+ neutrinos.acceptTauDecays(true);
	+
	+ // get MET from generic invisibles
	+ VetoedFinalState inv_fs(fs);
	+ inv_fs.addVetoOnThisFinalState(VisibleFinalState(fs));
	+ declare(inv_fs, "InvisibleFS");
	+
	+ // Jet clustering.
	+ VetoedFinalState vfs;
	+ vfs.addVetoOnThisFinalState(ewdressedelectrons);
	+ vfs.addVetoOnThisFinalState(ewdressedmuons);
	+ vfs.addVetoOnThisFinalState(neutrinos);
	+ FastJets jets(vfs, FastJets::ANTIKT, 0.4);
	+ jets.useInvisibles(true);
	+ declare(jets, "jets");
	+
	+ // Histogram booking
	+ _h["massttbar"] = bookHisto1D( 1, 1, 1);
	+ _h["massttbar_norm"] = bookHisto1D( 2, 1, 1);
	+ _h["ptttbar"] = bookHisto1D( 3, 1, 1);
	+ _h["ptttbar_norm"] = bookHisto1D( 4, 1, 1);
	+ _h["absrapttbar"] = bookHisto1D( 5, 1, 1);
	+ _h["absrapttbar_norm"] = bookHisto1D( 6, 1, 1);
	+ _h["ptpseudotophadron"] = bookHisto1D( 7, 1, 1);
	+ _h["ptpseudotophadron_norm"] = bookHisto1D( 8, 1, 1);
	+ _h["absrappseudotophadron"] = bookHisto1D( 9, 1, 1);
	+ _h["absrappseudotophadron_norm"] = bookHisto1D(10, 1, 1);
	+ _h["absPout"] = bookHisto1D(11, 1, 1);
	+ _h["absPout_norm"] = bookHisto1D(12, 1, 1);
	+ _h["dPhittbar"] = bookHisto1D(13, 1, 1);
	+ _h["dPhittbar_norm"] = bookHisto1D(14, 1, 1);
	+ _h["HTttbar"] = bookHisto1D(15, 1, 1);
	+ _h["HTttbar_norm"] = bookHisto1D(16, 1, 1);
	+ _h["Yboost"] = bookHisto1D(17, 1, 1);
	+ _h["Yboost_norm"] = bookHisto1D(18, 1, 1);
	+ _h["chittbar"] = bookHisto1D(19, 1, 1);
	+ _h["chittbar_norm"] = bookHisto1D(20, 1, 1);
	+ _h["RWt"] = bookHisto1D(21, 1, 1);
	+ _h["RWt_norm"] = bookHisto1D(22, 1, 1);
	+
	+ }
	+
	+ void analyze(const Event& event) {
	+
	+ const double weight = event.weight();
	+
	+ // Get the selected objects, using the projections.
	+ vector<DressedLepton> electrons = applyProjection<DressedLeptons>(event, "dressedelectrons").dressedLeptons();
	+ vector<DressedLepton> muons = applyProjection<DressedLeptons>(event, "dressedmuons").dressedLeptons();
	+ const Jets& jets = applyProjection<FastJets>(event, "jets").jetsByPt(Cuts::pT > 25*GeV && Cuts::abseta < 2.5);
	+ const FinalState& ifs = applyProjection<FinalState>(event, "InvisibleFS");
	+
	+ // Calculate MET
	+ FourMomentum met;
	+ foreach (const Particle& p, ifs.particles()) met += p.momentum();
	+
	+ // Count the number of b-tags
	+ Jets bjets, lightjets;
	+ foreach (const Jet& jet, jets){
	+ bool b_tagged = jet.bTags(Cuts::pT > 5*GeV).size();
	+ if ( b_tagged && bjets.size() < 2 ) bjets += jet;
	+ else lightjets += jet;
	+ }
	+
	+ bool single_electron = (electrons.size() == 1) && (muons.empty());
	+ bool single_muon = (muons.size() == 1) && (electrons.empty());
	+
	+ DressedLepton *lepton = NULL;
	+ if (single_electron) lepton = &electrons[0];
	+ else if (single_muon) lepton = &muons[0];
	+
	+ if(!single_electron && !single_muon) vetoEvent;
	+ if (jets.size() < 4 \|\| bjets.size() < 2) vetoEvent;
	+
	+ FourMomentum pbjet1; //Momentum of bjet1
	+ FourMomentum pbjet2; //Momentum of bjet2
	+ if ( deltaR(bjets[0], lepton) <= deltaR(bjets[1], lepton) ) {
	+ pbjet1 = bjets[0].momentum();
	+ pbjet2 = bjets[1].momentum();
	+ } else {
	+ pbjet1 = bjets[1].momentum();
	+ pbjet2 = bjets[0].momentum();
	+ }
	+
	+
	+ double bestWmass = 1000.0*TeV;
	+ double mWPDG = 80.399*GeV;
	+ int Wj1index = -1, Wj2index = -1;
	+ for (unsigned int i = 0; i < (lightjets.size() - 1); ++i) {
	+ for (unsigned int j = i + 1; j < lightjets.size(); ++j) {
	+ double wmass = (lightjets[i].momentum() + lightjets[j].momentum()).mass();
	+ if (fabs(wmass - mWPDG) < fabs(bestWmass - mWPDG)) {
	+ bestWmass = wmass;
	+ Wj1index = i;
	+ Wj2index = j;
	+ }
	+ }
	+ }
	+
	+ // compute hadronic W boson
	+ FourMomentum pWhadron = lightjets[Wj1index].momentum() + lightjets[Wj2index].momentum();
	+ double pz = computeneutrinoz(lepton->momentum(), met);
	+ FourMomentum ppseudoneutrino( sqrt(sqr(met.px()) + sqr(met.py()) + sqr(pz)), met.px(), met.py(), pz);
	+
	+
	+ //compute leptonic, hadronic, combined pseudo-top
	+ FourMomentum ppseudotoplepton = lepton->momentum() + ppseudoneutrino + pbjet1;
	+ FourMomentum ppseudotophadron = pbjet2 + pWhadron;
	+ FourMomentum pttbar = ppseudotoplepton + ppseudotophadron;
	+
	+ Vector3 z_versor(0,0,1);
	+ Vector3 vpseudotophadron = ppseudotophadron.vector3();
	+ Vector3 vpseudotoplepton = ppseudotoplepton.vector3();
	+ // Observables
	+ double ystar = 0.5 * deltaRap(ppseudotophadron, ppseudotoplepton);
	+ double chi_ttbar = exp(2 * fabs(ystar));
	+ double deltaPhi_ttbar = deltaPhi(ppseudotoplepton,ppseudotophadron);
	+ double HT_ttbar = ppseudotophadron.pt() + ppseudotoplepton.pt();
	+ double Yboost = 0.5 * fabs(ppseudotophadron.rapidity() + ppseudotoplepton.rapidity());
	+ double R_Wt = pWhadron.pt() / ppseudotophadron.pt();
	+ double absPout = fabs(vpseudotophadron.dot((vpseudotoplepton.cross(z_versor))/(vpseudotoplepton.cross(z_versor).mod())));
	+
	+ // absolute cross sections
	+ _h["ptpseudotophadron"]->fill( ppseudotophadron.pt(), weight); //pT of pseudo top hadron
	+ _h["ptttbar"]->fill( pttbar.pt(), weight); //fill pT of ttbar in combined channel
	+ _h["absrappseudotophadron"]->fill(ppseudotophadron.absrap(), weight);
	+ _h["absrapttbar"]->fill( pttbar.absrap(), weight);
	+ _h["massttbar"]->fill( pttbar.mass(), weight);
	+ _h["absPout"]->fill( absPout, weight);
	+ _h["chittbar"]->fill( chi_ttbar, weight);
	+ _h["dPhittbar"]->fill( deltaPhi_ttbar, weight);
	+ _h["HTttbar"]->fill( HT_ttbar, weight);
	+ _h["Yboost"]->fill( Yboost, weight);
	+ _h["RWt"]->fill( R_Wt, weight);
	+ // normalised cross sections
	+ _h["ptpseudotophadron_norm"]->fill( ppseudotophadron.pt(), weight); //pT of pseudo top hadron
	+ _h["ptttbar_norm"]->fill( pttbar.pt(), weight); //fill pT of ttbar in combined channel
	+ _h["absrappseudotophadron_norm"]->fill(ppseudotophadron.absrap(), weight);
	+ _h["absrapttbar_norm"]->fill( pttbar.absrap(), weight);
	+ _h["massttbar_norm"]->fill( pttbar.mass(), weight);
	+ _h["absPout_norm"]->fill( absPout, weight);
	+ _h["chittbar_norm"]->fill( chi_ttbar, weight);
	+ _h["dPhittbar_norm"]->fill( deltaPhi_ttbar, weight);
	+ _h["HTttbar_norm"]->fill( HT_ttbar, weight);
	+ _h["Yboost_norm"]->fill( Yboost, weight);
	+ _h["RWt_norm"]->fill( R_Wt, weight);
	+
	+ }
	+
	+ void finalize() {
	+ // Normalize to cross-section
	+ const double sf = (crossSection() / sumOfWeights());
	+ for (map<string, Histo1DPtr>::iterator hit = _h.begin(); hit != _h.end(); ++hit) {
	+ scale(hit->second, sf);
	+ if (hit->first.find("_norm") != string::npos) normalize(hit->second);
	+ }
	+ }
	+
	+ private:
	+
	+
	+ double computeneutrinoz(const FourMomentum& lepton, FourMomentum& met) const {
	+ //computing z component of neutrino momentum given lepton and met
	+ double pzneutrino;
	+ double m_W = 80.399; // in GeV, given in the paper
	+ double k = (( sqr( m_W ) - sqr( lepton.mass() ) ) / 2 ) + (lepton.px() * met.px() + lepton.py() * met.py());
	+ double a = sqr ( lepton.E() )- sqr ( lepton.pz() );
	+ double b = -2klepton.pz();
	+ double c = sqr( lepton.E() ) * sqr( met.pT() ) - sqr( k );
	+ double discriminant = sqr(b) - 4 * a * c;
	+ double quad[2] = { (- b - sqrt(discriminant)) / (2 * a), (- b + sqrt(discriminant)) / (2 * a) }; //two possible quadratic solns
	+ if (discriminant < 0) pzneutrino = - b / (2 * a); //if the discriminant is negative
	+ else { //if the discriminant is greater than or equal to zero, take the soln with smallest absolute value
	+ double absquad[2];
	+ for (int n=0; n<2; ++n) absquad[n] = fabs(quad[n]);
	+ if (absquad[0] < absquad[1]) pzneutrino = quad[0];
	+ else pzneutrino = quad[1];
	+ }
	+
	+ return pzneutrino;
	+ }
	+
	+ double _mT(const FourMomentum &l, FourMomentum &nu) const {
	+ return sqrt( 2 * l.pT() * nu.pT() * (1 - cos(deltaPhi(l, nu))) );
	+ }
	+
	+ /// @name Objects that are used by the event selection decisions
	+ map<string, Histo1DPtr> _h;
	+ };
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1404878);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2015_I1408516.cc b/src/Analyses/ATLAS_2015_I1408516.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2015_I1408516.cc
	@@ -0,0 +1,245 @@
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/ZFinder.hh"
	+
	+namespace Rivet {
	+
	+
	+ class ATLAS_2015_I1408516 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ ATLAS_2015_I1408516(string name="ATLAS_2015_I1408516", size_t mode=0)
	+ : Analysis(name), _mode(mode) // using electron channel for combined data
	+ { }
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Configure projections
	+ FinalState fs;
	+ Cut cuts = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;
	+ ZFinder zfinder_el(fs, cuts, (_mode ? PID::MUON : PID::ELECTRON),
	+ 12GeV, 150GeV, 0.1, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);
	+ declare(zfinder_el, "ZFinder");
	+
	+ // Book histograms
	+ const size_t offset = _mode ? 4 : 1;
	+
	+ _h["phistar_lo_00_08"] = bookHisto1D( 2, 1, offset);
	+ _h["phistar_lo_08_16"] = bookHisto1D( 3, 1, offset);
	+ _h["phistar_lo_16_24"] = bookHisto1D( 4, 1, offset);
	+
	+ _h["phistar_me_00_04"] = bookHisto1D( 5, 1, offset);
	+ _h["phistar_me_04_08"] = bookHisto1D( 6, 1, offset);
	+ _h["phistar_me_08_12"] = bookHisto1D( 7, 1, offset);
	+ _h["phistar_me_12_16"] = bookHisto1D( 8, 1, offset);
	+ _h["phistar_me_16_20"] = bookHisto1D( 9, 1, offset);
	+ _h["phistar_me_20_24"] = bookHisto1D(10, 1, offset);
	+
	+ _h["phistar_hi_00_08"] = bookHisto1D(11, 1, offset);
	+ _h["phistar_hi_08_16"] = bookHisto1D(12, 1, offset);
	+ _h["phistar_hi_16_24"] = bookHisto1D(13, 1, offset);
	+
	+ _h["phistar_mll_46_66" ] = bookHisto1D(14, 1, offset);
	+ _h["phistar_mll_66_116" ] = bookHisto1D(15, 1, offset);
	+ _h["phistar_mll_116_150"] = bookHisto1D(16, 1, offset);
	+
	+ _h["zpt_00_04"] = bookHisto1D(17, 1, offset);
	+ _h["zpt_04_08"] = bookHisto1D(18, 1, offset);
	+ _h["zpt_08_12"] = bookHisto1D(19, 1, offset);
	+ _h["zpt_12_16"] = bookHisto1D(20, 1, offset);
	+ _h["zpt_16_20"] = bookHisto1D(21, 1, offset);
	+ _h["zpt_20_24"] = bookHisto1D(22, 1, offset);
	+
	+ _h["zpt_mll_12_20" ] = bookHisto1D(23, 1, offset);
	+ _h["zpt_mll_20_30" ] = bookHisto1D(24, 1, offset);
	+ _h["zpt_mll_30_46" ] = bookHisto1D(25, 1, offset);
	+ _h["zpt_mll_46_66" ] = bookHisto1D(26, 1, offset);
	+ _h["zpt_mll_66_116" ] = bookHisto1D(27, 1, offset);
	+ _h["zpt_mll_116_150"] = bookHisto1D(28, 1, offset);
	+
	+ _h["zpt_00_04_xsec"] = bookHisto1D(29, 1, offset);
	+ _h["zpt_04_08_xsec"] = bookHisto1D(30, 1, offset);
	+ _h["zpt_08_12_xsec"] = bookHisto1D(31, 1, offset);
	+ _h["zpt_12_16_xsec"] = bookHisto1D(32, 1, offset);
	+ _h["zpt_16_20_xsec"] = bookHisto1D(33, 1, offset);
	+ _h["zpt_20_24_xsec"] = bookHisto1D(34, 1, offset);
	+
	+ _h["zpt_mll_12_20_xsec" ] = bookHisto1D(35, 1, offset);
	+ _h["zpt_mll_20_30_xsec" ] = bookHisto1D(36, 1, offset);
	+ _h["zpt_mll_30_46_xsec" ] = bookHisto1D(37, 1, offset);
	+ _h["zpt_mll_46_66_xsec" ] = bookHisto1D(38, 1, offset);
	+ _h["zpt_mll_66_116_xsec" ] = bookHisto1D(39, 1, offset);
	+ _h["zpt_mll_116_150_xsec"] = bookHisto1D(40, 1, offset);
	+
	+ _h["mll_xsec"] = bookHisto1D(41, 1, 1 + _mode);
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get leptonic Z boson
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");
	+ if (zfinder.bosons().size() != 1 ) vetoEvent;
	+ const Particle& Zboson = zfinder.boson();
	+
	+ // Get/cut on heavily used Z boson properties
	+ const double zpt = Zboson.pT();
	+ const double zrap = Zboson.absrap();
	+ const double zmass = Zboson.mass();
	+ if (zrap > 2.4) vetoEvent;
	+
	+ // Get/cut on Z boson leptons
	+ const ParticleVector& leptons = zfinder.constituents();
	+ if (leptons.size() != 2 \|\| leptons[0].threeCharge() * leptons[1].threeCharge() > 0) vetoEvent;
	+ const Particle& lminus = leptons[0].charge() < 0 ? leptons[0] : leptons[1];
	+ const Particle& lplus = leptons[0].charge() < 0 ? leptons[1] : leptons[0];
	+
	+ // Compute phi*
	+ const double phi_acop = M_PI - deltaPhi(lminus, lplus);
	+ const double costhetastar = tanh( 0.5 * (lminus.eta() - lplus.eta()) );
	+ const double sin2thetastar = (costhetastar > 1) ? 0.0 : (1.0 - sqr(costhetastar));
	+ const double phistar = tan(0.5 * phi_acop) * sqrt(sin2thetastar);
	+
	+ // Event weight for histogramming
	+ const double weight = event.weight();
	+
	+ // Inclusive mll
	+ if (zmass > 46GeV \|\| zpt > 45GeV) {
	+ // 46 GeV < mll < 150 GeV OR (12 GeV < mll < 46 GeV AND ZpT >45 GeV)
	+ _h["mll_xsec"]->fill(zmass, weight);
	+ }
	+
	+ // 12 GeV < mll < 150 GeV observables
	+ if (zmass < 20*GeV) {
	+ // 12 GeV < mll < 20 GeV
	+ if (zpt > 45*GeV) { // ZpT cut only for low-mass regions
	+ _h["zpt_mll_12_20_xsec"]->fill(zpt, weight);
	+ _h["zpt_mll_12_20" ]->fill(zpt, weight);
	+ }
	+ } else if (zmass < 30*GeV) {
	+ // 20 GeV < mll < 30 GeV
	+ if (zpt > 45*GeV) { // ZpT cut only for low-mass regions
	+ _h["zpt_mll_20_30_xsec"]->fill(zpt, weight);
	+ _h["zpt_mll_20_30" ]->fill(zpt, weight);
	+ }
	+ } else if (zmass < 46*GeV) {
	+ // 30 GeV < mll < 46 GeV
	+ if (zpt > 45*GeV) { // ZpT cut only for low-mass regions
	+ _h["zpt_mll_30_46_xsec"]->fill(zpt, weight);
	+ _h["zpt_mll_30_46" ]->fill(zpt, weight);
	+ }
	+ } else if (zmass < 66*GeV) {
	+ // 46 GeV < mll < 66 GeV
	+ _h["zpt_mll_46_66_xsec"]->fill(zpt, weight);
	+ _h["zpt_mll_46_66" ]->fill(zpt, weight);
	+
	+ _h["phistar_mll_46_66"]->fill(phistar, weight);
	+ if (zrap < 0.8) _h["phistar_lo_00_08"]->fill(phistar, weight);
	+ else if (zrap < 1.6) _h["phistar_lo_08_16"]->fill(phistar, weight);
	+ else _h["phistar_lo_16_24"]->fill(phistar, weight);
	+
	+ } else if (zmass < 116*GeV) {
	+ // 66 GeV < mll < 116 GeV
	+ _h["zpt_mll_66_116_xsec"]->fill(zpt, weight);
	+ _h["zpt_mll_66_116" ]->fill(zpt, weight);
	+
	+ if (zrap < 0.4) {
	+ _h["zpt_00_04_xsec"]->fill(zpt, weight);
	+ _h["zpt_00_04"]->fill(zpt, weight);
	+ } else if (zrap < 0.8) {
	+ _h["zpt_04_08_xsec"]->fill(zpt, weight);
	+ _h["zpt_04_08"]->fill(zpt, weight);
	+ } else if (zrap < 1.2) {
	+ _h["zpt_08_12_xsec"]->fill(zpt, weight);
	+ _h["zpt_08_12"]->fill(zpt, weight);
	+ } else if (zrap < 1.6) {
	+ _h["zpt_12_16_xsec"]->fill(zpt, weight);
	+ _h["zpt_12_16"]->fill(zpt, weight);
	+ } else if (zrap < 2.0) {
	+ _h["zpt_16_20_xsec"]->fill(zpt, weight);
	+ _h["zpt_16_20"]->fill(zpt, weight);
	+ } else {
	+ _h["zpt_20_24_xsec"]->fill(zpt, weight);
	+ _h["zpt_20_24"]->fill(zpt, weight);
	+ }
	+
	+ _h["phistar_mll_66_116"]->fill(phistar, weight);
	+ if (zrap < 0.4) _h["phistar_me_00_04"]->fill(phistar, weight);
	+ else if (zrap < 0.8) _h["phistar_me_04_08"]->fill(phistar, weight);
	+ else if (zrap < 1.2) _h["phistar_me_08_12"]->fill(phistar, weight);
	+ else if (zrap < 1.6) _h["phistar_me_12_16"]->fill(phistar, weight);
	+ else if (zrap < 2.0) _h["phistar_me_16_20"]->fill(phistar, weight);
	+ else _h["phistar_me_20_24"]->fill(phistar, weight);
	+
	+ } else {
	+
	+ // 116 GeV < mll < 150 GeV
	+ _h["zpt_mll_116_150_xsec"]->fill(zpt, weight);
	+ _h["zpt_mll_116_150" ]->fill(zpt, weight);
	+
	+ _h["phistar_mll_116_150"]->fill(phistar, weight);
	+ if (zrap < 0.8) _h["phistar_hi_00_08"]->fill(phistar, weight);
	+ else if (zrap < 1.6) _h["phistar_hi_08_16"]->fill(phistar, weight);
	+ else _h["phistar_hi_16_24"]->fill(phistar, weight);
	+
	+ }
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ // Scale non-xsec plots to cross-section
	+ const double sf = crossSection() / picobarn / sumOfWeights();
	+ for (const auto& key_hist : _h) {
	+ scale(key_hist.second, sf);
	+ if (!contains(key_hist.first, "_xsec")) normalize(key_hist.second);
	+ }
	+
	+ // M(ll) plot isn't a differential cross section so shouldn't be divided by bin width
	+ for (size_t i = 0; i < 6; ++i) {
	+ double bw = _h["mll_xsec"]->bin(i).xWidth();
	+ _h["mll_xsec"]->bin(i).scaleW(bw);
	+ }
	+ }
	+ //@}
	+
	+
	+ protected:
	+
	+ size_t _mode;
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ map<string, Histo1DPtr> _h;
	+ //@}
	+
	+ };
	+
	+
	+
	+ class ATLAS_2015_I1408516_EL : public ATLAS_2015_I1408516 {
	+ public:
	+ ATLAS_2015_I1408516_EL() : ATLAS_2015_I1408516("ATLAS_2015_I1408516_EL", 0) { }
	+ };
	+
	+ class ATLAS_2015_I1408516_MU : public ATLAS_2015_I1408516 {
	+ public:
	+ ATLAS_2015_I1408516_MU() : ATLAS_2015_I1408516("ATLAS_2015_I1408516_MU", 1) { }
	+ };
	+
	+
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1408516);
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1408516_EL);
	+ DECLARE_RIVET_PLUGIN(ATLAS_2015_I1408516_MU);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_CONF_2016_037.cc b/src/Analyses/ATLAS_2016_CONF_2016_037.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_CONF_2016_037.cc
	@@ -0,0 +1,203 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/Sphericity.hh"
	+#include "Rivet/Projections/SmearedParticles.hh"
	+#include "Rivet/Projections/SmearedJets.hh"
	+#include "Rivet/Projections/SmearedMET.hh"
	+#include "Rivet/Tools/Cutflow.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief ATLAS 2016 2 -SS-lepton / 3-lepton SUSY search, from 13.2/fb CONF note
	+ class ATLAS_2016_CONF_2016_037 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_CONF_2016_037);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ FinalState calofs(Cuts::abseta < 4.9);
	+ declare(calofs, "Clusters");
	+ FastJets fj(calofs, FastJets::ANTIKT, 0.4);
	+ declare(fj, "TruthJets");
	+ declare(SmearedJets(fj, JET_SMEAR_ATLAS_RUN2, [](const Jet& j) {
	+ if (j.abseta() > 2.5) return 0.;
	+ return j.bTagged(Cuts::pT > 5*GeV) ? 0.70 :
	+ j.cTagged(Cuts::pT > 5*GeV) ? 1/12. :
	+ j.tauTagged(Cuts::pT > 5*GeV) ? 1/54. : 1/380.; }), "Jets");
	+
	+ MissingMomentum mm(calofs);
	+ declare(mm, "TruthMET");
	+ declare(SmearedMET(mm, MET_SMEAR_ATLAS_RUN2), "MET");
	+
	+ FinalState es(Cuts::abspid == PID::ELECTRON && Cuts::abseta < 2.47 && !Cuts::absetaIn(1.37, 1.52) && Cuts::pT > 10*GeV);
	+ declare(es, "TruthElectrons");
	+ declare(SmearedParticles(es, ELECTRON_EFF_ATLAS_RUN2, ELECTRON_SMEAR_ATLAS_RUN2), "Electrons");
	+
	+ FinalState mus(Cuts::abspid == PID::MUON && Cuts::abseta < 2.5 && Cuts::pT > 10*GeV);
	+ declare(mus, "TruthMuons");
	+ declare(SmearedParticles(mus, MUON_EFF_ATLAS_RUN2, MUON_SMEAR_ATLAS_RUN2), "Muons");
	+
	+ ChargedFinalState cfs(Cuts::abseta < 2.5);
	+ declare(cfs, "TruthTracks");
	+ declare(SmearedParticles(cfs, TRK_EFF_ATLAS_RUN2), "Tracks");
	+
	+
	+ // Book histograms/counters
	+ _h_3l1 = bookCounter("SR3l1");
	+ _h_3l2 = bookCounter("SR3l2");
	+ _h_0b1 = bookCounter("SR0b1");
	+ _h_0b2 = bookCounter("SR0b2");
	+ _h_1b = bookCounter("SR1b");
	+ _h_3b = bookCounter("SR3b");
	+ _h_1bDD = bookCounter("SR1bDD");
	+ _h_3bDD = bookCounter("SR3bDD");
	+ _h_1bGG = bookCounter("SR1bGG");
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get baseline electrons, muons, and jets
	+ Particles elecs = apply<ParticleFinder>(event, "Electrons").particlesByPt();
	+ Particles muons = apply<ParticleFinder>(event, "Muons").particlesByPt();
	+ Jets jets = apply<JetAlg>(event, "Jets").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.8);
	+ const Jets bjets = filter_select(jets, [&](const Jet& j) { return j.bTagged(Cuts::pT > 5*GeV); });
	+
	+
	+ // Jet/electron/muon overlap removal and selection
	+ // Remove any electron or muon within dR = 0.2 of a b-tagged jet
	+ for (const Jet& bj : bjets) {
	+ ifilter_discard(elecs, deltaRLess(bj, 0.2, RAPIDITY));
	+ ifilter_discard(muons, deltaRLess(bj, 0.2, RAPIDITY));
	+ }
	+ // Remove any untagged jet within dR = 0.2 of an electron or muon
	+ for (const Particle& e : elecs)
	+ ifilter_discard(jets, deltaRLess(e, 0.2, RAPIDITY));
	+ for (const Particle& m : muons)
	+ ifilter_discard(jets, deltaRLess(m, 0.2, RAPIDITY));
	+ // Remove any untagged low-multiplicity/muon-dominated jet within dR = 0.4 of a muon
	+ for (const Particle& m : muons)
	+ ifilter_discard(jets, [&](const Jet& j) {
	+ if (deltaR(m, j, RAPIDITY) > 0.4) return false;
	+ const Particles trks = j.particles(Cuts::abscharge != 0);
	+ if (trks.size() < 3) return true;
	+ return m.pT()/j.pT() > 0.5 && m.pT()/sum(trks, pT, 0.0) > 0.7;
	+ });
	+ // Remove any electron or muon near a remaining jet, with a shrinking cone
	+ const auto lcone_iso_fn = [&](const Particle& l) {
	+ const double dr = min(0.4, 0.04 + 10*GeV/l.pT());
	+ return any(jets, deltaRLess(l, dr, RAPIDITY));
	+ };
	+ ifilter_discard(elecs, lcone_iso_fn);
	+ ifilter_discard(muons, lcone_iso_fn);
	+ // Track-sharing e,mu also filtered, but that decision can't be made here
	+ const Jets& sigjets = jets;
	+ const Jets& sigbjets = bjets;
	+
	+
	+ // Lepton isolation
	+ Particles sigelecs = filter_select(elecs, Cuts::abseta < 2);
	+ Particles sigmuons = muons;
	+ ifilter_select(sigelecs, ParticleEffFilter(ELECTRON_IDEFF_ATLAS_RUN2_MEDIUM));
	+ const Particles trks = apply<ParticleFinder>(event, "Tracks").particles();
	+ const Particles clus = apply<ParticleFinder>(event, "Clusters").particles();
	+ ifilter_discard(sigelecs, [&](const Particle& e) {
	+ const double R = min(0.2, 10*GeV/e.pT());
	+ double ptsum = -e.pT(), etsum = -e.Et();
	+ for (const Particle& t : trks)
	+ if (deltaR(t,e) < R) ptsum += t.pT();
	+ for (const Particle& c : clus)
	+ if (deltaR(c,e) < 0.2) etsum += c.pT(); ///< @todo Bit vague about "energy"
	+ return ptsum / e.pT() > 0.06 \|\| etsum / e.pT() > 0.06;
	+ });
	+ ifilter_discard(sigmuons, [&](const Particle& m) {
	+ const double R = min(0.3, 10*GeV/m.pT());
	+ double ptsum = -m.pT();
	+ for (const Particle& t : trks)
	+ if (deltaR(t,m) < R) ptsum += t.pT();
	+ return ptsum / m.pT() > 0.06;
	+ });
	+ /// @todo Note is vague about whether "signal lepton" defn includes pT > 20?
	+ ifilter_discard(sigelecs, Cuts::pT > 20*GeV);
	+ ifilter_discard(sigmuons, Cuts::pT > 20*GeV);
	+
	+
	+ // MET calculation (NB. done generically, with smearing, rather than via explicit physics objects)
	+ const Vector3 vmet = -apply<SmearedMET>(event, "MET").vectorEt();
	+ const double etmiss = vmet.mod();
	+
	+
	+ //////////////////
	+
	+
	+ // Event selection cuts
	+ const Particles sigleptons = sigelecs + sigmuons;
	+ if (sigleptons.size() < 2) vetoEvent;
	+ if (sigleptons.size() == 2 && sigleptons[0].charge() != sigleptons[1].charge()) vetoEvent;
	+
	+ // Jet sub-selections and meff calculation
	+ const Jets sigjets25 = filter_select(sigjets, Cuts::pT > 25*GeV);
	+ const Jets sigjets40 = filter_select(sigjets25, Cuts::pT > 40*GeV);
	+ const Jets sigjets50 = filter_select(sigjets40, Cuts::pT > 50*GeV);
	+ /// @todo Is meff specific to the jet pT cut?
	+ const double meff = sum(sigjets, pT, 0.0) + sum(sigleptons, pT, 0.0);
	+
	+ // Fill counters
	+ const double w = event.weight();
	+ if (sigleptons.size() >= 3 && sigbjets.empty() && sigjets40.size() >= 4 && etmiss > 150*GeV) _h_3l1->fill(w);
	+ if (sigleptons.size() >= 3 && sigbjets.empty() && sigjets40.size() >= 4 && etmiss > 200GeV && meff > 1500GeV) _h_3l2->fill(w);
	+ if (sigleptons.size() >= 2 && sigbjets.empty() && sigjets25.size() >= 6 && etmiss > 150GeV && meff > 500GeV) _h_0b1->fill(w);
	+ if (sigleptons.size() >= 2 && sigbjets.empty() && sigjets40.size() >= 6 && etmiss > 150GeV && meff > 900GeV) _h_0b2->fill(w);
	+ if (sigleptons.size() >= 2 && sigbjets.size() >= 1 && sigjets25.size() >= 6 && etmiss > 200GeV && meff > 650GeV) _h_1b->fill(w);
	+ if (sigleptons.size() >= 2 && sigbjets.size() >= 3 && sigjets25.size() >= 6 && etmiss > 150GeV && meff > 600GeV) _h_3b->fill(w);
	+ if (filter_select(sigleptons, Cuts::charge < 0).size() >= 2) {
	+ if (sigleptons.size() >= 2 && sigbjets.size() >= 1 && sigjets50.size() >= 6 && meff > 1200*GeV) _h_1bDD->fill(w);
	+ if (sigleptons.size() >= 2 && sigbjets.size() >= 3 && sigjets50.size() >= 6 && meff > 1000*GeV) _h_3bDD->fill(w);
	+ if (sigleptons.size() >= 2 && sigbjets.size() >= 1 && sigjets50.size() >= 6 && meff > 1800*GeV) _h_1bGG->fill(w);
	+ }
	+
	+ }
	+
	+
	+ /// Normalise counters after the run
	+ void finalize() {
	+
	+ const double sf = 13.2*crossSection()/femtobarn/sumOfWeights();
	+ scale({_h_3l1, _h_3l2, _h_0b1, _h_0b2, _h_1b, _h_3b, _h_1bDD, _h_3bDD, _h_1bGG}, sf);
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ CounterPtr _h_3l1, _h_3l2, _h_0b1, _h_0b2, _h_1b, _h_3b, _h_1bDD, _h_3bDD, _h_1bGG;
	+ //@}
	+
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_CONF_2016_037);
	+
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_CONF_2016_054.cc b/src/Analyses/ATLAS_2016_CONF_2016_054.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_CONF_2016_054.cc
	@@ -0,0 +1,217 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/Sphericity.hh"
	+#include "Rivet/Projections/SmearedParticles.hh"
	+#include "Rivet/Projections/SmearedJets.hh"
	+#include "Rivet/Projections/SmearedMET.hh"
	+#include "Rivet/Tools/Cutflow.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief ATLAS 2016 1-lepton SUSY search, from 14.8/fb CONF note
	+ class ATLAS_2016_CONF_2016_054 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_CONF_2016_054);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ FinalState calofs(Cuts::abseta < 4.9);
	+ FastJets fj(calofs, FastJets::ANTIKT, 0.4);
	+ declare(fj, "TruthJets");
	+ declare(SmearedJets(fj, JET_SMEAR_ATLAS_RUN2, [](const Jet& j) {
	+ if (j.abseta() > 2.5) return 0.;
	+ return j.bTagged(Cuts::pT > 5*GeV) ? 0.77 :
	+ j.cTagged(Cuts::pT > 5*GeV) ? 1/6.2 : 1/134.; }), "Jets");
	+
	+ MissingMomentum mm(calofs);
	+ declare(mm, "TruthMET");
	+ declare(SmearedMET(mm, MET_SMEAR_ATLAS_RUN2), "MET");
	+
	+ FinalState es(Cuts::abseta < 2.47 && Cuts::pT > 7*GeV && Cuts::abspid == PID::ELECTRON);
	+ declare(es, "TruthElectrons");
	+ declare(SmearedParticles(es, ELECTRON_EFF_ATLAS_RUN2, ELECTRON_SMEAR_ATLAS_RUN2), "Electrons");
	+
	+ FinalState mus(Cuts::abseta < 2.5 && Cuts::pT > 6*GeV && Cuts::abspid == PID::MUON);
	+ declare(mus, "TruthMuons");
	+ declare(SmearedParticles(mus, MUON_EFF_ATLAS_RUN2, MUON_SMEAR_ATLAS_RUN2), "Muons");
	+
	+
	+ // Book histograms/counters
	+ _h_gg2j = bookCounter("GG-2j");
	+ _h_gg6j0 = bookCounter("GG-6j-0bulk");
	+ _h_gg6j1 = bookCounter("GG-6j-1highmass");
	+ _h_gg4j0 = bookCounter("GG-4j-0lowx");
	+ _h_gg4j1 = bookCounter("GG-4j-1lowxbveto");
	+ _h_gg4j2 = bookCounter("GG-4j-2highx");
	+ _h_ss4j0 = bookCounter("SS-4j-0x12");
	+ _h_ss4j1 = bookCounter("SS-4j-1lowx");
	+ _h_ss5j0 = bookCounter("SS-5j-0x12");
	+ _h_ss5j1 = bookCounter("SS-5j-1highx");
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get baseline electrons, muons, and jets
	+ Particles elecs = apply<ParticleFinder>(event, "Electrons").particles();
	+ Particles muons = apply<ParticleFinder>(event, "Muons").particles();
	+ Jets jets = apply<JetAlg>(event, "Jets").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 4.5);
	+
	+ // Jet/electron/muons overlap removal and selection
	+ // Remove any jet within dR = 0.2 of an electron
	+ for (const Particle& e : elecs)
	+ ifilter_discard(jets, deltaRLess(e, 0.2, RAPIDITY));
	+ // Remove any electron within dR = 0.01 of a muon
	+ for (const Particle& m : muons)
	+ ifilter_discard(elecs, deltaRLess(m, 0.01, RAPIDITY));
	+ // Assemble b-jets collection, and remove muons within dR = 0.2 of a b-tagged jet
	+ Jets bjets;
	+ for (const Jet& j : jets) {
	+ if (j.abseta() < 2.5 && j.pT() > 30GeV && j.bTagged(Cuts::pT > 5GeV)) {
	+ bjets += j;
	+ ifilter_discard(muons, deltaRLess(j, 0.2, RAPIDITY));
	+ }
	+ }
	+ // Remove any jet within dR = 0.2 of a muon if track conditions are met
	+ for (const Particle& m : muons)
	+ ifilter_discard(jets, [&](const Jet& j){
	+ if (deltaR(j,m) > 0.2) return false;
	+ /// @todo Add track efficiency random filtering
	+ const Particles trks = j.particles(Cuts::abscharge > 0 && Cuts::pT > 0.5*GeV);
	+ return trks.size() < 4 \|\| m.pT()/j.pT() > 0.7;
	+ });
	+ // Remove any muon within dR = 0.2 of a remaining jet if the same track conditions are not met
	+ /// @todo There must be nicer way to do complementary removal...
	+ for (const Jet& j : jets) {
	+ /// @todo Add track efficiency random filtering
	+ const size_t ntrks = j.particles(Cuts::abscharge > 0 && Cuts::pT > 0.5*GeV).size();
	+ ifilter_discard(muons, [&](const Particle& m){
	+ if (deltaR(j,m) > 0.2) return false;
	+ return ntrks > 3 && m.pT()/j.pT() < 0.7;
	+ });
	+ }
	+ // Remove any muon with dR close to a remaining jet, via a functional form
	+ for (const Jet& j : jets)
	+ ifilter_discard(muons, [&](const Particle& m) { return deltaR(m,j, RAPIDITY) < min(0.4, 0.04 + 10*GeV/m.pT()); });
	+
	+
	+ // Signal jet selection
	+ const Jets sigjets = filter_select(jets, Cuts::pT > 30*GeV && Cuts::abseta < 2.8);
	+ const Jets sigbjets = bjets;
	+
	+ // "Gradient-loose" signal lepton selection
	+ const ParticleEffFilter grad_loose_filter([](const Particle& e) { return e.pT() > 60*GeV ? 0.98 : 0.95; });
	+ Particles sigelecs = filter_select(elecs, grad_loose_filter);
	+ Particles sigmuons = filter_select(muons, grad_loose_filter);
	+ // Tight electron selection (NB. assuming independent eff to gradient-loose... hmm)
	+ ifilter_select(sigelecs, ParticleEffFilter(ELECTRON_IDEFF_ATLAS_RUN2_TIGHT));
	+
	+
	+ // MET calculation (NB. done generically, with smearing, rather than via explicit physics objects)
	+ const Vector3 vmet = -apply<SmearedMET>(event, "MET").vectorEt();
	+ const double etmiss = vmet.mod();
	+
	+
	+ //////////////////
	+
	+
	+ // Event selection cuts
	+ if (sigelecs.size() + sigmuons.size() != 1) vetoEvent;
	+ const Particle siglepton = sigelecs.empty() ? sigmuons.front() : sigelecs.front();
	+
	+ // mT and m_eff
	+ const double mT = sqrt(2siglepton.pT()etmiss*(1-cos(deltaPhi(siglepton,vmet))));
	+ const double meff = siglepton.pT() + sum(sigjets, pT, 0.0) + etmiss;
	+
	+ // Aplanarities
	+ Sphericity sph;
	+ vector<FourMomentum> vecs;
	+ transform(sigjets, vecs, mom);
	+ sph.calc(vecs);
	+ const double jet_aplanarity = sph.aplanarity();
	+ vecs += siglepton.mom();
	+ sph.calc(vecs);
	+ const double lepton_aplanarity = sph.aplanarity();
	+
	+
	+ //////////////////
	+
	+
	+ // Fill counters
	+ const double w = event.weight();
	+ // GG
	+ if (siglepton.pT() < 35*GeV && sigjets.size() >= 2 &&
	+ sigjets[0].pT() > 200GeV && sigjets[1].pT() > 30GeV &&
	+ mT > 100GeV && etmiss > 460GeV && etmiss/meff > 0.35) _h_gg2j->fill(w);
	+ if (siglepton.pT() > 35*GeV && sigjets.size() >= 6 &&
	+ sigjets[0].pT() > 125GeV && sigjets[5].pT() > 30GeV &&
	+ mT > 225GeV && etmiss > 250GeV && meff > 1000*GeV && etmiss/meff > 0.2 &&
	+ jet_aplanarity > 0.04) _h_gg6j0->fill(w);
	+ if (siglepton.pT() > 35*GeV && sigjets.size() >= 6 &&
	+ sigjets[0].pT() > 125GeV && sigjets[5].pT() > 30GeV &&
	+ mT > 225GeV && etmiss > 250GeV && meff > 2000*GeV && etmiss/meff > 0.1 &&
	+ jet_aplanarity > 0.04) _h_gg6j1->fill(w);
	+ if (sigjets.size() >= 4 && sigjets[3].pT() > 100*GeV &&
	+ mT > 125GeV && etmiss > 250GeV && meff > 2000*GeV && jet_aplanarity > 0.06) _h_gg4j0->fill(w);
	+ if (sigjets.size() >= 4 && sigjets[3].pT() > 100*GeV && sigbjets.empty() &&
	+ mT > 125GeV && etmiss > 250GeV && meff > 2000*GeV && jet_aplanarity > 0.03) _h_gg4j1->fill(w);
	+ if (siglepton.pT() > 35*GeV &&
	+ sigjets.size() >= 4 && sigjets[0].pT() > 400GeV && inRange(sigjets[3].pT(), 30GeV, 100*GeV) &&
	+ mT > 475GeV && etmiss > 250GeV && meff > 1600*GeV && etmiss/meff > 0.3) _h_gg4j2->fill(w);
	+ // SS
	+ if (siglepton.pT() > 35GeV && sigjets.size() >= 4 && sigjets[3].pT() > 50GeV &&
	+ mT > 175GeV && etmiss > 300GeV && meff > 1200*GeV && lepton_aplanarity > 0.08) _h_ss4j0->fill(w);
	+ if (siglepton.pT() > 35GeV && sigjets.size() >= 5 && sigjets[4].pT() > 50GeV && sigbjets.empty() &&
	+ mT > 175GeV && etmiss > 300GeV && etmiss/meff > 0.2) _h_ss5j0->fill(w);
	+ if (siglepton.pT() > 35GeV && sigjets.size() >= 4 && sigjets[0].pT() > 250GeV && sigjets[3].pT() > 30*GeV &&
	+ inRange(mT, 150GeV, 400GeV) && etmiss > 250*GeV && lepton_aplanarity > 0.03) _h_ss4j1->fill(w);
	+ if (siglepton.pT() > 35GeV && sigjets.size() >= 5 && sigjets[4].pT() > 30GeV &&
	+ mT > 400GeV && etmiss > 400GeV && lepton_aplanarity > 0.03) _h_ss5j1->fill(w);
	+
	+ }
	+
	+
	+ /// Normalise counters after the run
	+ void finalize() {
	+
	+ const double sf = 14.8*crossSection()/femtobarn/sumOfWeights();
	+ scale({_h_gg2j, _h_gg6j0, _h_gg6j1, _h_gg4j0, _h_gg4j1, _h_gg4j2}, sf);
	+ scale({_h_ss4j0, _h_ss4j1, _h_ss5j0,_h_ss5j1}, sf);
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ CounterPtr _h_gg2j, _h_gg6j0, _h_gg6j1, _h_gg4j0, _h_gg4j1, _h_gg4j2;
	+ CounterPtr _h_ss4j0, _h_ss4j1, _h_ss5j0,_h_ss5j1;
	+ //@}
	+
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_CONF_2016_054);
	+
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_CONF_2016_078.cc b/src/Analyses/ATLAS_2016_CONF_2016_078.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_CONF_2016_078.cc
	@@ -0,0 +1,269 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/Sphericity.hh"
	+#include "Rivet/Projections/SmearedParticles.hh"
	+#include "Rivet/Projections/SmearedJets.hh"
	+#include "Rivet/Projections/SmearedMET.hh"
	+#include "Rivet/Tools/Cutflow.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief ATLAS 2016 0-lepton SUSY search, from 13/fb ICHEP'16 CONF note
	+ class ATLAS_2016_CONF_2016_078 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_CONF_2016_078);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ FinalState calofs(Cuts::abseta < 3.2);
	+ FastJets fj(calofs, FastJets::ANTIKT, 0.4);
	+ declare(fj, "TruthJets");
	+ declare(SmearedJets(fj, JET_SMEAR_ATLAS_RUN2, JET_BTAG_ATLAS_RUN2_MV2C10), "RecoJets");
	+
	+ MissingMomentum mm(calofs);
	+ declare(mm, "TruthMET");
	+ declare(SmearedMET(mm, MET_SMEAR_ATLAS_RUN2), "RecoMET");
	+
	+ PromptFinalState es(Cuts::abseta < 2.47 && Cuts::abspid == PID::ELECTRON, true, true);
	+ declare(es, "TruthElectrons");
	+ declare(SmearedParticles(es, ELECTRON_EFF_ATLAS_RUN2, ELECTRON_SMEAR_ATLAS_RUN2), "RecoElectrons");
	+
	+ PromptFinalState mus(Cuts::abseta < 2.7 && Cuts::abspid == PID::MUON, true);
	+ declare(mus, "TruthMuons");
	+ declare(SmearedParticles(mus, MUON_EFF_ATLAS_RUN2, MUON_SMEAR_ATLAS_RUN2), "RecoMuons");
	+
	+
	+ // Book histograms/counters
	+ _h_2j_0800 = bookCounter("2j-0800");
	+ _h_2j_1200 = bookCounter("2j-1200");
	+ _h_2j_1600 = bookCounter("2j-1600");
	+ _h_2j_2000 = bookCounter("2j-2000");
	+ _h_3j_1200 = bookCounter("2j-2000");
	+ _h_4j_1000 = bookCounter("4j-1000");
	+ _h_4j_1400 = bookCounter("4j-1400");
	+ _h_4j_1800 = bookCounter("4j-1800");
	+ _h_4j_2200 = bookCounter("4j-2200");
	+ _h_4j_2600 = bookCounter("4j-2600");
	+ _h_5j_1400 = bookCounter("5j-1400");
	+ _h_6j_1800 = bookCounter("6j-1800");
	+ _h_6j_2200 = bookCounter("6j-2200");
	+
	+
	+ // Book cut-flows
	+ const vector<string> cuts23j = {"Pre-sel+MET+pT1+meff", "Njet", "Dphi_min(j123,MET)", "Dphi_min(j4+,MET)", "pT2", "eta_j12", "MET/sqrtHT", "m_eff(incl)"};
	+ _flows.addCutflow("2j-0800", cuts23j);
	+ _flows.addCutflow("2j-1200", cuts23j);
	+ _flows.addCutflow("2j-1600", cuts23j);
	+ _flows.addCutflow("2j-2000", cuts23j);
	+ _flows.addCutflow("3j-1200", cuts23j);
	+ const vector<string> cuts456j = {"Pre-sel+MET+pT1+meff", "Njet", "Dphi_min(j123,MET)", "Dphi_min(j4+,MET)", "pT4", "eta_j1234", "Aplanarity", "MET/m_eff(Nj)", "m_eff(incl)"};
	+ _flows.addCutflow("4j-1000", cuts456j);
	+ _flows.addCutflow("4j-1400", cuts456j);
	+ _flows.addCutflow("4j-1800", cuts456j);
	+ _flows.addCutflow("4j-2200", cuts456j);
	+ _flows.addCutflow("4j-2600", cuts456j);
	+ _flows.addCutflow("5j-1400", cuts456j);
	+ _flows.addCutflow("6j-1800", cuts456j);
	+ _flows.addCutflow("6j-2200", cuts456j);
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ _flows.fillinit();
	+
	+ // Same MET cut for all signal regions
	+ const Vector3 vmet = -apply<SmearedMET>(event, "RecoMET").vectorEt();
	+ const double met = vmet.mod();
	+ if (met < 250*GeV) vetoEvent;
	+
	+ // Get baseline electrons, muons, and jets
	+ Particles elecs = apply<ParticleFinder>(event, "RecoElectrons").particles(Cuts::pT > 10*GeV);
	+ Particles muons = apply<ParticleFinder>(event, "RecoMuons").particles(Cuts::pT > 10*GeV);
	+ Jets jets = apply<JetAlg>(event, "RecoJets").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.8); ///< @todo Pile-up subtraction
	+
	+ // Jet/electron/muons overlap removal and selection
	+ // Remove electrons within dR = 0.2 of a b-tagged jet
	+ for (const Jet& j : jets)
	+ if (j.abseta() < 2.5 && j.pT() > 50GeV && j.bTagged(Cuts::pT > 5GeV))
	+ ifilter_discard(elecs, deltaRLess(j, 0.2, RAPIDITY));
	+ // Remove any \|eta\| < 2.8 jet within dR = 0.2 of a remaining electron
	+ for (const Particle& e : elecs)
	+ ifilter_discard(jets, deltaRLess(e, 0.2, RAPIDITY));
	+ // Remove any electron with dR in [0.2, 0.4] of a remaining jet
	+ for (const Jet& j : jets)
	+ ifilter_discard(elecs, [&](const Particle& e) { return inRange(deltaR(e,j, RAPIDITY), 0.2, 0.4); });
	+ // Remove any muon with dR close to a remaining jet, via a functional form
	+ for (const Jet& j : jets)
	+ ifilter_discard(muons, [&](const Particle& m) { return deltaR(m,j, RAPIDITY) < min(0.4, 0.04 + 10*GeV/m.pT()); });
	+ // Remove any \|eta\| < 2.8 jet within dR = 0.2 of a remaining muon if track conditions are met
	+ for (const Particle& m : muons)
	+ /// @todo Add track efficiency random filtering
	+ ifilter_discard(jets, [&](const Jet& j) {
	+ if (deltaR(j,m, RAPIDITY) > 0.2) return false;
	+ const Particles trks = j.particles(Cuts::abscharge > 0 && Cuts::pT > 0.5*GeV);
	+ return trks.size() < 3 \|\| (m.pT() > 2j.pT() && m.pT() > 0.7sum(trks, pT, 0.0));
	+ });
	+ // Loose electron selection
	+ ifilter_select(elecs, ParticleEffFilter(ELECTRON_IDEFF_ATLAS_RUN2_LOOSE));
	+
	+ // Veto the event if there are any remaining baseline leptons
	+ if (!elecs.empty()) vetoEvent;
	+ if (!muons.empty()) vetoEvent;
	+
	+ // Passed presel & MET
	+ _flows.fill(0, true);
	+
	+ // Get jets and their pTs
	+ const Jets jets20 = jets;
	+ const Jets jets50 = filterBy(jets, Cuts::pT > 50*GeV);
	+ const size_t njets50 = jets50.size(), njets20 = jets20.size();
	+ if (jets50.size() < 2) vetoEvent;
	+ vector<double> jetpts20, jetpts50;
	+ transform(jets20, jetpts20, pT);
	+ transform(jets50, jetpts50, pT);
	+
	+ // Construct multi-jet observables
	+ const double ht = sum(jetpts20, 0.0);
	+ const double met_sqrtHT = met / sqrt(ht);
	+ const double meff_incl = sum(jetpts50, met);
	+ const double meff_4 = (njets50 >= 4) ? sum(head(jetpts50, 4), met) : -1;
	+ const double meff_5 = (njets50 >= 5) ? sum(head(jetpts50, 5), met) : -1;
	+ const double meff_6 = (njets50 >= 6) ? sum(head(jetpts50, 6), met) : -1;
	+ const double met_meff_4 = met / meff_4;
	+ const double met_meff_5 = met / meff_5;
	+ const double met_meff_6 = met / meff_6;
	+
	+ // Jet \|eta\|s
	+ vector<double> jetetas20; transform(jets20, jetetas20, abseta);
	+ const double etamax_2 = (njets20 >= 2) ? max(head(jetetas20, 2)) : -1;
	+ const double etamax_4 = (njets20 >= 4) ? max(head(jetetas20, 4)) : -1;
	+ const double etamax_6 = (njets20 >= 6) ? max(head(jetetas20, 6)) : -1;
	+
	+ // Get dphis between MET and jets
	+ vector<double> dphimets50; transform(jets50, dphimets50, deltaPhiWRT(vmet));
	+ const vector<double> dphimets50_123 = head(dphimets50, 3);
	+ const vector<double> dphimets50_more = tail(dphimets50, -3);
	+ const double dphimin_123 = !dphimets50_123.empty() ? min(dphimets50_123) : -1;
	+ const double dphimin_more = !dphimets50_more.empty() ? min(dphimets50_more) : -1;
	+
	+ // Jet aplanarity
	+ Sphericity sph; sph.calc(jets50);
	+ const double aplanarity = sph.aplanarity();
	+
	+
	+ //////////////////
	+
	+
	+ const double w = event.weight();
	+
	+ // 2 jet regions
	+ if (dphimin_123 > 0.8 && dphimin_more > 0.4) {
	+ if (jetpts50[1] > 200*GeV && etamax_2 < 0.8) { //< implicit pT[0] cut
	+ if (met_sqrtHT > 14sqrt(GeV) && meff_incl > 800GeV) _h_2j_0800->fill(w);
	+ }
	+ if (jetpts50[1] > 250*GeV && etamax_2 < 1.2) { //< implicit pT[0] cut
	+ if (met_sqrtHT > 16sqrt(GeV) && meff_incl > 1200GeV) _h_2j_1200->fill(w);
	+ if (met_sqrtHT > 18sqrt(GeV) && meff_incl > 1600GeV) _h_2j_1600->fill(w);
	+ if (met_sqrtHT > 20sqrt(GeV) && meff_incl > 2000GeV) _h_2j_2000->fill(w);
	+ }
	+ }
	+
	+ // 3 jet region
	+ if (njets50 >= 3 && dphimin_123 > 0.4 && dphimin_more > 0.2) {
	+ if (jetpts50[0] > 600GeV && jetpts50[2] > 50GeV) { //< implicit pT[1] cut
	+ if (met_sqrtHT > 16sqrt(GeV) && meff_incl > 1200GeV) _h_3j_1200->fill(w);
	+ }
	+ }
	+
	+ // 4 jet regions (note implicit pT[1,2] cuts)
	+ if (njets50 >= 4 && dphimin_123 > 0.4 && dphimin_more > 0.4 && jetpts50[0] > 200*GeV && aplanarity > 0.04) {
	+ if (jetpts50[3] > 100GeV && etamax_4 < 1.2 && met_meff_4 > 0.25sqrt(GeV) && meff_incl > 1000*GeV) _h_4j_1000->fill(w);
	+ if (jetpts50[3] > 100GeV && etamax_4 < 2.0 && met_meff_4 > 0.25sqrt(GeV) && meff_incl > 1400*GeV) _h_4j_1400->fill(w);
	+ if (jetpts50[3] > 100GeV && etamax_4 < 2.0 && met_meff_4 > 0.20sqrt(GeV) && meff_incl > 1800*GeV) _h_4j_1800->fill(w);
	+ if (jetpts50[3] > 150GeV && etamax_4 < 2.0 && met_meff_4 > 0.20sqrt(GeV) && meff_incl > 2200*GeV) _h_4j_2200->fill(w);
	+ if (jetpts50[3] > 150GeV && met_meff_4 > 0.20sqrt(GeV) && meff_incl > 2600*GeV) _h_4j_2600->fill(w);
	+ }
	+
	+ // 5 jet region (note implicit pT[1,2,3] cuts)
	+ if (njets50 >= 5 && dphimin_123 > 0.4 && dphimin_more > 0.2 && jetpts50[0] > 500*GeV) {
	+ if (jetpts50[4] > 50GeV && met_meff_5 > 0.3sqrt(GeV) && meff_incl > 1400*GeV) _h_5j_1400->fill(w);
	+ }
	+
	+ // 6 jet regions (note implicit pT[1,2,3,4] cuts)
	+ if (njets50 >= 6 && dphimin_123 > 0.4 && dphimin_more > 0.2 && jetpts50[0] > 200*GeV && aplanarity > 0.08) {
	+ if (jetpts50[5] > 50GeV && etamax_6 < 2.0 && met_meff_6sqrt(GeV) > 0.20 && meff_incl > 1800*GeV) _h_6j_1800->fill(w);
	+ if (jetpts50[5] > 100GeV && met_meff_6sqrt(GeV) > 0.15 && meff_incl > 2200*GeV) _h_6j_2200->fill(w);
	+ }
	+
	+ // Cutflows
	+ _flows["2j-0800"].filltail({true, dphimin_123 > 0.8, dphimin_more > 0.4, jetpts50[1] > 200GeV, etamax_2 < 0.8, met_sqrtHT > 14sqrt(GeV), meff_incl > 800*GeV});
	+ _flows["2j-1200"].filltail({true, dphimin_123 > 0.8, dphimin_more > 0.4, jetpts50[1] > 250GeV, etamax_2 < 1.2, met_sqrtHT > 16sqrt(GeV), meff_incl > 1200*GeV});
	+ _flows["2j-1600"].filltail({true, dphimin_123 > 0.8, dphimin_more > 0.4, jetpts50[1] > 250GeV, etamax_2 < 1.2, met_sqrtHT > 18sqrt(GeV), meff_incl > 1600*GeV});
	+ _flows["2j-2000"].filltail({true, dphimin_123 > 0.8, dphimin_more > 0.4, jetpts50[1] > 250GeV, etamax_2 < 1.2, met_sqrtHT > 20sqrt(GeV), meff_incl > 2000*GeV});
	+ _flows["3j-1200"].filltail({njets50 >= 3, dphimin_123 > 0.4, dphimin_more > 0.2, jetpts50[0] > 600GeV && jetpts50[2] > 50GeV, true, met_sqrtHT > 16sqrt(GeV), meff_incl > 1200GeV});
	+ _flows["4j-1000"].filltail({njets50 >= 4, dphimin_123 > 0.4, dphimin_more > 0.4, jetpts50[0] > 200GeV && jetpts50[3] > 100GeV, etamax_4 < 1.2, aplanarity > 0.04, met_meff_4 > 0.25sqrt(GeV), meff_incl > 1000GeV});
	+ _flows["4j-1400"].filltail({njets50 >= 4, dphimin_123 > 0.4, dphimin_more > 0.4, jetpts50[0] > 200GeV && jetpts50[3] > 100GeV, etamax_4 < 2.0, aplanarity > 0.04, met_meff_4 > 0.25sqrt(GeV), meff_incl > 1400GeV});
	+ _flows["4j-1800"].filltail({njets50 >= 4, dphimin_123 > 0.4, dphimin_more > 0.4, jetpts50[0] > 200GeV && jetpts50[3] > 100GeV, etamax_4 < 2.0, aplanarity > 0.04, met_meff_4 > 0.20sqrt(GeV), meff_incl > 1800GeV});
	+ _flows["4j-2200"].filltail({njets50 >= 4, dphimin_123 > 0.4, dphimin_more > 0.4, jetpts50[0] > 200GeV && jetpts50[3] > 150GeV, etamax_4 < 2.0, aplanarity > 0.04, met_meff_4 > 0.20sqrt(GeV), meff_incl > 2200GeV});
	+ _flows["4j-2600"].filltail({njets50 >= 4, dphimin_123 > 0.4, dphimin_more > 0.4, jetpts50[0] > 200GeV && jetpts50[3] > 150GeV, true, aplanarity > 0.04, met_meff_4 > 0.20sqrt(GeV), meff_incl > 2600GeV});
	+ _flows["5j-1400"].filltail({njets50 >= 5, dphimin_123 > 0.4, dphimin_more > 0.2, jetpts50[0] > 500GeV && jetpts50[4] > 50GeV, true, true, met_meff_5 > 0.3sqrt(GeV), meff_incl > 1400GeV});
	+ _flows["6j-1800"].filltail({njets50 >= 6, dphimin_123 > 0.4, dphimin_more > 0.2, jetpts50[0] > 200GeV && jetpts50[5] > 50GeV, etamax_6 < 2.0, aplanarity > 0.08, met_meff_6 > 0.20sqrt(GeV), meff_incl > 1800GeV});
	+ _flows["6j-2200"].filltail({njets50 >= 6, dphimin_123 > 0.4, dphimin_more > 0.2, jetpts50[0] > 200GeV && jetpts50[5] > 100GeV, true, aplanarity > 0.08, met_meff_6 > 0.15sqrt(GeV), meff_incl > 2200GeV});
	+
	+ }
	+
	+
	+ /// Normalise counters after the run
	+ void finalize() {
	+
	+ const double sf = 13.3*crossSection()/femtobarn/sumOfWeights();
	+ scale({_h_2j_0800, _h_2j_1200, _h_2j_1600, _h_2j_2000}, sf);
	+ scale( _h_3j_1200, sf);
	+ scale({_h_4j_1000, _h_4j_1400, _h_4j_1800, _h_4j_2200, _h_4j_2600}, sf);
	+ scale( _h_5j_1400, sf);
	+ scale({_h_6j_1800, _h_6j_2200}, sf);
	+
	+ _flows.scale(sf);
	+ MSG_INFO("CUTFLOWS:\n\n" << _flows);
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ CounterPtr _h_2j_0800, _h_2j_1200, _h_2j_1600, _h_2j_2000, _h_3j_1200;
	+ CounterPtr _h_4j_1000, _h_4j_1400, _h_4j_1800, _h_4j_2200, _h_4j_2600;
	+ CounterPtr _h_5j_1400, _h_6j_1800, _h_6j_2200;
	+ //@}
	+
	+ /// Cut-flows
	+ Cutflows _flows;
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_CONF_2016_078);
	+
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_CONF_2016_094.cc b/src/Analyses/ATLAS_2016_CONF_2016_094.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_CONF_2016_094.cc
	@@ -0,0 +1,166 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/Sphericity.hh"
	+#include "Rivet/Projections/SmearedParticles.hh"
	+#include "Rivet/Projections/SmearedJets.hh"
	+#include "Rivet/Projections/SmearedMET.hh"
	+#include "Rivet/Tools/Cutflow.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief ATLAS 2016 1-lepton + many jets SUSY search, from 14.8/fb CONF note
	+ class ATLAS_2016_CONF_2016_094 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_CONF_2016_094);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ FinalState calofs(Cuts::abseta < 4.9);
	+ FastJets fj(calofs, FastJets::ANTIKT, 0.4);
	+ declare(fj, "TruthJets");
	+ declare(SmearedJets(fj, JET_SMEAR_ATLAS_RUN2, [](const Jet& j) {
	+ if (j.abseta() > 2.5) return 0.;
	+ return j.bTagged(Cuts::pT > 5*GeV) ? 0.80 :
	+ j.cTagged(Cuts::pT > 5*GeV) ? 1/6. : 1/106.; }), "Jets");
	+
	+ // MissingMomentum mm(calofs);
	+ // declare(mm, "TruthMET");
	+ // declare(SmearedMET(mm, MET_SMEAR_ATLAS_RUN2), "MET");
	+
	+ FinalState es(Cuts::abspid == PID::ELECTRON && Cuts::abseta < 2.47 && !Cuts::absetaIn(1.37, 1.52) && Cuts::pT > 10*GeV);
	+ declare(es, "TruthElectrons");
	+ declare(SmearedParticles(es, ELECTRON_EFF_ATLAS_RUN2, ELECTRON_SMEAR_ATLAS_RUN2), "Electrons");
	+
	+ FinalState mus(Cuts::abspid == PID::MUON && Cuts::abseta < 2.4 && Cuts::pT > 10*GeV);
	+ declare(mus, "TruthMuons");
	+ declare(SmearedParticles(mus, MUON_EFF_ATLAS_RUN2, MUON_SMEAR_ATLAS_RUN2), "Muons");
	+
	+
	+ // Book histograms/counters
	+ _h_08j40_0b = bookCounter("08j40_0b");
	+ _h_09j40_0b = bookCounter("09j40_0b");
	+ _h_10j40_0b = bookCounter("10j40_0b");
	+ _h_08j40_3b = bookCounter("08j40_3b");
	+ _h_09j40_3b = bookCounter("09j40_3b");
	+ _h_10j40_3b = bookCounter("10j40_3b");
	+ _h_08j60_0b = bookCounter("08j60_0b");
	+ _h_09j60_0b = bookCounter("09j60_0b");
	+ _h_10j60_0b = bookCounter("10j60_0b");
	+ _h_08j60_3b = bookCounter("08j60_3b");
	+ _h_09j60_3b = bookCounter("09j60_3b");
	+ _h_10j60_3b = bookCounter("10j60_3b");
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get baseline electrons, muons, and jets
	+ // NB. for electrons, we don't apply the loose ID here, since we don't want to double-count effs with later use of tight ID
	+ Particles elecs = apply<ParticleFinder>(event, "Electrons").particles();
	+ Particles muons = apply<ParticleFinder>(event, "Muons").particles();
	+ Jets jets = apply<JetAlg>(event, "Jets").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.4);
	+ ifilter_select(jets, JetEffFilter([](const Jet& j) { return j.pT() > 60*GeV ? 1.0 : 0.94; }));
	+
	+
	+ // Jet/electron/muon overlap removal and selection
	+ // Remove any untagged jet within dR = 0.2 of an electron
	+ for (const Particle& e : elecs)
	+ ifilter_discard(jets, [&](const Jet& j) { return !j.bTagged(Cuts::pT > 5*GeV) && deltaR(e, j, RAPIDITY) < 0.2; });
	+ // Remove any untagged low-multiplicity/muon-dominated jet within dR = 0.4 of a muon
	+ for (const Particle& m : muons)
	+ ifilter_discard(jets, [&](const Jet& j) {
	+ if (!j.bTagged(Cuts::pT > 5GeV)) return false; /// @note A different b-tag working point, 85%, was actually used here sigh*
	+ if (deltaR(m, j, RAPIDITY) > 0.4) return false;
	+ if (j.particles(Cuts::abscharge != 0).size() < 3) return true;
	+ return m.pT()/j.pT() > 0.5;
	+ });
	+ // Removing leptons within dR = 0.4 of remaining jets
	+ for (const Jet& j : jets) {
	+ ifilter_discard(elecs, deltaRLess(j, 0.4, RAPIDITY));
	+ ifilter_discard(muons, deltaRLess(j, 0.4, RAPIDITY));
	+ }
	+
	+ // Signal jet and lepton selection
	+ const Jets sigjets40 = filter_select(jets, Cuts::pT > 40*GeV);
	+ const Jets sigjets60 = filter_select(sigjets40, Cuts::pT > 60*GeV);
	+ const Jets sigbjets40 = filter_select(sigjets40, [](const Jet& j) { return j.bTagged(Cuts::pT > 5*GeV); });
	+ const Jets sigbjets60 = filter_select(sigjets60, [](const Jet& j) { return j.bTagged(Cuts::pT > 5*GeV); });
	+ const Particles sigmuons = filter_select(muons, Cuts::pT > 35*GeV);
	+ Particles sigelecs = filter_select(elecs, Cuts::pT > 35*GeV);
	+ ifilter_select(sigelecs, ParticleEffFilter(ELECTRON_IDEFF_ATLAS_RUN2_TIGHT));
	+
	+
	+ //////////////////
	+
	+
	+ // Event selection cuts
	+ if (sigelecs.size() + sigmuons.size() != 1) vetoEvent;
	+ const Particle siglepton = sigelecs.empty() ? sigmuons.front() : sigelecs.front();
	+
	+ /// @note The note describes Nj = 5, 6, 7, 8, 9, >= 10 and Nb = 0, 1, 2, 3, >= 4 = 30 2D bins
	+ /// for each jet cut... but only provides data for six Nj = >= 8, 9, 10, Nb = 0, >= 3 bins.
	+ /// We just implement the latter for now.
	+
	+ // Fill counters
	+ const double w = event.weight();
	+ if (sigjets40.size() >= 8 && sigbjets40.empty()) _h_08j40_0b->fill(w);
	+ if (sigjets40.size() >= 9 && sigbjets40.empty()) _h_09j40_0b->fill(w);
	+ if (sigjets40.size() >= 10 && sigbjets40.empty()) _h_10j40_0b->fill(w);
	+ if (sigjets40.size() >= 8 && sigbjets40.size() >= 3) _h_08j40_3b->fill(w);
	+ if (sigjets40.size() >= 9 && sigbjets40.size() >= 3) _h_09j40_3b->fill(w);
	+ if (sigjets40.size() >= 10 && sigbjets40.size() >= 3) _h_10j40_3b->fill(w);
	+
	+ if (sigjets60.size() >= 8 && sigbjets60.empty()) _h_08j60_0b->fill(w);
	+ if (sigjets60.size() >= 9 && sigbjets60.empty()) _h_09j60_0b->fill(w);
	+ if (sigjets60.size() >= 10 && sigbjets60.empty()) _h_10j60_0b->fill(w);
	+ if (sigjets60.size() >= 8 && sigbjets60.size() >= 3) _h_08j60_3b->fill(w);
	+ if (sigjets60.size() >= 9 && sigbjets60.size() >= 3) _h_09j60_3b->fill(w);
	+ if (sigjets60.size() >= 10 && sigbjets60.size() >= 3) _h_10j60_3b->fill(w);
	+
	+ }
	+
	+
	+ /// Normalise counters after the run
	+ void finalize() {
	+
	+ const double sf = 14.8*crossSection()/femtobarn/sumOfWeights();
	+ scale({_h_08j40_0b, _h_09j40_0b, _h_10j40_0b, _h_08j40_3b, _h_09j40_3b, _h_10j40_3b}, sf);
	+ scale({_h_08j60_0b, _h_09j60_0b, _h_10j60_0b, _h_08j60_3b, _h_09j60_3b, _h_10j60_3b}, sf);
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ CounterPtr _h_08j40_0b, _h_09j40_0b, _h_10j40_0b, _h_08j40_3b, _h_09j40_3b, _h_10j40_3b;
	+ CounterPtr _h_08j60_0b, _h_09j60_0b, _h_10j60_0b, _h_08j60_3b, _h_09j60_3b, _h_10j60_3b;
	+ //@}
	+
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_CONF_2016_094);
	+
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1419070.cc b/src/Analyses/ATLAS_2016_I1419070.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1419070.cc
	@@ -0,0 +1,141 @@
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+ class ATLAS_2016_I1419070 : public Analysis {
	+
	+ public:
	+
	+ /// Constructor
	+ ATLAS_2016_I1419070() : Analysis("ATLAS_2016_I1419070")
	+ { }
	+
	+ public:
	+
	+ void init() {
	+
	+ addProjection(FastJets(FinalState(), FastJets::ANTIKT, 0.4), "Jets");
	+
	+ forward_500MeV = bookProfile1D(1, 1, 1);
	+ forward_2GeV = bookProfile1D(2, 1, 1);
	+ forward_5GeV = bookProfile1D(3, 1, 1);
	+
	+ central_500MeV = bookProfile1D(4, 1, 1);
	+ central_2GeV = bookProfile1D(5, 1, 1);
	+ central_5GeV = bookProfile1D(6, 1, 1);
	+
	+ diff_500MeV = bookScatter2D("d07-x01-y01", true);
	+ diff_2GeV = bookScatter2D("d08-x01-y01", true);
	+ diff_5GeV = bookScatter2D("d09-x01-y01", true);
	+
	+ sum_500MeV = bookScatter2D("d10-x01-y01", true);
	+ sum_2GeV = bookScatter2D("d11-x01-y01", true);
	+ sum_5GeV = bookScatter2D("d12-x01-y01", true);
	+
	+ }
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+ const double weight = event.weight();
	+
	+ Jets m_goodJets = applyProjection<JetAlg>(event, "Jets").jetsByPt(Cuts::pT > 25*GeV && Cuts::abseta < 2.1);
	+
	+ if (m_goodJets.size() < 2) vetoEvent;
	+ if (m_goodJets[0].pT() < 50*GeV) vetoEvent;
	+ if (m_goodJets[1].pT() < 50*GeV) vetoEvent;
	+ if (fabs(1.0 - m_goodJets[0].pT()/m_goodJets[1].pT()) > 0.5) vetoEvent;
	+
	+ bool check = m_goodJets[0].abseta() < m_goodJets[1].abseta();
	+ int pos_f = int(check);
	+ int pos_c = int(!check);
	+
	+ double pt500MeV_f = CalculateNCharge(m_goodJets[pos_f], 0.5);
	+ double pt2GeV_f = CalculateNCharge(m_goodJets[pos_f], 2.0);
	+ double pt5GeV_f = CalculateNCharge(m_goodJets[pos_f], 5.0);
	+ double pT_f = m_goodJets[pos_f].pT();
	+
	+ double pt500MeV_c = CalculateNCharge(m_goodJets[pos_c], 0.5);
	+ double pt2GeV_c = CalculateNCharge(m_goodJets[pos_c], 2.0);
	+ double pt5GeV_c = CalculateNCharge(m_goodJets[pos_c], 5.0);
	+ double pT_c = m_goodJets[pos_c].pT();
	+
	+ forward_500MeV->fill(pT_f, pt500MeV_f, weight);
	+ forward_2GeV->fill( pT_f, pt2GeV_f, weight);
	+ forward_5GeV->fill( pT_f, pt5GeV_f, weight);
	+
	+ central_500MeV->fill(pT_c, pt500MeV_c, weight);
	+ central_2GeV->fill( pT_c, pt2GeV_c, weight);
	+ central_5GeV->fill( pT_c, pt5GeV_c, weight);
	+ }
	+
	+ double CalculateNCharge(Jet& jet, double pTcut=0.5) {
	+ unsigned int ncharge = 0;
	+ foreach (const Particle& p, jet.particles()) {
	+ if (p.pT() < pTcut) continue;
	+ if (p.threeCharge()) ++ncharge;
	+ }
	+ if (ncharge > 60) ncharge = 60;
	+ return double(ncharge);
	+ }
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ if (numEvents() > 2) {
	+ for (unsigned int i = 0; i < forward_500MeV->numBins(); ++i) {
	+ ProfileBin1D bsum = central_500MeV->bin(i) + forward_500MeV->bin(i);
	+ ProfileBin1D bsum2 = central_2GeV->bin(i) + forward_2GeV->bin(i);
	+ ProfileBin1D bsum5 = central_5GeV->bin(i) + forward_5GeV->bin(i);
	+ ProfileBin1D bdiff = central_500MeV->bin(i) - forward_500MeV->bin(i);
	+ ProfileBin1D bdiff2 = central_2GeV->bin(i) - forward_2GeV->bin(i);
	+ ProfileBin1D bdiff5 = central_5GeV->bin(i) - forward_5GeV->bin(i);
	+
	+ double ydiff = central_500MeV->bin(i).numEntries()? central_500MeV->bin(i).mean() : 0.0;
	+ double ydiff2 = central_2GeV->bin(i).numEntries()? central_2GeV->bin(i).mean() : 0.0;
	+ double ydiff5 = central_5GeV->bin(i).numEntries()? central_5GeV->bin(i).mean() : 0.0;
	+ ydiff -= forward_500MeV->bin(i).numEntries()? forward_500MeV->bin(i).mean() : 0.0;
	+ ydiff2 -= forward_2GeV->bin(i).numEntries()? forward_2GeV->bin(i).mean() : 0.0;
	+ ydiff5 -= forward_5GeV->bin(i).numEntries()? forward_5GeV->bin(i).mean() : 0.0;
	+
	+ double yerr = bsum.numEntries()? bsum.stdErr() : 0.0;
	+ double yerr2 = bsum2.numEntries()? bsum2.stdErr() : 0.0;
	+ double yerr5 = bsum5.numEntries()? bsum5.stdErr() : 0.0;
	+
	+ diff_500MeV->point(i).setY(ydiff, yerr);
	+ diff_2GeV->point(i).setY(ydiff2, yerr2);
	+ diff_5GeV->point(i).setY(ydiff5, yerr5);
	+
	+ sum_500MeV->point(i).setY(bsum.numEntries()? bsum.mean() : 0.0, yerr);
	+ sum_2GeV->point(i).setY(bsum2.numEntries()? bsum2.mean() : 0.0, yerr2);
	+ sum_5GeV->point(i).setY(bsum5.numEntries()? bsum5.mean() : 0.0, yerr5);
	+ }
	+ }
	+
	+ }
	+
	+
	+ private:
	+
	+ Profile1DPtr forward_500MeV;
	+ Profile1DPtr forward_2GeV;
	+ Profile1DPtr forward_5GeV;
	+
	+ Profile1DPtr central_500MeV;
	+ Profile1DPtr central_2GeV;
	+ Profile1DPtr central_5GeV;
	+
	+ Scatter2DPtr sum_500MeV;
	+ Scatter2DPtr sum_2GeV;
	+ Scatter2DPtr sum_5GeV;
	+
	+ Scatter2DPtr diff_500MeV;
	+ Scatter2DPtr diff_2GeV;
	+ Scatter2DPtr diff_5GeV;
	+
	+ };
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1419070);
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1419652.cc b/src/Analyses/ATLAS_2016_I1419652.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1419652.cc
	@@ -0,0 +1,178 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ class ATLAS_2016_I1419652 : public Analysis {
	+ public:
	+
	+ /// Particle types included
	+ enum PartTypes {
	+ k_NoStrange,
	+ k_AllCharged,
	+ kNPartTypes
	+ };
	+
	+ /// Phase space regions
	+ enum RegionID {
	+ k_pt500_nch1_eta25,
	+ k_pt500_nch1_eta08,
	+ kNregions
	+ };
	+
	+ /// Nch cut for each region
	+ const static int nchCut[kNregions];
	+
	+
	+ /// Default constructor
	+ ATLAS_2016_I1419652() : Analysis("ATLAS_2016_I1419652") {
	+ for (int iT = 0; iT < kNPartTypes; ++iT) {
	+ for (int iR = 0; iR < kNregions; ++iR) {
	+ _sumW[iT][iR] = 0.;
	+ }
	+ }
	+ }
	+
	+
	+ /// Initialization, called once before running
	+ void init() {
	+
	+ // Projections
	+ const ChargedFinalState cfs500_25(-2.5, 2.5, 500.0*MeV);
	+ declare(cfs500_25, "CFS500_25");
	+
	+ const ChargedFinalState cfs500_08(-0.8, 0.8, 500.0*MeV);
	+ declare(cfs500_08, "CFS500_08");
	+
	+ for (int iT = 0; iT < kNPartTypes; ++iT) {
	+ for (int iR = 0; iR < kNregions; ++iR) {
	+ _hist_nch [iT][iR] = bookHisto1D ( 1, iR + 1, iT + 1);
	+ _hist_pt [iT][iR] = bookHisto1D ( 2, iR + 1, iT + 1);
	+ _hist_eta [iT][iR] = bookHisto1D ( 3, iR + 1, iT + 1);
	+ _hist_ptnch[iT][iR] = bookProfile1D( 4, iR + 1, iT + 1);
	+ }
	+ }
	+ }
	+
	+
	+ void analyze(const Event& event) {
	+ string fsName;
	+ for (int iR = 0; iR < kNregions; ++iR) {
	+ switch (iR) {
	+ case k_pt500_nch1_eta25: fsName = "CFS500_25"; break;
	+ case k_pt500_nch1_eta08: fsName = "CFS500_08"; break;
	+ }
	+
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, fsName);
	+
	+ /// What's the benefit in separating this code which is only called from one place?!
	+ fillPtEtaNch(cfs, iR, event.weight());
	+ }
	+ }
	+
	+
	+
	+ void finalize() {
	+ // Standard histograms
	+ for (int iT = 0; iT < kNPartTypes; ++iT) {
	+ for (int iR = 0; iR < kNregions; ++iR) {
	+
	+ double etaRangeSize = -999.0; //intentionally crazy
	+ switch (iR) {
	+ case k_pt500_nch1_eta25 : etaRangeSize = 5.0 ; break;
	+ case k_pt500_nch1_eta08 : etaRangeSize = 1.6 ; break;
	+ default: etaRangeSize = -999.0; break; //intentionally crazy
	+ }
	+
	+ if (_sumW[iT][iR] > 0) {
	+ scale(_hist_nch[iT][iR], 1.0/_sumW[iT][iR]);
	+ scale(_hist_pt [iT][iR], 1.0/_sumW[iT][iR]/TWOPI/etaRangeSize);
	+ scale(_hist_eta[iT][iR], 1.0/_sumW[iT][iR]);
	+ } else {
	+ MSG_WARNING("Sum of weights is zero (!) in type/region: " << iT << " " << iR);
	+ }
	+ }
	+ }
	+ }
	+
	+
	+ /// Helper for collectively filling Nch, pT, eta, and pT vs. Nch histograms
	+ void fillPtEtaNch(const ChargedFinalState& cfs, int iRegion, double weight) {
	+
	+ // Get number of particles
	+ int nch[kNPartTypes];
	+ int nch_noStrange = 0;
	+ foreach (const Particle& p, cfs.particles()) {
	+ PdgId pdg = p.abspid ();
	+ if ( pdg == 3112 \|\| // Sigma-
	+ pdg == 3222 \|\| // Sigma+
	+ pdg == 3312 \|\| // Xi-
	+ pdg == 3334 ) // Omega-
	+ continue;
	+ nch_noStrange++;
	+ }
	+ nch[k_AllCharged] = cfs.size();
	+ nch[k_NoStrange ] = nch_noStrange;
	+
	+ // Skip if event fails cut for all charged (noStrange will always be less)
	+ if (nch[k_AllCharged] < nchCut[iRegion]) return;
	+
	+ // Fill event weight info
	+ _sumW[k_AllCharged][iRegion] += weight;
	+ if (nch[k_NoStrange ] >= nchCut[iRegion]) {
	+ _sumW[k_NoStrange][iRegion] += weight;
	+ }
	+
	+ // Fill nch
	+ _hist_nch[k_AllCharged][iRegion]->fill(nch[k_AllCharged], weight);
	+ if (nch[k_NoStrange ] >= nchCut[iRegion]) {
	+ _hist_nch [k_NoStrange][iRegion]->fill(nch[k_NoStrange ], weight);
	+ }
	+
	+ // Loop over particles, fill pT, eta and ptnch
	+ foreach (const Particle& p, cfs.particles()) {
	+ const double pt = p.pT()/GeV;
	+ const double eta = p.eta();
	+ _hist_pt [k_AllCharged][iRegion]->fill(pt , weight/pt);
	+ _hist_eta [k_AllCharged][iRegion]->fill(eta, weight);
	+ _hist_ptnch [k_AllCharged][iRegion]->fill(nch[k_AllCharged], pt, weight);
	+
	+ // Make sure nch cut is passed for nonStrange particles!
	+ if (nch[k_NoStrange ] >= nchCut[iRegion]) {
	+ PdgId pdg = p.abspid ();
	+ if ( pdg == 3112 \|\| // Sigma-
	+ pdg == 3222 \|\| // Sigma+
	+ pdg == 3312 \|\| // Xi-
	+ pdg == 3334 ) // Omega-
	+ continue;
	+ // Here we don't have strange particles anymore
	+ _hist_pt [k_NoStrange][iRegion]->fill(pt , weight/pt);
	+ _hist_eta [k_NoStrange][iRegion]->fill(eta, weight);
	+ _hist_ptnch[k_NoStrange][iRegion]->fill(nch[k_NoStrange], pt, weight);
	+ }
	+ }
	+ }
	+
	+
	+ private:
	+
	+ double _sumW[kNPartTypes][kNregions];
	+
	+ Histo1DPtr _hist_nch [kNPartTypes][kNregions];
	+ Histo1DPtr _hist_pt [kNPartTypes][kNregions];
	+ Histo1DPtr _hist_eta [kNPartTypes][kNregions];
	+ Profile1DPtr _hist_ptnch[kNPartTypes][kNregions];
	+
	+ };
	+
	+
	+ // Constants: pT & eta regions
	+ const int ATLAS_2016_I1419652::nchCut[] = {1, 1};
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1419652);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1424838.cc b/src/Analyses/ATLAS_2016_I1424838.cc
	--- a/src/Analyses/ATLAS_2016_I1424838.cc
	+++ b/src/Analyses/ATLAS_2016_I1424838.cc
	@@ -1,260 +1,222 @@
	-// -- C++ --
	#include "Rivet/Analysis.hh"
	-#include "Rivet/Tools/Logging.hh"
	-#include "Rivet/Math/MathUtils.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FParameter.hh"
	#include "Rivet/Projections/Spherocity.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	-#include "Rivet/Tools/ParticleIdUtils.hh"
	-#include <sstream>
	-#include <assert.h> /* assert */
	+
	namespace Rivet {


	-class ATLAS_2016_I1424838 : public Analysis {
	-public:
	-
	- /// @name Constructors etc.
	- //@{
	+ /// @brief Event shapes in leptonic $Z$-events
	+ class ATLAS_2016_I1424838 : public Analysis {
	+ public:

	/// Constructor
	- ATLAS_2016_I1424838()
	- : Analysis("ATLAS_2016_I1424838")
	- {
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_I1424838);


	- }
	-
	- //@}
	-
	-
	-public:
	-
	- // Convenience method for histogram booking
	- string mkHistoName(int idDS, int channel, int i) {
	- std::stringstream s;
	- s << "d0" << idDS << "-x0" << channel << "-y0" << i+1;
	- return s.str();
	- }
	-
	/// Book histograms and initialise projections before the run
	void init() {

	-
	-
	// Charged particles inside acceptance region
	- const ChargedFinalState cfs(Cuts::abseta<2.5 && Cuts::pT> 500*MeV);
	- addProjection(cfs, "CFS");
	+ const ChargedFinalState cfs(Cuts::abseta < 2.5 && Cuts::pT > 500*MeV);
	+ declare(cfs, "CFS");

	// ZFinders
	ZFinder zfinder(cfs, Cuts::abseta<2.4 && Cuts::pT>20.0GeV, PID::ELECTRON, 66GeV, 116*GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- //ZFinder zfinder( -2.4, 2.4, 20.0, ELECTRON, 66.0GeV, 116.0GeV, 0.1, true, true);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");
	ZFinder zfinder_mu(cfs, Cuts::abseta<2.4 && Cuts::pT>20.0GeV, PID::MUON, 66GeV, 116*GeV, 0.1, ZFinder::CLUSTERNODECAY);
	- //ZFinder zfinder_mu(-2.4, 2.4, 20.0, MUON, 66.0GeV, 116.0GeV, 0.1, true, true);
	- addProjection(zfinder_mu, "ZFinderMu");
	+ declare(zfinder_mu, "ZFinderMu");

	// This CFS only contains charged particles inside the acceptance excluding the leptons
	VetoedFinalState remfs(cfs);
	remfs.addVetoOnThisFinalState(zfinder);
	remfs.addVetoOnThisFinalState(zfinder_mu);
	- addProjection(remfs, "REMFS");
	-
	- //const FParameter fparam(zfinder.remainingFinalState());
	+ declare(remfs, "REMFS");
	+
	const FParameter fparam(remfs);
	- addProjection(fparam, "FParameter_");
	+ declare(fparam, "FParameter_");

	- //const Spherocity sphero(zfinder.remainingFinalState());
	const Spherocity sphero(remfs);
	- addProjection(sphero, "Spherocity_");
	+ declare(sphero, "Spherocity_");


	// Booking of ES histos
	for (size_t alg = 0; alg < 5; ++alg) {
	// Book the inclusive histograms
	- Elec_Ntrk[alg] = bookHisto1D(mkHistoName(1, 1, alg));
	- Elec_SumPt[alg] = bookHisto1D(mkHistoName(2, 1, alg));
	- Elec_Beamthrust[alg] = bookHisto1D(mkHistoName(3, 1, alg));
	- Elec_Thrust[alg] = bookHisto1D(mkHistoName(4, 1, alg));
	- Elec_FParam[alg] = bookHisto1D(mkHistoName(5, 1, alg));
	- Elec_Spherocity[alg] = bookHisto1D(mkHistoName(6, 1, alg));
	- Muon_Ntrk[alg] = bookHisto1D(mkHistoName(1, 2, alg));
	- Muon_SumPt[alg] = bookHisto1D(mkHistoName(2, 2, alg));
	- Muon_Beamthrust[alg] = bookHisto1D(mkHistoName(3, 2, alg));
	- Muon_Thrust[alg] = bookHisto1D(mkHistoName(4, 2, alg));
	- Muon_FParam[alg] = bookHisto1D(mkHistoName(5, 2, alg));
	- Muon_Spherocity[alg] = bookHisto1D(mkHistoName(6, 2, alg));
	+ _h_Elec_Ntrk[alg] = bookHisto1D(_mkHistoName(1, 1, alg));
	+ _h_Elec_SumPt[alg] = bookHisto1D(_mkHistoName(2, 1, alg));
	+ _h_Elec_Beamthrust[alg] = bookHisto1D(_mkHistoName(3, 1, alg));
	+ _h_Elec_Thrust[alg] = bookHisto1D(_mkHistoName(4, 1, alg));
	+ _h_Elec_FParam[alg] = bookHisto1D(_mkHistoName(5, 1, alg));
	+ _h_Elec_Spherocity[alg] = bookHisto1D(_mkHistoName(6, 1, alg));
	+ _h_Muon_Ntrk[alg] = bookHisto1D(_mkHistoName(1, 2, alg));
	+ _h_Muon_SumPt[alg] = bookHisto1D(_mkHistoName(2, 2, alg));
	+ _h_Muon_Beamthrust[alg] = bookHisto1D(_mkHistoName(3, 2, alg));
	+ _h_Muon_Thrust[alg] = bookHisto1D(_mkHistoName(4, 2, alg));
	+ _h_Muon_FParam[alg] = bookHisto1D(_mkHistoName(5, 2, alg));
	+ _h_Muon_Spherocity[alg] = bookHisto1D(_mkHistoName(6, 2, alg));
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	-
	- // Get generator weight
	- const double weight = event.weight();

	- // Check for Z boson in event
	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "ZFinder");
	- const ZFinder& zfinder_mu = applyProjection<ZFinder>(event, "ZFinderMu");
	- bool isElec = false;
	- bool isMuon = false;
	- if (zfinder.bosons().size() != 1) {
	- MSG_DEBUG("Num e+ e- pairs found = " << zfinder.bosons().size());
	+ // Get generator weight
	+ const double weight = event.weight();
	+
	+ // Check for Z boson in event
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");
	+ MSG_DEBUG("Num e+ e- pairs found = " << zfinder.bosons().size());
	+ const bool isElec = zfinder.bosons().size() == 1;
	+
	+ const ZFinder& zfinder_mu = apply<ZFinder>(event, "ZFinderMu");
	+ MSG_DEBUG("Num mu+ mu- pairs found = " << zfinder_mu.bosons().size());
	+ const bool isMuon = zfinder_mu.bosons().size() == 1;
	+
	+ // Only accept events with exactly two electrons or exactly two muons
	+ if (isElec && isMuon) vetoEvent;
	+ if (!(isElec \|\| isMuon)) vetoEvent;
	+
	+ // This determines the Zpt phase-space
	+ double zpT = -1000;
	+ if (isElec) zpT = zfinder.bosons()[0].pT();
	+ if (isMuon) zpT = zfinder_mu.bosons()[0].pT();
	+
	+ unsigned int alg = 4; //< for > 25 GeV
	+ if (zpT < 6*GeV) alg = 1;
	+ else if (inRange(zpT/GeV, 6, 12)) alg = 2;
	+ else if (inRange(zpT/GeV, 12, 25)) alg = 3;
	+ assert(alg < 5);
	+ assert(alg > 0);
	+
	+ // All charged particles within \|eta\|<2.5 except the leptons from Z-decay
	+ const VetoedFinalState& remfs = apply<VetoedFinalState>(event, "REMFS");
	+ // sumPt and Beamthrust (the latter will only be filled if the min Nch criterion is met)
	+ // and Thrust preparation
	+ double sumPt = 0.0, beamThrust = 0.0;
	+
	+ vector<Vector3> momenta;
	+ foreach(const Particle& p , remfs.particles()) {
	+ double pT = fabs(p.momentum().pT());
	+ double eta = p.momentum().eta();
	+ sumPt += pT;
	+ beamThrust += pTexp(-1.0fabs(eta));
	+ Vector3 mom = p.momentum().vector3();
	+ mom.setZ(0.0);
	+ momenta.push_back(mom);
	+ }
	+
	+
	+ // Fill inclusive histos
	+ if (isElec) {
	+ _h_Elec_Ntrk[alg] ->fill(remfs.size(), weight);
	+ _h_Elec_Ntrk[0] ->fill(remfs.size(), weight);
	+ _h_Elec_SumPt[alg] ->fill(sumPt, weight);
	+ _h_Elec_SumPt[0] ->fill(sumPt, weight);
	+ }
	+ if (isMuon) {
	+ _h_Muon_Ntrk[alg] ->fill(remfs.size(), weight);
	+ _h_Muon_Ntrk[0] ->fill(remfs.size(), weight);
	+ _h_Muon_SumPt[alg] ->fill(sumPt, weight);
	+ _h_Muon_SumPt[0] ->fill(sumPt, weight);
	+ }
	+
	+ // Skip event shape calculation if we don't match the minimum Nch criterion
	+ if (remfs.size() >=2) {
	+
	+ // Eventshape calculations
	+
	+ // Calculate transverse Thrust using all charged FS particles except the lepton
	+ // This is copied/inspired from the CMS_6000011_S8957746 analysis
	+ if (momenta.size() == 2) {
	+ // We need to use a ghost so that Thrust.calc() doesn't return 1.
	+ momenta.push_back(Vector3(1e-10*MeV, 0., 0.));
	}
	- else {
	- isElec = true;
	- }
	-
	- if (zfinder_mu.bosons().size() != 1) {
	- MSG_DEBUG("Num mu+ mu- pairs found = " << zfinder_mu.bosons().size());
	- }
	- else {
	- isMuon = true;
	- }
	+ Thrust thrustC;
	+ thrustC.calc(momenta);

	- // Only accept events with exactly two electrons or exactly two muons
	- if (isElec && isMuon) vetoEvent;
	- if (!(isElec \|\| isMuon)) vetoEvent;
	+ double thrust = thrustC.thrust();

	- // this determines the Zpt phase-space
	- double zpT=-1000;
	- if (isElec) zpT = zfinder.bosons()[0].momentum().perp();
	- if (isMuon) zpT = zfinder_mu.bosons()[0].momentum().perp();
	+ // F-Parameter
	+ const FParameter& fparam = apply<FParameter>(event, "FParameter_");
	+ // Spherocity
	+ const Spherocity& sphero = apply<Spherocity>(event, "Spherocity_");

	- unsigned int alg;
	- if ( zpT/MeV < 6000.) alg=1;
	- else if ( zpT/MeV >= 6000. && zpT/MeV < 12000.) alg=2;
	- else if ( zpT/MeV >= 12000. && zpT/MeV < 25000.) alg=3;
	- else alg=4;
	-
	-
	- assert(alg<5);
	- assert(alg>0);
	-
	- // All charged particles within \|eta\|<2.5 except the leptons from Z-decay
	- const VetoedFinalState& remfs = applyProjection<VetoedFinalState>(event, "REMFS");
	- // sumPt and Beamthrust (the latter will only be filled if the min Nch criterion is met)
	- // and Thrust preparation
	-
	- double sumPt = 0.0;
	- double beamThrust = 0.0;
	-
	-
	-
	- std::vector<Vector3> momenta;
	- foreach(const Particle& p , remfs.particles()) {
	- double pT = fabs(p.momentum().pT());
	- double eta = p.momentum().eta();
	- sumPt += pT;
	- beamThrust += pTexp(-1.0fabs(eta));
	- Vector3 mom = p.momentum().vector3();
	- mom.setZ(0.0);
	- momenta.push_back(mom);
	- }
	-
	+ // Histos differential in NMPI

	// Fill inclusive histos
	if (isElec) {
	- Elec_Ntrk[alg] ->fill(remfs.size(), weight);
	- Elec_Ntrk[0] ->fill(remfs.size(), weight);
	- Elec_SumPt[alg] ->fill(sumPt, weight);
	- Elec_SumPt[0] ->fill(sumPt, weight);
	+ _h_Elec_Thrust[alg] ->fill(thrust, weight);
	+ _h_Elec_Thrust[0] ->fill(thrust, weight);
	+ _h_Elec_FParam[alg] ->fill(fparam.F(), weight);
	+ _h_Elec_FParam[0] ->fill(fparam.F(), weight);
	+ _h_Elec_Spherocity[alg] ->fill(sphero.spherocity(), weight);
	+ _h_Elec_Spherocity[0] ->fill(sphero.spherocity(), weight);
	+ _h_Elec_Beamthrust[alg] ->fill(beamThrust, weight);
	+ _h_Elec_Beamthrust[0] ->fill(beamThrust, weight);
	}
	if (isMuon) {
	- Muon_Ntrk[alg] ->fill(remfs.size(), weight);
	- Muon_Ntrk[0] ->fill(remfs.size(), weight);
	- Muon_SumPt[alg] ->fill(sumPt, weight);
	- Muon_SumPt[0] ->fill(sumPt, weight);
	+ _h_Muon_Thrust[alg] ->fill(thrust, weight);
	+ _h_Muon_Thrust[0] ->fill(thrust, weight);
	+ _h_Muon_FParam[alg] ->fill(fparam.F(), weight);
	+ _h_Muon_FParam[0] ->fill(fparam.F(), weight);
	+ _h_Muon_Spherocity[alg] ->fill(sphero.spherocity(), weight);
	+ _h_Muon_Spherocity[0] ->fill(sphero.spherocity(), weight);
	+ _h_Muon_Beamthrust[alg] ->fill(beamThrust, weight);
	+ _h_Muon_Beamthrust[0] ->fill(beamThrust, weight);
	}
	-
	- // Skip event shape calculation if we don't match the minimum Nch criterion
	- if (remfs.size() >=2) {
	-
	- // Eventshape calculations
	-
	- // Calculate transverse Thrust using all charged FS particles except the lepton
	- // This is copied/inspired from the CMS_6000011_S8957746 analysis
	- if (momenta.size() == 2) {
	- // We need to use a ghost so that Thrust.calc() doesn't return 1.
	- momenta.push_back(Vector3(1e-10*MeV, 0., 0.));
	- }
	- Thrust thrustC;
	- thrustC.calc(momenta);
	-
	- double thrust = thrustC.thrust();
	-
	- // F-Parameter
	- const FParameter& fparam = applyProjection<FParameter>(event, "FParameter_");
	- // Spherocity
	- const Spherocity& sphero = applyProjection<Spherocity>(event, "Spherocity_");
	-
	- // Histos differential in NMPI
	-
	- // Fill inclusive histos
	- if (isElec) {
	- Elec_Thrust[alg] ->fill(thrust, weight);
	- Elec_Thrust[0] ->fill(thrust, weight);
	- Elec_FParam[alg] ->fill(fparam.F(), weight);
	- Elec_FParam[0] ->fill(fparam.F(), weight);
	- Elec_Spherocity[alg] ->fill(sphero.spherocity(), weight);
	- Elec_Spherocity[0] ->fill(sphero.spherocity(), weight);
	- Elec_Beamthrust[alg] ->fill(beamThrust, weight);
	- Elec_Beamthrust[0] ->fill(beamThrust, weight);
	- }
	- if (isMuon) {
	- Muon_Thrust[alg] ->fill(thrust, weight);
	- Muon_Thrust[0] ->fill(thrust, weight);
	- Muon_FParam[alg] ->fill(fparam.F(), weight);
	- Muon_FParam[0] ->fill(fparam.F(), weight);
	- Muon_Spherocity[alg] ->fill(sphero.spherocity(), weight);
	- Muon_Spherocity[0] ->fill(sphero.spherocity(), weight);
	- Muon_Beamthrust[alg] ->fill(beamThrust, weight);
	- Muon_Beamthrust[0] ->fill(beamThrust, weight);
	- }
	- }
	+ }
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	- for (size_t alg = 0; alg < 5; ++alg) {
	- normalize(Elec_Ntrk[alg]);
	- normalize(Elec_SumPt[alg]);
	- normalize(Elec_Beamthrust[alg]);
	- normalize(Elec_Thrust[alg]);
	- normalize(Elec_FParam[alg]);
	- normalize(Elec_Spherocity[alg]);
	- normalize(Muon_Ntrk[alg]);
	- normalize(Muon_SumPt[alg]);
	- normalize(Muon_Beamthrust[alg]);
	- normalize(Muon_Thrust[alg]);
	- normalize(Muon_FParam[alg]);
	- normalize(Muon_Spherocity[alg]);
	- }
	+ for (size_t alg = 0; alg < 5; ++alg) {
	+ normalize(_h_Elec_Ntrk[alg]);
	+ normalize(_h_Elec_SumPt[alg]);
	+ normalize(_h_Elec_Beamthrust[alg]);
	+ normalize(_h_Elec_Thrust[alg]);
	+ normalize(_h_Elec_FParam[alg]);
	+ normalize(_h_Elec_Spherocity[alg]);
	+ normalize(_h_Muon_Ntrk[alg]);
	+ normalize(_h_Muon_SumPt[alg]);
	+ normalize(_h_Muon_Beamthrust[alg]);
	+ normalize(_h_Muon_Thrust[alg]);
	+ normalize(_h_Muon_FParam[alg]);
	+ normalize(_h_Muon_Spherocity[alg]);
	+ }
	}

	-private:

	- Histo1DPtr Elec_Ntrk[5];
	- Histo1DPtr Elec_SumPt[5];
	- Histo1DPtr Elec_Beamthrust[5];
	- Histo1DPtr Elec_Thrust[5];
	- Histo1DPtr Elec_FParam[5];
	- Histo1DPtr Elec_Spherocity[5];
	+ private:

	- Histo1DPtr Muon_Ntrk[5];
	- Histo1DPtr Muon_SumPt[5];
	- Histo1DPtr Muon_Beamthrust[5];
	- Histo1DPtr Muon_Thrust[5];
	- Histo1DPtr Muon_FParam[5];
	- Histo1DPtr Muon_Spherocity[5];
	-};
	+ // Convenience method for histogram booking
	+ string _mkHistoName(int idDS, int channel, int i) {
	+ return "d0" + toString(idDS) + "-x0" + toString(channel) + "-y0" + toString(i+1);
	+ }

	-// This global object acts as a hook for the plugin system
	-DECLARE_RIVET_PLUGIN(ATLAS_2016_I1424838);
	+ Histo1DPtr _h_Elec_Ntrk[5];
	+ Histo1DPtr _h_Elec_SumPt[5];
	+ Histo1DPtr _h_Elec_Beamthrust[5];
	+ Histo1DPtr _h_Elec_Thrust[5];
	+ Histo1DPtr _h_Elec_FParam[5];
	+ Histo1DPtr _h_Elec_Spherocity[5];
	+
	+ Histo1DPtr _h_Muon_Ntrk[5];
	+ Histo1DPtr _h_Muon_SumPt[5];
	+ Histo1DPtr _h_Muon_Beamthrust[5];
	+ Histo1DPtr _h_Muon_Thrust[5];
	+ Histo1DPtr _h_Muon_FParam[5];
	+ Histo1DPtr _h_Muon_Spherocity[5];
	+
	+ };
	+
	+
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1424838);
	+

	}
	diff --git a/src/Analyses/ATLAS_2016_I1426695.cc b/src/Analyses/ATLAS_2016_I1426695.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1426695.cc
	@@ -0,0 +1,130 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Add a short analysis description here
	+ class ATLAS_2016_I1426695 : public Analysis {
	+ public:
	+
	+ //phase space regions
	+ enum regionID {
	+ k_pt100_nch2 = 0,
	+ k_pt500_nch1,
	+ k_pt500_nch6,
	+ k_pt500_nch20,
	+ k_pt500_nch50,
	+ kNregions
	+ };
	+
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_I1426695);
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ for (int iR=0; iR < kNregions; ++iR) {
	+ _sumW[iR] = 0.;
	+ }
	+
	+ // Initialise and register projections
	+ declare(ChargedFinalState(Cuts::abseta < 2.5 && Cuts::pT > 100*MeV), "CFS_100");
	+ declare(ChargedFinalState(Cuts::abseta < 2.5 && Cuts::pT > 500*MeV), "CFS_500");
	+
	+ // Book histograms
	+ for (int iR=0; iR < kNregions; ++iR) {
	+ if (iR == k_pt100_nch2 \|\| iR == k_pt500_nch1) {
	+ _hist_nch [iR] = bookHisto1D (1, iR + 1, 1);
	+ _hist_ptnch[iR] = bookProfile1D(4, iR + 1, 1);
	+ }
	+ _hist_pt [iR] = bookHisto1D(2, iR + 1, 1);
	+ _hist_eta[iR] = bookHisto1D(3, iR + 1, 1);
	+ }
	+ }
	+
	+ void fillPtEtaNch(const Particles particles, int nMin, int iRegion, double weight) {
	+
	+ //skip if event fails multiplicity cut
	+ int nch =particles.size();
	+ if (nch < nMin) return;
	+
	+ //fill event weight info
	+ _sumW[iRegion] += weight;
	+
	+ // Fill nch
	+ if (iRegion == k_pt100_nch2 \|\| iRegion == k_pt500_nch1) {
	+ _hist_nch[iRegion]->fill(nch, weight);
	+ }
	+
	+ for (const Particle&p : particles) {
	+ // Loop over particles, fill pT, eta and ptnch
	+ const double pt = p.pT()/GeV;
	+ const double eta = p.eta();
	+
	+ _hist_pt [iRegion]->fill(pt , weight/pt);
	+ _hist_eta[iRegion]->fill(eta, weight);
	+
	+ if (iRegion == k_pt100_nch2 \|\| iRegion == k_pt500_nch1) {
	+ _hist_ptnch[iRegion]->fill(nch, pt, weight);
	+ }
	+ } //end loop over particles
	+ }
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get charged particles, omitting some strange heavies
	+ const Cut& pcut = (
	+ (Cuts::abspid!=PID::SIGMAMINUS) && (Cuts::abspid!=PID::SIGMAPLUS) &&
	+ (Cuts::abspid!=PID::XIMINUS) && (Cuts::abspid!=PID::OMEGAMINUS));
	+ const Particles& p_100 = apply<ChargedFinalState>(event, "CFS_100").particles(pcut);
	+ const Particles& p_500 = apply<ChargedFinalState>(event, "CFS_500").particles(pcut);
	+
	+ fillPtEtaNch(p_100, 2, 0, event.weight());
	+ fillPtEtaNch(p_500, 1, 1, event.weight());
	+ fillPtEtaNch(p_500, 6, 2, event.weight());
	+ fillPtEtaNch(p_500, 20, 3, event.weight());
	+ fillPtEtaNch(p_500, 50, 4, event.weight());
	+ }
	+
	+
	+ void finalize() {
	+
	+ for (int iR = 0; iR < kNregions; ++iR) {
	+ if (_sumW[iR] > 0) {
	+ if (iR == k_pt100_nch2 \|\| iR == k_pt500_nch1) {
	+ scale(_hist_nch[iR], 1.0/_sumW[iR]);
	+ }
	+ scale(_hist_pt [iR], 1.0/_sumW[iR]/TWOPI/5.);
	+ scale(_hist_eta[iR], 1.0/_sumW[iR]);
	+ }
	+ }
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ double _sumW[kNregions];
	+
	+ /// @name Histograms
	+ Histo1DPtr _hist_nch [kNregions];
	+ Histo1DPtr _hist_pt [kNregions];
	+ Histo1DPtr _hist_eta [kNregions];
	+ Profile1DPtr _hist_ptnch [kNregions];
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1426695);
	+
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1444991.cc b/src/Analyses/ATLAS_2016_I1444991.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1444991.cc
	@@ -0,0 +1,195 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/DressedLeptons.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/VetoedFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/VisibleFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ class ATLAS_2016_I1444991 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_I1444991);
	+
	+
	+ public:
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // All particles within \|eta\| < 5.0
	+ const FinalState FS(Cuts::abseta < 5.0);
	+
	+ // Project photons for dressing
	+ IdentifiedFinalState photon_id(FS);
	+ photon_id.acceptIdPair(PID::PHOTON);
	+
	+ // Project dressed electrons with pT > 15 GeV and \|eta\| < 2.47
	+ IdentifiedFinalState el_id(FS);
	+ el_id.acceptIdPair(PID::ELECTRON);
	+ PromptFinalState el_bare(el_id);
	+ Cut cuts = (Cuts::abseta < 2.47) && ( (Cuts::abseta <= 1.37) \|\| (Cuts::abseta >= 1.52) ) && (Cuts::pT > 15*GeV);
	+ DressedLeptons el_dressed_FS(photon_id, el_bare, 0.1, cuts, true, true);
	+ declare(el_dressed_FS,"EL_DRESSED_FS");
	+
	+ // Project dressed muons with pT > 15 GeV and \|eta\| < 2.5
	+ IdentifiedFinalState mu_id(FS);
	+ mu_id.acceptIdPair(PID::MUON);
	+ PromptFinalState mu_bare(mu_id);
	+ DressedLeptons mu_dressed_FS(photon_id, mu_bare, 0.1, Cuts::abseta < 2.5 && Cuts::pT > 15*GeV, true, true);
	+ declare(mu_dressed_FS,"MU_DRESSED_FS");
	+
	+ // get MET from generic invisibles
	+ VetoedFinalState inv_fs(FS);
	+ inv_fs.addVetoOnThisFinalState(VisibleFinalState(FS));
	+ declare(inv_fs, "InvisibleFS");
	+
	+ // Project jets
	+ FastJets jets(FS, FastJets::ANTIKT, 0.4);
	+ jets.useInvisibles(JetAlg::NO_INVISIBLES);
	+ jets.useMuons(JetAlg::NO_MUONS);
	+ declare(jets, "jets");
	+
	+ // Book histograms
	+ _h_Njets = bookHisto1D( 2,1,1);
	+ _h_PtllMET = bookHisto1D( 3,1,1);
	+ _h_Yll = bookHisto1D( 4,1,1);
	+ _h_PtLead = bookHisto1D( 5,1,1);
	+ _h_Njets_norm = bookHisto1D( 6,1,1);
	+ _h_PtllMET_norm = bookHisto1D( 7,1,1);
	+ _h_Yll_norm = bookHisto1D( 8,1,1);
	+ _h_PtLead_norm = bookHisto1D( 9,1,1);
	+ _h_JetVeto = bookScatter2D(10, 1, 1, true);
	+
	+ //histos for jetveto
	+ std::vector<double> ptlead25_bins = { 0., 25., 300. };
	+ std::vector<double> ptlead40_bins = { 0., 40., 300. };
	+ _h_pTj1_sel25 = bookHisto1D( "pTj1_sel25", ptlead25_bins, "", "", "" );
	+ _h_pTj1_sel40 = bookHisto1D( "pTj1_sel40", ptlead40_bins, "", "", "" );
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ const double weight = event.weight();
	+
	+ // Get final state particles
	+ const FinalState& ifs = applyProjection<FinalState>(event, "InvisibleFS");
	+ const vector<DressedLepton>& good_mu = applyProjection<DressedLeptons>(event, "MU_DRESSED_FS").dressedLeptons();
	+ const vector<DressedLepton>& el_dressed = applyProjection<DressedLeptons>(event, "EL_DRESSED_FS").dressedLeptons();
	+ const Jets& jets = applyProjection<FastJets>(event, "jets").jetsByPt(Cuts::pT>25*GeV && Cuts::abseta < 4.5);
	+
	+ //find good electrons
	+ vector<DressedLepton> good_el;
	+ foreach(const DressedLepton& el, el_dressed){
	+ bool keep = true;
	+ foreach(const DressedLepton &mu, good_mu) {
	+ keep &= deltaR(el, mu) >= 0.1;
	+ }
	+ if (keep) good_el += el;
	+ }
	+
	+ // select only emu events
	+ if ((good_el.size() != 1) \|\| good_mu.size() != 1) vetoEvent;
	+
	+ //built dilepton
	+ FourMomentum dilep = good_el[0].momentum() + good_mu[0].momentum();
	+ double Mll = dilep.mass();
	+ double Yll = dilep.rapidity();
	+ double DPhill = fabs(deltaPhi(good_el[0], good_mu[0]));
	+ double pTl1 = (good_el[0].pT() > good_mu[0].pT())? good_el[0].pT() : good_mu[0].pT();
	+
	+ //get MET
	+ FourMomentum met;
	+ foreach (const Particle& p, ifs.particles()) met += p.momentum();
	+
	+ // do a few cuts before looking at jets
	+ if (pTl1 <= 22. \|\| DPhill >= 1.8 \|\| met.pT() <= 20.) vetoEvent;
	+ if (Mll <= 10. \|\| Mll >= 55.) vetoEvent;
	+
	+ Jets jets_selected;
	+ foreach (const Jet &j, jets) {
	+ if( j.abseta() > 2.4 && j.pT()<=30*GeV ) continue;
	+ bool keep = true;
	+ foreach(DressedLepton el, good_el) {
	+ keep &= deltaR(j, el) >= 0.3;
	+ }
	+ if (keep) jets_selected += j;
	+ }
	+
	+ double PtllMET = (met + good_el[0].momentum() + good_mu[0].momentum()).pT();
	+
	+ double Njets = jets_selected.size() > 2 ? 2 : jets_selected.size();
	+ double pTj1 = jets_selected.size()? jets_selected[0].pT() : 0.1;
	+
	+ // Fill histograms
	+ _h_Njets->fill(Njets, weight);
	+ _h_PtllMET->fill(PtllMET, weight);
	+ _h_Yll->fill(fabs(Yll), weight);
	+ _h_PtLead->fill(pTj1, weight);
	+ _h_Njets_norm->fill(Njets, weight);
	+ _h_PtllMET_norm->fill(PtllMET, weight);
	+ _h_Yll_norm->fill(fabs(Yll), weight);
	+ _h_PtLead_norm->fill(pTj1, weight);
	+ _h_pTj1_sel25->fill(pTj1, weight);
	+ _h_pTj1_sel40->fill(pTj1, weight);
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ const double xs = crossSectionPerEvent()/femtobarn;
	+
	+ /// @todo Normalise, scale and otherwise manipulate histograms here
	+ scale(_h_Njets, xs);
	+ scale(_h_PtllMET, xs);
	+ scale(_h_Yll, xs);
	+ scale(_h_PtLead, xs);
	+ normalize(_h_Njets_norm);
	+ normalize(_h_PtllMET_norm);
	+ normalize(_h_Yll_norm);
	+ normalize(_h_PtLead_norm);
	+ scale(_h_pTj1_sel25, xs);
	+ scale(_h_pTj1_sel40, xs);
	+ normalize(_h_pTj1_sel25);
	+ normalize(_h_pTj1_sel40);
	+ // fill jet veto efficiency histogram
	+ _h_JetVeto->point(0).setY(_h_pTj1_sel25->bin(0).sumW(), sqrt(_h_pTj1_sel25->bin(0).sumW2()));
	+ _h_JetVeto->point(1).setY(_h_PtLead_norm->bin(0).sumW(), sqrt(_h_PtLead_norm->bin(0).sumW2()));
	+ _h_JetVeto->point(2).setY(_h_pTj1_sel40->bin(0).sumW(), sqrt(_h_pTj1_sel25->bin(0).sumW2()));
	+
	+ }
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _h_Njets;
	+ Histo1DPtr _h_PtllMET;
	+ Histo1DPtr _h_Yll;
	+ Histo1DPtr _h_PtLead;
	+ Histo1DPtr _h_Njets_norm;
	+ Histo1DPtr _h_PtllMET_norm;
	+ Histo1DPtr _h_Yll_norm;
	+ Histo1DPtr _h_PtLead_norm;
	+
	+ Scatter2DPtr _h_JetVeto;
	+
	+ Histo1DPtr _h_pTj1_sel25;
	+ Histo1DPtr _h_pTj1_sel40;
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1444991);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1452559.cc b/src/Analyses/ATLAS_2016_I1452559.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1452559.cc
	@@ -0,0 +1,132 @@
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/VisibleFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/MissingMomentum.hh"
	+#include "Rivet/Projections/SmearedParticles.hh"
	+#include "Rivet/Projections/SmearedJets.hh"
	+#include "Rivet/Projections/SmearedMET.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// ATLAS 13 TeV monojet search with 3.2/fb of pp data
	+ class ATLAS_2016_I1452559 : public Analysis {
	+ public:
	+
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_I1452559);
	+
	+ void init() {
	+
	+ FastJets jets(FinalState(Cuts::abseta < 4.9), FastJets::ANTIKT, 0.4);
	+ SmearedJets recojets(jets, JET_SMEAR_ATLAS_RUN1);
	+ declare(recojets, "Jets");
	+
	+ FinalState electrons(Cuts::abspid == PID::ELECTRON && Cuts::abseta < 2.47 && Cuts::pT > 20*GeV);
	+ SmearedParticles recoelectrons(electrons, ELECTRON_EFF_ATLAS_RUN1);
	+ declare(recoelectrons, "Electrons");
	+
	+ FinalState muons(Cuts::abspid == PID::MUON && Cuts::abseta < 2.50 && Cuts::pT > 10*GeV);
	+ SmearedParticles recomuons(muons, MUON_EFF_ATLAS_RUN1);
	+ declare(recomuons, "Muons");
	+
	+ VisibleFinalState calofs(Cuts::abseta < 4.9 && Cuts::abspid != PID::MUON);
	+ MissingMomentum met(calofs);
	+ SmearedMET recomet(met, MET_SMEAR_ATLAS_RUN1);
	+ declare(recomet, "MET");
	+
	+
	+ /// Book histograms
	+ for (size_t i = 0; i < 7; ++i)
	+ _count_IM[i] = bookCounter("count_IM" + toString(i+1));
	+ for (size_t i = 0; i < 6; ++i)
	+ _count_EM[i] = bookCounter("count_EM" + toString(i+1));
	+
	+ }
	+
	+
	+ void analyze(const Event& event) {
	+
	+ const Jets jets = apply<JetAlg>(event, "Jets").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.8);
	+ const Particles elecs = apply<ParticleFinder>(event, "Electrons").particlesByPt();
	+ const Particles mus = apply<ParticleFinder>(event, "Muons").particlesByPt();
	+ MSG_DEBUG("Number of raw jets, electrons, muons = "
	+ << jets.size() << ", " << elecs.size() << ", " << mus.size());
	+
	+ // Discard jets very close to electrons, or with low track multiplicity and close to muons
	+ const Jets isojets = filter_discard(jets, [&](const Jet& j) {
	+ /// @todo Add track efficiency random filtering
	+ if (any(elecs, deltaRLess(j, 0.2))) return true;
	+ if (j.particles(Cuts::abscharge > 0 && Cuts::pT > 0.4*GeV).size() < 3 &&
	+ any(mus, deltaRLess(j, 0.4))) return true;
	+ return false;
	+ });
	+
	+ // Discard electrons close to remaining jets
	+ const Particles isoelecs = filter_discard(elecs, [&](const Particle& e) {
	+ return any(isojets, deltaRLess(e, 0.4));
	+ });
	+
	+ // Discard muons close to remaining jets
	+ const Particles isomus = filter_discard(mus, [&](const Particle& m) {
	+ for (const Jet& j : isojets) {
	+ if (deltaR(j,m) > 0.4) continue;
	+ if (j.particles(Cuts::abscharge > 0 && Cuts::pT > 0.4*GeV).size() > 3) return true;
	+ }
	+ return false;
	+ });
	+
	+ // Calculate ETmiss
	+ //const Vector3& vet = apply<MissingMomentum>(event, "MET").vectorEt();
	+ const Vector3& vet = apply<SmearedMET>(event, "MET").vectorEt();
	+ const double etmiss = vet.perp();
	+
	+
	+ // Event selection cuts
	+ if (etmiss < 250*GeV) vetoEvent;
	+ // Require at least one jet with pT > 250 GeV and \|eta\| < 2.4
	+ if (filter_select(isojets, Cuts::pT > 250*GeV && Cuts::abseta < 2.4).empty()) vetoEvent;
	+ // Require at most 4 jets with pT > 30 GeV and \|eta\| < 2.8
	+ if (filter_select(isojets, Cuts::pT > 30*GeV).size() > 4) vetoEvent;
	+ // Require no isolated jets within \|dphi\| < 0.4 of the MET vector
	+ if (any(isojets, deltaPhiLess(-vet, 0.4))) vetoEvent;
	+ // Require no isolated electrons or muons
	+ if (!isoelecs.empty() \|\| !isomus.empty()) vetoEvent;
	+
	+
	+ ////////////////////
	+
	+
	+ const double weight = event.weight();
	+
	+ // Get ETmiss bin number and fill counters
	+ const int i_etmiss = binIndex(etmiss/GeV, ETMISS_CUTS);
	+ // Inclusive ETmiss bins
	+ for (int ibin = 0; ibin < 7; ++ibin)
	+ if (i_etmiss >= ibin) _count_IM[ibin]->fill(weight);
	+ // Exclusive ETmiss bins
	+ if (inRange(i_etmiss, 0, 6)) _count_EM[i_etmiss]->fill(weight);
	+
	+ }
	+
	+
	+ void finalize() {
	+ const double norm = 3.2*crossSection()/femtobarn;
	+ scale(_count_IM, norm/sumOfWeights());
	+ scale(_count_EM, norm/sumOfWeights());
	+ }
	+
	+
	+ private:
	+
	+ const vector<double> ETMISS_CUTS = { 250, 300, 350, 400, 500, 600, 700, 13000 };
	+ CounterPtr _count_IM[7], _count_EM[6];
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1452559);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1457605.cc b/src/Analyses/ATLAS_2016_I1457605.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1457605.cc
	@@ -0,0 +1,130 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// Inclusive isolated prompt photon analysis with 2012 LHC data
	+ class ATLAS_2016_I1457605 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_I1457605);
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ FinalState fs;
	+ addProjection(fs, "FS");
	+
	+ // Consider the final state jets for the energy density calculation
	+ FastJets fj(fs, FastJets::KT, 0.5);
	+ fj.useJetArea(new fastjet::AreaDefinition(fastjet::VoronoiAreaSpec()));
	+ addProjection(fj, "KtJetsD05");
	+
	+ // Consider the leading pt photon with \|eta\| < 2.37 and pT > 25 GeV
	+ LeadingParticlesFinalState photonfs(PromptFinalState(FinalState(Cuts::abseta < 2.37 && Cuts::pT > 25*GeV)));
	+ photonfs.addParticleId(PID::PHOTON);
	+ addProjection(photonfs, "LeadingPhoton");
	+
	+ // Book the dsigma/dEt (in eta bins) histograms
	+ for (size_t i = 0; i < _eta_bins.size() - 1; ++i) {
	+ if (fuzzyEquals(_eta_bins[i], 1.37)) continue; // skip this bin
	+ int offset = i > 2? 0 : 1;
	+ _h_Et_photon[i] = bookHisto1D(i + offset, 1, 1);
	+ }
	+
	+ }
	+
	+
	+ /// Return eta bin for either dsigma/dET histogram (area_eta=false) or energy density correction (area_eta=true)
	+ size_t _getEtaBin(double eta_w, bool area_eta) const {
	+ const double eta = fabs(eta_w);
	+ if (!area_eta) {
	+ return binIndex(eta, _eta_bins);
	+ } else {
	+ return binIndex(eta, _eta_bins_areaoffset);
	+ }
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+ // Retrieve leading photon
	+ Particles photons = applyProjection<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	+ if (photons.size() < 1) vetoEvent;
	+ const Particle& leadingPhoton = photons[0];
	+
	+ // Veto events with photon in ECAL crack
	+ if (inRange(leadingPhoton.abseta(), 1.37, 1.56)) vetoEvent;
	+
	+ // Compute isolation energy in cone of radius .4 around photon (all particles)
	+ FourMomentum mom_in_EtCone;
	+ Particles fs = applyProjection<FinalState>(event, "FS").particles();
	+ for (const Particle& p : fs) {
	+ // Check if it's outside the cone of 0.4
	+ if (deltaR(leadingPhoton, p) >= 0.4) continue;
	+ // Except muons or neutrinos
	+ if (PID::isNeutrino(p.abspid()) \|\| p.abspid() == PID::MUON) continue;
	+ // Increment isolation energy
	+ mom_in_EtCone += p.momentum();
	+ }
	+ // Remove the photon energy from the isolation
	+ mom_in_EtCone -= leadingPhoton.momentum();
	+
	+ // Get the area-filtered jet inputs for computing median energy density, etc.
	+ vector<double> ptDensity;
	+ vector< vector<double> > ptDensities(_eta_bins_areaoffset.size()-1);
	+ const FastJets& fast_jets = applyProjection<FastJets>(event, "KtJetsD05");
	+ const auto clust_seq_area = fast_jets.clusterSeqArea();
	+ for (const Jet& jet : fast_jets.jets()) {
	+ const double area = clust_seq_area->area(jet);
	+ if (area > 1e-3 && jet.abseta() < _eta_bins_areaoffset.back())
	+ ptDensities.at( _getEtaBin(jet.abseta(), true) ) += jet.pT()/area;
	+ }
	+ // Compute the median energy density, etc.
	+ for (size_t b = 0; b < _eta_bins_areaoffset.size()-1; ++b) {
	+ const int njets = ptDensities[b].size();
	+ ptDensity += (njets > 0) ? median(ptDensities[b]) : 0.0;
	+ }
	+ // Compute the isolation energy correction (cone area*energy density)
	+ const double etCone_area = PI * sqr(0.4);
	+ const double correction = ptDensity[_getEtaBin(leadingPhoton.abseta(), true)] * etCone_area;
	+
	+ // Apply isolation cut on area-corrected value
	+ // cut is Etiso < 4.8GeV + 4.2E-03 * Et_gamma.
	+ if (mom_in_EtCone.Et() - correction > 4.8GeV + 0.0042leadingPhoton.Et()) vetoEvent;
	+
	+ // Fill histograms
	+ const size_t eta_bin = _getEtaBin(leadingPhoton.abseta(), false);
	+ _h_Et_photon[eta_bin]->fill(leadingPhoton.Et(), event.weight());
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ double sf = crossSection() / (picobarn * sumOfWeights());
	+ for (size_t i = 0; i < _eta_bins.size()-1; ++i) {
	+ if (fuzzyEquals(_eta_bins[i], 1.37)) continue;
	+ scale(_h_Et_photon[i], sf);
	+ }
	+ }
	+
	+
	+ private:
	+
	+ Histo1DPtr _h_Et_photon[5];
	+
	+ const vector<double> _eta_bins = {0.00, 0.60, 1.37, 1.56, 1.81, 2.37 };
	+ const vector<double> _eta_bins_areaoffset = {0.0, 1.5, 3.0};
	+
	+ };
	+
	+
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1457605);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1458270.cc b/src/Analyses/ATLAS_2016_I1458270.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1458270.cc
	@@ -0,0 +1,210 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/Sphericity.hh"
	+#include "Rivet/Projections/SmearedParticles.hh"
	+#include "Rivet/Projections/SmearedJets.hh"
	+#include "Rivet/Projections/SmearedMET.hh"
	+#include "Rivet/Tools/Cutflow.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief ATLAS 0-lepton SUSY search with 3.2/fb of 13 TeV pp data
	+ class ATLAS_2016_I1458270 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_I1458270);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ FinalState calofs(Cuts::abseta < 4.8);
	+ FastJets fj(calofs, FastJets::ANTIKT, 0.4);
	+ declare(fj, "TruthJets");
	+ declare(SmearedJets(fj, JET_SMEAR_ATLAS_RUN2, JET_BTAG_ATLAS_RUN2_MV2C20), "RecoJets");
	+
	+ MissingMomentum mm(calofs);
	+ declare(mm, "TruthMET");
	+ declare(SmearedMET(mm, MET_SMEAR_ATLAS_RUN2), "RecoMET");
	+
	+ PromptFinalState es(Cuts::abseta < 2.47 && Cuts::abspid == PID::ELECTRON, true, true);
	+ declare(es, "TruthElectrons");
	+ declare(SmearedParticles(es, ELECTRON_EFF_ATLAS_RUN2, ELECTRON_SMEAR_ATLAS_RUN2), "RecoElectrons");
	+
	+ PromptFinalState mus(Cuts::abseta < 2.7 && Cuts::abspid == PID::MUON, true);
	+ declare(mus, "TruthMuons");
	+ declare(SmearedParticles(mus, MUON_EFF_ATLAS_RUN2, MUON_SMEAR_ATLAS_RUN2), "RecoMuons");
	+
	+
	+ // Book histograms/counters
	+ _h_2jl = bookCounter("2jl");
	+ _h_2jm = bookCounter("2jm");
	+ _h_2jt = bookCounter("2jt");
	+ _h_4jt = bookCounter("4jt");
	+ _h_5j = bookCounter("5j");
	+ _h_6jm = bookCounter("6jm");
	+ _h_6jt = bookCounter("6jt");
	+
	+
	+ // Book cut-flows
	+ const vector<string> cuts2j = {"Pre-sel+MET+pT1", "Njet", "Dphi_min(j,MET)", "pT2", "MET/sqrtHT", "m_eff(incl)"};
	+ _flows.addCutflow("2jl", cuts2j);
	+ _flows.addCutflow("2jm", cuts2j);
	+ _flows.addCutflow("2jt", cuts2j);
	+ const vector<string> cutsXj = {"Pre-sel+MET+pT1", "Njet", "Dphi_min(j,MET)", "pT2", "pT4", "Aplanarity", "MET/m_eff(Nj)", "m_eff(incl)"};
	+ _flows.addCutflow("4jt", cutsXj);
	+ _flows.addCutflow("5j", cutsXj);
	+ _flows.addCutflow("6jm", cutsXj);
	+ _flows.addCutflow("6jt", cutsXj);
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ _flows.fillinit();
	+
	+ // Same MET cut for all signal regions
	+ //const Vector3 vmet = -apply<MissingMomentum>(event, "TruthMET").vectorEt();
	+ const Vector3 vmet = -apply<SmearedMET>(event, "RecoMET").vectorEt();
	+ const double met = vmet.mod();
	+ if (met < 200*GeV) vetoEvent;
	+
	+ // Get baseline electrons, muons, and jets
	+ Particles elecs = apply<ParticleFinder>(event, "RecoElectrons").particles(Cuts::pT > 10*GeV);
	+ Particles muons = apply<ParticleFinder>(event, "RecoMuons").particles(Cuts::pT > 10*GeV);
	+ Jets jets = apply<JetAlg>(event, "RecoJets").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.8); ///< @todo Pile-up subtraction
	+
	+ // Jet/electron/muons overlap removal and selection
	+ // Remove any \|eta\| < 2.8 jet within dR = 0.2 of a baseline electron
	+ for (const Particle& e : elecs)
	+ ifilter_discard(jets, deltaRLess(e, 0.2, RAPIDITY));
	+ // Remove any electron or muon with dR < 0.4 of a remaining (Nch > 3) jet
	+ for (const Jet& j : jets) {
	+ /// @todo Add track efficiency random filtering
	+ ifilter_discard(elecs, deltaRLess(j, 0.4, RAPIDITY));
	+ if (j.particles(Cuts::abscharge > 0 && Cuts::pT > 500*MeV).size() >= 3)
	+ ifilter_discard(muons, deltaRLess(j, 0.4, RAPIDITY));
	+ }
	+ // Discard the softer of any electrons within dR < 0.05
	+ for (size_t i = 0; i < elecs.size(); ++i) {
	+ const Particle& e1 = elecs[i];
	+ /// @todo Would be nice to pass a "tail view" for the filtering, but awkward without range API / iterator guts
	+ ifilter_discard(elecs, [&](const Particle& e2){ return e2.pT() < e1.pT() && deltaR(e1,e2) < 0.05; });
	+ }
	+
	+ // Loose electron selection
	+ ifilter_select(elecs, ParticleEffFilter(ELECTRON_IDEFF_ATLAS_RUN2_LOOSE));
	+
	+ // Veto the event if there are any remaining baseline leptons
	+ if (!elecs.empty()) vetoEvent;
	+ if (!muons.empty()) vetoEvent;
	+
	+ // Signal jets have pT > 50 GeV
	+ const Jets jets50 = filter_select(jets, Cuts::pT > 50*GeV);
	+ if (jets50.size() < 2) vetoEvent;
	+ vector<double> jetpts; transform(jets, jetpts, pT);
	+ vector<double> jetpts50; transform(jets50, jetpts50, pT);
	+ const double j1pt = jetpts50[0];
	+ const double j2pt = jetpts50[1];
	+ if (j1pt < 200*GeV) vetoEvent;
	+
	+ // Construct multi-jet observables
	+ const double ht = sum(jetpts, 0.0);
	+ const double met_sqrt_ht = met / sqrt(ht);
	+ const double meff_incl = sum(jetpts50, met);
	+
	+ // Get dphis between MET and jets
	+ vector<double> dphimets50; transform(jets50, dphimets50, deltaPhiWRT(vmet));
	+ const double min_dphi_met_2 = min(head(dphimets50, 2));
	+ const double min_dphi_met_3 = min(head(dphimets50, 3));
	+ MSG_DEBUG(dphimets50 << ", " << min_dphi_met_2 << ", " << min_dphi_met_3);
	+
	+ // Jet aplanarity
	+ Sphericity sph; sph.calc(jets);
	+ const double aplanarity = sph.aplanarity();
	+
	+
	+ // Fill SR counters
	+ // 2-jet SRs
	+ if (_flows["2jl"].filltail({true, true, min_dphi_met_2 > 0.8, j2pt > 200*GeV,
	+ met_sqrt_ht > 15sqrt(GeV), meff_incl > 1200GeV})) _h_2jl->fill(event.weight());
	+ if (_flows["2jm"].filltail({j1pt > 300GeV, true, min_dphi_met_2 > 0.4, j2pt > 50GeV,
	+ met_sqrt_ht > 15sqrt(GeV), meff_incl > 1600GeV})) _h_2jm->fill(event.weight());
	+ if (_flows["2jt"].filltail({true, true, min_dphi_met_2 > 0.8, j2pt > 200*GeV,
	+ met_sqrt_ht > 20sqrt(GeV), meff_incl > 2000GeV})) _h_2jt->fill(event.weight());
	+
	+ // Upper multiplicity SRs
	+ const double j4pt = jets50.size() > 3 ? jetpts50[3] : -1;
	+ const double j5pt = jets50.size() > 4 ? jetpts50[4] : -1;
	+ const double j6pt = jets50.size() > 5 ? jetpts50[5] : -1;
	+ const double meff_4 = jets50.size() > 3 ? sum(head(jetpts50, 4), 0.0) : -1;
	+ const double meff_5 = jets50.size() > 4 ? meff_4 + jetpts50[4] : -1;
	+ const double meff_6 = jets50.size() > 5 ? meff_5 + jetpts50[5] : -1;
	+ const double met_meff_4 = met / meff_4;
	+ const double met_meff_5 = met / meff_5;
	+ const double met_meff_6 = met / meff_6;
	+ const double min_dphi_met_more = jets50.size() > 3 ? min(tail(dphimets50, -3)) : -1;
	+
	+ if (_flows["4jt"].filltail({true, jets50.size() >= 4, min_dphi_met_3 > 0.4 && min_dphi_met_more > 0.2,
	+ jetpts[1] > 200GeV, j4pt > 100GeV, aplanarity > 0.04, met_meff_4 > 0.20, meff_incl > 2200*GeV}))
	+ _h_4jt->fill(event.weight());
	+ if (_flows["5j"].filltail({true, jets50.size() >= 5, min_dphi_met_3 > 0.4 && min_dphi_met_more > 0.2,
	+ jetpts[1] > 200GeV, j4pt > 100GeV && j5pt > 50GeV, aplanarity > 0.04, met_meff_5 > 0.25, meff_incl > 1600GeV}))
	+ _h_5j->fill(event.weight());
	+ if (_flows["6jm"].filltail({true, jets50.size() >= 6, min_dphi_met_3 > 0.4 && min_dphi_met_more > 0.2,
	+ jetpts[1] > 200GeV, j4pt > 100GeV && j6pt > 50GeV, aplanarity > 0.04, met_meff_6 > 0.25, meff_incl > 1600GeV}))
	+ _h_6jm->fill(event.weight());
	+ if (_flows["6jt"].filltail({true, jets50.size() >= 6, min_dphi_met_3 > 0.4 && min_dphi_met_more > 0.2,
	+ jetpts[1] > 200GeV, j4pt > 100GeV && j6pt > 50GeV, aplanarity > 0.04, met_meff_6 > 0.20, meff_incl > 2000GeV}))
	+ _h_6jt->fill(event.weight());
	+
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ const double sf = 3.2*crossSection()/femtobarn/sumOfWeights();
	+ scale({_h_2jl, _h_2jl, _h_2jl}, sf);
	+ scale({_h_4jt, _h_5j}, sf);
	+ scale({_h_6jm, _h_6jt}, sf);
	+
	+ MSG_INFO("CUTFLOWS:\n\n" << _flows);
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ CounterPtr _h_2jl, _h_2jm, _h_2jt;
	+ CounterPtr _h_4jt, _h_5j;
	+ CounterPtr _h_6jm, _h_6jt;
	+ //@}
	+
	+ /// Cut-flows
	+ Cutflows _flows;
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1458270);
	+
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1467230.cc b/src/Analyses/ATLAS_2016_I1467230.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1467230.cc
	@@ -0,0 +1,134 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief ATLAS 13 TeV minimum bias analysis for low-pT tracks
	+ class ATLAS_2016_I1467230 : public Analysis {
	+ public:
	+
	+ /// Particle types included
	+ enum PartTypes {
	+ k_NoStrange,
	+ k_AllCharged,
	+ kNPartTypes
	+ };
	+
	+ /// Phase space regions
	+ enum regionID {
	+ k_pt100_nch2_eta25,
	+ kNregions
	+ };
	+
	+
	+ /// Default constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_I1467230);
	+
	+
	+ /// Initialization, called once before running
	+ void init() {
	+
	+ for (int iT = 0; iT < kNPartTypes; ++iT) {
	+ for (int iR = 0; iR < kNregions; ++iR) {
	+ _sumW[iT][iR] = 0.;
	+ }
	+ }
	+
	+ // Initialize and register projections
	+ declare(ChargedFinalState(Cuts::abseta < 2.5 && Cuts::pT > 100*MeV), "CFS100_25");
	+
	+ for (int iT = 0; iT < kNPartTypes; ++iT) {
	+ for (int iR = 0; iR < kNregions; ++iR) {
	+ _hist_nch [iT][iR] = bookHisto1D ( 1, iR + 1, iT + 1);
	+ _hist_pt [iT][iR] = bookHisto1D ( 2, iR + 1, iT + 1);
	+ _hist_eta [iT][iR] = bookHisto1D ( 3, iR + 1, iT + 1);
	+ _hist_ptnch[iT][iR] = bookProfile1D( 4, iR + 1, iT + 1);
	+ }
	+ }
	+
	+ }
	+
	+
	+ /// Fill histograms for the given particle selection and phase-space region
	+ void fillPtEtaNch(const Particles& particles, int ptype, int iRegion, double weight) {
	+
	+ // Skip if event fails multiplicity cut
	+ const size_t nch = particles.size();
	+ if (nch < 2) return;
	+
	+ // Fill event weight info
	+ _sumW[ptype][iRegion] += weight;
	+
	+ // Fill nch
	+ _hist_nch[ptype][iRegion]->fill(nch, weight);
	+
	+ // Loop over particles, fill pT, eta and ptnch
	+ for (const Particle& p : particles) {
	+ const double pt = p.pT()/GeV;
	+ const double eta = p.eta();
	+ _hist_pt [ptype][iRegion]->fill(pt , weight/pt);
	+ _hist_eta [ptype][iRegion]->fill(eta, weight);
	+ _hist_ptnch[ptype][iRegion]->fill(nch, pt, weight);
	+ }
	+ }
	+
	+
	+ /// Per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get all charged particles
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS100_25");
	+ const Particles& pall = cfs.particles();
	+
	+ // Get charged particles, filtered to omit charged strange baryons
	+ const Cut& pcut = Cuts::abspid != PID::SIGMAMINUS && Cuts::abspid != PID::SIGMAPLUS && Cuts::abspid != PID::XIMINUS && Cuts::abspid != PID::OMEGAMINUS;
	+ const Particles& pnostrange = cfs.particles(pcut);
	+
	+ // Fill all histograms
	+ for (int iR = 0; iR < kNregions; ++iR) {
	+ fillPtEtaNch(pall, k_AllCharged, iR, event.weight());
	+ fillPtEtaNch(pnostrange, k_NoStrange, iR, event.weight());
	+ }
	+
	+ }
	+
	+
	+ /// Post-run data manipulation
	+ void finalize() {
	+
	+ // Scale all histograms
	+ for (int iT = 0; iT < kNPartTypes; ++iT) {
	+ for (int iR = 0; iR < kNregions; ++iR) {
	+ if (_sumW[iT][iR] > 0) {
	+ scale(_hist_nch[iT][iR], 1.0/_sumW[iT][iR]);
	+ scale(_hist_pt [iT][iR], 1.0/_sumW[iT][iR]/TWOPI/5.);
	+ scale(_hist_eta[iT][iR], 1.0/_sumW[iT][iR]);
	+ }
	+ }
	+ }
	+
	+ }
	+
	+
	+ private:
	+
	+ /// Weight sums
	+ double _sumW[kNPartTypes][kNregions];
	+
	+ /// @name Histogram arrays
	+ //@{
	+ Histo1DPtr _hist_nch [kNPartTypes][kNregions];
	+ Histo1DPtr _hist_pt [kNPartTypes][kNregions];
	+ Histo1DPtr _hist_eta [kNPartTypes][kNregions];
	+ Profile1DPtr _hist_ptnch [kNPartTypes][kNregions];
	+ //@}
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1467230);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1467454.cc b/src/Analyses/ATLAS_2016_I1467454.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1467454.cc
	@@ -0,0 +1,107 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/ZFinder.hh"
	+#include "Rivet/Tools/BinnedHistogram.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief High-mass Drell-Yan at 8 TeV
	+ class ATLAS_2016_I1467454 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ ATLAS_2016_I1467454(const string& name="ATLAS_2016_I1467454")
	+ : Analysis(name)
	+ {
	+ _mode = 0; // use electron channel by default
	+ }
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ const FinalState fs;
	+ Cut cuts = Cuts::abseta < 2.5 && Cuts::pT > 30*GeV;
	+ ZFinder zfinder(fs, cuts, _mode? PID::MUON : PID::ELECTRON, 116GeV, 1500GeV, 0.1);
	+ declare(zfinder, "ZFinder");
	+
	+ size_t ch = _mode? 11 : 0; // offset
	+ _hist_mll = bookHisto1D(18 + ch, 1, 1);
	+
	+ vector<double> mll_bins = { 116., 150., 200., 300., 500., 1500. };
	+ for (size_t i = 0; i < (mll_bins.size() - 1); ++i) {
	+ _hist_rap.addHistogram( mll_bins[i], mll_bins[i+1], bookHisto1D(19 + ch + i, 1, 1));
	+ _hist_deta.addHistogram(mll_bins[i], mll_bins[i+1], bookHisto1D(24 + ch + i, 1, 1));
	+ }
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");
	+ if (zfinder.bosons().size() != 1) vetoEvent;
	+
	+ const Particle& z0 = zfinder.bosons()[0];
	+ const Particle& el1 = zfinder.particles()[0];
	+ const Particle& el2 = zfinder.particles()[1];
	+
	+ if (el1.pT() > 40GeV \|\| el2.pT() > 40GeV) {
	+ const double mass = z0.mass();
	+ const double weight = event.weight();
	+ _hist_mll->fill(mass/GeV, weight);
	+ _hist_rap. fill(mass/GeV, z0.absrap(), weight);
	+ _hist_deta.fill(mass/GeV, deltaEta(el1,el2), weight);
	+ }
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ const double sf = crossSection()/sumOfWeights();
	+ scale(_hist_mll, sf);
	+ _hist_rap.scale(sf*0.5, this);
	+ _hist_deta.scale(sf*0.5, this);
	+
	+ }
	+
	+ //@}
	+
	+
	+ /// Choose to work in electron or muon mode
	+ size_t _mode;
	+
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _hist_mll;
	+ BinnedHistogram<double> _hist_rap, _hist_deta;
	+ //@}
	+
	+ };
	+
	+
	+ /// High-mass Drell-Yan at 8 TeV, electron channel
	+ struct ATLAS_2016_I1467454_EL : public ATLAS_2016_I1467454 {
	+ ATLAS_2016_I1467454_EL() : ATLAS_2016_I1467454("ATLAS_2016_I1467454_EL") { _mode = 0; }
	+ };
	+
	+
	+ /// High-mass Drell-Yan at 8 TeV, muon channel
	+ struct ATLAS_2016_I1467454_MU : public ATLAS_2016_I1467454 {
	+ ATLAS_2016_I1467454_MU() : ATLAS_2016_I1467454("ATLAS_2016_I1467454_MU") { _mode = 1; }
	+ };
	+
	+
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1467454);
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1467454_EL);
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1467454_MU);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1468167.cc b/src/Analyses/ATLAS_2016_I1468167.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1468167.cc
	@@ -0,0 +1,73 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// Measurement of the inelastic proton-proton cross-section at \sqrt{s} = 13 TeV
	+ class ATLAS_2016_I1468167 : public Analysis {
	+ public:
	+
	+
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_I1468167);
	+
	+
	+ /// Initialisation
	+ void init() {
	+ declare(FinalState(), "FS");
	+ _h_sigma = bookHisto1D(1, 1, 1);
	+ }
	+
	+
	+ /// Per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get all particles, sorted from minus to plus in eta
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	+ if (fs.size() < 2) vetoEvent; // need at least two particles to calculate gaps
	+ const Particles particles = fs.particles(cmpMomByEta);
	+
	+ // Find this event's largest gap size and center
	+ double etapre = particles.front().eta();
	+ double gapcenter = 0.;
	+ double gapsize = -1;
	+ for (const Particle& p : particles) {
	+ const double gap = fabs(p.eta() - etapre);
	+ if (gap > gapsize) { // new largest gap
	+ gapsize = gap;
	+ gapcenter = (p.eta() + etapre)/2.;
	+ }
	+ etapre = p.eta();
	+ }
	+
	+ // Calculate xi variable of the more massive side of the event, and apply xi cut
	+ FourMomentum mxFourVector, myFourVector;
	+ for (const Particle& p : particles) {
	+ ((p.eta() > gapcenter) ? mxFourVector : myFourVector) += p;
	+ }
	+ const double M2 = max(mxFourVector.mass2(), myFourVector.mass2());
	+ const double xi = M2/sqr(sqrtS()); // sqrt(s)=7000 GeV, note that units cancel
	+ if (xi < 1e-6) vetoEvent;
	+
	+ // Fill the histogram
	+ _h_sigma->fill(sqrtS()/GeV, event.weight());
	+ }
	+
	+
	+ /// Scale the acceptance histogram to inelastic cross-section
	+ void finalize() {
	+ scale(_h_sigma, crossSection()/millibarn/sumOfWeights());
	+ }
	+
	+
	+ /// Histogram
	+ Histo1DPtr _h_sigma;
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1468167);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1468168.cc b/src/Analyses/ATLAS_2016_I1468168.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1468168.cc
	@@ -0,0 +1,81 @@
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/DressedLeptons.hh"
	+
	+namespace Rivet {
	+
	+
	+ class ATLAS_2016_I1468168 : public Analysis {
	+ public:
	+
	+ DEFAULT_RIVET_ANALYSIS_CONSTRUCTOR(ATLAS_2016_I1468168);
	+
	+ void init() {
	+ // Eta ranges
	+ Cut eta_full = Cuts::abseta < 5.0 && Cuts::pT >= 1.0*MeV;
	+ // Lepton cuts
	+ Cut lep_cuts = Cuts::abseta < 2.5 && Cuts::pT >= 25.0*GeV;
	+
	+ // All final state particles
	+ FinalState fs(eta_full);
	+
	+ // Get photons to dress leptons
	+ IdentifiedFinalState photons(fs);
	+ photons.acceptIdPair(PID::PHOTON);
	+
	+ // Projection to find the electrons
	+ IdentifiedFinalState el_id(fs);
	+ el_id.acceptIdPair(PID::ELECTRON);
	+ PromptFinalState electrons(el_id);
	+ electrons.acceptTauDecays(true);
	+ DressedLeptons dressedelectrons(photons, electrons, 0.1, lep_cuts, true, true);
	+ addProjection(dressedelectrons, "DressedElectrons");
	+
	+ // Projection to find the muons
	+ IdentifiedFinalState mu_id(fs);
	+ mu_id.acceptIdPair(PID::MUON);
	+ PromptFinalState muons(mu_id);
	+ muons.acceptTauDecays(true);
	+ DressedLeptons dressedmuons(photons, muons, 0.1, lep_cuts, true, true);
	+ addProjection(dressedmuons, "DressedMuons");
	+
	+ /// @todo Make this a counter or Scatter1D?
	+ _hist = bookHisto1D("Passed_events", 1, 0, 1);
	+ }
	+
	+
	+ void analyze(const Event& event) {
	+
	+ // Get the selected objects, using the projections.
	+ const size_t num_es = applyProjection<DressedLeptons>(event, "DressedElectrons").dressedLeptons().size();
	+ const size_t num_mus = applyProjection<DressedLeptons>(event, "DressedMuons").dressedLeptons().size();
	+
	+ // Evaluate basic event selection
	+ const bool pass_emu = num_es == 1 && num_mus == 1;
	+ if (!pass_emu) vetoEvent;
	+
	+ // Fill histogram to measure the event acceptance
	+ _hist->fill(0.5, event.weight());
	+ }
	+
	+
	+ void finalize() {
	+ // Normalize to cross-section
	+ const double sf(crossSection() / sumOfWeights());
	+ scale(_hist, sf);
	+ }
	+
	+
	+ private:
	+
	+ Histo1DPtr _hist;
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1468168);
	+
	+}
	diff --git a/src/Analyses/ATLAS_2016_I1479760.cc b/src/Analyses/ATLAS_2016_I1479760.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/ATLAS_2016_I1479760.cc
	@@ -0,0 +1,121 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// Hard double-parton scattering in four-jet events at 7 TeV
	+ class ATLAS_2016_I1479760 : public Analysis {
	+ public:
	+
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ATLAS_2016_I1479760);
	+
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ /// Declare AntiKt 0.6 jets without muons and neutrinos
	+ FastJets fastJets(FinalState(), FastJets::ANTIKT, 0.6);
	+ fastJets.useInvisibles(JetAlg::NO_INVISIBLES);
	+ fastJets.useMuons(JetAlg::NO_MUONS);
	+ addProjection(fastJets, "AntiKt6Jets");
	+
	+ _hists["deltaPt34"] = bookHisto1D( 1, 1, 1);
	+ _hists["deltaPhi34"] = bookHisto1D( 2, 1, 1);
	+ _hists["deltaPt12"] = bookHisto1D( 3, 1, 1);
	+ _hists["deltaPt13"] = bookHisto1D( 4, 1, 1);
	+ _hists["deltaPt23"] = bookHisto1D( 5, 1, 1);
	+ _hists["deltaPt14"] = bookHisto1D( 6, 1, 1);
	+ _hists["deltaPt24"] = bookHisto1D( 7, 1, 1);
	+ _hists["deltaPhi12"] = bookHisto1D( 8, 1, 1);
	+ _hists["deltaPhi13"] = bookHisto1D( 9, 1, 1);
	+ _hists["deltaPhi23"] = bookHisto1D(10, 1, 1);
	+ _hists["deltaPhi14"] = bookHisto1D(11, 1, 1);
	+ _hists["deltaPhi24"] = bookHisto1D(12, 1, 1);
	+ _hists["deltaY12"] = bookHisto1D(13, 1, 1);
	+ _hists["deltaY34"] = bookHisto1D(14, 1, 1);
	+ _hists["deltaY13"] = bookHisto1D(15, 1, 1);
	+ _hists["deltaY23"] = bookHisto1D(16, 1, 1);
	+ _hists["deltaY14"] = bookHisto1D(17, 1, 1);
	+ _hists["deltaY24"] = bookHisto1D(18, 1, 1);
	+ _hists["deltaPhiPlanes12"] = bookHisto1D(19, 1, 1);
	+ _hists["deltaPhiPlanes13"] = bookHisto1D(20, 1, 1);
	+ _hists["deltaPhiPlanes14"] = bookHisto1D(21, 1, 1);
	+ }
	+
	+
	+ /// Calculate the DeltaPt variable
	+ double calcDeltaPt(const Jet& j1, const Jet& j2) {
	+ return (j1.momentum() + j2.momentum()).pT() / (j1.pT() + j2.pT());
	+ }
	+
	+ /// Calculate the DeltaPhi variable between event planes
	+ double calcDeltaPhiPlanes(const Jet& j1, const Jet& j2, const Jet& j3, const Jet& j4) {
	+ const FourMomentum sumVec1 = j1.momentum() + j2.momentum();
	+ const FourMomentum sumVec2 = j3.momentum() + j4.momentum();
	+ return deltaPhi(sumVec1, sumVec2);
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Retrieve all anti-kt R=0.6 jets with pT above 20 GeV and eta < 4.4
	+ const Jets jets = applyProjection<JetAlg>(event, "AntiKt6Jets").jetsByPt(Cuts::pT >= 20*GeV && Cuts::abseta <= 4.4);
	+
	+ // Require at least 4 jets, with the leading jet pT above 42.5 GeV
	+ if (jets.size() < 4) vetoEvent;
	+ if (jets[0].pT() < 42.5*GeV) vetoEvent;
	+
	+ /// Fill histograms
	+ const double weight = event.weight();
	+ _hists["deltaPt12"]->fill( calcDeltaPt( jets[0], jets[1] ), weight );
	+ _hists["deltaPt34"]->fill( calcDeltaPt( jets[2], jets[3] ), weight );
	+ _hists["deltaPt13"]->fill( calcDeltaPt( jets[0], jets[2] ), weight );
	+ _hists["deltaPt23"]->fill( calcDeltaPt( jets[1], jets[2] ), weight );
	+ _hists["deltaPt14"]->fill( calcDeltaPt( jets[0], jets[3] ), weight );
	+ _hists["deltaPt24"]->fill( calcDeltaPt( jets[1], jets[3] ), weight );
	+ //
	+ _hists["deltaPhi12"]->fill( deltaPhi( jets[0],jets[1] ), weight );
	+ _hists["deltaPhi34"]->fill( deltaPhi( jets[2],jets[3] ), weight );
	+ _hists["deltaPhi13"]->fill( deltaPhi( jets[0],jets[2] ), weight );
	+ _hists["deltaPhi23"]->fill( deltaPhi( jets[1],jets[2] ), weight );
	+ _hists["deltaPhi14"]->fill( deltaPhi( jets[0],jets[3] ), weight );
	+ _hists["deltaPhi24"]->fill( deltaPhi( jets[1],jets[3] ), weight );
	+ //
	+ _hists["deltaY12"]->fill( deltaRap( jets[0], jets[1] ), weight );
	+ _hists["deltaY34"]->fill( deltaRap( jets[2], jets[3] ), weight );
	+ _hists["deltaY13"]->fill( deltaRap( jets[0], jets[2] ), weight );
	+ _hists["deltaY23"]->fill( deltaRap( jets[1], jets[2] ), weight );
	+ _hists["deltaY14"]->fill( deltaRap( jets[0], jets[3] ), weight );
	+ _hists["deltaY24"]->fill( deltaRap( jets[1], jets[3] ), weight );
	+ //
	+ _hists["deltaPhiPlanes12"]->fill( calcDeltaPhiPlanes(jets[0], jets[1], jets[2], jets[3] ), weight );
	+ _hists["deltaPhiPlanes13"]->fill( calcDeltaPhiPlanes(jets[0], jets[2], jets[1], jets[3] ), weight );
	+ _hists["deltaPhiPlanes14"]->fill( calcDeltaPhiPlanes(jets[0], jets[3], jets[1], jets[2] ), weight );
	+ }
	+
	+
	+ /// Post-run processing
	+ void finalize() {
	+ for (auto& key_hist : _hists)
	+ normalize(key_hist.second);
	+ }
	+
	+ //@}
	+
	+
	+ /// Histograms
	+ map<string, Histo1DPtr> _hists;
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(ATLAS_2016_I1479760);
	+
	+}
	diff --git a/src/Analyses/BABAR_2003_I593379.cc b/src/Analyses/BABAR_2003_I593379.cc
	--- a/src/Analyses/BABAR_2003_I593379.cc
	+++ b/src/Analyses/BABAR_2003_I593379.cc
	@@ -1,187 +1,186 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief Babar charmonium spectra
	/// @author Peter Richardson
	class BABAR_2003_I593379 : public Analysis {
	public:

	BABAR_2003_I593379()
	: Analysis("BABAR_2003_I593379"), _weightSum(0.)
	{ }


	void analyze(const Event& e) {
	const double weight = e.weight();

	// Find the charmonia
	Particles upsilons;
	// First in unstable final state
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	foreach (const Particle& p, ufs.particles())
	if (p.pid() == 300553) upsilons.push_back(p);
	// Then in whole event if fails
	if (upsilons.empty()) {
	foreach (const GenParticle* p, Rivet::particles(e.genEvent())) {
	if (p->pdg_id() != 300553) continue;
	const GenVertex* pv = p->production_vertex();
	bool passed = true;
	if (pv) {
	foreach (const GenParticle* pp, particles_in(pv)) {
	if ( p->pdg_id() == pp->pdg_id() ) {
	passed = false;
	break;
	}
	}
	}
	if (passed) upsilons.push_back(Particle(*p));
	}
	}

	- // find an upsilons
	+ // Find upsilons
	foreach (const Particle& p, upsilons) {
	_weightSum += weight;
	- // find the charmonium resonances
	- vector<const GenParticle*> allJpsi, primaryJpsi, Psiprime,
	- all_chi_c1, all_chi_c2, primary_chi_c1, primary_chi_c2;
	+ // Find the charmonium resonances
	+ /// @todo Use Rivet::Particles
	+ vector<const GenParticle*> allJpsi, primaryJpsi, Psiprime, all_chi_c1, all_chi_c2, primary_chi_c1, primary_chi_c2;
	findDecayProducts(p.genParticle(), allJpsi, primaryJpsi, Psiprime,
	all_chi_c1, all_chi_c2, primary_chi_c1, primary_chi_c2);
	- LorentzTransform cms_boost(-p.momentum().boostVector());
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(p.mom().betaVec());
	for (size_t i = 0; i < allJpsi.size(); i++) {
	- double pcm = cms_boost.transform(FourMomentum(allJpsi[i]->momentum())).vector3().mod();
	+ const double pcm = cms_boost.transform(FourMomentum(allJpsi[i]->momentum())).p();
	_hist_all_Jpsi->fill(pcm, weight);
	}
	_mult_JPsi->fill(10.58, weight*double(allJpsi.size()));
	for (size_t i = 0; i < primaryJpsi.size(); i++) {
	- double pcm = cms_boost.transform(FourMomentum(primaryJpsi[i]->momentum())).vector3().mod();
	+ const double pcm = cms_boost.transform(FourMomentum(primaryJpsi[i]->momentum())).p();
	_hist_primary_Jpsi->fill(pcm, weight);
	}
	_mult_JPsi_direct->fill(10.58, weight*double(primaryJpsi.size()));
	for (size_t i=0; i<Psiprime.size(); i++) {
	- double pcm = cms_boost.transform(FourMomentum(Psiprime[i]->momentum())).vector3().mod();
	+ const double pcm = cms_boost.transform(FourMomentum(Psiprime[i]->momentum())).p();
	_hist_Psi_prime->fill(pcm, weight);
	}
	_mult_Psi2S->fill(10.58, weight*double(Psiprime.size()));
	for (size_t i = 0; i < all_chi_c1.size(); i++) {
	- double pcm = cms_boost.transform(FourMomentum(all_chi_c1[i]->momentum())).vector3().mod();
	+ const double pcm = cms_boost.transform(FourMomentum(all_chi_c1[i]->momentum())).p();
	_hist_chi_c1->fill(pcm, weight);
	}
	_mult_chi_c1->fill(10.58, weight*double(all_chi_c1.size()));
	_mult_chi_c1_direct->fill(10.58, weight*double(primary_chi_c1.size()));
	for (size_t i = 0; i < all_chi_c2.size(); i++) {
	- double pcm = cms_boost.transform(FourMomentum(all_chi_c2[i]->momentum())).vector3().mod();
	+ const double pcm = cms_boost.transform(FourMomentum(all_chi_c2[i]->momentum())).p();
	_hist_chi_c2->fill(pcm, weight);
	}
	_mult_chi_c2->fill(10.58, weight*double(all_chi_c2.size()));
	_mult_chi_c2_direct->fill(10.58, weight*double(primary_chi_c2.size()));
	}
	} // analyze


	void finalize() {
	scale(_hist_all_Jpsi , 0.5*0.1/_weightSum);
	scale(_hist_chi_c1 , 0.5*0.1/_weightSum);
	scale(_hist_chi_c2 , 0.5*0.1/_weightSum);
	scale(_hist_Psi_prime , 0.5*0.1/_weightSum);
	scale(_hist_primary_Jpsi , 0.5*0.1/_weightSum);
	scale(_mult_JPsi , 0.5*100./_weightSum);
	scale(_mult_JPsi_direct , 0.5*100./_weightSum);
	scale(_mult_chi_c1 , 0.5*100./_weightSum);
	scale(_mult_chi_c1_direct, 0.5*100./_weightSum);
	scale(_mult_chi_c2 , 0.5*100./_weightSum);
	scale(_mult_chi_c2_direct, 0.5*100./_weightSum);
	scale(_mult_Psi2S , 0.5*100./_weightSum);
	} // finalize


	void init() {
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");

	_mult_JPsi = bookHisto1D(1, 1, 1);
	_mult_JPsi_direct = bookHisto1D(1, 1, 2);
	_mult_chi_c1 = bookHisto1D(1, 1, 3);
	_mult_chi_c1_direct = bookHisto1D(1, 1, 4);
	_mult_chi_c2 = bookHisto1D(1, 1, 5);
	_mult_chi_c2_direct = bookHisto1D(1, 1, 6);
	_mult_Psi2S = bookHisto1D(1, 1, 7);
	_hist_all_Jpsi = bookHisto1D(6, 1, 1);
	_hist_chi_c1 = bookHisto1D(7, 1, 1);
	_hist_chi_c2 = bookHisto1D(7, 1, 2);
	_hist_Psi_prime = bookHisto1D(8, 1, 1);
	_hist_primary_Jpsi = bookHisto1D(10, 1, 1);
	} // init

	private:

	//@{
	// count of weights
	double _weightSum;
	/// Histograms
	Histo1DPtr _hist_all_Jpsi;
	Histo1DPtr _hist_chi_c1;
	Histo1DPtr _hist_chi_c2;
	Histo1DPtr _hist_Psi_prime;
	Histo1DPtr _hist_primary_Jpsi;

	Histo1DPtr _mult_JPsi;
	Histo1DPtr _mult_JPsi_direct;
	Histo1DPtr _mult_chi_c1;
	Histo1DPtr _mult_chi_c1_direct;
	Histo1DPtr _mult_chi_c2;
	Histo1DPtr _mult_chi_c2_direct;
	Histo1DPtr _mult_Psi2S;
	//@}

	void findDecayProducts(const GenParticle* p,
	vector<const GenParticle*>& allJpsi,
	vector<const GenParticle*>& primaryJpsi,
	vector<const GenParticle*>& Psiprime,
	vector<const GenParticle>& all_chi_c1, vector<const GenParticle>& all_chi_c2,
	vector<const GenParticle>& primary_chi_c1, vector<const GenParticle>& primary_chi_c2) {
	const GenVertex* dv = p->end_vertex();
	bool isOnium = false;
	/// @todo Use better looping
	for (GenVertex::particles_in_const_iterator pp = dv->particles_in_const_begin() ; pp != dv->particles_in_const_end() ; ++pp) {
	int id = (*pp)->pdg_id();
	id = id%1000;
	id -= id%10;
	id /= 10;
	if (id==44) isOnium = true;
	}
	/// @todo Use better looping
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	int id = (*pp)->pdg_id();
	if (id==100443) {
	Psiprime.push_back(*pp);
	}
	else if (id==20443) {
	all_chi_c1.push_back(*pp);
	if (!isOnium) primary_chi_c1.push_back(*pp);
	}
	else if (id==445) {
	all_chi_c2.push_back(*pp);
	if (!isOnium) primary_chi_c2.push_back(*pp);
	}
	else if (id==443) {
	allJpsi.push_back(*pp);
	if (!isOnium) primaryJpsi.push_back(*pp);
	}
	if ((*pp)->end_vertex()) {
	findDecayProducts(*pp, allJpsi, primaryJpsi, Psiprime, all_chi_c1, all_chi_c2, primary_chi_c1, primary_chi_c2);
	}
	}
	}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(BABAR_2003_I593379);

	}
	diff --git a/src/Analyses/BABAR_2005_S6181155.cc b/src/Analyses/BABAR_2005_S6181155.cc
	--- a/src/Analyses/BABAR_2005_S6181155.cc
	+++ b/src/Analyses/BABAR_2005_S6181155.cc
	@@ -1,146 +1,145 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief BABAR Xi_c baryons from fragmentation
	/// @author Peter Richardson
	class BABAR_2005_S6181155 : public Analysis {
	public:

	BABAR_2005_S6181155()
	: Analysis("BABAR_2005_S6181155")
	{ }

	+ void init() {
	+ declare(Beam(), "Beams");
	+ declare(UnstableFinalState(), "UFS");
	+ _histOnResonanceA = bookHisto1D(1,1,1);
	+ _histOnResonanceB = bookHisto1D(2,1,1);
	+ _histOffResonance = bookHisto1D(2,1,2);
	+ _sigma = bookHisto1D(3,1,1);
	+ _histOnResonanceA_norm = bookHisto1D(4,1,1);
	+ _histOnResonanceB_norm = bookHisto1D(5,1,1);
	+ _histOffResonance_norm = bookHisto1D(5,1,2);
	+
	+ }

	void analyze(const Event& e) {
	const double weight = e.weight();

	// Loop through unstable FS particles and look for charmed mesons/baryons
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	- const Beam beamproj = applyProjection<Beam>(e, "Beams");
	+ const Beam beamproj = apply<Beam>(e, "Beams");
	const ParticlePair& beams = beamproj.beams();
	- FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	- LorentzTransform cms_boost(-mom_tot.boostVector());
	+ const FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(mom_tot.betaVec());
	const double s = sqr(beamproj.sqrtS());

	- const bool onresonance = fuzzyEquals(beamproj.sqrtS(), 10.58, 2E-3);
	+ const bool onresonance = fuzzyEquals(beamproj.sqrtS()/GeV, 10.58, 2E-3);

	foreach (const Particle& p, ufs.particles()) {
	// 3-momentum in CMS frame
	+
	const double mom = cms_boost.transform(p.momentum()).vector3().mod();
	- // only looking at Xi_c^0
	- if(p.abspid() != 4132 ) continue;
	+ // Only looking at Xi_c^0
	+ if (p.abspid() != 4132 ) continue;
	if (onresonance) {
	_histOnResonanceA_norm->fill(mom,weight);
	_histOnResonanceB_norm->fill(mom,weight);
	}
	else {
	_histOffResonance_norm->fill(mom,s/sqr(10.58)*weight);
	}
	MSG_DEBUG("mom = " << mom);
	// off-resonance cross section
	- if(checkDecay(p.genParticle())) {
	+ if (checkDecay(p.genParticle())) {
	if (onresonance) {
	_histOnResonanceA->fill(mom,weight);
	_histOnResonanceB->fill(mom,weight);
	}
	else {
	_histOffResonance->fill(mom,s/sqr(10.58)*weight);
	_sigma->fill(10.6,weight);
	}
	}
	}
	- } // analyze
	+ }
	+

	void finalize() {
	scale(_histOnResonanceA, crossSection()/femtobarn/sumOfWeights());
	scale(_histOnResonanceB, crossSection()/femtobarn/sumOfWeights());
	scale(_histOffResonance, crossSection()/femtobarn/sumOfWeights());
	scale(_sigma , crossSection()/femtobarn/sumOfWeights());
	normalize(_histOnResonanceA_norm);
	normalize(_histOnResonanceB_norm);
	normalize(_histOffResonance_norm);
	- } // finalize
	+ }


	- void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(UnstableFinalState(), "UFS");
	-
	- _histOnResonanceA = bookHisto1D(1,1,1);
	- _histOnResonanceB = bookHisto1D(2,1,1);
	- _histOffResonance = bookHisto1D(2,1,2);
	- _sigma = bookHisto1D(3,1,1);
	- _histOnResonanceA_norm = bookHisto1D(4,1,1);
	- _histOnResonanceB_norm = bookHisto1D(5,1,1);
	- _histOffResonance_norm = bookHisto1D(5,1,2);
	-
	- } // init
	-
	private:

	//@{
	/// Histograms
	Histo1DPtr _histOnResonanceA;
	Histo1DPtr _histOnResonanceB;
	Histo1DPtr _histOffResonance;
	Histo1DPtr _sigma ;
	Histo1DPtr _histOnResonanceA_norm;
	Histo1DPtr _histOnResonanceB_norm;
	Histo1DPtr _histOffResonance_norm;
	//@}

	bool checkDecay(const GenParticle* p) {
	unsigned int nstable = 0, npip = 0, npim = 0;
	unsigned int nXim = 0, nXip = 0;
	findDecayProducts(p, nstable, npip, npim, nXip, nXim);
	int id = p->pdg_id();
	// Xi_c
	- if (id==4132) {
	- if (nstable==2 && nXim==1 && npip==1) return true;
	+ if (id == 4132) {
	+ if (nstable == 2 && nXim == 1 && npip == 1) return true;
	}
	- else if (id==-4132) {
	- if (nstable==2 && nXip==1 && npim==1) return true;
	+ else if (id == -4132) {
	+ if (nstable == 2 && nXip == 1 && npim == 1) return true;
	}
	return false;
	}

	void findDecayProducts(const GenParticle* p,
	unsigned int& nstable,
	unsigned int& npip, unsigned int& npim,
	unsigned int& nXip, unsigned int& nXim) {
	const GenVertex* dv = p->end_vertex();
	/// @todo Use better looping
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	int id = (*pp)->pdg_id();
	if (id==3312) {
	++nXim;
	++nstable;
	- } else if (id==-3312) {
	+ } else if (id == -3312) {
	++nXip;
	++nstable;
	- } else if(id==111\|\|id==221) {
	+ } else if(id == 111 \|\| id == 221) {
	++nstable;
	} else if ((*pp)->end_vertex()) {
	findDecayProducts(*pp, nstable, npip, npim, nXip, nXim);
	} else {
	if (id != 22) ++nstable;
	if (id == 211) ++npip;
	else if(id == -211) ++npim;
	}
	}
	}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(BABAR_2005_S6181155);

	}
	diff --git a/src/Analyses/BABAR_2007_S6895344.cc b/src/Analyses/BABAR_2007_S6895344.cc
	--- a/src/Analyses/BABAR_2007_S6895344.cc
	+++ b/src/Analyses/BABAR_2007_S6895344.cc
	@@ -1,89 +1,86 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief BABAR Lambda_c from fragmentation
	/// @author Peter Richardson
	class BABAR_2007_S6895344 : public Analysis {
	public:

	BABAR_2007_S6895344()
	: Analysis("BABAR_2007_S6895344")
	{ }


	+ void init() {
	+ declare(Beam(), "Beams");
	+ declare(UnstableFinalState(), "UFS");
	+
	+ _histOff = bookHisto1D(1,1,1);
	+ _sigmaOff = bookHisto1D(2,1,1);
	+ _histOn = bookHisto1D(3,1,1);
	+ _sigmaOn = bookHisto1D(4,1,1);
	+ }
	+
	+
	void analyze(const Event& e) {
	const double weight = e.weight();

	// Loop through unstable FS particles and look for charmed mesons/baryons
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	- const Beam beamproj = applyProjection<Beam>(e, "Beams");
	+ const Beam beamproj = apply<Beam>(e, "Beams");
	const ParticlePair& beams = beamproj.beams();
	- FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	- LorentzTransform cms_boost(-mom_tot.boostVector());
	+ const FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(mom_tot.betaVec());
	const double s = sqr(beamproj.sqrtS());
	const bool onresonance = fuzzyEquals(beamproj.sqrtS(), 10.58, 2E-3);

	// Particle masses from PDGlive (accessed online 16. Nov. 2009).
	foreach (const Particle& p, ufs.particles()) {
	- // only looking at Lambda_c
	- if(p.abspid()!=4122) continue;
	+ // Only looking at Lambda_c
	+ if (p.abspid() != 4122) continue;
	MSG_DEBUG("Lambda_c found");
	- double mH2 = 5.22780; // 2.28646^2
	- const double mom = cms_boost.transform(p.momentum()).vector3().mod();
	- double xp = mom/sqrt(s/4.0 - mH2);
	+ const double mH2 = 5.22780; // 2.28646^2
	+ const double mom = FourMomentum(cms_boost.transform(p.momentum())).p();
	+ const double xp = mom/sqrt(s/4.0 - mH2);

	- if(onresonance) {
	+ if (onresonance) {
	_histOn ->fill(xp,weight);
	- _sigmaOn ->fill(10.58,weight);
	- }
	- else {
	+ _sigmaOn ->fill(10.58, weight);
	+ } else {
	_histOff ->fill(xp,weight);
	- _sigmaOff->fill(10.54,weight);
	+ _sigmaOff->fill(10.54, weight);
	}
	}
	- } // analyze
	+ }


	void finalize() {
	-
	scale(_sigmaOn , 1./sumOfWeights());
	scale(_sigmaOff, 1./sumOfWeights());
	scale(_histOn , 1./sumOfWeights());
	scale(_histOff , 1./sumOfWeights());
	- } // finalize
	+ }


	- void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(UnstableFinalState(), "UFS");
	-
	- _histOff = bookHisto1D(1,1,1);
	- _sigmaOff = bookHisto1D(2,1,1);
	- _histOn = bookHisto1D(3,1,1);
	- _sigmaOn = bookHisto1D(4,1,1);
	-
	- } // init
	-
	private:

	//@{
	// Histograms for the continuum cross sections
	Histo1DPtr _sigmaOn ;
	Histo1DPtr _sigmaOff;
	Histo1DPtr _histOn ;
	Histo1DPtr _histOff ;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(BABAR_2007_S6895344);

	}
	diff --git a/src/Analyses/BABAR_2007_S7266081.cc b/src/Analyses/BABAR_2007_S7266081.cc
	--- a/src/Analyses/BABAR_2007_S7266081.cc
	+++ b/src/Analyses/BABAR_2007_S7266081.cc
	@@ -1,183 +1,181 @@
	// -- C++ --
	#include <iostream>
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	-#include "Rivet/ParticleName.hh"

	namespace Rivet {


	/// @brief BABAR tau lepton to three charged hadrons
	/// @author Peter Richardson
	class BABAR_2007_S7266081 : public Analysis {
	public:

	BABAR_2007_S7266081()
	: Analysis("BABAR_2007_S7266081"),
	_weight_total(0),
	_weight_pipipi(0), _weight_Kpipi(0), _weight_KpiK(0), _weight_KKK(0)
	{ }


	void init() {
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");
	_hist_pipipi_pipipi = bookHisto1D( 1, 1, 1);
	_hist_pipipi_pipi = bookHisto1D( 2, 1, 1);
	_hist_Kpipi_Kpipi = bookHisto1D( 3, 1, 1);
	_hist_Kpipi_Kpi = bookHisto1D( 4, 1, 1);
	_hist_Kpipi_pipi = bookHisto1D( 5, 1, 1);
	_hist_KpiK_KpiK = bookHisto1D( 6, 1, 1);
	_hist_KpiK_KK = bookHisto1D( 7, 1, 1);
	_hist_KpiK_piK = bookHisto1D( 8, 1, 1);
	_hist_KKK_KKK = bookHisto1D( 9, 1, 1);
	_hist_KKK_KK = bookHisto1D(10, 1, 1);
	}


	void analyze(const Event& e) {
	+ double weight = e.weight();
	// Find the taus
	Particles taus;
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	- foreach (const Particle& p, ufs.particles()) {
	- if (p.abspid() != PID::TAU) continue;
	- _weight_total += 1.;
	+ foreach(const Particle& p, apply<UnstableFinalState>(e, "UFS").particles(Cuts::pid==PID::TAU)) {
	+ _weight_total += weight;
	Particles pip, pim, Kp, Km;
	unsigned int nstable = 0;
	- // get the boost to the rest frame
	+ // Get the boost to the rest frame
	LorentzTransform cms_boost;
	if (p.p3().mod() > 1*MeV)
	- cms_boost = LorentzTransform(-p.momentum().boostVector());
	- // find the decay products we want
	+ cms_boost = LorentzTransform::mkFrameTransformFromBeta(p.momentum().betaVec());
	+ // Find the decay products we want
	findDecayProducts(p.genParticle(), nstable, pip, pim, Kp, Km);
	if (p.pid() < 0) {
	swap(pip, pim);
	swap(Kp, Km );
	}
	if (nstable != 4) continue;
	// pipipi
	if (pim.size() == 2 && pip.size() == 1) {
	- _weight_pipipi += 1.;
	+ _weight_pipipi += weight;
	_hist_pipipi_pipipi->
	- fill((pip[0].momentum()+pim[0].momentum()+pim[1].momentum()).mass(),1.);
	+ fill((pip[0].momentum()+pim[0].momentum()+pim[1].momentum()).mass(), weight);
	_hist_pipipi_pipi->
	- fill((pip[0].momentum()+pim[0].momentum()).mass(),1.);
	+ fill((pip[0].momentum()+pim[0].momentum()).mass(), weight);
	_hist_pipipi_pipi->
	- fill((pip[0].momentum()+pim[1].momentum()).mass(),1.);
	+ fill((pip[0].momentum()+pim[1].momentum()).mass(), weight);
	}
	else if (pim.size() == 1 && pip.size() == 1 && Km.size() == 1) {
	- _weight_Kpipi += 1.;
	+ _weight_Kpipi += weight;
	_hist_Kpipi_Kpipi->
	- fill((pim[0].momentum()+pip[0].momentum()+Km[0].momentum()).mass(),1.);
	+ fill((pim[0].momentum()+pip[0].momentum()+Km[0].momentum()).mass(), weight);
	_hist_Kpipi_Kpi->
	- fill((pip[0].momentum()+Km[0].momentum()).mass(),1.);
	+ fill((pip[0].momentum()+Km[0].momentum()).mass(), weight);
	_hist_Kpipi_pipi->
	- fill((pim[0].momentum()+pip[0].momentum()).mass(),1.);
	+ fill((pim[0].momentum()+pip[0].momentum()).mass(), weight);
	}
	else if (Kp.size() == 1 && Km.size() == 1 && pim.size() == 1) {
	- _weight_KpiK += 1.;
	+ _weight_KpiK += weight;
	_hist_KpiK_KpiK->
	- fill((Kp[0].momentum()+Km[0].momentum()+pim[0].momentum()).mass(),1.);
	+ fill((Kp[0].momentum()+Km[0].momentum()+pim[0].momentum()).mass(), weight);
	_hist_KpiK_KK->
	- fill((Kp[0].momentum()+Km[0].momentum()).mass(),1.);
	+ fill((Kp[0].momentum()+Km[0].momentum()).mass(), weight);
	_hist_KpiK_piK->
	- fill((Kp[0].momentum()+pim[0].momentum()).mass(),1.);
	+ fill((Kp[0].momentum()+pim[0].momentum()).mass(), weight);
	}
	else if (Kp.size() == 1 && Km.size() == 2) {
	- _weight_KKK += 1.;
	+ _weight_KKK += weight;
	_hist_KKK_KKK->
	- fill((Kp[0].momentum()+Km[0].momentum()+Km[1].momentum()).mass(),1.);
	+ fill((Kp[0].momentum()+Km[0].momentum()+Km[1].momentum()).mass(), weight);
	_hist_KKK_KK->
	- fill((Kp[0].momentum()+Km[0].momentum()).mass(),1.);
	+ fill((Kp[0].momentum()+Km[0].momentum()).mass(), weight);
	_hist_KKK_KK->
	- fill((Kp[0].momentum()+Km[1].momentum()).mass(),1.);
	+ fill((Kp[0].momentum()+Km[1].momentum()).mass(), weight);
	}
	}
	}


	void finalize() {
	if (_weight_pipipi > 0.) {
	scale(_hist_pipipi_pipipi, 1.0/_weight_pipipi);
	scale(_hist_pipipi_pipi , 0.5/_weight_pipipi);
	}
	if (_weight_Kpipi > 0.) {
	scale(_hist_Kpipi_Kpipi , 1.0/_weight_Kpipi);
	scale(_hist_Kpipi_Kpi , 1.0/_weight_Kpipi);
	scale(_hist_Kpipi_pipi , 1.0/_weight_Kpipi);
	}
	if (_weight_KpiK > 0.) {
	scale(_hist_KpiK_KpiK , 1.0/_weight_KpiK);
	scale(_hist_KpiK_KK , 1.0/_weight_KpiK);
	scale(_hist_KpiK_piK , 1.0/_weight_KpiK);
	}
	if (_weight_KKK > 0.) {
	scale(_hist_KKK_KKK , 1.0/_weight_KKK);
	scale(_hist_KKK_KK , 0.5/_weight_KKK);
	}
	/// @note Using autobooking for these scatters since their x values are not really obtainable from the MC data
	bookScatter2D(11, 1, 1, true)->point(0).setY(100_weight_pipipi/_weight_total, 100sqrt(_weight_pipipi)/_weight_total);
	bookScatter2D(12, 1, 1, true)->point(0).setY(100_weight_Kpipi/_weight_total, 100sqrt(_weight_Kpipi)/_weight_total);
	bookScatter2D(13, 1, 1, true)->point(0).setY(100_weight_KpiK/_weight_total, 100sqrt(_weight_KpiK)/_weight_total);
	bookScatter2D(14, 1, 1, true)->point(0).setY(100_weight_KKK/_weight_total, 100sqrt(_weight_KKK)/_weight_total);
	}


	private:

	//@{

	// Histograms
	Histo1DPtr _hist_pipipi_pipipi, _hist_pipipi_pipi;
	Histo1DPtr _hist_Kpipi_Kpipi, _hist_Kpipi_Kpi, _hist_Kpipi_pipi;
	Histo1DPtr _hist_KpiK_KpiK, _hist_KpiK_KK, _hist_KpiK_piK;
	Histo1DPtr _hist_KKK_KKK, _hist_KKK_KK;

	// Weights counters
	double _weight_total, _weight_pipipi, _weight_Kpipi, _weight_KpiK, _weight_KKK;

	//@}

	void findDecayProducts(const GenParticle* p,
	unsigned int & nstable,
	Particles& pip, Particles& pim,
	Particles& Kp, Particles& Km) {
	const GenVertex* dv = p->end_vertex();
	/// @todo Use better looping
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	int id = (*pp)->pdg_id();
	if (id == PID::PI0 )
	++nstable;
	else if (id == PID::K0S)
	++nstable;
	else if (id == PID::PIPLUS) {
	pip.push_back(Particle(**pp));
	++nstable;
	}
	else if (id == PID::PIMINUS) {
	pim.push_back(Particle(**pp));
	++nstable;
	}
	else if (id == PID::KPLUS) {
	Kp.push_back(Particle(**pp));
	++nstable;
	}
	else if (id == PID::KMINUS) {
	Km.push_back(Particle(**pp));
	++nstable;
	}
	else if ((*pp)->end_vertex()) {
	findDecayProducts(*pp, nstable, pip, pim, Kp, Km);
	}
	else
	++nstable;
	}
	}


	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(BABAR_2007_S7266081);

	}
	diff --git a/src/Analyses/BABAR_2013_I1116411.cc b/src/Analyses/BABAR_2013_I1116411.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/BABAR_2013_I1116411.cc
	@@ -0,0 +1,84 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Add a short analysis description here
	+ class BABAR_2013_I1116411 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(BABAR_2013_I1116411);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ declare(UnstableFinalState(), "UFS");
	+
	+ // Book histograms
	+ _h_q2 = bookHisto1D(1, 1, 1);
	+
	+ }
	+
	+ // Calculate the Q2 using mother and daughter charged lepton
	+ double q2(const Particle& B) {
	+ const Particle chlept = filter_select(B.children(), Cuts::pid==PID::POSITRON \|\| Cuts::pid==PID::ANTIMUON)[0];
	+ FourMomentum q = B.mom() - chlept.mom();
	+ return q*q;
	+ }
	+
	+ // Check for explicit decay into pdgids
	+ bool isSemileptonicDecay(const Particle& mother, vector<int> ids) {
	+ // Trivial check to ignore any other decays but the one in question modulo photons
	+ const Particles children = mother.children(Cuts::pid!=PID::PHOTON);
	+ if (children.size()!=ids.size()) return false;
	+ // Check for the explicit decay
	+ return all(ids, [&](int i){return count(children, hasPID(i))==1;});
	+ }
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+ // Get B+ Mesons
	+ foreach(const Particle& p, apply<UnstableFinalState>(event, "UFS").particles(Cuts::pid==PID::BPLUS)) {
	+ if (isSemileptonicDecay(p, {PID::OMEGA, PID::POSITRON, PID::NU_E}) \|\|
	+ isSemileptonicDecay(p, {PID::OMEGA, PID::ANTIMUON, PID::NU_MU})) {
	+ _h_q2->fill(q2(p), event.weight());
	+ }
	+ }
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ normalize(_h_q2, 1.21); // normalize to BF
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _h_q2;
	+ //@}
	+
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(BABAR_2013_I1116411);
	+
	+
	+}
	diff --git a/src/Analyses/BABAR_2013_I1238276.cc b/src/Analyses/BABAR_2013_I1238276.cc
	--- a/src/Analyses/BABAR_2013_I1238276.cc
	+++ b/src/Analyses/BABAR_2013_I1238276.cc
	@@ -1,121 +1,117 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	-#include "Rivet/Tools/ParticleIdUtils.hh"

	namespace Rivet {


	/// @brief BaBar pion, kaon and proton production in the continuum
	/// @author Peter Richardson
	class BABAR_2013_I1238276 : public Analysis {
	public:

	BABAR_2013_I1238276()
	: Analysis("BABAR_2013_I1238276")
	{ }


	+ void init() {
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+
	+ _histPion_no_dec = bookHisto1D(1,1,1);
	+ _histKaon_no_dec = bookHisto1D(1,1,2);
	+ _histProton_no_dec = bookHisto1D(1,1,3);
	+ _histPion_dec = bookHisto1D(2,1,1);
	+ _histKaon_dec = bookHisto1D(2,1,2);
	+ _histProton_dec = bookHisto1D(2,1,3);
	+ }
	+
	+
	void analyze(const Event& e) {
	const double weight = e.weight();

	// Loop through charged FS particles and look for charmed mesons/baryons
	- const ChargedFinalState& fs = applyProjection<ChargedFinalState>(e, "FS");
	+ const ChargedFinalState& fs = apply<ChargedFinalState>(e, "FS");

	- const Beam beamproj = applyProjection<Beam>(e, "Beams");
	+ const Beam beamproj = apply<Beam>(e, "Beams");
	const ParticlePair& beams = beamproj.beams();
	- FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	- LorentzTransform cms_boost(-mom_tot.boostVector());
	+ const FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(mom_tot.betaVec());
	MSG_DEBUG("CMS Energy sqrt s = " << beamproj.sqrtS());

	foreach (const Particle& p, fs.particles()) {
	// check if prompt or not
	const GenParticle* pmother = p.genParticle();
	const GenVertex* ivertex = pmother->production_vertex();
	bool prompt = true;
	while (ivertex) {
	int n_inparts = ivertex->particles_in_size();
	if (n_inparts < 1) break;
	pmother = particles(ivertex, HepMC::parents)[0]; // first mother particle
	int mother_pid = abs(pmother->pdg_id());
	if (mother_pid==PID::K0S \|\| mother_pid==PID::LAMBDA) {
	prompt = false;
	break;
	}
	else if (mother_pid<6) {
	break;
	}
	ivertex = pmother->production_vertex();
	}

	-
	// momentum in CMS frame
	const double mom = cms_boost.transform(p.momentum()).vector3().mod();
	const int PdgId = p.abspid();
	MSG_DEBUG("pdgID = " << PdgId << " Momentum = " << mom);
	switch (PdgId) {
	case PID::PIPLUS:
	if(prompt) _histPion_no_dec->fill(mom,weight);
	_histPion_dec ->fill(mom,weight);
	break;
	case PID::KPLUS:
	if(prompt) _histKaon_no_dec->fill(mom,weight);
	_histKaon_dec ->fill(mom,weight);
	break;
	case PID::PROTON:
	if(prompt) _histProton_no_dec->fill(mom,weight);
	_histProton_dec ->fill(mom,weight);
	default :
	break;
	}
	}
	- } // analyze
	+ }


	void finalize() {
	-
	scale(_histPion_no_dec ,1./sumOfWeights());
	scale(_histKaon_no_dec ,1./sumOfWeights());
	scale(_histProton_no_dec,1./sumOfWeights());
	scale(_histPion_dec ,1./sumOfWeights());
	scale(_histKaon_dec ,1./sumOfWeights());
	scale(_histProton_dec ,1./sumOfWeights());
	- } // finalize
	+ }


	- void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	-
	- _histPion_no_dec = bookHisto1D(1,1,1);
	- _histKaon_no_dec = bookHisto1D(1,1,2);
	- _histProton_no_dec = bookHisto1D(1,1,3);
	- _histPion_dec = bookHisto1D(2,1,1);
	- _histKaon_dec = bookHisto1D(2,1,2);
	- _histProton_dec = bookHisto1D(2,1,3);
	-
	- } // init
	-
	private:

	//@{
	// Histograms for continuum data (sqrt(s) = 10.52 GeV)
	// no K_S and Lambda decays
	Histo1DPtr _histPion_no_dec;
	Histo1DPtr _histKaon_no_dec;
	Histo1DPtr _histProton_no_dec;
	// including decays
	Histo1DPtr _histPion_dec;
	Histo1DPtr _histKaon_dec;
	Histo1DPtr _histProton_dec;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(BABAR_2013_I1238276);

	}
	diff --git a/src/Analyses/BABAR_2015_I1334693.cc b/src/Analyses/BABAR_2015_I1334693.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/BABAR_2015_I1334693.cc
	@@ -0,0 +1,83 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Add a short analysis description here
	+ class BABAR_2015_I1334693 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(BABAR_2015_I1334693);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ declare(UnstableFinalState(), "UFS");
	+
	+ // Book histograms
	+ _h_q2 = bookHisto1D(1, 1, 1);
	+
	+ }
	+
	+
	+ // Calculate the Q2 using mother and daugher meson
	+ double q2(const Particle& B, int mesonID) {
	+ FourMomentum q = B.mom() - filter_select(B.children(), Cuts::pid==mesonID)[0];
	+ return q*q;
	+ }
	+
	+ // Check for explicit decay into pdgids
	+ bool isSemileptonicDecay(const Particle& mother, vector<int> ids) {
	+ // Trivial check to ignore any other decays but the one in question modulo photons
	+ const Particles children = mother.children(Cuts::pid!=PID::PHOTON);
	+ if (children.size()!=ids.size()) return false;
	+ // Check for the explicit decay
	+ return all(ids, [&](int i){return count(children, hasPID(i))==1;});
	+ }
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+ // Loop over D0 mesons
	+ foreach(const Particle& p, apply<UnstableFinalState>(event, "UFS").particles(Cuts::pid==PID::D0)) {
	+ if (isSemileptonicDecay(p, {PID::PIMINUS, PID::POSITRON, PID::NU_E})) {
	+ _h_q2->fill(q2(p, PID::PIMINUS), event.weight());
	+ }
	+ }
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ normalize(_h_q2, 375.4); // normalize to data
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _h_q2;
	+ //@}
	+
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(BABAR_2015_I1334693);
	+
	+
	+}
	diff --git a/src/Analyses/BELLE_2001_S4598261.cc b/src/Analyses/BELLE_2001_S4598261.cc
	--- a/src/Analyses/BELLE_2001_S4598261.cc
	+++ b/src/Analyses/BELLE_2001_S4598261.cc
	@@ -1,111 +1,106 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief BELLE pi0 spectrum at Upsilon(4S)
	/// @author Peter Richardson
	class BELLE_2001_S4598261 : public Analysis {
	public:

	BELLE_2001_S4598261()
	: Analysis("BELLE_2001_S4598261"), _weightSum(0.)
	{ }


	+ void init() {
	+ declare(UnstableFinalState(), "UFS");
	+ _histdSigDp = bookHisto1D(1, 1, 1); // spectrum
	+ _histMult = bookHisto1D(2, 1, 1); // multiplicity
	+ }
	+
	+
	void analyze(const Event& e) {
	const double weight = e.weight();

	-
	- // find the upsilons
	+ // Find the upsilons
	Particles upsilons;
	- // first in unstable final state
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ // First in unstable final state
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	foreach (const Particle& p, ufs.particles())
	if (p.pid()==300553) upsilons.push_back(p);
	- // then in whole event if fails
	+ // Then in whole event if fails
	if (upsilons.empty()) {
	foreach (const GenParticle* p, Rivet::particles(e.genEvent())) {
	if (p->pdg_id() != 300553) continue;
	const GenVertex* pv = p->production_vertex();
	bool passed = true;
	if (pv) {
	/// @todo Use better looping
	for (GenVertex::particles_in_const_iterator pp = pv->particles_in_const_begin() ; pp != pv->particles_in_const_end() ; ++pp) {
	if ( p->pdg_id() == (*pp)->pdg_id() ) {
	passed = false;
	break;
	}
	}
	}
	if (passed) upsilons.push_back(Particle(p));
	}
	}

	// Find upsilons
	foreach (const Particle& p, upsilons) {
	_weightSum += weight;
	// Find the neutral pions from the decay
	vector<GenParticle *> pions;
	findDecayProducts(p.genParticle(), pions);
	- LorentzTransform cms_boost(-p.momentum().boostVector());
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(p.momentum().betaVec());
	for (size_t ix=0; ix<pions.size(); ++ix) {
	- double pcm =
	- cms_boost.transform(FourMomentum(pions[ix]->momentum())).vector3().mod();
	+ const double pcm = cms_boost.transform(FourMomentum(pions[ix]->momentum())).p();
	_histdSigDp->fill(pcm,weight);
	}
	_histMult->fill(0., pions.size()*weight);
	}
	}


	void finalize() {
	scale(_histdSigDp, 1./_weightSum);
	scale(_histMult , 1./_weightSum);
	}


	- void init() {
	- addProjection(UnstableFinalState(), "UFS");
	-
	- // spectrum
	- _histdSigDp = bookHisto1D(1, 1, 1);
	- // multiplicity
	- _histMult = bookHisto1D(2, 1, 1);
	- }
	-
	-
	private:

	//@{
	// count of weights
	double _weightSum;
	/// Histograms
	Histo1DPtr _histdSigDp;
	Histo1DPtr _histMult;
	//@}

	+
	void findDecayProducts(const GenParticle* p, vector<GenParticle*>& pions) {
	const GenVertex* dv = p->end_vertex();
	/// @todo Use better looping
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	- int id = (*pp)->pdg_id();
	- if (id==111) {
	+ const int id = (*pp)->pdg_id();
	+ if (id == 111) {
	pions.push_back(*pp);
	- } else if((*pp)->end_vertex())
	+ } else if ((*pp)->end_vertex())
	findDecayProducts(*pp, pions);
	}
	}


	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(BELLE_2001_S4598261);

	}
	diff --git a/src/Analyses/BELLE_2008_I786560.cc b/src/Analyses/BELLE_2008_I786560.cc
	--- a/src/Analyses/BELLE_2008_I786560.cc
	+++ b/src/Analyses/BELLE_2008_I786560.cc
	@@ -1,114 +1,112 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	-#include "Rivet/ParticleName.hh"

	namespace Rivet {


	/// @brief BELLE tau lepton to pi pi
	/// @author Peter Richardson
	class BELLE_2008_I786560 : public Analysis {
	public:

	BELLE_2008_I786560()
	: Analysis("BELLE_2008_I786560"),
	_weight_total(0),
	_weight_pipi(0)
	{ }


	void init() {
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");
	_hist_pipi = bookHisto1D( 1, 1, 1);
	}


	void analyze(const Event& e) {
	// Find the taus
	Particles taus;
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	foreach (const Particle& p, ufs.particles()) {
	if (p.abspid() != PID::TAU) continue;
	_weight_total += 1.;
	Particles pip, pim, pi0;
	unsigned int nstable = 0;
	// get the boost to the rest frame
	LorentzTransform cms_boost;
	if (p.p3().mod() > 1*MeV)
	- cms_boost = LorentzTransform(-p.momentum().boostVector());
	+ cms_boost = LorentzTransform::mkFrameTransformFromBeta(p.momentum().betaVec());
	// find the decay products we want
	findDecayProducts(p.genParticle(), nstable, pip, pim, pi0);
	if (p.pid() < 0) {
	swap(pip, pim);
	}
	if (nstable != 3) continue;
	// pipi
	if (pim.size() == 1 && pi0.size() == 1) {
	_weight_pipi += 1.;
	_hist_pipi->fill((pi0[0].momentum()+pim[0].momentum()).mass2(),1.);
	}
	}
	}


	void finalize() {
	if (_weight_pipi > 0.) scale(_hist_pipi, 1./_weight_pipi);
	}


	private:

	//@{

	// Histograms
	Histo1DPtr _hist_pipi;

	// Weights counters
	double _weight_total, _weight_pipi;

	//@}

	void findDecayProducts(const GenParticle* p,
	unsigned int & nstable,
	Particles& pip, Particles& pim,
	Particles& pi0) {
	const GenVertex* dv = p->end_vertex();
	/// @todo Use better looping
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin(); pp != dv->particles_out_const_end(); ++pp) {
	int id = (*pp)->pdg_id();
	if (id == PID::PI0 ) {
	pi0.push_back(Particle(**pp));
	++nstable;
	}
	else if (id == PID::K0S)
	++nstable;
	else if (id == PID::PIPLUS) {
	pip.push_back(Particle(**pp));
	++nstable;
	}
	else if (id == PID::PIMINUS) {
	pim.push_back(Particle(**pp));
	++nstable;
	}
	else if (id == PID::KPLUS) {
	++nstable;
	}
	else if (id == PID::KMINUS) {
	++nstable;
	}
	else if ((*pp)->end_vertex()) {
	findDecayProducts(*pp, nstable, pip, pim, pi0);
	}
	else
	++nstable;
	}
	}
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(BELLE_2008_I786560);

	}
	diff --git a/src/Analyses/BELLE_2011_I878990.cc b/src/Analyses/BELLE_2011_I878990.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/BELLE_2011_I878990.cc
	@@ -0,0 +1,82 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Add a short analysis description here
	+ class BELLE_2011_I878990 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(BELLE_2011_I878990);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ declare(UnstableFinalState(), "UFS");
	+
	+ // Book histograms
	+ _h_q2 = bookHisto1D(1, 1, 1);
	+ }
	+
	+ // Calculate the Q2 using mother and daugher meson
	+ double q2(const Particle& B, int mesonID) {
	+ FourMomentum q = B.mom() - filter_select(B.children(), Cuts::pid==mesonID)[0];
	+ return q*q;
	+ }
	+
	+ // Check for explicit decay into pdgids
	+ bool isSemileptonicDecay(const Particle& mother, vector<int> ids) {
	+ // Trivial check to ignore any other decays but the one in question modulo photons
	+ const Particles children = mother.children(Cuts::pid!=PID::PHOTON);
	+ if (children.size()!=ids.size()) return false;
	+ // Check for the explicit decay
	+ return all(ids, [&](int i){return count(children, hasPID(i))==1;});
	+ }
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+ // Loop over B0 mesons
	+ foreach(const Particle& p, apply<UnstableFinalState>(event, "UFS").particles(Cuts::pid==PID::B0)) {
	+ if (isSemileptonicDecay(p, {PID::PIMINUS, PID::POSITRON, PID::NU_E}) \|\|
	+ isSemileptonicDecay(p, {PID::PIMINUS, PID::ANTIMUON, PID::NU_MU})) {
	+ _h_q2->fill(q2(p, PID::PIMINUS), event.weight());
	+ }
	+ }
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ normalize(_h_q2, 3000.86); // normalize to BF*dQ2
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _h_q2;
	+ //@}
	+
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(BELLE_2011_I878990);
	+
	+
	+}
	diff --git a/src/Analyses/BELLE_2013_I1216515.cc b/src/Analyses/BELLE_2013_I1216515.cc
	--- a/src/Analyses/BELLE_2013_I1216515.cc
	+++ b/src/Analyses/BELLE_2013_I1216515.cc
	@@ -1,83 +1,81 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	-#include "Rivet/Tools/ParticleIdUtils.hh"

	namespace Rivet {


	/// @brief BELLE pion and kaon continuum production
	/// @author Peter Richardson
	class BELLE_2013_I1216515 : public Analysis {
	public:

	BELLE_2013_I1216515()
	: Analysis("BELLE_2013_I1216515")
	{ }


	void analyze(const Event& e) {
	const double weight = e.weight();

	// Loop through charged FS particles and look for charmed mesons/baryons
	- const ChargedFinalState& fs = applyProjection<ChargedFinalState>(e, "FS");
	+ const ChargedFinalState& fs = apply<ChargedFinalState>(e, "FS");

	- const Beam beamproj = applyProjection<Beam>(e, "Beams");
	+ const Beam beamproj = apply<Beam>(e, "Beams");
	const ParticlePair& beams = beamproj.beams();
	- FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	- LorentzTransform cms_boost(-mom_tot.boostVector());
	- MSG_DEBUG("CMS Energy sqrt s = " << beamproj.sqrtS());
	+ const FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(mom_tot.betaVec());
	+ MSG_DEBUG("CMS energy sqrt s = " << beamproj.sqrtS());

	foreach (const Particle& p, fs.particles()) {
	// energy in CMS frame
	const double en = cms_boost.transform(p.momentum()).t();
	const double z = 2.*en/beamproj.sqrtS();
	const int PdgId = p.abspid();
	MSG_DEBUG("pdgID = " << PdgId << " Energy = " << en);
	switch (PdgId) {
	case PID::PIPLUS:
	_histPion->fill(z,weight);
	break;
	case PID::KPLUS:
	_histKaon->fill(z,weight);
	break;
	default :
	break;
	}
	}
	} // analyze


	void finalize() {

	scale(_histPion,crossSection()/femtobarn/sumOfWeights());
	scale(_histKaon,crossSection()/femtobarn/sumOfWeights());
	} // finalize


	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");

	_histPion = bookHisto1D(1,1,1);
	_histKaon = bookHisto1D(1,1,2);

	} // init

	private:

	//@{
	// Histograms for continuum data (sqrt(s) = 10.52 GeV)
	Histo1DPtr _histPion;
	Histo1DPtr _histKaon;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(BELLE_2013_I1216515);

	}
	diff --git a/src/Analyses/BELLE_2013_I1238273.cc b/src/Analyses/BELLE_2013_I1238273.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/BELLE_2013_I1238273.cc
	@@ -0,0 +1,114 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Add a short analysis description here
	+ class BELLE_2013_I1238273 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(BELLE_2013_I1238273);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ declare(UnstableFinalState(), "UFS");
	+
	+ // Book histograms
	+ _h_q2_B0bar_pi = bookHisto1D(1, 1, 1);
	+ _h_q2_B0bar_rho = bookHisto1D(3, 1, 1);
	+ _h_q2_Bminus_pi = bookHisto1D(2, 1, 1);
	+ _h_q2_Bminus_rho = bookHisto1D(4, 1, 1);
	+ _h_q2_Bminus_omega = bookHisto1D(5, 1, 1);
	+
	+ }
	+
	+ // Calculate the Q2 using mother and daugher meson
	+ double q2(const Particle& B, int mesonID) {
	+ FourMomentum q = B.mom() - filter_select(B.children(), Cuts::pid==mesonID)[0];
	+ return q*q;
	+ }
	+
	+ // Check for explicit decay into pdgids
	+ bool isSemileptonicDecay(const Particle& mother, vector<int> ids) {
	+ // Trivial check to ignore any other decays but the one in question modulo photons
	+ const Particles children = mother.children(Cuts::pid!=PID::PHOTON);
	+ if (children.size()!=ids.size()) return false;
	+ // Check for the explicit decay
	+ return all(ids, [&](int i){return count(children, hasPID(i))==1;});
	+ }
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+ // Loop over B0bar Mesons
	+ foreach(const Particle& p, apply<UnstableFinalState>(event, "UFS").particles(Cuts::pid==PID::B0BAR)) {
	+ if (isSemileptonicDecay(p, {PID::PIPLUS, PID::ELECTRON, PID::NU_EBAR}) \|\|
	+ isSemileptonicDecay(p, {PID::PIPLUS, PID::MUON, PID::NU_MUBAR})) {
	+ _h_q2_B0bar_pi->fill(q2(p, PID::PIPLUS), event.weight());
	+ }
	+ if (isSemileptonicDecay(p, {PID::RHOPLUS, PID::ELECTRON, PID::NU_EBAR}) \|\|
	+ isSemileptonicDecay(p, {PID::RHOPLUS, PID::MUON, PID::NU_MUBAR})) {
	+ _h_q2_B0bar_rho->fill(q2(p, PID::RHOPLUS), event.weight());
	+ }
	+ }
	+ // Loop over B- Mesons
	+ foreach(const Particle& p, apply<UnstableFinalState>(event, "UFS").particles(Cuts::pid==PID::BMINUS)) {
	+ if (isSemileptonicDecay(p, {PID::PI0, PID::ELECTRON, PID::NU_EBAR}) \|\|
	+ isSemileptonicDecay(p, {PID::PI0, PID::MUON, PID::NU_MUBAR})) {
	+ _h_q2_Bminus_pi->fill(q2(p, PID::PI0), event.weight());
	+ }
	+ if (isSemileptonicDecay(p, {PID::RHO0, PID::ELECTRON, PID::NU_EBAR}) \|\|
	+ isSemileptonicDecay(p, {PID::RHO0, PID::MUON, PID::NU_MUBAR})) {
	+ _h_q2_Bminus_rho->fill(q2(p,PID::RHO0), event.weight());
	+ }
	+ if (isSemileptonicDecay(p, {PID::OMEGA, PID::ELECTRON, PID::NU_EBAR}) \|\|
	+ isSemileptonicDecay(p, {PID::OMEGA, PID::MUON, PID::NU_MUBAR})) {
	+ _h_q2_Bminus_omega->fill(q2(p, PID::OMEGA), event.weight());
	+ }
	+ }
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ normalize(_h_q2_B0bar_pi , 298.8); // normalize to BF*dQ2
	+ normalize(_h_q2_B0bar_rho , 1304.8); // normalize to BF*dQ2
	+ normalize(_h_q2_Bminus_pi , 324.8); // normalize to BF*dQ2
	+ normalize(_h_q2_Bminus_rho , 367.0); // normalize to BF*dQ2
	+ normalize(_h_q2_Bminus_omega, 793.1); // normalize to BF*dQ2
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _h_q2_B0bar_pi ;
	+ Histo1DPtr _h_q2_B0bar_rho ;
	+ Histo1DPtr _h_q2_Bminus_pi ;
	+ Histo1DPtr _h_q2_Bminus_rho ;
	+ Histo1DPtr _h_q2_Bminus_omega;
	+ //@}
	+
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(BELLE_2013_I1238273);
	+
	+
	+}
	diff --git a/src/Analyses/BELLE_2015_I1397632.cc b/src/Analyses/BELLE_2015_I1397632.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/BELLE_2015_I1397632.cc
	@@ -0,0 +1,98 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Add a short analysis description here
	+ class BELLE_2015_I1397632 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(BELLE_2015_I1397632);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+
	+ declare(UnstableFinalState(), "UFS");
	+
	+ // Book histograms
	+ _h_B_Denu = bookHisto1D(1, 1, 1);
	+ _h_B_Dmunu = bookHisto1D(1, 1, 2);
	+ _h_B_Deplusnu = bookHisto1D(1, 1, 3);
	+ _h_B_Dmuplusnu = bookHisto1D(1, 1, 4);
	+ }
	+
	+ // Check for explicit decay into pdgids
	+ bool isSemileptonicDecay(const Particle& mother, vector<int> ids) {
	+ // Trivial check to ignore any other decays but the one in question modulo photons
	+ const Particles children = mother.children(Cuts::pid!=PID::PHOTON);
	+ if (children.size()!=ids.size()) return false;
	+ // Check for the explicit decay
	+ return all(ids, [&](int i){return count(children, hasPID(i))==1;});
	+ }
	+
	+ // Calculate the recoil w using mother and daugher meson
	+ double recoilW(const Particle& B, int mesonID) {
	+ // TODO why does that not work with const?
	+ Particle D = filter_select(B.children(), Cuts::pid==mesonID)[0];
	+ FourMomentum q = B.mom() - D.mom();
	+ return (B.mom()B.mom() + D.mom()D.mom() - qq )/ (2. sqrt(B.mom()B.mom()) sqrt(D.mom()*D.mom()) );
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+ // Get B0 Mesons
	+ foreach(const Particle& p, apply<UnstableFinalState>(event, "UFS").particles(Cuts::pid==PID::B0)) {
	+ if (isSemileptonicDecay(p, {PID::DMINUS,PID::POSITRON,PID::NU_E})) _h_B_Denu->fill( recoilW(p, PID::DMINUS), event.weight());
	+ if (isSemileptonicDecay(p, {PID::DMINUS,PID::ANTIMUON,PID::NU_MU})) _h_B_Dmunu->fill(recoilW(p, PID::DMINUS), event.weight());
	+ }
	+ // Get B+ Mesons
	+ foreach(const Particle& p, apply<UnstableFinalState>(event, "UFS").particles(Cuts::pid==PID::BPLUS)) {
	+ if (isSemileptonicDecay(p, {PID::D0BAR,PID::POSITRON,PID::NU_E})) _h_B_Deplusnu->fill( recoilW(p, PID::D0BAR), event.weight());
	+ if (isSemileptonicDecay(p, {PID::D0BAR,PID::ANTIMUON,PID::NU_MU})) _h_B_Dmuplusnu->fill(recoilW(p, PID::D0BAR), event.weight());
	+ }
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ normalize(_h_B_Denu);
	+ normalize(_h_B_Dmunu);
	+ normalize(_h_B_Deplusnu);
	+ normalize(_h_B_Dmuplusnu);
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _h_B_Denu;
	+ Histo1DPtr _h_B_Dmunu;
	+ Histo1DPtr _h_B_Deplusnu;
	+ Histo1DPtr _h_B_Dmuplusnu;
	+ //@}
	+
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(BELLE_2015_I1397632);
	+
	+
	+}
	diff --git a/src/Analyses/CDF_1988_S1865951.cc b/src/Analyses/CDF_1988_S1865951.cc
	--- a/src/Analyses/CDF_1988_S1865951.cc
	+++ b/src/Analyses/CDF_1988_S1865951.cc
	@@ -1,85 +1,85 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/TriggerCDFRun0Run1.hh"

	namespace Rivet {


	/// @brief CDF track \f$ p_\perp \f$ distributions at 630 and 1800 GeV
	class CDF_1988_S1865951 : public Analysis {
	public:

	/// Constructor
	CDF_1988_S1865951()
	: Analysis("CDF_1988_S1865951")
	{
	_sumWTrig = 0;
	}


	/// @name Analysis methods
	//@{

	/// Book histograms and set up projections
	void init() {
	// Set up projections
	- addProjection(TriggerCDFRun0Run1(), "Trigger");
	+ declare(TriggerCDFRun0Run1(), "Trigger");
	const ChargedFinalState cfs(-1.0, 1.0, 0.4*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	// Book histo
	if (fuzzyEquals(sqrtS()/GeV, 1800, 1E-3)) {
	_hist_pt = bookHisto1D(1, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 630, 1E-3)) {
	_hist_pt = bookHisto1D(2, 1, 1);
	}
	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Trigger
	- const bool trigger = applyProjection<TriggerCDFRun0Run1>(event, "Trigger").minBiasDecision();
	+ const bool trigger = apply<TriggerCDFRun0Run1>(event, "Trigger").minBiasDecision();
	if (!trigger) vetoEvent;
	const double weight = event.weight();
	_sumWTrig += weight;

	- const FinalState& trackfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const FinalState& trackfs = apply<ChargedFinalState>(event, "CFS");
	foreach (Particle p, trackfs.particles()) {
	const double pt = p.pT()/GeV;
	// Effective weight for d3sig/dp3 = weight / ( Delta eta * 2pi * pt ), with Delta(eta) = 2
	const double eff_weight = weight/(22TWOPI*pt);
	_hist_pt->fill(pt, eff_weight);
	}
	}


	/// Scale histos
	void finalize() {
	scale(_hist_pt, crossSectionPerEvent()/millibarn);
	}

	//@}


	private:

	/// @name Counters
	//@{
	double _sumWTrig;
	//@}

	/// @name Histos
	//@{
	Histo1DPtr _hist_pt;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_1988_S1865951);

	}
	diff --git a/src/Analyses/CDF_1990_S2089246.cc b/src/Analyses/CDF_1990_S2089246.cc
	--- a/src/Analyses/CDF_1990_S2089246.cc
	+++ b/src/Analyses/CDF_1990_S2089246.cc
	@@ -1,85 +1,85 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/TriggerCDFRun0Run1.hh"

	namespace Rivet {


	/// @brief CDF pseudorapidity analysis at 630 and 1800 GeV
	/// @author Andy Buckley
	class CDF_1990_S2089246 : public Analysis {
	public:

	/// Constructor
	CDF_1990_S2089246()
	: Analysis("CDF_1990_S2089246")
	{
	_sumWTrig = 0;
	}


	/// @name Analysis methods
	//@{

	void init() {
	// Setup projections
	- addProjection(TriggerCDFRun0Run1(), "Trigger");
	- addProjection(ChargedFinalState(-3.5, 3.5), "CFS");
	+ declare(TriggerCDFRun0Run1(), "Trigger");
	+ declare(ChargedFinalState(-3.5, 3.5), "CFS");

	// Book histo
	if (fuzzyEquals(sqrtS()/GeV, 1800, 1E-3)) {
	_hist_eta = bookHisto1D(3, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 630, 1E-3)) {
	_hist_eta = bookHisto1D(4, 1, 1);
	}
	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Trigger
	- const bool trigger = applyProjection<TriggerCDFRun0Run1>(event, "Trigger").minBiasDecision();
	+ const bool trigger = apply<TriggerCDFRun0Run1>(event, "Trigger").minBiasDecision();
	if (!trigger) vetoEvent;
	const double weight = event.weight();
	_sumWTrig += weight;

	// Loop over final state charged particles to fill eta histos
	- const FinalState& fs = applyProjection<FinalState>(event, "CFS");
	+ const FinalState& fs = apply<FinalState>(event, "CFS");
	foreach (const Particle& p, fs.particles()) {
	const double eta = p.eta();
	_hist_eta->fill(fabs(eta), weight);
	}
	}


	/// Finalize
	void finalize() {
	// Divide through by num events to get d<N>/d(eta) in bins
	// Factor of 1/2 for \|eta\| -> eta
	scale(_hist_eta, 0.5/_sumWTrig);
	}

	//@}


	private:

	/// @name Weight counter
	//@{
	double _sumWTrig;
	//@}

	/// @name Histogram collections
	//@{
	Histo1DPtr _hist_eta;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_1990_S2089246);

	}
	diff --git a/src/Analyses/CDF_1993_S2742446.cc b/src/Analyses/CDF_1993_S2742446.cc
	--- a/src/Analyses/CDF_1993_S2742446.cc
	+++ b/src/Analyses/CDF_1993_S2742446.cc
	@@ -1,89 +1,110 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief CDF <what is this analysis doing?>
	class CDF_1993_S2742446 : public Analysis {
	public:

	CDF_1993_S2742446()
	: Analysis("CDF_1993_S2742446")
	{ }


	public:

	void init() {

	// The photon selection has been corrected to pTmin=22 GeV (vs. 23 in the trigger)
	LeadingParticlesFinalState photonfs(FinalState(-0.9, 0.9, 22.0*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// FS excluding the leading photon
	VetoedFinalState vfs(FinalState(-4.2, 4.2));
	vfs.addVetoOnThisFinalState(photonfs);
	- addProjection(vfs, "VFS");
	+ declare(vfs, "VFS");

	// Jets
	- addProjection(FastJets(vfs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ declare(FastJets(vfs, FastJets::CDFJETCLU, 0.7), "Jets");

	_h_costheta = bookHisto1D(1, 1, 1);

	}


	void analyze(const Event& event) {

	const double weight = event.weight();

	- Particles photons = applyProjection<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	+ Particles photons = apply<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	if (photons.size()!=1 \|\| photons[0].pT()>45.0*GeV) {
	vetoEvent;
	}
	FourMomentum leadingPhoton = photons[0].momentum();
	double eta_P = leadingPhoton.eta();
	double phi_P = leadingPhoton.phi();

	// photon isolation: less than 2 GeV EM E_T
	double Etsum=0.0;
	- foreach (const Particle& p, applyProjection<VetoedFinalState>(event, "VFS").particles()) {
	+ foreach (const Particle& p, apply<VetoedFinalState>(event, "VFS").particles()) {
	if (p.charge() != 0 && deltaR(eta_P, phi_P, p.eta(), p.phi()) < 0.7) Etsum += p.Et();
	}
	if (Etsum > 2*GeV) vetoEvent;

	+ FourMomentum jetsum;
	+ Jets jets = apply<FastJets>(event, "Jets").jets(Cuts::pT > 10*GeV, cmpMomByPt);
	+
	+ // Require at least one jet with pT>10 GeV
	+ if (jets.size()==0) vetoEvent;
	+
	+ // Require the leading jet to be in the opposite (phi) hemisphere w.r.t. the photon
	+ if (jets[0].phi() - phi_P <= M_PI) vetoEvent;
	+
	// sum all jets in the opposite hemisphere in phi from the photon
	- FourMomentum jetsum;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "Jets").jets(Cuts::pT > 10*GeV)) {
	+ foreach (const Jet& jet, jets) {
	if (fabs(jet.phi()-phi_P) > M_PI) jetsum+=jet.momentum();
	}

	+ // c.m. cuts, see Table 1
	+ double etaboost = (jetsum.eta()+eta_P)/2.;
	+ if (!inRange(etaboost, -1.2, 1.2)) vetoEvent;
	+
	+ double etastar = (jetsum.eta()-eta_P)/2.;
	+ if (!inRange(etastar, -1.1, 1.1)) vetoEvent;
	+
	+ double pstar = photons[0].pT()*cosh(etastar);
	+ if (!inRange(pstar, 27.8, 47.0)) vetoEvent;
	+
	const double costheta = fabs(tanh((eta_P-jetsum.eta())/2.0));
	+ if (!inRange(costheta, 0., 0.8)) vetoEvent;
	+
	+ // Fill histo
	_h_costheta->fill(costheta, weight);
	}


	void finalize() {
	/// @todo Take fixed norm direct from ref histo
	normalize(_h_costheta, 1.4271); // fixed norm ok
	}


	private:

	Histo1DPtr _h_costheta;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_1993_S2742446);

	}
	diff --git a/src/Analyses/CDF_1994_S2952106.cc b/src/Analyses/CDF_1994_S2952106.cc
	--- a/src/Analyses/CDF_1994_S2952106.cc
	+++ b/src/Analyses/CDF_1994_S2952106.cc
	@@ -1,209 +1,209 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"

	namespace Rivet {


	/// @brief CDF Run I color coherence analysis
	/// @author Andy Buckley
	/// @author Lars Sonnenschein
	class CDF_1994_S2952106 : public Analysis {
	public:

	/// Constructor
	CDF_1994_S2952106() : Analysis("CDF_1994_S2952106")
	{
	}


	/// @name Analysis methods
	//@{

	void init() {
	const FinalState fs(-4.2, 4.2);
	- addProjection(fs, "FS");
	- addProjection(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ declare(fs, "FS");
	+ declare(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");

	// Zero passed-cuts event weight counters
	_sumw = 0;

	// Output histograms
	_histJet1Et = bookHisto1D(1,1,1);
	_histJet2Et = bookHisto1D(2,1,1);
	_histJet3eta = bookScatter2D(3,1,1);
	_histR23 = bookScatter2D(4,1,1);
	_histAlpha = bookScatter2D(5,1,1);

	// Temporary histos: these are the ones we actually fill for the plots which require correction
	_tmphistJet3eta.reset(new Histo1D(refData(3,1,1)));
	_tmphistR23.reset( new Histo1D(refData(4,1,1)));
	_tmphistAlpha.reset( new Histo1D(refData(5,1,1)));
	}



	// Do the analysis
	void analyze(const Event & event) {
	- const Jets jets = applyProjection<FastJets>(event, "Jets").jets(cmpMomByEt);
	+ const Jets jets = apply<FastJets>(event, "Jets").jets(cmpMomByEt);
	MSG_DEBUG("Jet multiplicity before any cuts = " << jets.size());

	// ETs only from jets:
	double et_sinphi_sum = 0;
	double et_cosphi_sum = 0;
	double et_sum = 0;
	for (size_t i = 0; i< jets.size(); ++i) {
	et_sinphi_sum += jets[i].Et() * sin(jets[i].phi());
	et_cosphi_sum += jets[i].Et() * cos(jets[i].phi());
	et_sum += jets[i].Et();
	}

	// ET requirement
	if (sqrt(sqr(et_sinphi_sum) + sqr(et_cosphi_sum))/et_sum > 6.0) vetoEvent;

	// Check jet requirements
	if (jets.size() < 3) vetoEvent;
	if (jets[0].pT() < 110*GeV) vetoEvent;
	if (jets[2].pT() < 10*GeV) vetoEvent;

	// More jet 1,2,3 checks
	FourMomentum pj1(jets[0].momentum()), pj2(jets[1].momentum()), pj3(jets[2].momentum());
	if (fabs(pj1.eta()) > 0.7 \|\| fabs(pj2.eta()) > 0.7) vetoEvent;
	MSG_DEBUG("Jet 1 & 2 eta, pT requirements fulfilled");

	// Require that jets are back-to-back within 20 degrees in phi
	if ((PI - deltaPhi(pj1.phi(), pj2.phi())) > (20/180.0)*PI) vetoEvent;
	MSG_DEBUG("Jet 1 & 2 phi requirement fulfilled");

	const double weight = event.weight();
	_sumw += weight;

	// Fill histos
	_histJet1Et->fill(pj1.pT(), weight);
	_histJet2Et->fill(pj2.pT(), weight);
	_tmphistJet3eta->fill(pj3.eta(), weight);
	_tmphistR23->fill(deltaR(pj2, pj3), weight);

	// Calc and plot alpha
	const double dPhi = deltaPhi(pj3.phi(), pj2.phi());
	const double dH = sign(pj2.eta()) * (pj3.eta() - pj2.eta());
	const double alpha = atan(dH/dPhi);
	_tmphistAlpha->fill(alpha*180./PI, weight);
	}


	/// Apply bin-wise detector correction factors
	void finalize() {

	// Normal scalings
	normalize(_histJet1Et, 12.3);
	normalize(_histJet2Et, 12.3);

	// eta3 correction
	const double eta3_CDF_sim[] =
	{ 0.0013, 0.0037, 0.0047, 0.0071, 0.0093, 0.0117, 0.0151, 0.0149, 0.0197, 0.0257,
	0.0344, 0.0409, 0.0481, 0.0454, 0.0394, 0.0409, 0.0387, 0.0387, 0.0322, 0.0313,
	0.0290, 0.0309, 0.0412, 0.0417, 0.0412, 0.0397, 0.0417, 0.0414, 0.0376, 0.0316,
	0.0270, 0.0186, 0.0186, 0.0132, 0.0127, 0.0106, 0.0071, 0.0040, 0.0020, 0.0013 };
	const double eta3_CDF_sim_err[] =
	{ 0.0009, 0.0009, 0.0007, 0.0007, 0.0007, 0.0010, 0.0012, 0.0012, 0.0013, 0.0016,
	0.0017, 0.0020, 0.0020, 0.0022, 0.0020, 0.0020, 0.0018, 0.0018, 0.0016, 0.0017,
	0.0017, 0.0019, 0.0020, 0.0021, 0.0020, 0.0020, 0.0019, 0.0020, 0.0018, 0.0017,
	0.0017, 0.0014, 0.0014, 0.0009, 0.0010, 0.0009, 0.0009, 0.0008, 0.0008, 0.0009 };
	const double eta3_Ideal_sim[] =
	{ 0.0017, 0.0030, 0.0033, 0.0062, 0.0062, 0.0112, 0.0177, 0.0164, 0.0196, 0.0274,
	0.0351, 0.0413, 0.0520, 0.0497, 0.0448, 0.0446, 0.0375, 0.0329, 0.0291, 0.0272,
	0.0233, 0.0288, 0.0384, 0.0396, 0.0468, 0.0419, 0.0459, 0.0399, 0.0355, 0.0329,
	0.0274, 0.0230, 0.0201, 0.0120, 0.0100, 0.0080, 0.0051, 0.0051, 0.0010, 0.0010 };
	for (size_t i = 0; i < 40; ++i) {
	const double yval = _tmphistJet3eta->bin(i).area() * (eta3_CDF_sim[i]/eta3_Ideal_sim[i]);
	const double yerr = _tmphistJet3eta->bin(i).areaErr() * (eta3_CDF_sim_err[i]/eta3_Ideal_sim[i]);
	_histJet3eta->addPoint(_tmphistJet3eta->bin(i).xMid(), yval/_sumw,
	_tmphistJet3eta->bin(i).xWidth()/2.0, yerr/_sumw);
	}

	// R23 correction
	const double R23_CDF_sim[] =
	{ 0.0005, 0.0161, 0.0570, 0.0762, 0.0723, 0.0705, 0.0598, 0.0563, 0.0557, 0.0579,
	0.0538, 0.0522, 0.0486, 0.0449, 0.0418, 0.0361, 0.0326, 0.0304, 0.0252, 0.0212,
	0.0173, 0.0176, 0.0145, 0.0127, 0.0103, 0.0065, 0.0049, 0.0045, 0.0035, 0.0029,
	0.0024, 0.0014, 0.0011, 0.0010, 0.0009 };
	const double R23_CDF_sim_err[] =
	{ 0.0013, 0.0009, 0.0022, 0.0029, 0.0026, 0.0024, 0.0022, 0.0025, 0.0023, 0.0024,
	0.0021, 0.0021, 0.0021, 0.0021, 0.0021, 0.0019, 0.0019, 0.0016, 0.0017, 0.0014,
	0.0010, 0.0014, 0.0012, 0.0013, 0.0010, 0.0011, 0.0010, 0.0010, 0.0010, 0.0011,
	0.0011, 0.0009, 0.0008, 0.0008, 0.0009 };
	const double R23_Ideal_sim[] =
	{ 0.0005, 0.0176, 0.0585, 0.0862, 0.0843, 0.0756, 0.0673, 0.0635, 0.0586, 0.0619,
	0.0565, 0.0515, 0.0466, 0.0472, 0.0349, 0.0349, 0.0266, 0.0254, 0.0204, 0.0179,
	0.0142, 0.0134, 0.0101, 0.0090, 0.0080, 0.0034, 0.0030, 0.0033, 0.0027, 0.0021,
	0.0012, 0.0006, 0.0004, 0.0005, 0.0003 };
	for (size_t i = 0; i < 35; ++i) {
	const double yval = _tmphistR23->bin(i).area() * (R23_CDF_sim[i]/R23_Ideal_sim[i]);
	const double yerr = _tmphistR23->bin(i).areaErr() * (R23_CDF_sim_err[i]/R23_Ideal_sim[i]);
	_histR23->addPoint(_tmphistR23->bin(i).xMid(), yval/_sumw,
	_tmphistR23->bin(i).xWidth()/2.0, yerr/_sumw);
	}

	// alpha correction
	const double alpha_CDF_sim[] =
	{ 0.0517, 0.0461, 0.0490, 0.0452, 0.0451, 0.0435, 0.0317, 0.0287, 0.0294, 0.0261,
	0.0231, 0.0220, 0.0233, 0.0192, 0.0213, 0.0166, 0.0176, 0.0146, 0.0136, 0.0156,
	0.0142, 0.0152, 0.0151, 0.0147, 0.0164, 0.0186, 0.0180, 0.0210, 0.0198, 0.0189,
	0.0197, 0.0211, 0.0270, 0.0236, 0.0243, 0.0269, 0.0257, 0.0276, 0.0246, 0.0286 };
	const double alpha_CDF_sim_err[] =
	{ 0.0024, 0.0025, 0.0024, 0.0024, 0.0024, 0.0022, 0.0019, 0.0018, 0.0019, 0.0016,
	0.0017, 0.0017, 0.0019, 0.0013, 0.0017, 0.0014, 0.0016, 0.0013, 0.0012, 0.0009,
	0.0014, 0.0014, 0.0014, 0.0014, 0.0014, 0.0015, 0.0014, 0.0016, 0.0016, 0.0015,
	0.0016, 0.0016, 0.0019, 0.0017, 0.0019, 0.0018, 0.0018, 0.0018, 0.0018, 0.0019 };
	const double alpha_Ideal_sim[] =
	{ 0.0552, 0.0558, 0.0583, 0.0550, 0.0495, 0.0433, 0.0393, 0.0346, 0.0331, 0.0296,
	0.0258, 0.0196, 0.0171, 0.0179, 0.0174, 0.0141, 0.0114, 0.0096, 0.0076, 0.0087,
	0.0099, 0.0079, 0.0102, 0.0114, 0.0124, 0.0130, 0.0165, 0.0160, 0.0177, 0.0190,
	0.0232, 0.0243, 0.0238, 0.0248, 0.0235, 0.0298, 0.0292, 0.0291, 0.0268, 0.0316 };
	for (size_t i = 0; i < 40; ++i) {
	const double yval = _tmphistAlpha->bin(i).area() * (alpha_CDF_sim[i]/alpha_Ideal_sim[i]);
	const double yerr = _tmphistAlpha->bin(i).areaErr() * (alpha_CDF_sim_err[i]/alpha_Ideal_sim[i]);
	_histAlpha->addPoint(_tmphistAlpha->bin(i).xMid(), yval/_sumw,
	_tmphistAlpha->bin(i).xWidth()/2.0, yerr/_sumw);
	}
	}

	//@}


	private:

	/// @name Event weight counters
	//@{

	double _sumw;

	//@}


	/// @name Histograms
	//@{

	/// Straightforward output histos
	Histo1DPtr _histJet1Et, _histJet2Et;

	/// Output histos which need to have correction factors applied
	Scatter2DPtr _histR23, _histJet3eta, _histAlpha;

	/// Temporary histos, to be converted to DPSes
	Histo1DPtr _tmphistR23, _tmphistJet3eta, _tmphistAlpha;

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_1994_S2952106);

	}
	diff --git a/src/Analyses/CDF_1996_S3108457.cc b/src/Analyses/CDF_1996_S3108457.cc
	--- a/src/Analyses/CDF_1996_S3108457.cc
	+++ b/src/Analyses/CDF_1996_S3108457.cc
	@@ -1,126 +1,123 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/SmearedJets.hh"

	namespace Rivet {


	/// @brief CDF properties of high-mass multi-jet events
	class CDF_1996_S3108457 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CDF_1996_S3108457()
	: Analysis("CDF_1996_S3108457")
	{ }

	//@}


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections here
	const FinalState fs(-4.2, 4.2);
	- addProjection(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	+
	+ FastJets fj(fs, FastJets::CDFJETCLU, 0.7);
	+ declare(fj, "Jets");
	+
	+ // Smear Energy and mass with the 10% uncertainty quoted in the paper
	+ SmearedJets sj_E(fj, [](const Jet& jet){ return P4_SMEAR_MASS_GAUSS(P4_SMEAR_E_GAUSS(jet, 0.1jet.E()), 0.1jet.mass()); });
	+ declare(sj_E, "SmearedJets_E");


	/// Book histograms here, e.g.:
	for (size_t i=0; i<5; ++i) {
	_h_m[i] = bookHisto1D(1+i, 1, 1);
	_h_costheta[i] = bookHisto1D(10+i, 1, 1);
	_h_pT[i] = bookHisto1D(15+i, 1, 1);
	}
	/// @todo Ratios of mass histograms left out: Binning doesn't work out
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- /// Do the event by event analysis here
	- Jets jets;
	- double sumEt = 0.0;
	- FourMomentum jetsystem(0.0, 0.0, 0.0, 0.0);
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "Jets").jets(cmpMomByEt)) {
	- double Et = jet.Et();
	- if (Et > 20.0*GeV) {
	- jets.push_back(jet);
	- sumEt += Et;
	- jetsystem += jet.momentum();
	- }
	- }
	- /// @todo include gaussian jet energy resolution smearing?
	+ // Get the smeared jets
	+ Jets SJets = apply<JetAlg>(event, "SmearedJets_E").jets(Cuts::Et > 20.0*GeV, cmpMomByEt);
	+ if (SJets.size() < 2 \|\| SJets.size() > 6) vetoEvent;

	- if (jets.size() < 2 \|\| jets.size() > 6) {
	- vetoEvent;
	+ // Calculate Et, total jet 4 Momentum
	+ double sumEt(0), sumE(0);
	+ FourMomentum JS(0,0,0,0);
	+
	+ foreach(const Jet& jet, SJets) {
	+ sumEt += jet.Et()*GeV;
	+ sumE += jet.E()*GeV;
	+ JS+=jet.momentum();
	}

	- if (sumEt < 420.0*GeV) {
	- vetoEvent;
	- }
	+ if (sumEt < 420GeV \|\| sumE > 2000GeV) vetoEvent;

	- LorentzTransform cms_boost(-jetsystem.boostVector());
	- FourMomentum jet0boosted(cms_boost.transform(jets[0].momentum()));
	+ double mass = JS.mass();

	- double mass = jetsystem.mass();
	+ LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(JS.betaVec());
	+ FourMomentum jet0boosted(cms_boost.transform(SJets[0].momentum()));
	double costheta0 = fabs(cos(jet0boosted.theta()));

	if (costheta0 < 2.0/3.0) {
	- _h_m[jets.size()-2]->fill(mass, weight);
	+ _h_m[SJets.size()-2]->fill(mass, weight);
	}
	-
	- if (mass > 600.0*GeV) {
	- _h_costheta[jets.size()-2]->fill(costheta0, weight);
	- }
	-
	+ if (mass > 600.0*GeV) _h_costheta[JS.size()-2]->fill(costheta0, weight);
	if (costheta0 < 2.0/3.0 && mass > 600.0*GeV) {
	- foreach (const Jet jet, jets) {
	- _h_pT[jets.size()-2]->fill(jet.pT(), weight);
	+ foreach (const Jet& jet, SJets) {
	+ _h_pT[SJets.size()-2]->fill(jet.pT(), weight);
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	/// Normalise, scale and otherwise manipulate histograms here
	for (size_t i=0; i<5; ++i) {
	normalize(_h_m[i], 40.0);
	normalize(_h_costheta[i], 2.0);
	normalize(_h_pT[i], 20.0);
	}

	}

	//@}


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_m[5];
	Histo1DPtr _h_costheta[5];
	Histo1DPtr _h_pT[5];

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_1996_S3108457);

	}
	diff --git a/src/Analyses/CDF_1996_S3349578.cc b/src/Analyses/CDF_1996_S3349578.cc
	--- a/src/Analyses/CDF_1996_S3349578.cc
	+++ b/src/Analyses/CDF_1996_S3349578.cc
	@@ -1,468 +1,456 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/SmearedJets.hh"

	namespace Rivet {


	/// @brief CDF properties of high-mass multi-jet events
	class CDF_1996_S3349578 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CDF_1996_S3349578()
	: Analysis("CDF_1996_S3349578")
	{
	}

	//@}


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections here
	const FinalState fs(-4.2, 4.2);
	- addProjection(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ FastJets fj(fs, FastJets::CDFJETCLU, 0.7);
	+ declare(fj, "Jets");
	+
	+ // Smear Energy and mass with the 10% uncertainty quoted in the paper
	+ SmearedJets sj_E(fj, [](const Jet& jet){ return P4_SMEAR_MASS_GAUSS(P4_SMEAR_E_GAUSS(jet, 0.1jet.E()), 0.1jet.mass()); });
	+ declare(sj_E, "SmearedJets");

	/// Book histograms here, e.g.:
	_h_3_mNJ = bookHisto1D(1, 1, 1);
	_h_3_X3 = bookHisto1D(2, 1, 1);
	_h_3_X4 = bookHisto1D(3, 1, 1);
	_h_3_costheta3 = bookHisto1D(8, 1, 1);
	_h_3_psi3 = bookHisto1D(9, 1, 1);
	_h_3_f3 = bookHisto1D(14, 1, 1);
	_h_3_f4 = bookHisto1D(14, 1, 2);
	_h_3_f5 = bookHisto1D(14, 1, 3);

	_h_4_mNJ = bookHisto1D(1, 1, 2);
	_h_4_X3 = bookHisto1D(4, 1, 1);
	_h_4_X4 = bookHisto1D(5, 1, 1);
	_h_4_costheta3 = bookHisto1D(10, 1, 1);
	_h_4_psi3 = bookHisto1D(11, 1, 1);
	_h_4_f3 = bookHisto1D(15, 1, 1);
	_h_4_f4 = bookHisto1D(15, 1, 2);
	_h_4_f5 = bookHisto1D(15, 1, 3);
	_h_4_XA = bookHisto1D(17, 1, 1);
	_h_4_psiAB = bookHisto1D(19, 1, 1);
	_h_4_fA = bookHisto1D(21, 1, 1);
	_h_4_fB = bookHisto1D(21, 1, 2);

	_h_5_mNJ = bookHisto1D(1, 1, 3);
	_h_5_X3 = bookHisto1D(6, 1, 1);
	_h_5_X4 = bookHisto1D(7, 1, 1);
	_h_5_costheta3 = bookHisto1D(12, 1, 1);
	_h_5_psi3 = bookHisto1D(13, 1, 1);
	_h_5_f3 = bookHisto1D(16, 1, 1);
	_h_5_f4 = bookHisto1D(16, 1, 2);
	_h_5_f5 = bookHisto1D(16, 1, 3);
	_h_5_XA = bookHisto1D(18, 1, 1);
	_h_5_XC = bookHisto1D(18, 1, 2);
	_h_5_psiAB = bookHisto1D(20, 1, 1);
	_h_5_psiCD = bookHisto1D(20, 1, 2);
	_h_5_fA = bookHisto1D(22, 1, 1);
	_h_5_fB = bookHisto1D(23, 1, 1);
	_h_5_fC = bookHisto1D(24, 1, 1);
	_h_5_fD = bookHisto1D(25, 1, 1);

	}


	void analyze(const Event& event) {
	Jets jets;
	FourMomentum jetsystem(0.0, 0.0, 0.0, 0.0);
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "Jets").jets(cmpMomByEt)) {
	- double Et = jet.Et();
	- if (Et > 20.0*GeV) {
	- bool separated = true;
	- foreach (const Jet& ref, jets) {
	- if (deltaR(jet, ref) < 0.9) {
	- separated = false;
	- break;
	- }
	+ foreach (const Jet& jet, apply<JetAlg>(event, "SmearedJets").jets(Cuts::Et > 20.0*GeV, cmpMomByEt)) {
	+ bool separated = true;
	+ foreach (const Jet& ref, jets) {
	+ if (deltaR(jet, ref) < 0.9) {
	+ separated = false;
	+ break;
	}
	- if (!separated) continue;
	- jets.push_back(jet);
	- jetsystem += jet.momentum();
	}
	+ if (!separated) continue;
	+ jets.push_back(jet);
	+ jetsystem += jet.momentum();
	if (jets.size() >= 5) break;
	}
	- /// @todo include gaussian jet energy resolution smearing?

	const double weight = event.weight();
	if (jets.size() > 4) {
	_fiveJetAnalysis(jets, weight);
	jets.resize(4);
	}
	if (jets.size() > 3) {
	_fourJetAnalysis(jets, weight);
	jets.resize(3);
	}
	if (jets.size() > 2) {
	_threeJetAnalysis(jets, weight);
	}
	}


	void _threeJetAnalysis(const Jets& jets, const double& weight) {
	MSG_DEBUG("3 jet analysis");

	- double sumEt=0.0;
	+ double sumEt = 0.0;
	FourMomentum jetsystem(0.0, 0.0, 0.0, 0.0);
	foreach (const Jet& jet, jets) {
	- sumEt+=jet.Et();
	- jetsystem+=jet.momentum();
	+ sumEt += jet.Et();
	+ jetsystem += jet.momentum();
	}
	if (sumEt < 420.0*GeV) return;

	const double m3J = _safeMass(jetsystem);
	- if (m3J<600*GeV) {
	- return;
	- }
	+ if (m3J < 600*GeV) return;

	- LorentzTransform cms_boost(-jetsystem.boostVector());
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(jetsystem.betaVec());
	vector<FourMomentum> jets3;
	foreach (Jet jet, jets) {
	jets3.push_back(cms_boost.transform(jet.momentum()));
	}
	std::sort(jets3.begin(), jets3.end(), FourMomentum::byEDescending());
	- FourMomentum p3(jets3[0]);
	- FourMomentum p4(jets3[1]);
	- FourMomentum p5(jets3[2]);
	+ FourMomentum p3(jets3[0]), p4(jets3[1]), p5(jets3[2]);

	FourMomentum pAV = cms_boost.transform(_avg_beam_in_lab(m3J, jetsystem.rapidity()));
	- double costheta3=pAV.p3().unit().dot(p3.p3().unit());
	- if (fabs(costheta3)>0.6) {
	- return;
	- }
	+ double costheta3 = pAV.p3().unit().dot(p3.p3().unit());
	+ if (fabs(costheta3) > 0.6) return;

	double X3 = 2.0*p3.E()/m3J;
	- if (X3>0.9) {
	- return;
	- }
	+ if (X3 > 0.9) return;

	const double X4 = 2.0*p4.E()/m3J;
	const double psi3 = _psi(p3, pAV, p4, p5);
	const double f3 = _safeMass(p3)/m3J;
	const double f4 = _safeMass(p4)/m3J;
	const double f5 = _safeMass(p5)/m3J;

	_h_3_mNJ->fill(m3J, weight);
	_h_3_X3->fill(X3, weight);
	_h_3_X4->fill(X4, weight);
	_h_3_costheta3->fill(costheta3, weight);
	_h_3_psi3->fill(psi3, weight);
	_h_3_f3->fill(f3, weight);
	_h_3_f4->fill(f4, weight);
	_h_3_f5->fill(f5, weight);

	}




	void _fourJetAnalysis(const Jets& jets, const double& weight) {
	MSG_DEBUG("4 jet analysis");

	double sumEt=0.0;
	FourMomentum jetsystem(0.0, 0.0, 0.0, 0.0);
	foreach (const Jet& jet, jets) {
	sumEt+=jet.Et();
	jetsystem+=jet.momentum();
	}
	if (sumEt < 420.0*GeV) return;

	const double m4J = _safeMass(jetsystem);
	if (m4J < 650*GeV) return;

	- LorentzTransform cms_boost(-jetsystem.boostVector());
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(jetsystem.betaVec());
	vector<FourMomentum> jets4;
	foreach (Jet jet, jets) {
	jets4.push_back(cms_boost.transform(jet.momentum()));
	}
	std::sort(jets4.begin(), jets4.end(), FourMomentum::byEDescending());

	FourMomentum pA, pB;
	vector<FourMomentum> jets3(_reduce(jets4, pA, pB));
	std::sort(jets3.begin(), jets3.end(), FourMomentum::byEDescending());
	FourMomentum p3(jets3[0]);
	FourMomentum p4(jets3[1]);
	FourMomentum p5(jets3[2]);

	FourMomentum pAV = cms_boost.transform(_avg_beam_in_lab(m4J, jetsystem.rapidity()));
	double costheta3=pAV.p3().unit().dot(p3.p3().unit());
	if (fabs(costheta3)>0.8) {
	return;
	}

	const double X3 = 2.0*p3.E()/m4J;
	if (X3>0.9) {
	return;
	}

	// fill histograms
	const double X4 = 2.0*p4.E()/m4J;
	const double psi3 = _psi(p3, pAV, p4, p5);
	const double f3 = _safeMass(p3)/m4J;
	const double f4 = _safeMass(p4)/m4J;
	const double f5 = _safeMass(p5)/m4J;
	const double fA = _safeMass(pA)/m4J;
	const double fB = _safeMass(pB)/m4J;
	const double XA = pA.E()/(pA.E()+pB.E());
	const double psiAB = _psi(pA, pB, pA+pB, pAV);

	_h_4_mNJ->fill(m4J, weight);
	_h_4_X3->fill(X3, weight);
	_h_4_X4->fill(X4, weight);
	_h_4_costheta3->fill(costheta3, weight);
	_h_4_psi3->fill(psi3, weight);
	_h_4_f3->fill(f3, weight);
	_h_4_f4->fill(f4, weight);
	_h_4_f5->fill(f5, weight);
	_h_4_XA->fill(XA, weight);
	_h_4_psiAB->fill(psiAB, weight);
	_h_4_fA->fill(fA, weight);
	_h_4_fB->fill(fB, weight);
	}




	void _fiveJetAnalysis(const Jets& jets, const double& weight) {
	MSG_DEBUG("5 jet analysis");

	double sumEt=0.0;
	FourMomentum jetsystem(0.0, 0.0, 0.0, 0.0);
	foreach (const Jet& jet, jets) {
	sumEt+=jet.Et();
	jetsystem+=jet.momentum();
	}
	if (sumEt < 420.0*GeV) return;

	const double m5J = _safeMass(jetsystem);
	if (m5J < 750*GeV) return;

	- LorentzTransform cms_boost(-jetsystem.boostVector());
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(jetsystem.betaVec());
	vector<FourMomentum> jets5;
	foreach (Jet jet, jets) {
	jets5.push_back(cms_boost.transform(jet.momentum()));
	}
	std::sort(jets5.begin(), jets5.end(), FourMomentum::byEDescending());

	FourMomentum pC, pD;
	vector<FourMomentum> jets4(_reduce(jets5, pC, pD));
	std::sort(jets4.begin(), jets4.end(), FourMomentum::byEDescending());

	FourMomentum pA, pB;
	vector<FourMomentum> jets3(_reduce(jets4, pA, pB));
	std::sort(jets3.begin(), jets3.end(), FourMomentum::byEDescending());
	FourMomentum p3(jets3[0]);
	FourMomentum p4(jets3[1]);
	FourMomentum p5(jets3[2]);

	// fill histograms
	FourMomentum pAV = cms_boost.transform(_avg_beam_in_lab(m5J, jetsystem.rapidity()));
	const double costheta3 = pAV.p3().unit().dot(p3.p3().unit());
	const double X3 = 2.0*p3.E()/m5J;
	const double X4 = 2.0*p4.E()/m5J;
	const double psi3 = _psi(p3, pAV, p4, p5);
	const double f3 = _safeMass(p3)/m5J;
	const double f4 = _safeMass(p4)/m5J;
	const double f5 = _safeMass(p5)/m5J;
	const double fA = _safeMass(pA)/m5J;
	const double fB = _safeMass(pB)/m5J;
	const double XA = pA.E()/(pA.E()+pB.E());
	const double psiAB = _psi(pA, pB, pA+pB, pAV);
	const double fC = _safeMass(pC)/m5J;
	const double fD = _safeMass(pD)/m5J;
	const double XC = pC.E()/(pC.E()+pD.E());
	const double psiCD = _psi(pC, pD, pC+pD, pAV);

	_h_5_mNJ->fill(m5J, weight);
	_h_5_X3->fill(X3, weight);
	_h_5_X4->fill(X4, weight);
	_h_5_costheta3->fill(costheta3, weight);
	_h_5_psi3->fill(psi3, weight);
	_h_5_f3->fill(f3, weight);
	_h_5_f4->fill(f4, weight);
	_h_5_f5->fill(f5, weight);
	_h_5_XA->fill(XA, weight);
	_h_5_psiAB->fill(psiAB, weight);
	_h_5_fA->fill(fA, weight);
	_h_5_fB->fill(fB, weight);
	_h_5_XC->fill(XC, weight);
	_h_5_psiCD->fill(psiCD, weight);
	_h_5_fC->fill(fC, weight);
	_h_5_fD->fill(fD, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	/// Normalise, scale and otherwise manipulate histograms here
	normalize(_h_3_mNJ, 1.0);
	normalize(_h_3_X3, 1.0);
	normalize(_h_3_X4, 1.0);
	normalize(_h_3_costheta3, 1.0);
	normalize(_h_3_psi3, 1.0);
	normalize(_h_3_f3, 1.0);
	normalize(_h_3_f4, 1.0);
	normalize(_h_3_f5, 1.0);

	normalize(_h_4_mNJ, 1.0);
	normalize(_h_4_X3, 1.0);
	normalize(_h_4_X4, 1.0);
	normalize(_h_4_costheta3, 1.0);
	normalize(_h_4_psi3, 1.0);
	normalize(_h_4_f3, 1.0);
	normalize(_h_4_f4, 1.0);
	normalize(_h_4_f5, 1.0);
	normalize(_h_4_XA, 1.0);
	normalize(_h_4_psiAB, 1.0);
	normalize(_h_4_fA, 1.0);
	normalize(_h_4_fB, 1.0);

	normalize(_h_5_mNJ, 1.0);
	normalize(_h_5_X3, 1.0);
	normalize(_h_5_X4, 1.0);
	normalize(_h_5_costheta3, 1.0);
	normalize(_h_5_psi3, 1.0);
	normalize(_h_5_f3, 1.0);
	normalize(_h_5_f4, 1.0);
	normalize(_h_5_f5, 1.0);
	normalize(_h_5_XA, 1.0);
	normalize(_h_5_XC, 1.0);
	normalize(_h_5_psiAB, 1.0);
	normalize(_h_5_psiCD, 1.0);
	normalize(_h_5_fA, 1.0);
	normalize(_h_5_fB, 1.0);
	normalize(_h_5_fC, 1.0);
	normalize(_h_5_fD, 1.0);

	}

	//@}


	private:
	vector<FourMomentum> _reduce(const vector<FourMomentum>& jets,
	FourMomentum& combined1,
	FourMomentum& combined2) {
	double minMass2 = 1e9;
	size_t idx1(jets.size()), idx2(jets.size());
	for (size_t i=0; i<jets.size(); ++i) {
	for (size_t j=i+1; j<jets.size(); ++j) {
	double mass2 = FourMomentum(jets[i]+jets[j]).mass2();
	if (mass2<minMass2) {
	idx1=i;
	idx2=j;
	}
	}
	}
	vector<FourMomentum> newjets;
	for (size_t i=0; i<jets.size(); ++i) {
	if (i!=idx1 && i!=idx2) newjets.push_back(jets[i]);
	}
	newjets.push_back(jets[idx1]+jets[idx2]);
	combined1 = jets[idx1];
	combined2 = jets[idx2];
	return newjets;
	}

	FourMomentum _avg_beam_in_lab(const double& m, const double& y) {
	const double mt = m/2.0;
	FourMomentum beam1(mt, 0, 0, mt);
	FourMomentum beam2(mt, 0, 0, -mt);
	if (fabs(y)>1e-3) {
	FourMomentum boostvec(cosh(y), 0.0, 0.0, sinh(y));
	- LorentzTransform cms_boost(-boostvec.boostVector());
	- cms_boost = cms_boost.inverse();
	- beam1=cms_boost.transform(beam1);
	- beam2=cms_boost.transform(beam2);
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(boostvec.betaVec()).inverse();
	+ beam1 = cms_boost.transform(beam1);
	+ beam2 = cms_boost.transform(beam2);
	}
	- if (beam1.E()>beam2.E()) {
	- return beam1-beam2;
	- }
	- else {
	- return beam2-beam1;
	- }
	+ return (beam1.E() > beam2.E()) ? beam1-beam2 : beam2-beam1;
	}

	double _psi(const FourMomentum& p1, const FourMomentum& p2,
	const FourMomentum& p3, const FourMomentum& p4) {
	Vector3 p1xp2 = p1.p3().cross(p2.p3());
	Vector3 p3xp4 = p3.p3().cross(p4.p3());
	return mapAngle0ToPi(acos(p1xp2.unit().dot(p3xp4.unit())));
	}

	double _safeMass(const FourMomentum& p) {
	double mass2=p.mass2();
	if (mass2>0.0) return sqrt(mass2);
	else if (mass2<-1.0e-5) {
	MSG_WARNING("m2 = " << m2 << ". Assuming m2=0.");
	return 0.0;
	}
	else return 0.0;
	}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_3_mNJ;
	Histo1DPtr _h_3_X3;
	Histo1DPtr _h_3_X4;
	Histo1DPtr _h_3_costheta3;
	Histo1DPtr _h_3_psi3;
	Histo1DPtr _h_3_f3;
	Histo1DPtr _h_3_f4;
	Histo1DPtr _h_3_f5;

	Histo1DPtr _h_4_mNJ;
	Histo1DPtr _h_4_X3;
	Histo1DPtr _h_4_X4;
	Histo1DPtr _h_4_costheta3;
	Histo1DPtr _h_4_psi3;
	Histo1DPtr _h_4_f3;
	Histo1DPtr _h_4_f4;
	Histo1DPtr _h_4_f5;
	Histo1DPtr _h_4_XA;
	Histo1DPtr _h_4_psiAB;
	Histo1DPtr _h_4_fA;
	Histo1DPtr _h_4_fB;

	Histo1DPtr _h_5_mNJ;
	Histo1DPtr _h_5_X3;
	Histo1DPtr _h_5_X4;
	Histo1DPtr _h_5_costheta3;
	Histo1DPtr _h_5_psi3;
	Histo1DPtr _h_5_f3;
	Histo1DPtr _h_5_f4;
	Histo1DPtr _h_5_f5;
	Histo1DPtr _h_5_XA;
	Histo1DPtr _h_5_XC;
	Histo1DPtr _h_5_psiAB;
	Histo1DPtr _h_5_psiCD;
	Histo1DPtr _h_5_fA;
	Histo1DPtr _h_5_fB;
	Histo1DPtr _h_5_fC;
	Histo1DPtr _h_5_fD;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_1996_S3349578);

	}
	diff --git a/src/Analyses/CDF_1996_S3418421.cc b/src/Analyses/CDF_1996_S3418421.cc
	--- a/src/Analyses/CDF_1996_S3418421.cc
	+++ b/src/Analyses/CDF_1996_S3418421.cc
	@@ -1,95 +1,95 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF dijet angular distributions
	class CDF_1996_S3418421 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CDF_1996_S3418421()
	: Analysis("CDF_1996_S3418421")
	{
	}

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs(-4.2, 4.2);
	- addProjection(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ declare(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");

	_h_chi.addHistogram(241.0, 300.0, bookHisto1D(1, 1, 1));
	_h_chi.addHistogram(300.0, 400.0, bookHisto1D(1, 1, 2));
	_h_chi.addHistogram(400.0, 517.0, bookHisto1D(1, 1, 3));
	_h_chi.addHistogram(517.0, 625.0, bookHisto1D(1, 1, 4));
	_h_chi.addHistogram(625.0, 1800.0, bookHisto1D(1, 1, 5));
	_h_ratio = bookScatter2D(2, 1, 1);
	_htmp_chi_above_25 = bookHisto1D("TMP/chiabove25", refData(2, 1, 1));
	_htmp_chi_below_25 = bookHisto1D("TMP/chibelow25", refData(2, 1, 1));
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- Jets jets = applyProjection<FastJets>(event, "Jets").jetsByPt(50.0*GeV);
	+ Jets jets = apply<FastJets>(event, "Jets").jetsByPt(50.0*GeV);
	if (jets.size() < 2) vetoEvent;

	const FourMomentum jet1 = jets[0].momentum();
	const FourMomentum jet2 = jets[1].momentum();
	const double eta1 = jet1.eta();
	const double eta2 = jet2.eta();
	const double chi = exp(fabs(eta1 - eta2));
	if (fabs(eta2) > 2.0 \|\| fabs(eta1) > 2.0 \|\| chi > 5.0) vetoEvent;

	double m = FourMomentum(jet1 + jet2).mass();
	_h_chi.fill(m, chi, weight);

	// Fill ratio numerator or denominator depending on chi value
	((chi > 2.5) ? _htmp_chi_above_25 : _htmp_chi_below_25)->fill(m/GeV, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	foreach (Histo1DPtr hist, _h_chi.getHistograms()) {
	normalize(hist);
	}
	divide(_htmp_chi_below_25, _htmp_chi_above_25, _h_ratio);
	}

	//@}

	private:

	/// @name Histograms
	//@{
	BinnedHistogram<double> _h_chi;
	Histo1DPtr _htmp_chi_above_25, _htmp_chi_below_25;
	Scatter2DPtr _h_ratio;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_1996_S3418421);

	}
	diff --git a/src/Analyses/CDF_1997_S3541940.cc b/src/Analyses/CDF_1997_S3541940.cc
	--- a/src/Analyses/CDF_1997_S3541940.cc
	+++ b/src/Analyses/CDF_1997_S3541940.cc
	@@ -1,252 +1,245 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/SmearedJets.hh"

	namespace Rivet {


	/// @brief CDF properties of 6-jet events with large 6-jet mass
	class CDF_1997_S3541940 : public Analysis {
	public:

	CDF_1997_S3541940()
	: Analysis("CDF_1997_S3541940")
	{
	}


	public:

	void init() {

	const FinalState fs(-4.2, 4.2);
	- addProjection(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ FastJets fj (fs, FastJets::CDFJETCLU, 0.7);
	+ declare(fj, "Jets");
	+
	+ // Smear Energy and mass with the 10% uncertainty quoted in the paper
	+ SmearedJets sj_E(fj, [](const Jet& jet){ return P4_SMEAR_MASS_GAUSS(P4_SMEAR_E_GAUSS(jet, 0.1jet.E()), 0.1jet.mass()); });
	+ declare(sj_E, "SmearedJets");

	_h_m6J = bookHisto1D(1, 1, 1);
	_h_X3ppp = bookHisto1D(2, 1, 1);
	_h_X4ppp = bookHisto1D(3, 1, 1);
	_h_costheta3ppp = bookHisto1D(4, 1, 1);
	_h_psi3ppp = bookHisto1D(5, 1, 1);
	_h_f3ppp = bookHisto1D(6, 1, 1);
	_h_f4ppp = bookHisto1D(6, 1, 2);
	_h_f5ppp = bookHisto1D(6, 1, 3);
	_h_XApp = bookHisto1D(7, 1, 1);
	_h_XCp = bookHisto1D(8, 1, 1);
	_h_XE = bookHisto1D(9, 1, 1);
	_h_psiAppBpp = bookHisto1D(10, 1, 1);
	_h_psiCpDp = bookHisto1D(11, 1, 1);
	_h_psiEF = bookHisto1D(12, 1, 1);
	_h_fApp = bookHisto1D(13, 1, 1);
	_h_fBpp = bookHisto1D(14, 1, 1);
	_h_fCp = bookHisto1D(15, 1, 1);
	_h_fDp = bookHisto1D(16, 1, 1);
	_h_fE = bookHisto1D(17, 1, 1);
	_h_fF = bookHisto1D(18, 1, 1);
	}


	void analyze(const Event& event) {
	- const double weight = event.weight();
	-
	Jets jets;
	double sumEt = 0.0;
	FourMomentum jetsystem(0.0, 0.0, 0.0, 0.0);
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "Jets").jets(cmpMomByEt)) {
	+ foreach (const Jet& jet, apply<JetAlg>(event, "SmearedJets").jets(Cuts::Et>20*GeV && Cuts::abseta<3,cmpMomByEt)) {
	double Et = jet.Et();
	- double eta = jet.abseta();
	- if (Et > 20.0*GeV && eta < 3.0) {
	- bool separated = true;
	- foreach (const Jet& ref, jets) {
	- if (deltaR(jet.momentum(), ref.momentum()) < 0.9) {
	- separated = false;
	- break;
	- }
	+ bool separated = true;
	+ foreach (const Jet& ref, jets) {
	+ if (deltaR(jet, ref) < 0.9) {
	+ separated = false;
	+ break;
	}
	- if (!separated) continue;
	- jets.push_back(jet);
	- sumEt += Et;
	- jetsystem += jet.momentum();
	}
	+ if (!separated) continue;
	+ jets.push_back(jet);
	+ sumEt += Et;
	+ jetsystem += jet.momentum();
	if (jets.size() >= 6) break;
	}

	if (jets.size() < 6) vetoEvent;
	if (sumEt < 320.0*GeV) vetoEvent;

	double m6J = _safeMass(jetsystem);
	if (m6J < 520.0*GeV) vetoEvent;

	- LorentzTransform cms_boost(-jetsystem.boostVector());
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(jetsystem.betaVec());
	vector<FourMomentum> jets6;
	foreach (Jet jet, jets) {
	jets6.push_back(cms_boost.transform(jet.momentum()));
	}
	std::sort(jets6.begin(), jets6.end(), FourMomentum::byEDescending());

	FourMomentum pE, pF;
	vector<FourMomentum> jets5(_reduce(jets6, pE, pF));
	std::sort(jets5.begin(), jets5.end(), FourMomentum::byEDescending());

	FourMomentum pCp, pDp;
	vector<FourMomentum> jets4(_reduce(jets5, pCp, pDp));
	std::sort(jets4.begin(), jets4.end(), FourMomentum::byEDescending());

	FourMomentum pApp, pBpp;
	vector<FourMomentum> jets3(_reduce(jets4, pApp, pBpp));
	std::sort(jets3.begin(), jets3.end(), FourMomentum::byEDescending());
	FourMomentum p3ppp(jets3[0]);
	FourMomentum p4ppp(jets3[1]);
	FourMomentum p5ppp(jets3[2]);

	double X3ppp = 2.0*p3ppp.E()/m6J;
	- if (X3ppp > 0.9) {
	- vetoEvent;
	- }
	+ if (X3ppp > 0.9) vetoEvent;

	FourMomentum pAV = cms_boost.transform(_avg_beam_in_lab(m6J, jetsystem.rapidity()));
	double costheta3ppp = pAV.p3().unit().dot(p3ppp.p3().unit());
	- if (fabs(costheta3ppp) > 0.9) {
	- vetoEvent;
	- }
	+ if (fabs(costheta3ppp) > 0.9) vetoEvent;
	+
	+ const double weight = event.weight();

	// 3-jet-system variables
	_h_m6J->fill(m6J, weight);
	_h_X3ppp->fill(X3ppp, weight);
	_h_X4ppp->fill(2.0*p4ppp.E()/m6J, weight);
	_h_costheta3ppp->fill(costheta3ppp, weight);
	double psi3ppp = _psi(p3ppp, pAV, p4ppp, p5ppp);
	_h_psi3ppp->fill(psi3ppp, weight);
	_h_f3ppp->fill(_safeMass(p3ppp)/m6J, weight);
	_h_f4ppp->fill(_safeMass(p4ppp)/m6J, weight);
	_h_f5ppp->fill(_safeMass(p5ppp)/m6J, weight);

	// 4 -> 3 jet variables
	_h_fApp->fill(_safeMass(pApp)/m6J, weight);
	_h_fBpp->fill(_safeMass(pApp)/m6J, weight);
	_h_XApp->fill(pApp.E()/(pApp.E()+pBpp.E()), weight);
	double psiAppBpp = _psi(pApp, pBpp, pApp+pBpp, pAV);
	_h_psiAppBpp->fill(psiAppBpp, weight);

	// 5 -> 4 jet variables
	_h_fCp->fill(_safeMass(pCp)/m6J, weight);
	_h_fDp->fill(_safeMass(pDp)/m6J, weight);
	_h_XCp->fill(pCp.E()/(pCp.E()+pDp.E()), weight);
	double psiCpDp = _psi(pCp, pDp, pCp+pDp, pAV);
	_h_psiCpDp->fill(psiCpDp, weight);

	// 6 -> 5 jet variables
	_h_fE->fill(_safeMass(pE)/m6J, weight);
	_h_fF->fill(_safeMass(pF)/m6J, weight);
	_h_XE->fill(pE.E()/(pE.E()+pF.E()), weight);
	double psiEF = _psi(pE, pF, pE+pF, pAV);
	_h_psiEF->fill(psiEF, weight);
	}


	void finalize() {
	normalize(_h_m6J);
	normalize(_h_X3ppp);
	normalize(_h_X4ppp);
	normalize(_h_costheta3ppp);
	normalize(_h_psi3ppp);
	normalize(_h_f3ppp);
	normalize(_h_f4ppp);
	normalize(_h_f5ppp);
	normalize(_h_XApp);
	normalize(_h_XCp);
	normalize(_h_XE);
	normalize(_h_psiAppBpp);
	normalize(_h_psiCpDp);
	normalize(_h_psiEF);
	normalize(_h_fApp);
	normalize(_h_fBpp);
	normalize(_h_fCp);
	normalize(_h_fDp);
	normalize(_h_fE);
	normalize(_h_fF);
	}


	private:

	vector<FourMomentum> _reduce(const vector<FourMomentum>& jets,
	FourMomentum& combined1,
	FourMomentum& combined2) {
	double minMass2 = 1e9;
	size_t idx1(jets.size()), idx2(jets.size());
	for (size_t i = 0; i < jets.size(); ++i) {
	for (size_t j = i+1; j < jets.size(); ++j) {
	double mass2 = FourMomentum(jets[i] + jets[j]).mass2();
	if (mass2 < minMass2) {
	idx1 = i;
	idx2 = j;
	}
	}
	}
	vector<FourMomentum> newjets;
	for (size_t i = 0; i < jets.size(); ++i) {
	if (i != idx1 && i != idx2) newjets.push_back(jets[i]);
	}
	newjets.push_back(jets[idx1] + jets[idx2]);
	combined1 = jets[idx1];
	combined2 = jets[idx2];
	return newjets;
	}


	FourMomentum _avg_beam_in_lab(const double& m, const double& y) {
	const double mt = m/2.0;
	FourMomentum beam1(mt, 0, 0, mt);
	FourMomentum beam2(mt, 0, 0, -mt);
	if (fabs(y) > 1e-3) {
	FourMomentum boostvec(cosh(y), 0.0, 0.0, sinh(y));
	- LorentzTransform cms_boost(-boostvec.boostVector());
	- cms_boost = cms_boost.inverse();
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(boostvec.betaVec()).inverse();
	beam1 = cms_boost.transform(beam1);
	beam2 = cms_boost.transform(beam2);
	}
	- if (beam1.E() > beam2.E()) {
	- return beam1 - beam2;
	- }
	- else {
	- return beam2 - beam1;
	- }
	+ return (beam1.E() > beam2.E()) ? beam1 - beam2 : beam2 - beam1;
	}


	double _psi(const FourMomentum& p1, const FourMomentum& p2,
	const FourMomentum& p3, const FourMomentum& p4) {
	Vector3 p1xp2 = p1.p3().cross(p2.p3());
	Vector3 p3xp4 = p3.p3().cross(p4.p3());
	return mapAngle0ToPi(acos(p1xp2.unit().dot(p3xp4.unit())));
	}


	double _safeMass(const FourMomentum& p) {
	double mass2 = p.mass2();
	if (mass2 > 0.0) return sqrt(mass2);
	if (mass2 < -1e-5) MSG_WARNING("m2 = " << m2 << ". Assuming m2=0.");
	return 0.0;
	}


	private:

	Histo1DPtr _h_m6J;
	Histo1DPtr _h_X3ppp, _h_X4ppp;
	Histo1DPtr _h_costheta3ppp;
	Histo1DPtr _h_psi3ppp;
	Histo1DPtr _h_f3ppp, _h_f4ppp, _h_f5ppp;
	Histo1DPtr _h_XApp, _h_XCp, _h_XE;
	Histo1DPtr _h_psiAppBpp, _h_psiCpDp, _h_psiEF;
	Histo1DPtr _h_fApp, _h_fBpp, _h_fCp, _h_fDp, _h_fE, _h_fF;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_1997_S3541940);

	}
	diff --git a/src/Analyses/CDF_1998_S3618439.cc b/src/Analyses/CDF_1998_S3618439.cc
	--- a/src/Analyses/CDF_1998_S3618439.cc
	+++ b/src/Analyses/CDF_1998_S3618439.cc
	@@ -1,78 +1,78 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF diff cross-section in events with large missing energy
	class CDF_1998_S3618439 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CDF_1998_S3618439()
	: Analysis("CDF_1998_S3618439")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs(-4.2, 4.2);
	- addProjection(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ declare(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");

	_h_sumET_20 = bookHisto1D(1, 1, 1);
	_h_sumET_100 = bookHisto1D(1, 1, 2);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- Jets jets = applyProjection<FastJets>(event, "Jets").jets(Cuts::Et > 20*GeV, cmpMomByEt);
	+ Jets jets = apply<FastJets>(event, "Jets").jets(Cuts::Et > 20*GeV, cmpMomByEt);
	double sumET_20(0.0), sumET_100(0.0);
	foreach (const Jet& jet, jets) {
	double ET = jet.Et()/GeV;
	sumET_20 += ET;
	if (ET > 100.0) sumET_100 += ET;
	}
	if (sumET_20 > 320.0) _h_sumET_20->fill(sumET_20, weight);
	if (sumET_100 > 320.0) _h_sumET_100->fill(sumET_100, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_sumET_20, crossSection()/picobarn/sumOfWeights());
	scale(_h_sumET_100, crossSection()/picobarn/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_sumET_20, _h_sumET_100;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_1998_S3618439);

	}
	diff --git a/src/Analyses/CDF_2000_S4155203.cc b/src/Analyses/CDF_2000_S4155203.cc
	--- a/src/Analyses/CDF_2000_S4155203.cc
	+++ b/src/Analyses/CDF_2000_S4155203.cc
	@@ -1,71 +1,71 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	/// @brief CDF Run I Z \f$ p_\perp \f$ in Drell-Yan events
	/// @author Hendrik Hoeth
	class CDF_2000_S4155203 : public Analysis {
	public:

	/// Constructor
	CDF_2000_S4155203()
	: Analysis("CDF_2000_S4155203")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	ZFinder zfinder(FinalState(), Cuts::open(), PID::ELECTRON,
	66GeV, 116GeV, 0.0, ZFinder::NOCLUSTER);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	// Book histogram
	_hist_zpt = bookHisto1D(1, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& e) {
	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	if (zfinder.bosons().size() != 1) {
	MSG_DEBUG("Num e+ e- pairs found = " << zfinder.bosons().size());
	vetoEvent;
	}

	FourMomentum pZ = zfinder.bosons()[0].momentum();
	if (pZ.mass2() < 0) {
	MSG_DEBUG("Negative Z mass**2 = " << pZ.mass2()/GeV2 << "!");
	vetoEvent;
	}

	MSG_DEBUG("Dilepton mass = " << pZ.mass()/GeV << " GeV");
	MSG_DEBUG("Dilepton pT = " << pZ.pT()/GeV << " GeV");
	_hist_zpt->fill(pZ.pT()/GeV, e.weight());
	}


	void finalize() {
	scale(_hist_zpt, crossSection()/picobarn/sumOfWeights());
	}

	//@}


	private:

	Histo1DPtr _hist_zpt;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2000_S4155203);

	}
	diff --git a/src/Analyses/CDF_2000_S4266730.cc b/src/Analyses/CDF_2000_S4266730.cc
	--- a/src/Analyses/CDF_2000_S4266730.cc
	+++ b/src/Analyses/CDF_2000_S4266730.cc
	@@ -1,74 +1,74 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF dijet cross-section, differential in dijet mass
	class CDF_2000_S4266730 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CDF_2000_S4266730()
	: Analysis("CDF_2000_S4266730")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs(-4.2, 4.2);
	- addProjection(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ declare(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	_h_mjj = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	- Jets jets = applyProjection<FastJets>(event, "Jets").jets(cmpMomByEt);
	+ Jets jets = apply<FastJets>(event, "Jets").jets(cmpMomByEt);
	if (jets.size() < 2) vetoEvent;
	FourMomentum jet1 = jets[0].momentum();
	FourMomentum jet2 = jets[1].momentum();
	double eta1 = jet1.eta();
	double eta2 = jet2.eta();
	if (fabs(eta1) > 2.0 \|\| fabs(eta2) > 2.0) vetoEvent;
	if (fabs(tanh((eta1-eta2)/2)) > 2.0/3.0) vetoEvent;
	double mjj = FourMomentum(jet1+jet2).mass()/GeV;
	if (mjj < 180) vetoEvent;
	_h_mjj->fill(mjj, event.weight());
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_mjj, crossSection()/picobarn/sumOfWeights());
	}

	//@}


	private:

	/// Histogram
	Histo1DPtr _h_mjj;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2000_S4266730);


	}
	diff --git a/src/Analyses/CDF_2001_S4517016.cc b/src/Analyses/CDF_2001_S4517016.cc
	--- a/src/Analyses/CDF_2001_S4517016.cc
	+++ b/src/Analyses/CDF_2001_S4517016.cc
	@@ -1,84 +1,84 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF two-jet triply-differential cross-section
	class CDF_2001_S4517016 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CDF_2001_S4517016()
	: Analysis("CDF_2001_S4517016")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs(-4.2, 4.2);
	- addProjection(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ declare(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");

	_h_ET.addHistogram(0.1, 0.7, bookHisto1D(1, 1, 1));
	_h_ET.addHistogram(0.7, 1.4, bookHisto1D(2, 1, 1));
	_h_ET.addHistogram(1.4, 2.1, bookHisto1D(3, 1, 1));
	_h_ET.addHistogram(2.1, 3.0, bookHisto1D(4, 1, 1));
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- Jets jets = applyProjection<FastJets>(event, "Jets").jets(Cuts::Et > 10*GeV, cmpMomByEt);
	+ Jets jets = apply<FastJets>(event, "Jets").jets(Cuts::Et > 10*GeV, cmpMomByEt);
	if (jets.size() < 2) vetoEvent;
	FourMomentum jet1 = jets[0].momentum();
	FourMomentum jet2 = jets[1].momentum();
	double eta1 = jet1.abseta();
	double eta2 = jet2.abseta();
	double ET1 = jet1.Et();
	double ET2 = jet2.Et();
	if (!inRange(eta1, 0.1, 0.7) \|\| ET1 < 40.0*GeV) vetoEvent;
	if (!inRange(eta2, 0.1, 3.0)) vetoEvent;
	_h_ET.fill(eta2, ET1, weight);
	if (eta2<0.7 && ET2>40.0*GeV) _h_ET.fill(eta1, ET2, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double deta1 = 1.2;
	_h_ET.scale(crossSection()/nanobarn/sumOfWeights()/deta1 / 2.0, this);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	BinnedHistogram<double> _h_ET;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2001_S4517016);

	}
	diff --git a/src/Analyses/CDF_2001_S4563131.cc b/src/Analyses/CDF_2001_S4563131.cc
	--- a/src/Analyses/CDF_2001_S4563131.cc
	+++ b/src/Analyses/CDF_2001_S4563131.cc
	@@ -1,71 +1,71 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF Run I inclusive jet cross-section
	class CDF_2001_S4563131 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CDF_2001_S4563131()
	: Analysis("CDF_2001_S4563131")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs(-4.2, 4.2);
	- addProjection(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ declare(FastJets(fs, FastJets::CDFJETCLU, 0.7), "Jets");
	_h_ET = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	- Jets jets = applyProjection<FastJets>(event, "Jets").jets(Cuts::Et > 40*GeV, cmpMomByEt);
	+ Jets jets = apply<FastJets>(event, "Jets").jets(Cuts::Et > 40*GeV && Cuts::abseta >= 0.1 && Cuts::abseta <= 0.7, cmpMomByEt);
	foreach (const Jet& jet, jets) {
	- if (inRange(jet.abseta(), 0.1, 0.7))
	+ //if (inRange(jet.abseta(), 0.1, 0.7))
	_h_ET->fill(jet.Et(), weight);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double deta = 1.2;
	scale(_h_ET, crossSection()/sumOfWeights()/deta/nanobarn);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_ET;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2001_S4563131);

	}
	diff --git a/src/Analyses/CDF_2001_S4751469.cc b/src/Analyses/CDF_2001_S4751469.cc
	--- a/src/Analyses/CDF_2001_S4751469.cc
	+++ b/src/Analyses/CDF_2001_S4751469.cc
	@@ -1,279 +1,260 @@
	// -- C++ --
	-
	-// Field & Stuart underlying event analysis at CDF.
	-// Phys.Rev.D65:092002,2002 - no arXiv code.
	-// FNAL-PUB 01/211-E
	-
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	-#include "Rivet/Projections/ConstLossyFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/TriggerCDFRun0Run1.hh"
	+#include "Rivet/Projections/ConstLossyFinalState.hh"
	+//#include "Rivet/Projections/SmearedParticles.hh"

	namespace Rivet {


	- /// @brief "Field-Stuart" CDF Run I track-jet underlying event analysis
	+ /// @brief Field-Stuart CDF Run I track-jet underlying event analysis
	///
	/// @author Andy Buckley
	///
	/// The "original" underlying event analysis, using a non-standard track-jet algorithm.
	///
	/// @par Run conditions
	///
	/// @arg \f$ \sqrt{s} = \f$ 1800 GeV
	/// @arg Run with generic QCD events.
	/// @arg Several \f$ p_\perp^\text{min} \f$ cutoffs are probably required to fill the profile histograms:
	/// @arg \f$ p_\perp^\text{min} = \f$ 0 (min bias), 10, 20 GeV
	class CDF_2001_S4751469 : public Analysis {
	public:

	/// Constructor: cuts on final state are \f$ -1 < \eta < 1 \f$
	/// and \f$ p_T > 0.5 \f$ GeV.
	CDF_2001_S4751469()
	: Analysis("CDF_2001_S4751469"),
	_totalNumTrans2(0), _totalNumTrans5(0), _totalNumTrans30(0),
	_sumWeightsPtLead2(0),_sumWeightsPtLead5(0), _sumWeightsPtLead30(0)
	- {
	- }
	+ { }


	/// @name Analysis methods
	//@{

	// Book histograms
	void init() {
	- addProjection(TriggerCDFRun0Run1(), "Trigger");
	+ declare(TriggerCDFRun0Run1(), "Trigger");
	// Randomly discard 8% of charged particles as a kind of hacky detector correction.
	const ChargedFinalState cfs(-1.0, 1.0, 0.5*GeV);
	- const ConstLossyFinalState lfs(cfs, 0.08);
	+ /// @todo Replace ConstLossyFinalState with SmearedParticles
	+ const ConstLossyFinalState lossyfs(cfs, 0.08);
	+ //const SmearedParticles lossyfs(cfs, [](const Particle&){ return 0.92; });

	- addProjection(lfs, "FS");
	- addProjection(FastJets(lfs, FastJets::TRACKJET, 0.7), "TrackJet");
	+ declare(lossyfs, "FS");
	+ declare(FastJets(lossyfs, FastJets::TRACKJET, 0.7), "TrackJet");

	_numvsDeltaPhi2 = bookProfile1D(1, 1, 1);
	_numvsDeltaPhi5 = bookProfile1D(1, 1, 2);
	_numvsDeltaPhi30 = bookProfile1D(1, 1, 3);
	_pTvsDeltaPhi2 = bookProfile1D(2, 1, 1);
	_pTvsDeltaPhi5 = bookProfile1D(2, 1, 2);
	_pTvsDeltaPhi30 = bookProfile1D(2, 1, 3);

	_numTowardMB = bookProfile1D(3, 1, 1);
	_numTransMB = bookProfile1D(3, 1, 2);
	_numAwayMB = bookProfile1D(3, 1, 3);
	_numTowardJ20 = bookProfile1D(4, 1, 1);
	_numTransJ20 = bookProfile1D(4, 1, 2);
	_numAwayJ20 = bookProfile1D(4, 1, 3);

	_ptsumTowardMB = bookProfile1D(5, 1, 1);
	_ptsumTransMB = bookProfile1D(5, 1, 2);
	_ptsumAwayMB = bookProfile1D(5, 1, 3);
	_ptsumTowardJ20 = bookProfile1D(6, 1, 1);
	_ptsumTransJ20 = bookProfile1D(6, 1, 2);
	_ptsumAwayJ20 = bookProfile1D(6, 1, 3);

	_ptTrans2 = bookHisto1D(7, 1, 1);
	_ptTrans5 = bookHisto1D(7, 1, 2);
	_ptTrans30 = bookHisto1D(7, 1, 3);
	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Trigger
	- const bool trigger = applyProjection<TriggerCDFRun0Run1>(event, "Trigger").minBiasDecision();
	+ const bool trigger = apply<TriggerCDFRun0Run1>(event, "Trigger").minBiasDecision();
	if (!trigger) vetoEvent;

	- // Analyse, with pT > 0.5 GeV AND \|eta\| < 1
	- const JetAlg& tj = applyProjection<JetAlg>(event, "TrackJet");
	-
	- // Final state (lossy) charged particles
	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	-
	// Get jets, sorted by pT
	- const Jets jets = tj.jetsByPt();
	- if (jets.empty()) {
	- vetoEvent;
	- }
	-
	- Jet leadingJet = jets.front();
	- const double phiLead = leadingJet.phi();
	- const double ptLead = leadingJet.pT();
	+ const Jets jets = apply<JetAlg>(event, "TrackJet").jetsByPt();
	+ if (jets.empty()) vetoEvent;
	+ const Jet jet1 = jets.front();
	+ const double ptLead = jet1.pT();

	// Cut on highest pT jet: combined 0.5 GeV < pT(lead) < 50 GeV
	if (ptLead/GeV < 0.5) vetoEvent;
	if (ptLead/GeV > 50.0) vetoEvent;

	- // Get the event weight
	+ // Count sum of all event weights in three pT_lead regions
	const double weight = event.weight();
	-
	- // Count sum of all event weights in three pT_lead regions
	- if (ptLead/GeV > 2.0) {
	- _sumWeightsPtLead2 += weight;
	- }
	- if (ptLead/GeV > 5.0) {
	- _sumWeightsPtLead5 += weight;
	- }
	- if (ptLead/GeV > 30.0) {
	- _sumWeightsPtLead30 += weight;
	- }
	+ if (ptLead/GeV > 2.0) _sumWeightsPtLead2 += weight;
	+ if (ptLead/GeV > 5.0) _sumWeightsPtLead5 += weight;
	+ if (ptLead/GeV > 30.0) _sumWeightsPtLead30 += weight;

	// Run over tracks
	double ptSumToward(0.0), ptSumAway(0.0), ptSumTrans(0.0);
	size_t numToward(0), numTrans(0), numAway(0);

	// Temporary histos that bin N and pT in dphi
	Profile1D htmp_num_dphi_2(refData(1, 1, 1)), htmp_num_dphi_5(refData(1, 1, 2)), htmp_num_dphi_30(refData(1, 1, 3));
	Profile1D htmp_pt_dphi_2(refData(2, 1, 1)), htmp_pt_dphi_5(refData(2, 1, 2)), htmp_pt_dphi_30(refData(2, 1, 3));

	- foreach (const Particle& p, fs.particles()) {
	- // Calculate DeltaPhi(p,leadingJet)
	- const double dPhi = deltaPhi(p.phi(), phiLead);
	+ // Final state charged particles
	+ /// @todo Non-trackjet track efficiencies are corrected?
	+ const Particles& tracks = apply<FinalState>(event, "FS").particles();
	+ for (const Particle& p : tracks) {
	+ const double dPhi = deltaPhi(p, jet1);
	const double pT = p.pT();

	if (dPhi < PI/3.0) {
	ptSumToward += pT;
	++numToward;
	}
	else if (dPhi < 2*PI/3.0) {
	ptSumTrans += pT;
	++numTrans;
	// Fill transverse pT distributions
	if (ptLead/GeV > 2.0) {
	_ptTrans2->fill(pT/GeV, weight);
	_totalNumTrans2 += weight;
	}
	if (ptLead/GeV > 5.0) {
	_ptTrans5->fill(pT/GeV, weight);
	_totalNumTrans5 += weight;
	}
	if (ptLead/GeV > 30.0) {
	_ptTrans30->fill(pT/GeV, weight);
	_totalNumTrans30 += weight;
	}
	}
	else {
	ptSumAway += pT;
	++numAway;
	}

	// Fill tmp histos to bin event's track Nch & pT in dphi
	- const double dPhideg = 180*dPhi/PI;
	+ const double dPhideg = 180*dPhi/M_PI;
	if (ptLead/GeV > 2.0) {
	htmp_num_dphi_2.fill(dPhideg, 1);
	htmp_pt_dphi_2.fill (dPhideg, pT/GeV);
	}
	if (ptLead/GeV > 5.0) {
	htmp_num_dphi_5.fill(dPhideg, 1);
	htmp_pt_dphi_5.fill (dPhideg, pT/GeV);
	}
	if (ptLead/GeV > 30.0) {
	htmp_num_dphi_30.fill(dPhideg, 1);
	htmp_pt_dphi_30.fill (dPhideg, pT/GeV);
	}
	}

	// Update the "proper" dphi profile histograms
	for (int i = 0; i < 50; i++) { ///< @todo Should really explicitly iterate over nbins for each temp histo
	if (ptLead/GeV > 2.0) {
	const double x2 = htmp_pt_dphi_2.bin(i).xMid();
	const double num2 = (htmp_num_dphi_2.bin(i).numEntries() > 0) ? htmp_num_dphi_2.bin(i).mean() : 0.0;
	const double pt2 = (htmp_num_dphi_2.bin(i).numEntries() > 0) ? htmp_pt_dphi_2.bin(i).mean() : 0.0;
	_numvsDeltaPhi2->fill(x2, num2, weight);
	_pTvsDeltaPhi2->fill(x2, pt2, weight);
	}
	if (ptLead/GeV > 5.0) {
	const double x5 = htmp_pt_dphi_5.bin(i).xMid();
	const double num5 = (htmp_num_dphi_5.bin(i).numEntries() > 0) ? htmp_num_dphi_5.bin(i).mean() : 0.0;
	const double pt5 = (htmp_num_dphi_5.bin(i).numEntries() > 0) ? htmp_pt_dphi_5.bin(i).mean() : 0.0;
	_numvsDeltaPhi5->fill(x5, num5, weight);
	_pTvsDeltaPhi5->fill(x5, pt5, weight);
	}
	if (ptLead/GeV > 30.0) {
	const double x30 = htmp_pt_dphi_30.bin(i).xMid();
	const double num30 = (htmp_num_dphi_30.bin(i).numEntries() > 0) ? htmp_num_dphi_30.bin(i).mean() : 0.0;
	const double pt30 = (htmp_num_dphi_30.bin(i).numEntries() > 0) ? htmp_pt_dphi_30.bin(i).mean() : 0.0;
	_numvsDeltaPhi30->fill(x30, num30, weight);
	_pTvsDeltaPhi30->fill(x30, pt30, weight);
	}
	}

	// Log some event details about pT
	MSG_DEBUG("pT [lead; twd, away, trans] = [" << ptLead << "; "
	<< ptSumToward << ", " << ptSumAway << ", " << ptSumTrans << "]");

	// Update the pT profile histograms
	_ptsumTowardMB->fill(ptLead/GeV, ptSumToward/GeV, weight);
	_ptsumTowardJ20->fill(ptLead/GeV, ptSumToward/GeV, weight);

	_ptsumTransMB->fill(ptLead/GeV, ptSumTrans/GeV, weight);
	_ptsumTransJ20->fill(ptLead/GeV, ptSumTrans/GeV, weight);

	_ptsumAwayMB->fill(ptLead/GeV, ptSumAway/GeV, weight);
	_ptsumAwayJ20->fill(ptLead/GeV, ptSumAway/GeV, weight);

	// Log some event details about Nch
	MSG_DEBUG("N [twd, away, trans] = [" << ptLead << "; "
	<< numToward << ", " << numTrans << ", " << numAway << "]");

	// Update the N_track profile histograms
	_numTowardMB->fill(ptLead/GeV, numToward, weight);
	_numTowardJ20->fill(ptLead/GeV, numToward, weight);

	_numTransMB->fill(ptLead/GeV, numTrans, weight);
	_numTransJ20->fill(ptLead/GeV, numTrans, weight);

	_numAwayMB->fill(ptLead/GeV, numAway, weight);
	_numAwayJ20->fill(ptLead/GeV, numAway, weight);
	}


	/// Normalize histos
	void finalize() {
	normalize(_ptTrans2, _totalNumTrans2 / _sumWeightsPtLead2);
	normalize(_ptTrans5, _totalNumTrans5 / _sumWeightsPtLead5);
	normalize(_ptTrans30, _totalNumTrans30 / _sumWeightsPtLead30);
	}

	//@}


	private:

	/// Sum total number of charged particles in the trans region, in 3 \f$ p_\perp^\text{lead} \f$ bins.
	double _totalNumTrans2, _totalNumTrans5, _totalNumTrans30;

	/// Sum the total number of events in 3 \f$ p_\perp^\text{lead} \f$ bins.
	double _sumWeightsPtLead2,_sumWeightsPtLead5, _sumWeightsPtLead30;


	/// @name Histogram collections
	//@{

	// The sumpt vs. dphi and Nch vs. dphi histos
	Profile1DPtr _numvsDeltaPhi2, _numvsDeltaPhi5, _numvsDeltaPhi30;
	Profile1DPtr _pTvsDeltaPhi2, _pTvsDeltaPhi5, _pTvsDeltaPhi30;

	/// Profile histograms, binned in the \f$ p_T \f$ of the leading jet, for
	/// the \f$ p_T \f$ sum in the toward, transverse and away regions.
	Profile1DPtr _ptsumTowardMB, _ptsumTransMB, _ptsumAwayMB;
	Profile1DPtr _ptsumTowardJ20, _ptsumTransJ20, _ptsumAwayJ20;

	/// Profile histograms, binned in the \f$ p_T \f$ of the leading jet, for
	/// the number of charged particles per jet in the toward, transverse and
	/// away regions.
	Profile1DPtr _numTowardMB, _numTransMB, _numAwayMB;
	Profile1DPtr _numTowardJ20, _numTransJ20, _numAwayJ20;

	/// Histogram of \f$ p_T \f$ distribution for 3 different \f$ p_{T1} \f$ IR cutoffs.
	Histo1DPtr _ptTrans2, _ptTrans5, _ptTrans30;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2001_S4751469);

	}
	diff --git a/src/Analyses/CDF_2002_S4796047.cc b/src/Analyses/CDF_2002_S4796047.cc
	--- a/src/Analyses/CDF_2002_S4796047.cc
	+++ b/src/Analyses/CDF_2002_S4796047.cc
	@@ -1,122 +1,122 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/TriggerCDFRun0Run1.hh"

	namespace Rivet {


	/// @brief CDF Run I charged multiplicity measurement
	/// @author Hendrik Hoeth
	///
	/// This analysis measures the charged multiplicity distribution
	/// in minimum bias events at two different center-of-mass energies:
	/// \f$ \sqrt{s} = \f$ 630 and 1800 GeV.
	///
	/// Particles with c*tau > 10 mm are considered stable, i.e. they
	/// are reconstructed and their decay products removed. Selection
	/// cuts are \|eta\|<1 and pT>0.4 GeV.
	///
	/// @par Run conditions
	///
	/// @arg Two different beam energies: \f$ \sqrt{s} = \$f 630 & 1800 GeV
	/// @arg Run with generic QCD events.
	/// @arg Set particles with c*tau > 10 mm stable
	class CDF_2002_S4796047 : public Analysis {
	public:

	/// Constructor
	CDF_2002_S4796047()
	: Analysis("CDF_2002_S4796047")
	{
	_sumWTrig = 0;
	}


	/// @name Analysis methods
	//@{

	/// Book projections and histograms
	void init() {
	- addProjection(TriggerCDFRun0Run1(), "Trigger");
	+ declare(TriggerCDFRun0Run1(), "Trigger");
	const ChargedFinalState cfs(-1.0, 1.0, 0.4*GeV);
	- addProjection(cfs, "FS");
	+ declare(cfs, "FS");

	// Histos
	if (fuzzyEquals(sqrtS()/GeV, 630)) {
	_hist_multiplicity = bookHisto1D(1, 1, 1);
	_hist_pt_vs_multiplicity = bookProfile1D(3, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 1800)) {
	_hist_multiplicity = bookHisto1D(2, 1, 1);
	_hist_pt_vs_multiplicity = bookProfile1D(4, 1, 1);
	}
	}


	/// Do the analysis
	void analyze(const Event& evt) {
	// Trigger
	- const bool trigger = applyProjection<TriggerCDFRun0Run1>(evt, "Trigger").minBiasDecision();
	+ const bool trigger = apply<TriggerCDFRun0Run1>(evt, "Trigger").minBiasDecision();
	if (!trigger) vetoEvent;
	const double weight = evt.weight();
	_sumWTrig += weight;

	// Get beam energy and tracks
	- const ChargedFinalState& fs = applyProjection<ChargedFinalState>(evt, "FS");
	+ const ChargedFinalState& fs = apply<ChargedFinalState>(evt, "FS");
	const size_t numParticles = fs.particles().size();

	// Fill histos of charged multiplicity distributions
	_hist_multiplicity->fill(numParticles, weight);

	// Fill histos for <pT> vs. charged multiplicity
	foreach (const Particle& p, fs.particles()) {
	const double pT = p.pT();
	_hist_pt_vs_multiplicity->fill(numParticles, pT/GeV, weight);
	}

	}


	void finalize() {
	// This normalisation is NOT a cross-section.
	// In the paper the x-axes (!) of the histograms are
	// scaled such that they can put both energies in the
	// same plot. Of course this affects the area, too.
	// Since we want to plot the actual multiplicity, we
	// scale the x-axes back and have to adjust the areas
	// accordingly. The scale factors are given in the
	// legend of the plot in the paper. Have a look at
	// figure 1 and everything immediately becomes clear.
	// DON'T TRY TO REPAIR THIS, YOU WILL BREAK IT.
	if (fuzzyEquals(sqrtS()/GeV, 630)) {
	normalize(_hist_multiplicity, 3.21167); // fixed norm OK
	} else if (fuzzyEquals(sqrtS()/GeV, 1800)) {
	normalize(_hist_multiplicity, 4.19121); // fixed norm OK
	}
	}

	//@}


	private:

	/// @name Counter
	//@{
	double _sumWTrig;
	//@}

	/// @name Histos
	//@{
	Histo1DPtr _hist_multiplicity;
	Profile1DPtr _hist_pt_vs_multiplicity;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2002_S4796047);

	}
	diff --git a/src/Analyses/CDF_2004_S5839831.cc b/src/Analyses/CDF_2004_S5839831.cc
	--- a/src/Analyses/CDF_2004_S5839831.cc
	+++ b/src/Analyses/CDF_2004_S5839831.cc
	@@ -1,386 +1,386 @@
	// -- C++ --
	// "Acosta" underlying event analysis at CDF, inc. "Swiss Cheese"

	#include "Rivet/Analysis.hh"
	#include "Rivet/Jet.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/TriggerCDFRun0Run1.hh"

	namespace Rivet {


	/// @brief CDF calo jet underlying event analysis at 630 and 1800 GeV
	///
	/// CDF measurement of underlying event using calorimeter jet scales and
	/// alignment, particle flow activity in transverse cones, and the Swiss
	/// Cheese analysis method, where cones are excluded around the 2 and 3
	/// hardest jets.
	///
	/// @author Andy Buckley
	class CDF_2004_S5839831 : public Analysis {
	public:

	/// Constructor: cuts on charged final state are \f$ -1 < \eta < 1 \f$
	/// and \f$ p_T > 0.4 \f$ GeV.
	CDF_2004_S5839831()
	: Analysis("CDF_2004_S5839831")
	{ }


	private:


	/// @cond CONEUE_DETAIL

	struct ConesInfo {
	ConesInfo() : numMax(0), numMin(0), ptMax(0), ptMin(0), ptDiff(0) {}
	unsigned int numMax, numMin;
	double ptMax, ptMin, ptDiff;
	};

	/// @endcond

	ConesInfo _calcTransCones(const double etaLead, const double phiLead,
	const Particles& tracks) {
	const double phiTransPlus = mapAngle0To2Pi(phiLead + PI/2.0);
	const double phiTransMinus = mapAngle0To2Pi(phiLead - PI/2.0);
	MSG_DEBUG("phi_lead = " << phiLead
	<< " -> trans = (" << phiTransPlus
	<< ", " << phiTransMinus << ")");

	unsigned int numPlus(0), numMinus(0);
	double ptPlus(0), ptMinus(0);
	// Run over all charged tracks
	foreach (const Particle& t, tracks) {
	FourMomentum trackMom = t.momentum();
	const double pt = trackMom.pT();

	// Find if track mom is in either transverse cone
	if (deltaR(trackMom, etaLead, phiTransPlus) < 0.7) {
	ptPlus += pt;
	numPlus += 1;
	} else if (deltaR(trackMom, etaLead, phiTransMinus) < 0.7) {
	ptMinus += pt;
	numMinus += 1;
	}
	}

	ConesInfo rtn;
	// Assign N_{min,max} from N_{plus,minus}
	rtn.numMax = (ptPlus >= ptMinus) ? numPlus : numMinus;
	rtn.numMin = (ptPlus >= ptMinus) ? numMinus : numPlus;
	// Assign pT_{min,max} from pT_{plus,minus}
	rtn.ptMax = (ptPlus >= ptMinus) ? ptPlus : ptMinus;
	rtn.ptMin = (ptPlus >= ptMinus) ? ptMinus : ptPlus;
	rtn.ptDiff = fabs(rtn.ptMax - rtn.ptMin);

	MSG_DEBUG("Min cone has " << rtn.numMin << " tracks -> "
	<< "pT_min = " << rtn.ptMin/GeV << " GeV");
	MSG_DEBUG("Max cone has " << rtn.numMax << " tracks -> "
	<< "pT_max = " << rtn.ptMax/GeV << " GeV");

	return rtn;
	}


	ConesInfo _calcTransCones(const FourMomentum& leadvec,
	const Particles& tracks) {
	const double etaLead = leadvec.eta();
	const double phiLead = leadvec.phi();
	return _calcTransCones(etaLead, phiLead, tracks);
	}


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	- addProjection(TriggerCDFRun0Run1(), "Trigger");
	- addProjection(Beam(), "Beam");
	+ declare(TriggerCDFRun0Run1(), "Trigger");
	+ declare(Beam(), "Beam");
	const FinalState calofs(-1.2, 1.2);
	- addProjection(calofs, "CaloFS");
	- addProjection(FastJets(calofs, FastJets::CDFJETCLU, 0.7), "Jets");
	+ declare(calofs, "CaloFS");
	+ declare(FastJets(calofs, FastJets::CDFJETCLU, 0.7), "Jets");
	const ChargedFinalState trackfs(-1.2, 1.2, 0.4*GeV);
	- addProjection(trackfs, "TrackFS");
	+ declare(trackfs, "TrackFS");
	// Restrict tracks to \|eta\| < 0.7 for the min bias part.
	const ChargedFinalState mbfs(-0.7, 0.7, 0.4*GeV);
	- addProjection(mbfs, "MBFS");
	+ declare(mbfs, "MBFS");
	// Restrict tracks to \|eta\| < 1 for the Swiss-Cheese part.
	const ChargedFinalState cheesefs(-1.0, 1.0, 0.4*GeV);
	- addProjection(cheesefs, "CheeseFS");
	- addProjection(FastJets(cheesefs, FastJets::CDFJETCLU, 0.7), "CheeseJets");
	+ declare(cheesefs, "CheeseFS");
	+ declare(FastJets(cheesefs, FastJets::CDFJETCLU, 0.7), "CheeseJets");

	// Book histograms
	if (fuzzyEquals(sqrtS()/GeV, 1800, 1E-3)) {
	_pt90MaxAvg1800 = bookProfile1D(1, 1, 1);
	_pt90MinAvg1800 = bookProfile1D(1, 1, 2);
	_pt90Max1800 = bookProfile1D(2, 1, 1);
	_pt90Min1800 = bookProfile1D(2, 1, 2);
	_pt90Diff1800 = bookProfile1D(2, 1, 3);
	_num90Max1800 = bookProfile1D(4, 1, 1);
	_num90Min1800 = bookProfile1D(4, 1, 2);
	_pTSum1800_2Jet = bookProfile1D(7, 1, 1);
	_pTSum1800_3Jet = bookProfile1D(7, 1, 2);

	_pt90Dbn1800Et40 = bookHisto1D(3, 1, 1);
	_pt90Dbn1800Et80 = bookHisto1D(3, 1, 2);
	_pt90Dbn1800Et120 = bookHisto1D(3, 1, 3);
	_pt90Dbn1800Et160 = bookHisto1D(3, 1, 4);
	_pt90Dbn1800Et200 = bookHisto1D(3, 1, 5);
	_numTracksDbn1800MB = bookHisto1D(5, 1, 1);
	_ptDbn1800MB = bookHisto1D(6, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 630, 1E-3)) {
	_pt90Max630 = bookProfile1D(8, 1, 1);
	_pt90Min630 = bookProfile1D(8, 1, 2);
	_pt90Diff630 = bookProfile1D(8, 1, 3);
	_pTSum630_2Jet = bookProfile1D(9, 1, 1);
	_pTSum630_3Jet = bookProfile1D(9, 1, 2);

	_numTracksDbn630MB = bookHisto1D(10, 1, 1);
	_ptDbn630MB = bookHisto1D(11, 1, 1);
	}
	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Trigger
	- const bool trigger = applyProjection<TriggerCDFRun0Run1>(event, "Trigger").minBiasDecision();
	+ const bool trigger = apply<TriggerCDFRun0Run1>(event, "Trigger").minBiasDecision();
	if (!trigger) vetoEvent;

	// Get sqrt(s) and event weight
	- const double sqrtS = applyProjection<Beam>(event, "Beam").sqrtS();
	+ const double sqrtS = apply<Beam>(event, "Beam").sqrtS();
	const double weight = event.weight();

	{
	MSG_DEBUG("Running max/min analysis");
	- Jets jets = applyProjection<JetAlg>(event, "Jets").jets(cmpMomByE);
	+ Jets jets = apply<JetAlg>(event, "Jets").jets(cmpMomByE);
	if (!jets.empty()) {
	// Leading jet must be in central \|eta\| < 0.5 region
	const Jet leadingjet = jets.front();
	const double etaLead = leadingjet.eta();
	// Get Et of the leading jet: used to bin histograms
	const double ETlead = leadingjet.Et();
	MSG_DEBUG("Leading Et = " << ETlead/GeV << " GeV");
	if (fabs(etaLead) > 0.5 && ETlead < 15*GeV) {
	MSG_DEBUG("Leading jet eta = " << etaLead
	<< " not in \|eta\| < 0.5 & pT > 15 GeV");
	} else {
	// Multiplicity & pT distributions for sqrt(s) = 630 GeV, 1800 GeV
	- const Particles tracks = applyProjection<FinalState>(event, "TrackFS").particles();
	+ const Particles tracks = apply<FinalState>(event, "TrackFS").particles();
	const ConesInfo cones = _calcTransCones(leadingjet.momentum(), tracks);
	if (fuzzyEquals(sqrtS/GeV, 630)) {
	_pt90Max630->fill(ETlead/GeV, cones.ptMax/GeV, weight);
	_pt90Min630->fill(ETlead/GeV, cones.ptMin/GeV, weight);
	_pt90Diff630->fill(ETlead/GeV, cones.ptDiff/GeV, weight);
	} else if (fuzzyEquals(sqrtS/GeV, 1800)) {
	_num90Max1800->fill(ETlead/GeV, cones.numMax, weight);
	_num90Min1800->fill(ETlead/GeV, cones.numMin, weight);
	_pt90Max1800->fill(ETlead/GeV, cones.ptMax/GeV, weight);
	_pt90Min1800->fill(ETlead/GeV, cones.ptMin/GeV, weight);
	_pt90Diff1800->fill(ETlead/GeV, cones.ptDiff/GeV, weight);
	_pt90MaxAvg1800->fill(ETlead/GeV, cones.ptMax/GeV, weight); // /numMax
	_pt90MinAvg1800->fill(ETlead/GeV, cones.ptMin/GeV, weight); // /numMin
	//
	const double ptTransTotal = cones.ptMax + cones.ptMin;
	if (inRange(ETlead/GeV, 40., 80.)) {
	_pt90Dbn1800Et40->fill(ptTransTotal/GeV, weight);
	} else if (inRange(ETlead/GeV, 80., 120.)) {
	_pt90Dbn1800Et80->fill(ptTransTotal/GeV, weight);
	} else if (inRange(ETlead/GeV, 120., 160.)) {
	_pt90Dbn1800Et120->fill(ptTransTotal/GeV, weight);
	} else if (inRange(ETlead/GeV, 160., 200.)) {
	_pt90Dbn1800Et160->fill(ptTransTotal/GeV, weight);
	} else if (inRange(ETlead/GeV, 200., 270.)) {
	_pt90Dbn1800Et200->fill(ptTransTotal/GeV, weight);
	}
	}

	}
	}
	}


	// Fill min bias total track multiplicity histos
	{
	MSG_DEBUG("Running min bias multiplicity analysis");
	- const Particles mbtracks = applyProjection<FinalState>(event, "MBFS").particles();
	+ const Particles mbtracks = apply<FinalState>(event, "MBFS").particles();
	if (fuzzyEquals(sqrtS/GeV, 1800)) {
	_numTracksDbn1800MB->fill(mbtracks.size(), weight);
	} else if (fuzzyEquals(sqrtS/GeV, 630)) {
	_numTracksDbn630MB->fill(mbtracks.size(), weight);
	}
	// Run over all charged tracks
	foreach (const Particle& t, mbtracks) {
	FourMomentum trackMom = t.momentum();
	const double pt = trackMom.pT();
	// Plot total pT distribution for min bias
	if (fuzzyEquals(sqrtS/GeV, 1800)) {
	_ptDbn1800MB->fill(pt/GeV, weight);
	} else if (fuzzyEquals(sqrtS/GeV, 630)) {
	_ptDbn630MB->fill(pt/GeV, weight);
	}
	}
	}



	// Construct "Swiss Cheese" pT distributions, with pT contributions from
	// tracks within R = 0.7 of the 1st, 2nd (and 3rd) jets being ignored. A
	// different set of charged tracks, with \|eta\| < 1.0, is used here, and all
	// the removed jets must have Et > 5 GeV.
	{
	MSG_DEBUG("Running Swiss Cheese analysis");
	- const Particles cheesetracks = applyProjection<FinalState>(event, "CheeseFS").particles();
	- Jets cheesejets = applyProjection<JetAlg>(event, "Jets").jets(cmpMomByE);
	+ const Particles cheesetracks = apply<FinalState>(event, "CheeseFS").particles();
	+ Jets cheesejets = apply<JetAlg>(event, "Jets").jets(cmpMomByE);
	if (cheesejets.empty()) {
	MSG_DEBUG("No 'cheese' jets found in event");
	return;
	}
	if (cheesejets.size() > 1 &&
	fabs(cheesejets[0].eta()) <= 0.5 &&
	cheesejets[0].Et()/GeV > 5.0 &&
	cheesejets[1].Et()/GeV > 5.0) {

	const double cheeseETlead = cheesejets[0].Et();

	const double eta1 = cheesejets[0].eta();
	const double phi1 = cheesejets[0].phi();
	const double eta2 = cheesejets[1].eta();
	const double phi2 = cheesejets[1].phi();

	double ptSumSub2(0), ptSumSub3(0);
	foreach (const Particle& t, cheesetracks) {
	FourMomentum trackMom = t.momentum();
	const double pt = trackMom.pT();

	// Subtracting 2 leading jets
	const double deltaR1 = deltaR(trackMom, eta1, phi1);
	const double deltaR2 = deltaR(trackMom, eta2, phi2);
	MSG_TRACE("Track vs jet(1): "
	<< "\|(" << trackMom.eta() << ", " << trackMom.phi() << ") - "
	<< "\|(" << eta1 << ", " << phi1 << ")\| = " << deltaR1);
	MSG_TRACE("Track vs jet(2): "
	<< "\|(" << trackMom.eta() << ", " << trackMom.phi() << ") - "
	<< "\|(" << eta2 << ", " << phi2 << ")\| = " << deltaR2);
	if (deltaR1 > 0.7 && deltaR2 > 0.7) {
	ptSumSub2 += pt;

	// Subtracting 3rd leading jet
	if (cheesejets.size() > 2 &&
	cheesejets[2].Et()/GeV > 5.0) {
	const double eta3 = cheesejets[2].eta();
	const double phi3 = cheesejets[2].phi();
	const double deltaR3 = deltaR(trackMom, eta3, phi3);
	MSG_TRACE("Track vs jet(3): "
	<< "\|(" << trackMom.eta() << ", " << trackMom.phi() << ") - "
	<< "\|(" << eta3 << ", " << phi3 << ")\| = " << deltaR3);
	if (deltaR3 > 0.7) {
	ptSumSub3 += pt;
	}
	}
	}
	}

	// Swiss Cheese sub 2,3 jets distributions for sqrt(s) = 630 GeV, 1800 GeV
	if (fuzzyEquals(sqrtS/GeV, 630)) {
	if (!isZero(ptSumSub2)) _pTSum630_2Jet->fill(cheeseETlead/GeV, ptSumSub2/GeV, weight);
	if (!isZero(ptSumSub3))_pTSum630_3Jet->fill(cheeseETlead/GeV, ptSumSub3/GeV, weight);
	} else if (fuzzyEquals(sqrtS/GeV, 1800)) {
	if (!isZero(ptSumSub2))_pTSum1800_2Jet->fill(cheeseETlead/GeV, ptSumSub2/GeV, weight);
	if (!isZero(ptSumSub3))_pTSum1800_3Jet->fill(cheeseETlead/GeV, ptSumSub3/GeV, weight);
	}

	}
	}

	}


	void finalize() {
	/// @todo Take these normalisations from the data histo (it can't come from just the MC)

	if (fuzzyEquals(sqrtS()/GeV, 1800, 1E-3)) {
	// Normalize to actual number of entries in pT dbn histos...
	normalize(_pt90Dbn1800Et40, 1656.75); // norm OK
	normalize(_pt90Dbn1800Et80, 4657.5); // norm OK
	normalize(_pt90Dbn1800Et120, 5395.5); // norm OK
	normalize(_pt90Dbn1800Et160, 7248.75); // norm OK
	normalize(_pt90Dbn1800Et200, 2442.0); // norm OK
	}

	// ...and for min bias distributions:
	if (fuzzyEquals(sqrtS()/GeV, 1800, 1E-3)) {
	normalize(_numTracksDbn1800MB, 309718.25); // norm OK
	normalize(_ptDbn1800MB, 33600.0); // norm OK
	} else if (fuzzyEquals(sqrtS()/GeV, 630, 1E-3)) {
	normalize(_numTracksDbn630MB, 1101024.0); // norm OK
	normalize(_ptDbn630MB, 105088.0); // norm OK
	}
	}

	//@}


	private:

	/// @name Histogram collections
	//@{
	/// Profile histograms, binned in the \f$ E_T \f$ of the leading jet, for
	/// the average \f$ p_T \f$ in the toward, transverse and away regions at
	/// \f$ \sqrt{s} = 1800 \text{GeV} \f$.
	/// Corresponds to Table 1, and HepData table 1.
	Profile1DPtr _pt90MaxAvg1800, _pt90MinAvg1800;

	/// Profile histograms, binned in the \f$ E_T \f$ of the leading jet, for
	/// the \f$ p_T \f$ sum in the toward, transverse and away regions at
	/// \f$ \sqrt{s} = 1800 \text{GeV} \f$.
	/// Corresponds to figure 2/3, and HepData table 2.
	Profile1DPtr _pt90Max1800, _pt90Min1800, _pt90Diff1800;

	/// Profile histograms, binned in the \f$ E_T \f$ of the leading jet, for
	/// the \f$ p_T \f$ sum in the toward, transverse and away regions at
	/// at \f$ \sqrt{s} = 630 \text{GeV} \f$.
	/// Corresponds to figure 8, and HepData table 8.
	Profile1DPtr _pt90Max630, _pt90Min630, _pt90Diff630;

	/// Profile histograms, binned in the \f$ E_T \f$ of the leading jet, for
	/// the cone track multiplicity at \f$ \sqrt{s} = 1800 \text{GeV} \f$.
	/// Corresponds to figure 5, and HepData table 4.
	Profile1DPtr _num90Max1800, _num90Min1800;

	/// Profile histograms, binned in the \f$ E_T \f$ of the leading jet, for
	/// the \f$ p_T \f$ sum at \f$ \sqrt{s} = 1800 \text{GeV} \f$.
	/// Corresponds to figure 7, and HepData table 7.
	Profile1DPtr _pTSum1800_2Jet, _pTSum1800_3Jet;

	/// Profile histograms, binned in the \f$ E_T \f$ of the leading jet, for
	/// the \f$ p_T \f$ sum at \f$ \sqrt{s} = 630 \text{GeV} \f$.
	/// Corresponds to figure 9, and HepData table 9.
	Profile1DPtr _pTSum630_2Jet, _pTSum630_3Jet;

	/// Histogram of \f$ p_{T\text{sum}} \f$ distribution for 5 different
	/// \f$ E_{T1} \f$ bins.
	/// Corresponds to figure 4, and HepData table 3.
	Histo1DPtr _pt90Dbn1800Et40, _pt90Dbn1800Et80, _pt90Dbn1800Et120,
	_pt90Dbn1800Et160, _pt90Dbn1800Et200;

	/// Histograms of track multiplicity and \f$ p_T \f$ distributions for
	/// minimum bias events.
	/// Figure 6, and HepData tables 5 & 6.
	/// Figure 10, and HepData tables 10 & 11.
	Histo1DPtr _numTracksDbn1800MB, _ptDbn1800MB;
	Histo1DPtr _numTracksDbn630MB, _ptDbn630MB;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2004_S5839831);

	}
	diff --git a/src/Analyses/CDF_2005_S6080774.cc b/src/Analyses/CDF_2005_S6080774.cc
	--- a/src/Analyses/CDF_2005_S6080774.cc
	+++ b/src/Analyses/CDF_2005_S6080774.cc
	@@ -1,105 +1,105 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {


	/// @brief CDF diff cross-sections for prompt di-photon production
	class CDF_2005_S6080774 : public Analysis {
	public:

	/// Constructor
	CDF_2005_S6080774()
	: Analysis("CDF_2005_S6080774")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	IdentifiedFinalState ifs(Cuts::abseta < 0.9 && Cuts::pT > 13*GeV);
	ifs.acceptId(PID::PHOTON);
	- addProjection(ifs, "IFS");
	+ declare(ifs, "IFS");

	for (size_t yAxisId=1; yAxisId<5; ++yAxisId) {
	_h_m_PP.push_back(bookHisto1D(1, 1, yAxisId));
	_h_pT_PP.push_back(bookHisto1D(2, 1, yAxisId));
	_h_dphi_PP.push_back(bookHisto1D(3, 1, yAxisId));
	}
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- Particles photons = applyProjection<IdentifiedFinalState>(event, "IFS").particlesByPt();
	+ Particles photons = apply<IdentifiedFinalState>(event, "IFS").particlesByPt();
	if (photons.size() < 2 \|\| photons[0].pT() < 14.0*GeV) {
	vetoEvent;
	}

	// Isolate photons with ET_sum in cone
	Particles isolated_photons;
	- Particles fs = applyProjection<FinalState>(event, "FS").particles();
	+ Particles fs = apply<FinalState>(event, "FS").particles();
	foreach (const Particle& photon, photons) {
	FourMomentum mom_in_cone;
	double eta_P = photon.eta();
	double phi_P = photon.phi();
	foreach (const Particle& p, fs) {
	if (deltaR(eta_P, phi_P, p.eta(), p.phi()) < 0.4) {
	mom_in_cone += p.momentum();
	}
	}
	if (mom_in_cone.Et()-photon.Et() < 1.0*GeV) {
	isolated_photons.push_back(photon);
	}
	}

	if (isolated_photons.size() != 2) {
	vetoEvent;
	}

	FourMomentum mom_PP = isolated_photons[0].momentum() + isolated_photons[1].momentum();
	for (size_t i=0; i<4; ++i) {
	_h_m_PP[i]->fill(mom_PP.mass(), weight);
	_h_pT_PP[i]->fill(mom_PP.pT(), weight);
	_h_dphi_PP[i]->fill(mapAngle0ToPi(isolated_photons[0].phi()-
	isolated_photons[1].phi())/M_PI, weight);
	}
	}


	void finalize() {
	for (size_t i=0; i<4; ++i) {
	scale(_h_m_PP[i], crossSection()/sumOfWeights());
	scale(_h_pT_PP[i], crossSection()/sumOfWeights());
	scale(_h_dphi_PP[i], crossSection()/M_PI/sumOfWeights());
	}
	}

	//@}


	private:

	/// @name Histograms
	//@{
	std::vector<Histo1DPtr> _h_m_PP;
	std::vector<Histo1DPtr> _h_pT_PP;
	std::vector<Histo1DPtr> _h_dphi_PP;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2005_S6080774);

	}
	diff --git a/src/Analyses/CDF_2005_S6217184.cc b/src/Analyses/CDF_2005_S6217184.cc
	--- a/src/Analyses/CDF_2005_S6217184.cc
	+++ b/src/Analyses/CDF_2005_S6217184.cc
	@@ -1,132 +1,132 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/JetShape.hh"

	namespace Rivet {


	/// @brief CDF Run II jet shape analysis
	/// @author Andy Buckley
	class CDF_2005_S6217184 : public Analysis {
	public:

	/// Constructor
	CDF_2005_S6217184()
	: Analysis("CDF_2005_S6217184")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	const FinalState fs(-2.0, 2.0);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	FastJets fj(fs, FastJets::CDFMIDPOINT, 0.7);
	fj.useInvisibles();
	- addProjection(fj, "Jets");
	+ declare(fj, "Jets");

	// Specify pT bins
	_ptedges = {{ 37.0, 45.0, 55.0, 63.0, 73.0, 84.0, 97.0, 112.0, 128.0, 148.0,
	166.0, 186.0, 208.0, 229.0, 250.0, 277.0, 304.0, 340.0, 380.0 }};

	// Register a jet shape projection and histogram for each pT bin
	for (size_t i = 0; i < 6; ++i) {
	for (size_t j = 0; j < 3; ++j) {
	const size_t k = i*3 + j;
	stringstream ss; ss << "JetShape" << k;
	const string pname = ss.str();
	_jsnames_pT[k] = pname;
	const JetShape jsp(fj, 0.0, 0.7, 7, _ptedges[k], _ptedges[k+1], 0.1, 0.7, RAPIDITY);
	- addProjection(jsp, pname);
	+ declare(jsp, pname);
	_profhistRho_pT[k] = bookProfile1D(i+1, 1, j+1);
	_profhistPsi_pT[k] = bookProfile1D(6+i+1, 1, j+1);
	}
	}

	// Final histo
	_profhistPsi_vs_pT = bookScatter2D(13, 1, 1, true);
	}



	/// Do the analysis
	void analyze(const Event& evt) {

	// Get jets and require at least one to pass pT and y cuts
	- const Jets jets = applyProjection<FastJets>(evt, "Jets")
	+ const Jets jets = apply<FastJets>(evt, "Jets")
	.jetsByPt(Cuts::ptIn(_ptedges.front()GeV, _ptedges.back()GeV) && Cuts::absrap < 0.7);
	MSG_DEBUG("Jet multiplicity before cuts = " << jets.size());
	if (jets.size() == 0) {
	MSG_DEBUG("No jets found in required pT and rapidity range");
	vetoEvent;
	}

	// Calculate and histogram jet shapes
	const double weight = evt.weight();
	for (size_t ipt = 0; ipt < 18; ++ipt) {
	- const JetShape& jsipt = applyProjection<JetShape>(evt, _jsnames_pT[ipt]);
	+ const JetShape& jsipt = apply<JetShape>(evt, _jsnames_pT[ipt]);
	for (size_t ijet = 0; ijet < jsipt.numJets(); ++ijet) {
	for (size_t rbin = 0; rbin < jsipt.numBins(); ++rbin) {
	const double r_rho = jsipt.rBinMid(rbin);
	MSG_DEBUG(ipt << " " << rbin << " (" << r_rho << ") " << jsipt.diffJetShape(ijet, rbin));
	/// @note Bin width Jacobian factor of 0.7/0.1 = 7 in the differential shapes plot
	_profhistRho_pT[ipt]->fill(r_rho/0.7, (0.7/0.1)*jsipt.diffJetShape(ijet, rbin), weight);
	const double r_Psi = jsipt.rBinMax(rbin);
	_profhistPsi_pT[ipt]->fill(r_Psi/0.7, jsipt.intJetShape(ijet, rbin), weight);
	}
	}
	}

	}


	// Finalize
	void finalize() {
	// Construct final 1-Psi(0.3/0.7) profile from Psi profiles
	for (size_t i = 0; i < _ptedges.size()-1; ++i) {
	// Get entry for rad_Psi = 0.2 bin
	/// @note Not a great handling of empty bins!
	Profile1DPtr ph_i = _profhistPsi_pT[i];
	const double y = (ph_i->bin(2).effNumEntries() > 0) ? ph_i->bin(2).mean() : 0;
	const double ey = (ph_i->bin(2).effNumEntries() > 1) ? ph_i->bin(2).stdErr() : 0;
	_profhistPsi_vs_pT->point(i).setY(y, ey);
	}
	}

	//@}


	private:

	/// @name Analysis data
	//@{

	/// Jet \f$ p_\perp\f$ bins.
	vector<double> _ptedges; // This can't be a raw array if we want to initialise it non-painfully

	/// JetShape projection name for each \f$p_\perp\f$ bin.
	string _jsnames_pT[18];

	//@}


	/// @name Histograms
	//@{
	Profile1DPtr _profhistRho_pT[18];
	Profile1DPtr _profhistPsi_pT[18];
	Scatter2DPtr _profhistPsi_vs_pT;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2005_S6217184);

	}
	diff --git a/src/Analyses/CDF_2006_S6450792.cc b/src/Analyses/CDF_2006_S6450792.cc
	--- a/src/Analyses/CDF_2006_S6450792.cc
	+++ b/src/Analyses/CDF_2006_S6450792.cc
	@@ -1,61 +1,61 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF Inclusive jet cross-section differential in \f$ p_\perp \f$
	class CDF_2006_S6450792 : public Analysis {
	public:

	/// Constructor
	CDF_2006_S6450792()
	: Analysis("CDF_2006_S6450792")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	FinalState fs;
	- addProjection(FastJets(fs, FastJets::CDFMIDPOINT, 0.7), "ConeFinder");
	+ declare(FastJets(fs, FastJets::CDFMIDPOINT, 0.7), "ConeFinder");
	_h_jet_pt = bookHisto1D(1, 1, 1);
	}


	void analyze(const Event& event) {
	- const Jets& jets = applyProjection<JetAlg>(event, "ConeFinder").jets(Cuts::pT > 61*GeV);
	+ const Jets& jets = apply<JetAlg>(event, "ConeFinder").jets(Cuts::pT > 61*GeV);
	foreach (const Jet& jet, jets) {
	if (inRange(jet.absrap(), 0.1, 0.7))
	_h_jet_pt->fill(jet.pT()/GeV, event.weight());
	}
	}


	void finalize() {
	const double delta_y = 1.2;
	scale(_h_jet_pt, crossSection()/nanobarn/sumOfWeights()/delta_y);
	}

	//@}


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_jet_pt;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2006_S6450792);

	}
	diff --git a/src/Analyses/CDF_2006_S6653332.cc b/src/Analyses/CDF_2006_S6653332.cc
	--- a/src/Analyses/CDF_2006_S6653332.cc
	+++ b/src/Analyses/CDF_2006_S6653332.cc
	@@ -1,177 +1,177 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/InvMassFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ChargedLeptons.hh"

	namespace Rivet {


	/// @brief CDF Run II analysis: jet \f$ p_T \f$ and \f$ \eta \f$
	/// distributions in Z + (b) jet production
	/// @author Lars Sonnenschein
	///
	/// This CDF analysis provides \f$ p_T \f$ and \f$ \eta \f$ distributions of
	/// jets in Z + (b) jet production, before and after tagging.
	class CDF_2006_S6653332 : public Analysis {
	public:

	/// Constructor
	CDF_2006_S6653332()
	: Analysis("CDF_2006_S6653332"),
	_Rjet(0.7), _JetPtCut(20.), _JetEtaCut(1.5), _Lep1PtCut(18.), _Lep2PtCut(10.), _LepEtaCut(1.1),
	_sumWeightsWithZ(0.0), _sumWeightsWithZJet(0.0)
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	const FinalState fs(-3.6, 3.6);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Create a final state with any e+e- or mu+mu- pair with
	// invariant mass 76 -> 106 GeV and ET > 20 (Z decay products)
	vector<pair<PdgId,PdgId> > vids;
	vids.push_back(make_pair(PID::ELECTRON, PID::POSITRON));
	vids.push_back(make_pair(PID::MUON, PID::ANTIMUON));
	FinalState fs2(-3.6, 3.6);
	InvMassFinalState invfs(fs2, vids, 66GeV, 116GeV);
	- addProjection(invfs, "INVFS");
	+ declare(invfs, "INVFS");

	// Make a final state without the Z decay products for jet clustering
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(invfs);
	- addProjection(vfs, "VFS");
	- addProjection(FastJets(vfs, FastJets::CDFMIDPOINT, 0.7), "Jets");
	+ declare(vfs, "VFS");
	+ declare(FastJets(vfs, FastJets::CDFMIDPOINT, 0.7), "Jets");

	// Book histograms
	_sigmaBJet = bookHisto1D(1, 1, 1);
	_ratioBJetToZ = bookHisto1D(2, 1, 1);
	_ratioBJetToJet = bookHisto1D(3, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Check we have an l+l- pair that passes the kinematic cuts
	// Get the Z decay products (mu+mu- or e+e- pair)
	- const InvMassFinalState& invMassFinalState = applyProjection<InvMassFinalState>(event, "INVFS");
	+ const InvMassFinalState& invMassFinalState = apply<InvMassFinalState>(event, "INVFS");
	const Particles& ZDecayProducts = invMassFinalState.particles();

	// Make sure we have at least 2 Z decay products (mumu or ee)
	if (ZDecayProducts.size() < 2) vetoEvent;
	//
	double Lep1Pt = ZDecayProducts[0].pT();
	double Lep2Pt = ZDecayProducts[1].pT();
	double Lep1Eta = ZDecayProducts[0].absrap(); ///< @todo This is y... should be abseta()?
	double Lep2Eta = ZDecayProducts[1].absrap(); ///< @todo This is y... should be abseta()?

	if (Lep1Eta > _LepEtaCut && Lep2Eta > _LepEtaCut) vetoEvent;
	if (ZDecayProducts[0].abspid()==13 && Lep1Eta > 1. && Lep2Eta > 1.) vetoEvent;
	if (Lep1Pt < _Lep1PtCut && Lep2Pt < _Lep2PtCut) vetoEvent;

	_sumWeightsWithZ += event.weight();

	/// @todo Write out a warning if there are more than two decay products
	FourMomentum Zmom = ZDecayProducts[0].momentum() + ZDecayProducts[1].momentum();

	// Put all b-quarks in a vector
	/// @todo Use jet contents rather than accessing quarks directly
	Particles bquarks;
	/// @todo Use nicer looping
	for (GenEvent::particle_const_iterator p = event.genEvent()->particles_begin(); p != event.genEvent()->particles_end(); ++p) {
	if ( std::abs((*p)->pdg_id()) == PID::BQUARK ) {
	bquarks.push_back(Particle(**p));
	}
	}

	// Get jets
	- const FastJets& jetpro = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(event, "Jets");
	MSG_DEBUG("Jet multiplicity before any pT cut = " << jetpro.size());

	const PseudoJets& jets = jetpro.pseudoJetsByPt();
	MSG_DEBUG("jetlist size = " << jets.size());

	int numBJet = 0;
	int numJet = 0;
	// for each b-jet plot the ET and the eta of the jet, normalise to the total cross section at the end
	// for each event plot N jet and pT(Z), normalise to the total cross section at the end
	for (PseudoJets::const_iterator jt = jets.begin(); jt != jets.end(); ++jt) {
	// select jets that pass the kinematic cuts
	if (jt->perp() > _JetPtCut && fabs(jt->rapidity()) <= _JetEtaCut) {
	++numJet;
	// Does the jet contain a b-quark?
	/// @todo Use jet contents rather than accessing quarks directly
	bool bjet = false;
	foreach (const Particle& bquark, bquarks) {
	if (deltaR(jt->rapidity(), jt->phi(), bquark.rapidity(), bquark.phi()) <= _Rjet) {
	bjet = true;
	break;
	}
	} // end loop around b-jets
	if (bjet) {
	numBJet++;
	}
	}
	} // end loop around jets

	if (numJet > 0) _sumWeightsWithZJet += event.weight();
	if (numBJet > 0) {
	_sigmaBJet->fill(1960.0,event.weight());
	_ratioBJetToZ->fill(1960.0,event.weight());
	_ratioBJetToJet->fill(1960.0,event.weight());
	}

	}


	/// Finalize
	void finalize() {
	MSG_DEBUG("Total sum of weights = " << sumOfWeights());
	MSG_DEBUG("Sum of weights for Z production in mass range = " << _sumWeightsWithZ);
	MSG_DEBUG("Sum of weights for Z+jet production in mass range = " << _sumWeightsWithZJet);

	scale(_sigmaBJet, crossSection()/sumOfWeights());
	scale(_ratioBJetToZ, 1.0/_sumWeightsWithZ);
	scale(_ratioBJetToJet, 1.0/_sumWeightsWithZJet);
	}

	//@}


	private:

	/// @name Cuts and counters
	//@{
	double _Rjet;
	double _JetPtCut;
	double _JetEtaCut;
	double _Lep1PtCut;
	double _Lep2PtCut;
	double _LepEtaCut;

	double _sumWeightsWithZ;
	double _sumWeightsWithZJet;

	//@}

	/// @name Histograms
	//@{
	Histo1DPtr _sigmaBJet;
	Histo1DPtr _ratioBJetToZ;
	Histo1DPtr _ratioBJetToJet;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2006_S6653332);

	}
	diff --git a/src/Analyses/CDF_2007_S7057202.cc b/src/Analyses/CDF_2007_S7057202.cc
	--- a/src/Analyses/CDF_2007_S7057202.cc
	+++ b/src/Analyses/CDF_2007_S7057202.cc
	@@ -1,79 +1,79 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF inclusive jet cross-section using the \f$ k_\perp \f$ algorithm
	class CDF_2007_S7057202 : public Analysis {
	public:

	CDF_2007_S7057202()
	: Analysis("CDF_2007_S7057202")
	{ }


	void init() {
	// Set up projections
	const FinalState fs;
	- addProjection(FastJets(fs, FastJets::KT, 0.5), "JetsD05");
	- addProjection(FastJets(fs, FastJets::KT, 0.7), "JetsD07");
	- addProjection(FastJets(fs, FastJets::KT, 1.0), "JetsD10");
	+ declare(FastJets(fs, FastJets::KT, 0.5), "JetsD05");
	+ declare(FastJets(fs, FastJets::KT, 0.7), "JetsD07");
	+ declare(FastJets(fs, FastJets::KT, 1.0), "JetsD10");

	// Book histos
	_binnedHistosD07.addHistogram( 0, 0.1, bookHisto1D(1, 1, 1));
	_binnedHistosD07.addHistogram(0.1, 0.7, bookHisto1D(2, 1, 1));
	_binnedHistosD07.addHistogram(0.7, 1.1, bookHisto1D(3, 1, 1));
	_binnedHistosD07.addHistogram(1.1, 1.6, bookHisto1D(4, 1, 1));
	_binnedHistosD07.addHistogram(1.6, 2.1, bookHisto1D(5, 1, 1));
	_histoD05 = bookHisto1D(6, 1, 1);
	_histoD10 = bookHisto1D(7, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- foreach (const Jet& jet, applyProjection<JetAlg>(event, "JetsD07").jets(Cuts::pT > 54*GeV))
	+ foreach (const Jet& jet, apply<JetAlg>(event, "JetsD07").jets(Cuts::pT > 54*GeV))
	_binnedHistosD07.fill(jet.absrap(), jet.pT(), weight);

	- foreach (const Jet& jet, applyProjection<JetAlg>(event, "JetsD05").jets(Cuts::pT > 54*GeV))
	+ foreach (const Jet& jet, apply<JetAlg>(event, "JetsD05").jets(Cuts::pT > 54*GeV))
	if (inRange(jet.absrap(), 0.1, 0.7)) _histoD05->fill(jet.pT(), weight);

	- foreach (const Jet& jet, applyProjection<JetAlg>(event, "JetsD10").jets(Cuts::pT > 54*GeV))
	+ foreach (const Jet& jet, apply<JetAlg>(event, "JetsD10").jets(Cuts::pT > 54*GeV))
	if (inRange(jet.absrap(), 0.1, 0.7)) _histoD10->fill(jet.pT(), weight);
	}


	// Normalise histograms to cross-section
	void finalize() {
	const double xSec = crossSectionPerEvent()/nanobarn;

	scale(_histoD05, xSec);
	scale(_histoD10, xSec);
	// scale to xSec/yBinWidth and take into account the double yBinWidth due
	// to the absolute value of y
	_binnedHistosD07.scale(xSec/2.0, this);
	}

	private:

	BinnedHistogram<double> _binnedHistosD07;

	// Single histogram for the \f$R=0.5\f$ \f$k_\perp\f$ jets
	Histo1DPtr _histoD05;

	// Single histogram for the \f$R=1.0\f$ \f$k_\perp\f$ jets
	Histo1DPtr _histoD10;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2007_S7057202);

	}
	diff --git a/src/Analyses/CDF_2008_S7540469.cc b/src/Analyses/CDF_2008_S7540469.cc
	--- a/src/Analyses/CDF_2008_S7540469.cc
	+++ b/src/Analyses/CDF_2008_S7540469.cc
	@@ -1,177 +1,177 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief Measurement differential Z/\f$ \gamma^* \f$ + jet + \f$ X \f$ cross sections
	/// @author Frank Siegert
	class CDF_2008_S7540469 : public Analysis {

	public:

	/// Constructor
	CDF_2008_S7540469()
	: Analysis("CDF_2008_S7540469")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	// Full final state
	FinalState fs(-5.0, 5.0);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Leading electrons in tracking acceptance
	IdentifiedFinalState elfs(Cuts::abseta < 5 && Cuts::pT > 25*GeV);
	elfs.acceptIdPair(PID::ELECTRON);
	- addProjection(elfs, "LeadingElectrons");
	+ declare(elfs, "LeadingElectrons");

	_h_jet_multiplicity = bookHisto1D(1, 1, 1);
	_h_jet_pT_cross_section_incl_1jet = bookHisto1D(2, 1, 1);
	_h_jet_pT_cross_section_incl_2jet = bookHisto1D(3, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event & event) {
	const double weight = event.weight();

	// Skip if the event is empty
	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	if (fs.empty()) {
	MSG_DEBUG("Skipping event " << numEvents() << " because no final state pair found");
	vetoEvent;
	}

	// Find the Z candidates
	- const FinalState & electronfs = applyProjection<FinalState>(event, "LeadingElectrons");
	+ const FinalState & electronfs = apply<FinalState>(event, "LeadingElectrons");
	std::vector<std::pair<Particle, Particle> > Z_candidates;
	Particles all_els=electronfs.particles();
	for (size_t i=0; i<all_els.size(); ++i) {
	for (size_t j=i+1; j<all_els.size(); ++j) {
	bool candidate=true;
	double mZ = FourMomentum(all_els[i].momentum()+all_els[j].momentum()).mass()/GeV;
	if (mZ < 66.0 \|\| mZ > 116.0) {
	candidate = false;
	}
	double abs_eta_0 = fabs(all_els[i].eta());
	double abs_eta_1 = fabs(all_els[j].eta());
	if (abs_eta_1 < abs_eta_0) {
	double tmp = abs_eta_0;
	abs_eta_0 = abs_eta_1;
	abs_eta_1 = tmp;
	}
	if (abs_eta_0 > 1.0) {
	candidate = false;
	}
	if (!(abs_eta_1 < 1.0 \|\| (inRange(abs_eta_1, 1.2, 2.8)))) {
	candidate = false;
	}
	if (candidate) {
	Z_candidates.push_back(make_pair(all_els[i], all_els[j]));
	}
	}
	}
	if (Z_candidates.size() != 1) {
	MSG_DEBUG("Skipping event " << numEvents() << " because no unique electron pair found ");
	vetoEvent;
	}

	// Now build the jets on a FS without the electrons from the Z (including QED radiation)
	Particles jetparts;
	for (const Particle& p : fs.particles()) {
	bool copy = true;
	if (p.pid() == PID::PHOTON) {
	FourMomentum p_e0 = Z_candidates[0].first.momentum();
	FourMomentum p_e1 = Z_candidates[0].second.momentum();
	FourMomentum p_P = p.momentum();
	if (deltaR(p_e0, p_P) < 0.2) copy = false;
	if (deltaR(p_e1, p_P) < 0.2) copy = false;
	} else {
	if (p.genParticle()->barcode() == Z_candidates[0].first.genParticle()->barcode()) copy = false;
	if (p.genParticle()->barcode() == Z_candidates[0].second.genParticle()->barcode()) copy = false;
	}
	if (copy) jetparts.push_back(p);
	}

	// Proceed to lepton dressing
	const PseudoJets pjs = mkPseudoJets(jetparts);
	const auto jplugin = make_shared<fastjet::CDFMidPointPlugin>(0.7, 0.5, 1.0);
	const Jets jets_all = mkJets(fastjet::ClusterSequence(pjs, jplugin.get()).inclusive_jets());
	const Jets jets_cut = sortByPt(filterBy(jets_all, Cuts::pT > 30*GeV && Cuts::abseta < 2.1));
	// FastJets jetpro(FastJets::CDFMIDPOINT, 0.7);
	// jetpro.calc(jetparts);
	// // Take jets with pt > 30, \|eta\| < 2.1:
	// const Jets& jets = jetpro.jets();
	// Jets jets_cut;
	// foreach (const Jet& j, jets) {
	// if (j.pT()/GeV > 30.0 && j.abseta() < 2.1) {
	// jets_cut.push_back(j);
	// }
	// }
	// // Sort by pT:
	// sort(jets_cut.begin(), jets_cut.end(), cmpMomByPt);

	// Return if there are no jets:
	MSG_DEBUG("Num jets above 30 GeV = " << jets_cut.size());
	if (jets_cut.empty()) {
	MSG_DEBUG("No jets pass cuts ");
	vetoEvent;
	}

	// Cut on Delta R between Z electrons and all jets
	for (const Jet& j : jets_cut) {
	if (deltaR(Z_candidates[0].first, j) < 0.7) vetoEvent;
	if (deltaR(Z_candidates[0].second, j) < 0.7) vetoEvent;
	}

	// Fill histograms
	for (size_t njet=1; njet<=jets_cut.size(); ++njet) {
	_h_jet_multiplicity->fill(njet, weight);
	}
	for (const Jet& j : jets_cut) {
	if (jets_cut.size() > 0) {
	_h_jet_pT_cross_section_incl_1jet->fill(j.pT(), weight);
	}
	if (jets_cut.size() > 1) {
	_h_jet_pT_cross_section_incl_2jet->fill(j.pT(), weight);
	}
	}
	}


	/// Rescale histos
	void finalize() {
	const double invlumi = crossSection()/femtobarn/sumOfWeights();
	scale(_h_jet_multiplicity, invlumi);
	scale(_h_jet_pT_cross_section_incl_1jet, invlumi);
	scale(_h_jet_pT_cross_section_incl_2jet, invlumi);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_jet_multiplicity;
	Histo1DPtr _h_jet_pT_cross_section_incl_1jet;
	Histo1DPtr _h_jet_pT_cross_section_incl_2jet;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2008_S7540469);

	}
	diff --git a/src/Analyses/CDF_2008_S7541902.cc b/src/Analyses/CDF_2008_S7541902.cc
	--- a/src/Analyses/CDF_2008_S7541902.cc
	+++ b/src/Analyses/CDF_2008_S7541902.cc
	@@ -1,193 +1,193 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/InvMassFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include <algorithm>

	namespace Rivet {


	/// @brief CDF jet pT and multiplicity distributions in W + jets events
	///
	/// This CDF analysis provides jet pT distributions for 4 jet multiplicity bins
	/// as well as the jet multiplicity distribution in W + jets events.
	/// e-Print: arXiv:0711.4044 [hep-ex]
	class CDF_2008_S7541902 : public Analysis {
	public:

	/// Constructor
	CDF_2008_S7541902()
	: Analysis("CDF_2008_S7541902"),
	_electronETCut(20.0*GeV), _electronETACut(1.1),
	_eTmissCut(30.0GeV), _mTCut(20.0GeV),
	_jetEtCutA(20.0GeV), _jetEtCutB(25.0GeV), _jetETA(2.0),
	_sumW(0)
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	// Basic FS
	FinalState fs(-3.6, 3.6);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Create a final state with any e-nu pair with invariant mass 65 -> 95 GeV and ET > 20 (W decay products)
	vector<pair<PdgId,PdgId> > vids;
	vids += make_pair(PID::ELECTRON, PID::NU_EBAR);
	vids += make_pair(PID::POSITRON, PID::NU_E);
	FinalState fs2(-3.6, 3.6, 20*GeV);
	InvMassFinalState invfs(fs2, vids, 65GeV, 95GeV);
	- addProjection(invfs, "INVFS");
	+ declare(invfs, "INVFS");

	// Make a final state without the W decay products for jet clustering
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(invfs);
	- addProjection(vfs, "VFS");
	- addProjection(FastJets(vfs, FastJets::CDFJETCLU, 0.4), "Jets");
	+ declare(vfs, "VFS");
	+ declare(FastJets(vfs, FastJets::CDFJETCLU, 0.4), "Jets");

	// Book histograms
	for (int i = 0 ; i < 4 ; ++i) {
	_histJetEt[i] = bookHisto1D(1+i, 1, 1);
	_histJetMultRatio[i] = bookScatter2D(5, 1, i+1, true);
	/// @todo These would be better off as YODA::Counter until finalize()
	_histJetMult[i] = bookHisto1D(6+i, 1, 1); // _sumW is essentially the 0th "histo" counter
	}
	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Get the W decay products (electron and neutrino)
	- const InvMassFinalState& invMassFinalState = applyProjection<InvMassFinalState>(event, "INVFS");
	+ const InvMassFinalState& invMassFinalState = apply<InvMassFinalState>(event, "INVFS");
	const Particles& wDecayProducts = invMassFinalState.particles();

	FourMomentum electronP, neutrinoP;
	bool gotElectron(false), gotNeutrino(false);
	foreach (const Particle& p, wDecayProducts) {
	FourMomentum p4 = p.momentum();
	if (p4.Et() > _electronETCut && fabs(p4.eta()) < _electronETACut && p.abspid() == PID::ELECTRON) {
	electronP = p4;
	gotElectron = true;
	}
	else if (p4.Et() > _eTmissCut && p.abspid() == PID::NU_E) {
	neutrinoP = p4;
	gotNeutrino = true;
	}
	}

	// Veto event if the electron or MET cuts fail
	if (!gotElectron \|\| !gotNeutrino) vetoEvent;

	// Veto event if the MTR cut fails
	double mT2 = 2.0 * ( electronP.pT()neutrinoP.pT() - electronP.px()neutrinoP.px() - electronP.py()*neutrinoP.py() );
	if (sqrt(mT2) < _mTCut ) vetoEvent;

	// Get the jets
	- const JetAlg& jetProj = applyProjection<FastJets>(event, "Jets");
	+ const JetAlg& jetProj = apply<FastJets>(event, "Jets");
	Jets theJets = jetProj.jets(cmpMomByEt, Cuts::Et > _jetEtCutA);
	size_t njetsA(0), njetsB(0);
	foreach (const Jet& j, theJets) {
	const FourMomentum pj = j.momentum();
	if (fabs(pj.rapidity()) < _jetETA) {
	// Fill differential histograms for top 4 jets with Et > 20
	if (njetsA < 4 && pj.Et() > _jetEtCutA) {
	++njetsA;
	_histJetEt[njetsA-1]->fill(pj.Et(), event.weight());
	}
	// Count number of jets with Et > 25 (for multiplicity histograms)
	if (pj.Et() > _jetEtCutB) ++njetsB;
	}
	}

	// Increment event counter
	_sumW += event.weight();

	// Jet multiplicity
	for (size_t i = 1; i <= njetsB; ++i) {
	/// @todo This isn't really a histogram: replace with a YODA::Counter when we have one!
	_histJetMult[i-1]->fill(1960., event.weight());
	if (i == 4) break;
	}
	}



	/// Finalize
	void finalize() {

	// Fill the 0th ratio histogram specially
	/// @todo This special case for 1-to-0 will disappear if we use Counters for all mults including 0.
	if (_sumW > 0) {
	const YODA::Histo1D::Bin& b0 = _histJetMult[0]->bin(0);
	double ratio = b0.area()/_sumW;
	double frac_err = 1/_sumW; ///< This 1/sqrt{N} error treatment isn't right for weighted events: use YODA::Counter
	if (b0.area() > 0) frac_err = sqrt( sqr(frac_err) + sqr(b0.areaErr()/b0.area()) );
	_histJetMultRatio[0]->point(0).setY(ratio, ratio*frac_err);
	}

	// Loop over the non-zero multiplicities
	for (size_t i = 0; i < 3; ++i) {
	const YODA::Histo1D::Bin& b1 = _histJetMult[i]->bin(0);
	const YODA::Histo1D::Bin& b2 = _histJetMult[i+1]->bin(0);
	if (b1.area() == 0.0) continue;
	double ratio = b2.area()/b1.area();
	double frac_err = b1.areaErr()/b1.area();
	if (b2.area() > 0) frac_err = sqrt( sqr(frac_err) + sqr(b2.areaErr()/b2.area()) );
	_histJetMultRatio[i+1]->point(0).setY(ratio, ratio*frac_err);
	}

	// Normalize the non-ratio histograms
	for (size_t i = 0; i < 4; ++i) {
	scale(_histJetEt[i], crossSection()/picobarn/sumOfWeights());
	scale(_histJetMult[i], crossSection()/picobarn/sumOfWeights());
	}

	}

	//@}


	private:

	/// @name Cuts
	//@{

	/// Cut on the electron ET:
	double _electronETCut;
	/// Cut on the electron ETA:
	double _electronETACut;
	/// Cut on the missing ET
	double _eTmissCut;
	/// Cut on the transverse mass squared
	double _mTCut;
	/// Cut on the jet ET for differential cross sections
	double _jetEtCutA;
	/// Cut on the jet ET for jet multiplicity
	double _jetEtCutB;
	/// Cut on the jet ETA
	double _jetETA;

	//@}

	/// @name Histograms
	//@{
	Histo1DPtr _histJetEt[4];
	Histo1DPtr _histJetMultNorm;
	Scatter2DPtr _histJetMultRatio[4];
	Histo1DPtr _histJetMult[4];
	double _sumW;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2008_S7541902);

	}
	diff --git a/src/Analyses/CDF_2008_S7782535.cc b/src/Analyses/CDF_2008_S7782535.cc
	--- a/src/Analyses/CDF_2008_S7782535.cc
	+++ b/src/Analyses/CDF_2008_S7782535.cc
	@@ -1,137 +1,141 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/JetShape.hh"

	namespace Rivet {


	/// @brief CDF Run II b-jet shape paper
	class CDF_2008_S7782535 : public Analysis {
	public:

	/// Constructor
	CDF_2008_S7782535() : Analysis("CDF_2008_S7782535")
	{
	}


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	const FinalState fs(-3.6, 3.6);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	FastJets jetproj(fs, FastJets::CDFMIDPOINT, 0.7);
	jetproj.useInvisibles();
	- addProjection(jetproj, "Jets");
	+ declare(jetproj, "Jets");

	// Book histograms and corresponding jet shape projections
	_ptedges = {{ 52, 80, 104, 142, 300 }};
	for (size_t i = 0; i < 4; ++i) {
	stringstream ss; ss << "JetShape" << i;
	const string pname = ss.str();
	_jsnames_pT[i] = pname;
	const JetShape jsp(jetproj, 0.0, 0.7, 7, _ptedges[i], _ptedges[i+1], 0.0, 0.7, RAPIDITY);
	- addProjection(jsp, pname);
	+ declare(jsp, pname);
	_h_Psi_pT[i] = bookProfile1D(i+1, 2, 1);
	}
	_h_OneMinusPsi_vs_pT = bookScatter2D(5, 1, 1);
	}


	// Do the analysis
	void analyze(const Event& event) {
	- const FastJets& fjs = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& fjs = apply<FastJets>(event, "Jets");
	const Jets& jets = fjs.jets(Cuts::ptIn(_ptedges.front()GeV, _ptedges.back()GeV) && Cuts::absrap < 0.7);
	if (jets.size() == 0) {
	MSG_DEBUG("No jets found in required pT range");
	vetoEvent;
	}

	// Filter to just get a vector of b-jets
	Jets bjets;
	foreach (const Jet& j, jets) {
	if (j.bTagged()) bjets += j;
	}
	if (bjets.empty()) {
	MSG_DEBUG("No b-jet axes in acceptance");
	vetoEvent;
	}

	// Bin b-jets in pT
	Jets bjets_ptbinned[4];
	foreach (const Jet& bj, bjets) {
	const FourMomentum pbj = bj.momentum();
	const int ipt = binIndex(pbj.pT(), _ptedges);
	if (ipt == -1) continue; ///< Out of pT range (somehow!)
	bjets_ptbinned[ipt] += bj;
	}

	// Loop over jet pT bins and fill shape profiles
	const double weight = event.weight();
	for (size_t ipt = 0; ipt < 4; ++ipt) {
	if (bjets_ptbinned[ipt].empty()) continue;
	// Don't use the cached result: copy construct and calculate for provided b-jets only
	- JetShape jsipt = applyProjection<JetShape>(event, _jsnames_pT[ipt]);
	+ JetShape jsipt = apply<JetShape>(event, _jsnames_pT[ipt]);
	jsipt.calc(bjets_ptbinned[ipt]);
	for (size_t ijet = 0; ijet < jsipt.numJets(); ++ijet) {
	for (size_t rbin = 0; rbin < jsipt.numBins(); ++rbin) {
	const double r_Psi = jsipt.rBinMax(rbin);
	_h_Psi_pT[ipt]->fill(r_Psi/0.7, jsipt.intJetShape(ijet, rbin), weight);
	}
	}
	}

	}


	/// Finalize
	void finalize() {

	// Construct final 1-Psi(0.3/0.7) profile from Psi profiles
	for (size_t i = 0; i < _ptedges.size()-1; ++i) {
	// Get entry for rad_Psi = 0.2 bin
	Profile1DPtr ph_i = _h_Psi_pT[i];
	const double ex = 0.5*(_ptedges[i+1] - _ptedges[i]);
	const double x = _ptedges[i] + ex;
	- const double y = 1.0 - ph_i->bin(1).mean();
	- const double ey = ph_i->bin(1).stdErr();
	+ double y = 0; // This is to protect against exceptions
	+ double ey = 0; // thrown by YODA when calling mean and
	+ if (ph_i->bin(1).effNumEntries() > 1) { // stdErr at
	+ y = 1.0 - ph_i->bin(1).mean(); // low stats
	+ ey= ph_i->bin(1).stdErr();
	+ }
	_h_OneMinusPsi_vs_pT->addPoint(x, y, ex, ey);
	}

	}

	//@}


	private:

	/// @name Analysis data
	//@{

	/// Jet \f$ p_\perp\f$ bins.
	vector<double> _ptedges; // This can't be a raw array if we want to initialise it non-painfully

	/// JetShape projection name for each \f$p_\perp\f$ bin.
	string _jsnames_pT[4];

	//@}


	/// @name Histograms
	//@{
	Profile1DPtr _h_Psi_pT[4];
	Scatter2DPtr _h_OneMinusPsi_vs_pT;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2008_S7782535);

	}
	diff --git a/src/Analyses/CDF_2008_S7828950.cc b/src/Analyses/CDF_2008_S7828950.cc
	--- a/src/Analyses/CDF_2008_S7828950.cc
	+++ b/src/Analyses/CDF_2008_S7828950.cc
	@@ -1,68 +1,68 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF Run II inclusive jet cross-section using the Midpoint algorithm.
	///
	/// The analysis includes 1.1fb^-1 of CDF data and is the first with a
	/// cone algorithm to include the forward region of the detector.
	/// arXiv:0807.2204 to be published in PRD
	class CDF_2008_S7828950 : public Analysis {
	public:

	/// Constructor
	CDF_2008_S7828950()
	: Analysis("CDF_2008_S7828950")
	{ }


	/// @name Analysis methods
	//@{

	// Book histos and set counters for number of events passed in each one
	void init() {
	const FinalState fs;
	- addProjection(FastJets(fs, FastJets::CDFMIDPOINT, 0.7), "JetsM07");
	+ declare(FastJets(fs, FastJets::CDFMIDPOINT, 0.7), "JetsM07");

	_binnedHistosR07.addHistogram( 0, 0.1, bookHisto1D(1, 1, 1));
	_binnedHistosR07.addHistogram(0.1, 0.7, bookHisto1D(2, 1, 1));
	_binnedHistosR07.addHistogram(0.7, 1.1, bookHisto1D(3, 1, 1));
	_binnedHistosR07.addHistogram(1.1, 1.6, bookHisto1D(4, 1, 1));
	_binnedHistosR07.addHistogram(1.6, 2.1, bookHisto1D(5, 1, 1));

	}


	// Do the analysis
	void analyze(const Event& event) {
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "JetsM07").jets(Cuts::pT > 62*GeV)) {
	+ foreach (const Jet& jet, apply<FastJets>(event, "JetsM07").jets(Cuts::pT > 62*GeV)) {
	_binnedHistosR07.fill(jet.absrap(), jet.pT(), event.weight());
	}
	}


	// Normalise histograms to cross-section
	void finalize() {
	_binnedHistosR07.scale(crossSection()/nanobarn/sumOfWeights()/2.0, this);
	}

	//@}


	private:

	/// Histograms in different eta regions
	BinnedHistogram<double> _binnedHistosR07;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2008_S7828950);

	}
	diff --git a/src/Analyses/CDF_2008_S8093652.cc b/src/Analyses/CDF_2008_S8093652.cc
	--- a/src/Analyses/CDF_2008_S8093652.cc
	+++ b/src/Analyses/CDF_2008_S8093652.cc
	@@ -1,73 +1,73 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF dijet mass spectrum
	class CDF_2008_S8093652 : public Analysis {
	public:

	/// Constructor
	CDF_2008_S8093652()
	: Analysis("CDF_2008_S8093652")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	FastJets conefinder(fs, FastJets::CDFMIDPOINT, 0.7);
	- addProjection(conefinder, "ConeFinder");
	+ declare(conefinder, "ConeFinder");

	_h_m_dijet = bookHisto1D(1, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event & e) {
	const double weight = e.weight();

	- const JetAlg& jetpro = applyProjection<JetAlg>(e, "ConeFinder");
	+ const JetAlg& jetpro = apply<JetAlg>(e, "ConeFinder");
	const Jets& jets = jetpro.jetsByPt();

	if (jets.size() < 2) vetoEvent;

	const FourMomentum j0(jets[0].momentum());
	const FourMomentum j1(jets[1].momentum());
	if (j1.absrap() > 1.0 \|\| j0.absrap() > 1.0) {
	vetoEvent;
	}

	double mjj = FourMomentum(j0+j1).mass();
	_h_m_dijet->fill(mjj, weight);
	}


	/// Finalize
	void finalize() {
	scale(_h_m_dijet, crossSection()/sumOfWeights());
	}
	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_m_dijet;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2008_S8093652);

	}
	diff --git a/src/Analyses/CDF_2008_S8095620.cc b/src/Analyses/CDF_2008_S8095620.cc
	--- a/src/Analyses/CDF_2008_S8095620.cc
	+++ b/src/Analyses/CDF_2008_S8095620.cc
	@@ -1,187 +1,187 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/InvMassFinalState.hh"

	namespace Rivet {


	/// @brief CDF Run II Z + b-jet cross-section measurement
	class CDF_2008_S8095620 : public Analysis {
	public:

	/// Constructor.
	/// jet cuts: \|eta\| <= 1.5
	CDF_2008_S8095620()
	: Analysis("CDF_2008_S8095620"),
	_Rjet(0.7), _JetPtCut(20.), _JetEtaCut(1.5), _Lep1PtCut(18.), _Lep2PtCut(10.), _LepEtaCut(3.2),
	_sumWeightSelected(0.0)
	{
	}


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	const FinalState fs(-3.2, 3.2);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	// Create a final state with any e+e- or mu+mu- pair with
	// invariant mass 76 -> 106 GeV and ET > 18 (Z decay products)
	vector<pair<PdgId,PdgId> > vids;
	vids.push_back(make_pair(PID::ELECTRON, PID::POSITRON));
	vids.push_back(make_pair(PID::MUON, PID::ANTIMUON));
	FinalState fs2(-3.2, 3.2);
	InvMassFinalState invfs(fs2, vids, 76GeV, 106GeV);
	- addProjection(invfs, "INVFS");
	+ declare(invfs, "INVFS");
	// Make a final state without the Z decay products for jet clustering
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(invfs);
	- addProjection(vfs, "VFS");
	- addProjection(FastJets(vfs, FastJets::CDFMIDPOINT, 0.7), "Jets");
	+ declare(vfs, "VFS");
	+ declare(FastJets(vfs, FastJets::CDFMIDPOINT, 0.7), "Jets");

	// Book histograms
	_dStot = bookHisto1D(1, 1, 1);
	_dSdET = bookHisto1D(2, 1, 1);
	_dSdETA = bookHisto1D(3, 1, 1);
	_dSdZpT = bookHisto1D(4, 1, 1);
	_dSdNJet = bookHisto1D(5, 1, 1);
	_dSdNbJet = bookHisto1D(6, 1, 1);
	}


	// Do the analysis
	void analyze(const Event& event) {
	// Check we have an l+l- pair that passes the kinematic cuts
	// Get the Z decay products (mu+mu- or e+e- pair)
	- const InvMassFinalState& invMassFinalState = applyProjection<InvMassFinalState>(event, "INVFS");
	+ const InvMassFinalState& invMassFinalState = apply<InvMassFinalState>(event, "INVFS");
	const Particles& ZDecayProducts = invMassFinalState.particles();

	// make sure we have 2 Z decay products (mumu or ee)
	if (ZDecayProducts.size() < 2) vetoEvent;
	//new cuts
	double Lep1Pt = ZDecayProducts[0].perp();
	double Lep2Pt = ZDecayProducts[1].perp();
	double Lep1Eta = fabs(ZDecayProducts[0].rapidity());
	double Lep2Eta = fabs(ZDecayProducts[1].rapidity());

	if (Lep1Eta > _LepEtaCut \|\| Lep2Eta > _LepEtaCut) vetoEvent;

	if (ZDecayProducts[0].abspid()==13 &&
	((Lep1Eta > 1.5 \|\| Lep2Eta > 1.5) \|\| (Lep1Eta > 1.0 && Lep2Eta > 1.0))) {
	vetoEvent;
	}

	if (Lep1Pt > Lep2Pt) {
	if (Lep1Pt < _Lep1PtCut \|\| Lep2Pt < _Lep2PtCut) vetoEvent;
	}
	else {
	if (Lep1Pt < _Lep2PtCut \|\| Lep2Pt < _Lep1PtCut) vetoEvent;
	}

	_sumWeightSelected += event.weight();
	/// @todo: write out a warning if there are more than two decay products
	FourMomentum Zmom = ZDecayProducts[0].momentum() + ZDecayProducts[1].momentum();

	// Put all b-quarks in a vector
	/// @todo Use a b-hadron search rather than b-quarks for tagging
	Particles bquarks;
	foreach (const GenParticle* p, particles(event.genEvent())) {
	if (std::abs(p->pdg_id()) == PID::BQUARK) {
	bquarks += Particle(*p);
	}
	}

	// Get jets
	- const FastJets& jetpro = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(event, "Jets");
	MSG_DEBUG("Jet multiplicity before any pT cut = " << jetpro.size());

	const PseudoJets& jets = jetpro.pseudoJetsByPt();
	MSG_DEBUG("jetlist size = " << jets.size());

	int numBJet = 0;
	int numJet = 0;
	// for each b-jet plot the ET and the eta of the jet, normalise to the total cross section at the end
	// for each event plot N jet and pT(Z), normalise to the total cross section at the end
	for (PseudoJets::const_iterator jt = jets.begin(); jt != jets.end(); ++jt) {
	// select jets that pass the kinematic cuts
	if (jt->perp() > _JetPtCut && fabs(jt->rapidity()) <= _JetEtaCut) {
	numJet++;
	// does the jet contain a b-quark?
	bool bjet = false;
	foreach (const Particle& bquark, bquarks) {
	if (deltaR(jt->rapidity(), jt->phi(), bquark.rapidity(),bquark.phi()) <= _Rjet) {
	bjet = true;
	break;
	}
	} // end loop around b-jets
	if (bjet) {
	numBJet++;
	_dSdET->fill(jt->perp(),event.weight());
	_dSdETA->fill(fabs(jt->rapidity()),event.weight());
	}
	}
	} // end loop around jets

	// wasn't asking for b-jets before!!!!
	if(numJet > 0 && numBJet > 0) _dSdNJet->fill(numJet,event.weight());
	if(numBJet > 0) {
	_dStot->fill(1960.0,event.weight());
	_dSdNbJet->fill(numBJet,event.weight());
	_dSdZpT->fill(Zmom.pT(),event.weight());
	}
	}



	// Finalize
	void finalize() {
	// normalise histograms
	// scale by 1 / the sum-of-weights of events that pass the Z cuts
	// since the cross sections are normalized to the inclusive
	// Z cross sections.
	double Scale = 1.0;
	if (_sumWeightSelected != 0.0) Scale = 1.0/_sumWeightSelected;
	scale(_dStot,Scale);
	scale(_dSdET,Scale);
	scale(_dSdETA,Scale);
	scale(_dSdNJet,Scale);
	scale(_dSdNbJet,Scale);
	scale(_dSdZpT,Scale);
	}

	//@}


	private:

	double _Rjet;
	double _JetPtCut;
	double _JetEtaCut;
	double _Lep1PtCut;
	double _Lep2PtCut;
	double _LepEtaCut;
	double _sumWeightSelected;

	//@{
	/// Histograms
	Histo1DPtr _dStot;
	Histo1DPtr _dSdET;
	Histo1DPtr _dSdETA;
	Histo1DPtr _dSdNJet;
	Histo1DPtr _dSdNbJet;
	Histo1DPtr _dSdZpT;

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2008_S8095620);

	}
	diff --git a/src/Analyses/CDF_2009_S8383952.cc b/src/Analyses/CDF_2009_I856131.cc
	rename from src/Analyses/CDF_2009_S8383952.cc
	rename to src/Analyses/CDF_2009_I856131.cc
	--- a/src/Analyses/CDF_2009_S8383952.cc
	+++ b/src/Analyses/CDF_2009_I856131.cc
	@@ -1,87 +1,87 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	/// @brief CDF Z boson rapidity measurement
	- class CDF_2009_S8383952 : public Analysis {
	+ class CDF_2009_I856131 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	- CDF_2009_S8383952()
	- : Analysis("CDF_2009_S8383952")
	+ CDF_2009_I856131()
	+ : Analysis("CDF_2009_I856131")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections here
	// this seems to have been corrected completely for all selection cuts,
	// i.e. eta cuts and pT cuts on leptons.
	ZFinder zfinder(FinalState(), Cuts::open(), PID::ELECTRON,
	66GeV, 116GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");


	/// Book histograms here
	_h_xs = bookHisto1D(1, 1, 1);
	_h_yZ = bookHisto1D(2, 1, 1);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");
	if (zfinder.bosons().size() == 1) {
	const double weight = event.weight();
	_h_yZ->fill(fabs(zfinder.bosons()[0].rapidity()), weight);
	_h_xs->fill(1960, weight);
	} else {
	MSG_DEBUG("no unique lepton pair found.");
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_xs, crossSection()/sumOfWeights());
	// Data seems to have been normalized for the avg of the two sides
	// (+ve & -ve rapidity) rather than the sum, hence the 0.5:
	scale(_h_yZ, 0.5*crossSection()/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_yZ;
	Histo1DPtr _h_xs;
	//@}

	};



	// The hook for the plugin system
	- DECLARE_RIVET_PLUGIN(CDF_2009_S8383952);
	+ DECLARE_RIVET_PLUGIN(CDF_2009_I856131);

	}
	diff --git a/src/Analyses/CDF_2009_NOTE_9936.cc b/src/Analyses/CDF_2009_NOTE_9936.cc
	--- a/src/Analyses/CDF_2009_NOTE_9936.cc
	+++ b/src/Analyses/CDF_2009_NOTE_9936.cc
	@@ -1,72 +1,72 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/TriggerCDFRun2.hh"

	namespace Rivet {


	class CDF_2009_NOTE_9936 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CDF_2009_NOTE_9936()
	: Analysis("CDF_2009_NOTE_9936")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	- addProjection(TriggerCDFRun2(), "Trigger");
	+ declare(TriggerCDFRun2(), "Trigger");

	- addProjection(ChargedFinalState(-1.0, 1.0, 0.4*GeV), "CFS");
	+ declare(ChargedFinalState(-1.0, 1.0, 0.4*GeV), "CFS");

	_hist_nch = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	// MinBias Trigger
	- const bool trigger = applyProjection<TriggerCDFRun2>(event, "Trigger").minBiasDecision();
	+ const bool trigger = apply<TriggerCDFRun2>(event, "Trigger").minBiasDecision();
	if (!trigger) vetoEvent;
	//_sumWPassed += event.weight();
	const double weight = event.weight();

	// Get events charged multiplicity and fill histogram
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	_hist_nch->fill(cfs.size(), weight);

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	normalize(_hist_nch);
	}

	//@}

	private:

	Histo1DPtr _hist_nch;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2009_NOTE_9936);

	}
	diff --git a/src/Analyses/CDF_2009_S8057893.cc b/src/Analyses/CDF_2009_S8057893.cc
	--- a/src/Analyses/CDF_2009_S8057893.cc
	+++ b/src/Analyses/CDF_2009_S8057893.cc
	@@ -1,87 +1,87 @@
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF in-jet kT distribution analysis
	/// @todo Finish!
	class CDF_2009_S8057893 : public Analysis {
	public:

	/// Constructor
	CDF_2009_S8057893::CDF_2009_S8057893()
	: Analysis("CDF_2009_S8057893")
	{
	}


	/// @name Analysis methods
	//@{

	void CDF_2009_S8057893::init() {
	const FinalState fsj(-4.0, 4.0, 0.0*GeV);
	- addProjection(fsj, "FSJ");
	- addProjection(FastJets(fsj, FastJets::CDFMIDPOINT, 1.0), "Jets");
	+ declare(fsj, "FSJ");
	+ declare(FastJets(fsj, FastJets::CDFMIDPOINT, 1.0), "Jets");
	}


	void CDF_2009_S8057893::analyze(const Event& event) {
	- const FastJets& jetpro = applyProjection<FastJets>(e, "MidpointJets");
	+ const FastJets& jetpro = apply<FastJets>(e, "MidpointJets");
	const Jets& jets = jetpro.jetsByPt();
	MSG_DEBUG("Jet multiplicity = " << jets.size());
	if (jets.size() < 1) {
	MSG_DEBUG("Failed jet multiplicity cut");
	vetoEvent;
	}

	// Email sent to authors:
	// Okay, so here are the questions:

	// * What \|eta\| and pT_min acceptance cuts were used?
	// * Is the "cone algorithm" JETCLU or MIDPOINT? You refer to the old 1992 paper that defines
	// JETCLU, but I thought Run II analyses were using the more IRC-safe midpoint algorithm.
	// * Effective min j1, j2 Et values?
	// * Definition of "require the two leading jets to be well-balanced in Et"?
	// * Definition of the complementary cones: per-jet for j1, j2? Otherwise, what is defn of
	// "dijet axis" (since the two jet axes will not exactly match due to ISR and extra jets.)
	// Complementary cones are same eta as jet, but phi +- 90 degrees? Radius of compl. cones
	// = 1.0? Or defined in theta_c (not Lorentz invariant)?
	// * kT of tracks rel to jet axis for all jets, j1 & j2, or just j1?

	// Herwig missing from plots!
	// Data tables? More dijet mass bins (only 3 are shown, but 8 are mentioned)


	// Only use tracks with kT > 0.3 GeV

	// Low histo limit: kT_jet > 0.5 GeV

	// Opening cone theta_c = 0.5 rad (in dijet rest frame)

	// 95 < Mjj < 132 GeV
	// 243 < Mjj < 323 GeV
	// 428 < Mjj < 563 GeV
	// < Mjj < GeV
	// < Mjj < GeV
	// < Mjj < GeV
	// < Mjj < GeV
	// < Mjj < GeV
	}


	void CDF_2009_S8057893::finalize() {

	}

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2009_S8057893);

	}
	diff --git a/src/Analyses/CDF_2009_S8233977.cc b/src/Analyses/CDF_2009_S8233977.cc
	--- a/src/Analyses/CDF_2009_S8233977.cc
	+++ b/src/Analyses/CDF_2009_S8233977.cc
	@@ -1,124 +1,124 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/TriggerCDFRun2.hh"

	namespace Rivet {


	/// @brief CDF Run II min-bias cross-section
	/// @author Hendrik Hoeth
	///
	/// Measurement of \f$ \langle p_T \rangle \f$ vs. \f$ n_\text{ch} \f$,
	/// the track \f$ p_T \f$ distribution, and the \f$ \sum E_T \f$ distribution.
	/// Particles are selected within \|eta\|<1 and with pT>0.4 GeV.
	/// There is no pT cut for the \f$ \sum E_T \f$ measurement.
	///
	/// @par Run conditions
	///
	/// @arg \f$ \sqrt{s} = \f$ 1960 GeV
	/// @arg Run with generic QCD events.
	/// @arg Set particles with c*tau > 10 mm stable
	class CDF_2009_S8233977 : public Analysis {
	public:

	/// Constructor
	CDF_2009_S8233977()
	: Analysis("CDF_2009_S8233977"),
	_sumWeightSelected(0.0)
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and projections
	void init() {
	- addProjection(TriggerCDFRun2(), "Trigger");
	- addProjection(FinalState(-1.0, 1.0, 0.0*GeV), "EtFS");
	- addProjection(ChargedFinalState(-1.0, 1.0, 0.4*GeV), "CFS");
	+ declare(TriggerCDFRun2(), "Trigger");
	+ declare(FinalState(-1.0, 1.0, 0.0*GeV), "EtFS");
	+ declare(ChargedFinalState(-1.0, 1.0, 0.4*GeV), "CFS");

	_hist_pt = bookHisto1D(1, 1, 1);
	_hist_pt_vs_multiplicity = bookProfile1D(2, 1, 1);
	_hist_sumEt = bookHisto1D(3, 1, 1);
	}



	/// Do the analysis
	void analyze(const Event& evt) {
	// MinBias Trigger
	- const bool trigger = applyProjection<TriggerCDFRun2>(evt, "Trigger").minBiasDecision();
	+ const bool trigger = apply<TriggerCDFRun2>(evt, "Trigger").minBiasDecision();
	if (!trigger) vetoEvent;

	// Get the event weight
	const double weight = evt.weight();

	/// @todo The pT and sum(ET) distributions look slightly different from
	/// Niccolo's Monte Carlo plots. Still waiting for his answer.

	- const ChargedFinalState& trackfs = applyProjection<ChargedFinalState>(evt, "CFS");
	+ const ChargedFinalState& trackfs = apply<ChargedFinalState>(evt, "CFS");
	const size_t numParticles = trackfs.size();
	foreach (const Particle& p, trackfs.particles()) {
	const double pT = p.pT() / GeV;
	_hist_pt_vs_multiplicity->fill(numParticles, pT, weight);

	// The weight for entries in the pT distribution should be weight/(pTdPhidy).
	//
	// - dPhi = 2*PI
	//
	// - dy depends on the pT: They calculate y assuming the particle has the
	// pion mass and assuming that eta=1:
	// dy = 2 * 1/2 * ln [(sqrt(m^2 + (a+1)pT^2) + apT) / (sqrt(m^2 + (a+1)pT^2) - apT)]
	// with a = sinh(1).
	//
	// sinh(1) = 1.1752012
	// m(charged pion)^2 = (139.57 MeV)^2 = 0.019479785 GeV^2
	const double sinh1 = 1.1752012;
	const double apT = sinh1 * pT;
	const double mPi = 139.57*MeV;
	const double root = sqrt(mPimPi + (1+sinh1)pT*pT);
	const double dy = std::log((root+apT)/(root-apT));
	const double dphi = TWOPI;
	_hist_pt->fill(pT, weight/(pTdphidy));
	}

	// Calc sum(Et) from calo particles
	- const FinalState& etfs = applyProjection<FinalState>(evt, "EtFS");
	+ const FinalState& etfs = apply<FinalState>(evt, "EtFS");
	double sumEt = 0.0;
	foreach (const Particle& p, etfs.particles()) {
	sumEt += p.Et();
	}
	_hist_sumEt->fill(sumEt, weight);
	_sumWeightSelected += evt.weight();
	}



	/// Normalize histos
	void finalize() {
	scale(_hist_sumEt, crossSection()/millibarn/(4M_PI_sumWeightSelected));
	scale(_hist_pt, crossSection()/millibarn/_sumWeightSelected);
	MSG_DEBUG("sumOfWeights() = " << sumOfWeights());
	MSG_DEBUG("_sumWeightSelected = " << _sumWeightSelected);
	}

	//@}


	private:

	double _sumWeightSelected;
	Profile1DPtr _hist_pt_vs_multiplicity;
	Histo1DPtr _hist_pt;
	Histo1DPtr _hist_sumEt;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2009_S8233977);

	}
	diff --git a/src/Analyses/CDF_2009_S8436959.cc b/src/Analyses/CDF_2009_S8436959.cc
	--- a/src/Analyses/CDF_2009_S8436959.cc
	+++ b/src/Analyses/CDF_2009_S8436959.cc
	@@ -1,89 +1,89 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"

	namespace Rivet {


	/// @brief CDF inclusive isolated prompt photon cross-section
	class CDF_2009_S8436959 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CDF_2009_S8436959()
	: Analysis("CDF_2009_S8436959")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	LeadingParticlesFinalState photonfs(FinalState(-1.0, 1.0, 30.0*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	_h_Et_photon = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- Particles fs = applyProjection<FinalState>(event, "FS").particles();
	- Particles photons = applyProjection<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	+ Particles fs = apply<FinalState>(event, "FS").particles();
	+ Particles photons = apply<LeadingParticlesFinalState>(event, "LeadingPhoton").particles();
	if (photons.size()!=1) {
	vetoEvent;
	}
	FourMomentum leadingPhoton = photons[0].momentum();
	double eta_P = leadingPhoton.eta();
	double phi_P = leadingPhoton.phi();
	FourMomentum mom_in_cone;
	foreach (const Particle& p, fs) {
	if (deltaR(eta_P, phi_P, p.eta(), p.phi()) < 0.4) {
	mom_in_cone += p.momentum();
	}
	}
	if ( (mom_in_cone.Et() - leadingPhoton.Et()) > 2.0*GeV) {
	vetoEvent;
	}
	_h_Et_photon->fill(leadingPhoton.Et(), weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_Et_photon, crossSection()/sumOfWeights()/2.0);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_Et_photon;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2009_S8436959);

	}
	diff --git a/src/Analyses/CDF_2010_S8591881_DY.cc b/src/Analyses/CDF_2010_S8591881_DY.cc
	--- a/src/Analyses/CDF_2010_S8591881_DY.cc
	+++ b/src/Analyses/CDF_2010_S8591881_DY.cc
	@@ -1,212 +1,212 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/ChargedLeptons.hh"

	namespace Rivet {




	/// @brief CDF Run II underlying event in Drell-Yan
	/// @author Hendrik Hoeth
	///
	/// Measurement of the underlying event in Drell-Yan
	/// \f$ Z/\gamma^* \to e^+ e^- \f$ and
	/// \f$ Z/\gamma^* \to \mu^+ \mu^- \f$ events. The reconstructed
	/// Z defines the \f$ \phi \f$ orientation. A Z mass window cut is applied.
	///
	/// @par Run conditions
	///
	/// @arg \f$ \sqrt{s} = \f$ 1960 GeV
	/// @arg produce Drell-Yan events
	/// @arg Set particles with c*tau > 10 mm stable
	/// @arg Z decay mode: Z -> e+e- and Z -> mu+mu-
	/// @arg gamma decay mode: gamma -> e+e- and gamma -> mu+mu-
	/// @arg minimum invariant mass of the fermion pair coming from the Z/gamma: 70 GeV
	class CDF_2010_S8591881_DY : public Analysis {
	public:

	/// Constructor
	CDF_2010_S8591881_DY() : Analysis("CDF_2010_S8591881_DY")
	{
	}


	/// @name Analysis methods
	//@{

	void init() {
	// Set up projections
	const ChargedFinalState cfs(-1.0, 1.0, 0.5*GeV);
	const ChargedFinalState clfs(-1.0, 1.0, 20*GeV);
	- addProjection(cfs, "FS");
	- addProjection(ChargedLeptons(clfs), "CL");
	+ declare(cfs, "FS");
	+ declare(ChargedLeptons(clfs), "CL");

	// Book histograms
	_hist_tnchg = bookProfile1D( 1, 1, 1);
	_hist_pnchg = bookProfile1D( 1, 1, 2);
	_hist_anchg = bookProfile1D( 1, 1, 3);
	_hist_pmaxnchg = bookProfile1D( 2, 1, 1);
	_hist_pminnchg = bookProfile1D( 2, 1, 2);
	_hist_pdifnchg = bookProfile1D( 2, 1, 3);
	_hist_tcptsum = bookProfile1D( 3, 1, 1);
	_hist_pcptsum = bookProfile1D( 3, 1, 2);
	_hist_acptsum = bookProfile1D( 3, 1, 3);
	_hist_pmaxcptsum = bookProfile1D( 4, 1, 1);
	_hist_pmincptsum = bookProfile1D( 4, 1, 2);
	_hist_pdifcptsum = bookProfile1D( 4, 1, 3);
	_hist_tcptave = bookProfile1D( 5, 1, 1);
	_hist_pcptave = bookProfile1D( 5, 1, 2);
	_hist_tcptmax = bookProfile1D( 6, 1, 1);
	_hist_pcptmax = bookProfile1D( 6, 1, 2);
	_hist_zptvsnchg = bookProfile1D( 7, 1, 1);
	_hist_cptavevsnchg = bookProfile1D( 8, 1, 1);
	_hist_cptavevsnchgsmallzpt = bookProfile1D( 9, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& e) {

	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 1) {
	MSG_DEBUG("Failed multiplicity cut");
	vetoEvent;
	}

	// Get the event weight
	const double weight = e.weight();

	// Get the leptons
	- const Particles& leptons = applyProjection<ChargedLeptons>(e, "CL").chargedLeptons();
	+ const Particles& leptons = apply<ChargedLeptons>(e, "CL").chargedLeptons();

	// We want exactly two leptons of the same flavour.
	MSG_DEBUG("lepton multiplicity = " << leptons.size());
	if (leptons.size() != 2 \|\| leptons[0].pid() != -leptons[1].pid() ) vetoEvent;

	// Lepton pT > 20 GeV
	if (leptons[0].pT()/GeV <= 20 \|\| leptons[1].pT()/GeV <= 20) vetoEvent;

	// Lepton pair should have an invariant mass between 70 and 110 and \|eta\| < 6
	const FourMomentum dilepton = leptons[0].momentum() + leptons[1].momentum();
	if (!inRange(dilepton.mass()/GeV, 70., 110.) \|\| fabs(dilepton.eta()) >= 6) vetoEvent;
	MSG_DEBUG("Dilepton mass = " << dilepton.mass()/GeV << " GeV");
	MSG_DEBUG("Dilepton pT = " << dilepton.pT()/GeV << " GeV");

	// Calculate the observables
	size_t numToward(0), numAway(0);
	long int numTrans1(0), numTrans2(0);
	double ptSumToward(0.0), ptSumTrans1(0.0), ptSumTrans2(0.0), ptSumAway(0.0);
	double ptMaxToward(0.0), ptMaxTrans1(0.0), ptMaxTrans2(0.0), ptMaxAway(0.0);
	const double phiZ = dilepton.azimuthalAngle();
	const double pTZ = dilepton.pT();
	/// @todo Replace with foreach
	for (Particles::const_iterator p = fs.particles().begin(); p != fs.particles().end(); ++p) {
	// Don't use the leptons
	/// @todo Replace with PID::isLepton
	if (abs(p->pid()) < 20) continue;

	const double dPhi = deltaPhi(p->momentum().phi(), phiZ);
	const double pT = p->pT();
	double rotatedphi = p->momentum().phi() - phiZ;
	while (rotatedphi < 0) rotatedphi += 2*PI;

	if (dPhi < PI/3.0) {
	ptSumToward += pT;
	++numToward;
	if (pT > ptMaxToward)
	ptMaxToward = pT;
	} else if (dPhi < 2*PI/3.0) {
	if (rotatedphi <= PI) {
	ptSumTrans1 += pT;
	++numTrans1;
	if (pT > ptMaxTrans1)
	ptMaxTrans1 = pT;
	}
	else {
	ptSumTrans2 += pT;
	++numTrans2;
	if (pT > ptMaxTrans2)
	ptMaxTrans2 = pT;
	}
	} else {
	ptSumAway += pT;
	++numAway;
	if (pT > ptMaxAway)
	ptMaxAway = pT;
	}
	// We need to subtract the two leptons from the number of particles to get the correct multiplicity
	_hist_cptavevsnchg->fill(numParticles-2, pT, weight);
	if (pTZ < 10)
	_hist_cptavevsnchgsmallzpt->fill(numParticles-2, pT, weight);
	}

	// Fill the histograms
	_hist_tnchg->fill(pTZ, numToward/(4*PI/3), weight);
	_hist_pnchg->fill(pTZ, (numTrans1+numTrans2)/(4*PI/3), weight);
	_hist_pmaxnchg->fill(pTZ, (numTrans1>numTrans2 ? numTrans1 : numTrans2)/(2*PI/3), weight);
	_hist_pminnchg->fill(pTZ, (numTrans1<numTrans2 ? numTrans1 : numTrans2)/(2*PI/3), weight);
	_hist_pdifnchg->fill(pTZ, abs(numTrans1-numTrans2)/(2*PI/3), weight);
	_hist_anchg->fill(pTZ, numAway/(4*PI/3), weight);

	_hist_tcptsum->fill(pTZ, ptSumToward/(4*PI/3), weight);
	_hist_pcptsum->fill(pTZ, (ptSumTrans1+ptSumTrans2)/(4*PI/3), weight);
	_hist_pmaxcptsum->fill(pTZ, (ptSumTrans1>ptSumTrans2 ? ptSumTrans1 : ptSumTrans2)/(2*PI/3), weight);
	_hist_pmincptsum->fill(pTZ, (ptSumTrans1<ptSumTrans2 ? ptSumTrans1 : ptSumTrans2)/(2*PI/3), weight);
	_hist_pdifcptsum->fill(pTZ, fabs(ptSumTrans1-ptSumTrans2)/(2*PI/3), weight);
	_hist_acptsum->fill(pTZ, ptSumAway/(4*PI/3), weight);

	if (numToward > 0) {
	_hist_tcptave->fill(pTZ, ptSumToward/numToward, weight);
	_hist_tcptmax->fill(pTZ, ptMaxToward, weight);
	}
	if ((numTrans1+numTrans2) > 0) {
	_hist_pcptave->fill(pTZ, (ptSumTrans1+ptSumTrans2)/(numTrans1+numTrans2), weight);
	_hist_pcptmax->fill(pTZ, (ptMaxTrans1 > ptMaxTrans2 ? ptMaxTrans1 : ptMaxTrans2), weight);
	}

	// We need to subtract the two leptons from the number of particles to get the correct multiplicity
	_hist_zptvsnchg->fill(numParticles-2, pTZ, weight);
	}


	void finalize() {
	}

	//@}


	private:

	Profile1DPtr _hist_tnchg;
	Profile1DPtr _hist_pnchg;
	Profile1DPtr _hist_pmaxnchg;
	Profile1DPtr _hist_pminnchg;
	Profile1DPtr _hist_pdifnchg;
	Profile1DPtr _hist_anchg;
	Profile1DPtr _hist_tcptsum;
	Profile1DPtr _hist_pcptsum;
	Profile1DPtr _hist_pmaxcptsum;
	Profile1DPtr _hist_pmincptsum;
	Profile1DPtr _hist_pdifcptsum;
	Profile1DPtr _hist_acptsum;
	Profile1DPtr _hist_tcptave;
	Profile1DPtr _hist_pcptave;
	Profile1DPtr _hist_tcptmax;
	Profile1DPtr _hist_pcptmax;
	Profile1DPtr _hist_zptvsnchg;
	Profile1DPtr _hist_cptavevsnchg;
	Profile1DPtr _hist_cptavevsnchgsmallzpt;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2010_S8591881_DY);

	}
	diff --git a/src/Analyses/CDF_2010_S8591881_QCD.cc b/src/Analyses/CDF_2010_S8591881_QCD.cc
	--- a/src/Analyses/CDF_2010_S8591881_QCD.cc
	+++ b/src/Analyses/CDF_2010_S8591881_QCD.cc
	@@ -1,193 +1,193 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief CDF Run II underlying event in leading jet events
	/// @author Hendrik Hoeth
	///
	/// Rick Field's measurement of the underlying event in "leading jet" events.
	/// The leading jet (CDF midpoint \f$ R = 0.7 \f$) must be within \f$\|\eta\| < 2 \f$
	/// and defines the "toward" phi direction. Particles are selected in
	/// \f$ \|\eta\| < 1 \f$. For the \f$ p_\perp \f$-related observables there
	/// is a \f$ p_\perp > 0.5 \f$ GeV cut. For \f$ \sum E_\perp \f$ there is no
	/// \f$ p_\perp \f$ cut.
	///
	/// @par Run conditions
	/// @arg \f$ \sqrt{s} = \f$ 1960 GeV
	/// @arg Run with generic QCD events.
	/// @arg Set particles with c*tau > 10 mm stable
	/// @arg Several \f$ p_\perp^\text{min} \f$ cutoffs are probably required to fill the profile histograms:
	/// @arg \f$ p_\perp^\text{min} = \f$ 0 (min bias), 10, 20, 50, 100, 150 GeV
	/// @arg The corresponding merging points are at \f$ p_T = \f$ 0, 30, 50, 80, 130, 180 GeV
	class CDF_2010_S8591881_QCD : public Analysis {
	public:

	/// Constructor
	CDF_2010_S8591881_QCD()
	: Analysis("CDF_2010_S8591881_QCD")
	{
	}


	/// @name Analysis methods
	//@{

	void init() {
	// Final state for the jet finding
	const FinalState fsj(-4.0, 4.0, 0.0*GeV);
	- addProjection(fsj, "FSJ");
	- addProjection(FastJets(fsj, FastJets::CDFMIDPOINT, 0.7), "MidpointJets");
	+ declare(fsj, "FSJ");
	+ declare(FastJets(fsj, FastJets::CDFMIDPOINT, 0.7), "MidpointJets");

	// Charged final state for the distributions
	const ChargedFinalState cfs(-1.0, 1.0, 0.5*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	// Book histograms
	_hist_tnchg = bookProfile1D(10, 1, 1);
	_hist_pnchg = bookProfile1D(10, 1, 2);
	_hist_anchg = bookProfile1D(10, 1, 3);
	_hist_pmaxnchg = bookProfile1D(11, 1, 1);
	_hist_pminnchg = bookProfile1D(11, 1, 2);
	_hist_pdifnchg = bookProfile1D(11, 1, 3);
	_hist_tcptsum = bookProfile1D(12, 1, 1);
	_hist_pcptsum = bookProfile1D(12, 1, 2);
	_hist_acptsum = bookProfile1D(12, 1, 3);
	_hist_pmaxcptsum = bookProfile1D(13, 1, 1);
	_hist_pmincptsum = bookProfile1D(13, 1, 2);
	_hist_pdifcptsum = bookProfile1D(13, 1, 3);
	_hist_pcptave = bookProfile1D(14, 1, 1);
	_hist_pcptmax = bookProfile1D(15, 1, 1);
	}


	// Do the analysis
	void analyze(const Event& e) {
	/// @todo Implement Run II min bias trigger cf. CDF_2009?

	- const FinalState& fsj = applyProjection<FinalState>(e, "FSJ");
	+ const FinalState& fsj = apply<FinalState>(e, "FSJ");
	if (fsj.particles().size() < 1) {
	MSG_DEBUG("Failed multiplicity cut");
	vetoEvent;
	}

	- const Jets& jets = applyProjection<FastJets>(e, "MidpointJets").jetsByPt();
	+ const Jets& jets = apply<FastJets>(e, "MidpointJets").jetsByPt();
	MSG_DEBUG("Jet multiplicity = " << jets.size());

	// We require the leading jet to be within \|eta\|<2
	if (jets.size() < 1 \|\| fabs(jets[0].eta()) >= 2) {
	MSG_DEBUG("Failed leading jet cut");
	vetoEvent;
	}

	const double jetphi = jets[0].phi();
	const double jeteta = jets[0].eta();
	const double jetpT = jets[0].pT();
	MSG_DEBUG("Leading jet: pT = " << jetpT
	<< ", eta = " << jeteta << ", phi = " << jetphi);

	// Get the event weight
	const double weight = e.weight();

	// Get the final states to work with for filling the distributions
	- const FinalState& cfs = applyProjection<ChargedFinalState>(e, "CFS");
	+ const FinalState& cfs = apply<ChargedFinalState>(e, "CFS");

	size_t numOverall(0), numToward(0), numAway(0) ;
	long int numTrans1(0), numTrans2(0);
	double ptSumOverall(0.0), ptSumToward(0.0), ptSumTrans1(0.0), ptSumTrans2(0.0), ptSumAway(0.0);
	double ptMaxOverall(0.0), ptMaxToward(0.0), ptMaxTrans1(0.0), ptMaxTrans2(0.0), ptMaxAway(0.0);

	// Calculate all the charged stuff
	foreach (const Particle& p, cfs.particles()) {
	const double dPhi = deltaPhi(p.phi(), jetphi);
	const double pT = p.pT();
	const double phi = p.phi();
	double rotatedphi = phi - jetphi;
	while (rotatedphi < 0) rotatedphi += 2*PI;

	ptSumOverall += pT;
	++numOverall;
	if (pT > ptMaxOverall) {
	ptMaxOverall = pT;
	}

	if (dPhi < PI/3.0) {
	ptSumToward += pT;
	++numToward;
	if (pT > ptMaxToward) ptMaxToward = pT;
	}
	else if (dPhi < 2*PI/3.0) {
	if (rotatedphi <= PI) {
	ptSumTrans1 += pT;
	++numTrans1;
	if (pT > ptMaxTrans1) ptMaxTrans1 = pT;
	} else {
	ptSumTrans2 += pT;
	++numTrans2;
	if (pT > ptMaxTrans2) ptMaxTrans2 = pT;
	}
	}
	else {
	ptSumAway += pT;
	++numAway;
	if (pT > ptMaxAway) ptMaxAway = pT;
	}
	} // end charged particle loop

	// Fill the histograms
	_hist_tnchg->fill(jetpT/GeV, numToward/(4*PI/3), weight);
	_hist_pnchg->fill(jetpT/GeV, (numTrans1+numTrans2)/(4*PI/3), weight);
	_hist_pmaxnchg->fill(jetpT/GeV, (numTrans1>numTrans2 ? numTrans1 : numTrans2)/(2*PI/3), weight);
	_hist_pminnchg->fill(jetpT/GeV, (numTrans1<numTrans2 ? numTrans1 : numTrans2)/(2*PI/3), weight);
	_hist_pdifnchg->fill(jetpT/GeV, abs(numTrans1-numTrans2)/(2*PI/3), weight);
	_hist_anchg->fill(jetpT/GeV, numAway/(4*PI/3), weight);

	_hist_tcptsum->fill(jetpT/GeV, ptSumToward/GeV/(4*PI/3), weight);
	_hist_pcptsum->fill(jetpT/GeV, (ptSumTrans1+ptSumTrans2)/GeV/(4*PI/3), weight);
	_hist_pmaxcptsum->fill(jetpT/GeV, (ptSumTrans1>ptSumTrans2 ? ptSumTrans1 : ptSumTrans2)/GeV/(2*PI/3), weight);
	_hist_pmincptsum->fill(jetpT/GeV, (ptSumTrans1<ptSumTrans2 ? ptSumTrans1 : ptSumTrans2)/GeV/(2*PI/3), weight);
	_hist_pdifcptsum->fill(jetpT/GeV, fabs(ptSumTrans1-ptSumTrans2)/GeV/(2*PI/3), weight);
	_hist_acptsum->fill(jetpT/GeV, ptSumAway/GeV/(4*PI/3), weight);

	if ((numTrans1+numTrans2) > 0) {
	_hist_pcptave->fill(jetpT/GeV, (ptSumTrans1+ptSumTrans2)/GeV/(numTrans1+numTrans2), weight);
	_hist_pcptmax->fill(jetpT/GeV, (ptMaxTrans1 > ptMaxTrans2 ? ptMaxTrans1 : ptMaxTrans2)/GeV, weight);
	}
	}


	void finalize() {
	}

	//@}


	private:

	Profile1DPtr _hist_tnchg;
	Profile1DPtr _hist_pnchg;
	Profile1DPtr _hist_anchg;
	Profile1DPtr _hist_pmaxnchg;
	Profile1DPtr _hist_pminnchg;
	Profile1DPtr _hist_pdifnchg;
	Profile1DPtr _hist_tcptsum;
	Profile1DPtr _hist_pcptsum;
	Profile1DPtr _hist_acptsum;
	Profile1DPtr _hist_pmaxcptsum;
	Profile1DPtr _hist_pmincptsum;
	Profile1DPtr _hist_pdifcptsum;
	Profile1DPtr _hist_pcptave;
	Profile1DPtr _hist_pcptmax;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2010_S8591881_QCD);

	}
	diff --git a/src/Analyses/CDF_2012_I1124333.cc b/src/Analyses/CDF_2012_I1124333.cc
	--- a/src/Analyses/CDF_2012_I1124333.cc
	+++ b/src/Analyses/CDF_2012_I1124333.cc
	@@ -1,86 +1,86 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {

	using namespace Cuts;

	/// @ CDF Run II Z \f$ p_\perp \f$ in Drell-Yan events
	/// @author Simone Amoroso
	class CDF_2012_I1124333 : public Analysis {
	public:

	/// Constructor
	CDF_2012_I1124333()
	: Analysis("CDF_2012_I1124333")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections here
	ZFinder zfinder(FinalState(), Cuts::open(), PID::ELECTRON, 66GeV, 116GeV, 0.0, ZFinder::NOCLUSTER);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");


	/// Book histograms here, e.g.:
	// _hist_z_xs = bookHisto1D(1, 1, 1);
	_hist_zpt = bookHisto1D(2, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	/// @todo Do the event by event analysis here
	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");
	if (zfinder.bosons().size() != 1) {
	MSG_DEBUG("Num e+ e- pairs found = " << zfinder.bosons().size());
	vetoEvent;
	}
	const FourMomentum& pZ = zfinder.bosons()[0].momentum();
	if (pZ.mass2() < 0) {
	MSG_DEBUG("Negative Z mass**2 = " << pZ.mass2()/GeV2 << "!");
	vetoEvent;
	}

	MSG_DEBUG("Dilepton mass = " << pZ.mass()/GeV << " GeV");
	_hist_zpt->fill(pZ.pT(), weight);
	// _hist_z_xs->fill(1, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_hist_zpt, crossSection()/picobarn/sumOfWeights());
	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here


	/// @name Histograms
	//@{
	Histo1DPtr _hist_zpt;
	// Histo1DPtr _hist_z_xs;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2012_I1124333);

	}
	diff --git a/src/Analyses/CDF_2012_NOTE10874.cc b/src/Analyses/CDF_2012_NOTE10874.cc
	--- a/src/Analyses/CDF_2012_NOTE10874.cc
	+++ b/src/Analyses/CDF_2012_NOTE10874.cc
	@@ -1,94 +1,94 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"



	namespace Rivet {


	class CDF_2012_NOTE10874 : public Analysis {
	public:

	CDF_2012_NOTE10874()
	: Analysis("CDF_2012_NOTE10874")
	{}


	public:

	void init() {
	const ChargedFinalState cfs(-1.0, 1.0, 0.5*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	int isqrts = -1;
	if (fuzzyEquals(sqrtS(), 300*GeV)) isqrts = 1;
	else if (fuzzyEquals(sqrtS(), 900*GeV)) isqrts = 2;
	else if (fuzzyEquals(sqrtS(), 1960*GeV)) isqrts = 3;
	assert(isqrts >= 0);

	_h_nch_transverse = bookProfile1D(1,1,isqrts);
	_h_ptSumDen = bookProfile1D(2,1,isqrts);
	_h_avePt = bookProfile1D(3,1,isqrts);
	}

	// Little helper function to identify Delta(phi) regions
	inline int region_index(double dphi) {
	assert(inRange(dphi, 0.0, PI, CLOSED, CLOSED));
	if (dphi < PI/3.0) return 0;
	if (dphi < 2*PI/3.0) return 1;
	return 2;
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	if (cfs.size() < 1) {
	vetoEvent;
	}

	Particles particles = cfs.particlesByPt();
	Particle p_lead = particles[0];
	const double philead = p_lead.phi();
	const double pTlead = p_lead.pT();

	int tNch = 0;
	double ptSum = 0.0;
	foreach (const Particle& p, particles) {
	const double pT = p.pT();
	const double dPhi = deltaPhi(philead, p.phi());
	const int ir = region_index(dPhi);
	if (ir==1) {
	tNch++;
	ptSum += pT;
	}
	}

	const double dEtadPhi = 4.0*PI/3.0;

	_h_nch_transverse->fill(pTlead/GeV, tNch/dEtadPhi, weight);
	_h_ptSumDen->fill(pTlead/GeV, ptSum/dEtadPhi, weight);

	if (tNch > 0) {
	_h_avePt->fill(pTlead/GeV, ptSum/tNch, weight);
	}
	}


	void finalize() {
	}


	private:

	Profile1DPtr _h_nch_transverse, _h_ptSumDen, _h_avePt;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CDF_2012_NOTE10874);

	}
	diff --git a/src/Analyses/CDF_2015_1388868.cc b/src/Analyses/CDF_2015_1388868.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/CDF_2015_1388868.cc
	@@ -0,0 +1,129 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief CDF leading track underlying event at 300, 900 and 1960 GeV
	+ /// @author Orestes Tumbarell Aranda (Havana), Hannes Jung (DESY)
	+ class CDF_2015_I1388868 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CDF_2015_I1388868);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Energy selection
	+ double isqrts = 0;
	+ if (fuzzyEquals(sqrtS()/GeV, 300, 1E-3)) {
	+ isqrts = 3;
	+ } else if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) {
	+ isqrts = 2;
	+ } else if (fuzzyEquals(sqrtS()/GeV, 1960, 1E-3)) {
	+ isqrts = 1;
	+ } else {
	+ throw UserError("Unexpected sqrtS ! Only 300, 900, 1960 GeV is supported by CDF_2015_I1388868");
	+ }
	+ MSG_DEBUG("CDF Tevatron UE: running with " << sqrtS()/GeV);
	+
	+ // Book projection
	+ const ChargedFinalState cfs(Cuts::abseta < 0.8 && Cuts::pT > 0.5*GeV);
	+ declare(cfs, "Tracks");
	+
	+ // Book profile histos
	+ _NchgPDFden1 = bookProfile1D(isqrts,1,1);
	+ _NchgPMNden1 = bookProfile1D(isqrts,1,2);
	+ _NchgPMXden1 = bookProfile1D(isqrts,1,3);
	+ _NchgPden1 = bookProfile1D(isqrts,1,4);
	+ _PTsumPDFden1 = bookProfile1D(isqrts,1,6);
	+ _PTsumPMNden1 = bookProfile1D(isqrts,1,7);
	+ _PTsumPMXden1 = bookProfile1D(isqrts,1,8);
	+ _PTsumPden1 = bookProfile1D(isqrts,1,9);
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Require at least one track in the event with pT >= 0.5 GeV
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "Tracks");
	+ if (cfs.empty()) vetoEvent;
	+ const Particles trks = cfs.particlesByPt();
	+
	+ // Get lead track
	+ const Particle p_lead = trks[0];
	+ const double philead = p_lead.phi();
	+ const double ptlead = p_lead.pT();
	+
	+ // Loop over tracks and compute variables
	+ double NchgP1 = 0, NchgP2 = 0, PTsumP1 = 0, PTsumP2 = 0;
	+ for (const Particle& p : trks) {
	+
	+ // Region definition -- if not in transverse region, ignore
	+ const double dphi = mapAngle0To2Pi(p.phi() - philead);
	+ if (!inRange(dphi, PI/3, 2PI/3) && !inRange(dphi, 4PI/3, 5*PI/3)) continue;
	+
	+ // Transverse region 1
	+ if (inRange(dphi, PI/3, 2*PI/3)) {
	+ NchgP1 += 1;
	+ PTsumP1 += p.pT();
	+ }
	+ // Transverse region 2
	+ else if (inRange(dphi, 4PI/3, 5PI/3)) {
	+ NchgP2 += 1;
	+ PTsumP2 += p.pT();
	+ }
	+ }
	+
	+ // Calculate total variables
	+ const double NchgPtot = (NchgP1 + NchgP2)/2;
	+ const double NchgPmax = max(NchgP1,NchgP2);
	+ const double NchgPmin = min(NchgP1,NchgP2);
	+ const double PTsumPtot = (PTsumP1 + PTsumP2)/2;
	+ const double PTsumPmax = max(PTsumP1,PTsumP2);
	+ const double PTsumPmin = min(PTsumP1,PTsumP2);
	+ //
	+ const double PTsumPMXden = PTsumPmax/AREA;
	+ const double PTsumPMNden = PTsumPmin/AREA;
	+ const double NchgPMXden = NchgPmax/AREA;
	+ const double NchgPMNden = NchgPmin/AREA;
	+ //
	+ const double NchgPDFden = NchgPMXden - NchgPMNden;
	+ const double PTsumPDFden = PTsumPMXden - PTsumPMNden;
	+
	+ // Fill histograms
	+ const double weight = event.weight();
	+ _NchgPden1 ->fill(ptlead/GeV, NchgPtot/AREA, weight );
	+ _NchgPMXden1->fill(ptlead/GeV, NchgPmax/AREA, weight );
	+ _NchgPMNden1->fill(ptlead/GeV, NchgPmin/AREA, weight );
	+ _NchgPDFden1->fill(ptlead/GeV, NchgPDFden , weight );
	+ _PTsumPden1 ->fill(ptlead/GeV, PTsumPtot/AREA, weight );
	+ _PTsumPMXden1->fill(ptlead/GeV, PTsumPmax/AREA, weight );
	+ _PTsumPMNden1->fill(ptlead/GeV, PTsumPmin/AREA, weight );
	+ _PTsumPDFden1->fill(ptlead/GeV, PTsumPDFden , weight );
	+ }
	+
	+ //@}
	+
	+
	+ /// eta-phi area of the transverse region
	+ constexpr static double AREA = 20.8 M_PI/3;
	+
	+ /// Histograms
	+ Profile1DPtr _NchgPden1, _NchgPMXden1,_NchgPMNden1,_NchgPDFden1,_PTsumPden1,_PTsumPMXden1,_PTsumPMNden1,_PTsumPDFden1;
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(CDF_2015_I1388868);
	+
	+}
	diff --git a/src/Analyses/CLEO_2004_S5809304.cc b/src/Analyses/CLEO_2004_S5809304.cc
	--- a/src/Analyses/CLEO_2004_S5809304.cc
	+++ b/src/Analyses/CLEO_2004_S5809304.cc
	@@ -1,165 +1,164 @@
	// -- C++ --
	-#include <iostream>
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief CLEO charmed mesons and baryons from fragmentation
	/// @author Peter Richardson
	class CLEO_2004_S5809304 : public Analysis {
	public:

	CLEO_2004_S5809304()
	: Analysis("CLEO_2004_S5809304")
	{ }


	void analyze(const Event& e) {
	const double weight = e.weight();

	// Loop through unstable FS particles and look for charmed mesons/baryons
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	- const Beam beamproj = applyProjection<Beam>(e, "Beams");
	+ const Beam beamproj = apply<Beam>(e, "Beams");
	const ParticlePair& beams = beamproj.beams();
	- FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	+ const FourMomentum mom_tot = beams.first.momentum() + beams.second.momentum();
	LorentzTransform cms_boost;
	- if (mom_tot.p3().mod() > 0.001)
	- cms_boost = LorentzTransform(-mom_tot.boostVector());
	+ if (mom_tot.p3().mod() > 1*MeV)
	+ cms_boost = LorentzTransform::mkFrameTransformFromBeta(mom_tot.betaVec());
	const double s = sqr(beamproj.sqrtS());

	// Particle masses from PDGlive (accessed online 16. Nov. 2009).
	foreach (const Particle& p, ufs.particles()) {

	double xp = 0.0;
	double mH2 = 0.0;
	// 3-momentum in CMS frame
	const double mom = cms_boost.transform(p.momentum()).vector3().mod();

	const int PdgId = p.abspid();
	MSG_DEBUG("pdgID = " << PdgId << " mom = " << mom);
	switch (PdgId) {

	case 421:
	MSG_DEBUG("D0 found");
	mH2 = 3.47763; // 1.86484^2
	xp = mom/sqrt(s/4.0 - mH2);
	_sigmaD0A->fill(10.6,weight);
	_sigmaD0B->fill(10.6,weight);
	_histXpD0A->fill(xp, weight);
	_histXpD0B->fill(xp, weight);
	_histXpTotal->fill(xp, weight);
	break;
	case 411:
	MSG_DEBUG("D+ found");
	mH2 = 3.49547; // 1.86962^2
	xp = mom/sqrt(s/4.0 - mH2);
	_sigmaDPlus->fill(10.6,weight);
	_histXpDplus->fill(xp, weight);
	_histXpTotal->fill(xp, weight);
	break;

	case 413:
	MSG_DEBUG("D*+ found");
	mH2 = 4.04119; // 2.01027^2
	xp = mom/sqrt(s/4.0 - mH2);
	_sigmaDStarPlusA->fill(10.6,weight);
	_sigmaDStarPlusB->fill(10.6,weight);
	_histXpDStarPlusA->fill(xp, weight);
	_histXpDStarPlusB->fill(xp, weight);
	_histXpTotal->fill(xp, weight);
	break;

	case 423:
	MSG_DEBUG("D*0 found");
	mH2 = 4.02793; // 2.00697**2
	xp = mom/sqrt(s/4.0 - mH2);
	_sigmaDStar0A->fill(10.6,weight);
	_sigmaDStar0B->fill(10.6,weight);
	_histXpDStar0A->fill(xp, weight);
	_histXpDStar0B->fill(xp, weight);
	_histXpTotal->fill(xp, weight);
	break;
	}
	}
	} // analyze


	void finalize() {

	scale(_sigmaDPlus , crossSection()/picobarn/sumOfWeights());
	scale(_sigmaD0A , crossSection()/picobarn/sumOfWeights());
	scale(_sigmaD0B , crossSection()/picobarn/sumOfWeights());
	scale(_sigmaDStarPlusA, crossSection()/picobarn/sumOfWeights());
	scale(_sigmaDStarPlusB, crossSection()/picobarn/sumOfWeights());
	scale(_sigmaDStar0A , crossSection()/picobarn/sumOfWeights());
	scale(_sigmaDStar0B , crossSection()/picobarn/sumOfWeights());

	scale(_histXpDplus , crossSection()/picobarn/sumOfWeights());
	scale(_histXpD0A , crossSection()/picobarn/sumOfWeights());
	scale(_histXpD0B , crossSection()/picobarn/sumOfWeights());
	scale(_histXpDStarPlusA, crossSection()/picobarn/sumOfWeights());
	scale(_histXpDStarPlusB, crossSection()/picobarn/sumOfWeights());
	scale(_histXpDStar0A , crossSection()/picobarn/sumOfWeights());
	scale(_histXpDStar0B , crossSection()/picobarn/sumOfWeights());
	scale(_histXpTotal , crossSection()/picobarn/sumOfWeights()/4.);
	} // finalize


	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(UnstableFinalState(), "UFS");

	// continuum cross sections
	_sigmaDPlus = bookHisto1D(1,1,1);
	_sigmaD0A = bookHisto1D(1,1,2);
	_sigmaD0B = bookHisto1D(1,1,3);
	_sigmaDStarPlusA = bookHisto1D(1,1,4);
	_sigmaDStarPlusB = bookHisto1D(1,1,5);
	_sigmaDStar0A = bookHisto1D(1,1,6);
	_sigmaDStar0B = bookHisto1D(1,1,7);

	// histograms for continuum data
	_histXpDplus = bookHisto1D(2, 1, 1);
	_histXpD0A = bookHisto1D(3, 1, 1);
	_histXpD0B = bookHisto1D(4, 1, 1);
	_histXpDStarPlusA = bookHisto1D(5, 1, 1);
	_histXpDStarPlusB = bookHisto1D(6, 1, 1);
	_histXpDStar0A = bookHisto1D(7, 1, 1);
	_histXpDStar0B = bookHisto1D(8, 1, 1);
	_histXpTotal = bookHisto1D(9, 1, 1);

	} // init

	private:

	//@{
	// Histograms for the continuum cross sections
	Histo1DPtr _sigmaDPlus ;
	Histo1DPtr _sigmaD0A ;
	Histo1DPtr _sigmaD0B ;
	Histo1DPtr _sigmaDStarPlusA;
	Histo1DPtr _sigmaDStarPlusB;
	Histo1DPtr _sigmaDStar0A ;
	Histo1DPtr _sigmaDStar0B ;

	// histograms for continuum data
	Histo1DPtr _histXpDplus ;
	Histo1DPtr _histXpD0A ;
	Histo1DPtr _histXpD0B ;
	Histo1DPtr _histXpDStarPlusA;
	Histo1DPtr _histXpDStarPlusB;
	Histo1DPtr _histXpDStar0A ;
	Histo1DPtr _histXpDStar0B ;
	Histo1DPtr _histXpTotal ;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CLEO_2004_S5809304);

	}
	diff --git a/src/Analyses/CMSTOTEM_2014_I1294140.cc b/src/Analyses/CMSTOTEM_2014_I1294140.cc
	--- a/src/Analyses/CMSTOTEM_2014_I1294140.cc
	+++ b/src/Analyses/CMSTOTEM_2014_I1294140.cc
	@@ -1,79 +1,79 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/Beam.hh"

	namespace Rivet {


	class CMSTOTEM_2014_I1294140 : public Analysis {
	public:

	CMSTOTEM_2014_I1294140()
	: Analysis("CMSTOTEM_2014_I1294140")
	{ }


	void init() {
	ChargedFinalState cfs(-7.0, 7.0, 0.0*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	_Nevt_after_cuts_or = 0;
	_Nevt_after_cuts_and = 0;
	_Nevt_after_cuts_xor = 0;

	if (fuzzyEquals(sqrtS(), 8000*GeV, 1E-3)) {
	_h_dNch_dEta_OR = bookHisto1D(1, 1, 1);
	_h_dNch_dEta_AND = bookHisto1D(2, 1, 1);
	_h_dNch_dEta_XOR = bookHisto1D(3, 1, 1);
	}
	}


	void analyze(const Event& event) {
	// Count forward and backward charged particles
	- const ChargedFinalState& charged = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& charged = apply<ChargedFinalState>(event, "CFS");
	int count_plus = 0, count_minus = 0;
	foreach (const Particle& p, charged.particles()) {
	if (inRange(p.eta(), 5.3, 6.5)) count_plus++;
	if (inRange(p.eta(), -6.5, -5.3)) count_minus++;
	}

	// Cut combinations
	const bool cutsor = (count_plus > 0 \|\| count_minus > 0);
	const bool cutsand = (count_plus > 0 && count_minus > 0);
	const bool cutsxor = ( (count_plus > 0 && count_minus == 0) \|\| (count_plus == 0 && count_minus > 0) );

	// Increment counters and fill histos
	const double weight = event.weight();
	if (cutsor) _Nevt_after_cuts_or += weight;
	if (cutsand) _Nevt_after_cuts_and += weight;
	if (cutsxor) _Nevt_after_cuts_xor += weight;
	foreach (const Particle& p, charged.particles()) {
	if (cutsor) _h_dNch_dEta_OR ->fill(p.abseta(), weight);
	if (cutsand) _h_dNch_dEta_AND->fill(p.abseta(), weight);
	if (cutsxor) _h_dNch_dEta_XOR->fill(p.abseta(), weight);
	}

	}


	void finalize() {
	scale(_h_dNch_dEta_OR, 0.5/_Nevt_after_cuts_or);
	scale(_h_dNch_dEta_AND, 0.5/_Nevt_after_cuts_and);
	scale(_h_dNch_dEta_XOR, 0.5/_Nevt_after_cuts_xor);
	}


	private:

	Histo1DPtr _h_dNch_dEta_OR, _h_dNch_dEta_AND, _h_dNch_dEta_XOR;
	double _Nevt_after_cuts_or, _Nevt_after_cuts_and, _Nevt_after_cuts_xor;

	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMSTOTEM_2014_I1294140);

	}
	diff --git a/src/Analyses/CMS_QCD_10_024.cc b/src/Analyses/CMS_2010_PAS_QCD_10_024.cc
	rename from src/Analyses/CMS_QCD_10_024.cc
	rename to src/Analyses/CMS_2010_PAS_QCD_10_024.cc
	--- a/src/Analyses/CMS_QCD_10_024.cc
	+++ b/src/Analyses/CMS_2010_PAS_QCD_10_024.cc
	@@ -1,84 +1,84 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Particle.hh"

	namespace Rivet {


	class CMS_QCD_10_024 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CMS_QCD_10_024() : Analysis("CMS_QCD_10_024"),
	_weight_pt05_eta08(0.), _weight_pt10_eta08(0.),
	_weight_pt05_eta24(0.), _weight_pt10_eta24(0.) { }


	void init() {
	- addProjection(ChargedFinalState(-0.8, 0.8, 0.5*GeV), "CFS_08_05");
	- addProjection(ChargedFinalState(-0.8, 0.8, 1.0*GeV), "CFS_08_10");
	- addProjection(ChargedFinalState(-2.4, 2.4, 0.5*GeV), "CFS_24_05");
	- addProjection(ChargedFinalState(-2.4, 2.4, 1.0*GeV), "CFS_24_10");
	+ declare(ChargedFinalState(-0.8, 0.8, 0.5*GeV), "CFS_08_05");
	+ declare(ChargedFinalState(-0.8, 0.8, 1.0*GeV), "CFS_08_10");
	+ declare(ChargedFinalState(-2.4, 2.4, 0.5*GeV), "CFS_24_05");
	+ declare(ChargedFinalState(-2.4, 2.4, 1.0*GeV), "CFS_24_10");

	size_t offset = 0;
	if (fuzzyEquals(sqrtS()/GeV, 7000, 1E-3)) offset = 0;
	if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) offset = 4;
	_hist_dNch_deta_pt05_eta08 = bookHisto1D(1+offset, 1, 1);
	_hist_dNch_deta_pt10_eta08 = bookHisto1D(2+offset, 1, 1);
	_hist_dNch_deta_pt05_eta24 = bookHisto1D(3+offset, 1, 1);
	_hist_dNch_deta_pt10_eta24 = bookHisto1D(4+offset, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ChargedFinalState& cfs_08_05 = applyProjection<ChargedFinalState>(event, "CFS_08_05");
	- const ChargedFinalState& cfs_08_10 = applyProjection<ChargedFinalState>(event, "CFS_08_10");
	- const ChargedFinalState& cfs_24_05 = applyProjection<ChargedFinalState>(event, "CFS_24_05");
	- const ChargedFinalState& cfs_24_10 = applyProjection<ChargedFinalState>(event, "CFS_24_10");
	+ const ChargedFinalState& cfs_08_05 = apply<ChargedFinalState>(event, "CFS_08_05");
	+ const ChargedFinalState& cfs_08_10 = apply<ChargedFinalState>(event, "CFS_08_10");
	+ const ChargedFinalState& cfs_24_05 = apply<ChargedFinalState>(event, "CFS_24_05");
	+ const ChargedFinalState& cfs_24_10 = apply<ChargedFinalState>(event, "CFS_24_10");

	// Plot distributions
	if(!cfs_08_05.particles().empty()) _weight_pt05_eta08 += weight;
	if(!cfs_24_05.particles().empty()) _weight_pt05_eta24 += weight;
	foreach (const Particle& p, cfs_24_05.particles()) {
	_hist_dNch_deta_pt05_eta24->fill(p.eta(), weight);
	if(!cfs_08_05.particles().empty())
	_hist_dNch_deta_pt05_eta08->fill(p.eta(), weight);
	}
	if(!cfs_08_10.particles().empty()) _weight_pt10_eta08 += weight;
	if(!cfs_24_10.particles().empty()) _weight_pt10_eta24 += weight;
	foreach (const Particle& p, cfs_24_10.particles()) {
	_hist_dNch_deta_pt10_eta24->fill(p.eta(), weight);
	if(!cfs_08_10.particles().empty())
	_hist_dNch_deta_pt10_eta08->fill(p.eta(), weight);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_hist_dNch_deta_pt05_eta08,1./_weight_pt05_eta08);
	scale(_hist_dNch_deta_pt10_eta08,1./_weight_pt10_eta08);
	scale(_hist_dNch_deta_pt05_eta24,1./_weight_pt05_eta24);
	scale(_hist_dNch_deta_pt10_eta24,1./_weight_pt10_eta24);
	}


	private:

	Histo1DPtr _hist_dNch_deta_pt05_eta08;
	Histo1DPtr _hist_dNch_deta_pt10_eta08;
	Histo1DPtr _hist_dNch_deta_pt05_eta24;
	Histo1DPtr _hist_dNch_deta_pt10_eta24;
	double _weight_pt05_eta08,_weight_pt10_eta08,_weight_pt05_eta24,_weight_pt10_eta24;
	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_QCD_10_024);

	}
	diff --git a/src/Analyses/CMS_2010_S8547297.cc b/src/Analyses/CMS_2010_S8547297.cc
	--- a/src/Analyses/CMS_2010_S8547297.cc
	+++ b/src/Analyses/CMS_2010_S8547297.cc
	@@ -1,97 +1,97 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class CMS_2010_S8547297 : public Analysis {
	public:

	CMS_2010_S8547297() : Analysis("CMS_2010_S8547297") {}


	void init() {
	ChargedFinalState cfs(-2.5, 2.5, 0.0*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	if (fuzzyEquals(sqrtS()/GeV, 900)) {
	for (int d=1; d<=3; d++) {
	for (int y=1; y<=4; y++) {
	_h_dNch_dpT.push_back(bookHisto1D(d, 1, y));
	}
	}
	_h_dNch_dpT_all = bookHisto1D(7, 1, 1);
	_h_dNch_dEta = bookHisto1D(8, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 2360)) {
	for (int d=4; d<=6; d++) {
	for (int y=1; y<=4; y++) {
	_h_dNch_dpT.push_back(bookHisto1D(d, 1, y));
	}
	}
	_h_dNch_dpT_all = bookHisto1D(7, 1, 2);
	_h_dNch_dEta = bookHisto1D(8, 1, 2);
	}
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	//charged particles
	- const ChargedFinalState& charged = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& charged = apply<ChargedFinalState>(event, "CFS");

	foreach (const Particle& p, charged.particles()) {
	//selecting only charged hadrons
	if (! PID::isHadron(p.pid())) continue;

	const double pT = p.pT();
	const double eta = p.eta();

	// The data is actually a duplicated folded distribution. This should mimic it.
	_h_dNch_dEta->fill(eta, 0.5*weight);
	_h_dNch_dEta->fill(-eta, 0.5*weight);
	if (fabs(eta) < 2.4 && pT > 0.1*GeV) {
	if (pT < 4.0*GeV) {
	_h_dNch_dpT_all->fill(pT/GeV, weight/(pT/GeV));
	if (pT < 2.0*GeV) {
	int ietabin = int(fabs(eta)/0.2);
	_h_dNch_dpT[ietabin]->fill(pT/GeV, weight);
	}
	}
	}
	}
	}


	void finalize() {
	const double normfac = 1.0/sumOfWeights(); // Normalizing to unit eta is automatic
	// The pT distributions in bins of eta must be normalized to unit eta. This is a factor of 2
	// for the \|eta\| times 0.2 (eta range).
	// The pT distributions over all eta are normalized to unit eta (2.02.4) and by 1/2pi*pT.
	// The 1/pT part is taken care of in the filling. The 1/2pi is taken care of here.
	const double normpT = normfac/(2.0*0.2);
	const double normpTall = normfac/(2.0M_PI2.0*2.4);

	for (size_t ietabin=0; ietabin < _h_dNch_dpT.size(); ietabin++){
	scale(_h_dNch_dpT[ietabin], normpT);
	}
	scale(_h_dNch_dpT_all, normpTall);
	scale(_h_dNch_dEta, normfac);
	}


	private:

	std::vector<Histo1DPtr> _h_dNch_dpT;
	Histo1DPtr _h_dNch_dpT_all;
	Histo1DPtr _h_dNch_dEta;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2010_S8547297);

	}
	diff --git a/src/Analyses/CMS_2010_S8656010.cc b/src/Analyses/CMS_2010_S8656010.cc
	--- a/src/Analyses/CMS_2010_S8656010.cc
	+++ b/src/Analyses/CMS_2010_S8656010.cc
	@@ -1,88 +1,88 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class CMS_2010_S8656010 : public Analysis {
	public:

	CMS_2010_S8656010() : Analysis("CMS_2010_S8656010") {}


	void init() {
	ChargedFinalState cfs(-2.5, 2.5, 0.0*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	for (int d=1; d<=3; d++) {
	for (int y=1; y<=4; y++) {
	_h_dNch_dpT.push_back(bookHisto1D(d, 1, y));
	}
	}

	_h_dNch_dpT_all = bookHisto1D(4, 1, 1);
	_h_dNch_dEta = bookHisto1D(5, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	//charged particles
	- const ChargedFinalState& charged = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& charged = apply<ChargedFinalState>(event, "CFS");

	foreach (const Particle& p, charged.particles()) {
	//selecting only charged hadrons
	if (! PID::isHadron(p.pid())) continue;

	const double pT = p.pT();
	const double eta = p.eta();

	// The data is actually a duplicated folded distribution. This should mimic it.
	_h_dNch_dEta->fill(eta, 0.5*weight);
	_h_dNch_dEta->fill(-eta, 0.5*weight);
	if (fabs(eta) < 2.4 && pT > 0.1*GeV) {
	if (pT < 6.0*GeV) {
	_h_dNch_dpT_all->fill(pT/GeV, weight/(pT/GeV));
	if (pT < 2.0*GeV) {
	int ietabin = int(fabs(eta)/0.2);
	_h_dNch_dpT[ietabin]->fill(pT/GeV, weight);
	}
	}
	}
	}
	}


	void finalize() {
	const double normfac = 1.0/sumOfWeights(); // Normalizing to unit eta is automatic
	// The pT distributions in bins of eta must be normalized to unit eta. This is a factor of 2
	// for the \|eta\| times 0.2 (eta range).
	// The pT distributions over all eta are normalized to unit eta (2.02.4) and by 1/2pi*pT.
	// The 1/pT part is taken care of in the filling. The 1/2pi is taken care of here.
	const double normpT = normfac/(2.0*0.2);
	const double normpTall = normfac/(2.0M_PI2.0*2.4);

	for (size_t ietabin=0; ietabin < _h_dNch_dpT.size(); ietabin++){
	scale(_h_dNch_dpT[ietabin], normpT);
	}
	scale(_h_dNch_dpT_all, normpTall);
	scale(_h_dNch_dEta, normfac);
	}


	private:

	std::vector<Histo1DPtr> _h_dNch_dpT;
	Histo1DPtr _h_dNch_dpT_all;
	Histo1DPtr _h_dNch_dEta;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2010_S8656010);

	}
	diff --git a/src/Analyses/CMS_2011_I954992.cc b/src/Analyses/CMS_2011_I954992.cc
	--- a/src/Analyses/CMS_2011_I954992.cc
	+++ b/src/Analyses/CMS_2011_I954992.cc
	@@ -1,72 +1,72 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {


	class CMS_2011_I954992 : public Analysis {
	public:

	CMS_2011_I954992()
	: Analysis("CMS_2011_I954992")
	{ }


	public:

	void init() {
	ChargedFinalState cfs(Cuts::abseta < 2.4);
	- addProjection(cfs,"CFS");
	+ declare(cfs,"CFS");

	/// Get muons which pass the initial kinematic cuts
	IdentifiedFinalState muon_fs(Cuts::abseta < 2.1 && Cuts::pT > 4*GeV);
	muon_fs.acceptIdPair(PID::MUON);
	- addProjection(muon_fs, "MUON_FS");
	+ declare(muon_fs, "MUON_FS");

	_h_sigma = bookHisto1D(1,1,1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	if (cfs.size() != 2) vetoEvent; // no other charged particles in 2.4

	- const Particles& muonFS = applyProjection<IdentifiedFinalState>(event, "MUON_FS").particles();
	+ const Particles& muonFS = apply<IdentifiedFinalState>(event, "MUON_FS").particles();
	if (muonFS.size() != 2) vetoEvent;

	if (charge(muonFS[0]) != charge(muonFS[1])) {
	const double dimuon_mass = (muonFS[0].momentum() + muonFS[1].momentum()).mass();
	const double v_angle = muonFS[0].momentum().angle(muonFS[1].momentum());
	const double dPhi = deltaPhi(muonFS[0], muonFS[1]);
	const double deltaPt = fabs(muonFS[0].pT() - muonFS[1].pT());

	if (dimuon_mass >= 11.5*GeV &&
	v_angle < 0.95*PI &&
	dPhi > 0.9*PI &&
	deltaPt < 1.*GeV ) {
	_h_sigma->fill(sqrtS()/GeV, weight);
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_sigma, crossSection()/picobarn/sumOfWeights());
	}

	private:

	Histo1DPtr _h_sigma;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_I954992);

	}
	diff --git a/src/Analyses/CMS_2011_S8884919.cc b/src/Analyses/CMS_2011_S8884919.cc
	--- a/src/Analyses/CMS_2011_S8884919.cc
	+++ b/src/Analyses/CMS_2011_S8884919.cc
	@@ -1,121 +1,121 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/Beam.hh"
	using namespace std;

	namespace Rivet {

	class CMS_2011_S8884919 : public Analysis {
	public:

	CMS_2011_S8884919()
	: Analysis("CMS_2011_S8884919")
	{ }


	void init() {
	ChargedFinalState cfs(-2.4, 2.4, 0.0*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	// eta bins
	_etabins.push_back(0.5);
	_etabins.push_back(1.0);
	_etabins.push_back(1.5);
	_etabins.push_back(2.0);
	_etabins.push_back(2.4) ;

	if (fuzzyEquals(sqrtS()/GeV, 900)) {
	for (size_t ietabin=0; ietabin < _etabins.size(); ietabin++) {
	_h_dNch_dn.push_back( bookHisto1D( 2 + ietabin, 1, 1) );
	}
	_h_dNch_dn_pt500_eta24 = bookHisto1D(20, 1, 1);
	_h_dmpt_dNch_eta24 = bookProfile1D(23, 1, 1);
	}

	if (fuzzyEquals(sqrtS()/GeV, 2360)) {
	for (size_t ietabin=0; ietabin < _etabins.size(); ietabin++) {
	_h_dNch_dn.push_back( bookHisto1D(7 + ietabin, 1, 1) );
	}
	_h_dNch_dn_pt500_eta24 = bookHisto1D(21, 1, 1);
	_h_dmpt_dNch_eta24 = bookProfile1D(24, 1, 1);
	}

	if (fuzzyEquals(sqrtS()/GeV, 7000)) {
	for (size_t ietabin=0; ietabin < _etabins.size(); ietabin++) {
	_h_dNch_dn.push_back( bookHisto1D(12 + ietabin, 1, 1) );
	}
	_h_dNch_dn_pt500_eta24 = bookHisto1D(22, 1, 1);
	_h_dmpt_dNch_eta24 = bookProfile1D(25, 1, 1);
	}
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	// Get the charged particles
	- const ChargedFinalState& charged = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& charged = apply<ChargedFinalState>(event, "CFS");

	// Resetting the multiplicity for the event to 0;
	vector<int> _nch_in_Evt;
	vector<int> _nch_in_Evt_pt500;
	_nch_in_Evt.assign(_etabins.size(), 0);
	_nch_in_Evt_pt500.assign(_etabins.size(), 0);
	double sumpt = 0;

	// Loop over particles in event
	foreach (const Particle& p, charged.particles()) {
	// Selecting only charged hadrons
	if (! PID::isHadron(p.pid())) continue;

	double pT = p.pT();
	double eta = p.eta();
	sumpt += pT;
	for (size_t ietabin = _etabins.size(); ietabin > 0; --ietabin) {
	if (fabs(eta) > _etabins[ietabin-1]) break;
	++_nch_in_Evt[ietabin-1];
	if (pT > 0.5/GeV) ++_nch_in_Evt_pt500[ietabin-1];
	}
	}

	// Filling multiplicity-dependent histogramms
	for (size_t ietabin = 0; ietabin < _etabins.size(); ietabin++) {
	_h_dNch_dn[ietabin]->fill(_nch_in_Evt[ietabin], weight);
	}

	// Do only if eta bins are the needed ones
	if (_etabins[4] == 2.4 && _etabins[0] == 0.5) {
	if (_nch_in_Evt[4] != 0) {
	_h_dmpt_dNch_eta24->fill(_nch_in_Evt[4], sumpt/GeV / _nch_in_Evt[4], weight);
	}
	_h_dNch_dn_pt500_eta24->fill(_nch_in_Evt_pt500[4], weight);
	} else {
	MSG_WARNING("You changed the number of eta bins, but forgot to propagate it everywhere !!");
	}
	}


	void finalize() {
	for (size_t ietabin = 0; ietabin < _etabins.size(); ietabin++){
	normalize(_h_dNch_dn[ietabin]);
	}
	normalize(_h_dNch_dn_pt500_eta24);
	}


	private:

	vector<Histo1DPtr> _h_dNch_dn;
	Histo1DPtr _h_dNch_dn_pt500_eta24;
	Profile1DPtr _h_dmpt_dNch_eta24;

	vector<double> _etabins;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S8884919);

	}
	diff --git a/src/Analyses/CMS_2011_S8941262.cc b/src/Analyses/CMS_2011_S8941262.cc
	--- a/src/Analyses/CMS_2011_S8941262.cc
	+++ b/src/Analyses/CMS_2011_S8941262.cc
	@@ -1,76 +1,76 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Particle.hh"

	namespace Rivet {


	class CMS_2011_S8941262 : public Analysis {
	public:

	/// Constructor
	CMS_2011_S8941262() : Analysis("CMS_2011_S8941262") { }


	/// Book histograms and initialise projections before the run
	void init() {
	_h_total = bookHisto1D(1, 1, 1);
	_h_mupt = bookHisto1D(2, 1, 1);
	_h_mueta = bookHisto1D(3, 1, 1);
	nbtot=0.; nbmutot=0.;

	IdentifiedFinalState ifs(Cuts::abseta < 2.1 && Cuts::pT > 6*GeV);
	ifs.acceptIdPair(PID::MUON);
	- addProjection(ifs, "IFS");
	+ declare(ifs, "IFS");
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// a b-quark must have been produced
	/// @todo Ouch. Use hadron tagging...
	int nb = 0;
	foreach (const GenParticle* p, particles(event.genEvent())) {
	if (abs(p->pdg_id()) == PID::BQUARK) nb += 1;
	}
	if (nb == 0) vetoEvent;
	nbtot += weight;

	// Event must contain a muon
	- Particles muons = applyProjection<IdentifiedFinalState>(event, "IFS").particlesByPt();
	+ Particles muons = apply<IdentifiedFinalState>(event, "IFS").particlesByPt();
	if (muons.size() < 1) vetoEvent;
	nbmutot += weight;

	FourMomentum pmu = muons[0].momentum();
	_h_total->fill( 7000/GeV, weight);
	_h_mupt->fill( pmu.pT()/GeV, weight);
	_h_mueta->fill( pmu.eta()/GeV, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_total, crossSection()/microbarn/sumOfWeights());
	scale(_h_mupt, crossSection()/nanobarn/sumOfWeights());
	scale(_h_mueta, crossSection()/nanobarn/sumOfWeights());
	}


	private:

	double nbtot, nbmutot;

	Histo1DPtr _h_total;
	Histo1DPtr _h_mupt;
	Histo1DPtr _h_mueta;

	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S8941262);

	}
	diff --git a/src/Analyses/CMS_2011_S8950903.cc b/src/Analyses/CMS_2011_S8950903.cc
	--- a/src/Analyses/CMS_2011_S8950903.cc
	+++ b/src/Analyses/CMS_2011_S8950903.cc
	@@ -1,60 +1,60 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {

	// CMS azimuthal decorrelations
	class CMS_2011_S8950903 : public Analysis {
	public:

	CMS_2011_S8950903() : Analysis("CMS_2011_S8950903") {}


	void init() {
	FinalState fs;
	FastJets akt(fs, FastJets::ANTIKT, 0.5);
	- addProjection(akt, "antikT");
	+ declare(akt, "antikT");

	_h_deltaPhi.addHistogram( 80., 110., bookHisto1D(1, 1, 1));
	_h_deltaPhi.addHistogram(110., 140., bookHisto1D(2, 1, 1));
	_h_deltaPhi.addHistogram(140., 200., bookHisto1D(3, 1, 1));
	_h_deltaPhi.addHistogram(200., 300., bookHisto1D(4, 1, 1));
	_h_deltaPhi.addHistogram(300., 7000., bookHisto1D(5, 1, 1));
	}


	void analyze(const Event & event) {
	const double weight = event.weight();

	- const Jets& jets = applyProjection<JetAlg>(event, "antikT").jetsByPt();
	+ const Jets& jets = apply<JetAlg>(event, "antikT").jetsByPt();
	if (jets.size() < 2) vetoEvent;

	if (fabs(jets[0].eta()) > 1.1 \|\| jets[0].pT() < 80.) vetoEvent;
	if (fabs(jets[1].eta()) > 1.1 \|\| jets[1].pT() < 30.) vetoEvent;

	double dphi = deltaPhi(jets[0].momentum(), jets[1].phi());

	_h_deltaPhi.fill(jets[0].pT(), dphi, weight);
	}


	void finalize() {
	foreach (Histo1DPtr histo, _h_deltaPhi.getHistograms()) {
	normalize(histo, 1.);
	}
	}

	private:

	BinnedHistogram<double> _h_deltaPhi;

	};

	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S8950903);

	}

	diff --git a/src/Analyses/CMS_2011_S8957746.cc b/src/Analyses/CMS_2011_S8957746.cc
	--- a/src/Analyses/CMS_2011_S8957746.cc
	+++ b/src/Analyses/CMS_2011_S8957746.cc
	@@ -1,100 +1,100 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/Thrust.hh"

	namespace Rivet {

	/// Rivet analysis class for CMS_2011_S8957746 dataset
	class CMS_2011_S8957746 : public Analysis {
	public:

	/// Constructor
	CMS_2011_S8957746()
	: Analysis("CMS_2011_S8957746") { }


	/// Initialization, called once before running
	void init() {
	// Projections
	const FastJets jets(FinalState(-5.0, 5.0, 0.0*GeV), FastJets::ANTIKT, 0.5);
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	// Book histograms
	_hist_T_90 = bookHisto1D(1, 1, 1);
	_hist_m_90 = bookHisto1D(2, 1, 1);
	_hist_T_125 = bookHisto1D(3, 1, 1);
	_hist_m_125 = bookHisto1D(4, 1, 1);
	_hist_T_200 = bookHisto1D(5, 1, 1);
	_hist_m_200 = bookHisto1D(6, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	- const Jets& jets = applyProjection<FastJets>(event, "Jets").jetsByPt(30.0*GeV);
	+ const Jets& jets = apply<FastJets>(event, "Jets").jetsByPt(30.0*GeV);
	if (jets.size() < 2 \|\|
	fabs(jets[0].eta()) >= 1.3 \|\|
	fabs(jets[1].eta()) >= 1.3 \|\|
	jets[0].pT() < 90*GeV) {
	vetoEvent;
	}
	std::vector<Vector3> momenta;
	foreach (const Jet& j, jets) {
	if (j.abseta() < 1.3) {
	Vector3 mom = j.p3();
	mom.setZ(0.0);
	momenta.push_back(mom);
	}
	}
	if (momenta.size() == 2) {
	// We need to use a ghost so that Thrust.calc() doesn't return 1.
	momenta.push_back(Vector3(1e-10*MeV, 0., 0.));
	}
	Thrust thrust;
	thrust.calc(momenta);

	// The lowest bin also includes the underflow:
	const double T = max(log(1-thrust.thrust()), -12.0);
	const double M = max(log(thrust.thrustMajor()), -6.0);
	if (jets[0].pT()/GeV > 200) {
	_hist_T_200->fill(T, weight);
	_hist_m_200->fill(M, weight);
	} else if (jets[0].pT()/GeV > 125) {
	_hist_T_125->fill(T, weight);
	_hist_m_125->fill(M, weight);
	} else if (jets[0].pT()/GeV > 90) {
	_hist_T_90->fill(T, weight);
	_hist_m_90->fill(M, weight);
	}
	}


	void finalize() {
	normalize(_hist_T_90);
	normalize(_hist_m_90);
	normalize(_hist_T_125);
	normalize(_hist_m_125);
	normalize(_hist_T_200);
	normalize(_hist_m_200);
	}


	private:

	Histo1DPtr _hist_T_90;
	Histo1DPtr _hist_m_90;
	Histo1DPtr _hist_T_125;
	Histo1DPtr _hist_m_125;
	Histo1DPtr _hist_T_200;
	Histo1DPtr _hist_m_200;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S8957746);

	}
	diff --git a/src/Analyses/CMS_2011_S8968497.cc b/src/Analyses/CMS_2011_S8968497.cc
	--- a/src/Analyses/CMS_2011_S8968497.cc
	+++ b/src/Analyses/CMS_2011_S8968497.cc
	@@ -1,66 +1,66 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	class CMS_2011_S8968497 : public Analysis {
	public:

	CMS_2011_S8968497()
	: Analysis("CMS_2011_S8968497")
	{ }


	void init() {
	FinalState fs;
	FastJets antikt(fs, FastJets::ANTIKT, 0.5);
	- addProjection(antikt, "ANTIKT");
	+ declare(antikt, "ANTIKT");
	_h_chi_dijet.addHistogram(2200., 7000., bookHisto1D(1, 1, 1));
	_h_chi_dijet.addHistogram(1800., 2200., bookHisto1D(2, 1, 1));
	_h_chi_dijet.addHistogram(1400., 1800., bookHisto1D(3, 1, 1));
	_h_chi_dijet.addHistogram(1100., 1400., bookHisto1D(4, 1, 1));
	_h_chi_dijet.addHistogram( 850., 1100., bookHisto1D(5, 1, 1));
	_h_chi_dijet.addHistogram( 650., 850., bookHisto1D(6, 1, 1));
	_h_chi_dijet.addHistogram( 500., 650., bookHisto1D(7, 1, 1));
	_h_chi_dijet.addHistogram( 350., 500., bookHisto1D(8, 1, 1));
	_h_chi_dijet.addHistogram( 250., 350., bookHisto1D(9, 1, 1));
	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	- const Jets& jets = applyProjection<JetAlg>(event, "ANTIKT").jetsByPt();
	+ const Jets& jets = apply<JetAlg>(event, "ANTIKT").jetsByPt();
	if (jets.size() < 2) vetoEvent;
	FourMomentum j0(jets[0].momentum());
	FourMomentum j1(jets[1].momentum());
	double y0 = j0.rapidity();
	double y1 = j1.rapidity();
	if (fabs(y0+y1)/2. > 1.11) vetoEvent;
	double mjj = FourMomentum(j0+j1).mass();
	double chi = exp(fabs(y0-y1));
	if(chi<16.) _h_chi_dijet.fill(mjj, chi, weight);
	}


	void finalize() {
	foreach (Histo1DPtr hist, _h_chi_dijet.getHistograms()) {
	normalize(hist);
	}
	}


	private:

	BinnedHistogram<double> _h_chi_dijet;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S8968497);

	}
	diff --git a/src/Analyses/CMS_2011_S8973270.cc b/src/Analyses/CMS_2011_S8973270.cc
	--- a/src/Analyses/CMS_2011_S8973270.cc
	+++ b/src/Analyses/CMS_2011_S8973270.cc
	@@ -1,164 +1,164 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class CMS_2011_S8973270 : public Analysis {
	public:

	/// Constructor
	CMS_2011_S8973270() : Analysis("CMS_2011_S8973270") { }


	void init() {
	FinalState fs;
	FastJets jetproj(fs, FastJets::ANTIKT, 0.5);
	jetproj.useInvisibles();
	- addProjection(jetproj, "Jets");
	+ declare(jetproj, "Jets");

	UnstableFinalState ufs;
	- addProjection(ufs, "UFS");
	+ declare(ufs, "UFS");

	// Book histograms
	_h_dsigma_dR_56GeV = bookHisto1D(1,1,1);
	_h_dsigma_dR_84GeV = bookHisto1D(2,1,1);
	_h_dsigma_dR_120GeV = bookHisto1D(3,1,1);
	_h_dsigma_dPhi_56GeV = bookHisto1D(4,1,1);
	_h_dsigma_dPhi_84GeV = bookHisto1D(5,1,1);
	_h_dsigma_dPhi_120GeV = bookHisto1D(6,1,1);

	_countMCDR56 = 0;
	_countMCDR84 = 0;
	_countMCDR120 = 0;
	_countMCDPhi56 = 0;
	_countMCDPhi84 = 0;
	_countMCDPhi120 = 0;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const Jets& jets = applyProjection<FastJets>(event,"Jets").jetsByPt();
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const Jets& jets = apply<FastJets>(event,"Jets").jetsByPt();
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");

	// Find the leading jet pT and eta
	if (jets.size() == 0) vetoEvent;
	const double ljpT = jets[0].pT();
	const double ljeta = jets[0].eta();
	MSG_DEBUG("Leading jet pT / eta: " << ljpT << " / " << ljeta);

	// Minimum requirement for event
	if (ljpT > 56*GeV && fabs(ljeta) < 3.0) {
	// Find B hadrons in event
	int nab = 0, nb = 0; //counters for all B and independent B hadrons
	double etaB1 = 7.7, etaB2 = 7.7;
	double phiB1 = 7.7, phiB2 = 7.7;
	double pTB1 = 7.7, pTB2 = 7.7;

	foreach (const Particle& p, ufs.particles()) {
	int aid = p.abspid();
	if (aid/100 == 5 \|\| aid/1000==5) {
	nab++;
	// 2J+1 == 1 (mesons) or 2 (baryons)
	if (aid%10 == 1 \|\| aid%10 == 2) {
	// No B decaying to B
	if (aid != 5222 && aid != 5112 && aid != 5212 && aid != 5322) {
	if (nb==0) {
	etaB1 = p.eta();
	phiB1 = p.phi();
	pTB1 = p.pT();
	} else if (nb==1) {
	etaB2 = p.eta();
	phiB2 = p.phi();
	pTB2 = p.pT();
	}
	nb++;
	}
	}
	MSG_DEBUG("ID " << aid << " B hadron");
	}
	}

	if (nb==2 && pTB1 > 15GeV && pTB2 > 15GeV && fabs(etaB1) < 2.0 && fabs(etaB2) < 2.0) {
	double dPhi = deltaPhi(phiB1, phiB2);
	double dR = deltaR(etaB1, phiB1, etaB2, phiB2);
	MSG_DEBUG("DR/DPhi " << dR << " " << dPhi);

	// MC counters
	if (dR > 2.4) _countMCDR56 += weight;
	if (dR > 2.4 && ljpT > 84*GeV) _countMCDR84 += weight;
	if (dR > 2.4 && ljpT > 120*GeV) _countMCDR120 += weight;
	if (dPhi > 3.*PI/4.) _countMCDPhi56 += weight;
	if (dPhi > 3.PI/4. && ljpT > 84GeV) _countMCDPhi84 += weight;
	if (dPhi > 3.PI/4. && ljpT > 120GeV) _countMCDPhi120 += weight;

	_h_dsigma_dR_56GeV->fill(dR, weight);
	if (ljpT > 84*GeV) _h_dsigma_dR_84GeV->fill(dR, weight);
	if (ljpT > 120*GeV) _h_dsigma_dR_120GeV->fill(dR, weight);
	_h_dsigma_dPhi_56GeV->fill(dPhi, weight);
	if (ljpT > 84*GeV) _h_dsigma_dPhi_84GeV->fill(dPhi, weight);
	if (ljpT > 120*GeV) _h_dsigma_dPhi_120GeV->fill(dPhi, weight);
	//MSG_DEBUG("nb " << nb << " " << nab);
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	MSG_DEBUG("crossSection " << crossSection() << " sumOfWeights " << sumOfWeights());

	// Hardcoded bin widths
	double DRbin = 0.4;
	double DPhibin = PI/8.0;
	// Find out the correct numbers
	double nDataDR56 = 25862.20;
	double nDataDR84 = 5675.55;
	double nDataDR120 = 1042.72;
	double nDataDPhi56 = 24220.00;
	double nDataDPhi84 = 4964.00;
	double nDataDPhi120 = 919.10;
	double normDR56 = (_countMCDR56 > 0.) ? nDataDR56/_countMCDR56 : crossSection()/sumOfWeights();
	double normDR84 = (_countMCDR84 > 0.) ? nDataDR84/_countMCDR84 : crossSection()/sumOfWeights();
	double normDR120 = (_countMCDR120 > 0.) ? nDataDR120/_countMCDR120 : crossSection()/sumOfWeights();
	double normDPhi56 = (_countMCDPhi56 > 0.) ? nDataDPhi56/_countMCDPhi56 : crossSection()/sumOfWeights();
	double normDPhi84 = (_countMCDPhi84 > 0.) ? nDataDPhi84/_countMCDPhi84 : crossSection()/sumOfWeights();
	double normDPhi120 = (_countMCDPhi120 > 0.) ? nDataDPhi120/_countMCDPhi120 : crossSection()/sumOfWeights();
	scale(_h_dsigma_dR_56GeV, normDR56*DRbin);
	scale(_h_dsigma_dR_84GeV, normDR84*DRbin);
	scale(_h_dsigma_dR_120GeV, normDR120*DRbin);
	scale(_h_dsigma_dPhi_56GeV, normDPhi56*DPhibin);
	scale(_h_dsigma_dPhi_84GeV, normDPhi84*DPhibin);
	scale(_h_dsigma_dPhi_120GeV, normDPhi120*DPhibin);
	}

	//@}


	private:

	/// @name Counters
	//@{
	double _countMCDR56, _countMCDR84, _countMCDR120;
	double _countMCDPhi56, _countMCDPhi84, _countMCDPhi120;
	//@}

	/// @name Histograms
	//@{
	Histo1DPtr _h_dsigma_dR_56GeV, _h_dsigma_dR_84GeV, _h_dsigma_dR_120GeV;
	Histo1DPtr _h_dsigma_dPhi_56GeV, _h_dsigma_dPhi_84GeV, _h_dsigma_dPhi_120GeV;
	//@}

	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S8973270);

	}
	diff --git a/src/Analyses/CMS_2011_S8978280.cc b/src/Analyses/CMS_2011_S8978280.cc
	--- a/src/Analyses/CMS_2011_S8978280.cc
	+++ b/src/Analyses/CMS_2011_S8978280.cc
	@@ -1,114 +1,114 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief CMS strange particle spectra (Ks, Lambda, Cascade) in pp at 900 and 7000 GeV
	/// @author Kevin Stenson
	class CMS_2011_S8978280 : public Analysis {
	public:

	/// Constructor
	CMS_2011_S8978280()
	: Analysis("CMS_2011_S8978280")
	{ }


	void init() {
	UnstableFinalState ufs(Cuts::absrap < 2);
	- addProjection(ufs, "UFS");
	+ declare(ufs, "UFS");

	// Particle distributions versus rapidity and transverse momentum
	if (fuzzyEquals(sqrtS()/GeV, 900*GeV)){
	_h_dNKshort_dy = bookHisto1D(1, 1, 1);
	_h_dNKshort_dpT = bookHisto1D(2, 1, 1);
	_h_dNLambda_dy = bookHisto1D(3, 1, 1);
	_h_dNLambda_dpT = bookHisto1D(4, 1, 1);
	_h_dNXi_dy = bookHisto1D(5, 1, 1);
	_h_dNXi_dpT = bookHisto1D(6, 1, 1);
	//
	_h_LampT_KpT = bookScatter2D(7, 1, 1);
	_h_XipT_LampT = bookScatter2D(8, 1, 1);
	_h_Lamy_Ky = bookScatter2D(9, 1, 1);
	_h_Xiy_Lamy = bookScatter2D(10, 1, 1);

	} else if (fuzzyEquals(sqrtS()/GeV, 7000*GeV)){
	_h_dNKshort_dy = bookHisto1D(1, 1, 2);
	_h_dNKshort_dpT = bookHisto1D(2, 1, 2);
	_h_dNLambda_dy = bookHisto1D(3, 1, 2);
	_h_dNLambda_dpT = bookHisto1D(4, 1, 2);
	_h_dNXi_dy = bookHisto1D(5, 1, 2);
	_h_dNXi_dpT = bookHisto1D(6, 1, 2);
	//
	_h_LampT_KpT = bookScatter2D(7, 1, 2);
	_h_XipT_LampT = bookScatter2D(8, 1, 2);
	_h_Lamy_Ky = bookScatter2D(9, 1, 2);
	_h_Xiy_Lamy = bookScatter2D(10, 1, 2);
	}
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const UnstableFinalState& parts = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& parts = apply<UnstableFinalState>(event, "UFS");
	foreach (const Particle& p, parts.particles()) {
	switch (p.abspid()) {
	case PID::K0S:
	_h_dNKshort_dy->fill(p.absrap(), weight);
	_h_dNKshort_dpT->fill(p.pT(), weight);
	break;

	case PID::LAMBDA:
	// Lambda should not have Cascade or Omega ancestors since they should not decay. But just in case...
	if ( !( p.hasAncestor(3322) \|\| p.hasAncestor(-3322) \|\| p.hasAncestor(3312) \|\| p.hasAncestor(-3312) \|\| p.hasAncestor(3334) \|\| p.hasAncestor(-3334) ) ) {
	_h_dNLambda_dy->fill(p.absrap(), weight);
	_h_dNLambda_dpT->fill(p.pT(), weight);
	}
	break;

	case PID::XIMINUS:
	// Cascade should not have Omega ancestors since it should not decay. But just in case...
	if ( !( p.hasAncestor(3334) \|\| p.hasAncestor(-3334) ) ) {
	_h_dNXi_dy->fill(p.absrap(), weight);
	_h_dNXi_dpT->fill(p.pT(), weight);
	}
	break;
	}

	}
	}


	void finalize() {
	divide(_h_dNLambda_dpT,_h_dNKshort_dpT, _h_LampT_KpT);
	divide(_h_dNXi_dpT,_h_dNLambda_dpT, _h_XipT_LampT);
	divide(_h_dNLambda_dy,_h_dNKshort_dy, _h_Lamy_Ky);
	divide(_h_dNXi_dy,_h_dNLambda_dy, _h_Xiy_Lamy);
	const double normpT = 1.0/sumOfWeights();
	const double normy = 0.5*normpT; // Accounts for using \|y\| instead of y
	scale(_h_dNKshort_dy, normy);
	scale(_h_dNKshort_dpT, normpT);
	scale(_h_dNLambda_dy, normy);
	scale(_h_dNLambda_dpT, normpT);
	scale(_h_dNXi_dy, normy);
	scale(_h_dNXi_dpT, normpT);
	}


	private:

	// Particle distributions versus rapidity and transverse momentum
	Histo1DPtr _h_dNKshort_dy, _h_dNKshort_dpT, _h_dNLambda_dy, _h_dNLambda_dpT, _h_dNXi_dy, _h_dNXi_dpT;
	Scatter2DPtr _h_LampT_KpT, _h_XipT_LampT, _h_Lamy_Ky, _h_Xiy_Lamy;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S8978280);

	}
	diff --git a/src/Analyses/CMS_2011_S9086218.cc b/src/Analyses/CMS_2011_S9086218.cc
	--- a/src/Analyses/CMS_2011_S9086218.cc
	+++ b/src/Analyses/CMS_2011_S9086218.cc
	@@ -1,57 +1,57 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {

	// Inclusive jet pT
	class CMS_2011_S9086218 : public Analysis {
	public:

	// Constructor
	CMS_2011_S9086218() : Analysis("CMS_2011_S9086218") {}


	// Book histograms and initialize projections:
	void init() {
	const FinalState fs;

	// Initialize the projectors:
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.5),"Jets");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.5),"Jets");

	// Book histograms:
	_hist_sigma.addHistogram(0.0, 0.5, bookHisto1D(1, 1, 1));
	_hist_sigma.addHistogram(0.5, 1.0, bookHisto1D(2, 1, 1));
	_hist_sigma.addHistogram(1.0, 1.5, bookHisto1D(3, 1, 1));
	_hist_sigma.addHistogram(1.5, 2.0, bookHisto1D(4, 1, 1));
	_hist_sigma.addHistogram(2.0, 2.5, bookHisto1D(5, 1, 1));
	_hist_sigma.addHistogram(2.5, 3.0, bookHisto1D(6, 1, 1));
	}

	// Analysis
	void analyze(const Event &event) {
	const double weight = event.weight();
	- const FastJets& fj = applyProjection<FastJets>(event,"Jets");
	+ const FastJets& fj = apply<FastJets>(event,"Jets");
	const Jets& jets = fj.jets(Cuts::ptIn(18GeV, 1100.0GeV) && Cuts::absrap < 4.7);

	// Fill the relevant histograms:
	foreach(const Jet& j, jets) {
	_hist_sigma.fill(j.absrap(), j.pT(), weight);
	}
	}

	// Finalize
	void finalize() {
	_hist_sigma.scale(crossSection()/sumOfWeights()/2.0, this);
	}

	private:
	BinnedHistogram<double> _hist_sigma;
	};

	// This global object acts as a hook for the plugin system.
	DECLARE_RIVET_PLUGIN(CMS_2011_S9086218);

	}
	diff --git a/src/Analyses/CMS_2011_S9088458.cc b/src/Analyses/CMS_2011_S9088458.cc
	--- a/src/Analyses/CMS_2011_S9088458.cc
	+++ b/src/Analyses/CMS_2011_S9088458.cc
	@@ -1,63 +1,63 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// CMS ratio of 3-jet to 2-jet cross-sections
	class CMS_2011_S9088458 : public Analysis {
	public:


	CMS_2011_S9088458()
	: Analysis("CMS_2011_S9088458") { }


	void init() {
	FinalState fs;
	FastJets akt(fs, FastJets::ANTIKT, 0.5);
	- addProjection(akt, "antikT");
	+ declare(akt, "antikT");

	_h_tmp_dijet = Histo1D(refData(1, 1, 1));
	_h_tmp_trijet = Histo1D(refData(1, 1, 1));
	_h_r32 = bookScatter2D(1, 1, 1);
	}


	void analyze(const Event & event) {
	const double weight = event.weight();

	Jets highpT_jets;
	double HT = 0;
	- foreach(const Jet & jet, applyProjection<JetAlg>(event, "antikT").jetsByPt(50.0*GeV)) {
	+ foreach(const Jet & jet, apply<JetAlg>(event, "antikT").jetsByPt(50.0*GeV)) {
	if (jet.abseta() < 2.5) {
	highpT_jets.push_back(jet);
	HT += jet.pT();
	}
	}
	if (highpT_jets.size() < 2) vetoEvent;
	if (highpT_jets.size() >= 2) _h_tmp_dijet.fill(HT/TeV, weight);
	if (highpT_jets.size() >= 3) _h_tmp_trijet.fill(HT/TeV, weight);
	}


	void finalize() {
	divide(_h_tmp_trijet, _h_tmp_dijet, _h_r32);
	}


	private:

	Histo1D _h_tmp_dijet, _h_tmp_trijet;
	Scatter2DPtr _h_r32;

	};


	// A hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S9088458);

	}
	diff --git a/src/Analyses/CMS_2011_S9120041.cc b/src/Analyses/CMS_2011_S9120041.cc
	--- a/src/Analyses/CMS_2011_S9120041.cc
	+++ b/src/Analyses/CMS_2011_S9120041.cc
	@@ -1,146 +1,146 @@
	// -- C++ --

	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	using namespace std;

	namespace Rivet {


	// UE charged particles vs. leading jet
	class CMS_2011_S9120041 : public Analysis {
	public:

	/// Constructor
	CMS_2011_S9120041() : Analysis("CMS_2011_S9120041") {}


	void init() {
	const ChargedFinalState cfs(-2.0, 2.0, 500*MeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	const ChargedFinalState cfsforjet(-2.5, 2.5, 500*MeV);
	const FastJets jetpro(cfsforjet, FastJets::SISCONE, 0.5);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	if (fuzzyEquals(sqrtS(), 7.0*TeV)) {
	_h_Nch_vs_pT = bookProfile1D(1, 1, 1); // Nch vs. pT_max
	_h_Sum_vs_pT = bookProfile1D(2, 1, 1); // sum(pT) vs. pT_max
	_h_pT3_Nch = bookHisto1D(5, 1, 1); // transverse Nch, pT_max > 3GeV
	_h_pT3_Sum = bookHisto1D(6, 1, 1); // transverse sum(pT), pT_max > 3GeV
	_h_pT3_pT = bookHisto1D(7, 1, 1); // transverse pT, pT_max > 3GeV
	_h_pT20_Nch = bookHisto1D(8, 1, 1); // transverse Nch, pT_max > 20GeV
	_h_pT20_Sum = bookHisto1D(9, 1, 1); // transverse sum(pT), pT_max > 20GeV
	_h_pT20_pT = bookHisto1D(10, 1, 1); // transverse pT, pT_max > 20GeV
	}

	if (fuzzyEquals(sqrtS(), 0.9*TeV)) {
	_h_Nch_vs_pT = bookProfile1D(3, 1, 1); // Nch vs. pT_max
	_h_Sum_vs_pT = bookProfile1D(4, 1, 1); // sum(pT) vs. pT_max
	_h_pT3_Nch = bookHisto1D(11, 1, 1); // transverse Nch, pT_max > 3GeV
	_h_pT3_Sum = bookHisto1D(12, 1, 1); // transverse sum(pT), pT_max > 3GeV
	_h_pT3_pT = bookHisto1D(13, 1, 1); // transverse pT, pT_max > 3GeV
	}

	sumOfWeights3 = 0.0;
	sumOfWeights20 = 0.0;

	_nch_tot_pT3 = 0.0;
	_nch_tot_pT20 = 0.0;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Find the lead jet, applying a restriction that the jets must be within \|eta\| < 2.
	FourMomentum p_lead;
	- foreach (const Jet& j, applyProjection<FastJets>(event, "Jets").jetsByPt(1.0*GeV)) {
	+ foreach (const Jet& j, apply<FastJets>(event, "Jets").jetsByPt(1.0*GeV)) {
	if (j.abseta() < 2.0) {
	p_lead = j.momentum();
	break;
	}
	}
	if (p_lead.isZero()) vetoEvent;
	const double philead = p_lead.phi();
	const double pTlead = p_lead.pT();

	- Particles particles = applyProjection<ChargedFinalState>(event, "CFS").particlesByPt();
	+ Particles particles = apply<ChargedFinalState>(event, "CFS").particlesByPt();

	int nTransverse = 0;
	double ptSumTransverse = 0.;
	foreach (const Particle& p, particles) {
	double dphi = fabs(deltaPhi(philead, p.phi()));
	if (dphi>PI/3. && dphi<PI*2./3.) { // Transverse region
	nTransverse++;

	const double pT = p.pT()/GeV;
	ptSumTransverse += pT;

	if (pTlead > 3.0*GeV) _h_pT3_pT->fill(pT, weight);
	if (fuzzyEquals(sqrtS(), 7.0TeV) && pTlead > 20.0GeV) _h_pT20_pT->fill(pT, weight);
	}
	}

	const double area = 8./3. * PI;
	_h_Nch_vs_pT->fill(pTlead/GeV, 1./area*nTransverse, weight);
	_h_Sum_vs_pT->fill(pTlead/GeV, 1./area*ptSumTransverse, weight);
	if(pTlead > 3.0*GeV) {
	_h_pT3_Nch->fill(nTransverse, weight);
	_h_pT3_Sum->fill(ptSumTransverse, weight);
	sumOfWeights3 += weight;
	_nch_tot_pT3 += weight*nTransverse;
	}
	if (fuzzyEquals(sqrtS(), 7.0TeV) && pTlead > 20.0GeV) {
	_h_pT20_Nch->fill(nTransverse, weight);
	_h_pT20_Sum->fill(ptSumTransverse, weight);
	sumOfWeights20 += weight;
	_nch_tot_pT20 += weight*nTransverse;
	}
	}



	/// Normalise histograms etc., after the run
	void finalize() {
	normalize(_h_pT3_Nch);
	normalize(_h_pT3_Sum);
	if (sumOfWeights3 != 0.0) normalize(_h_pT3_pT, _nch_tot_pT3 / sumOfWeights3);

	if (fuzzyEquals(sqrtS(), 7.0*TeV)) {
	normalize(_h_pT20_Nch);
	normalize(_h_pT20_Sum);
	if (sumOfWeights20 != 0.0) normalize(_h_pT20_pT, _nch_tot_pT20 / sumOfWeights20);
	}
	}



	private:

	double sumOfWeights3;
	double sumOfWeights20;

	double _nch_tot_pT3;
	double _nch_tot_pT20;

	Profile1DPtr _h_Nch_vs_pT;
	Profile1DPtr _h_Sum_vs_pT;
	Histo1DPtr _h_pT3_Nch;
	Histo1DPtr _h_pT3_Sum;
	Histo1DPtr _h_pT3_pT;
	Histo1DPtr _h_pT20_Nch;
	Histo1DPtr _h_pT20_Sum;
	Histo1DPtr _h_pT20_pT;

	};


	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S9120041);
	}

	diff --git a/src/Analyses/CMS_2011_S9215166.cc b/src/Analyses/CMS_2011_S9215166.cc
	--- a/src/Analyses/CMS_2011_S9215166.cc
	+++ b/src/Analyses/CMS_2011_S9215166.cc
	@@ -1,111 +1,111 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	class CMS_2011_S9215166 : public Analysis {
	public:

	/// Constructor
	CMS_2011_S9215166() : Analysis("CMS_2011_S9215166"), _weightMB(0.), _weightDiJet(0.) { }


	void init() {
	const FinalState fs(-6.0, 6.0, 0.0*GeV);
	- addProjection(fs, "FS");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.5), "Jets");
	+ declare(fs, "FS");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.5), "Jets");

	VetoedFinalState fsv(fs);
	fsv.vetoNeutrinos();
	fsv.addVetoPairDetail(PID::MUON, 0.0GeV, 99999.9GeV);
	- addProjection(fsv, "fsv");
	+ declare(fsv, "fsv");

	// For the MB ND selection
	const ChargedFinalState fschrgd(-6.0,6.0,0.0*GeV);
	- addProjection(fschrgd, "fschrgd");
	+ declare(fschrgd, "fschrgd");
	VetoedFinalState fschrgdv(fschrgd);
	fschrgdv.vetoNeutrinos();
	- addProjection(fschrgdv, "fschrgdv");
	+ declare(fschrgdv, "fschrgdv");

	if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) {
	_hist_mb = bookHisto1D(1, 1, 1); // energy flow in MB, 0.9 TeV
	_hist_dijet = bookHisto1D(2, 1, 1); // energy flow in dijet events, 0.9 TeV
	} else if (fuzzyEquals(sqrtS()/GeV, 7000, 1E-3)) {
	_hist_mb = bookHisto1D(3, 1, 1); // energy flow in MB, 7 TeV
	_hist_dijet = bookHisto1D(4, 1, 1); // energy flow in dijet events, 7 TeV
	}
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	// Skip if the event is empty
	- const FinalState& fsv = applyProjection<FinalState>(event, "fsv");
	+ const FinalState& fsv = apply<FinalState>(event, "fsv");
	if (fsv.empty()) vetoEvent;

	// Veto diffractive topologies according to defined hadron level
	double count_chrg_forward = 0;
	double count_chrg_backward = 0;
	- const FinalState& fschrgdv = applyProjection<FinalState>(event, "fschrgdv");
	+ const FinalState& fschrgdv = apply<FinalState>(event, "fschrgdv");
	foreach (const Particle& p, fschrgdv.particles()) {
	if (3.9 < p.eta() && p.eta() < 4.4) count_chrg_forward++;
	if (-4.4 < p.eta() && p.eta() < -3.9) count_chrg_backward++;
	}
	if (count_chrg_forward == 0 \|\| count_chrg_backward == 0) vetoEvent;
	/// @todo "Diffractive" veto should really also veto dijet events?


	// MINIMUM BIAS EVENTS
	_weightMB += weight;
	foreach (const Particle& p, fsv.particles()) {
	_hist_mb->fill(p.abseta(), weight*p.E()/GeV);
	}


	// DIJET EVENTS
	double PTCUT = -1.0;
	if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) PTCUT = 8.0*GeV;
	else if (fuzzyEquals(sqrtS()/GeV, 7000, 1E-3)) PTCUT = 20.0*GeV;
	- const FastJets& jetpro = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(event, "Jets");
	const Jets jets = jetpro.jetsByPt(PTCUT);
	if (jets.size() >= 2) {
	// eta cut for the central jets
	if (fabs(jets[0].eta()) < 2.5 && fabs(jets[1].eta()) < 2.5) {
	// Back to back condition of the jets
	const double diffphi = deltaPhi(jets[1].phi(), jets[0].phi());
	if (diffphi-PI < 1.0) {
	_weightDiJet += weight;
	foreach (const Particle& p, fsv.particles()) {
	_hist_dijet->fill(p.abseta(), weight*p.E()/GeV);
	}
	}
	}
	}

	}


	void finalize() {
	scale(_hist_mb , 0.5/_weightMB );
	scale(_hist_dijet, 0.5/_weightDiJet);
	}


	private:

	Histo1DPtr _hist_mb, _hist_dijet;
	double _weightMB,_weightDiJet;

	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2011_S9215166);

	}
	diff --git a/src/Analyses/CMS_2012_I1087342.cc b/src/Analyses/CMS_2012_I1087342.cc
	--- a/src/Analyses/CMS_2012_I1087342.cc
	+++ b/src/Analyses/CMS_2012_I1087342.cc
	@@ -1,76 +1,76 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"


	namespace Rivet {

	// This analysis is a derived from the class Analysis:
	class CMS_2012_I1087342 : public Analysis {

	public:

	// Constructor
	CMS_2012_I1087342() : Analysis("CMS_2012_I1087342") {
	}

	void init() {
	const FinalState fs;
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.5),"Jets");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.5),"Jets");

	_hist_jetpt_fwdincl = bookHisto1D(1, 1, 1);
	_hist_jetpt_forward = bookHisto1D(2, 1, 1);
	_hist_jetpt_central = bookHisto1D(3, 1, 1);
	}

	void analyze(const Event& event) {
	const double weight = event.weight();

	- const FastJets& fj = applyProjection<FastJets>(event,"Jets");
	+ const FastJets& fj = apply<FastJets>(event,"Jets");
	const Jets jets = fj.jets(Cuts::ptIn(35GeV, 150GeV) && Cuts::abseta < 4.7);

	double cjet_pt = 0.0;
	double fjet_pt = 0.0;

	foreach(const Jet& j, jets) {
	double pT = j.pT();
	if (j.abseta() > 3.2) {
	_hist_jetpt_fwdincl->fill(j.pT()/GeV, weight);
	}
	if (j.abseta() < 2.8) {
	if (cjet_pt < pT) cjet_pt = pT;
	}
	if (inRange(j.abseta(), 3.2, 4.7)) {
	if (fjet_pt < pT) fjet_pt = pT;
	}
	}

	if (cjet_pt > 35GeV && fjet_pt > 35GeV) {
	_hist_jetpt_forward->fill(fjet_pt/GeV, weight);
	_hist_jetpt_central->fill(cjet_pt/GeV, weight);
	}

	}


	void finalize() {
	scale(_hist_jetpt_fwdincl, crossSection() / picobarn / sumOfWeights() / 3.0);
	scale(_hist_jetpt_forward, crossSection() / picobarn / sumOfWeights() / 3.0);
	scale(_hist_jetpt_central, crossSection() / picobarn / sumOfWeights() / 5.6);
	}


	private:

	Histo1DPtr _hist_jetpt_fwdincl;
	Histo1DPtr _hist_jetpt_forward;
	Histo1DPtr _hist_jetpt_central;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2012_I1087342);

	}
	diff --git a/src/Analyses/CMS_2012_I1090423.cc b/src/Analyses/CMS_2012_I1090423.cc
	--- a/src/Analyses/CMS_2012_I1090423.cc
	+++ b/src/Analyses/CMS_2012_I1090423.cc
	@@ -1,67 +1,67 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	class CMS_2012_I1090423 : public Analysis {
	public:

	CMS_2012_I1090423()
	: Analysis("CMS_2012_I1090423")
	{ }


	void init() {
	FinalState fs;
	FastJets antikt(fs, FastJets::ANTIKT, 0.5);
	- addProjection(antikt, "ANTIKT");
	+ declare(antikt, "ANTIKT");
	_h_chi_dijet.addHistogram(3000, 7000, bookHisto1D(1, 1, 1));
	_h_chi_dijet.addHistogram(2400, 3000, bookHisto1D(2, 1, 1));
	_h_chi_dijet.addHistogram(1900, 2400, bookHisto1D(3, 1, 1));
	_h_chi_dijet.addHistogram(1500, 1900, bookHisto1D(4, 1, 1));
	_h_chi_dijet.addHistogram(1200, 1500, bookHisto1D(5, 1, 1));
	_h_chi_dijet.addHistogram(1000, 1200, bookHisto1D(6, 1, 1));
	_h_chi_dijet.addHistogram( 800, 1000, bookHisto1D(7, 1, 1));
	_h_chi_dijet.addHistogram( 600, 800, bookHisto1D(8, 1, 1));
	_h_chi_dijet.addHistogram( 400, 600, bookHisto1D(9, 1, 1));
	}


	void analyze(const Event& event) {
	- const Jets& jets = applyProjection<JetAlg>(event, "ANTIKT").jetsByPt();
	+ const Jets& jets = apply<JetAlg>(event, "ANTIKT").jetsByPt();
	if (jets.size() < 2) vetoEvent;

	const double y0 = jets[0].rapidity();
	const double y1 = jets[1].rapidity();
	if (fabs(y0+y1)/2 > 1.11) vetoEvent;

	const double chi = exp(fabs(y0-y1));
	if (chi > 16) vetoEvent;

	const FourMomentum jj = jets[0].momentum() + jets[1].momentum();
	_h_chi_dijet.fill(jj.mass(), chi, event.weight());
	}


	void finalize() {
	foreach (Histo1DPtr hist, _h_chi_dijet.getHistograms()) {
	normalize(hist);
	}
	}


	private:

	BinnedHistogram<double> _h_chi_dijet;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2012_I1090423);

	}
	diff --git a/src/Analyses/CMS_2012_I1102908.cc b/src/Analyses/CMS_2012_I1102908.cc
	--- a/src/Analyses/CMS_2012_I1102908.cc
	+++ b/src/Analyses/CMS_2012_I1102908.cc
	@@ -1,89 +1,89 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include <sstream>

	namespace Rivet {

	/// @cond
	inline double _invert(double x) { return (x > 0) ? 1/x : 0; }
	/// @endcond


	/// @brief CMS inclusive and exclusive dijet production ratio at large rapidity intervals
	class CMS_2012_I1102908 : public Analysis {
	public:

	CMS_2012_I1102908()
	: Analysis("CMS_2012_I1102908")
	{ }


	void init() {
	// Projections
	- addProjection(FastJets(FinalState(), FastJets::ANTIKT, 0.5), "antikT");
	+ declare(FastJets(FinalState(), FastJets::ANTIKT, 0.5), "antikT");

	// Histograms
	/// @todo Can we manage to only register these as they are "really" created in the finalize()?
	_h_dijet_ratio = bookScatter2D(1, 1, 1);
	_h_MN_dijet_ratio = bookScatter2D(2, 1, 1);

	// Temporary histograms (directly instantiated)
	_h_DeltaY_exclusive = bookHisto1D("TMP/excl",refData(1, 1, 1));
	_h_DeltaY_inclusive = bookHisto1D("TMP/incl",refData(1, 1, 1));
	_h_DeltaY_MN = bookHisto1D("TMP/YMN",refData(1, 1, 1));
	}


	void analyze(const Event & event) {
	const double weight = event.weight();

	// Jets with pT > 35.0, -4.7 < y < 4.7
	- const JetAlg& jet_alg = applyProjection<JetAlg>(event, "antikT");
	+ const JetAlg& jet_alg = apply<JetAlg>(event, "antikT");
	const Jets& jets = jet_alg.jets(Cuts::pT > 35*GeV && Cuts::absrap < 4.7);

	// Veto event if number of jets less than 2
	if (jets.size() < 2) return;

	// Loop over jet pairs
	double deltaY_MN = 0.0;
	for (size_t ij1 = 0; ij1 < jets.size(); ++ij1) {
	for (size_t ij2 = ij1 + 1; ij2 < jets.size(); ++ij2) {
	const double deltaY = fabs(jets[ij1].rapidity() - jets[ij2].rapidity());
	// Exclusive dijet case:
	if (jets.size() == 2) _h_DeltaY_exclusive->fill(deltaY, weight);
	// Inclusive jets case:
	_h_DeltaY_inclusive->fill(deltaY, weight);
	// Mueller-Navelet:
	if (deltaY > deltaY_MN) deltaY_MN = deltaY;
	}
	}
	_h_DeltaY_MN->fill(deltaY_MN, weight);
	}



	void finalize() {
	_h_dijet_ratio = YODA::efficiency(_h_DeltaY_exclusive, *_h_DeltaY_inclusive);
	_h_MN_dijet_ratio = YODA::efficiency(_h_DeltaY_exclusive, *_h_DeltaY_MN);
	transformY(*_h_dijet_ratio, _invert);
	transformY(*_h_MN_dijet_ratio, _invert);
	}


	private:

	/// @name Histograms
	//@{
	Scatter2DPtr _h_dijet_ratio, _h_MN_dijet_ratio;
	Histo1DPtr _h_DeltaY_inclusive, _h_DeltaY_exclusive, _h_DeltaY_MN;
	//@}

	};


	DECLARE_RIVET_PLUGIN(CMS_2012_I1102908);

	}
	diff --git a/src/Analyses/CMS_2012_I1107658.cc b/src/Analyses/CMS_2012_I1107658.cc
	--- a/src/Analyses/CMS_2012_I1107658.cc
	+++ b/src/Analyses/CMS_2012_I1107658.cc
	@@ -1,175 +1,172 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	-#include "Rivet/ParticleName.hh"

	namespace Rivet {

	-
	-

	/// Underlying event activity in the Drell-Yan process at 7 TeV
	class CMS_2012_I1107658 : public Analysis {
	public:

	/// Constructor
	CMS_2012_I1107658()
	: Analysis("CMS_2012_I1107658")
	{ }


	/// Initialization
	void init() {

	/// @note Using a bare muon Z (but with a clustering radius!?)
	Cut cut = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;
	ZFinder zfinder(FinalState(), cut, PID::MUON, 4GeV, 140GeV, 0.2, ZFinder::NOCLUSTER);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	ChargedFinalState cfs(-2, 2, 500*MeV);
	VetoedFinalState nonmuons(cfs);
	nonmuons.addVetoPairId(PID::MUON);
	- addProjection(nonmuons, "nonmuons");
	+ declare(nonmuons, "nonmuons");

	_h_Nchg_towards_pTmumu = bookProfile1D(1, 1, 1);
	_h_Nchg_transverse_pTmumu = bookProfile1D(2, 1, 1);
	_h_Nchg_away_pTmumu = bookProfile1D(3, 1, 1);
	_h_pTsum_towards_pTmumu = bookProfile1D(4, 1, 1);
	_h_pTsum_transverse_pTmumu = bookProfile1D(5, 1, 1);
	_h_pTsum_away_pTmumu = bookProfile1D(6, 1, 1);
	_h_avgpT_towards_pTmumu = bookProfile1D(7, 1, 1);
	_h_avgpT_transverse_pTmumu = bookProfile1D(8, 1, 1);
	_h_avgpT_away_pTmumu = bookProfile1D(9, 1, 1);
	_h_Nchg_towards_plus_transverse_Mmumu = bookProfile1D(10, 1, 1);
	_h_pTsum_towards_plus_transverse_Mmumu = bookProfile1D(11, 1, 1);
	_h_avgpT_towards_plus_transverse_Mmumu = bookProfile1D(12, 1, 1);
	_h_Nchg_towards_zmass_81_101 = bookHisto1D(13, 1, 1);
	_h_Nchg_transverse_zmass_81_101 = bookHisto1D(14, 1, 1);
	_h_Nchg_away_zmass_81_101 = bookHisto1D(15, 1, 1);
	_h_pT_towards_zmass_81_101 = bookHisto1D(16, 1, 1);
	_h_pT_transverse_zmass_81_101 = bookHisto1D(17, 1, 1);
	_h_pT_away_zmass_81_101 = bookHisto1D(18, 1, 1);
	_h_Nchg_transverse_zpt_5 = bookHisto1D(19, 1, 1);
	_h_pT_transverse_zpt_5 = bookHisto1D(20, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");

	if (zfinder.bosons().size() != 1) vetoEvent;

	double Zpt = zfinder.bosons()[0].pT()/GeV;
	double Zphi = zfinder.bosons()[0].phi();
	double Zmass = zfinder.bosons()[0].mass()/GeV;

	- Particles particles = applyProjection<VetoedFinalState>(event, "nonmuons").particles();
	+ Particles particles = apply<VetoedFinalState>(event, "nonmuons").particles();

	int nTowards = 0;
	int nTransverse = 0;
	int nAway = 0;
	double ptSumTowards = 0;
	double ptSumTransverse = 0;
	double ptSumAway = 0;

	foreach (const Particle& p, particles) {
	double dphi = fabs(deltaPhi(Zphi, p.phi()));
	double pT = p.pT();

	if ( dphi < M_PI/3 ) {
	nTowards++;
	ptSumTowards += pT;
	if (Zmass > 81. && Zmass < 101.) _h_pT_towards_zmass_81_101->fill(pT, weight);
	} else if ( dphi < 2.*M_PI/3 ) {
	nTransverse++;
	ptSumTransverse += pT;
	if (Zmass > 81. && Zmass < 101.) _h_pT_transverse_zmass_81_101->fill(pT, weight);
	if (Zpt < 5.) _h_pT_transverse_zpt_5->fill(pT, weight);
	} else {
	nAway++;
	ptSumAway += pT;
	if (Zmass > 81. && Zmass < 101.) _h_pT_away_zmass_81_101->fill(pT, weight);
	}

	} // Loop over particles


	const double area = 8./3.*M_PI;
	if (Zmass > 81. && Zmass < 101.) {
	_h_Nchg_towards_pTmumu-> fill(Zpt, 1./area * nTowards, weight);
	_h_Nchg_transverse_pTmumu-> fill(Zpt, 1./area * nTransverse, weight);
	_h_Nchg_away_pTmumu-> fill(Zpt, 1./area * nAway, weight);
	_h_pTsum_towards_pTmumu-> fill(Zpt, 1./area * ptSumTowards, weight);
	_h_pTsum_transverse_pTmumu-> fill(Zpt, 1./area * ptSumTransverse, weight);
	_h_pTsum_away_pTmumu-> fill(Zpt, 1./area * ptSumAway, weight);
	if (nTowards > 0) _h_avgpT_towards_pTmumu-> fill(Zpt, ptSumTowards/nTowards, weight);
	if (nTransverse > 0) _h_avgpT_transverse_pTmumu-> fill(Zpt, ptSumTransverse/nTransverse, weight);
	if (nAway > 0) _h_avgpT_away_pTmumu-> fill(Zpt, ptSumAway/nAway, weight);
	_h_Nchg_towards_zmass_81_101-> fill(nTowards, weight);
	_h_Nchg_transverse_zmass_81_101->fill(nTransverse, weight);
	_h_Nchg_away_zmass_81_101-> fill(nAway, weight);
	}

	if (Zpt < 5.) {
	_h_Nchg_towards_plus_transverse_Mmumu->fill(Zmass, (nTowards + nTransverse)/(2.*area), weight);
	_h_pTsum_towards_plus_transverse_Mmumu->fill(Zmass, (ptSumTowards + ptSumTransverse)/(2.*area), weight);
	if ((nTowards + nTransverse) > 0) _h_avgpT_towards_plus_transverse_Mmumu->fill(Zmass, (ptSumTowards + ptSumTransverse)/(nTowards + nTransverse), weight);
	_h_Nchg_transverse_zpt_5->fill(nTransverse, weight);
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_pT_towards_zmass_81_101, safediv(1, _h_Nchg_towards_zmass_81_101->integral(), 0));
	scale(_h_pT_transverse_zmass_81_101, safediv(1, _h_Nchg_transverse_zmass_81_101->integral(), 0));
	scale(_h_pT_away_zmass_81_101, safediv(1, _h_Nchg_away_zmass_81_101->integral(), 0));
	scale(_h_pT_transverse_zpt_5, safediv(1, _h_Nchg_transverse_zpt_5->integral(), 0));
	normalize(_h_Nchg_towards_zmass_81_101);
	normalize(_h_Nchg_transverse_zmass_81_101);
	normalize(_h_Nchg_away_zmass_81_101);
	normalize(_h_Nchg_transverse_zpt_5);
	}


	private:


	/// @name Histogram objects
	//@{
	Profile1DPtr _h_Nchg_towards_pTmumu;
	Profile1DPtr _h_Nchg_transverse_pTmumu;
	Profile1DPtr _h_Nchg_away_pTmumu;
	Profile1DPtr _h_pTsum_towards_pTmumu;
	Profile1DPtr _h_pTsum_transverse_pTmumu;
	Profile1DPtr _h_pTsum_away_pTmumu;
	Profile1DPtr _h_avgpT_towards_pTmumu;
	Profile1DPtr _h_avgpT_transverse_pTmumu;
	Profile1DPtr _h_avgpT_away_pTmumu;
	Profile1DPtr _h_Nchg_towards_plus_transverse_Mmumu;
	Profile1DPtr _h_pTsum_towards_plus_transverse_Mmumu;
	Profile1DPtr _h_avgpT_towards_plus_transverse_Mmumu;
	Histo1DPtr _h_Nchg_towards_zmass_81_101;
	Histo1DPtr _h_Nchg_transverse_zmass_81_101;
	Histo1DPtr _h_Nchg_away_zmass_81_101;
	Histo1DPtr _h_pT_towards_zmass_81_101;
	Histo1DPtr _h_pT_transverse_zmass_81_101;
	Histo1DPtr _h_pT_away_zmass_81_101;
	Histo1DPtr _h_Nchg_transverse_zpt_5;
	Histo1DPtr _h_pT_transverse_zpt_5;
	//@}

	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2012_I1107658);

	}
	diff --git a/src/Analyses/CMS_2012_I1184941.cc b/src/Analyses/CMS_2012_I1184941.cc
	--- a/src/Analyses/CMS_2012_I1184941.cc
	+++ b/src/Analyses/CMS_2012_I1184941.cc
	@@ -1,70 +1,70 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	class CMS_2012_I1184941 : public Analysis {
	public:

	CMS_2012_I1184941()
	: Analysis("CMS_2012_I1184941")
	{ }


	void init() {
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	const FastJets jets(FinalState(-4.9, 4.9, 0.0*GeV), FastJets::ANTIKT, 0.5);
	- addProjection(jets, "AntiKtJets05");
	+ declare(jets, "AntiKtJets05");

	_h_xi = bookHisto1D(1, 1, 1);
	}


	void analyze(const Event& event) {
	double xiM = 0.;
	double xiP = 0.;

	- const Jets jets = applyProjection<FastJets>(event, "AntiKtJets05").jetsByPt(20.*GeV);
	+ const Jets jets = apply<FastJets>(event, "AntiKtJets05").jetsByPt(20.*GeV);
	if (jets.size() < 2) vetoEvent; // require a dijet system with a 20 GeV cut on both jets
	if (fabs(jets[0].eta()) > 4.4 \|\| fabs(jets[1].eta()) > 4.4) vetoEvent;

	- const FinalState& fsp = applyProjection<FinalState>(event, "FS");
	+ const FinalState& fsp = apply<FinalState>(event, "FS");

	foreach (const Particle& p, fsp.particles(cmpMomByEta)) {
	const double eta = p.eta();
	const double energy = p.E();
	const double costheta = cos(p.theta());
	// Yes, they really correct to +/- infinity, using Pythia 8 ...
	if (eta < 4.9) xiP += (energy + energy*costheta);
	if (eta > -4.9 ) xiM += (energy - energy*costheta);
	}

	xiP = xiP / (sqrtS()/GeV);
	xiM = xiM / (sqrtS()/GeV);

	const double weight = event.weight();
	_h_xi->fill( xiM, weight ); // Fill the histogram both with xiP and xiM, and get the average in the endjob.
	_h_xi->fill( xiP, weight );
	}


	void finalize() {
	scale( _h_xi, crossSection()/microbarn/sumOfWeights() / 2.);
	}


	private:

	Histo1DPtr _h_xi;

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2012_I1184941);

	}
	diff --git a/src/Analyses/CMS_2012_I1193338.cc b/src/Analyses/CMS_2012_I1193338.cc
	--- a/src/Analyses/CMS_2012_I1193338.cc
	+++ b/src/Analyses/CMS_2012_I1193338.cc
	@@ -1,82 +1,82 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	class CMS_2012_I1193338 : public Analysis {
	public:

	CMS_2012_I1193338()
	: Analysis("CMS_2012_I1193338")
	{ }


	void init() {
	- addProjection(ChargedFinalState(-2.4, 2.4, 0.2*GeV), "CFS");
	- addProjection(FinalState(), "FS");
	+ declare(ChargedFinalState(-2.4, 2.4, 0.2*GeV), "CFS");
	+ declare(FinalState(), "FS");

	_h_sigma = bookHisto1D(1, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	if (cfs.size() > 1) {_h_sigma->fill(1.5, weight);}
	if (cfs.size() > 2) {_h_sigma->fill(2.5, weight);}
	if (cfs.size() > 3) {_h_sigma->fill(3.5, weight);}

	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	if (fs.size() < 2) vetoEvent; // need at least two particles to calculate gaps

	double gapcenter = 0.;
	double LRG = 0.;
	double etapre = 0.;
	bool first = true;

	foreach(const Particle& p, fs.particles(cmpMomByEta)) { // sorted from minus to plus
	if (first) { // First particle
	first = false;
	etapre = p.eta();
	} else {
	double gap = fabs(p.eta()-etapre);
	if (gap > LRG) {
	LRG = gap; // largest gap
	gapcenter = (p.eta()+etapre)/2.; // find the center of the gap to separate the X and Y systems.
	}
	etapre = p.eta();
	}
	}


	FourMomentum mxFourVector, myFourVector;
	foreach(const Particle& p, fs.particles(cmpMomByEta)) {
	((p.eta() > gapcenter) ? mxFourVector : myFourVector) += p.momentum();
	}
	const double M2 = max(mxFourVector.mass2(), myFourVector.mass2());
	const double xi = M2/sqr(sqrtS()); // sqrt(s)=7000 GeV, note that units cancel
	if (xi < 5e-6) vetoEvent;

	_h_sigma->fill(0.5, weight);
	}


	void finalize() {
	scale(_h_sigma, crossSection()/millibarn/sumOfWeights());
	}

	private:

	Histo1DPtr _h_sigma;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2012_I1193338);

	}
	diff --git a/src/Analyses/CMS_2012_I1298807.cc b/src/Analyses/CMS_2012_I1298807.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/CMS_2012_I1298807.cc
	@@ -0,0 +1,200 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/ZFinder.hh"
	+#include "Rivet/Projections/VetoedFinalState.hh"
	+#include "Rivet/Projections/MergedFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// Inclusive ZZ production cross section and constraints on anomalous triple gauge couplings
	+ class CMS_2012_I1298807 : public Analysis {
	+ public:
	+
	+ // Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2012_I1298807);
	+
	+
	+ /// Initialise projections and histograms
	+ void init() {
	+
	+ IdentifiedFinalState leptons(Cuts::abseta < 2.5);
	+ leptons.acceptChLeptons();
	+
	+ FinalState electrons(Cuts::abseta < 2.5 && Cuts::abspid == PID::ELECTRON);
	+ IdentifiedFinalState muons(Cuts::abseta < 2.4 && Cuts::abspid == PID::MUON);
	+
	+ MergedFinalState leptons_cuts(electrons, muons);
	+ declare(electrons, "ELECTRONS");
	+ declare(muons, "MUONS");
	+ declare(leptons_cuts, "LEPTONS_CUTS");
	+
	+ Cut cut_el = Cuts::abseta < 2.5 && Cuts::pT > 7.0*GeV;
	+ Cut cut_mu = Cuts::abseta < 2.4 && Cuts::pT > 5.0*GeV;
	+
	+ ZFinder zeefinder(FinalState(), cut_el, PID::ELECTRON, 60GeV, 120GeV, 0.1, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	+ declare(zeefinder, "ZeeFinder");
	+
	+ ZFinder zmmfinder(FinalState(), cut_mu, PID::MUON, 60GeV, 120GeV, 0.1, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	+ declare(zmmfinder, "ZmmFinder");
	+
	+ VetoedFinalState fs_woZmm;
	+ fs_woZmm.addVetoOnThisFinalState(zmmfinder);
	+
	+ VetoedFinalState fs_woZee;
	+ fs_woZee.addVetoOnThisFinalState(zeefinder);
	+ ZFinder zmmfinder_woZmm(fs_woZmm, cut_mu, PID::MUON, 60GeV, 120GeV, 0.1, ZFinder::CLUSTERNODECAY);
	+ declare(zmmfinder_woZmm, "Zmmfinder_WoZmm");
	+ ZFinder zeefinder_woZee(fs_woZee, cut_el, PID::ELECTRON, 60GeV, 120GeV, 0.1, ZFinder::CLUSTERNODECAY);
	+ declare(zeefinder_woZee, "Zeefinder_WoZee");
	+
	+ // Book histograms
	+ _hist_pt_l1 = bookHisto1D(1, 1, 1);
	+ _hist_pt_z1 = bookHisto1D(1, 1, 2);
	+ _hist_pt_zz = bookHisto1D(1, 1, 3);
	+ _hist_m_zz = bookHisto1D(1, 1, 4);
	+ _hist_dphi_zz = bookHisto1D(1, 1, 5);
	+ _hist_dR_zz = bookHisto1D(1, 1, 6);
	+
	+ }
	+
	+
	+ // Perform the per-event analysis
	+ void analyze(const Event& evt) {
	+
	+ // Find leading leptons and apply cuts
	+ const Particles& leptons = apply<FinalState>(evt, "LEPTONS_CUTS").particlesByPt();
	+ if (leptons.size() < 2) vetoEvent;
	+ const double leading_l_pt = leptons[0].pT();
	+ const double second_l_pt = leptons[1].pT();
	+ if (leading_l_pt < 20GeV \|\| second_l_pt < 10GeV) vetoEvent;
	+
	+ // Find acceptable ZZ combinations and build four-momenta, otherwise veto
	+ const ZFinder& zeefinder = applyProjection<ZFinder>(evt, "ZeeFinder");
	+ const ZFinder& zmmfinder = applyProjection<ZFinder>(evt, "ZmmFinder");
	+ const ZFinder& zmmfinder_woZmm = applyProjection<ZFinder>(evt, "Zmmfinder_WoZmm");
	+ const ZFinder& zeefinder_woZee = applyProjection<ZFinder>(evt, "Zeefinder_WoZee");
	+ FourMomentum pZ_a, pZ_b, pZ_1, pZ_2;
	+ FourMomentum pZZ, Z_a_l1, Z_a_l2, Z_b_l1, Z_b_l2;
	+ if (zeefinder.bosons().size() > 0 && zmmfinder.bosons().size() > 0) {
	+ pZ_a = zeefinder.bosons()[0];
	+ pZ_b = zmmfinder.bosons()[0];
	+ pZZ = pZ_a + pZ_b;
	+ pZ_1 = pZ_a;
	+ pZ_2 = pZ_b;
	+ Z_a_l1 = zeefinder.constituents()[0];
	+ Z_a_l2 = zeefinder.constituents()[1];
	+ Z_b_l1 = zmmfinder.constituents()[0];
	+ Z_b_l2 = zmmfinder.constituents()[1];
	+ } else if (zeefinder.bosons().size() > 0 && zeefinder_woZee.bosons().size() > 0) {
	+ pZ_a = zeefinder.bosons()[0];
	+ pZ_b = zeefinder_woZee.bosons()[0];
	+ pZZ = pZ_a + pZ_b;
	+ pZ_1 = pZ_a;
	+ pZ_2 = pZ_b;
	+ Z_a_l1 = zeefinder.constituents()[0];
	+ Z_a_l2 = zeefinder.constituents()[1];
	+ Z_b_l1 = zeefinder_woZee.constituents()[0];
	+ Z_b_l2 = zeefinder_woZee.constituents()[1];
	+ } else if (zmmfinder.bosons().size() > 0 && zmmfinder_woZmm.bosons().size() > 0) {
	+ pZ_a = zmmfinder.bosons()[0];
	+ pZ_b = zmmfinder_woZmm.bosons()[0];
	+ pZZ = pZ_a + pZ_b;
	+ pZ_1 = pZ_a;
	+ pZ_2 = pZ_b;
	+ Z_a_l1 = zmmfinder.constituents()[0];
	+ Z_a_l2 = zmmfinder.constituents()[1];
	+ Z_b_l1 = zmmfinder_woZmm.constituents()[0];
	+ Z_b_l2 = zmmfinder_woZmm.constituents()[1];
	+ } else {
	+ vetoEvent;
	+ }
	+
	+ // Set ordered pT variables
	+ /// @todo Looks like there should be a nicer way than this
	+ double pt_l1 = Z_a_l1.pT();
	+ if (Z_a_l2.pT() > pt_l1) pt_l1 = Z_a_l2.pT();
	+ if (Z_b_l1.pT() > pt_l1) pt_l1 = Z_b_l1.pT();
	+ if (Z_b_l2.pT() > pt_l1) pt_l1 = Z_b_l2.pT();
	+
	+ // Leading Z pT
	+ double pt_z1 = pZ_a.pT();
	+ if (pZ_b.pT() > pZ_a.pT()) {
	+ pt_z1 = pZ_b.pT();
	+ pZ_1 = pZ_b;
	+ pZ_2 = pZ_a;
	+ }
	+
	+ // Fill histograms
	+ const double weight = evt.weight();
	+ _hist_pt_zz->fill(pZZ.pT()/GeV, weight);
	+ _hist_m_zz->fill(pZZ.mass()/GeV, weight);
	+ _hist_dphi_zz->fill(deltaPhi(pZ_a, pZ_b), weight);
	+ _hist_dR_zz->fill(deltaR(pZ_a, pZ_b, PSEUDORAPIDITY), weight);
	+ _hist_pt_z1->fill(pt_z1/GeV, weight);
	+ _hist_pt_l1->fill(pt_l1/GeV, weight);
	+
	+ }
	+
	+
	+ /// Scale histograms
	+ /// @note This is all needed to undo bin width factor -- WHY DO PEOPLE USE UNPHYSICAL HISTOGRAMS?!?
	+ /// @todo If we introduce a "bar plot" or similar, it'd work better here
	+ void finalize() {
	+
	+ double sum_height_pt_zz = 0;
	+ for (size_t i = 0; i < _hist_pt_zz->numBins(); i++) {
	+ _hist_pt_zz->bin(i).scaleW(1. / _hist_pt_zz->bin(i).width());
	+ sum_height_pt_zz += _hist_pt_zz->bin(i).height();
	+ }
	+ scale(_hist_pt_zz, 1. / sum_height_pt_zz);
	+
	+ double sum_height_m_zz = 0;
	+ for (size_t i = 0; i < _hist_m_zz->numBins(); i++) {
	+ _hist_m_zz->bin(i).scaleW(1. / _hist_m_zz->bin(i).width());
	+ sum_height_m_zz += _hist_m_zz->bin(i).height();
	+ }
	+ scale(_hist_m_zz, 1. / sum_height_m_zz);
	+
	+ double sum_height_dphi_zz = 0;
	+ for (size_t i = 0; i < _hist_dphi_zz->numBins(); i++) {
	+ _hist_dphi_zz->bin(i).scaleW(1. / _hist_dphi_zz->bin(i).width());
	+ sum_height_dphi_zz += _hist_dphi_zz->bin(i).height();
	+ }
	+ scale(_hist_dphi_zz, 1. / sum_height_dphi_zz);
	+
	+ double sum_height_dR_zz = 0;
	+ for (size_t i = 0; i < _hist_dR_zz->numBins(); i++) {
	+ _hist_dR_zz->bin(i).scaleW(1. / _hist_dR_zz->bin(i).width());
	+ sum_height_dR_zz += _hist_dR_zz->bin(i).height();
	+ }
	+ scale(_hist_dR_zz, 1. / sum_height_dR_zz);
	+
	+ double sum_height_pt_z1 = 0;
	+ for (size_t i = 0; i < _hist_pt_z1->numBins(); i++) {
	+ _hist_pt_z1->bin(i).scaleW(1. / _hist_pt_z1->bin(i).width());
	+ sum_height_pt_z1 += _hist_pt_z1->bin(i).height();
	+ }
	+ scale(_hist_pt_z1, 1. / sum_height_pt_z1);
	+
	+ double sum_height_pt_l1 = 0;
	+ for (size_t i = 0; i < _hist_pt_l1->numBins(); i++) {
	+ _hist_pt_l1->bin(i).scaleW(1. / _hist_pt_l1->bin(i).width());
	+ sum_height_pt_l1 += _hist_pt_l1->bin(i).height();
	+ }
	+ scale(_hist_pt_l1, 1. / sum_height_pt_l1);
	+ }
	+
	+
	+ /// Histograms
	+ Histo1DPtr _hist_pt_zz, _hist_m_zz, _hist_dphi_zz, _hist_dR_zz, _hist_pt_z1, _hist_pt_l1;
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(CMS_2012_I1298807);
	+
	+}
	diff --git a/src/Analyses/CMS_2012_I941555.cc b/src/Analyses/CMS_2012_I941555.cc
	--- a/src/Analyses/CMS_2012_I941555.cc
	+++ b/src/Analyses/CMS_2012_I941555.cc
	@@ -1,152 +1,152 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	/// @brief CMS Z pT and rapidity in Drell-Yan events at 7 TeV
	/// @author Justin Hugon, Luca Perrozzi
	class CMS_2012_I941555 : public Analysis {
	public:

	/// Constructor
	CMS_2012_I941555()
	: Analysis("CMS_2012_I941555")
	{
	_sumw_mu_dressed_pt = 0;
	_sumwpeak_mu_dressed = 0;
	_sumw_el_dressed_rap = 0;
	_sumw_el_dressed_pt = 0;
	_sumwpeak_el_dressed = 0;
	}


	/// @name Analysis methods
	//@{

	void init() {

	// Set up projections
	/// @todo Really?: ZFinder zfinder_dressed_mu_pt(-2.1, 2.1, 20, PID::MUON, 60GeV, 120GeV, 0.2, false, true);
	FinalState fs;
	Cut cuts = Cuts::abseta < 2.1 && Cuts::pT > 20*GeV;
	ZFinder zfinder_dressed_mu_pt(fs, cuts, PID::MUON, 60GeV, 120GeV, 0.2);
	- addProjection(zfinder_dressed_mu_pt, "ZFinder_dressed_mu_pt");
	+ declare(zfinder_dressed_mu_pt, "ZFinder_dressed_mu_pt");
	ZFinder zfinder_dressed_el_pt(fs, cuts, PID::ELECTRON, 60GeV, 120GeV, 0.1);
	- addProjection(zfinder_dressed_el_pt, "ZFinder_dressed_el_pt");
	+ declare(zfinder_dressed_el_pt, "ZFinder_dressed_el_pt");

	ZFinder zfinder_dressed_mu_rap(fs, Cuts::open(), PID::MUON, 60GeV, 120GeV, 0.1);
	- addProjection(zfinder_dressed_mu_rap, "ZFinder_dressed_mu_rap");
	+ declare(zfinder_dressed_mu_rap, "ZFinder_dressed_mu_rap");
	ZFinder zfinder_dressed_el_rap(fs, Cuts::open(), PID::ELECTRON, 60GeV, 120GeV, 0.1);
	- addProjection(zfinder_dressed_el_rap, "ZFinder_dressed_el_rap");
	+ declare(zfinder_dressed_el_rap, "ZFinder_dressed_el_rap");

	// Book histograms
	_hist_zrap_mu_dressed = bookHisto1D(1, 1, 1); // muon "dressed" rapidity
	_hist_zrap_el_dressed = bookHisto1D(1, 1, 2); // electron "dressed" rapidity
	_hist_zrap_comb_dressed = bookHisto1D(1, 1, 3); // electron "dressed" rapidity

	_hist_zpt_mu_dressed = bookHisto1D(2, 1, 1); // muon "dressed" pt
	_hist_zpt_el_dressed = bookHisto1D(2, 1, 2); // electron "dressed" pt
	_hist_zpt_comb_dressed = bookHisto1D(2, 1, 3); // electron "dressed" pt

	_hist_zptpeak_mu_dressed = bookHisto1D(3, 1, 1); // muon "dressed" pt peak
	_hist_zptpeak_el_dressed = bookHisto1D(3, 1, 2); // electron "dressed" pt peak
	_hist_zptpeak_comb_dressed = bookHisto1D(3, 1, 3); // electron "dressed" pt peak
	}


	/// Do the analysis
	void analyze(const Event& evt) {
	const double weight = evt.weight();

	- const ZFinder& zfinder_dressed_mu_rap = applyProjection<ZFinder>(evt, "ZFinder_dressed_mu_rap");
	+ const ZFinder& zfinder_dressed_mu_rap = apply<ZFinder>(evt, "ZFinder_dressed_mu_rap");
	if (!zfinder_dressed_mu_rap.bosons().empty()) {
	_sumw_mu_dressed_rap += weight;
	const FourMomentum pZ = zfinder_dressed_mu_rap.bosons()[0].momentum();
	_hist_zrap_mu_dressed->fill(pZ.rapidity()/GeV, weight);
	_hist_zrap_comb_dressed->fill(pZ.rapidity()/GeV, weight);
	}

	- const ZFinder& zfinder_dressed_mu_pt = applyProjection<ZFinder>(evt, "ZFinder_dressed_mu_pt");
	+ const ZFinder& zfinder_dressed_mu_pt = apply<ZFinder>(evt, "ZFinder_dressed_mu_pt");
	if (!zfinder_dressed_mu_pt.bosons().empty()) {
	_sumw_mu_dressed_pt += weight;
	const FourMomentum pZ = zfinder_dressed_mu_pt.bosons()[0].momentum();
	_hist_zpt_mu_dressed->fill(pZ.pT()/GeV, weight);
	_hist_zpt_comb_dressed->fill(pZ.pT()/GeV, weight);
	if (pZ.pT() < 30*GeV) {
	_sumwpeak_mu_dressed += weight;
	_hist_zptpeak_mu_dressed->fill(pZ.pT()/GeV, weight);
	_hist_zptpeak_comb_dressed->fill(pZ.pT()/GeV, weight);
	}
	}

	- const ZFinder& zfinder_dressed_el_rap = applyProjection<ZFinder>(evt, "ZFinder_dressed_el_rap");
	+ const ZFinder& zfinder_dressed_el_rap = apply<ZFinder>(evt, "ZFinder_dressed_el_rap");
	if (!zfinder_dressed_el_rap.bosons().empty()) {
	_sumw_el_dressed_rap += weight;
	const FourMomentum pZ = zfinder_dressed_el_rap.bosons()[0].momentum();
	_hist_zrap_el_dressed->fill(pZ.rapidity()/GeV, weight);
	_hist_zrap_comb_dressed->fill(pZ.rapidity()/GeV, weight);
	}

	- const ZFinder& zfinder_dressed_el_pt = applyProjection<ZFinder>(evt, "ZFinder_dressed_el_pt");
	+ const ZFinder& zfinder_dressed_el_pt = apply<ZFinder>(evt, "ZFinder_dressed_el_pt");
	if (!zfinder_dressed_el_pt.bosons().empty()) {
	_sumw_el_dressed_pt += weight;
	const FourMomentum pZ = zfinder_dressed_el_pt.bosons()[0].momentum();
	_hist_zpt_el_dressed->fill(pZ.pT()/GeV, weight);
	_hist_zpt_comb_dressed->fill(pZ.pT()/GeV, weight);
	if (pZ.pT() < 30*GeV) {
	_sumwpeak_el_dressed += weight;
	_hist_zptpeak_el_dressed->fill(pZ.pT()/GeV, weight);
	_hist_zptpeak_comb_dressed->fill(pZ.pT()/GeV, weight);
	}
	}

	}


	void finalize() {
	scale(_hist_zrap_mu_dressed, safediv(1, _sumw_mu_dressed_rap, 1));
	scale(_hist_zpt_mu_dressed, safediv(1, _sumw_mu_dressed_pt, 1));
	scale(_hist_zptpeak_mu_dressed, safediv(1, _sumwpeak_mu_dressed, 1));

	scale(_hist_zrap_el_dressed, safediv(1, _sumw_el_dressed_rap, 1));
	scale(_hist_zpt_el_dressed, safediv(1, _sumw_el_dressed_pt, 1));
	scale(_hist_zptpeak_el_dressed, safediv(1, _sumwpeak_el_dressed, 1));

	scale(_hist_zrap_comb_dressed, safediv(1, _sumw_el_dressed_rap+_sumw_mu_dressed_rap, 1));
	scale(_hist_zpt_comb_dressed, safediv(1, _sumw_el_dressed_pt+_sumw_mu_dressed_pt, 1));
	scale(_hist_zptpeak_comb_dressed, safediv(1, _sumwpeak_el_dressed+_sumwpeak_mu_dressed, 1));
	}

	//@}


	private:

	double _sumw_mu_dressed_rap;
	double _sumw_mu_dressed_pt;
	double _sumwpeak_mu_dressed;

	double _sumw_el_dressed_rap;
	double _sumw_el_dressed_pt;
	double _sumwpeak_el_dressed;

	Histo1DPtr _hist_zrap_mu_dressed;
	Histo1DPtr _hist_zpt_mu_dressed;
	Histo1DPtr _hist_zptpeak_mu_dressed;

	Histo1DPtr _hist_zrap_el_dressed;
	Histo1DPtr _hist_zpt_el_dressed;
	Histo1DPtr _hist_zptpeak_el_dressed;

	Histo1DPtr _hist_zrap_comb_dressed;
	Histo1DPtr _hist_zpt_comb_dressed;
	Histo1DPtr _hist_zptpeak_comb_dressed;

	};


	DECLARE_RIVET_PLUGIN(CMS_2012_I941555);

	}
	diff --git a/src/Analyses/CMS_2012_PAS_FSQ_12_020.cc b/src/Analyses/CMS_2012_PAS_FSQ_12_020.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/CMS_2012_PAS_FSQ_12_020.cc
	@@ -0,0 +1,109 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief CMS underlying event in leading track events at 7 TeV
	+ /// @author Paolo Gunnellini (DESY)
	+ ///
	+ /// CMS measurement of the underlying event in "leading track" events.
	+ class CMS_PAS_FSQ_12_020 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CMS_PAS_FSQ_12_020);
	+
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ const ChargedFinalState cfs(Cuts::abseta < 0.8 && Cuts::pT > 0.5*GeV);
	+ addProjection(cfs, "Tracks");
	+
	+ _NchgPDFden1 = bookProfile1D(7,1,1);
	+ _NchgPMNden1 = bookProfile1D(6,1,1);
	+ _NchgPMXden1 = bookProfile1D(5,1,1);
	+
	+ _PTsumPDFden1 = bookProfile1D(10,1,1);
	+ _PTsumPMNden1 = bookProfile1D(9,1,1);
	+ _PTsumPMXden1 = bookProfile1D(8,1,1);
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+
	+ // Require at least one track in the event with pT >= 0.5 GeV
	+ const FinalState& cfs = applyProjection<ChargedFinalState>(event, "Tracks");
	+ if (cfs.empty()) vetoEvent;
	+ const Particles trks = cfs.particlesByPt();
	+
	+ // Identify leading track and its phi and pT
	+ const Particle p_lead = trks[0];
	+ const double philead = p_lead.momentum().phi();
	+ const double ptlead = p_lead.momentum().pT();
	+
	+ // Loop over particles and build transverse side variables
	+ double NchgP1 = 0, NchgP2 = 0, PTsumP1 = 0, PTsumP2 = 0;
	+ for (const Particle& p : trks) {
	+
	+ // Region definition -- if not in transverse region, ignore
	+ const double dphi = mapAngle0To2Pi(p.phi() - philead);
	+ if (!inRange(dphi, PI/3, 2PI/3) && !inRange(dphi, 4PI/3, 5*PI/3)) continue;
	+
	+ // Transverse region 1
	+ if (inRange(dphi, PI/3, 2*PI/3)) {
	+ NchgP1 += 1;
	+ PTsumP1 += p.pT();
	+ }
	+ // Transverse region 2
	+ else if (inRange(dphi, 4PI/3, 5PI/3)) {
	+ NchgP2 += 1;
	+ PTsumP2 += p.pT();
	+ }
	+ }
	+
	+ // Calculate total variables
	+ // const double NchgPtot = (NchgP1 + NchgP2)/2;
	+ const double NchgPmax = max(NchgP1,NchgP2);
	+ const double NchgPmin = min(NchgP1,NchgP2);
	+ // const double PTsumPtot = (PTsumP1 + PTsumP2)/2;
	+ const double PTsumPmax = max(PTsumP1,PTsumP2);
	+ const double PTsumPmin = min(PTsumP1,PTsumP2);
	+ //
	+ const double PTsumPMXden = PTsumPmax/AREA;
	+ const double PTsumPMNden = PTsumPmin/AREA;
	+ const double NchgPMXden = NchgPmax/AREA;
	+ const double NchgPMNden = NchgPmin/AREA;
	+ //
	+ const double NchgPDFden = NchgPMXden - NchgPMNden;
	+ const double PTsumPDFden = PTsumPMXden - PTsumPMNden;
	+
	+ // Fill histograms
	+ const double weight = event.weight();
	+ _NchgPMXden1->fill(ptlead/GeV, NchgPmax/AREA, weight);
	+ _NchgPMNden1->fill(ptlead/GeV, NchgPmin/AREA, weight);
	+ _NchgPDFden1->fill(ptlead/GeV, NchgPDFden, weight);
	+ _PTsumPMXden1->fill(ptlead/GeV, PTsumPmax/AREA, weight);
	+ _PTsumPMNden1->fill(ptlead/GeV, PTsumPmin/AREA, weight);
	+ _PTsumPDFden1->fill(ptlead/GeV, PTsumPDFden, weight);
	+
	+ }
	+
	+
	+ /// eta-phi area of the transverse region
	+ constexpr static double AREA = 20.8 M_PI/3;
	+
	+ /// Histograms
	+ Profile1DPtr _NchgPden1, _NchgPMXden1, _NchgPMNden1, _NchgPDFden1, _PTsumPden1, _PTsumPMXden1, _PTsumPMNden1, _PTsumPDFden1;
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(CMS_PAS_FSQ_12_020);
	+
	+}
	diff --git a/src/Analyses/CMS_2012_PAS_QCD_11_010.cc b/src/Analyses/CMS_2012_PAS_QCD_11_010.cc
	--- a/src/Analyses/CMS_2012_PAS_QCD_11_010.cc
	+++ b/src/Analyses/CMS_2012_PAS_QCD_11_010.cc
	@@ -1,89 +1,89 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {

	class CMS_2012_PAS_QCD_11_010 : public Analysis {
	public:

	CMS_2012_PAS_QCD_11_010()
	: Analysis("CMS_2012_PAS_QCD_11_010")
	{ }

	void init() {
	const FastJets jets(ChargedFinalState(Cuts::abseta < 2.5 && Cuts::pT > 0.5*GeV), FastJets::ANTIKT, 0.5);
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	const UnstableFinalState ufs(Cuts::abseta < 2 && Cuts::pT > 0.6*GeV);
	- addProjection(ufs, "UFS");
	+ declare(ufs, "UFS");

	_h_nTrans_Lambda = bookProfile1D(1, 1, 1);
	_h_nTrans_Kaon = bookProfile1D(2, 1, 1);
	_h_ptsumTrans_Lambda = bookProfile1D(3, 1, 1);
	_h_ptsumTrans_Kaon = bookProfile1D(4, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- Jets jets = applyProjection<FastJets>(event, "Jets").jetsByPt(1.0*GeV);
	+ Jets jets = apply<FastJets>(event, "Jets").jetsByPt(1.0*GeV);
	if (jets.size() < 1) vetoEvent;

	if (fabs(jets[0].eta()) >= 2) { // cuts on leading jets
	vetoEvent;
	}

	FourMomentum p_lead = jets[0].momentum();
	const double pTlead = p_lead.pT();

	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");

	int numTrans_Kaon = 0;
	int numTrans_Lambda = 0;
	double ptSumTrans_Kaon = 0.;
	double ptSumTrans_Lambda = 0.;

	foreach (const Particle& p, ufs.particles()) {
	double dphi = deltaPhi(p, p_lead);
	double pT = p.pT();
	const PdgId id = p.abspid();

	if (dphi > PI/3. && dphi < 2./3.*PI) {
	if (id == 310 && pT > 0.6*GeV) {
	ptSumTrans_Kaon += pT/GeV;
	numTrans_Kaon++;
	}
	else if (id == 3122 && pT > 1.5*GeV) {
	ptSumTrans_Lambda += pT/GeV;
	numTrans_Lambda++;
	}
	}
	}

	_h_nTrans_Kaon->fill(pTlead/GeV, numTrans_Kaon / (8.0 * PI/3.0), weight);
	_h_nTrans_Lambda->fill(pTlead/GeV, numTrans_Lambda / (8.0 * PI/3.0), weight);
	_h_ptsumTrans_Kaon->fill(pTlead/GeV, ptSumTrans_Kaon / (GeV * (8.0 * PI/3.0)), weight);
	_h_ptsumTrans_Lambda->fill(pTlead/GeV, ptSumTrans_Lambda / (GeV * (8.0 * PI/3.0)), weight);
	}


	void finalize() { }

	private:

	Profile1DPtr _h_nTrans_Kaon;
	Profile1DPtr _h_nTrans_Lambda;
	Profile1DPtr _h_ptsumTrans_Kaon;
	Profile1DPtr _h_ptsumTrans_Lambda;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2012_PAS_QCD_11_010);

	}
	diff --git a/src/Analyses/CMS_2013_I1122847.cc b/src/Analyses/CMS_2013_I1122847.cc
	--- a/src/Analyses/CMS_2013_I1122847.cc
	+++ b/src/Analyses/CMS_2013_I1122847.cc
	@@ -1,237 +1,201 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {

	- using namespace Cuts;

	class CMS_2013_I1122847 : public Analysis {
	public:

	/// Constructor
	CMS_2013_I1122847()
	: Analysis("CMS_2013_I1122847") {}

	+
	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs;

	- Cut cuts_mu = etaIn(-2.4, 2.4) & (pT >= 20.0*GeV);
	+ Cut cuts_mu = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;
	ZFinder zfinder_mu(fs, cuts_mu, PID::MUON, 40.0*GeV, MAXDOUBLE,
	0.0, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);
	- addProjection(zfinder_mu, "zfinder_mu");
	+ declare(zfinder_mu, "zfinder_mu");

	- Cut cuts_el = (pT >= 20.0*GeV) & ((abseta < 1.447) \| ((abseta > 1.57) & (abseta < 2.4)));
	+ Cut cuts_el = (Cuts::pT >= 20*GeV && Cuts::abseta < 2.4 && !Cuts::absetaIn(1.447, 1.57));
	ZFinder zfinder_el(fs, cuts_el, PID::ELECTRON, 40.0*GeV, MAXDOUBLE,
	0.0, ZFinder::CLUSTERNODECAY, ZFinder::NOTRACK);
	- addProjection(zfinder_el, "zfinder_el");
	+ declare(zfinder_el, "zfinder_el");


	- /// histograms
	+ /// Histograms
	// dimuon
	_hist_mm_100_num = Histo1D(refData(1, 1, 1));
	_hist_mm_125_num = Histo1D(refData(1, 1, 2));
	_hist_mm_150_num = Histo1D(refData(1, 1, 3));
	_hist_mm_240_num = Histo1D(refData(1, 1, 4));

	_hist_mm_100_den = Histo1D(refData(1, 1, 1));
	_hist_mm_125_den = Histo1D(refData(1, 1, 2));
	_hist_mm_150_den = Histo1D(refData(1, 1, 3));
	_hist_mm_240_den = Histo1D(refData(1, 1, 4));

	- // dielectron
	+ // Dielectron
	_hist_ee_100_num = Histo1D(refData(2, 1, 1));
	_hist_ee_125_num = Histo1D(refData(2, 1, 2));
	_hist_ee_150_num = Histo1D(refData(2, 1, 3));
	_hist_ee_240_num = Histo1D(refData(2, 1, 4));

	_hist_ee_100_den = Histo1D(refData(2, 1, 1));
	_hist_ee_125_den = Histo1D(refData(2, 1, 2));
	_hist_ee_150_den = Histo1D(refData(2, 1, 3));
	_hist_ee_240_den = Histo1D(refData(2, 1, 4));

	- // dilepton
	+ // Dilepton
	_hist_ll_100_num = Histo1D(refData(3, 1, 1));
	_hist_ll_125_num = Histo1D(refData(3, 1, 2));
	_hist_ll_150_num = Histo1D(refData(3, 1, 3));
	_hist_ll_240_num = Histo1D(refData(3, 1, 4));

	_hist_ll_100_den = Histo1D(refData(3, 1, 1));
	_hist_ll_125_den = Histo1D(refData(3, 1, 2));
	_hist_ll_150_den = Histo1D(refData(3, 1, 3));
	_hist_ll_240_den = Histo1D(refData(3, 1, 4));
	}

	- double cosThetaCS(const Particle& l1, const Particle& l2) {

	- FourMomentum mom1 = l1.momentum();
	- FourMomentum mom2 = l2.momentum();
	+ double cosThetaCS(const Particle& l1, const Particle& l2) {
	+ const FourMomentum mom1 = l1.mom();
	+ const FourMomentum mom2 = l2.mom();
	+ const FourMomentum mom12 = mom1 + mom2;
	+ const double Q = mom12.mass();
	+ const double QT = mom12.pT();
	+ const double QZ = mom12.pz();

	- double Q = FourMomentum(mom1 + mom2).mass();
	- double QT = sqrt(pow((mom1.px() + mom2.px()), 2) + pow((mom1.py() + mom2.py()), 2));
	+ /// @todo Why include factors of sqrt2 which then get immediately multiplied then divided out?
	+ const double sqrt2 = sqrt(2.0);
	+ /// @todo Can be done more nicely via PID-ordered references to mom1, mom2
	+ const double P1p = ((l1.pid() > 0) ? (mom1.E() + mom1.pz()) : (mom2.E() + mom2.pz())) / sqrt2;
	+ const double P1m = ((l1.pid() > 0) ? (mom1.E() - mom1.pz()) : (mom2.E() - mom2.pz())) / sqrt2;
	+ const double P2p = ((l1.pid() > 0) ? (mom2.E() + mom2.pz()) : (mom1.E() + mom1.pz())) / sqrt2;
	+ const double P2m = ((l1.pid() > 0) ? (mom2.E() - mom2.pz()) : (mom1.E() - mom1.pz())) / sqrt2;

	- double P1p = 0.0;
	- double P1m = 0.0;
	- double P2p = 0.0;
	- double P2m = 0.0;
	-
	-
	- if (l1.pid() > 0) {
	- P1p = (mom1.E() + mom1.pz()) / sqrt(2.0);
	- P1m = (mom1.E() - mom1.pz()) / sqrt(2.0);
	- P2p = (mom2.E() + mom2.pz()) / sqrt(2.0);
	- P2m = (mom2.E() - mom2.pz()) / sqrt(2.0);
	- } else if (l1.pid() < 0) {
	- P1p = (mom2.E() + mom2.pz()) / sqrt(2.0);
	- P1m = (mom2.E() - mom2.pz()) / sqrt(2.0);
	- P2p = (mom1.E() + mom1.pz()) / sqrt(2.0);
	- P2m = (mom1.E() - mom1.pz()) / sqrt(2.0);
	- }
	-
	- double QZ = mom1.pz() + mom2.pz();
	- double cosThetaCS = (2 / (Q * sqrt(Q * Q + QT * QT))) * (P1p * P2m - P1m * P2p);
	- if (QZ < 0.0)
	- cosThetaCS = -cosThetaCS;
	-
	+ const double cosThetaCS = sign(QZ) * (2 / (Q * add_quad(Q, QT))) * (P1pP2m - P1mP2p);
	return cosThetaCS;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ZFinder& zfinder_el = applyProjection<ZFinder>(event, "zfinder_el");
	+ const ZFinder& zfinder_el = apply<ZFinder>(event, "zfinder_el");
	if (zfinder_el.bosons().size() > 0) {
	const Particle& z = zfinder_el.bosons()[0];
	const Particle& l1 = zfinder_el.constituents()[0];
	const Particle& l2 = zfinder_el.constituents()[1];

	// Prepare variables for filling
	- double rap = z.momentum().absrap();
	- double costhetacs = cosThetaCS(l1, l2);
	+ const double rap = z.absrap();
	+ const double costhetacs = cosThetaCS(l1, l2);
	+ const double sgn = sign(costhetacs);

	- double sign = 1.0;
	- if (costhetacs < 0.) sign = -1.0;
	// Fill the histograms
	if (rap < 1.0) {
	- _hist_ee_100_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ll_100_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ee_100_den.fill(z.momentum().mass(), weight);
	- _hist_ll_100_den.fill(z.momentum().mass(), weight);
	+ _hist_ee_100_num.fill(z.mass(), weight * sgn);
	+ _hist_ll_100_num.fill(z.mass(), weight * sgn);
	+ _hist_ee_100_den.fill(z.mass(), weight);
	+ _hist_ll_100_den.fill(z.mass(), weight);
	} else if (rap < 1.25) {
	- _hist_ee_125_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ll_125_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ee_125_den.fill(z.momentum().mass(), weight);
	- _hist_ll_125_den.fill(z.momentum().mass(), weight);
	+ _hist_ee_125_num.fill(z.mass(), weight * sgn);
	+ _hist_ll_125_num.fill(z.mass(), weight * sgn);
	+ _hist_ee_125_den.fill(z.mass(), weight);
	+ _hist_ll_125_den.fill(z.mass(), weight);
	} else if (rap < 1.50) {
	- _hist_ee_150_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ll_150_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ee_150_den.fill(z.momentum().mass(), weight);
	- _hist_ll_150_den.fill(z.momentum().mass(), weight);
	+ _hist_ee_150_num.fill(z.mass(), weight * sgn);
	+ _hist_ll_150_num.fill(z.mass(), weight * sgn);
	+ _hist_ee_150_den.fill(z.mass(), weight);
	+ _hist_ll_150_den.fill(z.mass(), weight);
	} else if (rap < 2.40) {
	- _hist_ee_240_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ll_240_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ee_240_den.fill(z.momentum().mass(), weight);
	- _hist_ll_240_den.fill(z.momentum().mass(), weight);
	+ _hist_ee_240_num.fill(z.mass(), weight * sgn);
	+ _hist_ll_240_num.fill(z.mass(), weight * sgn);
	+ _hist_ee_240_den.fill(z.mass(), weight);
	+ _hist_ll_240_den.fill(z.mass(), weight);
	}
	}

	- const ZFinder& zfinder_mu = applyProjection<ZFinder>(event, "zfinder_mu");
	+ const ZFinder& zfinder_mu = apply<ZFinder>(event, "zfinder_mu");
	if (zfinder_mu.bosons().size() > 0) {
	const Particle& z = zfinder_mu.bosons()[0];
	const Particle& l1 = zfinder_mu.constituents()[0];
	const Particle& l2 = zfinder_mu.constituents()[1];

	// Prepare variables for filling
	- double rap = z.momentum().absrap();
	- double costhetacs = cosThetaCS(l1, l2);
	-
	- double sign = 1.0;
	- if (costhetacs < 0.) sign = -1.0;
	+ const double rap = z.absrap();
	+ const double costhetacs = cosThetaCS(l1, l2);
	+ const double sgn = sign(costhetacs);

	// Fill the histograms
	if (rap < 1.0) {
	- _hist_mm_100_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ll_100_num.fill(z.momentum().mass(), weight * sign);
	- _hist_mm_100_den.fill(z.momentum().mass(), weight);
	- _hist_ll_100_den.fill(z.momentum().mass(), weight);
	+ _hist_mm_100_num.fill(z.mass(), weight * sgn);
	+ _hist_ll_100_num.fill(z.mass(), weight * sgn);
	+ _hist_mm_100_den.fill(z.mass(), weight);
	+ _hist_ll_100_den.fill(z.mass(), weight);
	} else if (rap < 1.25) {
	- _hist_mm_125_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ll_125_num.fill(z.momentum().mass(), weight * sign);
	- _hist_mm_125_den.fill(z.momentum().mass(), weight);
	- _hist_ll_125_den.fill(z.momentum().mass(), weight);
	+ _hist_mm_125_num.fill(z.mass(), weight * sgn);
	+ _hist_ll_125_num.fill(z.mass(), weight * sgn);
	+ _hist_mm_125_den.fill(z.mass(), weight);
	+ _hist_ll_125_den.fill(z.mass(), weight);
	} else if (rap < 1.50) {
	- _hist_mm_150_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ll_150_num.fill(z.momentum().mass(), weight * sign);
	- _hist_mm_150_den.fill(z.momentum().mass(), weight);
	- _hist_ll_150_den.fill(z.momentum().mass(), weight);
	+ _hist_mm_150_num.fill(z.mass(), weight * sgn);
	+ _hist_ll_150_num.fill(z.mass(), weight * sgn);
	+ _hist_mm_150_den.fill(z.mass(), weight);
	+ _hist_ll_150_den.fill(z.mass(), weight);
	} else if (rap < 2.40) {
	- _hist_mm_240_num.fill(z.momentum().mass(), weight * sign);
	- _hist_ll_240_num.fill(z.momentum().mass(), weight * sign);
	- _hist_mm_240_den.fill(z.momentum().mass(), weight);
	- _hist_ll_240_den.fill(z.momentum().mass(), weight);
	+ _hist_mm_240_num.fill(z.mass(), weight * sgn);
	+ _hist_ll_240_num.fill(z.mass(), weight * sgn);
	+ _hist_mm_240_den.fill(z.mass(), weight);
	+ _hist_ll_240_den.fill(z.mass(), weight);
	}
	}
	}

	+
	/// Normalise histograms etc., after the run
	void finalize() {
	divide(_hist_mm_100_num, _hist_mm_100_den, bookScatter2D(1, 1, 1));
	divide(_hist_mm_125_num, _hist_mm_125_den, bookScatter2D(1, 1, 2));
	divide(_hist_mm_150_num, _hist_mm_150_den, bookScatter2D(1, 1, 3));
	divide(_hist_mm_240_num, _hist_mm_240_den, bookScatter2D(1, 1, 4));

	divide(_hist_ee_100_num, _hist_ee_100_den, bookScatter2D(2, 1, 1));
	divide(_hist_ee_125_num, _hist_ee_125_den, bookScatter2D(2, 1, 2));
	divide(_hist_ee_150_num, _hist_ee_150_den, bookScatter2D(2, 1, 3));
	divide(_hist_ee_240_num, _hist_ee_240_den, bookScatter2D(2, 1, 4));

	divide(_hist_ll_100_num, _hist_ll_100_den, bookScatter2D(3, 1, 1));
	divide(_hist_ll_125_num, _hist_ll_125_den, bookScatter2D(3, 1, 2));
	divide(_hist_ll_150_num, _hist_ll_150_den, bookScatter2D(3, 1, 3));
	divide(_hist_ll_240_num, _hist_ll_240_den, bookScatter2D(3, 1, 4));
	}

	+
	private:
	+
	/// Histograms
	- Histo1D _hist_ee_100_num;
	- Histo1D _hist_ee_125_num;
	- Histo1D _hist_ee_150_num;
	- Histo1D _hist_ee_240_num;
	-
	- Histo1D _hist_ee_100_den;
	- Histo1D _hist_ee_125_den;
	- Histo1D _hist_ee_150_den;
	- Histo1D _hist_ee_240_den;
	-
	- Histo1D _hist_mm_100_num;
	- Histo1D _hist_mm_125_num;
	- Histo1D _hist_mm_150_num;
	- Histo1D _hist_mm_240_num;
	-
	- Histo1D _hist_mm_100_den;
	- Histo1D _hist_mm_125_den;
	- Histo1D _hist_mm_150_den;
	- Histo1D _hist_mm_240_den;
	-
	- Histo1D _hist_ll_100_num;
	- Histo1D _hist_ll_125_num;
	- Histo1D _hist_ll_150_num;
	- Histo1D _hist_ll_240_num;
	-
	- Histo1D _hist_ll_100_den;
	- Histo1D _hist_ll_125_den;
	- Histo1D _hist_ll_150_den;
	- Histo1D _hist_ll_240_den;
	+ Histo1D _hist_ee_100_num, _hist_ee_125_num, _hist_ee_150_num, _hist_ee_240_num;
	+ Histo1D _hist_ee_100_den, _hist_ee_125_den, _hist_ee_150_den, _hist_ee_240_den;
	+ Histo1D _hist_mm_100_num, _hist_mm_125_num, _hist_mm_150_num, _hist_mm_240_num;
	+ Histo1D _hist_mm_100_den, _hist_mm_125_den, _hist_mm_150_den, _hist_mm_240_den;
	+ Histo1D _hist_ll_100_num, _hist_ll_125_num, _hist_ll_150_num, _hist_ll_240_num;
	+ Histo1D _hist_ll_100_den, _hist_ll_125_den, _hist_ll_150_den, _hist_ll_240_den;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2013_I1122847);

	}
	diff --git a/src/Analyses/CMS_2013_I1208923.cc b/src/Analyses/CMS_2013_I1208923.cc
	--- a/src/Analyses/CMS_2013_I1208923.cc
	+++ b/src/Analyses/CMS_2013_I1208923.cc
	@@ -1,79 +1,79 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {

	// This analysis is a derived from the class Analysis:
	class CMS_2013_I1208923 : public Analysis {

	public:
	// Constructor
	CMS_2013_I1208923()
	: Analysis("CMS_2013_I1208923") {
	//setNeedsCrossSection(true);
	}

	// Book histograms and initialize projections:
	void init() {
	const FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Initialize the projections
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.7), "Jets");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.7), "Jets");

	// Book histograms
	_h_sigma.addHistogram(0.0, 0.5, bookHisto1D(1, 1, 1));
	_h_sigma.addHistogram(0.5, 1.0, bookHisto1D(1, 1, 2));
	_h_sigma.addHistogram(1.0, 1.5, bookHisto1D(1, 1, 3));
	_h_sigma.addHistogram(1.5, 2.0, bookHisto1D(1, 1, 4));
	_h_sigma.addHistogram(2.0, 2.5, bookHisto1D(1, 1, 5));

	_h_invMass.addHistogram(0.0, 0.5, bookHisto1D(2, 1, 1));
	_h_invMass.addHistogram(0.5, 1.0, bookHisto1D(2, 1, 2));
	_h_invMass.addHistogram(1.0, 1.5, bookHisto1D(2, 1, 3));
	_h_invMass.addHistogram(1.5, 2.0, bookHisto1D(2, 1, 4));
	_h_invMass.addHistogram(2.0, 2.5, bookHisto1D(2, 1, 5));
	}

	// Analysis
	void analyze(const Event &event) {
	const double weight = event.weight();
	- const FastJets &fJets = applyProjection<FastJets>(event, "Jets");
	+ const FastJets &fJets = apply<FastJets>(event, "Jets");

	// Fill the jet pT spectra
	const Jets& jets = fJets.jetsByPt(Cuts::pt>100.*GeV && Cuts::absrap <2.5);
	foreach (const Jet &j, jets) {
	_h_sigma.fill(fabs(j.momentum().rapidity()), j.momentum().pT() / GeV, weight);
	}

	// Require two jets
	const Jets& dijets = fJets.jetsByPt(Cuts::pt>30.*GeV && Cuts::absrap < 2.5);
	if (dijets.size() > 1) {
	if (dijets[0].momentum().pT() / GeV > 60.) {
	// Fill the invariant mass histogram
	double ymax = max(dijets[0].momentum().absrapidity(), dijets[1].momentum().absrapidity());
	double invMass = FourMomentum(dijets[0].momentum() + dijets[1].momentum()).mass();
	_h_invMass.fill(fabs(ymax), invMass, weight);
	}
	}

	}


	// Scale histograms by the production cross section
	void finalize() {
	_h_sigma.scale( crossSection() / sumOfWeights() / 2.0, this);
	_h_invMass.scale(crossSection() / sumOfWeights() / 2.0, this);
	}

	private:
	BinnedHistogram<double> _h_sigma;
	BinnedHistogram<double> _h_invMass;
	};

	// This global object acts as a hook for the plugin system.
	DECLARE_RIVET_PLUGIN(CMS_2013_I1208923);
	}
	diff --git a/src/Analyses/CMS_2013_I1209721.cc b/src/Analyses/CMS_2013_I1209721.cc
	--- a/src/Analyses/CMS_2013_I1209721.cc
	+++ b/src/Analyses/CMS_2013_I1209721.cc
	@@ -1,166 +1,166 @@
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/Thrust.hh"

	namespace Rivet {




	/// CMS Z+jets delta(phi) and jet thrust measurement at 7 TeV
	class CMS_2013_I1209721 : public Analysis {
	public:

	CMS_2013_I1209721()
	: Analysis("CMS_2013_I1209721")
	{ }


	/// Book projections and histograms
	void init() {
	// Full final state
	const FinalState fs(-5.0,5.0);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	// Z finders for electrons and muons
	Cut cuts = Cuts::abseta < 2.4 && Cuts::pT > 20*GeV;
	const ZFinder zfe(fs, cuts, PID::ELECTRON, 71GeV, 111GeV);
	const ZFinder zfm(fs, cuts, PID::MUON, 71GeV, 111GeV);
	- addProjection(zfe, "ZFE");
	- addProjection(zfm, "ZFM");
	+ declare(zfe, "ZFE");
	+ declare(zfm, "ZFM");
	// Jets
	const FastJets jets(fs, FastJets::ANTIKT, 0.5);
	- addProjection(jets, "JETS");
	+ declare(jets, "JETS");

	// Book histograms from data
	for (size_t i = 0; i < 2; ++i) {
	_histDeltaPhiZJ1_1[i] = bookHisto1D(1+i*9, 1, 1);
	_histDeltaPhiZJ1_2[i] = bookHisto1D(2+i*9, 1, 1);
	_histDeltaPhiZJ1_3[i] = bookHisto1D(4+i*9, 1, 1);
	_histDeltaPhiZJ2_3[i] = bookHisto1D(5+i*9, 1, 1);
	_histDeltaPhiZJ3_3[i] = bookHisto1D(3+i*9, 1, 1);
	_histDeltaPhiJ1J2_3[i] = bookHisto1D(6+i*9, 1, 1);
	_histDeltaPhiJ1J3_3[i] = bookHisto1D(7+i*9, 1, 1);
	_histDeltaPhiJ2J3_3[i] = bookHisto1D(8+i*9, 1, 1);
	_histTransvThrust[i] = bookHisto1D(9+i*9, 1, 1);
	}
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	// Apply the Z finders
	- const ZFinder& zfe = applyProjection<ZFinder>(event, "ZFE");
	- const ZFinder& zfm = applyProjection<ZFinder>(event, "ZFM");
	+ const ZFinder& zfe = apply<ZFinder>(event, "ZFE");
	+ const ZFinder& zfm = apply<ZFinder>(event, "ZFM");

	// Choose the Z candidate (there must be one)
	if (zfe.empty() && zfm.empty()) vetoEvent;
	const ParticleVector& z = !zfm.empty() ? zfm.bosons() : zfe.bosons();
	const ParticleVector& leptons = !zfm.empty() ? zfm.constituents() : zfe.constituents();

	// Determine whether we are in the boosted regime
	const bool is_boosted = (z[0].pT() > 150*GeV);

	// Build the jets
	- const FastJets& jetfs = applyProjection<FastJets>(event, "JETS");
	+ const FastJets& jetfs = apply<FastJets>(event, "JETS");
	const Jets& jets = jetfs.jetsByPt(Cuts::pT > 50*GeV && Cuts::abseta < 2.5);

	// Clean the jets against the lepton candidates, as in the paper, with a deltaR cut of 0.4 against the clustered leptons
	vector<const Jet*> cleanedJets;
	for (size_t i = 0; i < jets.size(); ++i) {
	bool isolated = true;
	for (size_t j = 0; j < 2; ++j) {
	if (deltaR(leptons[j], jets[i]) < 0.4) {
	isolated = false;
	break;
	}
	}
	if (isolated) cleanedJets.push_back(&jets[i]);
	}

	// Require at least 1 jet
	const unsigned int Njets = cleanedJets.size();
	if (Njets < 1) vetoEvent;

	// Now compute the thrust
	// Collect Z and jets transverse momenta to calculate transverse thrust
	vector<Vector3> momenta;
	momenta.clear();
	Vector3 mom = z[0].p3();
	mom.setZ(0);
	momenta.push_back(mom);

	for (size_t i = 0; i < cleanedJets.size(); ++i) {
	Vector3 mj = cleanedJets[i]->momentum().p3();
	mj.setZ(0);
	momenta.push_back(mj);
	}

	if (momenta.size() <= 2){
	// We need to use a ghost so that Thrust.calc() doesn't return 1.
	momenta.push_back(Vector3(0.0000001,0.0000001,0.));
	}

	// Define a macro to appropriately fill both unboosted and boosted histo versions
	#define FILLx2(HNAME, VAL) do { double x = VAL; for (size_t i = 0; i < 2; ++i) { \
	if (i == 0 \|\| is_boosted) HNAME[i]->fill(x, weight); } } while(0)

	Thrust thrust; thrust.calc(momenta);
	const double T = thrust.thrust();
	FILLx2(_histTransvThrust, log(max(1-T, 1e-6)));

	const double dphiZJ1 = deltaPhi(z[0], *cleanedJets[0]);
	FILLx2(_histDeltaPhiZJ1_1, dphiZJ1);
	if (Njets > 1) {
	FILLx2(_histDeltaPhiZJ1_2, dphiZJ1);
	if (Njets > 2) {
	FILLx2(_histDeltaPhiZJ1_3, dphiZJ1);
	FILLx2(_histDeltaPhiZJ2_3, deltaPhi(z[0], *cleanedJets[1]));
	FILLx2(_histDeltaPhiZJ3_3, deltaPhi(z[0], *cleanedJets[2]));
	FILLx2(_histDeltaPhiJ1J2_3, deltaPhi(cleanedJets[0], cleanedJets[1]));
	FILLx2(_histDeltaPhiJ1J3_3, deltaPhi(cleanedJets[0], cleanedJets[2]));
	FILLx2(_histDeltaPhiJ2J3_3, deltaPhi(cleanedJets[1], cleanedJets[2]));
	}
	}
	}


	/// Normalizations
	/// @note Most of these data normalizations neglect the overflow bins
	void finalize() {
	for (size_t i = 0; i < 2; ++i) {
	normalize(_histDeltaPhiZJ1_1[i], 1, false);
	normalize(_histDeltaPhiZJ1_2[i], 1, false);
	normalize(_histDeltaPhiZJ1_3[i], 1, false);
	normalize(_histDeltaPhiZJ2_3[i], 1, false);
	normalize(_histDeltaPhiZJ3_3[i], 1, false);
	normalize(_histDeltaPhiJ1J2_3[i], 1, false);
	normalize(_histDeltaPhiJ1J3_3[i], 1, false);
	normalize(_histDeltaPhiJ2J3_3[i], 1, false);
	normalize(_histTransvThrust[i]);
	}
	}


	private:

	// Arrays of unboosted/boosted histos
	Histo1DPtr _histDeltaPhiZJ1_1[2];
	Histo1DPtr _histDeltaPhiZJ1_2[2];
	Histo1DPtr _histDeltaPhiZJ1_3[2];
	Histo1DPtr _histDeltaPhiZJ2_3[2];
	Histo1DPtr _histDeltaPhiZJ3_3[2];
	Histo1DPtr _histDeltaPhiJ1J2_3[2];
	Histo1DPtr _histDeltaPhiJ1J3_3[2];
	Histo1DPtr _histDeltaPhiJ2J3_3[2];
	Histo1DPtr _histTransvThrust[2];

	};


	DECLARE_RIVET_PLUGIN(CMS_2013_I1209721);

	}
	diff --git a/src/Analyses/CMS_2013_I1218372.cc b/src/Analyses/CMS_2013_I1218372.cc
	--- a/src/Analyses/CMS_2013_I1218372.cc
	+++ b/src/Analyses/CMS_2013_I1218372.cc
	@@ -1,164 +1,164 @@
	// Samantha Dooling DESY
	// February 2012
	//
	// -- C++ --
	// =============================
	//
	// Ratio of the energy deposited in the pseudorapidity range
	// -6.6 < eta < -5.2 for events with a charged particle jet
	//
	// =============================
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	class CMS_2013_I1218372 : public Analysis {
	public:

	/// Constructor
	CMS_2013_I1218372()
	: Analysis("CMS_2013_I1218372")
	{ }

	void init() {

	// gives the range of eta and min pT for the final state from which I get the jets
	FastJets jetpro (ChargedFinalState(-2.5, 2.5, 0.3*GeV), FastJets::ANTIKT, 0.5);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	// skip Neutrinos and Muons
	VetoedFinalState fsv(FinalState(-7.0, -4.0, 0.*GeV));
	fsv.vetoNeutrinos();
	fsv.addVetoPairId(PID::MUON);
	- addProjection(fsv, "fsv");
	+ declare(fsv, "fsv");

	// for the hadron level selection
	VetoedFinalState sfsv(FinalState(-MAXDOUBLE, MAXDOUBLE, 0.*GeV));
	sfsv.vetoNeutrinos();
	sfsv.addVetoPairId(PID::MUON);
	- addProjection(sfsv, "sfsv");
	+ declare(sfsv, "sfsv");

	//counters
	passedSumOfWeights = 0.;
	inclEflow = 0.;

	// Temporary histograms to fill the energy flow for leading jet events.
	// Ratios are calculated in finalyze().
	int id = 0;
	if (fuzzyEquals(sqrtS()/GeV, 900, 1e-3)) id=1;
	if (fuzzyEquals(sqrtS()/GeV, 2760, 1e-3)) id=2;
	if (fuzzyEquals(sqrtS()/GeV, 7000, 1e-3)) id=3;
	_h_ratio = bookScatter2D(id, 1, 1);
	_tmp_jet = bookHisto1D ("TMP/eflow_jet" ,refData(id, 1, 1)); // Leading jet energy flow in pt
	_tmp_njet = bookHisto1D ("TMP/number_jet" ,refData(id, 1, 1)); // Number of events in pt
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	const double weight = event.weight();

	// Skip if the event is empty
	- const FinalState& fsv = applyProjection<FinalState>(event, "fsv");
	+ const FinalState& fsv = apply<FinalState>(event, "fsv");
	if (fsv.empty()) vetoEvent;

	// ====================== Minimum Bias selection

	- const FinalState& sfsv = applyProjection<FinalState>(event, "sfsv");
	+ const FinalState& sfsv = apply<FinalState>(event, "sfsv");
	Particles parts = sfsv.particles(cmpMomByRap);
	if (parts.empty()) vetoEvent;

	// find dymax
	double dymax = 0;
	int gap_pos = -1;
	for (size_t i = 0; i < parts.size()-1; ++i) {
	double dy = parts[i+1].rapidity() - parts[i].rapidity();
	if (dy > dymax) {
	dymax = dy;
	gap_pos = i;
	}
	}

	// calculate mx2 and my2
	FourMomentum xmom;
	for (int i=0; i<=gap_pos; ++i) {
	xmom += parts[i].momentum();
	}
	double mx2 = xmom.mass2();
	if (mx2<0) vetoEvent;

	FourMomentum ymom;
	for (size_t i=gap_pos+1; i<parts.size(); ++i) {
	ymom += parts[i].momentum();
	}
	double my2 = ymom.mass2();
	if (my2<0) vetoEvent;

	// calculate xix and xiy and xidd
	double xix = mx2 / sqr(sqrtS());
	double xiy = my2 / sqr(sqrtS());
	double xidd = mx2my2 / sqr(sqrtS()0.938*GeV);

	// combine the selection: xi cuts
	bool passedHadronCuts = false;
	if (fuzzyEquals(sqrtS()/GeV, 900, 1e-3) && (xix > 0.1 \|\| xiy > 0.4 \|\| xidd > 0.5)) passedHadronCuts = true;
	if (fuzzyEquals(sqrtS()/GeV, 2760, 1e-3) && (xix > 0.07 \|\| xiy > 0.2 \|\| xidd > 0.5)) passedHadronCuts = true;
	if (fuzzyEquals(sqrtS()/GeV, 7000, 1e-3) && (xix > 0.04 \|\| xiy > 0.1 \|\| xidd > 0.5)) passedHadronCuts = true;
	if (!passedHadronCuts) vetoEvent;

	// ============================== MINIMUM BIAS EVENTS

	// loop over particles to calculate the energy
	passedSumOfWeights += weight;

	foreach (const Particle& p, fsv.particles()) {
	if (-5.2 > p.eta() && p.eta() > -6.6) inclEflow += weight*p.E()/GeV;
	}

	// ============================== JET EVENTS

	- const FastJets& jetpro = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(event, "Jets");
	const Jets& jets = jetpro.jetsByPt(1.0*GeV);
	if (jets.size()<1) vetoEvent;

	if (fabs(jets[0].eta()) < 2.0) {
	_tmp_njet->fill(jets[0].pT()/GeV, weight);

	// energy flow
	foreach (const Particle& p, fsv.particles()) {
	if (p.eta() > -6.6 && p.eta() < -5.2) { // ask for the CASTOR region
	_tmp_jet->fill(jets[0].pT()/GeV, weight * p.E()/GeV);
	}
	}
	}

	}// analysis

	void finalize() {
	scale(_tmp_jet, passedSumOfWeights/inclEflow);
	divide(_tmp_jet, _tmp_njet, _h_ratio);
	}

	private:
	// counters
	double passedSumOfWeights;
	double inclEflow;

	// histograms
	Scatter2DPtr _h_ratio;
	Histo1DPtr _tmp_jet;
	Histo1DPtr _tmp_njet;
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2013_I1218372);

	}
	diff --git a/src/Analyses/CMS_2013_I1223519.cc b/src/Analyses/CMS_2013_I1223519.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/CMS_2013_I1223519.cc
	@@ -0,0 +1,249 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalStates.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/MissingMomentum.hh"
	+#include "Rivet/Projections/Smearing.hh"
	+#include <bitset>
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Add a short analysis description here
	+ class CMS_2013_I1223519 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2013_I1223519);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ FinalState calofs(Cuts::abseta < 5.0);
	+ declare(calofs, "Clusters");
	+
	+ MissingMomentum mm(calofs);
	+ declare(mm, "TruthMET");
	+ declare(SmearedMET(mm, MET_SMEAR_CMS_RUN2), "MET");
	+
	+ FastJets fj(calofs, FastJets::ANTIKT, 0.5);
	+ declare(fj, "TruthJets");
	+ declare(SmearedJets(fj, JET_SMEAR_CMS_RUN2, [](const Jet& j) {
	+ if (j.abseta() > 2.4) return 0.;
	+ return j.bTagged() ? 0.65 : 0.01; }), "Jets"); ///< @note Charm mistag and exact b-tag eff not given
	+
	+ FinalState ys(Cuts::abspid == PID::PHOTON && Cuts::abseta < 5.0);
	+ declare(ys, "TruthPhotons");
	+ declare(SmearedParticles(ys, PHOTON_EFF_CMS_RUN2 /, PHOTON_SMEAR_CMS_RUN2 /), "Photons");
	+
	+ FinalState es(Cuts::abspid == PID::ELECTRON && Cuts::abseta < 2.5);
	+ declare(es, "TruthElectrons");
	+ declare(SmearedParticles(es, ELECTRON_EFF_CMS_RUN2, ELECTRON_SMEAR_CMS_RUN2), "Electrons");
	+
	+ FinalState mus(Cuts::abspid == PID::MUON && Cuts::abseta < 2.4);
	+ declare(mus, "TruthMuons");
	+ declare(SmearedParticles(mus, MUON_EFF_CMS_RUN2, MUON_SMEAR_CMS_RUN2), "Muons");
	+
	+ ChargedFinalState cfs(Cuts::abseta < 2.5);
	+ declare(cfs, "TruthTracks");
	+ declare(SmearedParticles(cfs, TRK_EFF_CMS_RUN2), "Tracks");
	+
	+
	+ // Book histograms
	+ _h_alphaT23 = bookHisto1D("alphaT23", 15, 0, 3);
	+ _h_alphaT4 = bookHisto1D("alphaT4", 15, 0, 3);
	+ /// @todo Add HT histograms
	+
	+ // Book counters
	+ _h_srcounters.resize(8*7 + 3);
	+ for (size_t inj = 0; inj < 2; ++inj) {
	+ const size_t njmax = inj + 3;
	+ for (size_t nb = 0; nb < njmax; ++nb) {
	+ for (size_t iht = 0; iht < 8; ++iht) {
	+ const size_t i = 8 * ((inj == 0 ? 0 : 3) + nb) + iht;
	+ _h_srcounters[i] = bookCounter("srcount_j" + toString(njmax) + "_b" + toString(nb) + "_ht" + toString(iht+1));
	+ }
	+ }
	+ }
	+ // Special nj >= 4, nb >= 4 bins
	+ for (size_t iht = 0; iht < 3; ++iht) {
	+ _h_srcounters[8*7 + iht] = bookCounter("srcount_j4_b4_ht" + toString(iht+1));
	+ }
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get baseline photons, electrons & muons
	+ Particles photons = apply<ParticleFinder>(event, "Photons").particles(Cuts::pT > 25*GeV);
	+ Particles elecs = apply<ParticleFinder>(event, "Electrons").particles(Cuts::pT > 10*GeV);
	+ Particles muons = apply<ParticleFinder>(event, "Muons").particles(Cuts::pT > 10*GeV);
	+
	+ // Electron/muon isolation (guesswork/copied from other CMS analysis -- paper is unspecific)
	+ const Particles calofs = apply<ParticleFinder>(event, "Clusters").particles();
	+ ifilter_discard(photons, [&](const Particle& y) {
	+ double ptsum = -y.pT();
	+ for (const Particle& p : calofs)
	+ if (deltaR(p,y) < 0.3) ptsum += p.pT();
	+ return ptsum / y.pT() > 0.1;
	+ });
	+ ifilter_discard(elecs, [&](const Particle& e) {
	+ double ptsum = -e.pT();
	+ for (const Particle& p : calofs)
	+ if (deltaR(p,e) < 0.3) ptsum += p.pT();
	+ return ptsum / e.pT() > 0.1;
	+ });
	+ ifilter_discard(muons, [&](const Particle& m) {
	+ double ptsum = -m.pT();
	+ for (const Particle& p : calofs)
	+ if (deltaR(p,m) < 0.3) ptsum += p.pT();
	+ return ptsum / m.pT() > 0.2;
	+ });
	+
	+ // Veto the event if there are any remaining baseline photons or leptons
	+ if (!photons.empty()) vetoEvent;
	+ if (!elecs.empty()) vetoEvent;
	+ if (!muons.empty()) vetoEvent;
	+
	+
	+ // Get jets and apply jet-based event-selection cuts
	+ const JetAlg& jetproj = apply<JetAlg>(event, "Jets");
	+ const Jets alljets = jetproj.jetsByPt(Cuts::abseta < 3.0 && Cuts::Et > 37*GeV); //< most inclusive jets requirement
	+ if (filter_select(alljets, Cuts::Et > 73*GeV).size() < 2) vetoEvent; //< most inclusive lead jets requirement
	+
	+ // Filter jets into different Et requirements & compute corresponding HTs
	+ /// @note It's not clear if different HTs are used to choose the HT bins
	+ const Jets jets37 = filter_select(alljets, Cuts::Et > 37*GeV);
	+ const Jets jets43 = filter_select(jets37, Cuts::Et > 43*GeV);
	+ const Jets jets50 = filter_select(jets43, Cuts::Et > 50*GeV);
	+ const double ht37 = sum(jets37, Et, 0.0);
	+ const double ht43 = sum(jets43, Et, 0.0);
	+ const double ht50 = sum(jets50, Et, 0.0);
	+
	+ // Find the relevant HT bin and apply leading jet event-selection cuts
	+ static const vector<double> htcuts = { /* 275., 325., */ 375., 475., 575., 675., 775., 875.}; //< comment to avoid jets50 "fall-down"
	+ const int iht = inRange(ht37, 275GeV, 325GeV) ? 0 : inRange(ht43, 325GeV, 375GeV) ? 1 : (2+binIndex(ht50, htcuts, true));
	+ MSG_TRACE("HT = {" << ht37 << ", " << ht43 << ", " << ht50 << "} => IHT = " << iht);
	+ if (iht < 0) vetoEvent;
	+ if (iht == 1 && filter_select(jets43, Cuts::Et > 78*GeV).size() < 2) vetoEvent;
	+ if (iht >= 2 && filter_select(jets50, Cuts::Et > 100*GeV).size() < 2) vetoEvent;
	+
	+ // Create references for uniform access to relevant set of jets & HT
	+ const double etcut = iht == 0 ? 37. : iht == 1 ? 43. : 50.;
	+ const double& ht = iht == 0 ? ht37 : iht == 1 ? ht43 : ht50;
	+ const Jets& jets = iht == 0 ? jets37 : iht == 1 ? jets43 : jets50;
	+ if (!jetproj.jets(Cuts::abseta > 3 && Cuts::Et > etcut*GeV).empty()) vetoEvent;
	+ const size_t nj = jets.size();
	+ const size_t nb = count_if(jets.begin(), jets.end(), [](const Jet& j) { return j.bTagged(Cuts::pT > 5*GeV); });
	+
	+ // Compute HTmiss = pT of 4-vector sum of jet momenta
	+ const FourMomentum jsum = sum(jets, mom, FourMomentum());
	+ const double htmiss = jsum.pT();
	+
	+ // Require HTmiss / ETmiss < 1.25
	+ const double etmiss = apply<SmearedMET>(event, "MET").met();
	+ if (htmiss/etmiss > 1.25) vetoEvent;
	+
	+ // Compute DeltaHT = minimum difference of "dijet" ETs, i.e. max(\|1+2-3\|, \|1+3-2\|, \|2+3-1\|)
	+ double deltaht = -1;
	+ vector<double> jetets; transform(jets, jetets, Et);
	+ for (int i = 1; i < (1 << (jetets.size()-1)); ++i) { // count from 1 to 2N-1, i.e. through all heterogeneous bitmasks with MSB(2N)==0
	+ const bitset<10> bits(i); /// @warning There'd better not be more than 10 jets...
	+ const double htdiff = partition_diff(bits, jetets);
	+ // MSG_INFO(bits.to_string() << " => " << htdiff);
	+ if (deltaht < 0 \|\| htdiff < deltaht) deltaht = htdiff;
	+ }
	+ MSG_DEBUG("dHT_bitmask = " << deltaht);
	+
	+ // Cross-check calculation in 2- and 3-jet cases
	+ // if (jets.size() == 2) {
	+ // MSG_INFO("dHT2 = " << fabs(jets[0].Et() - jets[1].Et()));
	+ // } else if (jets.size() == 3) {
	+ // double deltaht_01_2 = fabs(jets[0].Et()+jets[1].Et()-jets[2].Et());
	+ // double deltaht_02_1 = fabs(jets[0].Et()+jets[2].Et()-jets[1].Et());
	+ // double deltaht_12_0 = fabs(jets[1].Et()+jets[2].Et()-jets[0].Et());
	+ // MSG_INFO("dHT3 = " << min({deltaht_01_2, deltaht_02_1, deltaht_12_0}));
	+ // }
	+
	+ // Compute alphaT from the above
	+ double alphaT = fabs(0.5((ht-deltaht)/(sqrt((htht)-(htmiss*htmiss)))));
	+ if (alphaT < 0.55) vetoEvent;
	+
	+ /// @todo Need to include trigger efficiency sampling or weighting?
	+
	+ // Fill histograms
	+ const double weight = event.weight();
	+ const size_t inj = nj < 4 ? 0 : 1;
	+ const size_t inb = nb < 4 ? nb : 4;
	+ if (iht >= 2)
	+ (inj == 0 ? _h_alphaT23 : _h_alphaT4)->fill(alphaT, weight);
	+
	+ // Fill the appropriate counter -- after working out the irregular SR bin index! sigh
	+ size_t i = 8 * ((inj == 0 ? 0 : 3) + inb) + iht;
	+ if (inj == 1 && inb == 4) i = 8*7 + (iht < 3 ? iht : 2);
	+ MSG_INFO("inj = " << inj << ", inb = " << inb << ", i = " << i);
	+ _h_srcounters[i]->fill(weight);
	+
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ const double sf = crossSection()/femtobarn*11.7/sumOfWeights();
	+ scale({_h_alphaT23,_h_alphaT4}, sf);
	+ for (size_t i = 0; i < 8*7+3; ++i)
	+ scale(_h_srcounters[i], sf);
	+
	+ }
	+
	+ //@}
	+
	+
	+ /// @name Utility functions for partitioning jet pTs into two groups and summing/diffing them
	+ //@{
	+
	+ /// Sum the given values into two subsets according to the provided bitmask
	+ template <size_t N>
	+ pair<double, double> partition_sum(const bitset<N>& mask, const vector<double>& vals) const {
	+ pair<double, double> rtn(0., 0.);
	+ for (size_t i = 0; i < vals.size(); ++i) {
	+ (!mask[vals.size()-1-i] ? rtn.first : rtn.second) += vals[i];
	+ }
	+ return rtn;
	+ }
	+
	+ /// Return the difference between summed subsets according to the provided bitmask
	+ template <size_t N>
	+ double partition_diff(const bitset<N>& mask, const vector<double>& vals) const {
	+ const pair<double, double> sums = partition_sum(mask, vals);
	+ const double diff = fabs(sums.first - sums.second);
	+ MSG_TRACE(mask.to_string() << ": " << sums.first << "/" << sums.second << " => " << diff);
	+ return diff;
	+ }
	+
	+ //@}
	+
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _h_alphaT23, _h_alphaT4;
	+ vector<CounterPtr> _h_srcounters;
	+ //@}
	+
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(CMS_2013_I1223519);
	+
	+
	+}
	diff --git a/src/Analyses/CMS_2013_I1224539_DIJET.cc b/src/Analyses/CMS_2013_I1224539_DIJET.cc
	--- a/src/Analyses/CMS_2013_I1224539_DIJET.cc
	+++ b/src/Analyses/CMS_2013_I1224539_DIJET.cc
	@@ -1,143 +1,143 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "fastjet/tools/Filter.hh"
	#include "fastjet/tools/Pruner.hh"

	namespace Rivet {


	class CMS_2013_I1224539_DIJET : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CMS_2013_I1224539_DIJET()
	: Analysis("CMS_2013_I1224539_DIJET"),
	_filter(fastjet::Filter(fastjet::JetDefinition(fastjet::cambridge_algorithm, 0.3), fastjet::SelectorNHardest(3))),
	_trimmer(fastjet::Filter(fastjet::JetDefinition(fastjet::kt_algorithm, 0.2), fastjet::SelectorPtFractionMin(0.03))),
	_pruner(fastjet::Pruner(fastjet::cambridge_algorithm, 0.1, 0.5))
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs(-2.4, 2.4, 0*GeV);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Jet collections
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.7), "JetsAK7");
	- addProjection(FastJets(fs, FastJets::CAM, 0.8), "JetsCA8");
	- addProjection(FastJets(fs, FastJets::CAM, 1.2), "JetsCA12");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.7), "JetsAK7");
	+ declare(FastJets(fs, FastJets::CAM, 0.8), "JetsCA8");
	+ declare(FastJets(fs, FastJets::CAM, 1.2), "JetsCA12");

	// Histograms
	for (size_t i = 0; i < N_PT_BINS_dj; ++i ) {
	_h_ungroomedAvgJetMass_dj[i] = bookHisto1D(i+1+0*N_PT_BINS_dj, 1, 1);
	_h_filteredAvgJetMass_dj[i] = bookHisto1D(i+1+1*N_PT_BINS_dj, 1, 1);
	_h_trimmedAvgJetMass_dj[i] = bookHisto1D(i+1+2*N_PT_BINS_dj, 1, 1);
	_h_prunedAvgJetMass_dj[i] = bookHisto1D(i+1+3*N_PT_BINS_dj, 1, 1);
	}
	}


	// Find the pT histogram bin index for value pt (in GeV), to hack a 2D histogram equivalent
	/// @todo Use a YODA axis/finder alg when available
	size_t findPtBin(double ptJ) {
	const double ptBins_dj[N_PT_BINS_dj+1] = { 220.0, 300.0, 450.0, 500.0, 600.0, 800.0, 1000.0, 1500.0};
	for (size_t ibin = 0; ibin < N_PT_BINS_dj; ++ibin) {
	if (inRange(ptJ, ptBins_dj[ibin], ptBins_dj[ibin+1])) return ibin;
	}
	return N_PT_BINS_dj;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Look at events with >= 2 jets
	- const PseudoJets& psjetsAK7 = applyProjection<FastJets>(event, "JetsAK7").pseudoJetsByPt( 50.0*GeV );
	+ const PseudoJets& psjetsAK7 = apply<FastJets>(event, "JetsAK7").pseudoJetsByPt( 50.0*GeV );
	if (psjetsAK7.size() < 2) vetoEvent;

	// Get the leading two jets and find their average pT
	const fastjet::PseudoJet& j0 = psjetsAK7[0];
	const fastjet::PseudoJet& j1 = psjetsAK7[1];
	double ptAvg = 0.5 * (j0.pt() + j1.pt());

	// Find the appropriate mean pT bin and escape if needed
	const size_t njetBin = findPtBin(ptAvg/GeV);
	if (njetBin >= N_PT_BINS_dj) vetoEvent;

	// Now run the substructure algs...
	fastjet::PseudoJet filtered0 = _filter(j0);
	fastjet::PseudoJet filtered1 = _filter(j1);
	fastjet::PseudoJet trimmed0 = _trimmer(j0);
	fastjet::PseudoJet trimmed1 = _trimmer(j1);
	fastjet::PseudoJet pruned0 = _pruner(j0);
	fastjet::PseudoJet pruned1 = _pruner(j1);

	// ... and fill the histograms
	_h_ungroomedAvgJetMass_dj[njetBin]->fill(0.5*(j0.m() + j1.m())/GeV, weight);
	_h_filteredAvgJetMass_dj[njetBin]->fill(0.5*(filtered0.m() + filtered1.m())/GeV, weight);
	_h_trimmedAvgJetMass_dj[njetBin]->fill(0.5*(trimmed0.m() + trimmed1.m())/GeV, weight);
	_h_prunedAvgJetMass_dj[njetBin]->fill(0.5*(pruned0.m() + pruned1.m())/GeV, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double normalizationVal = 1000;
	for (size_t i = 0; i < N_PT_BINS_dj; ++i) {
	normalize(_h_ungroomedAvgJetMass_dj[i], normalizationVal);
	normalize(_h_filteredAvgJetMass_dj[i], normalizationVal);
	normalize(_h_trimmedAvgJetMass_dj[i], normalizationVal);
	normalize(_h_prunedAvgJetMass_dj[i], normalizationVal);
	}
	}

	//@}


	private:

	/// @name FastJet grooming tools (configured in constructor init list)
	//@{
	const fastjet::Filter _filter;
	const fastjet::Filter _trimmer;
	const fastjet::Pruner _pruner;
	//@}


	/// @name Histograms
	//@{
	enum BINS_dj { PT_220_300_dj=0, PT_300_450_dj, PT_450_500_dj, PT_500_600_dj,
	PT_600_800_dj, PT_800_1000_dj, PT_1000_1500_dj, N_PT_BINS_dj };
	Histo1DPtr _h_ungroomedJet0pt, _h_ungroomedJet1pt;
	Histo1DPtr _h_ungroomedAvgJetMass_dj[N_PT_BINS_dj];
	Histo1DPtr _h_filteredAvgJetMass_dj[N_PT_BINS_dj];
	Histo1DPtr _h_trimmedAvgJetMass_dj[N_PT_BINS_dj];
	Histo1DPtr _h_prunedAvgJetMass_dj[N_PT_BINS_dj];
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2013_I1224539_DIJET);


	}
	diff --git a/src/Analyses/CMS_2013_I1224539_WJET.cc b/src/Analyses/CMS_2013_I1224539_WJET.cc
	--- a/src/Analyses/CMS_2013_I1224539_WJET.cc
	+++ b/src/Analyses/CMS_2013_I1224539_WJET.cc
	@@ -1,193 +1,193 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "fastjet/tools/Filter.hh"
	#include "fastjet/tools/Pruner.hh"

	namespace Rivet {


	class CMS_2013_I1224539_WJET : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CMS_2013_I1224539_WJET()
	: Analysis("CMS_2013_I1224539_WJET"),
	_filter(fastjet::Filter(fastjet::JetDefinition(fastjet::cambridge_algorithm, 0.3), fastjet::SelectorNHardest(3))),
	_trimmer(fastjet::Filter(fastjet::JetDefinition(fastjet::kt_algorithm, 0.2), fastjet::SelectorPtFractionMin(0.03))),
	_pruner(fastjet::Pruner(fastjet::cambridge_algorithm, 0.1, 0.5))
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs(-2.4, 2.4, 0*GeV);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Find W's with pT > 120, MET > 50
	WFinder wfinder(fs, Cuts::abseta < 2.4 && Cuts::pT > 80GeV, PID::ELECTRON, 50GeV, 1000GeV, 50.0GeV,
	0.2, WFinder::CLUSTERNODECAY, WFinder::NOTRACK, WFinder::TRANSMASS);
	- addProjection(wfinder, "WFinder");
	+ declare(wfinder, "WFinder");

	// W+jet jet collections
	- addProjection(FastJets(wfinder.remainingFinalState(), FastJets::ANTIKT, 0.7), "JetsAK7_wj");
	- addProjection(FastJets(wfinder.remainingFinalState(), FastJets::CAM, 0.8), "JetsCA8_wj");
	- addProjection(FastJets(wfinder.remainingFinalState(), FastJets::CAM, 1.2), "JetsCA12_wj");
	+ declare(FastJets(wfinder.remainingFinalState(), FastJets::ANTIKT, 0.7), "JetsAK7_wj");
	+ declare(FastJets(wfinder.remainingFinalState(), FastJets::CAM, 0.8), "JetsCA8_wj");
	+ declare(FastJets(wfinder.remainingFinalState(), FastJets::CAM, 1.2), "JetsCA12_wj");

	// Histograms
	/// @note These are 2D histos rendered into slices
	const int wjetsOffset = 51;
	for (size_t i = 0; i < N_PT_BINS_vj; ++i) {
	_h_ungroomedJetMass_AK7_wj[i] = bookHisto1D(wjetsOffset+i+1+0*N_PT_BINS_vj, 1, 1);
	_h_filteredJetMass_AK7_wj[i] = bookHisto1D(wjetsOffset+i+1+1*N_PT_BINS_vj, 1, 1);
	_h_trimmedJetMass_AK7_wj[i] = bookHisto1D(wjetsOffset+i+1+2*N_PT_BINS_vj, 1, 1);
	_h_prunedJetMass_AK7_wj[i] = bookHisto1D(wjetsOffset+i+1+3*N_PT_BINS_vj, 1, 1);
	_h_prunedJetMass_CA8_wj[i] = bookHisto1D(wjetsOffset+i+1+4*N_PT_BINS_vj, 1, 1);
	if (i > 0) _h_filteredJetMass_CA12_wj[i] = bookHisto1D(wjetsOffset+i+5*N_PT_BINS_vj, 1, 1);
	}
	}


	bool isBackToBack_wj(const WFinder& wf, const fastjet::PseudoJet& psjet) {
	const FourMomentum& w = wf.bosons()[0].momentum();
	const FourMomentum& l1 = wf.constituentLeptons()[0].momentum();
	const FourMomentum& l2 = wf.constituentNeutrinos()[0].momentum();
	/// @todo We should make FourMomentum know how to construct itself from a PseudoJet
	const FourMomentum jmom(psjet.e(), psjet.px(), psjet.py(), psjet.pz());
	return (deltaPhi(w, jmom) > 2.0 && deltaR(l1, jmom) > 1.0 && deltaPhi(l2, jmom) > 0.4);
	}


	// Find the pT histogram bin index for value pt (in GeV), to hack a 2D histogram equivalent
	/// @todo Use a YODA axis/finder alg when available
	size_t findPtBin(double ptJ) {
	const double ptBins_vj[N_PT_BINS_vj+1] = { 125.0, 150.0, 220.0, 300.0, 450.0 };
	for (size_t ibin = 0; ibin < N_PT_BINS_vj; ++ibin) {
	if (inRange(ptJ, ptBins_vj[ibin], ptBins_vj[ibin+1])) return ibin;
	}
	return N_PT_BINS_vj;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Get the W
	- const WFinder& wfinder = applyProjection<WFinder>(event, "WFinder");
	+ const WFinder& wfinder = apply<WFinder>(event, "WFinder");
	if (wfinder.bosons().size() != 1) vetoEvent;
	const Particle& w = wfinder.bosons()[0];
	const Particle& l = wfinder.constituentLeptons()[0];

	// Require a fairly high-pT W and charged lepton
	if (l.pT() < 80GeV \|\| w.pT() < 120GeV) vetoEvent;

	// Get the pseudojets.
	- const PseudoJets& psjetsCA8_wj = applyProjection<FastJets>(event, "JetsCA8_wj").pseudoJetsByPt( 50.0*GeV );
	- const PseudoJets& psjetsCA12_wj = applyProjection<FastJets>(event, "JetsCA12_wj").pseudoJetsByPt( 50.0*GeV );
	+ const PseudoJets& psjetsCA8_wj = apply<FastJets>(event, "JetsCA8_wj").pseudoJetsByPt( 50.0*GeV );
	+ const PseudoJets& psjetsCA12_wj = apply<FastJets>(event, "JetsCA12_wj").pseudoJetsByPt( 50.0*GeV );

	// AK7 jets
	- const PseudoJets& psjetsAK7_wj = applyProjection<FastJets>(event, "JetsAK7_wj").pseudoJetsByPt( 50.0*GeV );
	+ const PseudoJets& psjetsAK7_wj = apply<FastJets>(event, "JetsAK7_wj").pseudoJetsByPt( 50.0*GeV );
	if (!psjetsAK7_wj.empty()) {
	// Get the leading jet and make sure it's back-to-back with the W
	const fastjet::PseudoJet& j0 = psjetsAK7_wj[0];
	if (isBackToBack_wj(wfinder, j0)) {
	const size_t njetBin = findPtBin(j0.pt()/GeV);
	if (njetBin < N_PT_BINS_vj) {
	fastjet::PseudoJet filtered0 = _filter(j0);
	fastjet::PseudoJet trimmed0 = _trimmer(j0);
	fastjet::PseudoJet pruned0 = _pruner(j0);
	_h_ungroomedJetMass_AK7_wj[njetBin]->fill(j0.m()/GeV, weight);
	_h_filteredJetMass_AK7_wj[njetBin]->fill(filtered0.m()/GeV, weight);
	_h_trimmedJetMass_AK7_wj[njetBin]->fill(trimmed0.m()/GeV, weight);
	_h_prunedJetMass_AK7_wj[njetBin]->fill(pruned0.m()/GeV, weight);
	}
	}
	}

	// CA8 jets
	if (!psjetsCA8_wj.empty()) {
	// Get the leading jet and make sure it's back-to-back with the W
	const fastjet::PseudoJet& j0 = psjetsCA8_wj[0];
	if (isBackToBack_wj(wfinder, j0)) {
	const size_t njetBin = findPtBin(j0.pt()/GeV);
	if (njetBin < N_PT_BINS_vj) {
	fastjet::PseudoJet pruned0 = _pruner(j0);
	_h_prunedJetMass_CA8_wj[njetBin]->fill(pruned0.m()/GeV, weight);
	}
	}
	}

	// CA12 jets
	if (!psjetsCA12_wj.empty()) {
	// Get the leading jet and make sure it's back-to-back with the W
	const fastjet::PseudoJet& j0 = psjetsCA12_wj[0];
	if (isBackToBack_wj(wfinder, j0)) {
	const size_t njetBin = findPtBin(j0.pt()/GeV);
	if (njetBin < N_PT_BINS_vj&&njetBin>0) {
	fastjet::PseudoJet filtered0 = _filter(j0);
	_h_filteredJetMass_CA12_wj[njetBin]->fill( filtered0.m() / GeV, weight);
	}
	}
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double normalizationVal = 1000;
	for (size_t i = 0; i < N_PT_BINS_vj; ++i) {
	normalize(_h_ungroomedJetMass_AK7_wj[i], normalizationVal);
	normalize(_h_filteredJetMass_AK7_wj[i], normalizationVal);
	normalize(_h_trimmedJetMass_AK7_wj[i], normalizationVal);
	normalize(_h_prunedJetMass_AK7_wj[i], normalizationVal);
	normalize(_h_prunedJetMass_CA8_wj[i], normalizationVal);
	if (i > 0) normalize( _h_filteredJetMass_CA12_wj[i], normalizationVal);
	}
	}

	//@}


	private:

	/// @name FastJet grooming tools (configured in constructor init list)
	//@{
	const fastjet::Filter _filter;
	const fastjet::Filter _trimmer;
	const fastjet::Pruner _pruner;
	//@}


	/// @name Histograms
	//@{
	enum BINS_vj { PT_125_150_vj=0, PT_150_220_vj, PT_220_300_vj, PT_300_450_vj, N_PT_BINS_vj };
	Histo1DPtr _h_ungroomedJetMass_AK7_wj[N_PT_BINS_vj];
	Histo1DPtr _h_filteredJetMass_AK7_wj[N_PT_BINS_vj];
	Histo1DPtr _h_trimmedJetMass_AK7_wj[N_PT_BINS_vj];
	Histo1DPtr _h_prunedJetMass_AK7_wj[N_PT_BINS_vj];
	Histo1DPtr _h_prunedJetMass_CA8_wj[N_PT_BINS_vj];
	Histo1DPtr _h_filteredJetMass_CA12_wj[N_PT_BINS_vj];
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2013_I1224539_WJET);

	}
	diff --git a/src/Analyses/CMS_2013_I1224539_ZJET.cc b/src/Analyses/CMS_2013_I1224539_ZJET.cc
	--- a/src/Analyses/CMS_2013_I1224539_ZJET.cc
	+++ b/src/Analyses/CMS_2013_I1224539_ZJET.cc
	@@ -1,195 +1,195 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "fastjet/tools/Filter.hh"
	#include "fastjet/tools/Pruner.hh"

	namespace Rivet {




	class CMS_2013_I1224539_ZJET : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	CMS_2013_I1224539_ZJET()
	: Analysis("CMS_2013_I1224539_ZJET"),
	_filter(fastjet::Filter(fastjet::JetDefinition(fastjet::cambridge_algorithm, 0.3), fastjet::SelectorNHardest(3))),
	_trimmer(fastjet::Filter(fastjet::JetDefinition(fastjet::kt_algorithm, 0.2), fastjet::SelectorPtFractionMin(0.03))),
	_pruner(fastjet::Pruner(fastjet::cambridge_algorithm, 0.1, 0.5))
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs(Cuts::abseta < 2.4);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Find Zs with pT > 120 GeV
	ZFinder zfinder(fs, Cuts::abseta < 2.4 && Cuts::pT > 30GeV, PID::ELECTRON, 80GeV, 100*GeV,
	0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);

	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	// Z+jet jet collections
	- addProjection(FastJets(zfinder.remainingFinalState(), FastJets::ANTIKT, 0.7), "JetsAK7_zj");
	- addProjection(FastJets(zfinder.remainingFinalState(), FastJets::CAM, 0.8), "JetsCA8_zj");
	- addProjection(FastJets(zfinder.remainingFinalState(), FastJets::CAM, 1.2), "JetsCA12_zj");
	+ declare(FastJets(zfinder.remainingFinalState(), FastJets::ANTIKT, 0.7), "JetsAK7_zj");
	+ declare(FastJets(zfinder.remainingFinalState(), FastJets::CAM, 0.8), "JetsCA8_zj");
	+ declare(FastJets(zfinder.remainingFinalState(), FastJets::CAM, 1.2), "JetsCA12_zj");

	// Histograms
	/// @note These are 2D histos rendered into slices
	const int zjetsOffset = 28;
	for (size_t i = 0; i < N_PT_BINS_vj; ++i ) {
	_h_ungroomedJetMass_AK7_zj[i] = bookHisto1D(zjetsOffset+i+1+0*N_PT_BINS_vj, 1, 1);
	_h_filteredJetMass_AK7_zj[i] = bookHisto1D(zjetsOffset+i+1+1*N_PT_BINS_vj,1,1);
	_h_trimmedJetMass_AK7_zj[i] = bookHisto1D(zjetsOffset+i+1+2*N_PT_BINS_vj,1,1);
	_h_prunedJetMass_AK7_zj[i] = bookHisto1D(zjetsOffset+i+1+3*N_PT_BINS_vj,1,1);
	_h_prunedJetMass_CA8_zj[i] = bookHisto1D(zjetsOffset+i+1+4*N_PT_BINS_vj,1,1);
	if (i > 0) _h_filteredJetMass_CA12_zj[i] = bookHisto1D(zjetsOffset+i+5*N_PT_BINS_vj,1,1);
	}
	}


	bool isBackToBack_zj(const ZFinder& zf, const fastjet::PseudoJet& psjet) {
	const FourMomentum& z = zf.bosons()[0].momentum();
	const FourMomentum& l1 = zf.constituents()[0].momentum();
	const FourMomentum& l2 = zf.constituents()[1].momentum();
	/// @todo We should make FourMomentum know how to construct itself from a PseudoJet
	const FourMomentum jmom(psjet.e(), psjet.px(), psjet.py(), psjet.pz());
	return (deltaPhi(z, jmom) > 2.0 && deltaR(l1, jmom) > 1.0 && deltaR(l2, jmom) > 1.0);
	}


	// Find the pT histogram bin index for value pt (in GeV), to hack a 2D histogram equivalent
	/// @todo Use a YODA axis/finder alg when available
	size_t findPtBin(double ptJ) {
	const double ptBins_vj[N_PT_BINS_vj+1] = { 125.0, 150.0, 220.0, 300.0, 450.0 };
	for (size_t ibin = 0; ibin < N_PT_BINS_vj; ++ibin) {
	if (inRange(ptJ, ptBins_vj[ibin], ptBins_vj[ibin+1])) return ibin;
	}
	return N_PT_BINS_vj;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Get the Z
	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");
	if (zfinder.bosons().size() != 1) vetoEvent;
	const Particle& z = zfinder.bosons()[0];
	const Particle& l1 = zfinder.constituents()[0];
	const Particle& l2 = zfinder.constituents()[1];

	// Require a high-pT Z (and constituents)
	if (l1.pT() < 30GeV \|\| l2.pT() < 30GeV \|\| z.pT() < 120*GeV) vetoEvent;

	// AK7 jets
	- const PseudoJets& psjetsAK7_zj = applyProjection<FastJets>(event, "JetsAK7_zj").pseudoJetsByPt(50.0*GeV);
	+ const PseudoJets& psjetsAK7_zj = apply<FastJets>(event, "JetsAK7_zj").pseudoJetsByPt(50.0*GeV);
	if (!psjetsAK7_zj.empty()) {
	// Get the leading jet and make sure it's back-to-back with the Z
	const fastjet::PseudoJet& j0 = psjetsAK7_zj[0];
	if (isBackToBack_zj(zfinder, j0)) {
	const size_t njetBin = findPtBin(j0.pt()/GeV);
	if (njetBin < N_PT_BINS_vj) {
	fastjet::PseudoJet filtered0 = _filter(j0);
	fastjet::PseudoJet trimmed0 = _trimmer(j0);
	fastjet::PseudoJet pruned0 = _pruner(j0);
	_h_ungroomedJetMass_AK7_zj[njetBin]->fill(j0.m()/GeV, weight);
	_h_filteredJetMass_AK7_zj[njetBin]->fill(filtered0.m()/GeV, weight);
	_h_trimmedJetMass_AK7_zj[njetBin]->fill(trimmed0.m()/GeV, weight);
	_h_prunedJetMass_AK7_zj[njetBin]->fill(pruned0.m()/GeV, weight);
	}
	}
	}

	// CA8 jets
	- const PseudoJets& psjetsCA8_zj = applyProjection<FastJets>(event, "JetsCA8_zj").pseudoJetsByPt(50.0*GeV);
	+ const PseudoJets& psjetsCA8_zj = apply<FastJets>(event, "JetsCA8_zj").pseudoJetsByPt(50.0*GeV);
	if (!psjetsCA8_zj.empty()) {
	// Get the leading jet and make sure it's back-to-back with the Z
	const fastjet::PseudoJet& j0 = psjetsCA8_zj[0];
	if (isBackToBack_zj(zfinder, j0)) {
	const size_t njetBin = findPtBin(j0.pt()/GeV);
	if (njetBin < N_PT_BINS_vj) {
	fastjet::PseudoJet pruned0 = _pruner(j0);
	_h_prunedJetMass_CA8_zj[njetBin]->fill(pruned0.m()/GeV, weight);
	}
	}
	}

	// CA12 jets
	- const PseudoJets& psjetsCA12_zj = applyProjection<FastJets>(event, "JetsCA12_zj").pseudoJetsByPt(50.0*GeV);
	+ const PseudoJets& psjetsCA12_zj = apply<FastJets>(event, "JetsCA12_zj").pseudoJetsByPt(50.0*GeV);
	if (!psjetsCA12_zj.empty()) {
	// Get the leading jet and make sure it's back-to-back with the Z
	const fastjet::PseudoJet& j0 = psjetsCA12_zj[0];
	if (isBackToBack_zj(zfinder, j0)) {
	const size_t njetBin = findPtBin(j0.pt()/GeV);
	if (njetBin>0 && njetBin < N_PT_BINS_vj) {
	fastjet::PseudoJet filtered0 = _filter(j0);
	_h_filteredJetMass_CA12_zj[njetBin]->fill( filtered0.m() / GeV, weight);
	}
	}
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double normalizationVal = 1000;
	for (size_t i = 0; i < N_PT_BINS_vj; ++i ) {
	normalize( _h_ungroomedJetMass_AK7_zj[i], normalizationVal);
	normalize( _h_filteredJetMass_AK7_zj[i], normalizationVal);
	normalize( _h_trimmedJetMass_AK7_zj[i], normalizationVal);
	normalize( _h_prunedJetMass_AK7_zj[i], normalizationVal);
	normalize( _h_prunedJetMass_CA8_zj[i], normalizationVal);
	if (i > 0) normalize( _h_filteredJetMass_CA12_zj[i], normalizationVal);
	}
	}

	//@}


	private:

	/// @name FastJet grooming tools (configured in constructor init list)
	//@{
	const fastjet::Filter _filter;
	const fastjet::Filter _trimmer;
	const fastjet::Pruner _pruner;
	//@}


	/// @name Histograms
	//@{
	enum BINS_vj { PT_125_150_vj=0, PT_150_220_vj, PT_220_300_vj, PT_300_450_vj, N_PT_BINS_vj };
	Histo1DPtr _h_ungroomedJetMass_AK7_zj[N_PT_BINS_vj];
	Histo1DPtr _h_filteredJetMass_AK7_zj[N_PT_BINS_vj];
	Histo1DPtr _h_trimmedJetMass_AK7_zj[N_PT_BINS_vj];
	Histo1DPtr _h_prunedJetMass_AK7_zj[N_PT_BINS_vj];
	Histo1DPtr _h_prunedJetMass_CA8_zj[N_PT_BINS_vj];
	Histo1DPtr _h_filteredJetMass_CA12_zj[N_PT_BINS_vj];
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2013_I1224539_ZJET);

	}
	diff --git a/src/Analyses/CMS_2013_I1256943.cc b/src/Analyses/CMS_2013_I1256943.cc
	--- a/src/Analyses/CMS_2013_I1256943.cc
	+++ b/src/Analyses/CMS_2013_I1256943.cc
	@@ -1,188 +1,188 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// CMS cross-section and angular correlations in Z boson + b-hadrons events at 7 TeV
	class CMS_2013_I1256943 : public Analysis {
	public:

	/// Constructor
	CMS_2013_I1256943()
	: Analysis("CMS_2013_I1256943")
	{ }


	/// Add projections and book histograms
	void init() {
	_sumW = 0;
	_sumW50 = 0;
	_sumWpT = 0;

	FinalState fs(Cuts::abseta < 2.4 && Cuts::pT > 20*GeV);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	UnstableFinalState ufs(Cuts::abseta < 2 && Cuts::pT > 15*GeV);
	- addProjection(ufs, "UFS");
	+ declare(ufs, "UFS");

	Cut zetacut = Cuts::abseta < 2.4;

	ZFinder zfindermu(fs, zetacut, PID::MUON, 81.0GeV, 101.0GeV, 0.1, ZFinder::NOCLUSTER, ZFinder::TRACK, 91.2*GeV);
	- addProjection(zfindermu, "ZFinderMu");
	+ declare(zfindermu, "ZFinderMu");

	ZFinder zfinderel(fs, zetacut, PID::ELECTRON, 81.0GeV, 101.0GeV, 0.1, ZFinder::NOCLUSTER, ZFinder::TRACK, 91.2*GeV);
	- addProjection(zfinderel, "ZFinderEl");
	+ declare(zfinderel, "ZFinderEl");


	// Histograms in non-boosted region of Z pT
	_h_dR_BB = bookHisto1D(1, 1, 1);
	_h_dphi_BB = bookHisto1D(2, 1, 1);
	_h_min_dR_ZB = bookHisto1D(3, 1, 1);
	_h_A_ZBB = bookHisto1D(4, 1, 1);

	// Histograms in boosted region of Z pT (pT > 50 GeV)
	_h_dR_BB_boost = bookHisto1D(5, 1, 1);
	_h_dphi_BB_boost = bookHisto1D(6, 1, 1);
	_h_min_dR_ZB_boost = bookHisto1D(7, 1, 1);
	_h_A_ZBB_boost = bookHisto1D(8, 1, 1);

	_h_min_ZpT = bookHisto1D(9,1,1);
	}


	/// Do the analysis
	void analyze(const Event& e) {
	vector<FourMomentum> Bmom;

	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	- const ZFinder& zfindermu = applyProjection<ZFinder>(e, "ZFinderMu");
	- const ZFinder& zfinderel = applyProjection<ZFinder>(e, "ZFinderEl");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	+ const ZFinder& zfindermu = apply<ZFinder>(e, "ZFinderMu");
	+ const ZFinder& zfinderel = apply<ZFinder>(e, "ZFinderEl");

	// Look for a Z --> mu+ mu- event in the final state
	if (zfindermu.empty() && zfinderel.empty()) vetoEvent;

	const Particles& z = !zfindermu.empty() ? zfindermu.bosons() : zfinderel.bosons();
	const bool is_boosted = ( z[0].pT() > 50*GeV );

	// Loop over the unstable particles
	foreach (const Particle& p, ufs.particles()) {
	const PdgId pid = p.pid();

	// Look for particles with a bottom quark
	if (PID::hasBottom(pid)) {

	bool good_B = false;
	const GenParticle* pgen = p.genParticle();
	const GenVertex* vgen = pgen -> end_vertex();

	// Loop over the decay products of each unstable particle.
	// Look for a couple of B hadrons.
	for (GenVertex::particles_out_const_iterator it = vgen->particles_out_const_begin(); it != vgen->particles_out_const_end(); ++it) {
	// If the particle produced has a bottom quark do not count it and go to the next loop cycle.
	if (!( PID::hasBottom( (*it)->pdg_id() ) ) ) {
	good_B = true;
	continue;
	} else {
	good_B = false;
	break;
	}
	}
	if (good_B ) Bmom.push_back( p.momentum() );
	}
	else continue;
	}

	// If there are more than two B's in the final state veto the event
	if (Bmom.size() != 2 ) vetoEvent;

	// Calculate the observables
	- double dphiBB = fabs(Bmom[0].phi() - Bmom[1].phi());
	+ double dphiBB = deltaPhi(Bmom[0], Bmom[1]);
	double dRBB = deltaR(Bmom[0], Bmom[1]);

	const FourMomentum& pZ = z[0].momentum();
	const bool closest_B = ( deltaR(pZ, Bmom[0]) < deltaR(pZ, Bmom[1]) );
	const double mindR_ZB = closest_B ? deltaR(pZ, Bmom[0]) : deltaR(pZ, Bmom[1]);
	const double maxdR_ZB = closest_B ? deltaR(pZ, Bmom[1]) : deltaR(pZ, Bmom[0]);
	const double AZBB = ( maxdR_ZB - mindR_ZB ) / ( maxdR_ZB + mindR_ZB );

	// Get event weight for histogramming
	const double weight = e.weight();

	// Fill the histograms in the non-boosted region
	_h_dphi_BB->fill(dphiBB, weight);
	_h_dR_BB->fill(dRBB, weight);
	_h_min_dR_ZB->fill(mindR_ZB, weight);
	_h_A_ZBB->fill(AZBB, weight);
	_sumW += weight;
	_sumWpT += weight;

	// Fill the histograms in the boosted region
	if (is_boosted) {
	_sumW50 += weight;
	_h_dphi_BB_boost->fill(dphiBB, weight);
	_h_dR_BB_boost->fill(dRBB, weight);
	_h_min_dR_ZB_boost->fill(mindR_ZB, weight);
	_h_A_ZBB_boost->fill(AZBB, weight);
	}

	// Fill Z pT (cumulative) histogram
	_h_min_ZpT->fill(0, weight);
	if (pZ.pT() > 40*GeV ) {
	_sumWpT += weight;
	_h_min_ZpT->fill(40, weight);
	}
	if (pZ.pT() > 80*GeV ) {
	_sumWpT += weight;
	_h_min_ZpT->fill(80, weight);
	}
	if (pZ.pT() > 120*GeV ) {
	_sumWpT += weight;
	_h_min_ZpT->fill(120, weight);
	}

	Bmom.clear();
	}


	/// Finalize
	void finalize() {

	// Normalize excluding overflow bins (d'oh)
	normalize(_h_dR_BB, 0.7crossSection()_sumW/sumOfWeights(), false); // d01-x01-y01
	normalize(_h_dphi_BB, 0.53crossSection()_sumW/sumOfWeights(), false); // d02-x01-y01
	normalize(_h_min_dR_ZB, 0.84crossSection()_sumW/sumOfWeights(), false); // d03-x01-y01
	normalize(_h_A_ZBB, 0.2crossSection()_sumW/sumOfWeights(), false); // d04-x01-y01

	normalize(_h_dR_BB_boost, 0.84crossSection()_sumW50/sumOfWeights(), false); // d05-x01-y01
	normalize(_h_dphi_BB_boost, 0.63crossSection()_sumW50/sumOfWeights(), false); // d06-x01-y01
	normalize(_h_min_dR_ZB_boost, 1crossSection()_sumW50/sumOfWeights(), false); // d07-x01-y01
	normalize(_h_A_ZBB_boost, 0.25crossSection()_sumW50/sumOfWeights(), false); // d08-x01-y01

	normalize(_h_min_ZpT, 40crossSection()_sumWpT/sumOfWeights(), false); // d09-x01-y01
	}


	private:

	/// @name Weight counters
	//@{
	double _sumW, _sumW50, _sumWpT;
	//@}

	/// @name Histograms
	//@{
	Histo1DPtr _h_dphi_BB, _h_dR_BB, _h_min_dR_ZB, _h_A_ZBB;
	Histo1DPtr _h_dphi_BB_boost, _h_dR_BB_boost, _h_min_dR_ZB_boost, _h_A_ZBB_boost, _h_min_ZpT;
	//@}

	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2013_I1256943);

	}
	diff --git a/src/Analyses/CMS_2013_I1258128.cc b/src/Analyses/CMS_2013_I1258128.cc
	--- a/src/Analyses/CMS_2013_I1258128.cc
	+++ b/src/Analyses/CMS_2013_I1258128.cc
	@@ -1,168 +1,168 @@
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"

	namespace Rivet {


	/// CMS Z rapidity measurement
	class CMS_2013_I1258128 : public Analysis {
	public:

	// Constructor
	CMS_2013_I1258128()
	: Analysis("CMS_2013_I1258128")
	{ }


	void init() {
	// Full final state
	const FinalState fs(Cuts::abseta < 5);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Z finders for electrons and muons
	Cut cuts = Cuts::abseta < 2.1 && Cuts::pT > 20*GeV;
	const ZFinder zfe(fs, cuts, PID::ELECTRON, 76GeV, 106GeV);
	const ZFinder zfm(fs, cuts, PID::MUON, 76GeV, 106GeV);
	- addProjection(zfe, "ZFE");
	- addProjection(zfm, "ZFM");
	+ declare(zfe, "ZFE");
	+ declare(zfm, "ZFM");

	// Try to get the leading photon
	LeadingParticlesFinalState photonfs(FinalState(-2.5, 2.5, 40.0*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// Jets
	const FastJets jets(fs, FastJets::ANTIKT, 0.5);
	- addProjection(jets, "JETS");
	+ declare(jets, "JETS");

	// Histograms
	_hist1YZ = bookHisto1D(1, 1, 1);
	_hist1YJet = bookHisto1D(2, 1, 1);
	_hist1YSum = bookHisto1D(3, 1, 1);
	_hist1YDif = bookHisto1D(4, 1, 1);
	_hist2YPhoton = bookHisto1D(5, 1, 1);
	_hist2YJet = bookHisto1D(6, 1, 1);
	_hist2YSum = bookHisto1D(7, 1, 1);
	_hist2YDif = bookHisto1D(8, 1, 1);
	}


	void makeZCut(const Event& event) {
	// Apply the Z finders and veto if no Z found
	- const ZFinder& zfe = applyProjection<ZFinder>(event, "ZFE");
	- const ZFinder& zfm = applyProjection<ZFinder>(event, "ZFM");
	+ const ZFinder& zfe = apply<ZFinder>(event, "ZFE");
	+ const ZFinder& zfm = apply<ZFinder>(event, "ZFM");
	if (zfe.empty() && zfm.empty()) vetoEvent;

	// Choose the Z candidate
	const ParticleVector& z = (!zfm.empty()) ? zfm.bosons() : zfe.bosons();
	const ParticleVector& clusteredConstituents = (!zfm.empty()) ? zfm.constituents() : zfe.constituents();

	// Insist that the Z is in a high-pT (boosted) regime
	if (z[0].pT() < 40*GeV) return;

	// Build the jets
	- const FastJets& jetfs = applyProjection<FastJets>(event, "JETS");
	+ const FastJets& jetfs = apply<FastJets>(event, "JETS");
	Jets jets = jetfs.jetsByPt(Cuts::pT > 30*GeV && Cuts::abseta < 2.4);
	if (jets.empty()) return;

	// Clean the jets against the lepton candidates with a DeltaR cut of 0.5
	vector<const Jet*> cleanedJets;
	foreach (const Jet& j, jets) {
	bool isolated = true;
	foreach (const Particle& p, clusteredConstituents) {
	if (deltaR(p, j) < 0.5) {
	isolated = false;
	break;
	}
	}
	if (isolated) cleanedJets.push_back(&j);
	}
	// Require exactly 1 isolated jet
	if (cleanedJets.size() != 1) return;

	// Fill histos
	const double weight = event.weight();
	const double yz = z[0].rapidity();
	const double yjet = cleanedJets[0]->momentum().rapidity();
	_hist1YZ->fill(fabs(yz), weight);
	_hist1YJet->fill(fabs(yjet), weight);
	_hist1YSum->fill(0.5*fabs(yz + yjet), weight);
	_hist1YDif->fill(0.5*fabs(yz - yjet), weight);
	}


	void makePhotonCut(const Event& event) {
	// Get the photon
	- const FinalState& photonfs = applyProjection<FinalState>(event, "LeadingPhoton");
	+ const FinalState& photonfs = apply<FinalState>(event, "LeadingPhoton");
	if (photonfs.particles().size() < 1) return;
	const Particle& photon = photonfs.particles().front();
	if (photon.pT() < 40*GeV) return;
	if (fabs(photon.eta()) > 1.4442 ) return;

	// Build the jets
	- const FastJets& jetfs = applyProjection<FastJets>(event, "JETS");
	+ const FastJets& jetfs = apply<FastJets>(event, "JETS");
	Jets jets = jetfs.jetsByPt(Cuts::pT > 30*GeV && Cuts::abseta < 2.4);
	if (jets.empty()) return;

	// Clean the jets against the photon candidate with a DeltaR cut of 0.5
	vector<const Jet*> cleanedJets;
	foreach (const Jet& j, jets)
	if (deltaR(photon, j) > 0.5)
	cleanedJets.push_back(&j);
	// Require exactly 1 jet
	if (cleanedJets.size() != 1) return;

	// Fill histos
	const double weight = event.weight();
	const double ypho = photon.rapidity();
	const double yjet = cleanedJets[0]->momentum().rapidity();
	_hist2YPhoton->fill(fabs(ypho), weight);
	_hist2YJet->fill(fabs(yjet), weight);
	_hist2YSum->fill(0.5*fabs(ypho + yjet), weight);
	_hist2YDif->fill(0.5*fabs(ypho - yjet), weight);
	}


	void analyze(const Event& event) {
	makeZCut(event);
	makePhotonCut(event);
	}


	void finalize() {
	normalizeByContents(_hist1YZ);
	normalizeByContents(_hist1YJet);
	normalizeByContents(_hist1YSum);
	normalizeByContents(_hist1YDif);
	normalizeByContents(_hist2YPhoton);
	normalizeByContents(_hist2YJet);
	normalizeByContents(_hist2YSum);
	normalizeByContents(_hist2YDif);
	}


	// The CMS normalization in this analysis is that the sum over bin contents
	// is equal to 1. This function normalizes to area = area*bin_width. /
	// @note This is a strange definition... why?
	void normalizeByContents(Histo1DPtr h) {
	normalize(h, h->bin(0).xWidth());
	}


	private:

	Histo1DPtr _hist1YZ, _hist1YJet, _hist1YSum, _hist1YDif;
	Histo1DPtr _hist2YPhoton, _hist2YJet, _hist2YSum, _hist2YDif;

	};


	// Plugin system hook
	DECLARE_RIVET_PLUGIN(CMS_2013_I1258128);

	}
	diff --git a/src/Analyses/CMS_2013_I1261026.cc b/src/Analyses/CMS_2013_I1261026.cc
	--- a/src/Analyses/CMS_2013_I1261026.cc
	+++ b/src/Analyses/CMS_2013_I1261026.cc
	@@ -1,237 +1,237 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// Jet and underlying event properties as a function of particle multiplicity
	class CMS_2013_I1261026 : public Analysis {
	public:

	CMS_2013_I1261026()
	: Analysis("CMS_2013_I1261026"), _jetStructNorm(5,0.), _multBinCent(5,0.),
	_jetCounter5GeV(5,0.), _jetCounter30GeV(5,0.), _passedEv(5,0.)
	{ }


	void init() {
	FastJets jetpro(ChargedFinalState(-2.4, 2.4, 0.25*GeV), FastJets::ANTIKT, 0.5);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	const ChargedFinalState cfs(-2.4, 2.4, 0.25*GeV);
	- addProjection(cfs, "CFS250");
	+ declare(cfs, "CFS250");

	// For min bias trigger
	const ChargedFinalState cfsBSCplus(3.23, 4.65, 500*MeV);
	- addProjection(cfsBSCplus, "cfsBSCplus");
	+ declare(cfsBSCplus, "cfsBSCplus");

	const ChargedFinalState cfsBSCminus(-4.65, -3.23, 500*MeV);
	- addProjection(cfsBSCminus, "cfsBSCminus");
	+ declare(cfsBSCminus, "cfsBSCminus");

	// Histograms:
	_h_AllTrkMeanPt = bookProfile1D(1, 1, 1);
	_h_SoftTrkMeanPt = bookProfile1D(2, 1, 1);
	_h_IntrajetTrkMeanPt = bookProfile1D(3, 1, 1);
	_h_IntrajetLeaderTrkMeanPt = bookProfile1D(4, 1, 1);
	_h_MeanJetPt = bookProfile1D(5, 1, 1);
	_h_JetRate5GeV = bookProfile1D(6, 1, 1);
	_h_JetRate30GeV = bookProfile1D(7, 1, 1);

	for (int ihist = 0; ihist < 5; ++ihist) {
	_h_JetSpectrum[ihist] = bookHisto1D(ihist+8, 1, 1);
	_h_JetStruct[ihist] = bookHisto1D(ihist+13, 1, 1);

	// Temp histograms for distribution parameters and SEM calculation
	_th_AllTrkSpectrum[ihist] = Histo1D(200, 0.0, 20.0);
	_th_SoftTrkSpectrum[ihist] = Histo1D(100, 0.0, 15.0);
	_th_JetTrkSpectrum[ihist] = Histo1D(100, 0.0, 20.0);
	_th_JetLTrkSpectrum[ihist] = Histo1D(100, 0.0, 20.0);
	}

	_multBinCent[0] = 20;
	_multBinCent[1] = 40;
	_multBinCent[2] = 65;
	_multBinCent[3] = 95;
	_multBinCent[4] = 125;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// MinBias trigger
	- const ChargedFinalState& cfsBSCplus = applyProjection<ChargedFinalState>(event, "cfsBSCplus");
	+ const ChargedFinalState& cfsBSCplus = apply<ChargedFinalState>(event, "cfsBSCplus");
	if (cfsBSCplus.empty()) vetoEvent;
	- const ChargedFinalState& cfsBSCminus = applyProjection<ChargedFinalState>(event, "cfsBSCminus");
	+ const ChargedFinalState& cfsBSCminus = apply<ChargedFinalState>(event, "cfsBSCminus");
	if (cfsBSCminus.empty()) vetoEvent;

	- const ChargedFinalState& cfsp = applyProjection<ChargedFinalState>(event, "CFS250");
	+ const ChargedFinalState& cfsp = apply<ChargedFinalState>(event, "CFS250");
	if (cfsp.empty()) vetoEvent;

	- const FastJets& jetpro = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(event, "Jets");
	const Jets& jets = jetpro.jetsByPt(5.0*GeV);

	const int mult = cfsp.size();

	int multbin[6] = { 10, 30, 50, 80, 110, 140 };
	for (int ibin = 0; ibin < 5; ++ibin) {
	if (mult > multbin[ibin] && mult <= multbin[ibin + 1]) {
	_passedEv[ibin] += weight;
	eventDecomp(event, ibin, weight);

	for (size_t ijets = 0; ijets < jets.size(); ijets++) {
	if (jets[ijets].abseta() < 1.9) {
	_h_JetSpectrum[ibin]->fill(jets[ijets].pT()/GeV, weight);
	if (jets[ijets].pT() > 5*GeV) _jetCounter5GeV[ibin] += weight;
	if (jets[ijets].pT() > 30*GeV) _jetCounter30GeV[ibin] += weight;
	}
	}
	}
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	for (size_t i = 0; i < 5; ++i) {
	// All trk mean pT vs Nch
	_h_AllTrkMeanPt->fill(_multBinCent[i], _th_AllTrkSpectrum[i].xMean(), getMeanError(_th_AllTrkSpectrum[i]));

	// Soft trk mean pT vs Nch
	_h_SoftTrkMeanPt->fill(_multBinCent[i], _th_SoftTrkSpectrum[i].xMean(), getMeanError(_th_SoftTrkSpectrum[i]));

	// Intrajet trk mean pT vs Nch
	_h_IntrajetTrkMeanPt->fill(_multBinCent[i], _th_JetTrkSpectrum[i].xMean(), getMeanError(_th_JetTrkSpectrum[i]));

	// Intrajet leader trk mean pT vs Nch
	_h_IntrajetLeaderTrkMeanPt->fill(_multBinCent[i], _th_JetLTrkSpectrum[i].xMean(), getMeanError(_th_JetLTrkSpectrum[i]));

	// Jet mean pT vs Nch
	const double sem = (_h_JetSpectrum[i]->xStdDev())/(sqrt(_h_JetSpectrum[i]->sumW())) / _h_JetSpectrum[i]->xMean();
	_h_MeanJetPt->fill(_multBinCent[i], _h_JetSpectrum[i]->xMean(), sem);

	// Jet rates
	double avJetRate5 = _jetCounter5GeV[i] / _passedEv[i];
	double avJetRate30 = _jetCounter30GeV[i] / _passedEv[i];

	const double sem5 = (_jetCounter5GeV[i] != 0) ? 1 / sqrt(_jetCounter5GeV[i]) : 0;
	_h_JetRate5GeV->fill(_multBinCent[i], avJetRate5, sem5);

	const double sem30 = (_jetCounter30GeV[i] != 0) ? 1 / sqrt(_jetCounter30GeV[i]) : 0;
	_h_JetRate30GeV->fill(_multBinCent[i], avJetRate30, sem30);

	scale(_h_JetSpectrum[i], 4.0 / _jetCounter5GeV[i]);
	scale(_h_JetStruct[i], 0.08 / _jetStructNorm[i]);
	}

	}


	double getMeanError(const Histo1D& hist) {
	double sem = hist.xStdErr(); // Standard error of the mean
	return sem / hist.xMean(); // relative SEM
	}


	void eventDecomp(const Event& event, size_t ibin, double weight) {

	struct TrkInJet { double pt; double eta; double phi; double R; };
	TrkInJet jetConstituents[100][100]; //1-st index - the number of the jet, 2-nd index - track in the jet
	TrkInJet jetsEv[100];
	size_t j[100];
	size_t jCount = 0;

	for (size_t i = 0; i < 100; i++) {
	j[i] = 0;
	jetsEv[i].pt = 0;
	jetsEv[i].eta = 0;
	jetsEv[i].phi = 0;
	for (size_t k = 0; k < 100; k++) {
	jetConstituents[i][k].pt = 0;
	jetConstituents[i][k].phi = 0;
	jetConstituents[i][k].eta = 0;
	jetConstituents[i][k].R = 0;
	}
	}

	- const FastJets& jetpro = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(event, "Jets");
	const Jets& jets = jetpro.jetsByPt(5.0*GeV);

	// Start event decomp

	for (size_t ijets = 0; ijets < jets.size(); ijets++) {
	jetsEv[ijets].pt = jets[ijets].pT();
	jetsEv[ijets].eta = jets[ijets].eta();
	jetsEv[ijets].phi = jets[ijets].phi();
	jCount++;
	}

	- const ChargedFinalState& cfsp = applyProjection<ChargedFinalState>(event, "CFS250");
	+ const ChargedFinalState& cfsp = apply<ChargedFinalState>(event, "CFS250");
	foreach (const Particle& p, cfsp.particles()) {
	_th_AllTrkSpectrum[ibin].fill(p.pT()/GeV, weight);
	int flag = 0;
	for (size_t i = 0; i < jCount; i++) {
	const double delta_phi = deltaPhi(jetsEv[i].phi, p.phi());
	const double delta_eta = jetsEv[i].eta - p.eta();
	const double R = sqrt(delta_phi * delta_phi + delta_eta * delta_eta);
	if (R <= 0.5) {
	flag++;
	jetConstituents[i][j[i]].pt = p.pT();
	jetConstituents[i][j[i]].R = R;
	j[i]++;
	}
	}
	if (flag == 0) _th_SoftTrkSpectrum[ibin].fill(p.pT()/GeV, weight);
	}

	for (size_t i = 0; i < jCount; i++) {
	double ptInjetLeader = 0;
	if (!inRange(jetsEv[i].eta, -1.9, 1.9)) continue; // only fully reconstructed jets for internal jet studies
	for (size_t k = 0; k < j[i]; k++) {
	_th_JetTrkSpectrum[ibin].fill(jetConstituents[i][k].pt , weight);
	_h_JetStruct[ibin]->fill(jetConstituents[i][k].R, jetConstituents[i][k].pt/jetsEv[i].pt);
	_jetStructNorm[ibin] += jetConstituents[i][k].pt / jetsEv[i].pt;
	if (ptInjetLeader < jetConstituents[i][k].pt) ptInjetLeader = jetConstituents[i][k].pt;
	}
	if (ptInjetLeader != 0) _th_JetLTrkSpectrum[ibin].fill(ptInjetLeader, weight);
	}

	}


	private:

	// Counters etc.
	vector<double> _jetStructNorm;
	vector<double> _multBinCent;
	/// @todo Need to handle weights
	vector<double> _jetCounter5GeV, _jetCounter30GeV, _passedEv;

	Profile1DPtr _h_AllTrkMeanPt, _h_SoftTrkMeanPt;
	Profile1DPtr _h_IntrajetTrkMeanPt, _h_IntrajetLeaderTrkMeanPt;
	Profile1DPtr _h_MeanJetPt;
	Profile1DPtr _h_JetRate5GeV, _h_JetRate30GeV;

	Histo1DPtr _h_JetSpectrum[5];
	Histo1DPtr _h_JetStruct[5];

	// Temp histograms
	Histo1D _th_AllTrkSpectrum[5];
	Histo1D _th_SoftTrkSpectrum[5];
	Histo1D _th_JetTrkSpectrum[5];
	Histo1D _th_JetLTrkSpectrum[5];

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2013_I1261026);

	}
	diff --git a/src/Analyses/CMS_2013_I1265659.cc b/src/Analyses/CMS_2013_I1265659.cc
	--- a/src/Analyses/CMS_2013_I1265659.cc
	+++ b/src/Analyses/CMS_2013_I1265659.cc
	@@ -1,83 +1,83 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class CMS_2013_I1265659 : public Analysis {
	public:

	/// Constructor
	CMS_2013_I1265659()
	: Analysis("CMS_2013_I1265659")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {
	const FastJets jets(FinalState(-10, 10, 0.0*GeV), FastJets::ANTIKT, 0.5);
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	_h_hTotD = bookHisto1D(1, 1, 1);
	_h_hTotDF = bookHisto1D(1, 1, 2);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	- const Jets& jets = applyProjection<FastJets>(event, "Jets").jetsByPt(30.0*GeV);
	+ const Jets& jets = apply<FastJets>(event, "Jets").jetsByPt(30.0*GeV);
	if (jets.size() < 3) vetoEvent;

	const FourMomentum jet1 = jets[0].momentum();
	const FourMomentum jet2 = jets[1].momentum();
	const FourMomentum jet3 = jets[2].momentum();

	// Cut on lead jet pT and lead/sublead jet centrality
	if (jet1.pT() < 100*GeV) vetoEvent;
	if (jet1.abseta() > 2.5 \|\| jet2.abseta() > 2.5) vetoEvent;

	// Construct eta & phi distances between 2nd and 3rd jets
	double dEta23 = jet3.eta() - jet2.eta(); ///< Note not abs
	double dPhi23 = jet3.phi() - jet2.phi(); ///< Note not abs
	if (dPhi23 > M_PI) dPhi23 -= 2*M_PI; ///< @todo Use mapTo... functions?
	if (dPhi23 < -M_PI) dPhi23 += 2*M_PI; ///< @todo Use mapTo... functions?

	// Cut on distance between 2nd and 3rd jets
	const double R23 = add_quad(dPhi23, dEta23);
	if (!inRange(R23, 0.5, 1.5)) vetoEvent;

	// Cut on dijet mass
	const FourMomentum diJet = jet1 + jet2;
	if (diJet.mass() < 220*GeV) vetoEvent;

	// Calc beta and fill histogram (choose central or fwd histo inline)
	double beta = fabs(atan2(dPhi23, sign(jet2.eta())*dEta23));
	((jet2.abseta() < 0.8) ? _h_hTotD : _h_hTotDF)->fill(beta, event.weight());
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double width = _h_hTotD->bin(0).xWidth();
	normalize(_h_hTotD, width);
	normalize(_h_hTotDF, width);
	}


	private:

	/// @name Histograms
	Histo1DPtr _h_hTotD;
	Histo1DPtr _h_hTotDF;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2013_I1265659);

	}
	diff --git a/src/Analyses/CMS_2013_I1272853.cc b/src/Analyses/CMS_2013_I1272853.cc
	--- a/src/Analyses/CMS_2013_I1272853.cc
	+++ b/src/Analyses/CMS_2013_I1272853.cc
	@@ -1,111 +1,111 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/DressedLeptons.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/InvMassFinalState.hh"

	namespace Rivet {


	/// CMS W + 2 jet double parton scattering analysis
	class CMS_2013_I1272853 : public Analysis {
	public:

	/// Constructor
	CMS_2013_I1272853()
	: Analysis("CMS_2013_I1272853") { }


	/// Book histograms and initialise projections before the run
	void init() {

	const FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	/// @todo Use C++11 initialisation syntax
	vector<PdgIdPair> vidsW;
	vidsW += make_pair(PID::MUON, PID::NU_MUBAR), make_pair(PID::ANTIMUON, PID::NU_MU);
	InvMassFinalState invfsW(fs, vidsW, 20GeV, 1e6GeV);
	- addProjection(invfsW, "INVFSW");
	+ declare(invfsW, "INVFSW");

	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(invfsW);
	- addProjection(vfs, "VFS");
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.5), "Jets");
	+ declare(vfs, "VFS");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.5), "Jets");

	_h_deltaS_eq2jet_Norm = bookHisto1D(1,1,1);
	_h_rel_deltaPt_eq2jet_Norm = bookHisto1D(2,1,1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Find Ws
	- const InvMassFinalState& invMassFinalStateW = applyProjection<InvMassFinalState>(event, "INVFSW");
	+ const InvMassFinalState& invMassFinalStateW = apply<InvMassFinalState>(event, "INVFSW");
	if (invMassFinalStateW.empty()) vetoEvent;
	const Particles& WDecayProducts = invMassFinalStateW.particles();
	if (WDecayProducts.size() < 2) vetoEvent;

	// Cuts on W decay properties
	const int iNU_MU = (WDecayProducts[1].abspid() == PID::NU_MU) ? 1 : 0;
	const int iAN_MU = 1 - iNU_MU;
	const double pt1 = WDecayProducts[iAN_MU].pT();
	const double pt2 = WDecayProducts[iNU_MU].Et();
	const double eta1 = WDecayProducts[iAN_MU].abseta();
	const double phi1 = WDecayProducts[iAN_MU].phi();
	const double phi2 = WDecayProducts[iNU_MU].phi();
	const double mt = sqrt(2 * pt1 * pt2 * (1 - cos(phi1-phi2)));
	if (mt < 50GeV \|\| pt1 < 35GeV \|\| eta1 > 2.1 \|\| pt2 < 30*GeV) vetoEvent;

	// Get jets and make sure there are at least two of them in \|y\| < 2
	- const FastJets& jetpro = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(event, "Jets");
	/// @todo Collapse this into jetpro.jetsByPt(ptGtr(20*GeV) & rapIn(2.0))
	vector<FourMomentum> jets;
	foreach (const Jet& jet, jetpro.jetsByPt(20*GeV))
	if (jet.absrap() < 2.0) jets.push_back(jet.momentum());
	if (jets.size() != 2) vetoEvent;

	const double mupx = pt1 * cos(phi1);
	const double mupy = pt1 * sin(phi1);
	const double met_x = pt2 * cos(phi2);
	const double met_y = pt2 * sin(phi2);
	const double dpt = add_quad(jets[0].px() + jets[1].px(), jets[0].py() + jets[1].py());
	const double rel_dpt = dpt / (jets[0].pT() + jets[1].pT());
	const double pT2 = sqr(mupx + met_x) + sqr(mupy + met_y);
	const double Px = (mupx + met_x)*(jets[0].px() + jets[1].px());
	const double Py = (mupy + met_y)*(jets[0].py() + jets[1].py());
	const double p1p2_mag = dpt * sqrt(pT2);
	const double dS = acos((Px+Py) / p1p2_mag);

	const double weight = event.weight();
	_h_rel_deltaPt_eq2jet_Norm->fill(rel_dpt, weight);
	_h_deltaS_eq2jet_Norm->fill(dS, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double rel_dpt_bw = 1.0002 / 30.0;
	const double dphi_bw = 3.14160 / 30.0;
	normalize(_h_rel_deltaPt_eq2jet_Norm, rel_dpt_bw);
	normalize(_h_deltaS_eq2jet_Norm, dphi_bw);
	}


	private:

	Histo1DPtr _h_rel_deltaPt_eq2jet_Norm;
	Histo1DPtr _h_deltaS_eq2jet_Norm;

	};



	DECLARE_RIVET_PLUGIN(CMS_2013_I1272853);

	}
	diff --git a/src/Analyses/CMS_2013_I1273574.cc b/src/Analyses/CMS_2013_I1273574.cc
	--- a/src/Analyses/CMS_2013_I1273574.cc
	+++ b/src/Analyses/CMS_2013_I1273574.cc
	@@ -1,102 +1,102 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// CMS 4-jet production at 7 TeV
	class CMS_2013_I1273574 : public Analysis {
	public:

	/// Constructor
	CMS_2013_I1273574()
	: Analysis("CMS_2013_I1273574")
	{ }


	/// Book histograms and initialise projections before the run
	void init() {
	const FinalState cnfs(-4.7, 4.7);
	- addProjection(FastJets(cnfs, FastJets::ANTIKT, 0.5), "Jets");
	+ declare(FastJets(cnfs, FastJets::ANTIKT, 0.5), "Jets");

	_h_jetetas[0] = bookHisto1D(1,1,1);
	_h_jetpts[0] = bookHisto1D(2,1,1);
	_h_DeltaS = bookHisto1D(3,1,1);
	_h_DeltaPhiSoft = bookHisto1D(4,1,1);
	_h_DeltaPtRelSoft = bookHisto1D(5,1,1);
	_h_jetetas[2] = bookHisto1D(6,1,1);
	_h_jetpts[2] = bookHisto1D(7,1,1);
	_h_jetetas[3] = bookHisto1D(8,1,1);
	_h_jetpts[3] = bookHisto1D(9,1,1);
	_h_jetetas[1] = bookHisto1D(10,1,1);
	_h_jetpts[1] = bookHisto1D(11,1,1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	/// @todo Use jetsByPt(ptGtr(20*GeV) & absetaIn(4.7)), then no need for the lower loop;
	- const Jets jets = applyProjection<FastJets>(event, "Jets").jetsByPt(20*GeV);
	+ const Jets jets = apply<FastJets>(event, "Jets").jetsByPt(20*GeV);
	if (jets.size() < 4) vetoEvent;

	// Ensure that there are exactly 4 jets > 20 GeV, with two above 50 GeV
	Jets hardjets, alljets;
	foreach (const Jet& j, jets) {
	if (j.abseta() > 4.7) continue;
	if (j.pT() > 50*GeV) hardjets.push_back(j);
	if (j.pT() > 20*GeV) alljets.push_back(j);
	}
	if (hardjets.size() < 2 \|\| alljets.size() != 4) vetoEvent;
	const double weight = event.weight();

	// Histogram pT and eta of all 4 jets
	for (size_t i = 0; i < 4; ++i) {
	_h_jetpts[i]->fill(alljets[i].pT()/GeV, weight);
	_h_jetetas[i]->fill(alljets[i].eta(), weight);
	}

	// Create vector sums of the hard and soft pairs of jets
	const FourMomentum p12 = alljets[0].momentum() + alljets[1].momentum();
	const FourMomentum p34 = alljets[2].momentum() + alljets[3].momentum();

	// Fill the delta(phi) between the soft jets
	const double dphisoft = deltaPhi(alljets[2], alljets[3]);
	_h_DeltaPhiSoft->fill(dphisoft, weight);

	// Fill the pT balance between the soft jets
	const double ptbalanceSoft = p34.pT() / (alljets[2].pT() + alljets[3].pT());
	_h_DeltaPtRelSoft->fill(ptbalanceSoft, weight);

	// Fill the azimuthal angle difference between the two jet pairs
	const double p12p34_trans = p12.px()p34.px() + p12.py()p34.py();
	const double DeltaS = acos( p12p34_trans / p12.pT() / p34.pT() );
	_h_DeltaS->fill(DeltaS, weight);
	}


	/// Normalise histograms (mostly to cross-section)
	void finalize() {
	const double invlumi = crossSection()/picobarn/sumOfWeights();
	for (size_t i = 0; i < 4; ++i) {
	scale(_h_jetpts[i], invlumi);
	scale(_h_jetetas[i], invlumi);
	}
	normalize(_h_DeltaPtRelSoft);
	normalize(_h_DeltaPhiSoft);
	normalize(_h_DeltaS);
	}


	private:

	Histo1DPtr _h_jetpts[4], _h_jetetas[4];
	Histo1DPtr _h_DeltaS, _h_DeltaPhiSoft, _h_DeltaPtRelSoft;

	};


	DECLARE_RIVET_PLUGIN(CMS_2013_I1273574);

	}
	diff --git a/src/Analyses/CMS_2014_I1298810.cc b/src/Analyses/CMS_2014_I1298810.cc
	--- a/src/Analyses/CMS_2014_I1298810.cc
	+++ b/src/Analyses/CMS_2014_I1298810.cc
	@@ -1,142 +1,142 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// Ratios of jet pT spectra, related to ratios of differential jet cross sections
	class CMS_2014_I1298810 : public Analysis {
	public:

	/// Constructor
	CMS_2014_I1298810()
	: Analysis("CMS_2014_I1298810")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	// Projections
	FastJets jetsak5(FinalState(), FastJets::ANTIKT, 0.5);
	- addProjection(jetsak5, "JetsAK5");
	+ declare(jetsak5, "JetsAK5");
	FastJets jetsak7(FinalState(), FastJets::ANTIKT, 0.7);
	- addProjection(jetsak7, "JetsAK7");
	+ declare(jetsak7, "JetsAK7");

	// Histograms
	_h_pt_05_ak5 = bookHisto1D(1, 1, 1);
	_h_pt_05_10_ak5 = bookHisto1D(2, 1, 1);
	_h_pt_10_15_ak5 = bookHisto1D(3, 1, 1);
	_h_pt_15_20_ak5 = bookHisto1D(4, 1, 1);
	_h_pt_20_25_ak5 = bookHisto1D(5, 1, 1);
	_h_pt_25_30_ak5 = bookHisto1D(6, 1, 1);

	_h_pt_05_ak7 = bookHisto1D(7, 1, 1);
	_h_pt_05_10_ak7 = bookHisto1D(8, 1, 1);
	_h_pt_10_15_ak7 = bookHisto1D(9, 1, 1);
	_h_pt_15_20_ak7 = bookHisto1D(10, 1, 1);
	_h_pt_20_25_ak7 = bookHisto1D(11, 1, 1);
	_h_pt_25_30_ak7 = bookHisto1D(12, 1, 1);

	_h_pt_05_ratio = bookScatter2D(13, 1, 1);
	_h_pt_05_10_ratio = bookScatter2D(14, 1, 1);
	_h_pt_10_15_ratio = bookScatter2D(15, 1, 1);
	_h_pt_15_20_ratio = bookScatter2D(16, 1, 1);
	_h_pt_20_25_ratio = bookScatter2D(17, 1, 1);
	_h_pt_25_30_ratio = bookScatter2D(18, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	- const Jets& jetsak5 = applyProjection<FastJets>(event, "JetsAK5").jetsByPt(56*GeV);
	- const Jets& jetsak7 = applyProjection<FastJets>(event, "JetsAK7").jetsByPt(56*GeV);
	+ const Jets& jetsak5 = apply<FastJets>(event, "JetsAK5").jetsByPt(56*GeV);
	+ const Jets& jetsak7 = apply<FastJets>(event, "JetsAK7").jetsByPt(56*GeV);
	if (jetsak5.size() < 1 && jetsak7.size() < 1) vetoEvent;

	const double weight = event.weight();

	// Filling R = 0.5 jets
	foreach(const Jet& jet, jetsak5) {
	if (jet.absrapidity() < 0.5) {
	_h_pt_05_ak5->fill(jet.pT()/GeV, weight);
	} else if (jet.absrapidity() < 1.0) {
	_h_pt_05_10_ak5->fill(jet.pT()/GeV, weight);
	} else if (jet.absrapidity() < 1.5) {
	_h_pt_10_15_ak5->fill(jet.pT()/GeV, weight);
	} else if (jet.absrapidity() < 2.0) {
	_h_pt_15_20_ak5->fill(jet.pT()/GeV, weight);
	} else if (jet.absrapidity() < 2.5) {
	_h_pt_20_25_ak5->fill(jet.pT()/GeV, weight);
	} else if (jet.absrapidity() < 3.0) {
	_h_pt_25_30_ak5->fill(jet.pT()/GeV, weight);
	}
	}


	// Filling R = 0.7 jets
	foreach(const Jet& jet, jetsak7) {
	if (jet.absrapidity() < 0.5) {
	_h_pt_05_ak7->fill(jet.pT() * GeV, weight);
	} else if (jet.absrapidity() < 1.0) {
	_h_pt_05_10_ak7->fill(jet.pT() * GeV, weight);
	} else if (jet.absrapidity() < 1.5) {
	_h_pt_10_15_ak7->fill(jet.pT() * GeV, weight);
	} else if (jet.absrapidity() < 2.0) {
	_h_pt_15_20_ak7->fill(jet.pT() * GeV, weight);
	} else if (jet.absrapidity() < 2.5) {
	_h_pt_20_25_ak7->fill(jet.pT() * GeV, weight);
	} else if (jet.absrapidity() < 3.0) {
	_h_pt_25_30_ak7->fill(jet.pT() * GeV, weight);
	}
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_pt_05_ak5, crossSection()/sumOfWeights());
	scale(_h_pt_05_10_ak5, crossSection()/sumOfWeights());
	scale(_h_pt_10_15_ak5, crossSection()/sumOfWeights());
	scale(_h_pt_15_20_ak5, crossSection()/sumOfWeights());
	scale(_h_pt_20_25_ak5, crossSection()/sumOfWeights());
	scale(_h_pt_25_30_ak5, crossSection()/sumOfWeights());

	scale(_h_pt_05_ak7, crossSection()/sumOfWeights());
	scale(_h_pt_05_10_ak7, crossSection()/sumOfWeights());
	scale(_h_pt_10_15_ak7, crossSection()/sumOfWeights());
	scale(_h_pt_15_20_ak7, crossSection()/sumOfWeights());
	scale(_h_pt_20_25_ak7, crossSection()/sumOfWeights());
	scale(_h_pt_25_30_ak7, crossSection()/sumOfWeights());

	divide(_h_pt_05_ak5, _h_pt_05_ak7, _h_pt_05_ratio);
	divide(_h_pt_05_10_ak5, _h_pt_05_10_ak7, _h_pt_05_10_ratio);
	divide(_h_pt_10_15_ak5, _h_pt_10_15_ak7, _h_pt_10_15_ratio);
	divide(_h_pt_15_20_ak5, _h_pt_15_20_ak7, _h_pt_15_20_ratio);
	divide(_h_pt_20_25_ak5, _h_pt_20_25_ak7, _h_pt_20_25_ratio);
	divide(_h_pt_25_30_ak5, _h_pt_25_30_ak7, _h_pt_25_30_ratio);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_pt_05_ak5, _h_pt_05_10_ak5, _h_pt_10_15_ak5, _h_pt_15_20_ak5, _h_pt_20_25_ak5, _h_pt_25_30_ak5;
	Histo1DPtr _h_pt_05_ak7, _h_pt_05_10_ak7, _h_pt_10_15_ak7, _h_pt_15_20_ak7, _h_pt_20_25_ak7, _h_pt_25_30_ak7;
	Scatter2DPtr _h_pt_05_ratio, _h_pt_05_10_ratio, _h_pt_10_15_ratio, _h_pt_15_20_ratio, _h_pt_20_25_ratio, _h_pt_25_30_ratio;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2014_I1298810);

	}
	diff --git a/src/Analyses/CMS_2014_I1303894.cc b/src/Analyses/CMS_2014_I1303894.cc
	--- a/src/Analyses/CMS_2014_I1303894.cc
	+++ b/src/Analyses/CMS_2014_I1303894.cc
	@@ -1,243 +1,243 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/InvMassFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/DressedLeptons.hh"

	namespace Rivet {


	/// @brief Differential cross-section of W bosons + jets in pp collisions at sqrt(s)=7 TeV
	/// @author Darin Baumgartel (darinb@cern.ch)
	///
	/// Based on Rivet analysis originally created by Anil Singh (anil@cern.ch), Lovedeep Saini (lovedeep@cern.ch)
	class CMS_2014_I1303894 : public Analysis {
	public:

	/// Constructor
	CMS_2014_I1303894()
	: Analysis("CMS_2014_I1303894")
	{ }


	// Book histograms and initialise projections before the run
	void init() {
	// Projections
	const FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	MissingMomentum missing(fs);
	- addProjection(missing, "MET");
	+ declare(missing, "MET");

	IdentifiedFinalState bareMuons(fs);
	bareMuons.acceptIdPair(PID::MUON);
	DressedLeptons muonClusters(fs, bareMuons, 0.1, Cuts::open(), false, false);
	- addProjection(muonClusters, "muonClusters");
	+ declare(muonClusters, "muonClusters");

	IdentifiedFinalState neutrinos;
	neutrinos.acceptIdPair(PID::NU_MU);
	- addProjection(neutrinos, "neutrinos");
	+ declare(neutrinos, "neutrinos");

	VetoedFinalState jetFS(fs);
	jetFS.addVetoOnThisFinalState(muonClusters);
	jetFS.addVetoOnThisFinalState(neutrinos);
	jetFS.vetoNeutrinos();
	FastJets JetProjection(jetFS, FastJets::ANTIKT, 0.5);
	JetProjection.useInvisibles(false);
	- addProjection(JetProjection, "Jets");
	+ declare(JetProjection, "Jets");

	// Histograms
	_histDPhiMuJet1 = bookHisto1D(1,1,1);
	_histDPhiMuJet2 = bookHisto1D(2,1,1);
	_histDPhiMuJet3 = bookHisto1D(3,1,1);
	_histDPhiMuJet4 = bookHisto1D(4,1,1);

	_histEtaJet1 = bookHisto1D(5,1,1);
	_histEtaJet2 = bookHisto1D(6,1,1);
	_histEtaJet3 = bookHisto1D(7,1,1);
	_histEtaJet4 = bookHisto1D(8,1,1);

	_histHT1JetInc = bookHisto1D(9,1,1);
	_histHT2JetInc = bookHisto1D(10,1,1);
	_histHT3JetInc = bookHisto1D(11,1,1);
	_histHT4JetInc = bookHisto1D(12,1,1);

	_histJet30MultExc = bookHisto1D(13,1,1);
	_histJet30MultInc = bookHisto1D(14,1,1);

	_histPtJet1 = bookHisto1D(15,1,1);
	_histPtJet2 = bookHisto1D(16,1,1);
	_histPtJet3 = bookHisto1D(17,1,1);
	_histPtJet4 = bookHisto1D(18,1,1);

	// Counters
	_n_1jet = 0.0;
	_n_2jet = 0.0;
	_n_3jet = 0.0;
	_n_4jet = 0.0;
	_n_inclusivebinsummation = 0.0;
	}


	void analyze(const Event& event) {
	// Get the dressed muon
	- const DressedLeptons& muonClusters = applyProjection<DressedLeptons>(event, "muonClusters");
	+ const DressedLeptons& muonClusters = apply<DressedLeptons>(event, "muonClusters");
	int nmu = muonClusters.dressedLeptons().size();
	if (nmu < 1) vetoEvent;
	DressedLepton dressedmuon = muonClusters.dressedLeptons()[0];
	if (dressedmuon.momentum().abseta() > 2.1) vetoEvent;
	if (dressedmuon.momentum().pT() < 25.0*GeV) vetoEvent;

	// Get the muon neutrino
	- const Particles& neutrinos = applyProjection<FinalState>(event, "neutrinos").particlesByPt();
	+ const Particles& neutrinos = apply<FinalState>(event, "neutrinos").particlesByPt();
	if (neutrinos.empty()) vetoEvent;

	// Check that the muon and neutrino are not decay products of tau
	if (dressedmuon.constituentLepton().hasAncestor( PID::TAU)) vetoEvent;
	if (dressedmuon.constituentLepton().hasAncestor(-PID::TAU)) vetoEvent;
	if (dressedmuon.constituentLepton().hasAncestor( PID::NU_TAU)) vetoEvent;
	if (dressedmuon.constituentLepton().hasAncestor(-PID::NU_TAU)) vetoEvent;
	if (neutrinos[0].hasAncestor( PID::TAU)) vetoEvent;
	if (neutrinos[0].hasAncestor(-PID::TAU)) vetoEvent;
	if (neutrinos[0].hasAncestor( PID::NU_TAU)) vetoEvent;
	if (neutrinos[0].hasAncestor(-PID::NU_TAU)) vetoEvent;

	// Recording of event weight and numbers
	const double weight = event.weight();

	// Get the missing momentum
	- const MissingMomentum& met = applyProjection<MissingMomentum>(event, "MET");
	+ const MissingMomentum& met = apply<MissingMomentum>(event, "MET");
	const double ptmet = met.visibleMomentum().pT();
	const double phimet = (-met.visibleMomentum()).phi();

	// Calculate MET and MT(mu,MET), and remove events with MT < 50 GeV
	const double ptmuon = dressedmuon.pT();
	const double phimuon = dressedmuon.phi();
	const double mt_mumet = sqrt(2ptmuonptmet*(1.0 - cos(phimet-phimuon)));

	// Remove events in MT < 50 region
	if (mt_mumet < 50*GeV) vetoEvent;

	// Loop over jets and fill pt/eta/phi quantities in vectors
	- const Jets& jets_filtered = applyProjection<FastJets>(event, "Jets").jetsByPt(0.0*GeV);
	+ const Jets& jets_filtered = apply<FastJets>(event, "Jets").jetsByPt(0.0*GeV);
	vector<float> finaljet_pT_list, finaljet_eta_list, finaljet_phi_list;
	double htjets = 0.0;
	for (size_t ii = 0; ii < jets_filtered.size(); ++ii) {
	// Jet pT/eta/phi
	double jet_pt = jets_filtered[ii].pT();
	double jet_eta = jets_filtered[ii].eta();
	double jet_phi = jets_filtered[ii].phi();

	// Kinemetic cuts for jet acceptance
	if (fabs(jet_eta) > 2.4) continue;
	if (jet_pt < 30.0*GeV) continue;
	if (deltaR(dressedmuon, jets_filtered[ii]) < 0.5) continue;

	// Add jet to jet list and increases the HT variable
	finaljet_pT_list.push_back(jet_pt);
	finaljet_eta_list.push_back(jet_eta);
	finaljet_phi_list.push_back(jet_phi);
	htjets += fabs(jet_pt);
	}


	// Filling of histograms:
	// Fill as many jets as there are into the exclusive jet multiplicity
	if (!finaljet_pT_list.empty())
	_histJet30MultExc->fill(finaljet_pT_list.size(), weight);

	for (size_t ij = 0; ij < finaljet_pT_list.size(); ++ij) {
	_histJet30MultInc->fill(ij+1, weight);
	_n_inclusivebinsummation += weight;
	}

	if (finaljet_pT_list.size() >= 1) {
	_histPtJet1->fill(finaljet_pT_list[0],weight);
	_histEtaJet1->fill(fabs(finaljet_eta_list[0]), weight);
	_histDPhiMuJet1->fill(deltaPhi(finaljet_phi_list[0], phimuon),weight);
	_histHT1JetInc->fill(htjets, weight);
	_n_1jet +=weight;
	}

	if (finaljet_pT_list.size() >= 2) {
	_histPtJet2->fill(finaljet_pT_list[1], weight);
	_histEtaJet2->fill(fabs(finaljet_eta_list[1]), weight);
	_histDPhiMuJet2->fill(deltaPhi(finaljet_phi_list[1], phimuon), weight);
	_histHT2JetInc->fill(htjets, weight);
	_n_2jet += weight;
	}

	if (finaljet_pT_list.size() >= 3) {
	_histPtJet3->fill(finaljet_pT_list[2], weight);
	_histEtaJet3->fill(fabs(finaljet_eta_list[2]), weight);
	_histDPhiMuJet3->fill(deltaPhi(finaljet_phi_list[2], phimuon), weight);
	_histHT3JetInc->fill(htjets, weight);
	_n_3jet += weight;
	}

	if (finaljet_pT_list.size() >=4 ) {
	_histPtJet4->fill(finaljet_pT_list[3], weight);
	_histEtaJet4->fill(fabs(finaljet_eta_list[3]), weight);
	_histDPhiMuJet4->fill(deltaPhi(finaljet_phi_list[3], phimuon), weight);
	_histHT4JetInc-> fill(htjets, weight);
	_n_4jet += weight;
	}

	}


	// Finalize the histograms.
	void finalize() {

	const double inclusive_cross_section = crossSection();
	const double norm_1jet_histo = inclusive_cross_section*_n_1jet/sumOfWeights();
	const double norm_2jet_histo = inclusive_cross_section*_n_2jet/sumOfWeights();
	const double norm_3jet_histo = inclusive_cross_section*_n_3jet/sumOfWeights();
	const double norm_4jet_histo = inclusive_cross_section*_n_4jet/sumOfWeights();
	const double norm_incmultiplicity = inclusive_cross_section*_n_inclusivebinsummation/sumOfWeights();

	normalize(_histJet30MultExc, norm_1jet_histo);
	normalize(_histJet30MultInc, norm_incmultiplicity);

	normalize(_histPtJet1, norm_1jet_histo);
	normalize(_histHT1JetInc, norm_1jet_histo);
	normalize(_histEtaJet1, norm_1jet_histo);
	normalize(_histDPhiMuJet1, norm_1jet_histo);

	normalize(_histPtJet2, norm_2jet_histo);
	normalize(_histHT2JetInc, norm_2jet_histo);
	normalize(_histEtaJet2, norm_2jet_histo);
	normalize(_histDPhiMuJet2, norm_2jet_histo);

	normalize(_histPtJet3, norm_3jet_histo);
	normalize(_histHT3JetInc, norm_3jet_histo);
	normalize(_histEtaJet3, norm_3jet_histo);
	normalize(_histDPhiMuJet3, norm_3jet_histo);

	normalize(_histPtJet4, norm_4jet_histo);
	normalize(_histHT4JetInc, norm_4jet_histo);
	normalize(_histEtaJet4, norm_4jet_histo);
	normalize(_histDPhiMuJet4, norm_4jet_histo);
	}


	private:

	Histo1DPtr _histJet30MultExc, _histJet30MultInc;
	Histo1DPtr _histPtJet1, _histPtJet2, _histPtJet3, _histPtJet4;
	Histo1DPtr _histEtaJet1, _histEtaJet2, _histEtaJet3, _histEtaJet4;
	Histo1DPtr _histDPhiMuJet1, _histDPhiMuJet2, _histDPhiMuJet3, _histDPhiMuJet4;
	Histo1DPtr _histHT1JetInc, _histHT2JetInc, _histHT3JetInc, _histHT4JetInc;

	double _n_1jet, _n_2jet, _n_3jet, _n_4jet, _n_inclusivebinsummation;

	};


	DECLARE_RIVET_PLUGIN(CMS_2014_I1303894);

	}
	diff --git a/src/Analyses/CMS_2014_I1305624.cc b/src/Analyses/CMS_2014_I1305624.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/CMS_2014_I1305624.cc
	@@ -0,0 +1,910 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+
	+ namespace {
	+
	+ /// Number of event shape variables
	+ /// @todo Move into the EventShape class
	+ const int NEVTVAR = 5;
	+
	+ /// Number of leading jet pT thresholds
	+ /// @todo Move into the analysis class
	+ const int NJETPTMN = 5;
	+ /// Leading jet pT thresholds
	+ /// @todo Move into the analysis class
	+ const double LEADINGPTTHRESHOLD[NJETPTMN] = { 110.0, 170.0, 250.0, 320.0, 390.0 };
	+
	+
	+ // Helpers for event shape calculations in hidden namespace; implementation at bottom of file
	+ /// @todo Why a class? Improve/remove this junk
	+ class EventShape {
	+ public:
	+
	+ /// Constructor from vectors of four-vectors as input objects in the event to calculate the event shapes
	+ EventShape(const vector<double>& px_vector, const vector<double>& py_vector, const vector<double>& pz_vector,
	+ const vector<double>& e_vector, double eta_central, int irap, int nmn)
	+ : _object_px(px_vector), _object_py(py_vector), _object_pz(pz_vector),
	+ _object_e(e_vector), _eta_c(eta_central), _irap(irap), _nmnjet(nmn)
	+ { }
	+
	+ /// @brief Returns the values of the five event shapes
	+ ///
	+ /// Event shape indices:
	+ /// 0. central transverse thrust
	+ /// 1. central total jet broadening
	+ /// 2. central total jet mass
	+ /// 3. central total transverse jet mass
	+ /// 4. central three-jet resolution threshold
	+ vector<double> getEventShapes() {
	+ _calculate(); ///< @todo There should be some test for success/failure!!
	+ return _event_shapes;
	+ }
	+
	+ /// Returns the global thrust axis Nx, Ny, Nz=0
	+ vector<double> getThrustAxis() {
	+ _calculate(); ///< @todo There should be some test for success/failure!!
	+ return _thrust_axis;
	+ }
	+
	+ /// Returns the central thrust axis Nx, Ny, Nz=0
	+ vector<double> getThrustAxisC() {
	+ _calculate(); ///< @todo There should be some test for success/failure!!
	+ return _thrust_axis_c;
	+ }
	+
	+ // /// @brief Choice of the central region
	+ // void setEtaC(double eta_central) { _eta_c = eta_central; }
	+
	+ // // Whether to use the rapidity y (rap==1) or the pseudorapidity eta (rap==0)
	+ // void setRapType(int irap) { _irap = irap; }
	+
	+
	+ private:
	+
	+ /// Calculate everything
	+ int _calculate();
	+
	+ /// Returns the difference in phi between two vectors
	+ double _delta_phi(double, double);
	+
	+ /// The Lorentz scalar product
	+ double _lorentz_sp(const vector<double>&, const vector<double>&);
	+
	+ // Calculates the three-jet resolutions
	+ double _three_jet_res(const vector<double>&, const vector<double>&, const vector<double>&, const vector<double>&, int);
	+
	+ // Calculates the thrust axis and the tau values
	+ vector<double> _thrust(const vector<double>&, const vector<double>&);
	+
	+
	+ vector<double> _object_px, _object_py, _object_pz, _object_p;
	+ vector<double> _object_pt, _object_e, _object_phi, _object_eta;
	+ vector<double> _event_shapes;
	+ vector<double> _thrust_axis, _thrust_axis_c;
	+
	+ double _eta_c;
	+ int _irap;
	+ size_t _nmnjet;
	+
	+ };
	+
	+ }
	+
	+
	+
	+
	+ class CMS_2014_I1305624 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ CMS_2014_I1305624()
	+ : Analysis("CMS_2014_I1305624")
	+ { }
	+
	+
	+ /// @name Analysis methods
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+ const FastJets jets(FinalState(Cuts::abseta < 2.6), FastJets::ANTIKT, 0.5);
	+ declare(jets, "Jets");
	+
	+ for (int ij=0; ij < NJETPTMN; ij++) {
	+ _h_thrustc[ij] = bookHisto1D(1, 1, ij+1);
	+ _h_broadt[ij] = bookHisto1D(1, 2, ij+1);
	+ _h_tot3dmass[ij] = bookHisto1D(1, 3, ij+1);
	+ _h_tottrnsmass[ij] = bookHisto1D(1, 4, ij+1);
	+ _h_y23c[ij] = bookHisto1D(1, 5, ij+1);
	+ //
	+ _alow1[ij] = _h_thrustc[ij]->xMin();
	+ _alow2[ij] = _h_broadt[ij]->xMin();
	+ _alow3[ij] = _h_tot3dmass[ij]->xMin();
	+ _alow4[ij] = _h_tottrnsmass[ij]->xMin();
	+ _alow5[ij] = _h_y23c[ij]->xMin();
	+ //
	+ _ahgh1[ij] = _h_thrustc[ij]->xMax();
	+ _ahgh2[ij] = _h_broadt[ij]->xMax();
	+ _ahgh3[ij] = _h_tot3dmass[ij]->xMax();
	+ _ahgh4[ij] = _h_tottrnsmass[ij]->xMax();
	+ _ahgh5[ij] = _h_y23c[ij]->xMax();
	+ }
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ const Jets& jets = apply<FastJets>(event, "Jets").jetsByPt(30.0*GeV);
	+ if (jets.size() < 2) vetoEvent;
	+ if (jets[0].abseta() > 2.4 \|\| jets[1].abseta() > 2.4) vetoEvent;
	+
	+ const double leadingpt = jets[0].pT();
	+ if (leadingpt < 110*GeV) vetoEvent;
	+
	+ vector<double> jtpx, jtpy, jtpz, jten;
	+ foreach (const Jet& j, jets) {
	+ if (j.abseta() < 2.4) {
	+ jtpx.push_back(j.px());
	+ jtpy.push_back(j.py());
	+ jtpz.push_back(j.pz());
	+ jten.push_back(j.E());
	+ }
	+ }
	+
	+ EventShape eventshape(jtpx, jtpy, jtpz, jten, 2.4, 0, 2);
	+ const vector<double> eventvar = eventshape.getEventShapes();
	+ if (eventvar[NEVTVAR] < 0) vetoEvent; // Jets are not only one hemisphere
	+
	+ const double weight = event.weight();
	+ for (int ij = NJETPTMN-1; ij >= 0; --ij) {
	+ if (leadingpt/GeV > LEADINGPTTHRESHOLD[ij]) {
	+ if (inRange(eventvar[0], _alow1[ij], _ahgh1[ij])) _h_thrustc[ij]->fill(eventvar[0], weight);
	+ if (inRange(eventvar[2], _alow3[ij], _ahgh3[ij])) _h_tot3dmass[ij]->fill(eventvar[2], weight);
	+ if (inRange(eventvar[3], _alow4[ij], _ahgh4[ij])) _h_tottrnsmass[ij]->fill(eventvar[3], weight);
	+ if (eventvar[NEVTVAR] >= 3) {
	+ if (inRange(eventvar[1], _alow2[ij], _ahgh2[ij])) _h_broadt[ij]->fill(eventvar[1], weight);
	+ if (inRange(eventvar[4], _alow5[ij], _ahgh5[ij])) _h_y23c[ij]->fill(eventvar[4], weight);
	+ }
	+ break;
	+ }
	+ }
	+
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ for (int ij = 0; ij < NJETPTMN; ij++) {
	+ normalize(_h_thrustc[ij]);
	+ normalize(_h_broadt[ij]);
	+ normalize(_h_tot3dmass[ij]);
	+ normalize(_h_tottrnsmass[ij]);
	+ normalize(_h_y23c[ij]);
	+ }
	+ }
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _h_thrustc[NJETPTMN];
	+ Histo1DPtr _h_broadt[NJETPTMN];
	+ Histo1DPtr _h_tot3dmass[NJETPTMN];
	+ Histo1DPtr _h_tottrnsmass[NJETPTMN];
	+ Histo1DPtr _h_y23c[NJETPTMN];
	+ //@}
	+
	+ // Data members
	+ double _alow1[NJETPTMN], _alow2[NJETPTMN], _alow3[NJETPTMN], _alow4[NJETPTMN], _alow5[NJETPTMN];
	+ double _ahgh1[NJETPTMN], _ahgh2[NJETPTMN], _ahgh3[NJETPTMN], _ahgh4[NJETPTMN], _ahgh5[NJETPTMN];
	+
	+ };
	+
	+
	+ DECLARE_RIVET_PLUGIN(CMS_2014_I1305624);
	+
	+
	+
	+ /////////////////////
	+
	+
	+ namespace {
	+
	+ // EventShape helper class method implementations:
	+
	+ int EventShape::_calculate() {
	+ if (!_event_shapes.empty() && !_thrust_axis.empty() && !_thrust_axis_c.empty())
	+ return 1; //< return success if this appears to already have been run
	+
	+ const size_t length = (size_t) _object_px.size();
	+
	+ if (((size_t) _object_py.size() != length) \|\|
	+ ((size_t) _object_pz.size() != length) \|\|
	+ ((size_t) _object_e.size() != length)) {
	+ /// @todo Change to exception or assert
	+ // cout << "ERROR!!!! Input vectors differ in size! Change that please!" << endl;
	+ // cout<<"py_size: "<<_object_py.size()<<" ,pz_size: "<<_object_pz.size()
	+ // <<" ,px_size: "<<_object_px.size()<<" ,E_size: "<<_object_e.size()<<endl;
	+ return 0;
	+ }
	+
	+ if (!_object_p.empty()) {
	+ _object_p.clear();
	+ _object_pt.clear();
	+ _object_eta.clear();
	+ _object_phi.clear();
	+ _event_shapes.clear();
	+ _thrust_axis.clear();
	+ _thrust_axis_c.clear();
	+ }
	+
	+ for (size_t j = 0; j < length; j++) {
	+ _object_p.push_back(0.);
	+ _object_pt.push_back(0.);
	+ _object_eta.push_back(0.);
	+ _object_phi.push_back(0.);
	+ }
	+
	+ for (int j = 0; j < NEVTVAR; j++) {
	+ _event_shapes.push_back(-50.);
	+ }
	+
	+ _event_shapes.push_back(double(_object_px.size())); //< WTF?
	+
	+ for (size_t j = 0; j < 3; j++) {
	+ _thrust_axis.push_back(0.);
	+ _thrust_axis_c.push_back(0.);
	+ }
	+
	+ double theta = 0;
	+
	+ for (size_t k = 0; k < length; k++) {
	+ _object_p[k] = sqrt(pow(_object_px[k],2) + pow(_object_py[k],2) + pow(_object_pz[k],2));
	+ _object_pt[k] = sqrt(pow(_object_px[k],2) + pow(_object_py[k],2));
	+ if (_object_p[k] > _object_e[k] + 1e-4) {
	+ /// @todo Change to exception or assert
	+ // cout << "ERROR!!! object " << k <<" has P = " << _object_p[k]
	+ // << " which is bigger than E = " << _object_e[k] <<" "
	+ // << _object_px[k] <<" "<< _object_py[k] <<" "
	+ // << _object_pz[k] <<" of total length "<< length
	+ // << endl;
	+ return 0;
	+ }
	+
	+ //to prevent a division by zero
	+ if (_irap == 0) {
	+ if (fabs(_object_pz[k]) > 1e-5) {
	+ theta = atan(_object_pt[k]/(_object_pz[k]));
	+ } else {
	+ theta = M_PI/2;
	+ }
	+ if (theta < 0.) theta = theta + M_PI;
	+ _object_eta[k] = -log(tan(0.5*theta));
	+ }
	+ if (_irap == 1) {
	+ if (_object_pz[k] == _object_e[k]) {
	+ /// @todo Change to exception or assert
	+ // cout << "ERROR!!! object "<<k<<" has Pz "<< _object_pz[k] <<" which is equal to E = "<< _object_e[k] <<endl;
	+ return 0;
	+ }
	+ _object_eta[k]=0.5*log((_object_e[k]+_object_pz[k])/(_object_e[k]-_object_pz[k]));
	+ }
	+ if (_irap != 0 && _irap != 1) {
	+ /// @todo Change to exception or assert
	+ // cout << "ERROR!!!, The choice to use the rapidity y or the pseudorapidity eta is not set correctly! Change that please!" << endl;
	+ return 0;
	+ }
	+ _object_phi[k] = atan2(_object_py[k], _object_px[k]);
	+ }
	+
	+ vector<double> object_px_in, object_py_in, object_pz_in, object_pt_in, object_e_in, object_et_in, object_eta_in;
	+ vector<double> object_px_out, object_py_out, object_pz_out, object_e_out, object_pt_out, object_eta_out;
	+ if (!object_px_in.empty()) { //< FFS, this is impossible: it's only just been created!
	+ object_px_in.clear();
	+ object_py_in.clear();
	+ object_pz_in.clear();
	+ object_pt_in.clear();
	+ object_e_in.clear();
	+ object_et_in.clear();
	+ object_eta_in.clear();
	+ object_px_out.clear();
	+ object_py_out.clear();
	+ object_pz_out.clear();
	+ object_pt_out.clear();
	+ object_e_out.clear();
	+ object_eta_out.clear();
	+ }
	+
	+ size_t nin = 0;
	+
	+ for (size_t j = 0; j < length; j++) {
	+ if (fabs(_object_eta[j]) < _eta_c) {
	+ object_px_in.push_back(_object_px[j]);
	+ object_py_in.push_back(_object_py[j]);
	+ object_pz_in.push_back(_object_pz[j]);
	+ object_e_in.push_back(_object_e[j]);
	+ object_pt_in.push_back(sqrt(pow(_object_px[j],2)+pow(_object_py[j],2)));
	+ object_et_in.push_back(sqrt((pow(_object_e[j],2)*pow(_object_pt[j],2))/(pow(_object_pt[j],2)+pow(_object_pz[j],2))));
	+ object_eta_in.push_back(_object_eta[j]);
	+ nin += 1;
	+ } else {
	+ object_px_out.push_back(_object_px[j]);
	+ object_py_out.push_back(_object_py[j]);
	+ object_pz_out.push_back(_object_pz[j]);
	+ object_e_out.push_back(_object_e[j]);
	+ object_pt_out.push_back(sqrt(pow(_object_px[j],2)+pow(_object_py[j],2)));
	+ object_eta_out.push_back(_object_eta[j]);
	+ }
	+ }
	+
	+ if (object_px_in.size() != nin) {
	+ /// @todo Change to exception or assert
	+ cout<<"ERROR!!! wrong dimension of 'in' momenta"<<endl;
	+ //return 0; ///< @todo Why not do this?
	+ }
	+ const size_t nout = length - nin;
	+
	+ if (nin < _nmnjet) {
	+ for (int i = 0; i < NEVTVAR; i++) {
	+ _event_shapes[i] = -50.0;
	+ }
	+ }
	+
	+ _event_shapes[NEVTVAR] = nin;
	+
	+ if (nin >= _nmnjet) {
	+ double p_sum_c = 0; //GMA
	+ double pt_sum_c = 0;
	+ double eta_cw=0;
	+ double px_sum_in = 0;
	+ double py_sum_in = 0;
	+ for (size_t j = 0; j < nin; j++) {
	+ pt_sum_c += object_pt_in[j];
	+ p_sum_c += sqrt(pow(object_pt_in[j],2.) + pow(object_pz_in[j], 2.0)); //GMA
	+ eta_cw += object_pt_in[j]*object_eta_in[j];
	+ px_sum_in += object_px_in[j];
	+ py_sum_in += object_py_in[j];
	+ }
	+ eta_cw /= pt_sum_c;
	+
	+ double expTerm = 0;
	+ for (size_t j = 0; j < nout; j++) {
	+ expTerm += object_pt_out[j] * exp(-fabs(object_eta_out[j]-eta_cw));
	+ }
	+ expTerm /= pt_sum_c;
	+
	+ //the central global transverse thrust centrthr is calculated
	+ double centrthr = 0;
	+ vector<double> thrust_central = _thrust(object_px_in, object_py_in);
	+
	+ for (size_t l=0; l<3; l++) _thrust_axis_c[l] = thrust_central[l];
	+ //the variable which gets resummed is not thrust
	+ //but tau = 1 - thrust - see calculation
	+ centrthr = thrust_central[3];
	+ _event_shapes[0] = centrthr;
	+
	+ double alpha_c = atan2(_thrust_axis_c[1], _thrust_axis_c[0]);
	+ //central jet masses
	+ //define two jet masses in region U and D
	+ double cenjm_up = 0;
	+ double cenjm_down= 0;
	+ double dot_product = 0;
	+
	+ vector<double> up_sum;
	+ vector<double> down_sum;
	+ for (size_t j=0; j<4;j++) {
	+ up_sum.push_back(0.);
	+ down_sum.push_back(0.);
	+ }
	+ for (size_t i=0;i<nin;i++) {
	+ dot_product = object_px_in[i] * _thrust_axis_c[0] + object_py_in[i] * _thrust_axis_c[1];
	+ if (dot_product >= 0) {
	+ up_sum[0]+=object_px_in[i];
	+ up_sum[1]+=object_py_in[i];
	+ up_sum[2]+=object_pz_in[i];
	+ up_sum[3]+=object_e_in[i];
	+ } else {
	+ down_sum[0]+=object_px_in[i];
	+ down_sum[1]+=object_py_in[i];
	+ down_sum[2]+=object_pz_in[i];
	+ down_sum[3]+=object_e_in[i];
	+ }
	+ }
	+ cenjm_up = _lorentz_sp(up_sum, up_sum) / pow(p_sum_c, 2.); //GMA pow(pt_sum_c,2);
	+ cenjm_down = _lorentz_sp(down_sum, down_sum) / pow(p_sum_c, 2.); //GMA pow(pt_sum_c,2);
	+
	+ //central total jet mass centotjm
	+ double centotjm=0;
	+ centotjm = cenjm_up + cenjm_down;
	+
	+ _event_shapes[2]=centotjm;
	+
	+ double centrjm_up=0, centrjm_down=0;
	+ vector<double> upsum;
	+ vector<double> downsum;
	+ for (size_t j = 0; j < 3; j++) {
	+ upsum.push_back(0.);
	+ downsum.push_back(0.);
	+ }
	+ for (size_t i = 0; i < nin; i++) {
	+ dot_product = object_px_in[i]_thrust_axis_c[0]+object_py_in[i]_thrust_axis_c[1];
	+ if (dot_product >= 0) {
	+ upsum[0] += object_px_in[i];
	+ upsum[1] += object_py_in[i];
	+ upsum[2] += object_et_in[i];
	+ } else {
	+ downsum[0] += object_px_in[i];
	+ downsum[1] += object_py_in[i];
	+ downsum[2] += object_et_in[i];
	+ }
	+ }
	+ centrjm_up = _lorentz_sp(upsum, upsum) / pow(pt_sum_c, 2);
	+ centrjm_down = _lorentz_sp(downsum, downsum) / pow(pt_sum_c, 2);
	+ double centottrjm = centrjm_up + centrjm_down;
	+
	+ _event_shapes[3] = centottrjm;
	+
	+ //central three-jet resolution threshold
	+ double ceny3=0;
	+ if (nin < 3) {
	+ ceny3 = -1.0;
	+ } else {
	+ ceny3 = _three_jet_res(object_px_in, object_py_in, object_pz_in, object_e_in, _irap);
	+ }
	+
	+ _event_shapes[4] = ceny3;
	+
	+ //the central jet broadenings in the up and down region
	+ double cenbroad_up=0;
	+ double cenbroad_down=0;
	+
	+ double eta_up=0;
	+ size_t num_up=0;
	+ double eta_down =0;
	+ size_t num_down =0;
	+ double phi_temp =0;
	+ double phi_up_aver =0;
	+ double phi_down_aver =0;
	+ double pt_sum_up =0;
	+ double pt_sum_down =0;
	+ double dot_product_b =0;
	+ vector<double> phi_up;
	+ vector<double> phi_down;
	+ double py_rot =0;
	+ double px_rot =0;
	+
	+ for (size_t j = 0; j < 4; j++) {
	+ up_sum.push_back(0.);
	+ down_sum.push_back(0.);
	+ }
	+
	+ for (size_t i=0;i<nin;i++) {
	+ dot_product_b =sqrt(object_px_in[i]_thrust_axis_c[0] + object_py_in[i]_thrust_axis_c[1]);
	+ if (dot_product_b>=0){
	+ pt_sum_up += object_pt_in[i];
	+ //rotate the coordinate system so that
	+ //the central thrust axis is e_x
	+ px_rot = cos(alpha_c)object_px_in[i]+sin(alpha_c)object_py_in[i];
	+ py_rot = - sin(alpha_c)object_px_in[i]+cos(alpha_c)object_py_in[i];
	+ //calculate the eta and phi in the rotated system
	+ eta_up += object_pt_in[i]*object_eta_in[i];
	+ phi_temp = atan2(py_rot,px_rot);
	+
	+ if(phi_temp > M_PI/2){
	+ phi_temp = phi_temp - M_PI/2;
	+ }
	+ if (phi_temp < -M_PI/2){
	+ phi_temp = phi_temp + M_PI/2;
	+ }
	+ phi_up.push_back(phi_temp);
	+ phi_up_aver += object_pt_in[i]*phi_temp;
	+ num_up += 1;
	+ } else {
	+ eta_down += object_pt_in[i]*object_eta_in[i];
	+ pt_sum_down += object_pt_in[i];
	+ px_rot = cos(alpha_c)object_px_in[i]+sin(alpha_c)object_py_in[i];
	+ py_rot = - sin(alpha_c)object_px_in[i]+cos(alpha_c)object_py_in[i];
	+ phi_temp = atan2(py_rot,px_rot);
	+ if (phi_temp > M_PI/2) {
	+ //if phi is bigger than pi/2 in the new system calculate
	+ //the difference to the thrust axis
	+ phi_temp = M_PI -phi_temp;
	+ }
	+ if (phi_temp<-M_PI/2) {
	+ //if phi is smaller than
	+ phi_temp = -M_PI-phi_temp;
	+ }
	+ phi_down.push_back(phi_temp);
	+ //calculate the pt-weighted phi
	+ phi_down_aver += object_pt_in[i]*phi_temp;
	+ num_down += 1;
	+ }
	+ }
	+ if (num_up!=0){
	+ eta_up = eta_up/pt_sum_up;
	+ phi_up_aver = phi_up_aver/pt_sum_up;
	+ }
	+ if (num_down!=0) {
	+ eta_down = eta_down/pt_sum_down;
	+ phi_down_aver = phi_down_aver/pt_sum_down;
	+ }
	+
	+ size_t index_up=0, index_down=0;
	+ for (size_t i = 0; i < nin; i++) {
	+ dot_product_b = object_px_in[i]_thrust_axis_c[0] + object_py_in[i]_thrust_axis_c[1];
	+ if (dot_product_b >= 0) {
	+ //calculate the broadenings of the regions with the rotated system
	+ //and the pt-weighted average of phi in the rotated system
	+ cenbroad_up += object_pt_in[i]*sqrt(pow(object_eta_in[i]-eta_up, 2) +
	+ pow(_delta_phi(phi_up[index_up], phi_up_aver), 2));
	+ index_up += 1;
	+ } else {
	+ cenbroad_down += object_pt_in[i]*sqrt(pow(object_eta_in[i]-eta_down, 2)+
	+ pow(_delta_phi(phi_down[index_down], phi_down_aver), 2));
	+ index_down += 1;
	+ }
	+ }
	+
	+ if (index_up == 0 \|\| index_down ==0) _event_shapes[NEVTVAR] *= -1;
	+
	+ cenbroad_up=cenbroad_up/(2*pt_sum_c);
	+ cenbroad_down=cenbroad_down/(2*pt_sum_c);
	+
	+ //central total jet broadening
	+ double centotbroad = 0;
	+ centotbroad = cenbroad_up + cenbroad_down;
	+
	+ _event_shapes[1] = centotbroad;
	+
	+ for (int ij = 0; ij < 5; ij++) {
	+ if (_event_shapes[ij] < 1.e-20) _event_shapes[ij] = 1.e-20;
	+ _event_shapes[ij] = log(_event_shapes[ij]);
	+ }
	+ }
	+
	+ return 1;
	+ }
	+
	+
	+ double EventShape::_three_jet_res(const vector<double>& in_object_px, const vector<double>& in_object_py, const vector<double>& in_object_pz, const vector<double>& in_object_e, int irap) {
	+
	+ size_t y3_length = (size_t)in_object_px.size();
	+ if (((size_t) in_object_py.size()!=y3_length) \|\|
	+ ((size_t) in_object_pz.size()!=y3_length) \|\|
	+ (in_object_e.size()!=y3_length)) {
	+ // cout << "ERROR!!!! Input vectors differ in size! Change that please!" << endl;
	+ // cout<<"py_size: "<<in_object_py.size()<<" ,pz_size: "<<in_object_pz.size()
	+ // <<" ,px_size: "<<in_object_px.size()<<" , E_size: "<<in_object_e.size() <<endl;
	+ return 0.0;
	+ }
	+
	+ vector<double> in_object_p, in_object_pt, in_object_eta, in_object_phi;
	+ if (!in_object_p.empty()) {
	+ in_object_p.clear();
	+ in_object_pt.clear();
	+ in_object_eta.clear();
	+ in_object_phi.clear();
	+ }
	+ for (size_t j = 0; j < y3_length; j++) {
	+ in_object_p.push_back(0.);
	+ in_object_pt.push_back(0.);
	+ in_object_eta.push_back(0.);
	+ in_object_phi.push_back(0.);
	+ }
	+ double theta_y3_1st = 0;
	+ for (size_t k =0; k<y3_length; k++) {
	+ in_object_p[k] = sqrt(pow(in_object_px[k],2) + pow(in_object_py[k],2) + pow(in_object_pz[k],2));
	+ in_object_pt[k] = sqrt(pow(in_object_px[k],2) + pow(in_object_py[k],2));
	+
	+ //calculates the pseudorapidity to prevent a division by zero
	+ if (irap == 0) {
	+ if (fabs(in_object_pz[k]) > 1E-5) {
	+ theta_y3_1st = atan(in_object_pt[k]/(in_object_pz[k]));
	+ } else {
	+ theta_y3_1st = M_PI/2;
	+ }
	+ if (theta_y3_1st<0.) theta_y3_1st = theta_y3_1st + M_PI;
	+ in_object_eta[k] = - log(tan(0.5*theta_y3_1st));
	+ }
	+ //calculates the real rapidity
	+ if (irap == 1) {
	+ in_object_eta[k]=0.5*log((in_object_e[k]+in_object_pz[k])/(in_object_e[k]-in_object_pz[k]));
	+ }
	+ in_object_phi[k] = atan2(in_object_py[k], in_object_px[k]);
	+ }
	+
	+ //the three-jet resolution
	+ //threshold y3
	+ double y3 = 0;
	+
	+ //vector which will be filled with the
	+ //minimum of the distances
	+ double max_dmin_temp=0;
	+
	+ double max_dmin = 0;
	+
	+ //distance input object k, beam
	+ double distance_jB = 0;
	+ double distance_jB_min = 0;
	+ //distance of input object k to l
	+ double distance_jk = 0;
	+ double distance_jk_min = 0;
	+ //as we search the minimum of the distances
	+ //give them values which are for sure higher
	+ //than those we evaluate first in the for-loups
	+
	+ size_t index_jB = 0;
	+ size_t index_j_jk = 0;
	+ size_t index_k_jk = 0;
	+
	+ //to decide later if the minmum is a jB or jk
	+ int decide_jB = -1;
	+
	+ vector<double> input_pt, input_px, input_py, input_pz;
	+ vector<double> input_p, input_e, input_phi, input_eta;
	+
	+ if (!input_pt.empty()) {
	+ input_pt.clear();
	+ input_px.clear();
	+ input_px.clear();
	+ input_pz.clear();
	+ input_p.clear();
	+ input_e.clear();
	+ input_phi.clear();
	+ input_eta.clear();
	+ }
	+
	+ for (size_t j = 0; j < y3_length; j++){
	+ input_pt.push_back(in_object_pt[j]);
	+ input_px.push_back(in_object_px[j]);
	+ input_py.push_back(in_object_py[j]);
	+ input_pz.push_back(in_object_pz[j]);
	+ input_p.push_back(in_object_p[j]);
	+ input_e.push_back(in_object_e[j]);
	+ input_phi.push_back(in_object_phi[j]);
	+ input_eta.push_back(in_object_eta[j]);
	+ }
	+ if (y3_length<3) {
	+ return -1;
	+ } else {
	+ size_t rest = y3_length;
	+ for (size_t i = 0; i<y3_length; i++) {
	+ //make the minima at the initialization step
	+ //of each looping bigger than the first values
	+ distance_jB_min = 0.36*pow(input_pt[0],2) + 10;
	+ //DELTA PHIs wanted not the pure difference
	+ distance_jk_min = min(pow(input_pt[1], 2), pow(input_pt[0], 2)) *
	+ (pow(input_eta[1]-input_eta[0], 2) +
	+ pow(_delta_phi(input_phi[1], input_phi[0]), 2)) + 10;
	+ //do the procedure only until we have only 2 objects left anymore
	+ if (rest > 2) {
	+ for (size_t j=0; j<rest;j++) {
	+ //calculate the distance between object j and the beam
	+ distance_jB = 0.36*pow(input_pt[j], 2);
	+ if(distance_jB < distance_jB_min){
	+ distance_jB_min = distance_jB;
	+ index_jB = j;
	+ }
	+ if (j > 0) {
	+ for(size_t k=0; k<j;k++){
	+ //calculate the distance in delta eta and delta phi between object i and object j
	+ distance_jk = min(pow(input_pt[j], 2),pow(input_pt[k], 2))*
	+ (pow(input_eta[j]-input_eta[k], 2)+
	+ pow(_delta_phi(input_phi[j],input_phi[k]), 2));
	+ if (distance_jk<distance_jk_min) {
	+ distance_jk_min = distance_jk;
	+ index_j_jk = j;
	+ index_k_jk =k;
	+ }
	+ }
	+ }
	+ }
	+ //decide if the minimum is from a jB or jk combination
	+ if (distance_jk_min<distance_jB_min) {
	+ max_dmin_temp = max(distance_jk_min,max_dmin_temp);
	+ decide_jB = 0;
	+ } else {
	+ max_dmin_temp = max(distance_jB_min,max_dmin_temp);
	+ decide_jB=1;
	+ }
	+ //if we have only three jets left calculate
	+ //the maxima of the dmin's
	+ //if the minimum is a jB eliminate the input object
	+ if (decide_jB == 1) {
	+ //if index_jB is the last one nothing is to do
	+ if (index_jB != rest-1) {
	+ for (size_t i=index_jB; i<rest-1;i++) {
	+ input_pt[i]=input_pt[i+1];
	+ input_phi[i]=input_phi[i+1];
	+ input_eta[i]=input_eta[i+1];
	+ input_px[i]=input_px[i+1];
	+ input_py[i]=input_py[i+1];
	+ input_pz[i]=input_pz[i+1];
	+ input_e[i]=input_e[i+1];
	+ }
	+ }
	+ }
	+ //if the minimum is a jk combine both input objects
	+ if(decide_jB==0) {
	+ input_px[index_k_jk] = input_px[index_k_jk]+input_px[index_j_jk];
	+ input_py[index_k_jk] = input_py[index_k_jk]+input_py[index_j_jk];
	+ input_pz[index_k_jk] = input_pz[index_k_jk]+input_pz[index_j_jk];
	+ input_e[index_k_jk] = input_e[index_k_jk]+input_e[index_j_jk];
	+ input_p[index_k_jk] = sqrt(pow(input_px[index_k_jk], 2)+
	+ pow(input_py[index_k_jk], 2)+
	+ pow(input_pz[index_k_jk], 2));
	+ //calculate the pt, eta and phi of the new combined momenta k_jk
	+ input_pt[index_k_jk] = sqrt(pow(input_px[index_k_jk], 2)+
	+ pow(input_py[index_k_jk], 2));
	+ //in the case of pseudorapidity
	+ if (irap == 0) {
	+ double theta_new =0;
	+ if (fabs(input_pz[index_k_jk]) > 1E-5){
	+ theta_new = atan(input_pt[index_k_jk]/(input_pz[index_k_jk]));
	+ } else {
	+ theta_new = M_PI/2;
	+ }
	+ if (theta_new < 0) {
	+ theta_new = theta_new + M_PI;
	+ }
	+ input_eta[index_k_jk] = - log(tan(0.5*theta_new));
	+ }
	+ //in the real rapidity y is wanted
	+ if (irap == 1) {
	+ input_eta[index_k_jk] = 0.5 * log((input_e[index_k_jk]+
	+ input_pz[index_k_jk]) /
	+ (input_e[index_k_jk] -
	+ input_pz[index_k_jk]));
	+ }
	+ input_phi[index_k_jk] = atan2(input_py[index_k_jk], input_px[index_k_jk]);
	+ if (index_j_jk != rest-1) {
	+ for (size_t i = index_j_jk; i<rest-1;i++) {
	+ input_pt[i] = input_pt[i+1];
	+ input_phi[i] = input_phi[i+1];
	+ input_eta[i] = input_eta[i+1];
	+ input_px[i] = input_px[i+1];
	+ input_py[i] = input_py[i+1];
	+ input_pz[i] = input_pz[i+1];
	+ input_e[i] = input_e[i+1];
	+ }
	+ }
	+ }
	+ }
	+ if (rest == 3) max_dmin = max_dmin_temp;
	+ rest = rest-1;
	+ }
	+ }
	+
	+ double et2 = 0;
	+ et2 = input_pt[0] + input_pt[1];
	+ y3 = max_dmin/pow(et2,2);
	+
	+ return y3;
	+ }
	+
	+
	+ vector<double> EventShape::_thrust(const vector<double>& input_px, const vector<double>& input_py) {
	+
	+ double thrustmax_calc = 0;
	+ double temp_calc = 0;
	+ size_t length_thrust_calc = 0;
	+ vector<double> thrust_values, thrust_axis_calc;
	+ vector<double> p_thrust_max_calc, p_dec_1_calc, p_dec_2_calc, p_pt_beam_calc;
	+
	+ if (!thrust_values.empty()){
	+ thrust_values.clear();
	+ thrust_axis_calc.clear();
	+ p_thrust_max_calc.clear();
	+ p_dec_1_calc.clear();
	+ p_dec_2_calc.clear();
	+ p_pt_beam_calc.clear();
	+ }
	+
	+ for (size_t j = 0; j < 3; j++){
	+ p_pt_beam_calc.push_back(0.);
	+ p_dec_1_calc.push_back(0.);
	+ p_dec_2_calc.push_back(0.);
	+ p_thrust_max_calc.push_back(0.);
	+ thrust_axis_calc.push_back(0.);
	+ }
	+
	+ for (size_t j = 0; j < 4; j++) {
	+ thrust_values.push_back(0.);
	+ }
	+
	+ length_thrust_calc = input_px.size();
	+ if (input_py.size() != length_thrust_calc) {
	+ /// @todo Change to exception or assert
	+ cout<<"ERROR in thrust calculation!!! Size of input vectors differs. Change that please!"<<endl;
	+ return thrust_values;
	+ }
	+
	+ double pt_sum_calc =0;
	+ for(size_t k=0;k<length_thrust_calc;k++){
	+ pt_sum_calc+=sqrt(pow(input_px[k],2)+pow(input_py[k],2));
	+ for(size_t j = 0; j < 3; j++){
	+ p_thrust_max_calc[j]=0;
	+ }
	+ //get a vector perpendicular to the beam axis and
	+ //perpendicular to the momentum of particle k
	+ //per default beam axis b = (0,0,1)
	+ p_pt_beam_calc[0] = input_py[k]*1;
	+ p_pt_beam_calc[1] = - input_px[k]*1;
	+ p_pt_beam_calc[2] = 0.; // GMA p_pt_beam_calc[3] = 0.;
	+ for(size_t i=0;i<length_thrust_calc;i++){
	+ if(i!=k){
	+ if((input_px[i]p_pt_beam_calc[0]+input_py[i]p_pt_beam_calc[1])>=0){
	+ p_thrust_max_calc[0]= p_thrust_max_calc[0] + input_px[i];
	+ p_thrust_max_calc[1]= p_thrust_max_calc[1] + input_py[i];
	+ }else{
	+ p_thrust_max_calc[0]= p_thrust_max_calc[0] - input_px[i];
	+ p_thrust_max_calc[1]= p_thrust_max_calc[1] - input_py[i];
	+ }
	+ }
	+ }
	+ p_dec_1_calc[0] = p_thrust_max_calc[0] + input_px[k];
	+ p_dec_1_calc[1] = p_thrust_max_calc[1] + input_py[k];
	+ p_dec_1_calc[2] = 0;
	+ p_dec_2_calc[0] = p_thrust_max_calc[0] - input_px[k];
	+ p_dec_2_calc[1] = p_thrust_max_calc[1] - input_py[k];
	+ p_dec_2_calc[2] = 0;
	+ temp_calc = pow(p_dec_1_calc[0], 2) + pow(p_dec_1_calc[1], 2);
	+
	+ if (temp_calc>thrustmax_calc) {
	+ thrustmax_calc =temp_calc;
	+ for (size_t i=0; i<3; i++) {
	+ thrust_axis_calc[i] = p_dec_1_calc[i]/sqrt(thrustmax_calc);
	+ }
	+ }
	+ temp_calc = pow(p_dec_2_calc[0], 2)+pow(p_dec_2_calc[1], 2);
	+ if (temp_calc > thrustmax_calc) {
	+ thrustmax_calc =temp_calc;
	+ for (size_t i=0; i<3; i++) {
	+ thrust_axis_calc[i] = p_dec_2_calc[i]/sqrt(thrustmax_calc);
	+ }
	+ }
	+ }
	+ for (size_t j = 0; j < 3; j++) thrust_values[j] = thrust_axis_calc[j];
	+ const double thrust_calc = sqrt(thrustmax_calc)/pt_sum_calc;
	+
	+ // the variable which gets returned is not the thrust but tau=1-thrust
	+ thrust_values[3] = 1 - thrust_calc;
	+ if (thrust_values[3] < 1e-20) thrust_values[3] = 1e-20;
	+
	+ return thrust_values;
	+ }
	+
	+
	+ double EventShape::_delta_phi(double phi1, double phi2) {
	+ double dphi = fabs(phi2 - phi1);
	+ if (dphi > M_PI) dphi = 2*M_PI - dphi;
	+ return dphi;
	+ }
	+
	+
	+ // Returns the scalar product between two 4 momenta
	+ double EventShape::_lorentz_sp(const vector<double>& a, const vector<double>& b) {
	+ size_t dim = (size_t) a.size();
	+ if (a.size()!=b.size()) {
	+ cout<<"ERROR!!! Dimension of input vectors are different! Change that please!"<<endl;
	+ return 0;
	+ } else {
	+ double l_dot_product=a[dim-1]*b[dim-1];
	+ for(size_t i=0; i<dim-1;i++){
	+ l_dot_product-=a[i]*b[i];
	+ }
	+ return l_dot_product;
	+ }
	+ }
	+
	+
	+ }
	+
	+
	+}
	diff --git a/src/Analyses/CMS_2015_I1310737.cc b/src/Analyses/CMS_2015_I1310737.cc
	--- a/src/Analyses/CMS_2015_I1310737.cc
	+++ b/src/Analyses/CMS_2015_I1310737.cc
	@@ -1,191 +1,190 @@
	+// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/InvMassFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	class CMS_2015_I1310737 : public Analysis {
	public:

	/// Constructor
	- CMS_2015_I1310737()
	- : Analysis("CMS_2015_I1310737")
	- { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2015_I1310737);


	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs; ///< @todo No cuts?
	VisibleFinalState visfs(fs);

	ZFinder zeeFinder(fs, Cuts::abseta < 2.4 && Cuts::pT > 20GeV, PID::ELECTRON, 71.0GeV, 111.0*GeV);
	- addProjection(zeeFinder, "ZeeFinder");
	+ declare(zeeFinder, "ZeeFinder");

	ZFinder zmumuFinder(fs, Cuts::abseta < 2.4 && Cuts::pT > 20GeV, PID::MUON, 71.0GeV, 111.0*GeV);
	- addProjection(zmumuFinder, "ZmumuFinder");
	+ declare(zmumuFinder, "ZmumuFinder");

	VetoedFinalState jetConstits(visfs);
	jetConstits.addVetoOnThisFinalState(zeeFinder);
	jetConstits.addVetoOnThisFinalState(zmumuFinder);

	FastJets akt05Jets(jetConstits, FastJets::ANTIKT, 0.5);
	- addProjection(akt05Jets, "AntiKt05Jets");
	+ declare(akt05Jets, "AntiKt05Jets");


	_h_excmult_jets_tot = bookHisto1D(1, 1, 1);
	_h_incmult_jets_tot = bookHisto1D(2, 1, 1);
	_h_leading_jet_pt_tot = bookHisto1D(3, 1, 1);
	_h_second_jet_pt_tot = bookHisto1D(4, 1, 1);
	_h_third_jet_pt_tot = bookHisto1D(5, 1, 1);
	_h_fourth_jet_pt_tot = bookHisto1D(6, 1, 1);
	_h_leading_jet_eta_tot = bookHisto1D(7, 1, 1);
	_h_second_jet_eta_tot = bookHisto1D(8, 1, 1);
	_h_third_jet_eta_tot = bookHisto1D(9, 1, 1);
	_h_fourth_jet_eta_tot = bookHisto1D(10, 1, 1);
	_h_ht1_tot = bookHisto1D(11, 1, 1);
	_h_ht2_tot = bookHisto1D(12, 1, 1);
	_h_ht3_tot = bookHisto1D(13, 1, 1);
	_h_ht4_tot = bookHisto1D(14, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {;

	- const ZFinder& zeeFS = applyProjection<ZFinder>(event, "ZeeFinder");
	- const ZFinder& zmumuFS = applyProjection<ZFinder>(event, "ZmumuFinder");
	+ const ZFinder& zeeFS = apply<ZFinder>(event, "ZeeFinder");
	+ const ZFinder& zmumuFS = apply<ZFinder>(event, "ZmumuFinder");

	const Particles& zees = zeeFS.bosons();
	const Particles& zmumus = zmumuFS.bosons();

	// We did not find exactly one Z. No good.
	if (zees.size() + zmumus.size() != 1) {
	MSG_DEBUG("Did not find exactly one good Z candidate");
	vetoEvent;
	}

	// Find the (dressed!) leptons
	const Particles& dressedLeptons = zees.size() ? zeeFS.constituents() : zmumuFS.constituents();

	// Cluster jets
	// NB. Veto has already been applied on leptons and photons used for dressing
	- const FastJets& fj = applyProjection<FastJets>(event, "AntiKt05Jets");
	+ const FastJets& fj = apply<FastJets>(event, "AntiKt05Jets");
	const Jets& jets = fj.jetsByPt(Cuts::abseta < 2.4 && Cuts::pT > 30*GeV);

	// Perform lepton-jet overlap and HT calculation
	double ht = 0;
	Jets goodjets;
	foreach (const Jet& j, jets) {
	// Decide if this jet is "good", i.e. isolated from the leptons
	/// @todo Nice use-case for any() and a C++11 lambda
	bool overlap = false;
	foreach (const Particle& l, dressedLeptons) {
	if (Rivet::deltaR(j, l) < 0.5) {
	overlap = true;
	break;
	}
	}

	// Fill HT and good-jets collection
	if (overlap) continue;
	goodjets.push_back(j);
	ht += j.pT();
	}

	// We don't care about events with no isolated jets
	if (goodjets.empty()) {
	MSG_DEBUG("No jets in event");
	vetoEvent;
	}


	/////////////////


	// Weight to be used for histo filling
	const double w = 0.5 * event.weight();

	// Fill jet number integral histograms
	_h_excmult_jets_tot->fill(goodjets.size(), w);
	/// @todo Could be better computed by toIntegral transform on exclusive histo
	for (size_t iJet = 1; iJet <= goodjets.size(); iJet++ )
	_h_incmult_jets_tot->fill(iJet, w);

	// Fill leading jet histograms
	const Jet& j1 = goodjets[0];
	_h_leading_jet_pt_tot->fill(j1.pT()/GeV, w);
	_h_leading_jet_eta_tot->fill(j1.abseta(), w);
	_h_ht1_tot->fill(ht/GeV, w);

	// Fill 2nd jet histograms
	if (goodjets.size() < 2) return;
	const Jet& j2 = goodjets[1];
	_h_second_jet_pt_tot->fill(j2.pT()/GeV, w);
	_h_second_jet_eta_tot->fill(j2.abseta(), w);
	_h_ht2_tot->fill(ht/GeV, w);

	// Fill 3rd jet histograms
	if (goodjets.size() < 3) return;
	const Jet& j3 = goodjets[2];
	_h_third_jet_pt_tot->fill(j3.pT()/GeV, w);
	_h_third_jet_eta_tot->fill(j3.abseta(), w);
	_h_ht3_tot->fill(ht/GeV, w);

	// Fill 4th jet histograms
	if (goodjets.size() < 4) return;
	const Jet& j4 = goodjets[3];
	_h_fourth_jet_pt_tot->fill(j4.pT()/GeV, w);
	_h_fourth_jet_eta_tot->fill(j4.abseta(), w);
	_h_ht4_tot->fill(ht/GeV, w);
	}


	/// Normalise histograms etc., after the run
	void finalize() {

	const double norm = (sumOfWeights() != 0) ? crossSection()/sumOfWeights() : 1.0;

	MSG_INFO("Cross section = " << std::setfill(' ') << std::setw(14) << std::fixed << std::setprecision(3) << crossSection() << " pb");
	MSG_INFO("# Events = " << std::setfill(' ') << std::setw(14) << std::fixed << std::setprecision(3) << numEvents() );
	MSG_INFO("SumW = " << std::setfill(' ') << std::setw(14) << std::fixed << std::setprecision(3) << sumOfWeights());
	MSG_INFO("Norm factor = " << std::setfill(' ') << std::setw(14) << std::fixed << std::setprecision(6) << norm);

	scale(_h_excmult_jets_tot, norm );
	scale(_h_incmult_jets_tot, norm );
	scale(_h_leading_jet_pt_tot, norm );
	scale(_h_second_jet_pt_tot, norm );
	scale(_h_third_jet_pt_tot, norm );
	scale(_h_fourth_jet_pt_tot, norm );
	scale(_h_leading_jet_eta_tot, norm );
	scale(_h_second_jet_eta_tot, norm );
	scale(_h_third_jet_eta_tot, norm );
	scale(_h_fourth_jet_eta_tot, norm );
	scale(_h_ht1_tot, norm );
	scale(_h_ht2_tot, norm );
	scale(_h_ht3_tot, norm );
	scale(_h_ht4_tot, norm );
	}


	private:

	/// @name Histograms

	Histo1DPtr _h_excmult_jets_tot, _h_incmult_jets_tot;
	Histo1DPtr _h_leading_jet_pt_tot, _h_second_jet_pt_tot, _h_third_jet_pt_tot, _h_fourth_jet_pt_tot;
	Histo1DPtr _h_leading_jet_eta_tot, _h_second_jet_eta_tot, _h_third_jet_eta_tot, _h_fourth_jet_eta_tot;
	Histo1DPtr _h_ht1_tot, _h_ht2_tot, _h_ht3_tot, _h_ht4_tot;

	};


	DECLARE_RIVET_PLUGIN(CMS_2015_I1310737);


	}
	diff --git a/src/Analyses/CMS_2015_I1327224.cc b/src/Analyses/CMS_2015_I1327224.cc
	--- a/src/Analyses/CMS_2015_I1327224.cc
	+++ b/src/Analyses/CMS_2015_I1327224.cc
	@@ -1,58 +1,60 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {
	+
	+
	class CMS_2015_I1327224 : public Analysis {
	public:

	- CMS_2015_I1327224()
	- : Analysis("CMS_2015_I1327224")
	- { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2015_I1327224);
	+

	void init() {
	FinalState fs;
	FastJets antikt(fs, FastJets::ANTIKT, 0.5);
	- addProjection(antikt, "ANTIKT");
	+ declare(antikt, "ANTIKT");
	_h_chi_dijet.addHistogram(4200., 8000., bookHisto1D(1, 1, 1));
	_h_chi_dijet.addHistogram(3600., 4200., bookHisto1D(2, 1, 1));
	_h_chi_dijet.addHistogram(3000., 3600., bookHisto1D(3, 1, 1));
	_h_chi_dijet.addHistogram(2400., 3000., bookHisto1D(4, 1, 1));
	_h_chi_dijet.addHistogram(1900., 2400., bookHisto1D(5, 1, 1));
	}

	+
	void analyze(const Event& event) {
	const double weight = event.weight();
	- const Jets& jets = applyProjection<JetAlg>(event, "ANTIKT").jetsByPt();
	+ const Jets& jets = apply<JetAlg>(event, "ANTIKT").jetsByPt();
	if (jets.size() < 2) vetoEvent;

	FourMomentum j0(jets[0].momentum());
	FourMomentum j1(jets[1].momentum());
	double y0 = j0.rapidity();
	double y1 = j1.rapidity();
	if (fabs(y0 + y1) / 2. > 1.11) vetoEvent;

	double mjj = FourMomentum(j0 + j1).mass();
	if (mjj/GeV <1900) vetoEvent;

	double chi = exp(fabs(y0 - y1));
	if (chi >= 16.) vetoEvent;
	-
	- // Fill the histogram
	+
	+ // Fill the histogram
	_h_chi_dijet.fill(mjj/GeV, chi, weight);
	}

	void finalize() {
	foreach (Histo1DPtr hist, _h_chi_dijet.getHistograms()) {
	normalize(hist);
	}
	}

	private:
	BinnedHistogram<double> _h_chi_dijet;
	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2015_I1327224);
	}
	diff --git a/src/Analyses/CMS_2015_I1346843.cc b/src/Analyses/CMS_2015_I1346843.cc
	--- a/src/Analyses/CMS_2015_I1346843.cc
	+++ b/src/Analyses/CMS_2015_I1346843.cc
	@@ -1,118 +1,112 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedLeptons.hh"
	#include "Rivet/Projections/NeutralFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	-
	namespace Rivet {

	+
	+ /// Differential cross-section of FSR photons in Z decays
	class CMS_2015_I1346843 : public Analysis {
	public:
	- // Constructor
	- CMS_2015_I1346843() : Analysis("CMS_2015_I1346843") {
	- }

	- public:
	- // Book histograms and initialise projections before the run
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2015_I1346843);
	+
	+ /// Book histograms and initialise projections before the run
	void init() {
	-
	- Cut c_photons = (Cuts::pT >= 5.0*GeV) & (Cuts::etaIn(-2.5, 1.4) \|\| Cuts::etaIn(1.6, 2.5));
	-
	- Cut c_muons = (Cuts::pT>9*GeV) & (Cuts::abseta<2.4);

	-
	+ Cut c_photons = Cuts::pT >= 5.0*GeV && (Cuts::etaIn(-2.5, 1.4) \|\| Cuts::etaIn(1.6, 2.5));
	IdentifiedFinalState photons(c_photons);
	photons.acceptId(PID::PHOTON);
	- addProjection(photons, "PHOTFS");
	-
	+ declare(photons, "PHOTFS");
	+
	+ Cut c_muons = Cuts::pT > 9*GeV && Cuts::abseta < 2.4;
	IdentifiedFinalState muons(c_muons);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "MUFS");
	+ declare(muons, "MUFS");


	_hist_pho_et = bookHisto1D(1, 1, 1); // photon transverse energy
	_hist_pho_et_wide = bookHisto1D(1, 2, 1); // photon transverse energy (0.5 < dr < 3.0)
	_hist_pho_et_close = bookHisto1D(1, 3, 1); // photon transverse energy (0.05 < dr < 0.5)
	_hist_pho_et_lqt = bookHisto1D(1, 4, 1); // photon transverse energy (q_T < 10)
	_hist_pho_et_hqt = bookHisto1D(1, 5, 1); // photon transverse energy (q_T > 50)
	_hist_pho_dr = bookHisto1D(2, 1, 1); // delta_R
	_hist_pho_dr_lqt = bookHisto1D(2, 2, 1); // delta_R (q_T < 10)
	_hist_pho_dr_hqt = bookHisto1D(2, 3, 1); // delta_R (q_T > 50)
	}


	// Perform the per-event analysis
	void analyze(const Event& event) {

	- Particles muons = applyProjection<IdentifiedFinalState>(event, "MUFS").particlesByPt();
	+ const Particles muons = apply<IdentifiedFinalState>(event, "MUFS").particlesByPt();

	- if (muons.size()<2) vetoEvent;
	+ if (muons.size() < 2) vetoEvent;
	if (muons[0].pT()/GeV < 31) vetoEvent;
	- if (muons[0].charge()*muons[1].charge()>0) vetoEvent;
	- double M = (muons[0].momentum() + muons[1].momentum()).mass()/GeV;
	- if (M<30 \|\| M >87) vetoEvent;
	+ if (muons[0].charge()*muons[1].charge() > 0) vetoEvent;
	+ const double mZ = (muons[0].momentum() + muons[1].momentum()).mass();
	+ if (!inRange(mZ, 30GeV, 87GeV)) vetoEvent;

	- const double weight = event.weight();
	-
	-
	- Particles photons = applyProjection<IdentifiedFinalState>(event, "PHOTFS").particlesByPt();
	+ const Particles photons = apply<IdentifiedFinalState>(event, "PHOTFS").particlesByPt();
	// We want the photon with the highest pT that does not come from a decay
	foreach(const Particle& p, photons) {
	- if (!p.fromDecay() && p.isStable()) {
	- double dR = std::min(deltaR(p, muons[0]) , deltaR(p, muons[1]) );
	- if (dR > 0.05 && dR <= 3.0) {
	- // Calculate the three-body (mu,mu,gamma) transverse momentum
	- double qT = (muons[0].mom() + muons[1].mom() + p.mom()).pT();
	- // Fill the analysis histograms
	- _hist_pho_et->fill(p.pT() / GeV, weight);
	- _hist_pho_dr->fill(dR, weight);
	-
	- if (dR <= 0.5) {
	- _hist_pho_et_close->fill(p.pT() / GeV, weight);
	- }
	- else {
	- _hist_pho_et_wide ->fill(p.pT() / GeV, weight);
	- }
	+ if (p.fromDecay() \|\| !p.isStable()) continue;

	- if (qT / GeV < 10.) {
	- _hist_pho_et_lqt->fill(p.pT() / GeV, weight);
	- _hist_pho_dr_lqt->fill(dR, weight);
	- }
	- if (qT / GeV > 50.) {
	- _hist_pho_et_hqt->fill(p.pT() / GeV, weight);
	- _hist_pho_dr_hqt->fill(dR, weight);
	- }
	- break; // Exit the loop since we found the highest pT lepton already
	- }
	+ const double dR = std::min(deltaR(p, muons[0]), deltaR(p, muons[1]) );
	+ if (!inRange(dR, 0.05, 3.0)) continue;
	+
	+ // Calculate the three-body (mu,mu,gamma) transverse momentum
	+ const double qT = (muons[0].mom() + muons[1].mom() + p.mom()).pT();
	+
	+ // Fill the analysis histograms
	+ _hist_pho_et->fill(p.pT()/GeV, event.weight());
	+ _hist_pho_dr->fill(dR, event.weight());
	+
	+ (dR <= 0.5 ? _hist_pho_et_close : _hist_pho_et_wide)->fill(p.pT()/GeV, event.weight());
	+
	+ if (qT / GeV < 10.) {
	+ _hist_pho_et_lqt->fill(p.pT()/GeV, event.weight());
	+ _hist_pho_dr_lqt->fill(dR, event.weight());
	}
	+
	+ if (qT / GeV > 50.) {
	+ _hist_pho_et_hqt->fill(p.pT()/GeV, event.weight());
	+ _hist_pho_dr_hqt->fill(dR, event.weight());
	+ }
	+
	+ break; // Exit the loop since we found the highest pT lepton already
	}
	- }
	+ }


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_hist_pho_et, crossSection() / sumOfWeights());
	scale(_hist_pho_et_wide, crossSection() / sumOfWeights());
	scale(_hist_pho_et_close, crossSection() / sumOfWeights());
	scale(_hist_pho_et_lqt, crossSection() / sumOfWeights());
	scale(_hist_pho_et_hqt, crossSection() / sumOfWeights());
	scale(_hist_pho_dr, crossSection() / sumOfWeights());
	scale(_hist_pho_dr_lqt, crossSection() / sumOfWeights());
	scale(_hist_pho_dr_hqt, crossSection() / sumOfWeights());
	}

	+
	private:
	- Histo1DPtr _hist_pho_et;
	- Histo1DPtr _hist_pho_et_wide;
	- Histo1DPtr _hist_pho_et_close;
	- Histo1DPtr _hist_pho_et_lqt;
	- Histo1DPtr _hist_pho_et_hqt;
	- Histo1DPtr _hist_pho_dr;
	- Histo1DPtr _hist_pho_dr_lqt;
	- Histo1DPtr _hist_pho_dr_hqt;
	+
	+ Histo1DPtr _hist_pho_et;
	+ Histo1DPtr _hist_pho_et_wide, _hist_pho_et_close;
	+ Histo1DPtr _hist_pho_et_lqt, _hist_pho_et_hqt;
	+ Histo1DPtr _hist_pho_dr;
	+ Histo1DPtr _hist_pho_dr_lqt, _hist_pho_dr_hqt;
	+
	};

	+
	DECLARE_RIVET_PLUGIN(CMS_2015_I1346843);
	+
	}
	diff --git a/src/Analyses/CMS_2015_I1356998.cc b/src/Analyses/CMS_2015_I1356998.cc
	--- a/src/Analyses/CMS_2015_I1356998.cc
	+++ b/src/Analyses/CMS_2015_I1356998.cc
	@@ -1,142 +1,143 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {

	+
	class CMS_2015_I1356998 : public Analysis {
	public:

	CMS_2015_I1356998()
	: Analysis("CMS_2015_I1356998"), edge(4.7)
	{ }

	- public:

	void init() {

	- addProjection(FinalState(),"FS");
	+ declare(FinalState(),"FS");

	_h_noCASTORtag = bookHisto1D(1, 1, 1);
	_h_CASTORtag = bookHisto1D(2, 1, 1);
	_h_centralGap = bookHisto1D(3, 1, 1);
	_h_sigmaVis = bookHisto1D(4, 1, 1);
	_h_maxFwdGap = bookHisto1D(5, 1, 1);
	-
	+
	}

	+
	void analyze(const Event& event) {

	- const double weight = event.weight();
	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	+ const double weight = event.weight();
	+ const FinalState& fs = apply<FinalState>(event, "FS");

	- // A vector containing a lot of eta values
	- vector<double> detparticles;
	- detparticles.push_back(-edge);
	- foreach (const Particle& p, fs.particles(Cuts::pT > 0.2*GeV && Cuts::abseta<edge, cmpMomByEta) ) {
	- detparticles.push_back(p.momentum().eta());
	- }
	- detparticles.push_back(edge);
	+ // A vector containing a lot of eta values
	+ vector<double> detparticles;
	+ detparticles.push_back(-edge);
	+ foreach (const Particle& p, fs.particles(Cuts::pT > 0.2*GeV && Cuts::abseta<edge, cmpMomByEta) ) {
	+ detparticles.push_back(p.momentum().eta());
	+ }
	+ detparticles.push_back(edge);

	- // Find maximum gap size
	- vector <double>::iterator iter;
	- vector<double> detgaps;
	- for (iter = detparticles.begin()+1; iter != detparticles.end(); ++iter) {
	- const double detgap = iter - (iter-1);
	- detgaps.push_back(detgap);
	- }
	- double detgapbwd = detgaps.front();
	- double detgapfwd = detgaps.back();
	- double detfmax = max(detgapbwd, detgapfwd);
	+ // Find maximum gap size
	+ vector <double>::iterator iter;
	+ vector<double> detgaps;
	+ for (iter = detparticles.begin()+1; iter != detparticles.end(); ++iter) {
	+ const double detgap = iter - (iter-1);
	+ detgaps.push_back(detgap);
	+ }
	+ double detgapbwd = detgaps.front();
	+ double detgapfwd = detgaps.back();
	+ double detfmax = max(detgapbwd, detgapfwd);

	- // Fill rapidity gap histo
	- if (detfmax != 2*edge ) {
	- _h_maxFwdGap->fill(detfmax, weight);
	+ // Fill rapidity gap histo
	+ if (detfmax != 2*edge ) {
	+ _h_maxFwdGap->fill(detfmax, weight);
	+ }
	+ // Everything that follows has to do with the cross-section measurements
	+
	+ if (fs.size() < 2) vetoEvent;
	+
	+ // Gap center calculations
	+ const ParticleVector particlesByRapidity = fs.particles(cmpMomByRap); //ByRapidity();
	+
	+ vector<double> gaps;
	+ vector<double> midpoints;
	+ for (size_t ip = 1; ip < particlesByRapidity.size(); ++ip) {
	+ const Particle& p1 = particlesByRapidity[ip-1];
	+ const Particle& p2 = particlesByRapidity[ip];
	+ const double gap = p2.momentum().rapidity() - p1.momentum().rapidity();
	+ const double mid = (p2.momentum().rapidity() + p1.momentum().rapidity()) / 2.;
	+ gaps.push_back(gap);
	+ midpoints.push_back(mid);
	+ }
	+
	+ int imid = std::distance(gaps.begin(), max_element(gaps.begin(), gaps.end()));
	+ double gapcenter = midpoints[imid];
	+
	+ // Calculations for cross-sections
	+ FourMomentum MxFourVector(0.,0.,0.,0.);
	+ FourMomentum MyFourVector(0.,0.,0.,0.);
	+
	+ foreach(const Particle& p, fs.particles(cmpMomByEta)) {
	+ if (p.momentum().rapidity() > gapcenter) {
	+ MxFourVector += p.momentum();
	}
	- // Everything that follows has to do with the cross-section measurements
	+ else {
	+ MyFourVector += p.momentum();
	+ }
	+ }

	- if (fs.size() < 2) vetoEvent;
	+ double Mx = MxFourVector.mass();
	+ double My = MyFourVector.mass();

	- // Gap center calculations
	- const ParticleVector particlesByRapidity = fs.particles(cmpMomByRap); //ByRapidity();
	+ const double xix = (MxMx)/(sqrtS()/GeV sqrtS()/GeV);

	- vector<double> gaps;
	- vector<double> midpoints;
	- for (size_t ip = 1; ip < particlesByRapidity.size(); ++ip) {
	- const Particle& p1 = particlesByRapidity[ip-1];
	- const Particle& p2 = particlesByRapidity[ip];
	- const double gap = p2.momentum().rapidity() - p1.momentum().rapidity();
	- const double mid = (p2.momentum().rapidity() + p1.momentum().rapidity()) / 2.;
	- gaps.push_back(gap);
	- midpoints.push_back(mid);
	- }
	+ if (log10(My) < 0.5) {
	+ _h_noCASTORtag->fill(log10(xix), weight);
	+ if (log10(xix) > -5.5 && log10(xix) < -2.5) _h_sigmaVis->fill(0.5, weight);
	+ }
	+ else if (log10(My) < 1.1) {
	+ _h_CASTORtag->fill(log10(xix), weight);
	+ if (log10(xix) > -5.5 && log10(xix) < -2.5) _h_sigmaVis->fill(1.5, weight);
	+ }

	- int imid = std::distance(gaps.begin(), max_element(gaps.begin(), gaps.end()));
	- double gapcenter = midpoints[imid];
	+ // Central gap x-section
	+ double xigen = (MxMx) (MyMy) / (sqrtS()/GeV sqrtS()/GeV * 0.93827 * 0.93827); // Proton masses...
	+ double dy0 = -log(xigen);

	- // Calculations for cross-sections
	- FourMomentum MxFourVector(0.,0.,0.,0.);
	- FourMomentum MyFourVector(0.,0.,0.,0.);
	+ if (dy0 > 3.) {
	+ if (log10(My) > 1.1 && log10(Mx) > 1.1) {
	+ _h_centralGap->fill(dy0, weight);
	+ _h_sigmaVis->fill(2.5, weight);
	+ }
	+ }

	- foreach(const Particle& p, fs.particles(cmpMomByEta)) {
	- if (p.momentum().rapidity() > gapcenter) {
	- MxFourVector += p.momentum();
	- }
	- else {
	- MyFourVector += p.momentum();
	- }
	- }
	-
	- double Mx = MxFourVector.mass();
	- double My = MyFourVector.mass();
	-
	- const double xix = (MxMx)/(sqrtS()/GeV sqrtS()/GeV);
	-
	- if (log10(My) < 0.5) {
	- _h_noCASTORtag->fill(log10(xix), weight);
	- if (log10(xix) > -5.5 && log10(xix) < -2.5) _h_sigmaVis->fill(0.5, weight);
	- }
	- else if (log10(My) < 1.1) {
	- _h_CASTORtag->fill(log10(xix), weight);
	- if (log10(xix) > -5.5 && log10(xix) < -2.5) _h_sigmaVis->fill(1.5, weight);
	- }
	-
	- // Central gap x-section
	- double xigen = (MxMx) (MyMy) / (sqrtS()/GeV sqrtS()/GeV * 0.93827 * 0.93827); // Proton masses...
	- double dy0 = -log(xigen);
	-
	- if (dy0 > 3.) {
	- if (log10(My) > 1.1 && log10(Mx) > 1.1) {
	- _h_centralGap->fill(dy0, weight);
	- _h_sigmaVis->fill(2.5, weight);
	- }
	- }
	-
	-}
	+ }

	void finalize() {

	double xs = crossSection()/millibarn/sumOfWeights();
	- scale(_h_noCASTORtag, xs);
	- scale(_h_CASTORtag , xs);
	- scale(_h_centralGap , xs);
	- scale(_h_sigmaVis , xs);
	- scale(_h_maxFwdGap , xs);
	+ scale(_h_noCASTORtag, xs);
	+ scale(_h_CASTORtag , xs);
	+ scale(_h_centralGap , xs);
	+ scale(_h_sigmaVis , xs);
	+ scale(_h_maxFwdGap , xs);

	}

	private:

	Histo1DPtr _h_noCASTORtag;
	Histo1DPtr _h_CASTORtag;
	Histo1DPtr _h_centralGap;
	Histo1DPtr _h_sigmaVis;
	Histo1DPtr _h_maxFwdGap;
	double edge;

	};


	DECLARE_RIVET_PLUGIN(CMS_2015_I1356998);

	}
	diff --git a/src/Analyses/CMS_2015_I1370682.cc b/src/Analyses/CMS_2015_I1370682.cc
	--- a/src/Analyses/CMS_2015_I1370682.cc
	+++ b/src/Analyses/CMS_2015_I1370682.cc
	@@ -1,612 +1,612 @@
	#include "Rivet/Analysis.hh"
	#include "Rivet/Math/LorentzTrans.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	namespace { //< only visible in this compilation unit

	/// @brief Pseudo top finder
	///
	/// Find top quark in the particle level.
	/// The definition is based on the agreement at the LHC working group.
	class PseudoTop : public FinalState {
	public:
	/// @name Standard constructors and destructors.
	//@{

	/// The default constructor. May specify the minimum and maximum
	/// pseudorapidity \f$ \eta \f$ and the min \f$ p_T \f$ (in GeV).
	PseudoTop(double lepR = 0.1, double lepMinPt = 20, double lepMaxEta = 2.4,
	double jetR = 0.4, double jetMinPt = 30, double jetMaxEta = 4.7)
	: FinalState(-MAXDOUBLE, MAXDOUBLE, 0*GeV),
	_lepR(lepR), _lepMinPt(lepMinPt), _lepMaxEta(lepMaxEta),
	_jetR(jetR), _jetMinPt(jetMinPt), _jetMaxEta(jetMaxEta)
	{
	setName("PseudoTop");
	}

	enum TTbarMode {CH_NONE=-1, CH_FULLHADRON = 0, CH_SEMILEPTON, CH_FULLLEPTON};
	enum DecayMode {CH_HADRON = 0, CH_MUON, CH_ELECTRON};

	TTbarMode mode() const {
	if (!_isValid) return CH_NONE;
	if (_mode1 == CH_HADRON && _mode2 == CH_HADRON) return CH_FULLHADRON;
	else if ( _mode1 != CH_HADRON && _mode2 != CH_HADRON) return CH_FULLLEPTON;
	else return CH_SEMILEPTON;
	}
	DecayMode mode1() const {return _mode1;}
	DecayMode mode2() const {return _mode2;}

	/// Clone on the heap.
	virtual unique_ptr<Projection> clone() const {
	return unique_ptr<Projection>(new PseudoTop(*this));
	}

	//@}

	public:
	Particle t1() const {return _t1;}
	Particle t2() const {return _t2;}
	Particle b1() const {return _b1;}
	Particle b2() const {return _b2;}
	ParticleVector wDecays1() const {return _wDecays1;}
	ParticleVector wDecays2() const {return _wDecays2;}
	Jets jets() const {return _jets;}
	Jets bjets() const {return _bjets;}
	Jets ljets() const {return _ljets;}

	protected:
	// Apply the projection to the event
	void project(const Event& e); // override; ///< @todo Re-enable when C++11 allowed
	void cleanup(std::map<double, std::pair<size_t, size_t> >& v, const bool doCrossCleanup=false) const;

	private:
	const double _lepR, _lepMinPt, _lepMaxEta;
	const double _jetR, _jetMinPt, _jetMaxEta;

	//constexpr ///< @todo Re-enable when C++11 allowed
	static double _tMass; // = 172.5*GeV; ///< @todo Re-enable when C++11 allowed
	//constexpr ///< @todo Re-enable when C++11 allowed
	static double _wMass; // = 80.4*GeV; ///< @todo Re-enable when C++11 allowed

	private:
	bool _isValid;
	DecayMode _mode1, _mode2;

	Particle _t1, _t2;
	Particle _b1, _b2;
	ParticleVector _wDecays1, _wDecays2;
	Jets _jets, _bjets, _ljets;

	};

	// More implementation below the analysis code

	}



	/// Pseudo-top analysis from CMS
	class CMS_2015_I1370682 : public Analysis {
	public:

	CMS_2015_I1370682()
	: Analysis("CMS_2015_I1370682"),
	_applyCorrection(true),
	_doShapeOnly(false)
	{ }


	void init() {
	- addProjection(PseudoTop(0.1, 20, 2.4, 0.5, 30, 2.4), "ttbar");
	+ declare(PseudoTop(0.1, 20, 2.4, 0.5, 30, 2.4), "ttbar");

	// Lepton + Jet channel
	_hSL_topPt = bookHisto1D("d15-x01-y01"); // 1/sigma dsigma/dpt(top)
	_hSL_topPtTtbarSys = bookHisto1D("d16-x01-y01"); // 1/sigma dsigma/dpt*(top)
	_hSL_topY = bookHisto1D("d17-x01-y01"); // 1/sigma dsigma/dy(top)
	_hSL_ttbarDelPhi = bookHisto1D("d18-x01-y01"); // 1/sigma dsigma/ddeltaphi(t,tbar)
	_hSL_topPtLead = bookHisto1D("d19-x01-y01"); // 1/sigma dsigma/dpt(t1)
	_hSL_topPtSubLead = bookHisto1D("d20-x01-y01"); // 1/sigma dsigma/dpt(t2)
	_hSL_ttbarPt = bookHisto1D("d21-x01-y01"); // 1/sigma dsigma/dpt(ttbar)
	_hSL_ttbarY = bookHisto1D("d22-x01-y01"); // 1/sigma dsigma/dy(ttbar)
	_hSL_ttbarMass = bookHisto1D("d23-x01-y01"); // 1/sigma dsigma/dm(ttbar)

	// Dilepton channel
	_hDL_topPt = bookHisto1D("d24-x01-y01"); // 1/sigma dsigma/dpt(top)
	_hDL_topPtTtbarSys = bookHisto1D("d25-x01-y01"); // 1/sigma dsigma/dpt*(top)
	_hDL_topY = bookHisto1D("d26-x01-y01"); // 1/sigma dsigma/dy(top)
	_hDL_ttbarDelPhi = bookHisto1D("d27-x01-y01"); // 1/sigma dsigma/ddeltaphi(t,tbar)
	_hDL_topPtLead = bookHisto1D("d28-x01-y01"); // 1/sigma dsigma/dpt(t1)
	_hDL_topPtSubLead = bookHisto1D("d29-x01-y01"); // 1/sigma dsigma/dpt(t2)
	_hDL_ttbarPt = bookHisto1D("d30-x01-y01"); // 1/sigma dsigma/dpt(ttbar)
	_hDL_ttbarY = bookHisto1D("d31-x01-y01"); // 1/sigma dsigma/dy(ttbar)
	_hDL_ttbarMass = bookHisto1D("d32-x01-y01"); // 1/sigma dsigma/dm(ttbar)

	}


	void analyze(const Event& event) {

	// Get the ttbar candidate
	- const PseudoTop& ttbar = applyProjection<PseudoTop>(event, "ttbar");
	+ const PseudoTop& ttbar = apply<PseudoTop>(event, "ttbar");
	if ( ttbar.mode() == PseudoTop::CH_NONE ) vetoEvent;

	const FourMomentum& t1P4 = ttbar.t1().momentum();
	const FourMomentum& t2P4 = ttbar.t2().momentum();
	const double pt1 = std::max(t1P4.pT(), t2P4.pT());
	const double pt2 = std::min(t1P4.pT(), t2P4.pT());
	const double dPhi = deltaPhi(t1P4, t2P4);
	- const FourMomentum ttP4 = t1P4+t2P4;
	- const FourMomentum t1P4AtCM = LorentzTransform(-ttP4.boostVector()).transform(t1P4);
	+ const FourMomentum ttP4 = t1P4 + t2P4;
	+ const FourMomentum t1P4AtCM = LorentzTransform::mkFrameTransformFromBeta(ttP4.betaVec()).transform(t1P4);

	const double weight = event.weight();

	if ( ttbar.mode() == PseudoTop::CH_SEMILEPTON ) {
	const Particle lCand1 = ttbar.wDecays1()[0]; // w1 dau0 is the lepton in the PseudoTop
	if (lCand1.pT() < 33*GeV \|\| lCand1.abseta() > 2.1) vetoEvent;
	_hSL_topPt->fill(t1P4.pT(), weight);
	_hSL_topPt->fill(t2P4.pT(), weight);
	_hSL_topPtTtbarSys->fill(t1P4AtCM.pT(), weight);
	_hSL_topY->fill(t1P4.rapidity(), weight);
	_hSL_topY->fill(t2P4.rapidity(), weight);
	_hSL_ttbarDelPhi->fill(dPhi, weight);
	_hSL_topPtLead->fill(pt1, weight);
	_hSL_topPtSubLead->fill(pt2, weight);
	_hSL_ttbarPt->fill(ttP4.pT(), weight);
	_hSL_ttbarY->fill(ttP4.rapidity(), weight);
	_hSL_ttbarMass->fill(ttP4.mass(), weight);
	}
	else if ( ttbar.mode() == PseudoTop::CH_FULLLEPTON ) {
	const Particle lCand1 = ttbar.wDecays1()[0]; // dau0 are the lepton in the PseudoTop
	const Particle lCand2 = ttbar.wDecays2()[0]; // dau0 are the lepton in the PseudoTop
	if (lCand1.pT() < 20*GeV \|\| lCand1.abseta() > 2.4) vetoEvent;
	if (lCand2.pT() < 20*GeV \|\| lCand2.abseta() > 2.4) vetoEvent;
	_hDL_topPt->fill(t1P4.pT(), weight);
	_hDL_topPt->fill(t2P4.pT(), weight);
	_hDL_topPtTtbarSys->fill(t1P4AtCM.pT(), weight);
	_hDL_topY->fill(t1P4.rapidity(), weight);
	_hDL_topY->fill(t2P4.rapidity(), weight);
	_hDL_ttbarDelPhi->fill(dPhi, weight);
	_hDL_topPtLead->fill(pt1, weight);
	_hDL_topPtSubLead->fill(pt2, weight);
	_hDL_ttbarPt->fill(ttP4.pT(), weight);
	_hDL_ttbarY->fill(ttP4.rapidity(), weight);
	_hDL_ttbarMass->fill(ttP4.mass(), weight);
	}

	}


	void finalize() {
	if ( _applyCorrection ) {
	// Correction functions for TOP-12-028 paper, (parton bin height)/(pseudotop bin height)
	const double ch15[] = { 5.473609, 4.941048, 4.173346, 3.391191, 2.785644, 2.371346, 2.194161, 2.197167, };
	const double ch16[] = { 5.470905, 4.948201, 4.081982, 3.225532, 2.617519, 2.239217, 2.127878, 2.185918, };
	const double ch17[] = { 10.003667, 4.546519, 3.828115, 3.601018, 3.522194, 3.524694, 3.600951, 3.808553, 4.531891, 9.995370, };
	const double ch18[] = { 4.406683, 4.054041, 3.885393, 4.213646, };
	const double ch19[] = { 6.182537, 5.257703, 4.422280, 3.568402, 2.889408, 2.415878, 2.189974, 2.173210, };
	const double ch20[] = { 5.199874, 4.693318, 3.902882, 3.143785, 2.607877, 2.280189, 2.204124, 2.260829, };
	const double ch21[] = { 6.053523, 3.777506, 3.562251, 3.601356, 3.569347, 3.410472, };
	const double ch22[] = { 11.932351, 4.803773, 3.782709, 3.390775, 3.226806, 3.218982, 3.382678, 3.773653, 4.788191, 11.905338, };
	const double ch23[] = { 7.145255, 5.637595, 4.049882, 3.025917, 2.326430, 1.773824, 1.235329, };

	const double ch24[] = { 2.268193, 2.372063, 2.323975, 2.034655, 1.736793, };
	const double ch25[] = { 2.231852, 2.383086, 2.341894, 2.031318, 1.729672, 1.486993, };
	const double ch26[] = { 3.993526, 2.308249, 2.075136, 2.038297, 2.036302, 2.078270, 2.295817, 4.017713, };
	const double ch27[] = { 2.205978, 2.175010, 2.215376, 2.473144, };
	const double ch28[] = { 2.321077, 2.371895, 2.338871, 2.057821, 1.755382, };
	const double ch29[] = { 2.222707, 2.372591, 2.301688, 1.991162, 1.695343, };
	const double ch30[] = { 2.599677, 2.026855, 2.138620, 2.229553, };
	const double ch31[] = { 5.791779, 2.636219, 2.103642, 1.967198, 1.962168, 2.096514, 2.641189, 5.780828, };
	const double ch32[] = { 2.006685, 2.545525, 2.477745, 2.335747, 2.194226, 2.076500, };

	applyCorrection(_hSL_topPt, ch15);
	applyCorrection(_hSL_topPtTtbarSys, ch16);
	applyCorrection(_hSL_topY, ch17);
	applyCorrection(_hSL_ttbarDelPhi, ch18);
	applyCorrection(_hSL_topPtLead, ch19);
	applyCorrection(_hSL_topPtSubLead, ch20);
	applyCorrection(_hSL_ttbarPt, ch21);
	applyCorrection(_hSL_ttbarY, ch22);
	applyCorrection(_hSL_ttbarMass, ch23);

	applyCorrection(_hDL_topPt, ch24);
	applyCorrection(_hDL_topPtTtbarSys, ch25);
	applyCorrection(_hDL_topY, ch26);
	applyCorrection(_hDL_ttbarDelPhi, ch27);
	applyCorrection(_hDL_topPtLead, ch28);
	applyCorrection(_hDL_topPtSubLead, ch29);
	applyCorrection(_hDL_ttbarPt, ch30);
	applyCorrection(_hDL_ttbarY, ch31);
	applyCorrection(_hDL_ttbarMass, ch32);
	}

	if ( _doShapeOnly ) {
	normalize(_hSL_topPt );
	normalize(_hSL_topPtTtbarSys);
	normalize(_hSL_topY );
	normalize(_hSL_ttbarDelPhi );
	normalize(_hSL_topPtLead );
	normalize(_hSL_topPtSubLead );
	normalize(_hSL_ttbarPt );
	normalize(_hSL_ttbarY );
	normalize(_hSL_ttbarMass );

	normalize(_hDL_topPt );
	normalize(_hDL_topPtTtbarSys);
	normalize(_hDL_topY );
	normalize(_hDL_ttbarDelPhi );
	normalize(_hDL_topPtLead );
	normalize(_hDL_topPtSubLead );
	normalize(_hDL_ttbarPt );
	normalize(_hDL_ttbarY );
	normalize(_hDL_ttbarMass );
	}
	else {
	const double s = 1./sumOfWeights();
	scale(_hSL_topPt , s);
	scale(_hSL_topPtTtbarSys, s);
	scale(_hSL_topY , s);
	scale(_hSL_ttbarDelPhi , s);
	scale(_hSL_topPtLead , s);
	scale(_hSL_topPtSubLead , s);
	scale(_hSL_ttbarPt , s);
	scale(_hSL_ttbarY , s);
	scale(_hSL_ttbarMass , s);
	scale(_hDL_topPt , s);
	scale(_hDL_topPtTtbarSys, s);
	scale(_hDL_topY , s);
	scale(_hDL_ttbarDelPhi , s);
	scale(_hDL_topPtLead , s);
	scale(_hDL_topPtSubLead , s);
	scale(_hDL_ttbarPt , s);
	scale(_hDL_ttbarY , s);
	scale(_hDL_ttbarMass , s);
	}

	}


	void applyCorrection(Histo1DPtr h, const double* cf) {
	vector<YODA::HistoBin1D>& bins = h->bins();
	for (size_t i=0, n=bins.size(); i<n; ++i ) {
	const double s = cf[i];
	YODA::HistoBin1D& bin = bins[i];
	bin.scaleW(s);
	}
	}


	private:

	const bool _applyCorrection, _doShapeOnly;
	Histo1DPtr _hSL_topPt, _hSL_topPtTtbarSys, _hSL_topY, _hSL_ttbarDelPhi, _hSL_topPtLead,
	_hSL_topPtSubLead, _hSL_ttbarPt, _hSL_ttbarY, _hSL_ttbarMass;
	Histo1DPtr _hDL_topPt, _hDL_topPtTtbarSys, _hDL_topY, _hDL_ttbarDelPhi, _hDL_topPtLead,
	_hDL_topPtSubLead, _hDL_ttbarPt, _hDL_ttbarY, _hDL_ttbarMass;

	};



	DECLARE_RIVET_PLUGIN(CMS_2015_I1370682);


	///////////////

	// More PseudoTop implementation
	namespace {


	double PseudoTop::_tMass = 172.5*GeV;
	double PseudoTop::_wMass = 80.4*GeV;


	void PseudoTop::cleanup(map<double, pair<size_t, size_t> >& v, const bool doCrossCleanup) const {
	vector<map<double, pair<size_t, size_t> >::iterator> toErase;
	set<size_t> usedLeg1, usedLeg2;
	if ( !doCrossCleanup ) {
	/// @todo Reinstate when C++11 allowed: for (auto key = v.begin(); key != v.end(); ++key) {
	for (map<double, pair<size_t, size_t> >::iterator key = v.begin(); key != v.end(); ++key) {
	const size_t leg1 = key->second.first;
	const size_t leg2 = key->second.second;
	if (usedLeg1.find(leg1) == usedLeg1.end() and
	usedLeg2.find(leg2) == usedLeg2.end()) {
	usedLeg1.insert(leg1);
	usedLeg2.insert(leg2);
	} else {
	toErase.push_back(key);
	}
	}
	}
	else {
	/// @todo Reinstate when C++11 allowed: for (auto key = v.begin(); key != v.end(); ++key) {
	for (map<double, pair<size_t, size_t> >::iterator key = v.begin(); key != v.end(); ++key) {
	const size_t leg1 = key->second.first;
	const size_t leg2 = key->second.second;
	if (usedLeg1.find(leg1) == usedLeg1.end() and
	usedLeg1.find(leg2) == usedLeg1.end()) {
	usedLeg1.insert(leg1);
	usedLeg1.insert(leg2);
	} else {
	toErase.push_back(key);
	}
	}
	}
	/// @todo Reinstate when C++11 allowed: for (auto& key : toErase) v.erase(key);
	for (size_t i = 0; i < toErase.size(); ++i) v.erase(toErase[i]);
	}


	void PseudoTop::project(const Event& e) {
	// Leptons : do the lepton clustering anti-kt R=0.1 using stable photons and leptons not from hadron decay
	// Neutrinos : neutrinos not from hadron decay
	// MET : vector sum of all invisible particles in x-y plane
	// Jets : anti-kt R=0.4 using all particles excluding neutrinos and particles used in lepton clustering
	// add ghost B hadrons during the jet clustering to identify B jets.

	// W->lv : dressed lepton and neutrino pairs
	// W->jj : light flavored dijet
	// W candidate : select lv or jj pairs which minimise \|mW1-80.4\|+\|mW2-80.4\|
	// lepton-neutrino pair will be selected with higher priority

	// t->Wb : W candidate + b jet
	// t candidate : select Wb pairs which minimise \|mtop1-172.5\|+\|mtop2-172.5\|

	_isValid = false;
	_theParticles.clear();
	_wDecays1.clear();
	_wDecays2.clear();
	_jets.clear();
	_bjets.clear();
	_ljets.clear();
	_mode1 = _mode2 = CH_HADRON;

	// Collect final state particles
	Particles pForLep, pForJet;
	Particles neutrinos; // Prompt neutrinos
	/// @todo Avoid this unsafe jump into HepMC -- all this can be done properly via VisibleFS and HeavyHadrons projections
	for (const GenParticle* p : Rivet::particles(e.genEvent())) {
	const int status = p->status();
	const int pdgId = p->pdg_id();
	if (status == 1) {
	Particle rp = *p;
	if (!PID::isHadron(pdgId) && !rp.fromHadron()) {
	// Collect particles not from hadron decay
	if (rp.isNeutrino()) {
	// Prompt neutrinos are kept in separate collection
	neutrinos.push_back(rp);
	} else if (pdgId == 22 \|\| rp.isLepton()) {
	// Leptons and photons for the dressing
	pForLep.push_back(rp);
	}
	} else if (!rp.isNeutrino()) {
	// Use all particles from hadron decay
	pForJet.push_back(rp);
	}
	} else if (PID::isHadron(pdgId) && PID::hasBottom(pdgId)) {
	// NOTE: Consider B hadrons with pT > 5GeV - not in CMS proposal
	//if ( p->momentum().perp() < 5 ) continue;

	// Do unstable particles, to be used in the ghost B clustering
	// Use last B hadrons only
	bool isLast = true;
	- for (GenParticle* pp : Rivet::particles(p->end_vertex(), HepMC::children)) {
	+ for (const GenParticlePtr pp : Rivet::particles(p->end_vertex(), HepMC::children)) {
	if (PID::hasBottom(pp->pdg_id())) {
	isLast = false;
	break;
	}
	}
	if (!isLast) continue;

	// Rescale momentum by 10^-20
	Particle ghost(pdgId, FourMomentum(p->momentum())*1e-20/p->momentum().rho());
	pForJet.push_back(ghost);
	}
	}

	// Start object building from trivial thing - prompt neutrinos
	sortByPt(neutrinos);

	// Proceed to lepton dressing
	const PseudoJets lep_pjs = mkPseudoJets(pForLep);
	const fastjet::JetDefinition lep_jdef(fastjet::antikt_algorithm, _lepR);
	const Jets leps_all = mkJets(fastjet::ClusterSequence(lep_pjs, lep_jdef).inclusive_jets());
	const Jets leps_sel = sortByPt(filterBy(leps_all, Cuts::pT > _lepMinPt));
	// FastJets fjLep(FastJets::ANTIKT, _lepR);
	// fjLep.calc(pForLep);

	Jets leptons;
	vector<int> leptonsId;
	set<int> dressedIdxs;
	for (const Jet& lep : leps_sel) {
	if (lep.abseta() > _lepMaxEta) continue;
	double leadingPt = -1;
	int leptonId = 0;
	for (const Particle& p : lep.particles()) {
	/// @warning Barcodes aren't future-proof in HepMC
	dressedIdxs.insert(p.genParticle()->barcode());
	if (p.isLepton() && p.pT() > leadingPt) {
	leadingPt = p.pT();
	leptonId = p.pid();
	}
	}
	if (leptonId == 0) continue;
	leptons.push_back(lep);
	leptonsId.push_back(leptonId);
	}

	// Re-use particles not used in lepton dressing
	for (const Particle& rp : pForLep) {
	/// @warning Barcodes aren't future-proof in HepMC
	const int barcode = rp.genParticle()->barcode();
	// Skip if the particle is used in dressing
	if (dressedIdxs.find(barcode) != dressedIdxs.end()) continue;
	// Put back to be used in jet clustering
	pForJet.push_back(rp);
	}

	// Then do the jet clustering
	const PseudoJets jet_pjs = mkPseudoJets(pForJet);
	const fastjet::JetDefinition jet_jdef(fastjet::antikt_algorithm, _jetR);
	const Jets jets_all = mkJets(fastjet::ClusterSequence(jet_pjs, jet_jdef).inclusive_jets());
	const Jets jets_sel = sortByPt(filterBy(jets_all, Cuts::pT > _jetMinPt));
	// FastJets fjJet(FastJets::ANTIKT, _jetR);
	//fjJet.useInvisibles(); // NOTE: CMS proposal to remove neutrinos (AB: wouldn't work anyway, since they were excluded from clustering inputs)
	// fjJet.calc(pForJet);
	for (const Jet& jet : jets_sel) {
	if (jet.abseta() > _jetMaxEta) continue;
	_jets.push_back(jet);
	bool isBJet = false;
	for (const Particle& rp : jet.particles()) {
	if (PID::hasBottom(rp.pdgId())) {
	isBJet = true;
	break;
	}
	}
	if ( isBJet ) _bjets.push_back(jet);
	else _ljets.push_back(jet);
	}

	// Every building blocks are ready. Continue to pseudo-W and pseudo-top combination

	if (_bjets.size() < 2) return; // Ignore single top for now
	map<double, pair<size_t, size_t> > wLepCandIdxs;
	map<double, pair<size_t, size_t> > wHadCandIdxs;

	// Collect leptonic-decaying W's
	for (size_t iLep = 0, nLep = leptons.size(); iLep < nLep; ++iLep) {
	const Jet& lep = leptons.at(iLep);
	for (size_t iNu = 0, nNu = neutrinos.size(); iNu < nNu; ++iNu) {
	const Particle& nu = neutrinos.at(iNu);
	const double m = (lep.momentum()+nu.momentum()).mass();
	const double dm = std::abs(m-_wMass);
	wLepCandIdxs[dm] = make_pair(iLep, iNu);
	}
	}

	// Continue to hadronic decaying W's
	for (size_t i = 0, nLjet = _ljets.size(); i < nLjet; ++i) {
	const Jet& ljet1 = _ljets[i];
	for (size_t j = i+1; j < nLjet; ++j) {
	const Jet& ljet2 = _ljets[j];
	const double m = (ljet1.momentum()+ljet2.momentum()).mass();
	const double dm = std::abs(m-_wMass);
	wHadCandIdxs[dm] = make_pair(i, j);
	}
	}

	// Cleanup W candidate, choose pairs with minimum dm if they share decay products
	cleanup(wLepCandIdxs);
	cleanup(wHadCandIdxs, true);
	const size_t nWLepCand = wLepCandIdxs.size();
	const size_t nWHadCand = wHadCandIdxs.size();

	if (nWLepCand + nWHadCand < 2) return; // We skip single top

	int w1Q = 1, w2Q = -1;
	int w1dau1Id = 1, w2dau1Id = -1;
	FourMomentum w1dau1LVec, w1dau2LVec;
	FourMomentum w2dau1LVec, w2dau2LVec;
	if (nWLepCand == 0) { // Full hadronic case
	const pair<size_t, size_t>& idPair1 = wHadCandIdxs.begin()->second;
	const pair<size_t, size_t>& idPair2 = (++wHadCandIdxs.begin())->second; ///< @todo Reinstate std::next
	const Jet& w1dau1 = _ljets[idPair1.first];
	const Jet& w1dau2 = _ljets[idPair1.second];
	const Jet& w2dau1 = _ljets[idPair2.first];
	const Jet& w2dau2 = _ljets[idPair2.second];
	w1dau1LVec = w1dau1.momentum();
	w1dau2LVec = w1dau2.momentum();
	w2dau1LVec = w2dau1.momentum();
	w2dau2LVec = w2dau2.momentum();
	} else if (nWLepCand == 1) { // Semi-leptonic case
	const pair<size_t, size_t>& idPair1 = wLepCandIdxs.begin()->second;
	const pair<size_t, size_t>& idPair2 = wHadCandIdxs.begin()->second;
	const Jet& w1dau1 = leptons[idPair1.first];
	const Particle& w1dau2 = neutrinos[idPair1.second];
	const Jet& w2dau1 = _ljets[idPair2.first];
	const Jet& w2dau2 = _ljets[idPair2.second];
	w1dau1LVec = w1dau1.momentum();
	w1dau2LVec = w1dau2.momentum();
	w2dau1LVec = w2dau1.momentum();
	w2dau2LVec = w2dau2.momentum();
	w1dau1Id = leptonsId[idPair1.first];
	w1Q = w1dau1Id > 0 ? -1 : 1;
	w2Q = -w1Q;
	switch (w1dau1Id) {
	case 13: case -13: _mode1 = CH_MUON; break;
	case 11: case -11: _mode1 = CH_ELECTRON; break;
	}
	} else { // Full leptonic case
	const pair<size_t, size_t>& idPair1 = wLepCandIdxs.begin()->second;
	const pair<size_t, size_t>& idPair2 = (++wLepCandIdxs.begin())->second; ///< @todo Reinstate std::next
	const Jet& w1dau1 = leptons[idPair1.first];
	const Particle& w1dau2 = neutrinos[idPair1.second];
	const Jet& w2dau1 = leptons[idPair2.first];
	const Particle& w2dau2 = neutrinos[idPair2.second];
	w1dau1LVec = w1dau1.momentum();
	w1dau2LVec = w1dau2.momentum();
	w2dau1LVec = w2dau1.momentum();
	w2dau2LVec = w2dau2.momentum();
	w1dau1Id = leptonsId[idPair1.first];
	w2dau1Id = leptonsId[idPair2.first];
	w1Q = w1dau1Id > 0 ? -1 : 1;
	w2Q = w2dau1Id > 0 ? -1 : 1;
	switch (w1dau1Id) {
	case 13: case -13: _mode1 = CH_MUON; break;
	case 11: case -11: _mode1 = CH_ELECTRON; break;
	}
	switch (w2dau1Id) {
	case 13: case -13: _mode2 = CH_MUON; break;
	case 11: case -11: _mode2 = CH_ELECTRON; break;
	}
	}
	const FourMomentum w1LVec = w1dau1LVec+w1dau2LVec;
	const FourMomentum w2LVec = w2dau1LVec+w2dau2LVec;

	// Combine b jets
	double sumDm = 1e9;
	FourMomentum b1LVec, b2LVec;
	for (size_t i = 0, n = _bjets.size(); i < n; ++i) {
	const Jet& bjet1 = _bjets[i];
	const double mtop1 = (w1LVec+bjet1.momentum()).mass();
	const double dmtop1 = std::abs(mtop1-_tMass);
	for (size_t j=0; j<n; ++j) {
	if (i == j) continue;
	const Jet& bjet2 = _bjets[j];
	const double mtop2 = (w2LVec+bjet2.momentum()).mass();
	const double dmtop2 = std::abs(mtop2-_tMass);

	if (sumDm <= dmtop1+dmtop2) continue;

	sumDm = dmtop1+dmtop2;
	b1LVec = bjet1.momentum();
	b2LVec = bjet2.momentum();
	}
	}
	if (sumDm >= 1e9) return; // Failed to make top, but this should not happen.

	const FourMomentum t1LVec = w1LVec + b1LVec;
	const FourMomentum t2LVec = w2LVec + b2LVec;

	// Put all of them into candidate collection
	_t1 = Particle(w1Q*6, t1LVec);
	_b1 = Particle(w1Q*5, b1LVec);
	_wDecays1.push_back(Particle(w1dau1Id, w1dau1LVec));
	_wDecays1.push_back(Particle(-w1dau1Id+w1Q, w1dau2LVec));

	_t2 = Particle(w2Q*6, t2LVec);
	_b2 = Particle(w2Q*5, b2LVec);
	_wDecays2.push_back(Particle(w2dau1Id, w2dau1LVec));
	_wDecays2.push_back(Particle(-w2dau1Id+w2Q, w2dau2LVec));

	_isValid = true;
	}

	}


	}
	diff --git a/src/Analyses/CMS_2015_I1384119.cc b/src/Analyses/CMS_2015_I1384119.cc
	--- a/src/Analyses/CMS_2015_I1384119.cc
	+++ b/src/Analyses/CMS_2015_I1384119.cc
	@@ -1,62 +1,60 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	class CMS_2015_I1384119 : public Analysis {
	public:

	/// Constructor
	- CMS_2015_I1384119()
	- : Analysis("CMS_2015_I1384119")
	- { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2015_I1384119);


	/// Book histograms and initialise projections before the run
	void init() {
	const FinalState fsa(Cuts::abseta < 20);
	- addProjection(fsa, "FSA");
	+ declare(fsa, "FSA");
	const ChargedFinalState cfs(Cuts::abseta < 2);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	_hist_dNch_dEta_inel = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	// Apply inelastic selection (veto pp -> pp elastic events)
	- const FinalState& fsa = applyProjection<FinalState>(event, "FSA");
	+ const FinalState& fsa = apply<FinalState>(event, "FSA");
	if (fsa.size() <= 2) vetoEvent;

	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	foreach (const Particle& p, cfs.particles()) {
	const int id = p.abspid();
	// continue if particle is a proton, a kaon or a pion
	if (id == 211 \|\| id == 321 \|\| id == 2212) ///< @todo Use PID:: ID constants
	_hist_dNch_dEta_inel->fill(p.eta(), event.weight());
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_hist_dNch_dEta_inel, 1/sumOfWeights());
	}


	private:

	/// Histograms
	Histo1DPtr _hist_dNch_dEta_inel;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2015_I1384119);

	}
	diff --git a/src/Analyses/CMS_2015_I1385107.cc b/src/Analyses/CMS_2015_I1385107.cc
	--- a/src/Analyses/CMS_2015_I1385107.cc
	+++ b/src/Analyses/CMS_2015_I1385107.cc
	@@ -1,126 +1,126 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// CMS UE charged particles vs. leading jet at 2.76 TeV
	class CMS_2015_I1385107 : public Analysis {
	public:
	/// Constructor
	CMS_2015_I1385107() : Analysis("CMS_2015_I1385107"),
	ETACUT(2.0),
	AREATOT(2ETACUT 2*M_PI),
	AREA3(AREATOT / 3.),
	AREA6(AREATOT / 6.)
	{ }


	/// Book histograms and initialise projections before the run
	void init() {

	const ChargedFinalState cfs(Cuts::abseta < 2 && Cuts::pT > 500*MeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	const ChargedFinalState cfsforjet(Cuts::abseta < 2.5 && Cuts::pT > 500*MeV);
	const FastJets jetpro(cfsforjet, FastJets::SISCONE, 0.5);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	_h_Nch_TransAVE_vs_pT = bookProfile1D(1, 1, 1); // Nch vs. pT_max (TransAVE)
	_h_Sum_TransAVE_vs_pT = bookProfile1D(2, 1, 1); // sum(pT) vs. pT_max (TransAVE)
	_h_Nch_TransMAX_vs_pT = bookProfile1D(3, 1, 1); // Nch vs. pT_max (TransMAX)
	_h_Sum_TransMAX_vs_pT = bookProfile1D(4, 1, 1); // sum(pT) vs. pT_max (TransMAX)
	_h_Nch_TransMIN_vs_pT = bookProfile1D(5, 1, 1); // Nch vs. pT_max (TransMIN)
	_h_Sum_TransMIN_vs_pT = bookProfile1D(6, 1, 1); // sum(pT) vs. pT_max (TransMIN)
	_h_Nch_TransDIF_vs_pT = bookProfile1D(7, 1, 1); // Nch vs. pT_max (TransDIF)
	_h_Sum_TransDIF_vs_pT = bookProfile1D(8, 1, 1); // sum(pT) vs. pT_max (TransDIF)
	}


	/// Local definition of a signed dphi, for use in differentating L and R trans regions
	double signedDeltaPhi(double jetphi, double partphi) {
	double delta = partphi - jetphi;
	while (delta <= -PI) delta += 2 * PI;
	while (delta > PI) delta -= 2 * PI;
	return delta;
	}

	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Find the lead jet, applying a restriction that the jets must be within \|eta\| < 2.
	FourMomentum p_lead;
	- foreach (const Jet& j, applyProjection<FastJets>(event, "Jets").jetsByPt(1*GeV)) {
	+ foreach (const Jet& j, apply<FastJets>(event, "Jets").jetsByPt(1*GeV)) {
	if (j.abseta() < 2.0) {
	p_lead = j.momentum();
	break;
	}
	}
	if (p_lead.isZero()) vetoEvent;
	const double phi_lead = p_lead.phi();
	const double pT_lead = p_lead.pT();

	// Loop on charged particles and separate Left and Right transverse regions
	- Particles particles = applyProjection<ChargedFinalState>(event, "CFS").particlesByPt();
	+ Particles particles = apply<ChargedFinalState>(event, "CFS").particlesByPt();
	int nch_TransLeft = 0, nch_TransRight = 0;
	double ptSum_TransLeft = 0., ptSum_TransRight = 0.;
	foreach (const Particle& p, particles) {
	const double dphi = signedDeltaPhi(phi_lead, p.momentum().phi());
	if (!inRange(fabs(dphi), PI/3, 2*PI/3.)) continue; //< only fill trans regions
	if (dphi < 0) { // Transverse Right region
	nch_TransRight += 1;
	ptSum_TransRight += p.pT() / GeV;
	} else if (dphi > 0) { // Transverse Left region
	nch_TransLeft += 1;
	ptSum_TransLeft += p.pT() / GeV;
	}
	}

	// Translate to min and max (+sum and diff) Transverse regions
	const int nch_TransMIN = std::min(nch_TransLeft, nch_TransRight);
	const int nch_TransMAX = std::max(nch_TransLeft, nch_TransRight);
	const int nch_TransSUM = nch_TransMAX + nch_TransMIN;
	const int nch_TransDIF = nch_TransMAX - nch_TransMIN;
	//
	const double ptSum_TransMIN = std::min(ptSum_TransLeft, ptSum_TransRight);
	const double ptSum_TransMAX = std::max(ptSum_TransLeft, ptSum_TransRight);
	const double ptSum_TransSUM = ptSum_TransMAX + ptSum_TransMIN;
	const double ptSum_TransDIF = ptSum_TransMAX - ptSum_TransMIN;

	// Fill profiles
	const double weight = event.weight();
	_h_Nch_TransMIN_vs_pT->fill(pT_lead/GeV, 1/AREA6 * nch_TransMIN, weight);
	_h_Sum_TransMIN_vs_pT->fill(pT_lead/GeV, 1/AREA6 * ptSum_TransMIN, weight);
	//
	_h_Nch_TransMAX_vs_pT->fill(pT_lead/GeV, 1/AREA6 * nch_TransMAX, weight);
	_h_Sum_TransMAX_vs_pT->fill(pT_lead/GeV, 1/AREA6 * ptSum_TransMAX, weight);
	//
	_h_Nch_TransAVE_vs_pT->fill(pT_lead/GeV, 1/AREA3 * nch_TransSUM, weight);
	_h_Sum_TransAVE_vs_pT->fill(pT_lead/GeV, 1/AREA3 * ptSum_TransSUM, weight);
	//
	_h_Nch_TransDIF_vs_pT->fill(pT_lead/GeV, 1/AREA6 * nch_TransDIF, weight);
	_h_Sum_TransDIF_vs_pT->fill(pT_lead/GeV, 1/AREA6 * ptSum_TransDIF, weight);
	}


	private:

	// Data members like post-cuts event weight counters go here
	const double ETACUT, AREATOT, AREA3, AREA6;

	/// Histograms
	Profile1DPtr _h_Nch_TransAVE_vs_pT, _h_Sum_TransAVE_vs_pT;
	Profile1DPtr _h_Nch_TransDIF_vs_pT, _h_Sum_TransDIF_vs_pT;
	Profile1DPtr _h_Nch_TransMIN_vs_pT, _h_Sum_TransMIN_vs_pT;
	Profile1DPtr _h_Nch_TransMAX_vs_pT, _h_Sum_TransMAX_vs_pT;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(CMS_2015_I1385107);

	}
	diff --git a/src/Analyses/CMS_2015_I1397174.cc b/src/Analyses/CMS_2015_I1397174.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/CMS_2015_I1397174.cc
	@@ -0,0 +1,386 @@
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/PartonicTops.hh"
	+#include "Rivet/Projections/VetoedFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// Fully leptonic partonic ttbar analysis
	+ class CMS_2015_I1397174 : public Analysis {
	+ public:
	+
	+ /// Minimal constructor
	+ CMS_2015_I1397174()
	+ : Analysis("CMS_2015_I1397174") { }
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Set up projections and book histograms
	+ void init() {
	+
	+ // Parton level top quarks
	+ addProjection(PartonicTops(PartonicTops::E_MU, false), "PartonTops");
	+
	+ // Find jets not related to the top/W decays
	+ VetoedFinalState vfs;
	+ vfs.addDecayProductsVeto(PID::WPLUSBOSON);
	+ vfs.addDecayProductsVeto(PID::WMINUSBOSON);
	+ FastJets fj(vfs, FastJets::ANTIKT, 0.5, JetAlg::ALL_MUONS, JetAlg::ALL_INVISIBLES);
	+ addProjection(fj, "Jets");
	+
	+ // Book histograms
	+ _hVis_nJet30_abs = bookHisto1D( 1, 1, 1);
	+ _hVis_nJet30 = bookHisto1D( 2, 1, 1);
	+ _hVis_nJet60_abs = bookHisto1D( 3, 1, 1);
	+ _hVis_nJet60 = bookHisto1D( 4, 1, 1);
	+ _hVis_nJet100_abs = bookHisto1D( 5, 1, 1);
	+ _hVis_nJet100 = bookHisto1D( 6, 1, 1);
	+
	+ _hVis_addJet1Pt_abs = bookHisto1D( 7, 1, 1);
	+ _hVis_addJet1Pt = bookHisto1D( 8, 1, 1);
	+ _hVis_addJet1Eta_abs = bookHisto1D( 9, 1, 1);
	+ _hVis_addJet1Eta = bookHisto1D(10, 1, 1);
	+ _hVis_addJet2Pt_abs = bookHisto1D(11, 1, 1);
	+ _hVis_addJet2Pt = bookHisto1D(12, 1, 1);
	+ _hVis_addJet2Eta_abs = bookHisto1D(13, 1, 1);
	+ _hVis_addJet2Eta = bookHisto1D(14, 1, 1);
	+ _hVis_addJJMass_abs = bookHisto1D(15, 1, 1);
	+ _hVis_addJJMass = bookHisto1D(16, 1, 1);
	+ _hVis_addJJDR_abs = bookHisto1D(17, 1, 1);
	+ _hVis_addJJDR = bookHisto1D(18, 1, 1);
	+ _hVis_addJJHT_abs = bookHisto1D(19, 1, 1);
	+ _hVis_addJJHT = bookHisto1D(20, 1, 1);
	+
	+ _hFull_addJet1Pt_abs = bookHisto1D(21, 1, 1);
	+ _hFull_addJet1Pt = bookHisto1D(22, 1, 1);
	+ _hFull_addJet1Eta_abs = bookHisto1D(23, 1, 1);
	+ _hFull_addJet1Eta = bookHisto1D(24, 1, 1);
	+ _hFull_addJet2Pt_abs = bookHisto1D(25, 1, 1);
	+ _hFull_addJet2Pt = bookHisto1D(26, 1, 1);
	+ _hFull_addJet2Eta_abs = bookHisto1D(27, 1, 1);
	+ _hFull_addJet2Eta = bookHisto1D(28, 1, 1);
	+ _hFull_addJJMass_abs = bookHisto1D(29, 1, 1);
	+ _hFull_addJJMass = bookHisto1D(30, 1, 1);
	+ _hFull_addJJDR_abs = bookHisto1D(31, 1, 1);
	+ _hFull_addJJDR = bookHisto1D(32, 1, 1);
	+ _hFull_addJJHT_abs = bookHisto1D(33, 1, 1);
	+ _hFull_addJJHT = bookHisto1D(34, 1, 1);
	+
	+ _hVis_addBJet1Pt_abs = bookHisto1D(35, 1, 1);
	+ _hVis_addBJet1Pt = bookHisto1D(36, 1, 1);
	+ _hVis_addBJet1Eta_abs = bookHisto1D(37, 1, 1);
	+ _hVis_addBJet1Eta = bookHisto1D(38, 1, 1);
	+ _hVis_addBJet2Pt_abs = bookHisto1D(39, 1, 1);
	+ _hVis_addBJet2Pt = bookHisto1D(40, 1, 1);
	+ _hVis_addBJet2Eta_abs = bookHisto1D(41, 1, 1);
	+ _hVis_addBJet2Eta = bookHisto1D(42, 1, 1);
	+ _hVis_addBBMass_abs = bookHisto1D(43, 1, 1);
	+ _hVis_addBBMass = bookHisto1D(44, 1, 1);
	+ _hVis_addBBDR_abs = bookHisto1D(45, 1, 1);
	+ _hVis_addBBDR = bookHisto1D(46, 1, 1);
	+
	+ _hFull_addBJet1Pt_abs = bookHisto1D(47, 1, 1);
	+ _hFull_addBJet1Pt = bookHisto1D(48, 1, 1);
	+ _hFull_addBJet1Eta_abs = bookHisto1D(49, 1, 1);
	+ _hFull_addBJet1Eta = bookHisto1D(50, 1, 1);
	+ _hFull_addBJet2Pt_abs = bookHisto1D(51, 1, 1);
	+ _hFull_addBJet2Pt = bookHisto1D(52, 1, 1);
	+ _hFull_addBJet2Eta_abs = bookHisto1D(53, 1, 1);
	+ _hFull_addBJet2Eta = bookHisto1D(54, 1, 1);
	+ _hFull_addBBMass_abs = bookHisto1D(55, 1, 1);
	+ _hFull_addBBMass = bookHisto1D(56, 1, 1);
	+ _hFull_addBBDR_abs = bookHisto1D(57, 1, 1);
	+ _hFull_addBBDR = bookHisto1D(58, 1, 1);
	+
	+ _h_gap_addJet1Pt = bookProfile1D(59, 1, 1);
	+ _h_gap_addJet1Pt_eta0 = bookProfile1D(60, 1, 1);
	+ _h_gap_addJet1Pt_eta1 = bookProfile1D(61, 1, 1);
	+ _h_gap_addJet1Pt_eta2 = bookProfile1D(62, 1, 1);
	+ _h_gap_addJet2Pt = bookProfile1D(63, 1, 1);
	+ _h_gap_addJet2Pt_eta0 = bookProfile1D(64, 1, 1);
	+ _h_gap_addJet2Pt_eta1 = bookProfile1D(65, 1, 1);
	+ _h_gap_addJet2Pt_eta2 = bookProfile1D(66, 1, 1);
	+ _h_gap_addJetHT = bookProfile1D(67, 1, 1);
	+ _h_gap_addJetHT_eta0 = bookProfile1D(68, 1, 1);
	+ _h_gap_addJetHT_eta1 = bookProfile1D(69, 1, 1);
	+ _h_gap_addJetHT_eta2 = bookProfile1D(70, 1, 1);
	+ }
	+
	+
	+ void analyze(const Event& event) {
	+
	+ // The objects used in the PAPER 12-041 are defined as follows (see p.16 for details):
	+ //
	+ // * Leptons : from the W boson decays after FSR
	+ // * Jets : anti-kT R=0.5 to all stable particles
	+ // exclude W->enu, munu, taunu
	+ // * B jet : B-Ghost matched
	+ // * B from top : B hadron from top->b decay
	+ //
	+ // Visible phase space definition:
	+ //
	+ // * Leptons : pT > 20, \|eta\| < 2.4
	+ // * B jets from top : pT > 30, \|eta\| < 2.4
	+ // Additional jets : pT > 20, \|eta\| < 2.4
	+ // *
	+ // Full phase space definition:
	+ //
	+ // * Correction to dilepton BR from W boson BR
	+ // * No cut on top decay products
	+ // * Additional jets : pT > 20, \|eta\| < 2.4
	+
	+ // Do the analysis only for the ttbar full leptonic channel, removing tau decays
	+ const Particles partontops = apply<ParticleFinder>(event, "PartonTops").particlesByPt();
	+ if (partontops.size() != 2) vetoEvent;
	+ const Particle& t1 = partontops[0];
	+ const Particle& t2 = partontops[1];
	+
	+ // Apply acceptance cuts on top-decay leptons (existence should be guaranteed)
	+ const auto isPromptChLepton = [](const Particle& p){return isChargedLepton(p) && !fromDecay(p);};
	+ const Particle lep1 = t1.allDescendants(lastParticleWith(isPromptChLepton)).front();
	+ const Particle lep2 = t2.allDescendants(lastParticleWith(isPromptChLepton)).front();
	+ if (lep1.pT() < 1e-9GeV \|\| lep2.pT() < 1e-9GeV) vetoEvent; // sanity check?
	+
	+ const Jets jets = apply<JetAlg>(event, "Jets").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.4);
	+ int nJet30 = 0, nJet60 = 0, nJet100 = 0;
	+ Jets topBJets, addJets, addBJets, addJets_eta0, addJets_eta1, addJets_eta2;
	+ for (const Jet& jet : jets) {
	+ if (jet.pT() > 30*GeV) nJet30 += 1;
	+ if (jet.pT() > 60*GeV) nJet60 += 1;
	+ if (jet.pT() > 100*GeV) nJet100 += 1;
	+
	+ const bool isBtagged = jet.bTagged();
	+ const bool isBFromTop = any(jet.bTags(), hasParticleAncestorWith(Cuts::abspid == PID::TQUARK));
	+
	+ if (isBFromTop) {
	+ if (jet.pT() > 30*GeV) topBJets.push_back(jet);
	+ } else {
	+ addJets.push_back(jet);
	+ if (isBtagged) addBJets.push_back(jet);
	+ if (jet.abseta() < 0.8 ) addJets_eta0.push_back(jet);
	+ else if (jet.abseta() < 1.5 ) addJets_eta1.push_back(jet);
	+ else if (jet.abseta() < 2.4 ) addJets_eta2.push_back(jet);
	+ }
	+ }
	+
	+
	+ const bool isVisiblePS = topBJets.size() >= 2
	+ && lep1.pT() > 20GeV && lep1.abseta() < 2.4 && lep2.pT() > 20GeV && lep2.abseta() < 2.4;
	+ MSG_DEBUG(isVisiblePS << ": #b(top) = " << topBJets.size()
	+ << "; l1 = " << lep1.pT() << ", " << lep1.abseta()
	+ << "; l2 = " << lep2.pT() << ", " << lep2.abseta());
	+
	+ const double weight = event.weight();
	+
	+
	+ if (isVisiblePS) {
	+ fillWithOF(_hVis_nJet30_abs, nJet30, weight);
	+ fillWithOF(_hVis_nJet30, nJet30, weight);
	+ fillWithOF(_hVis_nJet60_abs, nJet60, weight);
	+ fillWithOF(_hVis_nJet60, nJet60, weight);
	+ fillWithOF(_hVis_nJet100_abs, nJet100, weight);
	+ fillWithOF(_hVis_nJet100, nJet100, weight);
	+
	+ fillGapFractions(addJets, _h_gap_addJet1Pt, _h_gap_addJet2Pt, _h_gap_addJetHT, weight);
	+ fillGapFractions(addJets_eta0, _h_gap_addJet1Pt_eta0, _h_gap_addJet2Pt_eta0, _h_gap_addJetHT_eta0, weight);
	+ fillGapFractions(addJets_eta1, _h_gap_addJet1Pt_eta1, _h_gap_addJet2Pt_eta1, _h_gap_addJetHT_eta1, weight);
	+ fillGapFractions(addJets_eta2, _h_gap_addJet1Pt_eta2, _h_gap_addJet2Pt_eta2, _h_gap_addJetHT_eta2, weight);
	+ }
	+
	+ // Plots with two additional jets
	+ if (addJets.size() >= 1) {
	+ const double ht = sum(addJets, pT, 0.0);
	+ _hFull_addJJHT_abs->fill(ht/GeV, weight);
	+ _hFull_addJJHT ->fill(ht/GeV, weight);
	+ if (isVisiblePS) {
	+ _hVis_addJJHT_abs->fill(ht/GeV, weight);
	+ _hVis_addJJHT ->fill(ht/GeV, weight);
	+ }
	+
	+ const Jet& j1 = addJets[0];
	+ _hFull_addJet1Pt_abs ->fill(j1.pT()/GeV, weight);
	+ _hFull_addJet1Pt ->fill(j1.pT()/GeV, weight);
	+ _hFull_addJet1Eta_abs->fill(j1.abseta(), weight);
	+ _hFull_addJet1Eta ->fill(j1.abseta(), weight);
	+ if (isVisiblePS) {
	+ _hVis_addJet1Pt_abs ->fill(j1.pT()/GeV, weight);
	+ _hVis_addJet1Pt ->fill(j1.pT()/GeV, weight);
	+ _hVis_addJet1Eta_abs->fill(j1.abseta(), weight);
	+ _hVis_addJet1Eta ->fill(j1.abseta(), weight);
	+ }
	+
	+ if (addJets.size() >= 2) {
	+ const Jet& j2 = addJets[1];
	+
	+ _hFull_addJet2Pt_abs ->fill(j2.pT()/GeV, weight);
	+ _hFull_addJet2Pt ->fill(j2.pT()/GeV, weight);
	+ _hFull_addJet2Eta_abs->fill(j2.abseta(), weight);
	+ _hFull_addJet2Eta ->fill(j2.abseta(), weight);
	+ if (isVisiblePS) {
	+ _hVis_addJet2Pt_abs ->fill(j2.pT()/GeV, weight);
	+ _hVis_addJet2Pt ->fill(j2.pT()/GeV, weight);
	+ _hVis_addJet2Eta_abs->fill(j2.abseta(), weight);
	+ _hVis_addJet2Eta ->fill(j2.abseta(), weight);
	+ }
	+
	+ const double jjmass = (j1.mom() + j2.mom()).mass();
	+ const double jjdR = deltaR(j1, j2);
	+ _hFull_addJJMass_abs->fill(jjmass/GeV, weight);
	+ _hFull_addJJMass ->fill(jjmass/GeV, weight);
	+ _hFull_addJJDR_abs ->fill(jjdR, weight);
	+ _hFull_addJJDR ->fill(jjdR, weight);
	+ if (isVisiblePS) {
	+ _hVis_addJJMass_abs->fill(jjmass/GeV, weight);
	+ _hVis_addJJMass ->fill(jjmass/GeV, weight);
	+ _hVis_addJJDR_abs ->fill(jjdR, weight);
	+ _hVis_addJJDR ->fill(jjdR, weight);
	+ }
	+ }
	+ }
	+
	+
	+ // Same set of plots if there are additional b-jets
	+ if (addBJets.size() >= 1) {
	+ const Jet& b1 = addBJets[0];
	+ _hFull_addBJet1Pt_abs ->fill(b1.pT()/GeV, weight);
	+ _hFull_addBJet1Pt ->fill(b1.pT()/GeV, weight);
	+ _hFull_addBJet1Eta_abs->fill(b1.abseta(), weight);
	+ _hFull_addBJet1Eta ->fill(b1.abseta(), weight);
	+ if (isVisiblePS) {
	+ _hVis_addBJet1Pt_abs ->fill(b1.pT()/GeV, weight);
	+ _hVis_addBJet1Pt ->fill(b1.pT()/GeV, weight);
	+ _hVis_addBJet1Eta_abs->fill(b1.abseta(), weight);
	+ _hVis_addBJet1Eta ->fill(b1.abseta(), weight);
	+ }
	+
	+ if (addBJets.size() >= 2) {
	+ const Jet& b2 = addBJets[1];
	+
	+ _hFull_addBJet2Pt_abs ->fill(b2.pT()/GeV, weight);
	+ _hFull_addBJet2Pt ->fill(b2.pT()/GeV, weight);
	+ _hFull_addBJet2Eta_abs->fill(b2.abseta(), weight);
	+ _hFull_addBJet2Eta ->fill(b2.abseta(), weight);
	+ if (isVisiblePS) {
	+ _hVis_addBJet2Pt_abs ->fill(b2.pT()/GeV, weight);
	+ _hVis_addBJet2Pt ->fill(b2.pT()/GeV, weight);
	+ _hVis_addBJet2Eta_abs->fill(b2.abseta(), weight);
	+ _hVis_addBJet2Eta ->fill(b2.abseta(), weight);
	+ }
	+
	+ const double bbmass = (b1.mom() + b2.mom()).mass();
	+ const double bbdR = deltaR(b1, b2);
	+ _hFull_addBBMass_abs->fill(bbmass/GeV, weight);
	+ _hFull_addBBMass ->fill(bbmass/GeV, weight);
	+ _hFull_addBBDR_abs ->fill(bbdR, weight);
	+ _hFull_addBBDR ->fill(bbdR, weight);
	+ if (isVisiblePS) {
	+ _hVis_addBBMass_abs->fill(bbmass/GeV, weight);
	+ _hVis_addBBMass ->fill(bbmass/GeV, weight);
	+ _hVis_addBBDR_abs ->fill(bbdR, weight);
	+ _hVis_addBBDR ->fill(bbdR, weight);
	+ }
	+ }
	+ }
	+
	+ }
	+
	+
	+ void finalize() {
	+ const double ttbarXS = !std::isnan(crossSectionPerEvent()) ? crossSection() : 252.89*picobarn;
	+ if (std::isnan(crossSectionPerEvent()))
	+ MSG_INFO("No valid cross-section given, using NNLO (arXiv:1303.6254; sqrt(s)=8 TeV, m_t=172.5 GeV): " << ttbarXS/picobarn << " pb");
	+
	+ normalize({_hVis_nJet30,_hVis_nJet60, _hVis_nJet100,
	+ _hVis_addJet1Pt, _hVis_addJet1Eta, _hVis_addJet2Pt, _hVis_addJet2Eta,
	+ _hVis_addJJMass, _hVis_addJJDR, _hVis_addJJHT,
	+ _hFull_addJet1Pt, _hFull_addJet1Eta, _hFull_addJet2Pt, _hFull_addJet2Eta,
	+ _hFull_addJJMass, _hFull_addJJDR, _hFull_addJJHT,
	+ _hVis_addBJet1Pt, _hVis_addBJet1Eta, _hVis_addBJet2Pt, _hVis_addBJet2Eta,
	+ _hVis_addBBMass, _hVis_addBBDR,
	+ _hFull_addBJet1Pt, _hFull_addBJet1Eta, _hFull_addBJet2Pt, _hFull_addBJet2Eta,
	+ _hFull_addBBMass, _hFull_addBBDR});
	+
	+ const double xsPerWeight = ttbarXS/picobarn / sumOfWeights();
	+ scale({_hVis_nJet30_abs, _hVis_nJet60_abs, _hVis_nJet100_abs,
	+ _hVis_addJet1Pt_abs, _hVis_addJet1Eta_abs, _hVis_addJet2Pt_abs, _hVis_addJet2Eta_abs,
	+ _hVis_addJJMass_abs, _hVis_addJJDR_abs, _hVis_addJJHT_abs,
	+ _hVis_addBJet1Pt_abs, _hVis_addBJet1Eta_abs, _hVis_addBJet2Pt_abs, _hVis_addBJet2Eta_abs,
	+ _hVis_addBBMass_abs, _hVis_addBBDR_abs}, xsPerWeight);
	+
	+ const double sfull = xsPerWeight / 0.0454; //< correct for dilepton branching fraction
	+ scale({_hFull_addJet1Pt_abs, _hFull_addJet1Eta_abs, _hFull_addJet2Pt_abs, _hFull_addJet2Eta_abs,
	+ _hFull_addJJMass_abs, _hFull_addJJDR_abs, _hFull_addJJHT_abs,
	+ _hFull_addBJet1Pt_abs, _hFull_addBJet1Eta_abs, _hFull_addBJet2Pt_abs, _hFull_addBJet2Eta_abs,
	+ _hFull_addBBMass_abs, _hFull_addBBDR_abs}, sfull);
	+ }
	+
	+ //@}
	+
	+
	+ void fillWithOF(Histo1DPtr h, double x, double w) {
	+ h->fill(std::min(x, h->xMax()-1e-9), w);
	+ }
	+
	+
	+ void fillGapFractions(const Jets& addJets, Profile1DPtr h_gap_addJet1Pt, Profile1DPtr h_gap_addJet2Pt, Profile1DPtr h_gap_addJetHT, double weight) {
	+ const double j1pt = (addJets.size() > 0) ? addJets[0].pT() : 0;
	+ for (size_t i = 0; i < h_gap_addJet1Pt->numBins(); ++i) {
	+ const double binCenter = h_gap_addJet1Pt->bin(i).xMid();
	+ h_gap_addJet1Pt->fillBin(i, int(j1pt/GeV < binCenter), weight);
	+ }
	+
	+ const double j2pt = (addJets.size() > 1) ? addJets[1].pT() : 0;
	+ for (size_t i = 0; i < h_gap_addJet2Pt->numBins(); ++i) {
	+ const double binCenter = h_gap_addJet2Pt->bin(i).xMid();
	+ h_gap_addJet2Pt->fillBin(i, int(j2pt/GeV < binCenter), weight);
	+ }
	+
	+ const double ht = sum(addJets, pT, 0.);
	+ for (size_t i = 0; i < h_gap_addJetHT->numBins(); ++i) {
	+ const double binCenter = h_gap_addJetHT->bin(i).xMid();
	+ h_gap_addJetHT->fillBin(i, int(ht/GeV < binCenter) , weight);
	+ }
	+ }
	+
	+
	+ // @name Histogram data members
	+ //@{
	+
	+ Histo1DPtr _hVis_nJet30_abs, _hVis_nJet60_abs, _hVis_nJet100_abs;
	+ Histo1DPtr _hVis_addJet1Pt_abs, _hVis_addJet1Eta_abs, _hVis_addJet2Pt_abs, _hVis_addJet2Eta_abs;
	+ Histo1DPtr _hVis_addJJMass_abs, _hVis_addJJDR_abs, _hVis_addJJHT_abs;
	+ Histo1DPtr _hFull_addJet1Pt_abs, _hFull_addJet1Eta_abs, _hFull_addJet2Pt_abs, _hFull_addJet2Eta_abs;
	+ Histo1DPtr _hFull_addJJMass_abs, _hFull_addJJDR_abs, _hFull_addJJHT_abs;
	+ Histo1DPtr _hVis_addBJet1Pt_abs, _hVis_addBJet1Eta_abs, _hVis_addBJet2Pt_abs, _hVis_addBJet2Eta_abs;
	+ Histo1DPtr _hVis_addBBMass_abs, _hVis_addBBDR_abs;
	+ Histo1DPtr _hFull_addBJet1Pt_abs, _hFull_addBJet1Eta_abs, _hFull_addBJet2Pt_abs, _hFull_addBJet2Eta_abs;
	+ Histo1DPtr _hFull_addBBMass_abs, _hFull_addBBDR_abs;
	+
	+ Histo1DPtr _hVis_nJet30, _hVis_nJet60, _hVis_nJet100;
	+ Histo1DPtr _hVis_addJet1Pt, _hVis_addJet1Eta, _hVis_addJet2Pt, _hVis_addJet2Eta;
	+ Histo1DPtr _hVis_addJJMass, _hVis_addJJDR, _hVis_addJJHT;
	+ Histo1DPtr _hFull_addJet1Pt, _hFull_addJet1Eta, _hFull_addJet2Pt, _hFull_addJet2Eta;
	+ Histo1DPtr _hFull_addJJMass, _hFull_addJJDR, _hFull_addJJHT;
	+ Histo1DPtr _hVis_addBJet1Pt, _hVis_addBJet1Eta, _hVis_addBJet2Pt, _hVis_addBJet2Eta;
	+ Histo1DPtr _hVis_addBBMass, _hVis_addBBDR;
	+ Histo1DPtr _hFull_addBJet1Pt, _hFull_addBJet1Eta, _hFull_addBJet2Pt, _hFull_addBJet2Eta;
	+ Histo1DPtr _hFull_addBBMass, _hFull_addBBDR;
	+
	+ Profile1DPtr _h_gap_addJet1Pt, _h_gap_addJet1Pt_eta0, _h_gap_addJet1Pt_eta1, _h_gap_addJet1Pt_eta2;
	+ Profile1DPtr _h_gap_addJet2Pt, _h_gap_addJet2Pt_eta0, _h_gap_addJet2Pt_eta1, _h_gap_addJet2Pt_eta2;
	+ Profile1DPtr _h_gap_addJetHT, _h_gap_addJetHT_eta0, _h_gap_addJetHT_eta1, _h_gap_addJetHT_eta2;
	+
	+ //@}
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(CMS_2015_I1397174);
	+
	+
	+}
	diff --git a/src/Analyses/CMS_2016_I1459051.cc b/src/Analyses/CMS_2016_I1459051.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/CMS_2016_I1459051.cc
	@@ -0,0 +1,95 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Tools/BinnedHistogram.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// Inclusive jet pT at 13 TeV
	+ class CMS_2016_I1459051 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2016_I1459051);
	+
	+
	+ /// Book histograms and initialize projections:
	+ void init() {
	+
	+ // Initialize the projections
	+ const FinalState fs;
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.4), "JetsAK4");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.7), "JetsAK7");
	+
	+ // Book sets of histograms, binned in absolute rapidity
	+ // AK7
	+ _hist_sigmaAK7.addHistogram(0.0, 0.5, bookHisto1D(1, 1, 1));
	+ _hist_sigmaAK7.addHistogram(0.5, 1.0, bookHisto1D(2, 1, 1));
	+ _hist_sigmaAK7.addHistogram(1.0, 1.5, bookHisto1D(3, 1, 1));
	+ _hist_sigmaAK7.addHistogram(1.5, 2.0, bookHisto1D(4, 1, 1));
	+ _hist_sigmaAK7.addHistogram(2.0, 2.5, bookHisto1D(5, 1, 1));
	+ _hist_sigmaAK7.addHistogram(2.5, 3.0, bookHisto1D(6, 1, 1));
	+ _hist_sigmaAK7Forward = bookHisto1D(7, 1, 1);
	+ // AK4
	+ _hist_sigmaAK4.addHistogram(0.0, 0.5, bookHisto1D(8, 1, 1));
	+ _hist_sigmaAK4.addHistogram(0.5, 1.0, bookHisto1D(9, 1, 1));
	+ _hist_sigmaAK4.addHistogram(1.0, 1.5, bookHisto1D(10, 1, 1));
	+ _hist_sigmaAK4.addHistogram(1.5, 2.0, bookHisto1D(11, 1, 1));
	+ _hist_sigmaAK4.addHistogram(2.0, 2.5, bookHisto1D(12, 1, 1));
	+ _hist_sigmaAK4.addHistogram(2.5, 3.0, bookHisto1D(13, 1, 1));
	+ _hist_sigmaAK4Forward = bookHisto1D(14, 1, 1);
	+
	+ }
	+
	+
	+ /// Per-event analysis
	+ void analyze(const Event &event) {
	+
	+ const double weight = event.weight();
	+
	+ // AK4 jets
	+ const FastJets& fjAK4 = applyProjection<FastJets>(event, "JetsAK4");
	+ const Jets& jetsAK4 = fjAK4.jets(Cuts::ptIn(114GeV, 2200.0GeV) && Cuts::absrap < 4.7);
	+ for (const Jet& j : jetsAK4) {
	+ _hist_sigmaAK4.fill(j.absrap(), j.pT(), weight);
	+ if (inRange(j.absrap(), 3.2, 4.7)) _hist_sigmaAK4Forward->fill(j.pT(), weight);
	+ }
	+
	+ // AK7 jets
	+ const FastJets& fjAK7 = applyProjection<FastJets>(event, "JetsAK7");
	+ const Jets& jetsAK7 = fjAK7.jets(Cuts::ptIn(114GeV, 2200.0GeV) && Cuts::absrap < 4.7);
	+ for (const Jet& j : jetsAK7) {
	+ _hist_sigmaAK7.fill(j.absrap(), j.pT(), weight);
	+ if (inRange(j.absrap(), 3.2, 4.7)) _hist_sigmaAK7Forward->fill(j.pT(), weight);
	+ }
	+
	+ }
	+
	+
	+ // Finalize
	+ void finalize() {
	+ /// @todo What is the cross-section unit?
	+ _hist_sigmaAK4.scale(crossSection()/sumOfWeights()/2.0, this);
	+ _hist_sigmaAK7.scale(crossSection()/sumOfWeights()/2.0, this);
	+ scale(_hist_sigmaAK4Forward,crossSection()/sumOfWeights()/3.0);
	+ scale(_hist_sigmaAK7Forward,crossSection()/sumOfWeights()/3.0);
	+ }
	+
	+
	+ /// @name Histograms
	+ //@{
	+ BinnedHistogram<double> _hist_sigmaAK4;
	+ BinnedHistogram<double> _hist_sigmaAK7;
	+ Histo1DPtr _hist_sigmaAK4Forward;
	+ Histo1DPtr _hist_sigmaAK7Forward;
	+ //@}
	+
	+ };
	+
	+
	+ // This global object acts as a hook for the plugin system.
	+ DECLARE_RIVET_PLUGIN(CMS_2016_I1459051);
	+
	+}
	diff --git a/src/Analyses/CMS_2016_I1473674.cc b/src/Analyses/CMS_2016_I1473674.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/CMS_2016_I1473674.cc
	@@ -0,0 +1,141 @@
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Tools/Logging.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/TauFinder.hh"
	+#include "Rivet/Projections/DressedLeptons.hh"
	+#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/VetoedFinalState.hh"
	+#include "Rivet/Projections/InvMassFinalState.hh"
	+#include "Rivet/Projections/MissingMomentum.hh"
	+#include "Rivet/Tools/ParticleIdUtils.hh"
	+
	+namespace Rivet {
	+
	+ class CMS_2016_I1473674 : public Analysis {
	+ public:
	+
	+ // Minimal constructor
	+ CMS_2016_I1473674() : Analysis("CMS_2016_I1473674") {
	+ }
	+
	+ // Set up projections and book histograms
	+ void init() {
	+ // Complete final state
	+ FinalState fs(-MAXDOUBLE, MAXDOUBLE, 0*GeV);
	+
	+ // Projection for taus
	+ TauFinder taus(TauFinder::ANY);
	+ addProjection(taus, "Tau");
	+ IdentifiedFinalState nu_taus(fs);
	+ nu_taus.acceptIdPair(PID::NU_TAU);
	+ addProjection(nu_taus, "NuTau");
	+
	+ // Projection for electrons and muons
	+ IdentifiedFinalState photons(fs);
	+ photons.acceptIdPair(PID::PHOTON);
	+
	+ IdentifiedFinalState el_id(fs);
	+ el_id.acceptIdPair(PID::ELECTRON);
	+ PromptFinalState electrons(el_id);
	+ addProjection(electrons, "Electrons");
	+ DressedLeptons dressed_electrons(photons, electrons, 0.1, Cuts::open(), true, false);
	+ addProjection(dressed_electrons, "DressedElectrons");
	+
	+ IdentifiedFinalState mu_id(fs);
	+ mu_id.acceptIdPair(PID::MUON);
	+ PromptFinalState muons(mu_id);
	+ addProjection(muons, "Muons");
	+ DressedLeptons dressed_muons(photons, muons, 0.1, Cuts::open(), true, false);
	+ addProjection(dressed_muons, "DressedMuons");
	+
	+ // Projection for jets
	+ VetoedFinalState fs_jets(FinalState(-MAXDOUBLE, MAXDOUBLE, 0*GeV));
	+ fs_jets.addVetoOnThisFinalState(dressed_muons);
	+ addProjection(FastJets(fs_jets, FastJets::ANTIKT, 0.5), "Jets");
	+
	+ // Projections for MET
	+ addProjection(MissingMomentum(), "MET");
	+
	+ // Booking of histograms
	+ _hist_met = bookHisto1D(5, 1, 1);
	+ _hist_ht = bookHisto1D(6, 1, 1);
	+ _hist_st = bookHisto1D(7, 1, 1);
	+ _hist_wpt = bookHisto1D(8, 1, 1);
	+ }
	+
	+
	+ // per event analysis
	+ void analyze(const Event& event) {
	+ const double weight = event.weight();
	+
	+ // select ttbar -> lepton+jets
	+ const DressedLeptons& dressed_electrons = applyProjection<DressedLeptons>(event, "DressedElectrons");
	+ const DressedLeptons& dressed_muons = applyProjection<DressedLeptons>(event, "DressedMuons");
	+ if (dressed_electrons.dressedLeptons().size() +
	+ dressed_muons.dressedLeptons().size() != 1) {
	+ vetoEvent;
	+ }
	+
	+ FourMomentum lepton;
	+ if (dressed_electrons.dressedLeptons().size() == 1) {
	+ lepton = dressed_electrons.dressedLeptons()[0].momentum();
	+ } else {
	+ lepton = dressed_muons.dressedLeptons()[0].momentum();
	+ }
	+
	+ // veto if lepton is tau
	+ const TauFinder& taus = applyProjection<TauFinder>(event, "Tau");
	+ const IdentifiedFinalState nu_taus = applyProjection<IdentifiedFinalState>(event, "NuTau");
	+ foreach (const Particle& tau, taus.taus()) {
	+ foreach (const Particle& nu, nu_taus.particles()) {
	+ if (tau.pid() * nu.pid() < 0)
	+ continue;
	+
	+ const FourMomentum w_candidate = tau.momentum() + nu.momentum();
	+ if (abs(w_candidate.mass() - 80.4) > 5.)
	+ vetoEvent;
	+ }
	+ }
	+
	+
	+ // MET
	+ const MissingMomentum& met = applyProjection<MissingMomentum>(event, "MET");
	+ _hist_met->fill(met.visibleMomentum().pT()/GeV, weight);
	+
	+ // HT and ST
	+ const FastJets& jetpro = applyProjection<FastJets>(event, "Jets");
	+ const Jets jets = jetpro.jetsByPt(20*GeV);
	+
	+ double ht = 0.0;
	+ foreach (const Jet& j, jets) {
	+ if (deltaR(j.momentum(), lepton) > 0.3) {
	+ ht += j.pT();
	+ }
	+ }
	+
	+ double st = ht + lepton.pT() + met.visibleMomentum().pT();
	+ _hist_ht->fill(ht/GeV, weight);
	+ _hist_st->fill(st/GeV, weight);
	+
	+ // WPT
	+ FourMomentum w = lepton - met.visibleMomentum();
	+ _hist_wpt->fill(w.pT()/GeV, weight);
	+ }
	+
	+ // scale by 1 over weight
	+ void finalize() {
	+ normalize(_hist_met);
	+ normalize(_hist_ht);
	+ normalize(_hist_st);
	+ normalize(_hist_wpt);
	+ }
	+
	+ private:
	+ Histo1DPtr _hist_met, _hist_ht, _hist_st, _hist_wpt;
	+ };
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(CMS_2016_I1473674);
	+}
	diff --git a/src/Analyses/CMS_2016_PAS_SUS_16_14.cc b/src/Analyses/CMS_2016_PAS_SUS_16_14.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/CMS_2016_PAS_SUS_16_14.cc
	@@ -0,0 +1,201 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/PromptFinalState.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+#include "Rivet/Projections/Sphericity.hh"
	+#include "Rivet/Projections/SmearedParticles.hh"
	+#include "Rivet/Projections/SmearedJets.hh"
	+#include "Rivet/Projections/SmearedMET.hh"
	+#include "Rivet/Tools/Cutflow.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief CMS 2016 0-lepton SUSY search, from 13/fb PAS note
	+ class CMS_2016_PAS_SUS_16_14 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(CMS_2016_PAS_SUS_16_14);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ FinalState calofs(Cuts::abseta < 5.0);
	+ FastJets fj(calofs, FastJets::ANTIKT, 0.4);
	+ declare(fj, "TruthJets");
	+ declare(SmearedJets(fj, JET_SMEAR_CMS_RUN2, [](const Jet& j) {
	+ if (j.abseta() > 2.5) return 0.;
	+ return j.bTagged() ? 0.55 : j.cTagged() ? 0.12 : 0.016; }), "Jets");
	+
	+ FinalState es(Cuts::abspid == PID::ELECTRON && Cuts::abseta < 2.5);
	+ declare(es, "TruthElectrons");
	+ declare(SmearedParticles(es, ELECTRON_EFF_CMS_RUN2, ELECTRON_SMEAR_CMS_RUN2), "Electrons");
	+
	+ FinalState mus(Cuts::abspid == PID::MUON && Cuts::abseta < 2.4);
	+ declare(mus, "TruthMuons");
	+ declare(SmearedParticles(mus, MUON_EFF_CMS_RUN2, MUON_SMEAR_CMS_RUN2), "Muons");
	+
	+ FinalState isofs(Cuts::abseta < 3.0 && Cuts::abspid != PID::ELECTRON && Cuts::abspid != PID::MUON);
	+ declare(isofs, "IsoFS");
	+ FinalState cfs(Cuts::abseta < 2.5 && Cuts::abscharge != 0);
	+ declare(cfs, "TruthTracks");
	+ declare(SmearedParticles(cfs, TRK_EFF_CMS_RUN2), "Tracks");
	+
	+ // Book histograms/counters
	+ _h_srcounts.resize(160);
	+ for (size_t ij = 0; ij < 4; ++ij) {
	+ for (size_t ib = 0; ib < 4; ++ib) {
	+ for (size_t ih = 0; ih < 10; ++ih) {
	+ const size_t i = 40ij + 10ib + ih;
	+ _h_srcounts[i] = bookCounter(toString(2*ij+3) + "j-" + toString(ib) + "b-" + toString(ih));
	+ }
	+ }
	+ }
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get jets and require Nj >= 3
	+ const Jets jets24 = apply<JetAlg>(event, "Jets").jetsByPt(Cuts::pT > 30*GeV && Cuts::abseta < 2.4);
	+ if (jets24.size() < 3) vetoEvent;
	+
	+ // HT cut
	+ vector<double> jetpts24; transform(jets24, jetpts24, pT);
	+ const double ht = sum(jetpts24, 0.0);
	+ if (ht < 300*GeV) vetoEvent;
	+
	+ // HTmiss cut
	+ const Jets jets50 = apply<JetAlg>(event, "Jets").jetsByPt(Cuts::pT > 30*GeV && Cuts::abseta < 5.0);
	+ const FourMomentum htmissvec = -sum(jets24, mom, FourMomentum());
	+ const double htmiss = htmissvec.pT();
	+ if (htmissvec.pT() < 300*GeV) vetoEvent;
	+
	+
	+ // Get baseline electrons & muons
	+ Particles elecs = apply<ParticleFinder>(event, "Electrons").particles(Cuts::pT > 10*GeV);
	+ Particles muons = apply<ParticleFinder>(event, "Muons").particles(Cuts::pT > 10*GeV);
	+
	+ // Electron/muon isolation
	+ const Particles calofs = apply<ParticleFinder>(event, "IsoFS").particles();
	+ ifilter_discard(elecs, [&](const Particle& e) {
	+ const double R = max(0.05, min(0.2, 10*GeV/e.pT()));
	+ double ptsum = -e.pT();
	+ for (const Particle& p : calofs)
	+ if (deltaR(p,e) < R) ptsum += p.pT();
	+ return ptsum / e.pT() > 0.1;
	+ });
	+ ifilter_discard(muons, [&](const Particle& m) {
	+ const double R = max(0.05, min(0.2, 10*GeV/m.pT()));
	+ double ptsum = -m.pT();
	+ for (const Particle& p : calofs)
	+ if (deltaR(p,m) < R) ptsum += p.pT();
	+ return ptsum / m.pT() > 0.2;
	+ });
	+
	+ // Veto the event if there are any remaining baseline leptons
	+ if (!elecs.empty()) vetoEvent;
	+ if (!muons.empty()) vetoEvent;
	+
	+
	+ // Get isolated tracks
	+ Particles trks25 = apply<ParticleFinder>(event, "Tracks").particles();
	+ ifilter_discard(trks25, [&](const Particle& t) {
	+ double ptsum = -t.pT();
	+ for (const Particle& p : trks25)
	+ if (deltaR(p,t) < 0.3) ptsum += p.pT();
	+ return ptsum/t.pT() > ((t.abspid() == PID::ELECTRON \|\| t.abspid() == PID::MUON) ? 0.2 : 0.1);
	+ });
	+ const Particles trks = filter_select(trks25, Cuts::abseta < 2.4);
	+
	+ // Isolated track pT, pTmiss and mT cut
	+ // mT^2 = m1^2 + m2^2 + 2(ET1 ET2 - pT1 . pT2))
	+ // => mT0^2 = 2(ET1 \|pT2\| - pT1 . pT2)) for m1, m2 -> 0
	+ FourMomentum ptmissvec = htmissvec; ///< @todo Can we do better? No e,mu left...
	+ const double ptmiss = ptmissvec.pT();
	+ for (const Particle& t : trks) {
	+ const double ptcut = (t.abspid() == PID::ELECTRON \|\| t.abspid() == PID::MUON) ? 5GeV : 10GeV;
	+ const double mT = sqrt( t.mass2() + 2(t.Et()ptmiss - t.pT()ptmisscos(deltaPhi(t,ptmissvec))) );
	+ if (mT < 100*GeV && t.pT() < ptcut) vetoEvent;
	+ }
	+
	+ // Lead jets isolation from Htmiss
	+ if (deltaPhi(htmissvec, jets24[0]) < 0.5) vetoEvent;
	+ if (deltaPhi(htmissvec, jets24[1]) < 0.5) vetoEvent;
	+ if (deltaPhi(htmissvec, jets24[2]) < 0.3) vetoEvent;
	+ if (jets24.size() >= 4 && deltaPhi(htmissvec, jets24[3]) < 0.3) vetoEvent;
	+
	+
	+ ////////
	+
	+
	+ // Calculate a bin index for this event
	+ // Nj bin
	+ static const vector<double> njedges = {3., 5., 7., 9.};
	+ const size_t nj = jets24.size();
	+ // Nbj bin
	+ static const vector<double> njbedges = {0., 1., 2., 3.};
	+ const size_t inj = binIndex(nj, njedges, true);
	+ size_t nbj = 0;
	+ for (const Jet& j : jets24)
	+ if (j.bTagged()) nbj += 1;
	+ const size_t inbj = binIndex(nbj, njbedges, true);
	+ // HTmiss vs HT 2D bin
	+ int iht = 0;
	+ if (htmiss < 350*GeV) {
	+ iht = ht < 500 ? 1 : ht < 1000 ? 2 : 3;
	+ } if (htmiss < 500GeV && ht > 350GeV) {
	+ iht = ht < 500 ? 4 : ht < 1000 ? 5 : 6;
	+ } if (htmiss < 750GeV && ht > 500GeV) {
	+ iht = ht < 1000 ? 7 : 8;
	+ } if (ht > 750*GeV) {
	+ iht = ht < 1500 ? 9 : 10;
	+ }
	+ if (iht == 0) vetoEvent;
	+ iht -= 1; //< change from the paper's indexing scheme to C++ zero-indexed
	+ // Total bin number
	+ const size_t ibin = 40inj + 10inbj + (size_t)iht;
	+
	+ // Fill SR counter
	+ _h_srcounts[ibin]->fill(event.weight());
	+
	+ }
	+
	+
	+ /// Normalise counters after the run
	+ void finalize() {
	+
	+ const double sf = 12.9*crossSection()/femtobarn/sumOfWeights();
	+ scale(_h_srcounts, sf);
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ vector<CounterPtr> _h_srcounts;
	+ //@}
	+
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(CMS_2016_PAS_SUS_16_14);
	+
	+
	+}
	diff --git a/src/Analyses/D0_1995_I398175.cc b/src/Analyses/D0_1995_I398175.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/D0_1995_I398175.cc
	@@ -0,0 +1,137 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/JetShape.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief D0 Run-1 jet shapes measurement
	+ class D0_1995_I398175 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(D0_1995_I398175);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ const FinalState fs(-4.0, 4.0);
	+ declare(fs, "FS");
	+ // FastJets jets(fs, FastJets::ANTIKT, 0.6);
	+ FastJets jets(fs, FastJets::D0ILCONE, 1.0);
	+ jets.useInvisibles();
	+ declare(jets, "Jets");
	+
	+
	+ // Specify jets pT bins
	+ _ptedges = {{ 45.0, 70.0, 105.0, 140.0, 1800.0}};
	+
	+ // Book histograms
	+ for (size_t ptbin = 0; ptbin < 4; ++ptbin) {
	+ _jsnames_pT[ptbin] = "JetShape" + to_str(ptbin) ;
	+ const JetShape jsp(jets, 0.0, 1.0, 10, _ptedges[ptbin], _ptedges[ptbin+1], 0.0, 0.2, PSEUDORAPIDITY);
	+ declare(jsp, _jsnames_pT[ptbin]);
	+ _h_Rho_pT_central[ptbin] = bookProfile1D(ptbin+1, 1, 1);
	+ }
	+
	+ const JetShape jspfwd0(jets, 0.0, 1.0, 10, 45, 70, 2.5, 3.5, PSEUDORAPIDITY);
	+ declare(jspfwd0, "JetShapeFwd0");
	+ const JetShape jspfwd1(jets, 0.0, 1.0, 10, 70, 105, 2.5, 3.5, PSEUDORAPIDITY);
	+ declare(jspfwd1, "JetShapeFwd1");
	+ _h_Rho_pT_forward[0] = bookProfile1D(5, 1, 1);
	+ _h_Rho_pT_forward[1] = bookProfile1D(6, 1, 1);
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get jets and require at least one to pass pT and y cuts
	+ const Jets jets = apply<FastJets>(event, "Jets").jetsByPt(Cuts::ptIn(_ptedges.front()GeV, _ptedges.back()GeV) );
	+ MSG_DEBUG("Selecting jets with pT> "<<_ptedges.front());
	+ MSG_DEBUG("Jet multiplicity before cuts = " << jets.size());
	+ if (jets.size() == 0){
	+ MSG_DEBUG("No jets found in required pT and rapidity range");
	+ vetoEvent;
	+ }
	+ const double weight = event.weight();
	+
	+ // Calculate and histogram jet shapes
	+ for (size_t ipt = 0; ipt < 4; ++ipt) {
	+ const JetShape& jsipt = apply<JetShape>(event, _jsnames_pT[ipt]);
	+ for (size_t ijet = 0; ijet < jsipt.numJets(); ++ijet) {
	+ for (size_t rbin = 0; rbin < jsipt.numBins(); ++rbin) {
	+ const double r_rho = jsipt.rBinMid(rbin);
	+ MSG_DEBUG(ipt << " " << rbin << " (" << r_rho << ") " << jsipt.diffJetShape(ijet, rbin));
	+ /// @note Bin width Jacobian factor of 0.7/0.1 = 7 in the differential shapes plot
	+ // _profhistRho_pT[ipt]->fill(r_rho/0.7, (0.7/0.1)*jsipt.diffJetShape(ijet, rbin), weight);
	+ const double r_Psi = jsipt.rBinMax(rbin);
	+ MSG_DEBUG(ipt << " " << rbin << " (" << r_rho << ") " << jsipt.intJetShape(ijet, rbin));
	+ _h_Rho_pT_central[ipt]->fill(r_Psi/1.0, jsipt.intJetShape(ijet, rbin), weight);
	+ }
	+ }
	+ }
	+
	+
	+ const JetShape& jsiptfwd0 = apply<JetShape>(event, "JetShapeFwd0");
	+ for (size_t ijet = 0; ijet < jsiptfwd0.numJets(); ++ijet) {
	+ for (size_t rbin = 0; rbin < jsiptfwd0.numBins(); ++rbin) {
	+ const double r_Psi = jsiptfwd0.rBinMax(rbin);
	+ _h_Rho_pT_forward[0]->fill(r_Psi/1.0, jsiptfwd0.intJetShape(ijet, rbin), weight);
	+ }
	+ }
	+
	+ const JetShape& jsiptfwd1 = apply<JetShape>(event, "JetShapeFwd1");
	+ for (size_t ijet = 0; ijet < jsiptfwd1.numJets(); ++ijet) {
	+ for (size_t rbin = 0; rbin < jsiptfwd1.numBins(); ++rbin) {
	+ const double r_Psi = jsiptfwd1.rBinMax(rbin);
	+ _h_Rho_pT_forward[1]->fill(r_Psi/1.0, jsiptfwd1.intJetShape(ijet, rbin), weight);
	+ }
	+ }
	+
	+
	+
	+
	+
	+ }
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+
	+ // scale(_h_YYYY, crossSection()/sumOfWeights()); // norm to cross section
	+ // normalize(_h_YYYY); // normalize to unity
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+
	+ vector<double> _ptedges;
	+ string _jsnames_pT[4];
	+ /// @name Histograms
	+ //@{
	+ Profile1DPtr _h_Rho_pT_central[4];
	+ Profile1DPtr _h_Rho_pT_forward[2];
	+
	+ //@}
	+
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(D0_1995_I398175);
	+
	+
	+}
	diff --git a/src/Analyses/D0_1996_S3214044.cc b/src/Analyses/D0_1996_S3214044.cc
	--- a/src/Analyses/D0_1996_S3214044.cc
	+++ b/src/Analyses/D0_1996_S3214044.cc
	@@ -1,268 +1,267 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Math/LorentzTrans.hh"
	-#include "Rivet/Math/Vector3.hh"
	-#include "Rivet/Math/Units.hh"

	namespace Rivet {


	/// @brief D0 topological distributions of 3- and 4-jet events.
	class D0_1996_S3214044 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	D0_1996_S3214044() : Analysis("D0_1996_S3214044")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	const FinalState fs;
	- addProjection(fs, "FS");
	- /// @todo Use correct jet algorithm
	- addProjection(FastJets(fs, FastJets::D0ILCONE, 0.7), "ConeJets");
	+ declare(fs, "FS");
	+ /// @todo Use correct jet algorithm --- tried FJ3 D0RunICone but does
	+ // not look as good as the Run2 cone alg used here
	+ declare(FastJets(fs, FastJets::D0ILCONE, 0.7), "ConeJets");

	_h_3j_x3 = bookHisto1D(1, 1, 1);
	_h_3j_x5 = bookHisto1D(2, 1, 1);
	_h_3j_costheta3 = bookHisto1D(3, 1, 1);
	_h_3j_psi = bookHisto1D(4, 1, 1);
	_h_3j_mu34 = bookHisto1D(5, 1, 1);
	_h_3j_mu35 = bookHisto1D(6, 1, 1);
	_h_3j_mu45 = bookHisto1D(7, 1, 1);

	_h_4j_x3 = bookHisto1D(8, 1, 1);
	_h_4j_x4 = bookHisto1D(9, 1, 1);
	_h_4j_x5 = bookHisto1D(10, 1, 1);
	_h_4j_x6 = bookHisto1D(11, 1, 1);
	_h_4j_costheta3 = bookHisto1D(12, 1, 1);
	_h_4j_costheta4 = bookHisto1D(13, 1, 1);
	_h_4j_costheta5 = bookHisto1D(14, 1, 1);
	_h_4j_costheta6 = bookHisto1D(15, 1, 1);
	_h_4j_cosomega34 = bookHisto1D(16, 1, 1);
	_h_4j_cosomega35 = bookHisto1D(17, 1, 1);
	_h_4j_cosomega36 = bookHisto1D(18, 1, 1);
	_h_4j_cosomega45 = bookHisto1D(19, 1, 1);
	_h_4j_cosomega46 = bookHisto1D(20, 1, 1);
	_h_4j_cosomega56 = bookHisto1D(21, 1, 1);
	_h_4j_mu34 = bookHisto1D(22, 1, 1);
	_h_4j_mu35 = bookHisto1D(23, 1, 1);
	_h_4j_mu36 = bookHisto1D(24, 1, 1);
	_h_4j_mu45 = bookHisto1D(25, 1, 1);
	_h_4j_mu46 = bookHisto1D(26, 1, 1);
	_h_4j_mu56 = bookHisto1D(27, 1, 1);
	_h_4j_theta_BZ = bookHisto1D(28, 1, 1);
	_h_4j_costheta_NR = bookHisto1D(29, 1, 1);

	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- Jets jets_in = applyProjection<FastJets>(event, "ConeJets")
	- .jets(cmpMomByEt, Cuts::pT > 20*GeV && Cuts::abseta < 3);
	+ Jets jets_in = apply<FastJets>(event, "ConeJets")
	+ .jets(Cuts::Et > 20*GeV && Cuts::abseta < 3, cmpMomByEt);

	Jets jets_isolated;
	for (size_t i = 0; i < jets_in.size(); ++i) {
	bool isolated = true;
	for (size_t j = 0; j < jets_in.size(); ++j) {
	if (i != j && deltaR(jets_in[i], jets_in[j]) < 1.4) {
	isolated = false;
	break;
	}
	}
	if (isolated) jets_isolated.push_back(jets_in[i]);
	}

	if (jets_isolated.size() == 0 \|\| jets_isolated[0].Et() < 60.0*GeV) vetoEvent;

	if (jets_isolated.size() > 2) _threeJetAnalysis(jets_isolated, weight);
	if (jets_isolated.size() > 3) _fourJetAnalysis(jets_isolated, weight);
	}


	void finalize() {
	normalize(_h_3j_x3, 1.0);
	normalize(_h_3j_x5, 1.0);
	normalize(_h_3j_costheta3, 1.0);
	normalize(_h_3j_psi, 1.0);
	normalize(_h_3j_mu34, 1.0);
	normalize(_h_3j_mu35, 1.0);
	normalize(_h_3j_mu45, 1.0);
	normalize(_h_4j_x3, 1.0);
	normalize(_h_4j_x4, 1.0);
	normalize(_h_4j_x5, 1.0);
	normalize(_h_4j_x6, 1.0);
	normalize(_h_4j_costheta3, 1.0);
	normalize(_h_4j_costheta4, 1.0);
	normalize(_h_4j_costheta5, 1.0);
	normalize(_h_4j_costheta6, 1.0);
	normalize(_h_4j_cosomega34, 1.0);
	normalize(_h_4j_cosomega35, 1.0);
	normalize(_h_4j_cosomega36, 1.0);
	normalize(_h_4j_cosomega45, 1.0);
	normalize(_h_4j_cosomega46, 1.0);
	normalize(_h_4j_cosomega56, 1.0);
	normalize(_h_4j_mu34, 1.0);
	normalize(_h_4j_mu35, 1.0);
	normalize(_h_4j_mu36, 1.0);
	normalize(_h_4j_mu45, 1.0);
	normalize(_h_4j_mu46, 1.0);
	normalize(_h_4j_mu56, 1.0);
	normalize(_h_4j_theta_BZ, 1.0);
	normalize(_h_4j_costheta_NR, 1.0);
	}

	//@}


	private:

	/// @name Helper functions
	//@{

	void _threeJetAnalysis(const Jets& jets, const double& weight) {
	// >=3 jet events
	FourMomentum jjj(jets[0].momentum()+jets[1].momentum()+jets[2].momentum());
	const double sqrts = _safeMass(jjj);
	if (sqrts<200*GeV) {
	return;
	}

	- LorentzTransform cms_boost(-jjj.boostVector());
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(jjj.betaVec());
	vector<FourMomentum> jets_boosted;
	foreach (Jet jet, jets) {
	jets_boosted.push_back(cms_boost.transform(jet.momentum()));
	}
	std::sort(jets_boosted.begin(), jets_boosted.end(), FourMomentum::byEDescending());
	FourMomentum p3(jets_boosted[0]);
	FourMomentum p4(jets_boosted[1]);
	FourMomentum p5(jets_boosted[2]);

	Vector3 beam1(0.0, 0.0, 1.0);
	Vector3 p1xp3 = beam1.cross(p3.p3());
	Vector3 p4xp5 = p4.p3().cross(p5.p3());
	const double cospsi = p1xp3.dot(p4xp5)/p1xp3.mod()/p4xp5.mod();

	_h_3j_x3->fill(2.0*p3.E()/sqrts, weight);
	_h_3j_x5->fill(2.0*p5.E()/sqrts, weight);
	_h_3j_costheta3->fill(fabs(cos(p3.theta())), weight);
	_h_3j_psi->fill(acos(cospsi)/degree, weight);
	_h_3j_mu34->fill(_safeMass(FourMomentum(p3+p4))/sqrts, weight);
	_h_3j_mu35->fill(_safeMass(FourMomentum(p3+p5))/sqrts, weight);
	_h_3j_mu45->fill(_safeMass(FourMomentum(p4+p5))/sqrts, weight);
	}


	void _fourJetAnalysis(const Jets& jets, const double& weight) {
	// >=4 jet events
	FourMomentum jjjj(jets[0].momentum() + jets[1].momentum() + jets[2].momentum()+ jets[3].momentum());
	const double sqrts = _safeMass(jjjj);
	if (sqrts < 200*GeV) return;

	- LorentzTransform cms_boost(-jjjj.boostVector());
	+ const LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(jjjj.betaVec());
	vector<FourMomentum> jets_boosted;
	foreach (Jet jet, jets) {
	jets_boosted.push_back(cms_boost.transform(jet.momentum()));
	}
	sort(jets_boosted.begin(), jets_boosted.end(), FourMomentum::byEDescending());
	FourMomentum p3(jets_boosted[0]);
	FourMomentum p4(jets_boosted[1]);
	FourMomentum p5(jets_boosted[2]);
	FourMomentum p6(jets_boosted[3]);

	Vector3 p3xp4 = p3.p3().cross(p4.p3());
	Vector3 p5xp6 = p5.p3().cross(p6.p3());
	const double costheta_BZ = p3xp4.dot(p5xp6)/p3xp4.mod()/p5xp6.mod();
	const double costheta_NR = (p3.p3()-p4.p3()).dot(p5.p3()-p6.p3())/
	(p3.p3()-p4.p3()).mod()/(p5.p3()-p6.p3()).mod();

	_h_4j_x3->fill(2.0*p3.E()/sqrts, weight);
	_h_4j_x4->fill(2.0*p4.E()/sqrts, weight);
	_h_4j_x5->fill(2.0*p5.E()/sqrts, weight);
	_h_4j_x6->fill(2.0*p6.E()/sqrts, weight);
	_h_4j_costheta3->fill(fabs(cos(p3.theta())), weight);
	_h_4j_costheta4->fill(fabs(cos(p4.theta())), weight);
	_h_4j_costheta5->fill(fabs(cos(p5.theta())), weight);
	_h_4j_costheta6->fill(fabs(cos(p6.theta())), weight);
	_h_4j_cosomega34->fill(cos(p3.angle(p4)), weight);
	_h_4j_cosomega35->fill(cos(p3.angle(p5)), weight);
	_h_4j_cosomega36->fill(cos(p3.angle(p6)), weight);
	_h_4j_cosomega45->fill(cos(p4.angle(p5)), weight);
	_h_4j_cosomega46->fill(cos(p4.angle(p6)), weight);
	_h_4j_cosomega56->fill(cos(p5.angle(p6)), weight);
	_h_4j_mu34->fill(_safeMass(FourMomentum(p3+p4))/sqrts, weight);
	_h_4j_mu35->fill(_safeMass(FourMomentum(p3+p5))/sqrts, weight);
	_h_4j_mu36->fill(_safeMass(FourMomentum(p3+p6))/sqrts, weight);
	_h_4j_mu45->fill(_safeMass(FourMomentum(p4+p5))/sqrts, weight);
	_h_4j_mu46->fill(_safeMass(FourMomentum(p4+p6))/sqrts, weight);
	_h_4j_mu56->fill(_safeMass(FourMomentum(p5+p6))/sqrts, weight);
	- _h_4j_theta_BZ->fill(acos(costheta_BZ)/degree, weight);
	- _h_4j_costheta_NR->fill(costheta_NR, weight);
	+ _h_4j_theta_BZ->fill(acos(fabs(costheta_BZ))/degree, weight);
	+ _h_4j_costheta_NR->fill(fabs(costheta_NR), weight);

	}

	double _safeMass(const FourMomentum& p) {
	double mass2=p.mass2();
	if (mass2>0.0) return sqrt(mass2);
	else if (mass2<-1.0e-5) {
	MSG_WARNING("m2 = " << m2 << ". Assuming m2=0.");
	return 0.0;
	}
	else return 0.0;
	}

	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_3j_x3;
	Histo1DPtr _h_3j_x5;
	Histo1DPtr _h_3j_costheta3;
	Histo1DPtr _h_3j_psi;
	Histo1DPtr _h_3j_mu34;
	Histo1DPtr _h_3j_mu35;
	Histo1DPtr _h_3j_mu45;

	Histo1DPtr _h_4j_x3;
	Histo1DPtr _h_4j_x4;
	Histo1DPtr _h_4j_x5;
	Histo1DPtr _h_4j_x6;
	Histo1DPtr _h_4j_costheta3;
	Histo1DPtr _h_4j_costheta4;
	Histo1DPtr _h_4j_costheta5;
	Histo1DPtr _h_4j_costheta6;
	Histo1DPtr _h_4j_cosomega34;
	Histo1DPtr _h_4j_cosomega35;
	Histo1DPtr _h_4j_cosomega36;
	Histo1DPtr _h_4j_cosomega45;
	Histo1DPtr _h_4j_cosomega46;
	Histo1DPtr _h_4j_cosomega56;
	Histo1DPtr _h_4j_mu34;
	Histo1DPtr _h_4j_mu35;
	Histo1DPtr _h_4j_mu36;
	Histo1DPtr _h_4j_mu45;
	Histo1DPtr _h_4j_mu46;
	Histo1DPtr _h_4j_mu56;
	Histo1DPtr _h_4j_theta_BZ;
	Histo1DPtr _h_4j_costheta_NR;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_1996_S3214044);

	}
	diff --git a/src/Analyses/D0_1996_S3324664.cc b/src/Analyses/D0_1996_S3324664.cc
	--- a/src/Analyses/D0_1996_S3324664.cc
	+++ b/src/Analyses/D0_1996_S3324664.cc
	@@ -1,108 +1,102 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief D0 azimuthal correlation of jets widely separated in rapidity
	class D0_1996_S3324664 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	D0_1996_S3324664() : Analysis("D0_1996_S3324664")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	const FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	/// @todo Use correct jet algorithm
	- addProjection(FastJets(fs, FastJets::D0ILCONE, 0.7), "ConeJets");
	+ declare(FastJets(fs, FastJets::D0ILCONE, 0.7), "ConeJets");

	_h_deta = bookHisto1D(1, 1, 1);
	_h_dphi.addHistogram(0.0, 2.0, bookHisto1D(2, 1, 1));
	_h_dphi.addHistogram(2.0, 4.0, bookHisto1D(2, 1, 2));
	_h_dphi.addHistogram(4.0, 6.0, bookHisto1D(2, 1, 3));
	_h_cosdphi_deta = bookProfile1D(3, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	-
	- Jets jets;
	- foreach (const Jet& jet, applyProjection<FastJets>(event, "ConeJets").jets(Cuts::pT > 20*GeV)) {
	- if (jet.abseta() < 3.0) jets.push_back(jet);
	- }
	+ Jets jets = apply<FastJets>(event, "ConeJets").jets(Cuts::Et > 20*GeV && Cuts::abseta<3, cmpMomByEt);

	if (jets.size() < 2) vetoEvent;

	FourMomentum minjet = jets[0].momentum();
	FourMomentum maxjet = jets[1].momentum();
	double mineta = minjet.eta();
	double maxeta = maxjet.eta();

	foreach (const Jet& jet, jets) {
	double eta = jet.eta();
	if (eta < mineta) {
	minjet = jet.momentum();
	mineta = eta;
	} else if (eta > maxeta) {
	maxjet = jet.momentum();
	maxeta = eta;
	}
	}

	if (minjet.Et() < 50GeV && maxjet.Et() < 50.0GeV) vetoEvent;

	double deta = maxjet.eta()-minjet.eta();
	double dphi = mapAngle0To2Pi(maxjet.phi()-minjet.phi());

	_h_deta->fill(deta, weight);
	_h_dphi.fill(deta, 1.0-dphi/M_PI, weight);
	_h_cosdphi_deta->fill(deta, cos(M_PI-dphi), weight);
	}


	void finalize() {
	// Normalised to #events
	- normalize(_h_deta, 8830.0); // fixed norm OK
	+ normalize(_h_deta, 8830.); // fixed norm OK

	- // I have no idea what this is normalised to... in the paper it says unity!
	- /// @todo Understand this!
	+ // Normalied to 1/(4pi)
	foreach (Histo1DPtr histo, _h_dphi.getHistograms()) {
	- /// @todo Prefer to scale rather than normalize, if possible
	- normalize(histo, 0.0798);
	+ normalize(histo, 1./(4.*M_PI));
	}

	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_deta;
	BinnedHistogram<double> _h_dphi;
	Profile1DPtr _h_cosdphi_deta;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_1996_S3324664);

	}
	diff --git a/src/Analyses/D0_2000_I499943.cc b/src/Analyses/D0_2000_I499943.cc
	--- a/src/Analyses/D0_2000_I499943.cc
	+++ b/src/Analyses/D0_2000_I499943.cc
	@@ -1,107 +1,107 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/HeavyHadrons.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {


	class D0_2000_I499943 : public Analysis {
	public:

	/// Constructor
	D0_2000_I499943()
	: Analysis("D0_2000_I499943")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs;
	IdentifiedFinalState muons(Cuts::abseta < 0.8 && Cuts::pT > 4.0*GeV);
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "Muons");
	+ declare(muons, "Muons");

	FastJets jetproj(fs, FastJets::D0ILCONE, 0.7);
	jetproj.useInvisibles();
	- addProjection(jetproj, "Jets");
	+ declare(jetproj, "Jets");

	// Book histograms
	_h_pt_leading_mu = bookHisto1D(1, 1, 1);
	_h_dphi_mumu = bookHisto1D(3, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	- const Jets& jets = applyProjection<FastJets>(event, "Jets").jetsByPt(12*GeV);
	+ const Jets& jets = apply<FastJets>(event, "Jets").jetsByPt(12*GeV);
	if (jets.size() < 2) vetoEvent;

	- const Particles& muons = applyProjection<IdentifiedFinalState>(event, "Muons").particlesByPt();
	+ const Particles& muons = apply<IdentifiedFinalState>(event, "Muons").particlesByPt();
	if (muons.size() < 2) vetoEvent;

	// Muon selection: require the muons to be close to jets, not the usual overlap vetoing!
	Particles cand_mu;
	foreach (const Particle& mu, muons) {
	// Ignore muons in "bad" region 80 < phi < 110 degrees
	/// @todo Is this really not corrected for?!
	if (inRange(mu.phi(), 1.4, 1.92)) continue;

	// A muon is a good candidate if within R = 0.8 of a jet
	foreach (const Jet& jet, jets) {
	if (deltaR(mu, jet) < 0.8) {
	cand_mu.push_back(mu);
	break;
	}
	}
	}

	// Must find at least two jet-matched muons in the event
	if (cand_mu.size() < 2) vetoEvent;

	/// @todo Is this cut needed? Does space angle mean dR or 3D opening angle in lab frame?
	// Remove muon pairs closer than 165 deg in space angle (cosmic veto)
	// double dR_mumu = deltaR(cand_mu[0].momentum(), cand_mu[1].momentum());
	// if (dR_mumu < 165*degree) vetoEvent;

	// Selecting muon pairs with 6 < mass < 35 GeV (we use the two with highest pT)
	double m_mumu = (cand_mu[0].momentum() + cand_mu[1].momentum()).mass();
	if (!inRange(m_mumu, 6GeV, 35GeV)) vetoEvent;

	// Get phi angle between muons in degrees
	double dphi_mumu = deltaPhi(cand_mu[0], cand_mu[1]) * 180/M_PI;

	// Fill histos
	_h_pt_leading_mu->fill(cand_mu[0].pt()/GeV, event.weight());
	_h_dphi_mumu->fill(dphi_mumu, event.weight());
	}


	// Normalise histograms to cross-section
	void finalize() {
	scale(_h_pt_leading_mu, crossSection()/sumOfWeights()/nanobarn);
	scale(_h_dphi_mumu, crossSection()/sumOfWeights()/nanobarn);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_pt_leading_mu, _h_dphi_mumu;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2000_I499943);

	}
	diff --git a/src/Analyses/D0_2000_I503361.cc b/src/Analyses/D0_2000_I503361.cc
	--- a/src/Analyses/D0_2000_I503361.cc
	+++ b/src/Analyses/D0_2000_I503361.cc
	@@ -1,83 +1,83 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {

	using namespace Cuts;

	/// @ D0 Run I Z \f$ p_\perp \f$ in Drell-Yan events
	/// @author Simone Amoroso
	class D0_2000_I503361 : public Analysis {
	public:

	/// Constructor
	D0_2000_I503361()
	: Analysis("D0_2000_I503361")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections here
	ZFinder zfinder(FinalState(), Cuts::open(), PID::ELECTRON, 75GeV, 105GeV, 0.0*GeV, ZFinder::NOCLUSTER);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");


	_hist_zpt = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	/// @todo Do the event by event analysis here
	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");
	if (zfinder.bosons().size() != 1) {
	MSG_DEBUG("Num e+ e- pairs found = " << zfinder.bosons().size());
	vetoEvent;
	}
	const FourMomentum& pZ = zfinder.bosons()[0].momentum();
	if (pZ.mass2() < 0) {
	MSG_DEBUG("Negative Z mass**2 = " << pZ.mass2()/GeV2 << "!");
	vetoEvent;
	}

	MSG_DEBUG("Dilepton mass = " << pZ.mass()/GeV << " GeV");
	_hist_zpt->fill(pZ.pT(), weight);

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_hist_zpt, crossSection()/picobarn/sumOfWeights());
	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here


	/// @name Histograms
	//@{
	Histo1DPtr _hist_zpt;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2000_I503361);

	}
	diff --git a/src/Analyses/D0_2000_S4480767.cc b/src/Analyses/D0_2000_S4480767.cc
	--- a/src/Analyses/D0_2000_S4480767.cc
	+++ b/src/Analyses/D0_2000_S4480767.cc
	@@ -1,66 +1,66 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/WFinder.hh"

	namespace Rivet {


	class D0_2000_S4480767 : public Analysis {
	public:

	/// Constructor
	D0_2000_S4480767()
	: Analysis("D0_2000_S4480767")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs;
	WFinder wf(fs, Cuts::abseta < 5, PID::ELECTRON, 0.0GeV, 200.0GeV, 0.0*GeV, 0.2);
	- addProjection(wf, "WFinder");
	+ declare(wf, "WFinder");

	_h_W_pT = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const WFinder& wf = applyProjection<WFinder>(event, "WFinder");
	+ const WFinder& wf = apply<WFinder>(event, "WFinder");
	if (wf.bosons().size() == 0) vetoEvent;

	_h_W_pT->fill(wf.bosons()[0].pT()/GeV, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_W_pT, crossSection()/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_W_pT;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2000_S4480767);

	}
	diff --git a/src/Analyses/D0_2001_S4674421.cc b/src/Analyses/D0_2001_S4674421.cc
	--- a/src/Analyses/D0_2001_S4674421.cc
	+++ b/src/Analyses/D0_2001_S4674421.cc
	@@ -1,191 +1,191 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief D0 Run I differential W/Z boson cross-section analysis
	/// @author Lars Sonnenschein
	/// @author Andy Buckley
	class D0_2001_S4674421 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor.
	D0_2001_S4674421()
	: Analysis("D0_2001_S4674421")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	// Final state projection
	FinalState fs(-5.0, 5.0); // corrected for detector acceptance
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Z -> e- e+
	LeadingParticlesFinalState eeFS(FinalState(-5.0, 5.0, 0.)); //20.);
	eeFS.addParticleIdPair(PID::ELECTRON);
	- addProjection(eeFS, "eeFS");
	+ declare(eeFS, "eeFS");

	// W- -> e- nu_e~
	LeadingParticlesFinalState enuFS(FinalState(-5.0, 5.0, 0.)); //25.);
	enuFS.addParticleId(PID::ELECTRON).addParticleId(PID::NU_EBAR);
	- addProjection(enuFS, "enuFS");
	+ declare(enuFS, "enuFS");

	// W+ -> e+ nu_e
	LeadingParticlesFinalState enubFS(FinalState(-5.0, 5.0, 0.)); //25.);
	enubFS.addParticleId(PID::POSITRON).addParticleId(PID::NU_E);
	- addProjection(enubFS, "enubFS");
	+ declare(enubFS, "enubFS");

	// Remove neutrinos for isolation of final state particles
	VetoedFinalState vfs(fs);
	vfs.vetoNeutrinos();
	- addProjection(vfs, "VFS");
	+ declare(vfs, "VFS");

	// Counters
	_eventsFilledW = 0.0;
	_eventsFilledZ = 0.0;

	// Histograms
	_h_dsigdpt_w = bookHisto1D(1, 1, 1);
	_h_dsigdpt_z = bookHisto1D(1, 1, 2);
	_h_dsigdpt_scaled_z = bookScatter2D(2, 1, 1);
	}



	void analyze(const Event& event) {
	const double weight = event.weight();

	- const LeadingParticlesFinalState& eeFS = applyProjection<LeadingParticlesFinalState>(event, "eeFS");
	+ const LeadingParticlesFinalState& eeFS = apply<LeadingParticlesFinalState>(event, "eeFS");
	// Z boson analysis
	if (eeFS.particles().size() >= 2) {
	// If there is a Z candidate:
	// Fill Z pT distributions
	double deltaM2=1e30,mass2(0.);
	double pT=-1.;
	const Particles& Zdaughters = eeFS.particles();
	for (size_t ix = 0; ix < Zdaughters.size(); ++ix) {
	for (size_t iy = ix+1; iy < Zdaughters.size(); ++iy) {
	if (Zdaughters[ix].pid()!=-Zdaughters[iy].pid()) continue;
	const FourMomentum pmom = Zdaughters[ix].momentum() + Zdaughters[iy].momentum();
	double mz2 = pmom.mass2();
	double dm2 = fabs(mz2 - sqr(91.118*GeV));
	if (dm2 < deltaM2) {
	pT = pmom.pT();
	deltaM2 = dm2;
	mass2 = mz2;
	}
	}
	}
	if (pT > 0. && mass2 > 0. && inRange(sqrt(mass2)/GeV, 75.0, 105.0)) {
	_eventsFilledZ += weight;
	MSG_DEBUG("Z pmom.pT() = " << pT/GeV << " GeV");
	_h_dsigdpt_z->fill(pT/GeV, weight);
	// return if found a Z
	return;
	}
	}
	// There is no Z -> ee candidate... so this might be a W event
	- const LeadingParticlesFinalState& enuFS = applyProjection<LeadingParticlesFinalState>(event, "enuFS");
	- const LeadingParticlesFinalState& enubFS = applyProjection<LeadingParticlesFinalState>(event, "enubFS");
	+ const LeadingParticlesFinalState& enuFS = apply<LeadingParticlesFinalState>(event, "enuFS");
	+ const LeadingParticlesFinalState& enubFS = apply<LeadingParticlesFinalState>(event, "enubFS");

	double deltaM2=1e30;
	double pT=-1.;
	for (size_t iw = 0; iw < 2; ++iw) {
	Particles Wdaughters;
	Wdaughters = (iw == 0) ? enuFS.particles() : enubFS.particles();
	for (size_t ix = 0; ix < Wdaughters.size(); ++ix) {
	for (size_t iy = ix+1; iy < Wdaughters.size(); ++iy) {
	if (Wdaughters[ix].pid() == Wdaughters[iy].pid()) continue;
	const FourMomentum pmom = Wdaughters[0].momentum() + Wdaughters[1].momentum();
	double dm2 = abs(pmom.mass2() - sqr(80.4*GeV));
	if (dm2 < deltaM2) {
	pT = pmom.pT();
	deltaM2 = dm2;
	}
	}
	}
	}
	if (pT > 0.) {
	_eventsFilledW += weight;
	_h_dsigdpt_w->fill(pT/GeV, weight);
	}
	}



	void finalize() {
	// Get cross-section per event (i.e. per unit weight) from generator
	const double xSecPerEvent = crossSectionPerEvent()/picobarn;

	// Correct W pT distribution to W cross-section
	const double xSecW = xSecPerEvent * _eventsFilledW;

	// Correct Z pT distribution to Z cross-section
	const double xSecZ = xSecPerEvent * _eventsFilledZ;

	// Get W and Z pT integrals
	const double wpt_integral = _h_dsigdpt_w->integral();
	const double zpt_integral = _h_dsigdpt_z->integral();

	// Divide and scale ratio histos
	if (xSecW == 0 \|\| wpt_integral == 0 \|\| xSecZ == 0 \|\| zpt_integral == 0) {
	MSG_WARNING("Not filling ratio plot because input histos are empty");
	} else {
	// Scale factor converts event counts to cross-sections, and inverts the
	// branching ratios since only one decay channel has been analysed for each boson.
	// Oh, and we put MW/MZ in, like they do in the paper.
	const double MW_MZ = 0.8820; // Ratio M_W/M_Z
	const double BRZEE_BRWENU = 0.033632 / 0.1073; // Ratio of branching fractions
	const double scalefactor = (xSecW / wpt_integral) / (xSecZ / zpt_integral) * MW_MZ * BRZEE_BRWENU;
	for (size_t ibin = 0; ibin < _h_dsigdpt_w->numBins(); ibin++) {
	const double xval = _h_dsigdpt_w->bin(ibin).xMid();
	const double xerr = _h_dsigdpt_w->bin(ibin).xWidth() / 2.;
	double yval(0), yerr(0);
	if (_h_dsigdpt_w->bin(ibin).sumW() != 0 && _h_dsigdpt_z->bin(ibin).sumW() != 0) {
	yval = scalefactor * _h_dsigdpt_w->bin(ibin).sumW() / _h_dsigdpt_z->bin(ibin).sumW();
	yerr = yval * sqrt( sqr(_h_dsigdpt_w->bin(ibin).relErr()) + sqr(_h_dsigdpt_z->bin(ibin).areaErr()) );
	}
	_h_dsigdpt_scaled_z->addPoint(xval, yval, xerr, yerr);
	}
	}

	// Normalize non-ratio histos
	normalize(_h_dsigdpt_w, xSecW);
	normalize(_h_dsigdpt_z, xSecZ);
	}


	//@}

	private:

	/// @name Event counters for cross section normalizations
	//@{
	double _eventsFilledW;
	double _eventsFilledZ;
	//@}

	//@{
	/// Histograms
	Histo1DPtr _h_dsigdpt_w;
	Histo1DPtr _h_dsigdpt_z;
	Scatter2DPtr _h_dsigdpt_scaled_z;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2001_S4674421);

	}
	diff --git a/src/Analyses/D0_2004_S5992206.cc b/src/Analyses/D0_2004_S5992206.cc
	--- a/src/Analyses/D0_2004_S5992206.cc
	+++ b/src/Analyses/D0_2004_S5992206.cc
	@@ -1,138 +1,138 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/VisibleFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"

	namespace Rivet {


	/* @brief D0 Run II angular correlations in di-jet events
	* @author Lars Sonnenschein
	*
	* Measurement of angular correlations in di-jet events.
	*
	* @par Run conditions
	*
	* @arg \f$ \sqrt{s} = \f$ 1960 GeV
	* @arg Run with generic QCD events.
	* @arg Several \f$ p_\perp^\text{min} \f$ cutoffs are probably required to fill the histograms:
	* @arg \f$ p_\perp^\text{min} = \f$ 50, 75, 100, 150 GeV for the four pT ranges respecively
	*
	*/
	class D0_2004_S5992206 : public Analysis {

	public:

	/// @name Constructors etc.
	//@{

	/// Constructor.
	D0_2004_S5992206()
	: Analysis("D0_2004_S5992206")
	{ }

	//@}


	/// @name Analysis methods
	//@{

	void init() {
	// Final state for jets, mET etc.
	const FinalState fs(-3.0, 3.0);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	// Veto neutrinos, and muons with pT above 1.0 GeV
	VetoedFinalState vfs(fs);
	vfs.vetoNeutrinos();
	vfs.addVetoPairDetail(PID::MUON, 1.0*GeV, MAXDOUBLE);
	- addProjection(vfs, "VFS");
	- addProjection(FastJets(vfs, FastJets::D0ILCONE, 0.7), "Jets");
	- addProjection(MissingMomentum(vfs), "CalMET");
	+ declare(vfs, "VFS");
	+ declare(FastJets(vfs, FastJets::D0ILCONE, 0.7), "Jets");
	+ declare(MissingMomentum(vfs), "CalMET");

	// Book histograms
	_histJetAzimuth_pTmax75_100 = bookHisto1D(1, 2, 1);
	_histJetAzimuth_pTmax100_130 = bookHisto1D(2, 2, 1);
	_histJetAzimuth_pTmax130_180 = bookHisto1D(3, 2, 1);
	_histJetAzimuth_pTmax180_ = bookHisto1D(4, 2, 1);
	}


	/// Do the analysis
	void analyze(const Event& event) {

	// Analyse and print some info
	- const JetAlg& jetpro = applyProjection<JetAlg>(event, "Jets");
	+ const JetAlg& jetpro = apply<JetAlg>(event, "Jets");
	MSG_DEBUG("Jet multiplicity before any pT cut = " << jetpro.size());

	const Jets jets = jetpro.jetsByPt(40.0*GeV);
	if (jets.size() >= 2) {
	MSG_DEBUG("Jet multiplicity after pT > 40 GeV cut = " << jets.size());
	} else {
	vetoEvent;
	}
	const double rap1 = jets[0].rapidity();
	const double rap2 = jets[1].rapidity();
	if (fabs(rap1) > 0.5 \|\| fabs(rap2) > 0.5) {
	vetoEvent;
	}
	MSG_DEBUG("Jet eta and pT requirements fulfilled");
	const double pT1 = jets[0].pT();

	- const MissingMomentum& caloMissEt = applyProjection<MissingMomentum>(event, "CalMET");
	+ const MissingMomentum& caloMissEt = apply<MissingMomentum>(event, "CalMET");
	MSG_DEBUG("Missing vector Et = " << caloMissEt.vectorEt()/GeV << " GeV");
	if (caloMissEt.vectorEt().mod() > 0.7*pT1) {
	MSG_DEBUG("Vetoing event with too much missing ET: "
	<< caloMissEt.vectorEt()/GeV << " GeV > "
	<< 0.7*pT1/GeV << " GeV");
	vetoEvent;
	}

	if (pT1/GeV >= 75.0) {
	const double weight = event.weight();
	const double dphi = deltaPhi(jets[0].phi(), jets[1].phi());
	if (inRange(pT1/GeV, 75.0, 100.0)) {
	_histJetAzimuth_pTmax75_100->fill(dphi, weight);
	} else if (inRange(pT1/GeV, 100.0, 130.0)) {
	_histJetAzimuth_pTmax100_130->fill(dphi, weight);
	} else if (inRange(pT1/GeV, 130.0, 180.0)) {
	_histJetAzimuth_pTmax130_180->fill(dphi, weight);
	} else if (pT1/GeV > 180.0) {
	_histJetAzimuth_pTmax180_->fill(dphi, weight);
	}
	}

	}


	// Finalize
	void finalize() {
	// Normalize histograms to unit area
	normalize(_histJetAzimuth_pTmax75_100);
	normalize(_histJetAzimuth_pTmax100_130);
	normalize(_histJetAzimuth_pTmax130_180);
	normalize(_histJetAzimuth_pTmax180_);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _histJetAzimuth_pTmax75_100;
	Histo1DPtr _histJetAzimuth_pTmax100_130;
	Histo1DPtr _histJetAzimuth_pTmax130_180;
	Histo1DPtr _histJetAzimuth_pTmax180_;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2004_S5992206);

	}
	diff --git a/src/Analyses/D0_2006_S6438750.cc b/src/Analyses/D0_2006_S6438750.cc
	--- a/src/Analyses/D0_2006_S6438750.cc
	+++ b/src/Analyses/D0_2006_S6438750.cc
	@@ -1,102 +1,102 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief D0 inclusive isolated photon cross-section vs. \f$ p_\perp(gamma) \f$.
	/// @author Andy Buckley
	/// @author Gavin Hesketh
	class D0_2006_S6438750 : public Analysis {

	public:

	/// @name Constructors etc.
	//@{

	/// Default constructor.
	D0_2006_S6438750()
	: Analysis("D0_2006_S6438750")
	{ }

	//@}


	/// @name Analysis methods
	//@{

	void init() {
	// General FS for photon isolation
	FinalState fs;
	- addProjection(fs, "AllFS");
	+ declare(fs, "AllFS");

	// Get leading photon
	LeadingParticlesFinalState photonfs(FinalState(-0.9, 0.9, 23.0*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// Book histograms
	_h_pTgamma = bookHisto1D(1, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& event) {

	// Get the photon
	- const FinalState& photonfs = applyProjection<FinalState>(event, "LeadingPhoton");
	+ const FinalState& photonfs = apply<FinalState>(event, "LeadingPhoton");
	if (photonfs.particles().size() != 1) {
	vetoEvent;
	}
	const FourMomentum photon = photonfs.particles().front().momentum();

	// Isolate photon by ensuring that a 0.4 cone around it contains less than 10% of the photon's energy
	double E_P = photon.E();
	double eta_P = photon.eta();
	double phi_P = photon.phi();
	double econe = 0.0;
	- foreach (const Particle& p, applyProjection<FinalState>(event, "AllFS").particles()) {
	+ foreach (const Particle& p, apply<FinalState>(event, "AllFS").particles()) {
	if (deltaR(eta_P, phi_P,
	p.eta(), p.phi()) < 0.4) {
	econe += p.E();
	if (econe/E_P > 1.1) {
	vetoEvent;
	}
	}
	}

	// Fill histo
	const double weight = event.weight();
	_h_pTgamma->fill(photon.pT(), weight);
	}



	// Finalize
	void finalize() {
	const double lumi_gen = sumOfWeights()/crossSection();
	// Divide by effective lumi, plus rapidity bin width of 1.8
	scale(_h_pTgamma, 1/lumi_gen * 1/1.8);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_pTgamma;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2006_S6438750);

	}
	diff --git a/src/Analyses/D0_2007_S7075677.cc b/src/Analyses/D0_2007_S7075677.cc
	--- a/src/Analyses/D0_2007_S7075677.cc
	+++ b/src/Analyses/D0_2007_S7075677.cc
	@@ -1,74 +1,74 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	/// @brief Measurement of D0 Run II Z \f$ p_\perp \f$ diff cross-section shape
	/// @author Andy Buckley
	/// @author Gavin Hesketh
	/// @author Frank Siegert
	class D0_2007_S7075677 : public Analysis {
	public:

	/// Default constructor.
	D0_2007_S7075677()
	: Analysis("D0_2007_S7075677")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	ZFinder zfinder(FinalState(), Cuts::open(), PID::ELECTRON,
	71GeV, 111GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	_h_yZ = bookHisto1D(1, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event & e) {
	const double weight = e.weight();

	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	if (zfinder.bosons().size() == 1) {
	const Particles& el(zfinder.constituents());
	if (el[0].pT() > 25GeV \|\| el[1].pT() > 25GeV) {
	_h_yZ->fill(fabs(zfinder.bosons()[0].rapidity()), weight);
	}
	} else {
	MSG_DEBUG("No unique lepton pair found.");
	}
	}


	// Finalize
	void finalize() {
	// Data seems to have been normalized for the avg of the two sides
	// (+ve & -ve rapidity) rather than the sum, hence the 0.5:
	normalize(_h_yZ, 0.5);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_yZ;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2007_S7075677);

	}
	diff --git a/src/Analyses/D0_2008_S6879055.cc b/src/Analyses/D0_2008_S6879055.cc
	--- a/src/Analyses/D0_2008_S6879055.cc
	+++ b/src/Analyses/D0_2008_S6879055.cc
	@@ -1,126 +1,126 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief D0 measurement of the ratio \f$ \sigma(Z/\gamma^* + n \text{ jets})/\sigma(Z/\gamma^*) \f$
	class D0_2008_S6879055 : public Analysis {
	public:

	/// Default constructor.
	D0_2008_S6879055()
	: Analysis("D0_2008_S6879055")
	{ }
	// DEFAULT_RIVET_ANA_CONSTRUCTOR(D0_2008_S6879055);

	/// @name Analysis methods
	//@{

	// Book histograms
	void init() {
	FinalState fs;
	ZFinder zfinder(fs, Cuts::open(), PID::ELECTRON,
	40GeV, 200GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	FastJets conefinder(zfinder.remainingFinalState(), FastJets::D0ILCONE, 0.5);
	- addProjection(conefinder, "ConeFinder");
	+ declare(conefinder, "ConeFinder");

	_crossSectionRatio = bookHisto1D(1, 1, 1);
	_pTjet1 = bookHisto1D(2, 1, 1);
	_pTjet2 = bookHisto1D(3, 1, 1);
	_pTjet3 = bookHisto1D(4, 1, 1);
	}



	/// Do the analysis
	void analyze(const Event& event) {
	const double weight = event.weight();



	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");
	if (zfinder.bosons().size()!=1) {
	vetoEvent;
	}

	FourMomentum e0 = zfinder.constituents()[0].momentum();
	FourMomentum e1 = zfinder.constituents()[1].momentum();
	const double e0eta = e0.eta();
	const double e0phi = e0.phi();
	const double e1eta = e1.eta();
	const double e1phi = e1.phi();

	vector<FourMomentum> finaljet_list;
	- foreach (const Jet& j, applyProjection<JetAlg>(event, "ConeFinder").jetsByPt(20*GeV)) {
	+ foreach (const Jet& j, apply<JetAlg>(event, "ConeFinder").jetsByPt(20*GeV)) {
	const double jeta = j.eta();
	const double jphi = j.phi();
	if (fabs(jeta) < 2.5) {
	if (deltaR(e0eta, e0phi, jeta, jphi) > 0.4 &&
	deltaR(e1eta, e1phi, jeta, jphi) > 0.4) {
	finaljet_list.push_back(j.momentum());
	}
	}
	}

	// For normalisation of crossSection data (includes events with no jets passing cuts)
	_crossSectionRatio->fill(0, weight);

	// Fill jet pT and multiplicities
	if (finaljet_list.size() >= 1) {
	_crossSectionRatio->fill(1, weight);
	_pTjet1->fill(finaljet_list[0].pT(), weight);
	}
	if (finaljet_list.size() >= 2) {
	_crossSectionRatio->fill(2, weight);
	_pTjet2->fill(finaljet_list[1].pT(), weight);
	}
	if (finaljet_list.size() >= 3) {
	_crossSectionRatio->fill(3, weight);
	_pTjet3->fill(finaljet_list[2].pT(), weight);
	}
	if (finaljet_list.size() >= 4) {
	_crossSectionRatio->fill(4, weight);
	}
	}



	/// Finalize
	void finalize() {
	// Now divide by the inclusive result
	scale(_crossSectionRatio,1/_crossSectionRatio->bin(0).area());

	// Normalise jet pTs to integrals of data
	// @note There is no other way to do this, because these quantities are not detector-corrected
	/// @todo Use integrals of refData()?
	normalize(_pTjet1, 10439); // fixed norm OK
	normalize(_pTjet2, 1461.5); // fixed norm OK
	normalize(_pTjet3, 217); // fixed norm OK
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _crossSectionRatio;
	Histo1DPtr _pTjet1;
	Histo1DPtr _pTjet2;
	Histo1DPtr _pTjet3;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2008_S6879055);

	}
	diff --git a/src/Analyses/D0_2008_S7554427.cc b/src/Analyses/D0_2008_S7554427.cc
	--- a/src/Analyses/D0_2008_S7554427.cc
	+++ b/src/Analyses/D0_2008_S7554427.cc
	@@ -1,73 +1,73 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	/// @brief D0 Run II Z \f$ p_\perp \f$ differential cross-section shape
	/// @author Andy Buckley
	/// @author Gavin Hesketh
	/// @author Frank Siegert
	class D0_2008_S7554427 : public Analysis {
	public:

	/// Default constructor.
	D0_2008_S7554427()
	: Analysis("D0_2008_S7554427")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	ZFinder zfinder(fs, Cuts::open(), PID::ELECTRON,
	40GeV, 200GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	_h_ZpT = bookHisto1D(1, 1, 1);
	_h_forward_ZpT = bookHisto1D(3, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& e) {
	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	if (zfinder.bosons().size() != 1) {
	MSG_DEBUG("No unique lepton pair found.");
	vetoEvent;
	}
	const double yZ = fabs(zfinder.bosons()[0].rapidity());
	const double pTZ = zfinder.bosons()[0].pT();
	_h_ZpT->fill(pTZ, e.weight());
	if (yZ > 2) _h_forward_ZpT->fill(pTZ, e.weight());
	}


	// Finalize
	void finalize() {
	normalize(_h_ZpT);
	normalize(_h_forward_ZpT);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_ZpT, _h_forward_ZpT;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2008_S7554427);

	}
	diff --git a/src/Analyses/D0_2008_S7662670.cc b/src/Analyses/D0_2008_S7662670.cc
	--- a/src/Analyses/D0_2008_S7662670.cc
	+++ b/src/Analyses/D0_2008_S7662670.cc
	@@ -1,124 +1,124 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief D0 differential jet cross sections
	/// @author Andy Buckley
	/// @author Gavin Hesketh
	class D0_2008_S7662670 : public Analysis {

	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	D0_2008_S7662670()
	: Analysis("D0_2008_S7662670")
	{ }

	//@}


	/// @name Analysis methods
	//@{

	void init()
	{

	// Full final state
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Jets
	FastJets jetpro(fs, FastJets::D0ILCONE, 0.7);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	// Book histograms
	_h_dsigdptdy_y00_04 = bookHisto1D(1, 1, 1);
	_h_dsigdptdy_y04_08 = bookHisto1D(2, 1, 1);
	_h_dsigdptdy_y08_12 = bookHisto1D(3, 1, 1);
	_h_dsigdptdy_y12_16 = bookHisto1D(4, 1, 1);
	_h_dsigdptdy_y16_20 = bookHisto1D(5, 1, 1);
	_h_dsigdptdy_y20_24 = bookHisto1D(6, 1, 1);
	}



	/// Do the analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Skip if the event is empty
	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	if (fs.empty()) {
	MSG_DEBUG("Empty event!");
	vetoEvent;
	}

	// Find the jets
	- const JetAlg& jetpro = applyProjection<JetAlg>(event, "Jets");
	+ const JetAlg& jetpro = apply<JetAlg>(event, "Jets");
	// Fill histo for each jet
	foreach (const Jet& j, jetpro.jets(Cuts::pT > 50*GeV)) {
	const double pt = j.pT();
	const double y = j.absrap();
	MSG_TRACE("Filling histos: pT = " << pt/GeV << ", \|y\| = " << y);
	if (y < 0.4) {
	_h_dsigdptdy_y00_04->fill(pt/GeV, weight);
	} else if (y < 0.8) {
	_h_dsigdptdy_y04_08->fill(pt/GeV, weight);
	} else if (y < 1.2) {
	_h_dsigdptdy_y08_12->fill(pt/GeV, weight);
	} else if (y < 1.6) {
	_h_dsigdptdy_y12_16->fill(pt/GeV, weight);
	} else if (y < 2.0) {
	_h_dsigdptdy_y16_20->fill(pt/GeV, weight);
	} else if (y < 2.4) {
	_h_dsigdptdy_y20_24->fill(pt/GeV, weight);
	}
	}

	}


	/// Finalize
	void finalize() {
	/// Scale by L_eff = sig_MC * L_exp / num_MC
	const double lumi_mc = sumOfWeights() / crossSection();
	const double scalefactor = 1 / lumi_mc;
	scale(_h_dsigdptdy_y00_04, scalefactor);
	scale(_h_dsigdptdy_y04_08, scalefactor);
	scale(_h_dsigdptdy_y08_12, scalefactor);
	scale(_h_dsigdptdy_y12_16, scalefactor);
	scale(_h_dsigdptdy_y16_20, scalefactor);
	scale(_h_dsigdptdy_y20_24, scalefactor);
	}

	//@}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_dsigdptdy_y00_04;
	Histo1DPtr _h_dsigdptdy_y04_08;
	Histo1DPtr _h_dsigdptdy_y08_12;
	Histo1DPtr _h_dsigdptdy_y12_16;
	Histo1DPtr _h_dsigdptdy_y16_20;
	Histo1DPtr _h_dsigdptdy_y20_24;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2008_S7662670);

	}
	diff --git a/src/Analyses/D0_2008_S7719523.cc b/src/Analyses/D0_2008_S7719523.cc
	--- a/src/Analyses/D0_2008_S7719523.cc
	+++ b/src/Analyses/D0_2008_S7719523.cc
	@@ -1,202 +1,202 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	// A local scope function for division, handling the div-by-zero case
	/// @todo Why isn't the math divide() function being found?
	namespace {
	inline double _safediv(double a, double b, double result_if_err) {
	return (b != 0) ? a/b : result_if_err;
	}
	}


	/// @brief Measurement of isolated gamma + jet + X differential cross-sections
	///
	/// Inclusive isolated gamma + jet cross-sections, differential in pT(gamma), for
	/// various photon and jet rapidity bins.
	///
	/// @author Andy Buckley
	/// @author Gavin Hesketh
	class D0_2008_S7719523 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	D0_2008_S7719523()
	: Analysis("D0_2008_S7719523")
	{ }

	//@}


	/// @name Analysis methods
	//@{

	/// Set up projections and book histograms
	void init() {
	// General FS
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Get leading photon
	LeadingParticlesFinalState photonfs(FinalState(-1.0, 1.0, 30.0*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// FS excluding the leading photon
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(photonfs);
	- addProjection(vfs, "JetFS");
	+ declare(vfs, "JetFS");

	// Jets
	FastJets jetpro(vfs, FastJets::D0ILCONE, 0.7);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	// Histograms
	_h_central_same_cross_section = bookHisto1D(1, 1, 1);
	_h_central_opp_cross_section = bookHisto1D(2, 1, 1);
	_h_forward_same_cross_section = bookHisto1D(3, 1, 1);
	_h_forward_opp_cross_section = bookHisto1D(4, 1, 1);

	// Ratio histos to be filled by divide()
	_h_cen_opp_same = bookScatter2D(5, 1, 1);
	_h_fwd_opp_same = bookScatter2D(8, 1, 1);
	// Ratio histos to be filled manually, since the num/denom inputs don't match
	_h_cen_same_fwd_same = bookScatter2D(6, 1, 1, true);
	_h_cen_opp_fwd_same = bookScatter2D(7, 1, 1, true);
	_h_cen_same_fwd_opp = bookScatter2D(9, 1, 1, true);
	_h_cen_opp_fwd_opp = bookScatter2D(10, 1, 1, true);
	}



	/// Do the analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Get the photon
	- const FinalState& photonfs = applyProjection<FinalState>(event, "LeadingPhoton");
	+ const FinalState& photonfs = apply<FinalState>(event, "LeadingPhoton");
	if (photonfs.particles().size() != 1) {
	vetoEvent;
	}
	const FourMomentum photon = photonfs.particles().front().momentum();

	// Isolate photon by ensuring that a 0.4 cone around it contains less than 7% of the photon's energy
	double egamma = photon.E();
	double eta_P = photon.eta();
	double phi_P = photon.phi();
	double econe = 0.0;
	- foreach (const Particle& p, applyProjection<FinalState>(event, "JetFS").particles()) {
	+ foreach (const Particle& p, apply<FinalState>(event, "JetFS").particles()) {
	if (deltaR(eta_P, phi_P, p.eta(), p.phi()) < 0.4) {
	econe += p.E();
	// Veto as soon as E_cone gets larger
	if (econe/egamma > 0.07) {
	MSG_DEBUG("Vetoing event because photon is insufficiently isolated");
	vetoEvent;
	}
	}
	}

	- Jets jets = applyProjection<FastJets>(event, "Jets").jetsByPt(15.0*GeV);
	+ Jets jets = apply<FastJets>(event, "Jets").jetsByPt(15.0*GeV);
	if (jets.empty()) vetoEvent;

	FourMomentum leadingJet = jets[0].momentum();
	if (deltaR(eta_P, phi_P, leadingJet.eta(), leadingJet.phi()) < 0.7) {
	vetoEvent;
	}

	int photon_jet_sign = sign( leadingJet.rapidity() * photon.rapidity() );

	// Veto if leading jet is outside plotted rapidity regions
	const double abs_y1 = fabs(leadingJet.rapidity());
	if (inRange(abs_y1, 0.8, 1.5) \|\| abs_y1 > 2.5) {
	MSG_DEBUG("Leading jet falls outside acceptance range; \|y1\| = " << abs_y1);
	vetoEvent;
	}

	// Fill histos
	if (fabs(leadingJet.rapidity()) < 0.8) {
	Histo1DPtr h = (photon_jet_sign >= 1) ? _h_central_same_cross_section : _h_central_opp_cross_section;
	h->fill(photon.pT(), weight);
	} else if (inRange( fabs(leadingJet.rapidity()), 1.5, 2.5)) {
	Histo1DPtr h = (photon_jet_sign >= 1) ? _h_forward_same_cross_section : _h_forward_opp_cross_section;
	h->fill(photon.pT(), weight);
	}

	}


	/// Finalize
	void finalize() {
	const double lumi_gen = sumOfWeights()/crossSection();
	const double dy_photon = 2.0;
	const double dy_jet_central = 1.6;
	const double dy_jet_forward = 2.0;

	// Cross-section ratios (6 plots)
	// Central/central and forward/forward ratios
	divide(_h_central_opp_cross_section, _h_central_same_cross_section, _h_cen_opp_same);
	divide(_h_forward_opp_cross_section, _h_forward_same_cross_section, _h_fwd_opp_same);
	// Central/forward ratio combinations
	/// @note The central/forward histo binnings are not the same! Hence the need to do these by hand :-(
	for (size_t i = 0; i < _h_cen_same_fwd_same->numPoints(); ++i) {
	const YODA::HistoBin1D& cen_same_bini = _h_central_same_cross_section->bin(i);
	const YODA::HistoBin1D& cen_opp_bini = _h_central_opp_cross_section->bin(i);
	const YODA::HistoBin1D& fwd_same_bini = _h_central_same_cross_section->bin(i);
	const YODA::HistoBin1D& fwd_opp_bini = _h_central_opp_cross_section->bin(i);
	_h_cen_same_fwd_same->point(i).setY(_safediv(cen_same_bini.sumW(), fwd_same_bini.sumW(), 0),
	add_quad(cen_same_bini.relErr(), fwd_same_bini.relErr()));
	_h_cen_opp_fwd_same->point(i).setY(_safediv(cen_opp_bini.sumW(), fwd_same_bini.sumW(), 0),
	add_quad(cen_opp_bini.relErr(), fwd_same_bini.relErr()));
	_h_cen_same_fwd_opp->point(i).setY(_safediv(cen_same_bini.sumW(), fwd_opp_bini.sumW(), 0),
	add_quad(cen_same_bini.relErr(), fwd_opp_bini.relErr()));
	_h_cen_opp_fwd_opp->point(i).setY(_safediv(cen_opp_bini.sumW(), fwd_opp_bini.sumW(), 0),
	add_quad(cen_opp_bini.relErr(), fwd_opp_bini.relErr()));
	}

	// Use generator cross section for remaining histograms
	// Each of these needs the additional factor 2 because the
	// y_photon * y_jet requirement reduces the corresponding 2D "bin width"
	// by a factor 1/2.
	scale(_h_central_same_cross_section, 2.0/lumi_gen * 1.0/dy_photon * 1.0/dy_jet_central);
	scale(_h_central_opp_cross_section, 2.0/lumi_gen * 1.0/dy_photon * 1.0/dy_jet_central);
	scale(_h_forward_same_cross_section, 2.0/lumi_gen * 1.0/dy_photon * 1.0/dy_jet_forward);
	scale(_h_forward_opp_cross_section, 2.0/lumi_gen * 1.0/dy_photon * 1.0/dy_jet_forward);
	}

	//@}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_central_same_cross_section;
	Histo1DPtr _h_central_opp_cross_section;
	Histo1DPtr _h_forward_same_cross_section;
	Histo1DPtr _h_forward_opp_cross_section;

	Scatter2DPtr _h_cen_opp_same;
	Scatter2DPtr _h_fwd_opp_same;
	Scatter2DPtr _h_cen_same_fwd_same;
	Scatter2DPtr _h_cen_opp_fwd_same;
	Scatter2DPtr _h_cen_same_fwd_opp;
	Scatter2DPtr _h_cen_opp_fwd_opp;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2008_S7719523);

	}
	diff --git a/src/Analyses/D0_2008_S7837160.cc b/src/Analyses/D0_2008_S7837160.cc
	--- a/src/Analyses/D0_2008_S7837160.cc
	+++ b/src/Analyses/D0_2008_S7837160.cc
	@@ -1,112 +1,112 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {


	/// @brief D0 Run II measurement of W charge asymmetry
	/// @author Andy Buckley
	/// @author Gavin Hesketh
	class D0_2008_S7837160 : public Analysis {
	public:

	/// Default constructor.
	D0_2008_S7837160()
	: Analysis("D0_2008_S7837160")
	{ }


	/// @name Analysis methods
	//@{

	// Book histograms and set up projections
	void init() {
	// Projections
	FinalState fs;
	/// @todo Use separate pT and ETmiss cuts in WFinder
	const WFinder wfe(fs, Cuts::abseta < 5 && Cuts::pT > 25GeV, PID::ELECTRON, 60.0GeV, 100.0GeV, 25.0GeV, 0.2);
	- addProjection(wfe, "WFe");
	+ declare(wfe, "WFe");

	// Histograms (temporary +- charge histos and scatters to store the calculated asymmetries)
	for (size_t pmindex = 0; pmindex < 2; ++pmindex) {
	const string suffix = (pmindex == 0) ? "plus" : "minus";
	_hs_dsigpm_deta_25_35[pmindex] = bookHisto1D("TMP/dsigpm_deta_25_35_" + suffix, refData(1, 1, 1));
	_hs_dsigpm_deta_35[pmindex] = bookHisto1D("TMP/dsigpm_deta_35_" + suffix, refData(1, 1, 2));
	_hs_dsigpm_deta_25[pmindex] = bookHisto1D("TMP/dsigpm_deta_25_" + suffix, refData(1, 1, 3));
	}
	_h_asym1 = bookScatter2D(1, 1, 1);
	_h_asym2 = bookScatter2D(1, 1, 2);
	_h_asym3 = bookScatter2D(1, 1, 3);
	}


	/// Do the analysis
	void analyze(const Event & event) {
	- const WFinder& wf = applyProjection<WFinder>(event, "WFe");
	+ const WFinder& wf = apply<WFinder>(event, "WFe");
	if (wf.bosons().size() == 0) {
	MSG_DEBUG("No W candidates found: vetoing");
	vetoEvent;
	}

	// Get the e+- momentum, and an effective charge including the eta sign
	/// @todo Is it correct to multiply the eta sign into the charge to "fold" the plot?
	const FourMomentum p_e = wf.constituentLeptons()[0].momentum();
	const int chg_e = sign(p_e.eta()) * sign(charge(wf.constituentLeptons()[0]));
	assert(chg_e == 1 \|\| chg_e == -1);
	MSG_TRACE("Charged lepton sign = " << chg_e);

	// Fill histos with appropriate +- indexing
	const double weight = event.weight();
	const size_t pmindex = (chg_e > 0) ? 0 : 1;
	if (p_e.Et() < 35*GeV) _hs_dsigpm_deta_25_35[pmindex]->fill(fabs(p_e.eta()), weight);
	else _hs_dsigpm_deta_35[pmindex]->fill(fabs(p_e.eta()), weight);
	_hs_dsigpm_deta_25[pmindex]->fill(fabs(p_e.eta()), weight);
	}


	/// @name Helper functions for constructing asymmetry histograms in finalize()
	//@{
	void calc_asymm(const Histo1DPtr plus, const Histo1DPtr minus, Scatter2DPtr target) {
	divide(plus - minus, plus + minus, target);
	}
	void calc_asymm(const Histo1DPtr histos[2], Scatter2DPtr target) {
	calc_asymm(histos[0], histos[1], target);
	}
	//@}


	/// @brief Finalize
	///
	/// Construct asymmetry: (dsig+/deta - dsig-/deta) / (dsig+/deta + dsig-/deta) for each ET region
	void finalize() {
	calc_asymm(_hs_dsigpm_deta_25_35, _h_asym1);
	calc_asymm(_hs_dsigpm_deta_35, _h_asym2);
	calc_asymm(_hs_dsigpm_deta_25, _h_asym3);
	_h_asym1->scale(1.,100.);
	_h_asym2->scale(1.,100.);
	_h_asym3->scale(1.,100.);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _hs_dsigpm_deta_25_35[2], _hs_dsigpm_deta_35[2], _hs_dsigpm_deta_25[2];
	Scatter2DPtr _h_asym1, _h_asym2, _h_asym3;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2008_S7837160);

	}
	diff --git a/src/Analyses/D0_2008_S7863608.cc b/src/Analyses/D0_2008_S7863608.cc
	--- a/src/Analyses/D0_2008_S7863608.cc
	+++ b/src/Analyses/D0_2008_S7863608.cc
	@@ -1,134 +1,134 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// @brief D0 differential Z/\f$ \gamma^* \f$ + jet + \f$ X \f$ cross sections
	/// @author Gavin Hesketh, Andy Buckley, Frank Siegert
	class D0_2008_S7863608 : public Analysis {
	public:

	/// Constructor
	D0_2008_S7863608()
	: Analysis("D0_2008_S7863608")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	/// @todo These clustering arguments look odd: are they ok?
	Cut cut = Cuts::abseta < 1.7 && Cuts::pT > 15*GeV;
	ZFinder zfinder(FinalState(), cut, PID::MUON, 65GeV, 115GeV, 0.2, ZFinder::NOCLUSTER, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	FastJets conefinder(zfinder.remainingFinalState(), FastJets::D0ILCONE, 0.5);
	- addProjection(conefinder, "ConeFinder");
	+ declare(conefinder, "ConeFinder");

	_sum_of_weights_inclusive = 0;

	_h_jet_pT_cross_section = bookHisto1D(1, 1, 1);
	_h_jet_pT_normalised = bookHisto1D(1, 1, 2);
	_h_jet_y_cross_section = bookHisto1D(2, 1, 1);
	_h_jet_y_normalised = bookHisto1D(2, 1, 2);
	_h_Z_pT_cross_section = bookHisto1D(3, 1, 1);
	_h_Z_pT_normalised = bookHisto1D(3, 1, 2);
	_h_Z_y_cross_section = bookHisto1D(4, 1, 1);
	_h_Z_y_normalised = bookHisto1D(4, 1, 2);
	_h_total_cross_section = bookHisto1D(5, 1, 1);
	}


	// Do the analysis
	void analyze(const Event& e) {
	const double weight = e.weight();

	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	if (zfinder.bosons().size()==1) {
	_sum_of_weights_inclusive += weight;
	- const JetAlg& jetpro = applyProjection<JetAlg>(e, "ConeFinder");
	+ const JetAlg& jetpro = apply<JetAlg>(e, "ConeFinder");
	const Jets& jets = jetpro.jetsByPt(20*GeV);
	Jets jets_cut;
	foreach (const Jet& j, jets) {
	if (j.abseta() < 2.8) {
	jets_cut.push_back(j);
	}
	}

	// Return if there are no jets:
	if(jets_cut.size()<1) {
	MSG_DEBUG("Skipping event " << numEvents() << " because no jets pass cuts ");
	vetoEvent;
	}

	const FourMomentum Zmom = zfinder.bosons()[0].momentum();

	// In jet pT
	_h_jet_pT_cross_section->fill( jets_cut[0].pT(), weight);
	_h_jet_pT_normalised->fill( jets_cut[0].pT(), weight);
	_h_jet_y_cross_section->fill( fabs(jets_cut[0].rapidity()), weight);
	_h_jet_y_normalised->fill( fabs(jets_cut[0].rapidity()), weight);

	// In Z pT
	_h_Z_pT_cross_section->fill(Zmom.pT(), weight);
	_h_Z_pT_normalised->fill(Zmom.pT(), weight);
	_h_Z_y_cross_section->fill(Zmom.absrap(), weight);
	_h_Z_y_normalised->fill(Zmom.absrap(), weight);

	_h_total_cross_section->fill(1960, weight);
	}
	}


	/// Finalize
	void finalize() {
	const double invlumi = crossSection()/sumOfWeights();
	scale(_h_total_cross_section, invlumi);
	scale(_h_jet_pT_cross_section, invlumi);
	scale(_h_jet_y_cross_section, invlumi);
	scale(_h_Z_pT_cross_section, invlumi);
	scale(_h_Z_y_cross_section, invlumi);

	double factor=1/_sum_of_weights_inclusive;
	if (_sum_of_weights_inclusive == 0) factor = 0;
	scale(_h_jet_pT_normalised, factor);
	scale(_h_jet_y_normalised, factor);
	scale(_h_Z_pT_normalised, factor);
	scale(_h_Z_y_normalised, factor);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_jet_pT_cross_section;
	Histo1DPtr _h_jet_y_cross_section;
	Histo1DPtr _h_Z_pT_cross_section;
	Histo1DPtr _h_Z_y_cross_section;
	Histo1DPtr _h_total_cross_section;
	Histo1DPtr _h_jet_pT_normalised;
	Histo1DPtr _h_jet_y_normalised;
	Histo1DPtr _h_Z_pT_normalised;
	Histo1DPtr _h_Z_y_normalised;
	//@}

	double _sum_of_weights_inclusive;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2008_S7863608);

	}
	diff --git a/src/Analyses/D0_2009_S8202443.cc b/src/Analyses/D0_2009_S8202443.cc
	--- a/src/Analyses/D0_2009_S8202443.cc
	+++ b/src/Analyses/D0_2009_S8202443.cc
	@@ -1,126 +1,126 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief D0 Z + jet + \f$ X \f$ cross-section / \f$ p_\perp \f$ distributions
	class D0_2009_S8202443 : public Analysis {
	public:

	/// Constructor
	D0_2009_S8202443()
	: Analysis("D0_2009_S8202443"),
	_sum_of_weights(0), _sum_of_weights_constrained(0)
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	// Leptons in constrained tracking acceptance
	Cut cuts = (Cuts::abseta < 1.1 \|\| Cuts::absetaIn(1.5, 2.5)) && Cuts::pT > 25*GeV;
	ZFinder zfinder_constrained(fs, cuts, PID::ELECTRON, 65GeV, 115GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder_constrained, "ZFinderConstrained");
	+ declare(zfinder_constrained, "ZFinderConstrained");
	FastJets conefinder_constrained(zfinder_constrained.remainingFinalState(), FastJets::D0ILCONE, 0.5);
	- addProjection(conefinder_constrained, "ConeFinderConstrained");
	+ declare(conefinder_constrained, "ConeFinderConstrained");

	// Unconstrained leptons
	ZFinder zfinder(fs, Cuts::open(), PID::ELECTRON, 65GeV, 115GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");
	FastJets conefinder(zfinder.remainingFinalState(), FastJets::D0ILCONE, 0.5);
	- addProjection(conefinder, "ConeFinder");
	+ declare(conefinder, "ConeFinder");

	_h_jet1_pT_constrained = bookHisto1D(1, 1, 1);
	_h_jet2_pT_constrained = bookHisto1D(3, 1, 1);
	_h_jet3_pT_constrained = bookHisto1D(5, 1, 1);
	_h_jet1_pT = bookHisto1D(2, 1, 1);
	_h_jet2_pT = bookHisto1D(4, 1, 1);
	_h_jet3_pT = bookHisto1D(6, 1, 1);
	}



	// Do the analysis
	void analyze(const Event& e) {
	double weight = e.weight();

	// Unconstrained electrons
	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	if (zfinder.bosons().size() == 0) {
	MSG_DEBUG("No unique lepton pair found.");
	vetoEvent;
	}
	_sum_of_weights += weight;
	- const Jets jets_cut = applyProjection<JetAlg>(e, "ConeFinder").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.5);
	+ const Jets jets_cut = apply<JetAlg>(e, "ConeFinder").jetsByPt(Cuts::pT > 20*GeV && Cuts::abseta < 2.5);
	if (jets_cut.size() > 0)
	_h_jet1_pT->fill(jets_cut[0].pT()/GeV, weight);
	if (jets_cut.size() > 1)
	_h_jet2_pT->fill(jets_cut[1].pT()/GeV, weight);
	if (jets_cut.size() > 2)
	_h_jet3_pT->fill(jets_cut[2].pT()/GeV, weight);


	// Constrained electrons
	- const ZFinder& zfinder_constrained = applyProjection<ZFinder>(e, "ZFinderConstrained");
	+ const ZFinder& zfinder_constrained = apply<ZFinder>(e, "ZFinderConstrained");
	if (zfinder_constrained.bosons().size() == 0) {
	MSG_DEBUG("No unique constrained lepton pair found.");
	return; // Not really a "veto", since if we got this far there is an unconstrained Z
	}
	_sum_of_weights_constrained += weight;
	- const Jets& jets_constrained = applyProjection<JetAlg>(e, "ConeFinderConstrained").jetsByPt(20*GeV);
	+ const Jets& jets_constrained = apply<JetAlg>(e, "ConeFinderConstrained").jetsByPt(20*GeV);
	/// @todo Replace this explicit selection with a Cut
	Jets jets_cut_constrained;
	foreach (const Jet& j, jets_constrained) {
	if (j.abseta() < 2.5) jets_cut_constrained.push_back(j);
	}
	if (jets_cut_constrained.size() > 0)
	_h_jet1_pT_constrained->fill(jets_cut_constrained[0].pT()/GeV, weight);
	if (jets_cut_constrained.size() > 1)
	_h_jet2_pT_constrained->fill(jets_cut_constrained[1].pT()/GeV, weight);
	if (jets_cut_constrained.size() > 2)
	_h_jet3_pT_constrained->fill(jets_cut_constrained[2].pT()/GeV, weight);
	}


	// Finalize
	void finalize() {
	scale(_h_jet1_pT, 1/_sum_of_weights);
	scale(_h_jet2_pT, 1/_sum_of_weights);
	scale(_h_jet3_pT, 1/_sum_of_weights);
	scale(_h_jet1_pT_constrained, 1/_sum_of_weights_constrained);
	scale(_h_jet2_pT_constrained, 1/_sum_of_weights_constrained);
	scale(_h_jet3_pT_constrained, 1/_sum_of_weights_constrained);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_jet1_pT;
	Histo1DPtr _h_jet2_pT;
	Histo1DPtr _h_jet3_pT;
	Histo1DPtr _h_jet1_pT_constrained;
	Histo1DPtr _h_jet2_pT_constrained;
	Histo1DPtr _h_jet3_pT_constrained;
	//@}

	double _sum_of_weights, _sum_of_weights_constrained;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2009_S8202443);

	}
	diff --git a/src/Analyses/D0_2009_S8320160.cc b/src/Analyses/D0_2009_S8320160.cc
	--- a/src/Analyses/D0_2009_S8320160.cc
	+++ b/src/Analyses/D0_2009_S8320160.cc
	@@ -1,94 +1,94 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief D0 dijet angular distributions
	class D0_2009_S8320160 : public Analysis {
	public:

	/// @name Construction
	//@{

	/// Constructor
	D0_2009_S8320160() : Analysis("D0_2009_S8320160")
	{
	}

	//@}


	/// @name Analysis methods
	//@{

	// Book histograms
	void init() {
	FinalState fs;
	FastJets conefinder(fs, FastJets::D0ILCONE, 0.7);
	- addProjection(conefinder, "ConeFinder");
	+ declare(conefinder, "ConeFinder");

	_h_chi_dijet.addHistogram(250., 300., bookHisto1D(1, 1, 1));
	_h_chi_dijet.addHistogram(300., 400., bookHisto1D(2, 1, 1));
	_h_chi_dijet.addHistogram(400., 500., bookHisto1D(3, 1, 1));
	_h_chi_dijet.addHistogram(500., 600., bookHisto1D(4, 1, 1));
	_h_chi_dijet.addHistogram(600., 700., bookHisto1D(5, 1, 1));
	_h_chi_dijet.addHistogram(700., 800., bookHisto1D(6, 1, 1));
	_h_chi_dijet.addHistogram(800., 900., bookHisto1D(7, 1, 1));
	_h_chi_dijet.addHistogram(900., 1000., bookHisto1D(8, 1, 1));
	_h_chi_dijet.addHistogram(1000., 1100., bookHisto1D(9, 1, 1));
	_h_chi_dijet.addHistogram(1100., 1960, bookHisto1D(10, 1, 1));
	}



	/// Do the analysis
	void analyze(const Event & e) {
	const double weight = e.weight();

	- const Jets& jets = applyProjection<JetAlg>(e, "ConeFinder").jetsByPt();
	+ const Jets& jets = apply<JetAlg>(e, "ConeFinder").jetsByPt();
	if (jets.size() < 2) vetoEvent;

	FourMomentum j0(jets[0].momentum());
	FourMomentum j1(jets[1].momentum());
	double y0 = j0.rapidity();
	double y1 = j1.rapidity();

	if (fabs(y0+y1)>2) vetoEvent;

	double mjj = FourMomentum(j0+j1).mass();
	double chi = exp(fabs(y0-y1));
	if(chi<16.) _h_chi_dijet.fill(mjj, chi, weight);
	}



	/// Finalize
	void finalize() {
	foreach (Histo1DPtr hist, _h_chi_dijet.getHistograms()) {
	normalize(hist);
	}
	}

	//@}


	private:

	/// @name Histograms
	//@{
	BinnedHistogram<double> _h_chi_dijet;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2009_S8320160);

	}
	diff --git a/src/Analyses/D0_2009_S8349509.cc b/src/Analyses/D0_2009_S8349509.cc
	--- a/src/Analyses/D0_2009_S8349509.cc
	+++ b/src/Analyses/D0_2009_S8349509.cc
	@@ -1,171 +1,171 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief D0 Z+jets angular distributions
	class D0_2009_S8349509 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	D0_2009_S8349509()
	: Analysis("D0_2009_S8349509"),
	_inclusive_Z_sumofweights(0)
	{ }

	//@}


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	Cut cut = Cuts::abseta < 1.7 && Cuts::pT > 15*GeV;
	ZFinder zfinder(FinalState(), cut, PID::MUON, 65GeV, 115GeV, 0.2, ZFinder::NOCLUSTER, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	FastJets conefinder(zfinder.remainingFinalState(), FastJets::D0ILCONE, 0.5);
	- addProjection(conefinder, "ConeFinder");
	+ declare(conefinder, "ConeFinder");

	_h_dphi_jet_Z25 = bookHisto1D(1, 1, 1);
	_h_dphi_jet_Z45 = bookHisto1D(2, 1, 1);

	_h_dy_jet_Z25 = bookHisto1D(3, 1, 1);
	_h_dy_jet_Z45 = bookHisto1D(4, 1, 1);

	_h_yboost_jet_Z25 = bookHisto1D(5, 1, 1);
	_h_yboost_jet_Z45 = bookHisto1D(6, 1, 1);

	_h_dphi_jet_Z25_xs = bookHisto1D(1, 1, 2);
	_h_dphi_jet_Z45_xs = bookHisto1D(2, 1, 2);

	_h_dy_jet_Z25_xs = bookHisto1D(3, 1, 2);
	_h_dy_jet_Z45_xs = bookHisto1D(4, 1, 2);

	_h_yboost_jet_Z25_xs = bookHisto1D(5, 1, 2);
	_h_yboost_jet_Z45_xs = bookHisto1D(6, 1, 2);

	_inclusive_Z_sumofweights = 0;
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ZFinder& zfinder = applyProjection<ZFinder>(event, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(event, "ZFinder");
	if (zfinder.bosons().size() == 1) {
	// count inclusive sum of weights for histogram normalisation
	_inclusive_Z_sumofweights += weight;

	const FourMomentum& zmom = zfinder.bosons()[0].momentum();
	if (zmom.pT() < 25*GeV) vetoEvent;

	Jets jets;
	- foreach (const Jet& j, applyProjection<JetAlg>(event, "ConeFinder").jetsByPt(20*GeV)) {
	+ foreach (const Jet& j, apply<JetAlg>(event, "ConeFinder").jetsByPt(20*GeV)) {
	if (j.abseta() < 2.8) {
	jets.push_back(j);
	break;
	}
	}

	// Return if there are no jets:
	if (jets.size() < 1) {
	MSG_DEBUG("Skipping event " << numEvents() << " because no jets pass cuts ");
	vetoEvent;
	}

	const FourMomentum& jetmom = jets[0].momentum();
	const double yZ = zmom.rapidity();
	const double yjet = jetmom.rapidity();
	const double dphi = deltaPhi(zmom, jetmom);
	const double dy = deltaRap(zmom, jetmom);
	const double yboost = fabs(yZ+yjet)/2;

	if (zmom.pT() > 25*GeV) {
	_h_dphi_jet_Z25->fill(dphi, weight);
	_h_dy_jet_Z25->fill(dy, weight);
	_h_yboost_jet_Z25->fill(yboost, weight);
	_h_dphi_jet_Z25_xs->fill(dphi, weight);
	_h_dy_jet_Z25_xs->fill(dy, weight);
	_h_yboost_jet_Z25_xs->fill(yboost, weight);
	}
	if (zmom.pT() > 45*GeV) {
	_h_dphi_jet_Z45->fill(dphi, weight);
	_h_dy_jet_Z45->fill(dy, weight);
	_h_yboost_jet_Z45->fill(yboost, weight);
	_h_dphi_jet_Z45_xs->fill(dphi, weight);
	_h_dy_jet_Z45_xs->fill(dy, weight);
	_h_yboost_jet_Z45_xs->fill(yboost, weight);
	}
	}

	}


	void finalize() {
	if (_inclusive_Z_sumofweights == 0) return;
	scale(_h_dphi_jet_Z25, 1/_inclusive_Z_sumofweights);
	scale(_h_dphi_jet_Z45, 1/_inclusive_Z_sumofweights);
	scale(_h_dy_jet_Z25, 1/_inclusive_Z_sumofweights);
	scale(_h_dy_jet_Z45, 1/_inclusive_Z_sumofweights);
	scale(_h_yboost_jet_Z25, 1/_inclusive_Z_sumofweights);
	scale(_h_yboost_jet_Z45, 1/_inclusive_Z_sumofweights);

	scale(_h_dphi_jet_Z25_xs, crossSectionPerEvent());
	scale(_h_dphi_jet_Z45_xs, crossSectionPerEvent());
	scale(_h_dy_jet_Z25_xs, crossSectionPerEvent());
	scale(_h_dy_jet_Z45_xs, crossSectionPerEvent());
	scale(_h_yboost_jet_Z25_xs, crossSectionPerEvent());
	scale(_h_yboost_jet_Z45_xs, crossSectionPerEvent());
	}

	//@}

	private:

	// Data members like post-cuts event weight counters go here

	private:

	/// @name Histograms (normalised)
	//@{
	Histo1DPtr _h_dphi_jet_Z25;
	Histo1DPtr _h_dphi_jet_Z45;

	Histo1DPtr _h_dy_jet_Z25;
	Histo1DPtr _h_dy_jet_Z45;

	Histo1DPtr _h_yboost_jet_Z25;
	Histo1DPtr _h_yboost_jet_Z45;
	//@}

	/// @name Histograms (absolute cross sections)
	//@{
	Histo1DPtr _h_dphi_jet_Z25_xs;
	Histo1DPtr _h_dphi_jet_Z45_xs;

	Histo1DPtr _h_dy_jet_Z25_xs;
	Histo1DPtr _h_dy_jet_Z45_xs;

	Histo1DPtr _h_yboost_jet_Z25_xs;
	Histo1DPtr _h_yboost_jet_Z45_xs;
	//@}

	double _inclusive_Z_sumofweights;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2009_S8349509);

	}
	diff --git a/src/Analyses/D0_2010_S8566488.cc b/src/Analyses/D0_2010_S8566488.cc
	--- a/src/Analyses/D0_2010_S8566488.cc
	+++ b/src/Analyses/D0_2010_S8566488.cc
	@@ -1,89 +1,89 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief D0 dijet invariant mass measurement
	class D0_2010_S8566488 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	D0_2010_S8566488()
	: Analysis("D0_2010_S8566488")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	FastJets conefinder(fs, FastJets::D0ILCONE, 0.7);
	- addProjection(conefinder, "ConeFinder");
	+ declare(conefinder, "ConeFinder");

	_h_m_dijet.addHistogram(0.0, 0.4, bookHisto1D(1, 1, 1));
	_h_m_dijet.addHistogram(0.4, 0.8, bookHisto1D(2, 1, 1));
	_h_m_dijet.addHistogram(0.8, 1.2, bookHisto1D(3, 1, 1));
	_h_m_dijet.addHistogram(1.2, 1.6, bookHisto1D(4, 1, 1));
	_h_m_dijet.addHistogram(1.6, 2.0, bookHisto1D(5, 1, 1));
	_h_m_dijet.addHistogram(2.0, 2.4, bookHisto1D(6, 1, 1));
	}


	/// Perform the per-event analysis
	void analyze(const Event& e) {
	const double weight = e.weight();

	- const Jets& jets = applyProjection<JetAlg>(e, "ConeFinder").jetsByPt(40.0*GeV);
	+ const Jets& jets = apply<JetAlg>(e, "ConeFinder").jetsByPt(40.0*GeV);
	if (jets.size() < 2) vetoEvent;

	FourMomentum j0(jets[0].momentum());
	FourMomentum j1(jets[1].momentum());
	double ymax = std::max(j0.absrap(), j1.absrap());
	double mjj = FourMomentum(j0+j1).mass();

	_h_m_dijet.fill(ymax, mjj/TeV, weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	_h_m_dijet.scale(crossSection()/sumOfWeights(), this);
	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here


	private:

	/// @name Histograms
	//@{
	BinnedHistogram<double> _h_m_dijet;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2010_S8566488);

	}
	diff --git a/src/Analyses/D0_2010_S8570965.cc b/src/Analyses/D0_2010_S8570965.cc
	--- a/src/Analyses/D0_2010_S8570965.cc
	+++ b/src/Analyses/D0_2010_S8570965.cc
	@@ -1,144 +1,144 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	/// @brief D0 direct photon pair production
	class D0_2010_S8570965 : public Analysis {
	public:


	D0_2010_S8570965()
	: Analysis("D0_2010_S8570965")
	{ }


	void init() {
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	IdentifiedFinalState ifs(Cuts::abseta < 0.9 && Cuts::pT > 20*GeV);
	ifs.acceptId(PID::PHOTON);
	- addProjection(ifs, "IFS");
	+ declare(ifs, "IFS");

	_h_M = bookHisto1D(1, 1, 1);
	_h_pT = bookHisto1D(2, 1, 1);
	_h_dPhi = bookHisto1D(3, 1, 1);
	_h_costheta = bookHisto1D(4, 1, 1);

	std::pair<double, double> M_ranges[] = { std::make_pair(30.0, 50.0),
	std::make_pair(50.0, 80.0),
	std::make_pair(80.0, 350.0) };

	for (size_t i = 0; i < 3; ++i) {
	_h_pT_M.addHistogram(M_ranges[i].first, M_ranges[i].second, bookHisto1D(5+3*i, 1, 1));
	_h_dPhi_M.addHistogram(M_ranges[i].first, M_ranges[i].second, bookHisto1D(6+3*i, 1, 1));
	_h_costheta_M.addHistogram(M_ranges[i].first, M_ranges[i].second, bookHisto1D(7+3*i, 1, 1));
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- Particles photons = applyProjection<IdentifiedFinalState>(event, "IFS").particlesByPt();
	+ Particles photons = apply<IdentifiedFinalState>(event, "IFS").particlesByPt();
	if (photons.size() < 2 \|\|
	(photons[0].pT() < 21.0*GeV)) {
	vetoEvent;
	}

	// Isolate photons with ET_sum in cone
	Particles isolated_photons;
	- Particles fs = applyProjection<FinalState>(event, "FS").particles();
	+ Particles fs = apply<FinalState>(event, "FS").particles();
	foreach (const Particle& photon, photons) {
	double eta_P = photon.eta();
	double phi_P = photon.phi();
	double Etsum=0.0;
	foreach (const Particle& p, fs) {
	if (p.genParticle()->barcode() != photon.genParticle()->barcode() &&
	deltaR(eta_P, phi_P, p.eta(), p.phi()) < 0.4) {
	Etsum += p.Et();
	}
	}
	if (Etsum < 2.5*GeV) {
	isolated_photons.push_back(photon);
	}
	}

	if (isolated_photons.size() != 2) {
	vetoEvent;
	}
	std::sort(isolated_photons.begin(), isolated_photons.end(), cmpMomByPt);

	FourMomentum y1=isolated_photons[0].momentum();
	FourMomentum y2=isolated_photons[1].momentum();
	if (deltaR(y1, y2)<0.4) {
	vetoEvent;
	}

	FourMomentum yy=y1+y2;
	double Myy = yy.mass()/GeV;
	if (Myy<30.0 \|\| Myy>350.0) {
	vetoEvent;
	}

	double pTyy = yy.pT()/GeV;
	if (Myy<pTyy) {
	vetoEvent;
	}

	double dPhiyy = mapAngle0ToPi(y1.phi()-y2.phi());
	if (dPhiyy<0.5*M_PI) {
	vetoEvent;
	}

	double costhetayy = fabs(tanh((y1.eta()-y2.eta())/2.0));

	_h_M->fill(Myy, weight);
	_h_pT->fill(pTyy, weight);
	_h_dPhi->fill(dPhiyy, weight);
	_h_costheta->fill(costhetayy, weight);

	_h_pT_M.fill(Myy, pTyy, weight);
	_h_dPhi_M.fill(Myy, dPhiyy, weight);
	_h_costheta_M.fill(Myy, costhetayy, weight);
	}


	void finalize() {

	scale(_h_M, crossSection()/sumOfWeights());
	scale(_h_pT, crossSection()/sumOfWeights());
	scale(_h_dPhi, crossSection()/sumOfWeights());
	scale(_h_costheta, crossSection()/sumOfWeights());

	_h_pT_M.scale(crossSection()/sumOfWeights(), this);
	_h_dPhi_M.scale(crossSection()/sumOfWeights(), this);
	_h_costheta_M.scale(crossSection()/sumOfWeights(), this);

	}


	private:

	Histo1DPtr _h_M;
	Histo1DPtr _h_pT;
	Histo1DPtr _h_dPhi;
	Histo1DPtr _h_costheta;
	BinnedHistogram<double> _h_pT_M;
	BinnedHistogram<double> _h_dPhi_M;
	BinnedHistogram<double> _h_costheta_M;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2010_S8570965);

	}
	diff --git a/src/Analyses/D0_2010_S8671338.cc b/src/Analyses/D0_2010_S8671338.cc
	--- a/src/Analyses/D0_2010_S8671338.cc
	+++ b/src/Analyses/D0_2010_S8671338.cc
	@@ -1,70 +1,70 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {




	/// @brief Measurement of Z(->muon muon) pT differential cross-section
	/// @author Flavia Dias
	class D0_2010_S8671338 : public Analysis {
	public:

	/// Constructor
	D0_2010_S8671338()
	: Analysis("D0_2010_S8671338")
	{ }


	///@name Analysis methods
	//@{

	/// Add projections and book histograms
	void init() {
	Cut cut = Cuts::abseta < 1.7 && Cuts::pT > 15*GeV;
	ZFinder zfinder(FinalState(), cut, PID::MUON, 65GeV, 115GeV, 0.2, ZFinder::NOCLUSTER, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	_h_Z_pT_normalised = bookHisto1D(1, 1, 1);
	_h_Z_pT_xs = bookHisto1D(2, 1, 1);
	}


	// Do the analysis
	void analyze(const Event& e) {
	const double weight = e.weight();
	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	if (zfinder.bosons().size()==1) {
	double ZpT = zfinder.bosons()[0].pT()/GeV;
	_h_Z_pT_normalised->fill(ZpT, weight);
	_h_Z_pT_xs->fill(ZpT, weight);
	}
	}


	/// Finalize
	void finalize() {
	normalize(_h_Z_pT_normalised);
	scale(_h_Z_pT_xs, crossSection()/sumOfWeights());
	}

	//@}


	private:

	/// @name Histogram
	Histo1DPtr _h_Z_pT_normalised;
	Histo1DPtr _h_Z_pT_xs;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2010_S8671338);

	}
	diff --git a/src/Analyses/D0_2010_S8821313.cc b/src/Analyses/D0_2010_S8821313.cc
	--- a/src/Analyses/D0_2010_S8821313.cc
	+++ b/src/Analyses/D0_2010_S8821313.cc
	@@ -1,105 +1,105 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {




	class D0_2010_S8821313 : public Analysis {
	public:

	/// Constructor
	D0_2010_S8821313()
	: Analysis("D0_2010_S8821313")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections
	FinalState fs;
	Cut cuts = (Cuts::abseta < 1.1 \|\| Cuts::absetaIn( 1.5, 3.0)) && Cuts::pT > 20*GeV;
	ZFinder zfinder_ee(fs, cuts, PID::ELECTRON, 70GeV, 110GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder_ee, "zfinder_ee");
	+ declare(zfinder_ee, "zfinder_ee");
	ZFinder zfinder_mm(fs, Cuts::abseta < 2 && Cuts::pT > 15GeV, PID::MUON, 70GeV, 110*GeV, 0.0, ZFinder::NOCLUSTER, ZFinder::NOTRACK);
	- addProjection(zfinder_mm, "zfinder_mm");
	+ declare(zfinder_mm, "zfinder_mm");

	/// Book histograms here
	_h_phistar_ee.addHistogram(0.0, 1.0, bookHisto1D(1, 1, 1));
	_h_phistar_ee.addHistogram(1.0, 2.0, bookHisto1D(1, 1, 2));
	_h_phistar_ee.addHistogram(2.0, 10.0, bookHisto1D(1, 1, 3));
	_h_phistar_mm.addHistogram(0.0, 1.0, bookHisto1D(2, 1, 1));
	_h_phistar_mm.addHistogram(1.0, 2.0, bookHisto1D(2, 1, 2));
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ZFinder& zfinder_ee = applyProjection<ZFinder>(event, "zfinder_ee");
	+ const ZFinder& zfinder_ee = apply<ZFinder>(event, "zfinder_ee");
	if (zfinder_ee.bosons().size() == 1) {
	Particles ee = zfinder_ee.constituents();
	std::sort(ee.begin(), ee.end(), cmpMomByPt);
	const FourMomentum& eminus = PID::threeCharge(ee[0].pid()) < 0 ? ee[0].momentum() : ee[1].momentum();
	const FourMomentum& eplus = PID::threeCharge(ee[0].pid()) < 0 ? ee[1].momentum() : ee[0].momentum();
	double phi_acop = M_PI - mapAngle0ToPi(eminus.phi() - eplus.phi());
	double costhetastar = tanh((eminus.eta() - eplus.eta())/2);
	double sin2thetastar = 1 - sqr(costhetastar);
	if (sin2thetastar < 0) sin2thetastar = 0;
	const double phistar = tan(phi_acop/2) * sqrt(sin2thetastar);
	const FourMomentum& zmom = zfinder_ee.bosons()[0].momentum();
	_h_phistar_ee.fill(zmom.rapidity(), phistar, weight);
	}

	- const ZFinder& zfinder_mm = applyProjection<ZFinder>(event, "zfinder_mm");
	+ const ZFinder& zfinder_mm = apply<ZFinder>(event, "zfinder_mm");
	if (zfinder_mm.bosons().size() == 1) {
	Particles mm = zfinder_mm.constituents();
	std::sort(mm.begin(), mm.end(), cmpMomByPt);
	const FourMomentum& mminus = PID::threeCharge(mm[0].pid()) < 0 ? mm[0].momentum() : mm[1].momentum();
	const FourMomentum& mplus = PID::threeCharge(mm[0].pid()) < 0 ? mm[1].momentum() : mm[0].momentum();
	double phi_acop = M_PI - mapAngle0ToPi(mminus.phi() - mplus.phi());
	double costhetastar = tanh((mminus.eta() - mplus.eta())/2);
	double sin2thetastar = 1 - sqr(costhetastar);
	if (sin2thetastar < 0) sin2thetastar = 0;
	const double phistar = tan(phi_acop/2) * sqrt(sin2thetastar);
	const FourMomentum& zmom = zfinder_mm.bosons()[0].momentum();
	_h_phistar_mm.fill(zmom.rapidity(), phistar, weight);
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	foreach (Histo1DPtr hist, _h_phistar_ee.getHistograms()) normalize(hist);
	foreach (Histo1DPtr hist, _h_phistar_mm.getHistograms()) normalize(hist);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	BinnedHistogram<double> _h_phistar_ee;
	BinnedHistogram<double> _h_phistar_mm;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2010_S8821313);

	}
	diff --git a/src/Analyses/D0_2011_I895662.cc b/src/Analyses/D0_2011_I895662.cc
	--- a/src/Analyses/D0_2011_I895662.cc
	+++ b/src/Analyses/D0_2011_I895662.cc
	@@ -1,95 +1,95 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	class D0_2011_I895662 : public Analysis {
	public:

	D0_2011_I895662()
	: Analysis("D0_2011_I895662")
	{ }


	public:

	void init() {
	FastJets jets(FinalState(-3.6, 3.6, 0.*GeV), FastJets::D0ILCONE, 0.7);
	jets.useInvisibles();
	- addProjection(jets, "Jets");
	+ declare(jets, "Jets");

	_h_m3j_08_40 = bookHisto1D(1, 1, 1);
	_h_m3j_16_40 = bookHisto1D(2, 1, 1);
	_h_m3j_24_40 = bookHisto1D(3, 1, 1);
	_h_m3j_24_70 = bookHisto1D(4, 1, 1);
	_h_m3j_24_100 = bookHisto1D(5, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- Jets jets = applyProjection<FastJets>(event, "Jets").jetsByPt(40.*GeV);
	+ Jets jets = apply<FastJets>(event, "Jets").jetsByPt(40.*GeV);

	// Need three jets, leading jet above 150 GeV
	if (jets.size() < 3 \|\| jets[0].pT() <= 150.*GeV) vetoEvent;

	std::vector<FourMomentum> p;
	for (size_t i=0; i<3; i++) {
	p.push_back(jets[i].momentum());
	}

	// Jets need to be separated by 2*Rcone
	if (deltaR(p[0], p[1], RAPIDITY) < 1.4 \|\|
	deltaR(p[0], p[2], RAPIDITY) < 1.4 \|\|
	deltaR(p[1], p[2], RAPIDITY) < 1.4)
	vetoEvent;

	// Leading three jets need to be within \|y\|<2.4
	double ymax = fabs(p[0].rapidity());
	for (size_t i=1; i<3; i++) {
	if (ymax < fabs(p[i].rapidity())) ymax = fabs(p[i].rapidity());
	}
	if (ymax >= 2.4) vetoEvent;

	double m3jet = (p[0]+p[1]+p[2]).mass()/GeV;

	if (ymax < 0.8) _h_m3j_08_40->fill(m3jet, weight);
	if (ymax < 1.6) _h_m3j_16_40->fill(m3jet, weight);
	if (ymax < 2.4) {
	_h_m3j_24_40->fill(m3jet, weight);
	if (p[2].pT() > 70.*GeV) _h_m3j_24_70->fill(m3jet, weight);
	if (p[2].pT() > 100.*GeV) _h_m3j_24_100->fill(m3jet, weight);
	}

	}


	void finalize() {
	// Factor of 1000 is based on GeV <-> TeV mismatch between paper and Hepdata table
	scale(_h_m3j_08_40, 1000*crossSection()/picobarn/sumOfWeights());
	scale(_h_m3j_16_40, 1000*crossSection()/picobarn/sumOfWeights());
	scale(_h_m3j_24_40, 1000*crossSection()/picobarn/sumOfWeights());
	scale(_h_m3j_24_70, 1000*crossSection()/picobarn/sumOfWeights());
	scale(_h_m3j_24_100, 1000*crossSection()/picobarn/sumOfWeights());
	}


	private:

	Histo1DPtr _h_m3j_08_40;
	Histo1DPtr _h_m3j_16_40;
	Histo1DPtr _h_m3j_24_40;
	Histo1DPtr _h_m3j_24_70;
	Histo1DPtr _h_m3j_24_100;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2011_I895662);

	}
	diff --git a/src/Analyses/D0_2015_I1324946.cc b/src/Analyses/D0_2015_I1324946.cc
	--- a/src/Analyses/D0_2015_I1324946.cc
	+++ b/src/Analyses/D0_2015_I1324946.cc
	@@ -1,104 +1,104 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {

	using namespace Cuts;

	class D0_2015_I1324946 : public Analysis {
	public:

	/// Constructor
	D0_2015_I1324946()
	: Analysis("D0_2015_I1324946")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	FinalState fs;
	ZFinder zfinder_mm(fs, Cuts::abseta < 2 && Cuts::pT > 15GeV, PID::MUON, 30GeV, 500*GeV, 0.0, ZFinder::NOCLUSTER, ZFinder::NOTRACK);
	- addProjection(zfinder_mm, "zfinder_mm");
	+ declare(zfinder_mm, "zfinder_mm");

	_h_phistar_mm_peak_central = bookHisto1D(1, 1, 1);
	_h_phistar_mm_peak_forward = bookHisto1D(1, 1, 2);
	_h_phistar_mm_low_central = bookHisto1D(2, 1, 1);
	_h_phistar_mm_low_forward = bookHisto1D(2, 1, 2);
	_h_phistar_mm_high1 = bookHisto1D(3, 1, 1);
	_h_phistar_mm_high2 = bookHisto1D(4, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();


	//70<Mmm<105
	- const ZFinder& zfinder_mm = applyProjection<ZFinder>(event, "zfinder_mm");
	+ const ZFinder& zfinder_mm = apply<ZFinder>(event, "zfinder_mm");
	if (zfinder_mm.bosons().size() == 1) {
	Particles mm = zfinder_mm.constituents();
	std::sort(mm.begin(), mm.end(), cmpMomByPt);
	const FourMomentum& mminus = PID::threeCharge(mm[0].pid()) < 0 ? mm[0].momentum() : mm[1].momentum();
	const FourMomentum& mplus = PID::threeCharge(mm[0].pid()) < 0 ? mm[1].momentum() : mm[0].momentum();
	double phi_acop = M_PI - mapAngle0ToPi(mminus.phi() - mplus.phi());
	double costhetastar = tanh((mminus.eta() - mplus.eta())/2);
	double sin2thetastar = 1 - sqr(costhetastar);
	if (sin2thetastar < 0) sin2thetastar = 0;
	const double phistar = tan(phi_acop/2) * sqrt(sin2thetastar);
	const FourMomentum& zmom = zfinder_mm.bosons()[0].momentum();
	if (zmom.mass()<30GeV \|\| zmom.mass() >500GeV) vetoEvent;

	if( zmom.mass()>70 && zmom.mass()<100 && zmom.absrap()<1.0) _h_phistar_mm_peak_central->fill(phistar, weight);
	if( zmom.mass()>70 && zmom.mass()<100 && zmom.absrap()>1.0 && zmom.absrap()<2.0) _h_phistar_mm_peak_forward->fill(phistar, weight);
	if( zmom.mass()>30 && zmom.mass()<60 && zmom.absrap()<1.0) _h_phistar_mm_low_central->fill(phistar, weight);
	if( zmom.mass()>30 && zmom.mass()<60 && zmom.absrap()>1.0 && zmom.absrap()<2.0) _h_phistar_mm_low_forward->fill(phistar, weight);
	if( zmom.mass()>160 && zmom.mass()<300) _h_phistar_mm_high1->fill(phistar, weight);
	if( zmom.mass()>300 && zmom.mass()<500) _h_phistar_mm_high2->fill(phistar, weight);

	}
	}

	/// Normalise histograms etc., after the run
	void finalize() {

	normalize(_h_phistar_mm_low_central);
	normalize(_h_phistar_mm_low_forward);
	normalize(_h_phistar_mm_peak_central);
	normalize(_h_phistar_mm_peak_forward);
	normalize(_h_phistar_mm_high1);
	normalize(_h_phistar_mm_high2);

	}


	//}

	//@}


	private:
	/// @name Histograms
	//@{

	Histo1DPtr _h_phistar_mm_low_central;
	Histo1DPtr _h_phistar_mm_low_forward;
	Histo1DPtr _h_phistar_mm_peak_central;
	Histo1DPtr _h_phistar_mm_peak_forward;
	Histo1DPtr _h_phistar_mm_high1;
	Histo1DPtr _h_phistar_mm_high2;
	//@}
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(D0_2015_I1324946);

	}
	diff --git a/src/Analyses/DELPHI_1995_S3137023.cc b/src/Analyses/DELPHI_1995_S3137023.cc
	--- a/src/Analyses/DELPHI_1995_S3137023.cc
	+++ b/src/Analyses/DELPHI_1995_S3137023.cc
	@@ -1,107 +1,107 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief DELPHI strange baryon paper
	/// @author Hendrik Hoeth
	class DELPHI_1995_S3137023 : public Analysis {
	public:

	/// Constructor
	DELPHI_1995_S3137023()
	: Analysis("DELPHI_1995_S3137023")
	{
	_weightedTotalNumXiMinus = 0;
	_weightedTotalNumSigma1385Plus = 0;
	}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");

	_histXpXiMinus = bookHisto1D(2, 1, 1);
	_histXpSigma1385Plus = bookHisto1D(3, 1, 1);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	const int id = p.abspid();
	switch (id) {
	case 3312:
	_histXpXiMinus->fill(p.p3().mod()/meanBeamMom, weight);
	_weightedTotalNumXiMinus += weight;
	break;
	case 3114: case 3224:
	_histXpSigma1385Plus->fill(p.p3().mod()/meanBeamMom, weight);
	_weightedTotalNumSigma1385Plus += weight;
	break;
	}
	}

	}


	/// Finalize
	void finalize() {
	normalize(_histXpXiMinus , _weightedTotalNumXiMinus/sumOfWeights());
	normalize(_histXpSigma1385Plus , _weightedTotalNumSigma1385Plus/sumOfWeights());
	}

	//@}


	private:

	/// Store the weighted sums of numbers of charged / charged+neutral
	/// particles - used to calculate average number of particles for the
	/// inclusive single particle distributions' normalisations.
	double _weightedTotalNumXiMinus;
	double _weightedTotalNumSigma1385Plus;

	Histo1DPtr _histXpXiMinus;
	Histo1DPtr _histXpSigma1385Plus;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(DELPHI_1995_S3137023);

	}
	diff --git a/src/Analyses/DELPHI_1996_S3430090.cc b/src/Analyses/DELPHI_1996_S3430090.cc
	--- a/src/Analyses/DELPHI_1996_S3430090.cc
	+++ b/src/Analyses/DELPHI_1996_S3430090.cc
	@@ -1,552 +1,552 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/Sphericity.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ParisiTensor.hh"
	#include "Rivet/Projections/Hemispheres.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/**
	* @brief DELPHI event shapes and identified particle spectra
	* @author Andy Buckley
	* @author Hendrik Hoeth
	*
	* This is the paper which was used for the original PROFESSOR MC tuning
	* study. It studies a wide range of e+ e- event shape variables, differential
	* jet rates in the Durham and JADE schemes, and incorporates identified
	* particle spectra, from other LEP analyses.
	*
	* @par Run conditions
	*
	* @arg LEP1 beam energy: \f$ \sqrt{s} = \f$ 91.2 GeV
	* @arg Run with generic QCD events.
	* @arg No \f$ p_\perp^\text{min} \f$ cutoff is required
	*/
	class DELPHI_1996_S3430090 : public Analysis {
	public:

	/// Constructor
	DELPHI_1996_S3430090()
	: Analysis("DELPHI_1996_S3430090")
	{
	_weightedTotalPartNum = 0.0;
	_passedCutWeightSum = 0.0;
	_passedCut3WeightSum = 0.0;
	_passedCut4WeightSum = 0.0;
	_passedCut5WeightSum = 0.0;
	}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	+ declare(Beam(), "Beams");
	// Don't try to introduce a pT or eta cut here. It's all corrected
	// back. (See Section 2 of the paper.)
	const ChargedFinalState cfs;
	- addProjection(cfs, "FS");
	- addProjection(UnstableFinalState(), "UFS");
	- addProjection(FastJets(cfs, FastJets::JADE, 0.7), "JadeJets");
	- addProjection(FastJets(cfs, FastJets::DURHAM, 0.7), "DurhamJets");
	- addProjection(Sphericity(cfs), "Sphericity");
	- addProjection(ParisiTensor(cfs), "Parisi");
	+ declare(cfs, "FS");
	+ declare(UnstableFinalState(), "UFS");
	+ declare(FastJets(cfs, FastJets::JADE, 0.7), "JadeJets");
	+ declare(FastJets(cfs, FastJets::DURHAM, 0.7), "DurhamJets");
	+ declare(Sphericity(cfs), "Sphericity");
	+ declare(ParisiTensor(cfs), "Parisi");
	const Thrust thrust(cfs);
	- addProjection(thrust, "Thrust");
	- addProjection(Hemispheres(thrust), "Hemispheres");
	+ declare(thrust, "Thrust");
	+ declare(Hemispheres(thrust), "Hemispheres");

	_histPtTIn = bookHisto1D(1, 1, 1);
	_histPtTOut = bookHisto1D(2, 1, 1);
	_histPtSIn = bookHisto1D(3, 1, 1);
	_histPtSOut = bookHisto1D(4, 1, 1);

	_histRapidityT = bookHisto1D(5, 1, 1);
	_histRapidityS = bookHisto1D(6, 1, 1);
	_histScaledMom = bookHisto1D(7, 1, 1);
	_histLogScaledMom = bookHisto1D(8, 1, 1);

	_histPtTOutVsXp = bookProfile1D(9, 1, 1);
	_histPtVsXp = bookProfile1D(10, 1, 1);

	_hist1MinusT = bookHisto1D(11, 1, 1);
	_histTMajor = bookHisto1D(12, 1, 1);
	_histTMinor = bookHisto1D(13, 1, 1);
	_histOblateness = bookHisto1D(14, 1, 1);

	_histSphericity = bookHisto1D(15, 1, 1);
	_histAplanarity = bookHisto1D(16, 1, 1);
	_histPlanarity = bookHisto1D(17, 1, 1);

	_histCParam = bookHisto1D(18, 1, 1);
	_histDParam = bookHisto1D(19, 1, 1);

	_histHemiMassH = bookHisto1D(20, 1, 1);
	_histHemiMassL = bookHisto1D(21, 1, 1);
	_histHemiMassD = bookHisto1D(22, 1, 1);

	_histHemiBroadW = bookHisto1D(23, 1, 1);
	_histHemiBroadN = bookHisto1D(24, 1, 1);
	_histHemiBroadT = bookHisto1D(25, 1, 1);
	_histHemiBroadD = bookHisto1D(26, 1, 1);

	// Binned in y_cut
	_histDiffRate2Durham = bookHisto1D(27, 1, 1);
	_histDiffRate2Jade = bookHisto1D(28, 1, 1);
	_histDiffRate3Durham = bookHisto1D(29, 1, 1);
	_histDiffRate3Jade = bookHisto1D(30, 1, 1);
	_histDiffRate4Durham = bookHisto1D(31, 1, 1);
	_histDiffRate4Jade = bookHisto1D(32, 1, 1);

	// Binned in cos(chi)
	_histEEC = bookHisto1D(33, 1, 1);
	_histAEEC = bookHisto1D(34, 1, 1);

	_histMultiCharged = bookHisto1D(35, 1, 1);

	_histMultiPiPlus = bookHisto1D(36, 1, 1);
	_histMultiPi0 = bookHisto1D(36, 1, 2);
	_histMultiKPlus = bookHisto1D(36, 1, 3);
	_histMultiK0 = bookHisto1D(36, 1, 4);
	_histMultiEta = bookHisto1D(36, 1, 5);
	_histMultiEtaPrime = bookHisto1D(36, 1, 6);
	_histMultiDPlus = bookHisto1D(36, 1, 7);
	_histMultiD0 = bookHisto1D(36, 1, 8);
	_histMultiBPlus0 = bookHisto1D(36, 1, 9);

	_histMultiF0 = bookHisto1D(37, 1, 1);

	_histMultiRho = bookHisto1D(38, 1, 1);
	_histMultiKStar892Plus = bookHisto1D(38, 1, 2);
	_histMultiKStar892_0 = bookHisto1D(38, 1, 3);
	_histMultiPhi = bookHisto1D(38, 1, 4);
	_histMultiDStar2010Plus = bookHisto1D(38, 1, 5);

	_histMultiF2 = bookHisto1D(39, 1, 1);
	_histMultiK2Star1430_0 = bookHisto1D(39, 1, 2);

	_histMultiP = bookHisto1D(40, 1, 1);
	_histMultiLambda0 = bookHisto1D(40, 1, 2);
	_histMultiXiMinus = bookHisto1D(40, 1, 3);
	_histMultiOmegaMinus = bookHisto1D(40, 1, 4);
	_histMultiDeltaPlusPlus = bookHisto1D(40, 1, 5);
	_histMultiSigma1385Plus = bookHisto1D(40, 1, 6);
	_histMultiXi1530_0 = bookHisto1D(40, 1, 7);
	_histMultiLambdaB0 = bookHisto1D(40, 1, 8);
	}



	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();
	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");
	const double weight = e.weight();
	_passedCutWeightSum += weight;
	_weightedTotalPartNum += numParticles * weight;

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Thrusts
	MSG_DEBUG("Calculating thrust");
	- const Thrust& thrust = applyProjection<Thrust>(e, "Thrust");
	+ const Thrust& thrust = apply<Thrust>(e, "Thrust");
	_hist1MinusT->fill(1 - thrust.thrust(), weight);
	_histTMajor->fill(thrust.thrustMajor(), weight);
	_histTMinor->fill(thrust.thrustMinor(), weight);
	_histOblateness->fill(thrust.oblateness(), weight);

	// Jets
	- const FastJets& durjet = applyProjection<FastJets>(e, "DurhamJets");
	- const FastJets& jadejet = applyProjection<FastJets>(e, "JadeJets");
	+ const FastJets& durjet = apply<FastJets>(e, "DurhamJets");
	+ const FastJets& jadejet = apply<FastJets>(e, "JadeJets");
	if (numParticles >= 3) {
	_passedCut3WeightSum += weight;
	if (durjet.clusterSeq()) _histDiffRate2Durham->fill(durjet.clusterSeq()->exclusive_ymerge_max(2), weight);
	if (jadejet.clusterSeq()) _histDiffRate2Jade->fill(jadejet.clusterSeq()->exclusive_ymerge_max(2), weight);
	}
	if (numParticles >= 4) {
	_passedCut4WeightSum += weight;
	if (durjet.clusterSeq()) _histDiffRate3Durham->fill(durjet.clusterSeq()->exclusive_ymerge_max(3), weight);
	if (jadejet.clusterSeq()) _histDiffRate3Jade->fill(jadejet.clusterSeq()->exclusive_ymerge_max(3), weight);
	}
	if (numParticles >= 5) {
	_passedCut5WeightSum += weight;
	if (durjet.clusterSeq()) _histDiffRate4Durham->fill(durjet.clusterSeq()->exclusive_ymerge_max(4), weight);
	if (jadejet.clusterSeq()) _histDiffRate4Jade->fill(jadejet.clusterSeq()->exclusive_ymerge_max(4), weight);
	}

	// Sphericities
	MSG_DEBUG("Calculating sphericity");
	- const Sphericity& sphericity = applyProjection<Sphericity>(e, "Sphericity");
	+ const Sphericity& sphericity = apply<Sphericity>(e, "Sphericity");
	_histSphericity->fill(sphericity.sphericity(), weight);
	_histAplanarity->fill(sphericity.aplanarity(), weight);
	_histPlanarity->fill(sphericity.planarity(), weight);

	// C & D params
	MSG_DEBUG("Calculating Parisi params");
	- const ParisiTensor& parisi = applyProjection<ParisiTensor>(e, "Parisi");
	+ const ParisiTensor& parisi = apply<ParisiTensor>(e, "Parisi");
	_histCParam->fill(parisi.C(), weight);
	_histDParam->fill(parisi.D(), weight);

	// Hemispheres
	MSG_DEBUG("Calculating hemisphere variables");
	- const Hemispheres& hemi = applyProjection<Hemispheres>(e, "Hemispheres");
	+ const Hemispheres& hemi = apply<Hemispheres>(e, "Hemispheres");
	_histHemiMassH->fill(hemi.scaledM2high(), weight);
	_histHemiMassL->fill(hemi.scaledM2low(), weight);
	_histHemiMassD->fill(hemi.scaledM2diff(), weight);
	_histHemiBroadW->fill(hemi.Bmax(), weight);
	_histHemiBroadN->fill(hemi.Bmin(), weight);
	_histHemiBroadT->fill(hemi.Bsum(), weight);
	_histHemiBroadD->fill(hemi.Bdiff(), weight);

	// Iterate over all the charged final state particles.
	double Evis = 0.0;
	double Evis2 = 0.0;
	MSG_DEBUG("About to iterate over charged FS particles");
	foreach (const Particle& p, fs.particles()) {
	// Get momentum and energy of each particle.
	const Vector3 mom3 = p.p3();
	const double energy = p.E();
	Evis += energy;

	// Scaled momenta.
	const double mom = mom3.mod();
	const double scaledMom = mom/meanBeamMom;
	const double logInvScaledMom = -std::log(scaledMom);
	_histLogScaledMom->fill(logInvScaledMom, weight);
	_histScaledMom->fill(scaledMom, weight);

	// Get momenta components w.r.t. thrust and sphericity.
	const double momT = dot(thrust.thrustAxis(), mom3);
	const double momS = dot(sphericity.sphericityAxis(), mom3);
	const double pTinT = dot(mom3, thrust.thrustMajorAxis());
	const double pToutT = dot(mom3, thrust.thrustMinorAxis());
	const double pTinS = dot(mom3, sphericity.sphericityMajorAxis());
	const double pToutS = dot(mom3, sphericity.sphericityMinorAxis());
	const double pT = sqrt(pow(pTinT, 2) + pow(pToutT, 2));
	_histPtTIn->fill(fabs(pTinT/GeV), weight);
	_histPtTOut->fill(fabs(pToutT/GeV), weight);
	_histPtSIn->fill(fabs(pTinS/GeV), weight);
	_histPtSOut->fill(fabs(pToutS/GeV), weight);
	_histPtVsXp->fill(scaledMom, fabs(pT/GeV), weight);
	_histPtTOutVsXp->fill(scaledMom, fabs(pToutT/GeV), weight);

	// Calculate rapidities w.r.t. thrust and sphericity.
	const double rapidityT = 0.5 * std::log((energy + momT) / (energy - momT));
	const double rapidityS = 0.5 * std::log((energy + momS) / (energy - momS));
	_histRapidityT->fill(fabs(rapidityT), weight);
	_histRapidityS->fill(fabs(rapidityS), weight);
	MSG_TRACE(fabs(rapidityT) << " " << scaledMom/GeV);
	}
	Evis2 = Evis*Evis;

	// (A)EEC
	// Need iterators since second loop starts at current outer loop iterator, i.e. no "foreach" here!
	for (Particles::const_iterator p_i = fs.particles().begin(); p_i != fs.particles().end(); ++p_i) {
	for (Particles::const_iterator p_j = p_i; p_j != fs.particles().end(); ++p_j) {
	if (p_i == p_j) continue;
	const Vector3 mom3_i = p_i->momentum().p3();
	const Vector3 mom3_j = p_j->momentum().p3();
	const double energy_i = p_i->momentum().E();
	const double energy_j = p_j->momentum().E();
	const double cosij = dot(mom3_i.unit(), mom3_j.unit());
	const double eec = (energy_i*energy_j) / Evis2;
	_histEEC->fill(cosij, eec*weight);
	if (cosij < 0)
	_histAEEC->fill( cosij, eec*weight);
	else
	_histAEEC->fill(-cosij, -eec*weight);
	}
	}

	_histMultiCharged->fill(_histMultiCharged->bin(0).xMid(), numParticles*weight);


	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	int id = p.abspid();
	switch (id) {
	case 211:
	_histMultiPiPlus->fill(_histMultiPiPlus->bin(0).xMid(), weight);
	break;
	case 111:
	_histMultiPi0->fill(_histMultiPi0->bin(0).xMid(), weight);
	break;
	case 321:
	_histMultiKPlus->fill(_histMultiKPlus->bin(0).xMid(), weight);
	break;
	case 130:
	case 310:
	_histMultiK0->fill(_histMultiK0->bin(0).xMid(), weight);
	break;
	case 221:
	_histMultiEta->fill(_histMultiEta->bin(0).xMid(), weight);
	break;
	case 331:
	_histMultiEtaPrime->fill(_histMultiEtaPrime->bin(0).xMid(), weight);
	break;
	case 411:
	_histMultiDPlus->fill(_histMultiDPlus->bin(0).xMid(), weight);
	break;
	case 421:
	_histMultiD0->fill(_histMultiD0->bin(0).xMid(), weight);
	break;
	case 511:
	case 521:
	case 531:
	_histMultiBPlus0->fill(_histMultiBPlus0->bin(0).xMid(), weight);
	break;
	case 9010221:
	_histMultiF0->fill(_histMultiF0->bin(0).xMid(), weight);
	break;
	case 113:
	_histMultiRho->fill(_histMultiRho->bin(0).xMid(), weight);
	break;
	case 323:
	_histMultiKStar892Plus->fill(_histMultiKStar892Plus->bin(0).xMid(), weight);
	break;
	case 313:
	_histMultiKStar892_0->fill(_histMultiKStar892_0->bin(0).xMid(), weight);
	break;
	case 333:
	_histMultiPhi->fill(_histMultiPhi->bin(0).xMid(), weight);
	break;
	case 413:
	_histMultiDStar2010Plus->fill(_histMultiDStar2010Plus->bin(0).xMid(), weight);
	break;
	case 225:
	_histMultiF2->fill(_histMultiF2->bin(0).xMid(), weight);
	break;
	case 315:
	_histMultiK2Star1430_0->fill(_histMultiK2Star1430_0->bin(0).xMid(), weight);
	break;
	case 2212:
	_histMultiP->fill(_histMultiP->bin(0).xMid(), weight);
	break;
	case 3122:
	_histMultiLambda0->fill(_histMultiLambda0->bin(0).xMid(), weight);
	break;
	case 3312:
	_histMultiXiMinus->fill(_histMultiXiMinus->bin(0).xMid(), weight);
	break;
	case 3334:
	_histMultiOmegaMinus->fill(_histMultiOmegaMinus->bin(0).xMid(), weight);
	break;
	case 2224:
	_histMultiDeltaPlusPlus->fill(_histMultiDeltaPlusPlus->bin(0).xMid(), weight);
	break;
	case 3114:
	_histMultiSigma1385Plus->fill(_histMultiSigma1385Plus->bin(0).xMid(), weight);
	break;
	case 3324:
	_histMultiXi1530_0->fill(_histMultiXi1530_0->bin(0).xMid(), weight);
	break;
	case 5122:
	_histMultiLambdaB0->fill(_histMultiLambdaB0->bin(0).xMid(), weight);
	break;
	}
	}
	}



	// Finalize
	void finalize() {
	// Normalize inclusive single particle distributions to the average number
	// of charged particles per event.
	const double avgNumParts = _weightedTotalPartNum / _passedCutWeightSum;

	normalize(_histPtTIn, avgNumParts);
	normalize(_histPtTOut, avgNumParts);
	normalize(_histPtSIn, avgNumParts);
	normalize(_histPtSOut, avgNumParts);

	normalize(_histRapidityT, avgNumParts);
	normalize(_histRapidityS, avgNumParts);

	normalize(_histLogScaledMom, avgNumParts);
	normalize(_histScaledMom, avgNumParts);

	scale(_histEEC, 1.0/_passedCutWeightSum);
	scale(_histAEEC, 1.0/_passedCutWeightSum);
	scale(_histMultiCharged, 1.0/_passedCutWeightSum);

	scale(_histMultiPiPlus, 1.0/_passedCutWeightSum);
	scale(_histMultiPi0, 1.0/_passedCutWeightSum);
	scale(_histMultiKPlus, 1.0/_passedCutWeightSum);
	scale(_histMultiK0, 1.0/_passedCutWeightSum);
	scale(_histMultiEta, 1.0/_passedCutWeightSum);
	scale(_histMultiEtaPrime, 1.0/_passedCutWeightSum);
	scale(_histMultiDPlus, 1.0/_passedCutWeightSum);
	scale(_histMultiD0, 1.0/_passedCutWeightSum);
	scale(_histMultiBPlus0, 1.0/_passedCutWeightSum);

	scale(_histMultiF0, 1.0/_passedCutWeightSum);

	scale(_histMultiRho, 1.0/_passedCutWeightSum);
	scale(_histMultiKStar892Plus, 1.0/_passedCutWeightSum);
	scale(_histMultiKStar892_0, 1.0/_passedCutWeightSum);
	scale(_histMultiPhi, 1.0/_passedCutWeightSum);
	scale(_histMultiDStar2010Plus, 1.0/_passedCutWeightSum);

	scale(_histMultiF2, 1.0/_passedCutWeightSum);
	scale(_histMultiK2Star1430_0, 1.0/_passedCutWeightSum);

	scale(_histMultiP, 1.0/_passedCutWeightSum);
	scale(_histMultiLambda0, 1.0/_passedCutWeightSum);
	scale(_histMultiXiMinus, 1.0/_passedCutWeightSum);
	scale(_histMultiOmegaMinus, 1.0/_passedCutWeightSum);
	scale(_histMultiDeltaPlusPlus, 1.0/_passedCutWeightSum);
	scale(_histMultiSigma1385Plus, 1.0/_passedCutWeightSum);
	scale(_histMultiXi1530_0, 1.0/_passedCutWeightSum);
	scale(_histMultiLambdaB0, 1.0/_passedCutWeightSum);

	scale(_hist1MinusT, 1.0/_passedCutWeightSum);
	scale(_histTMajor, 1.0/_passedCutWeightSum);
	scale(_histTMinor, 1.0/_passedCutWeightSum);
	scale(_histOblateness, 1.0/_passedCutWeightSum);

	scale(_histSphericity, 1.0/_passedCutWeightSum);
	scale(_histAplanarity, 1.0/_passedCutWeightSum);
	scale(_histPlanarity, 1.0/_passedCutWeightSum);

	scale(_histHemiMassD, 1.0/_passedCutWeightSum);
	scale(_histHemiMassH, 1.0/_passedCutWeightSum);
	scale(_histHemiMassL, 1.0/_passedCutWeightSum);

	scale(_histHemiBroadW, 1.0/_passedCutWeightSum);
	scale(_histHemiBroadN, 1.0/_passedCutWeightSum);
	scale(_histHemiBroadT, 1.0/_passedCutWeightSum);
	scale(_histHemiBroadD, 1.0/_passedCutWeightSum);

	scale(_histCParam, 1.0/_passedCutWeightSum);
	scale(_histDParam, 1.0/_passedCutWeightSum);

	scale(_histDiffRate2Durham, 1.0/_passedCut3WeightSum);
	scale(_histDiffRate2Jade, 1.0/_passedCut3WeightSum);
	scale(_histDiffRate3Durham, 1.0/_passedCut4WeightSum);
	scale(_histDiffRate3Jade, 1.0/_passedCut4WeightSum);
	scale(_histDiffRate4Durham, 1.0/_passedCut5WeightSum);
	scale(_histDiffRate4Jade, 1.0/_passedCut5WeightSum);
	}

	//@}


	private:

	/// Store the weighted sums of numbers of charged / charged+neutral
	/// particles - used to calculate average number of particles for the
	/// inclusive single particle distributions' normalisations.
	double _weightedTotalPartNum;

	/// @name Sums of weights past various cuts
	//@{
	double _passedCutWeightSum;
	double _passedCut3WeightSum;
	double _passedCut4WeightSum;
	double _passedCut5WeightSum;
	//@}

	/// @name Histograms
	//@{
	Histo1DPtr _histPtTIn;
	Histo1DPtr _histPtTOut;
	Histo1DPtr _histPtSIn;
	Histo1DPtr _histPtSOut;

	Histo1DPtr _histRapidityT;
	Histo1DPtr _histRapidityS;

	Histo1DPtr _histScaledMom, _histLogScaledMom;

	Profile1DPtr _histPtTOutVsXp, _histPtVsXp;

	Histo1DPtr _hist1MinusT;
	Histo1DPtr _histTMajor;
	Histo1DPtr _histTMinor;
	Histo1DPtr _histOblateness;

	Histo1DPtr _histSphericity;
	Histo1DPtr _histAplanarity;
	Histo1DPtr _histPlanarity;

	Histo1DPtr _histCParam;
	Histo1DPtr _histDParam;

	Histo1DPtr _histHemiMassD;
	Histo1DPtr _histHemiMassH;
	Histo1DPtr _histHemiMassL;

	Histo1DPtr _histHemiBroadW;
	Histo1DPtr _histHemiBroadN;
	Histo1DPtr _histHemiBroadT;
	Histo1DPtr _histHemiBroadD;

	Histo1DPtr _histDiffRate2Durham;
	Histo1DPtr _histDiffRate2Jade;
	Histo1DPtr _histDiffRate3Durham;
	Histo1DPtr _histDiffRate3Jade;
	Histo1DPtr _histDiffRate4Durham;
	Histo1DPtr _histDiffRate4Jade;

	Histo1DPtr _histEEC, _histAEEC;

	Histo1DPtr _histMultiCharged;

	Histo1DPtr _histMultiPiPlus;
	Histo1DPtr _histMultiPi0;
	Histo1DPtr _histMultiKPlus;
	Histo1DPtr _histMultiK0;
	Histo1DPtr _histMultiEta;
	Histo1DPtr _histMultiEtaPrime;
	Histo1DPtr _histMultiDPlus;
	Histo1DPtr _histMultiD0;
	Histo1DPtr _histMultiBPlus0;

	Histo1DPtr _histMultiF0;

	Histo1DPtr _histMultiRho;
	Histo1DPtr _histMultiKStar892Plus;
	Histo1DPtr _histMultiKStar892_0;
	Histo1DPtr _histMultiPhi;
	Histo1DPtr _histMultiDStar2010Plus;

	Histo1DPtr _histMultiF2;
	Histo1DPtr _histMultiK2Star1430_0;

	Histo1DPtr _histMultiP;
	Histo1DPtr _histMultiLambda0;
	Histo1DPtr _histMultiXiMinus;
	Histo1DPtr _histMultiOmegaMinus;
	Histo1DPtr _histMultiDeltaPlusPlus;
	Histo1DPtr _histMultiSigma1385Plus;
	Histo1DPtr _histMultiXi1530_0;
	Histo1DPtr _histMultiLambdaB0;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(DELPHI_1996_S3430090);

	}
	diff --git a/src/Analyses/DELPHI_1999_S3960137.cc b/src/Analyses/DELPHI_1999_S3960137.cc
	--- a/src/Analyses/DELPHI_1999_S3960137.cc
	+++ b/src/Analyses/DELPHI_1999_S3960137.cc
	@@ -1,99 +1,99 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief DELPHI rho,f_0 and f_2 fragmentation function paper
	/// @author Peter Richardson
	class DELPHI_1999_S3960137 : public Analysis {
	public:

	/// Constructor
	DELPHI_1999_S3960137()
	: Analysis("DELPHI_1999_S3960137")
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	_histXpRho = bookHisto1D( 1, 1, 1);
	_histXpf0 = bookHisto1D( 1, 1, 2);
	_histXpf2 = bookHisto1D( 1, 1, 3);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	const int id = p.abspid();
	double xp = p.p3().mod()/meanBeamMom;
	switch (id) {
	case 9010221:
	_histXpf0->fill(xp, weight);
	break;
	case 225:
	_histXpf2->fill(xp, weight);
	break;
	case 113:
	_histXpRho->fill(xp, weight);
	break;
	}
	}
	}


	/// Finalize
	void finalize() {
	scale(_histXpf0 , 1./sumOfWeights());
	scale(_histXpf2 , 1./sumOfWeights());
	scale(_histXpRho, 1./sumOfWeights());
	}

	//@}


	private:

	Histo1DPtr _histXpf0;
	Histo1DPtr _histXpf2;
	Histo1DPtr _histXpRho;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(DELPHI_1999_S3960137);

	}
	diff --git a/src/Analyses/DELPHI_2000_S4328825.cc b/src/Analyses/DELPHI_2000_S4328825.cc
	--- a/src/Analyses/DELPHI_2000_S4328825.cc
	+++ b/src/Analyses/DELPHI_2000_S4328825.cc
	@@ -1,139 +1,139 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/Sphericity.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ParisiTensor.hh"
	#include "Rivet/Projections/Hemispheres.hh"
	#include "Rivet/Projections/InitialQuarks.hh"
	#include <cmath>

	namespace Rivet {


	/// @brief OPAL multiplicities at various energies
	/// @author Peter Richardson
	class DELPHI_2000_S4328825 : public Analysis {
	public:

	/// Constructor
	DELPHI_2000_S4328825()
	: Analysis("DELPHI_2000_S4328825"),
	_weightedTotalChargedPartNumLight(0.),
	_weightedTotalChargedPartNumCharm(0.),
	_weightedTotalChargedPartNumBottom(0.),
	_weightLight(0.),_weightCharm(0.),_weightBottom(0.)
	{}

	/// @name Analysis methods
	//@{


	void init() {
	// Projections
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "CFS");
	- addProjection(InitialQuarks(), "IQF");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "CFS");
	+ declare(InitialQuarks(), "IQF");

	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	- const FinalState& cfs = applyProjection<FinalState>(event, "CFS");
	+ const FinalState& cfs = apply<FinalState>(event, "CFS");
	if (cfs.size() < 2) vetoEvent;


	int flavour = 0;
	- const InitialQuarks& iqf = applyProjection<InitialQuarks>(event, "IQF");
	+ const InitialQuarks& iqf = apply<InitialQuarks>(event, "IQF");

	// If we only have two quarks (qqbar), just take the flavour.
	// If we have more than two quarks, look for the highest energetic q-qbar pair.
	if (iqf.particles().size() == 2) {
	flavour = iqf.particles().front().abspid();
	}
	else {
	map<int, double> quarkmap;
	foreach (const Particle& p, iqf.particles()) {
	if (quarkmap[p.pid()] < p.E()) {
	quarkmap[p.pid()] = p.E();
	}
	}
	double maxenergy = 0.;
	for (int i = 1; i <= 5; ++i) {
	if (quarkmap[i]+quarkmap[-i] > maxenergy) {
	flavour = i;
	}
	}
	}
	const size_t numParticles = cfs.particles().size();
	switch (flavour) {
	case 1: case 2: case 3:
	_weightLight += weight;
	_weightedTotalChargedPartNumLight += numParticles * weight;
	break;
	case 4:
	_weightCharm += weight;
	_weightedTotalChargedPartNumCharm += numParticles * weight;
	break;
	case 5:
	_weightBottom += weight;
	_weightedTotalChargedPartNumBottom += numParticles * weight;
	break;
	}

	}


	void finalize() {
	Histo1D temphisto(refData(1, 1, 1));

	const double avgNumPartsBottom = _weightedTotalChargedPartNumBottom / _weightBottom;
	const double avgNumPartsCharm = _weightedTotalChargedPartNumCharm / _weightCharm;
	const double avgNumPartsLight = _weightedTotalChargedPartNumLight / _weightLight;
	Scatter2DPtr h_bottom = bookScatter2D(1, 1, 1);
	Scatter2DPtr h_charm = bookScatter2D(1, 1, 2);
	Scatter2DPtr h_light = bookScatter2D(1, 1, 3);
	Scatter2DPtr h_diff = bookScatter2D(1, 1, 4); // bottom minus light
	for (size_t b = 0; b < temphisto.numBins(); b++) {
	const double x = temphisto.bin(b).xMid();
	const double ex = temphisto.bin(b).xWidth()/2.;
	if (inRange(sqrtS()/GeV, x-ex, x+ex)) {
	// @TODO: Fix y-error:
	h_bottom->addPoint(x, avgNumPartsBottom, ex, 0.);
	h_charm->addPoint(x, avgNumPartsCharm, ex, 0.);
	h_light->addPoint(x, avgNumPartsLight, ex, 0.);
	h_diff->addPoint(x, avgNumPartsBottom-avgNumPartsLight, ex, 0.);
	}
	}
	}

	//@}


	private:

	/// @name Multiplicities
	//@{
	double _weightedTotalChargedPartNumLight;
	double _weightedTotalChargedPartNumCharm;
	double _weightedTotalChargedPartNumBottom;
	//@}

	/// @name Weights
	//@{
	double _weightLight;
	double _weightCharm;
	double _weightBottom;
	//@}
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(DELPHI_2000_S4328825);

	}
	diff --git a/src/Analyses/DELPHI_2002_069_CONF_603.cc b/src/Analyses/DELPHI_2002_069_CONF_603.cc
	--- a/src/Analyses/DELPHI_2002_069_CONF_603.cc
	+++ b/src/Analyses/DELPHI_2002_069_CONF_603.cc
	@@ -1,129 +1,129 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"


	/// @todo Use inline PID functions instead
	#define IS_PARTON_PDGID(id) ( abs(id) <= 100 && abs(id) != 22 && (abs(id) < 11 \|\| abs(id) > 18) )
	#define IS_BHADRON_PDGID(id) ( ((abs(id)/100)%10 == 5) \|\| (abs(id) >= 5000 && abs(id) <= 5999) )

	namespace Rivet {


	/// @brief DELPHI b-fragmentation measurement
	/// @author Hendrik Hoeth
	class DELPHI_2002_069_CONF_603 : public Analysis {
	public:

	/// Constructor
	DELPHI_2002_069_CONF_603()
	: Analysis("DELPHI_2002_069_CONF_603")
	{
	}


	/// @name Analysis methods
	//@{

	/// Book projections and histograms
	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");

	_histXbprim = bookHisto1D(1, 1, 1);
	_histXbweak = bookHisto1D(2, 1, 1);
	_histMeanXbprim = bookProfile1D(4, 1, 1);
	_histMeanXbweak = bookProfile1D(5, 1, 1);
	}


	void analyze(const Event& e) {
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed ncharged cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed ncharged cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);


	foreach (const GenParticle* p, particles(e.genEvent())) {
	const GenVertex* pv = p->production_vertex();
	const GenVertex* dv = p->end_vertex();
	if (IS_BHADRON_PDGID(p->pdg_id())) {
	const double xp = p->momentum().e()/meanBeamMom;

	// If the B-hadron has a parton as parent, call it primary B-hadron:
	if (pv) {
	bool is_primary = false;
	for (GenVertex::particles_in_const_iterator pp = pv->particles_in_const_begin(); pp != pv->particles_in_const_end() ; ++pp) {
	if (IS_PARTON_PDGID((*pp)->pdg_id())) is_primary = true;
	}
	if (is_primary) {
	_histXbprim->fill(xp, weight);
	_histMeanXbprim->fill(_histMeanXbprim->bin(0).xMid(), xp, weight);
	}
	}

	// If the B-hadron has no B-hadron as a child, it decayed weakly:
	if (dv) {
	bool is_weak = true;
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin() ;
	pp != dv->particles_out_const_end() ; ++pp) {
	if (IS_BHADRON_PDGID((*pp)->pdg_id())) {
	is_weak = false;
	}
	}
	if (is_weak) {
	_histXbweak->fill(xp, weight);
	_histMeanXbweak->fill(_histMeanXbweak->bin(0).xMid(), xp, weight);
	}
	}

	}
	}
	}


	// Finalize
	void finalize() {
	normalize(_histXbprim);
	normalize(_histXbweak);
	}


	private:

	/// Store the weighted sums of numbers of charged / charged+neutral
	/// particles - used to calculate average number of particles for the
	/// inclusive single particle distributions' normalisations.

	Histo1DPtr _histXbprim;
	Histo1DPtr _histXbweak;

	Profile1DPtr _histMeanXbprim;
	Profile1DPtr _histMeanXbweak;

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(DELPHI_2002_069_CONF_603);

	}
	diff --git a/src/Analyses/DELPHI_2011_I890503.cc b/src/Analyses/DELPHI_2011_I890503.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/DELPHI_2011_I890503.cc
	@@ -0,0 +1,85 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/Beam.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+
	+
	+
	+namespace Rivet {
	+
	+
	+ class DELPHI_2011_I890503 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DELPHI_2011_I890503()
	+ : Analysis("DELPHI_2011_I890503")
	+ {
	+ }
	+
	+
	+ /// Book projections and histograms
	+ void init() {
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	+
	+ _histXbweak = bookHisto1D(1, 1, 1);
	+ _histMeanXbweak = bookProfile1D(2, 1, 1);
	+ }
	+
	+
	+ void analyze(const Event& e) {
	+
	+ // Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	+ if (apply<FinalState>(e, "FS").particles().size() < 2) {
	+ MSG_DEBUG("Failed ncharged cut");
	+ vetoEvent;
	+ }
	+ MSG_DEBUG("Passed ncharged cut");
	+
	+ // Get event weight for histo filling
	+ const double weight = e.weight();
	+
	+ // Get beams and average beam momentum
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	+ const double meanBeamMom = ( beams.first.p3().mod() +
	+ beams.second.p3().mod() ) / 2.0;
	+ MSG_DEBUG("Avg beam momentum = " << meanBeamMom);
	+
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	+ // Get Bottom hadrons
	+ const Particles bhads = filter_select(ufs.particles(), isBottomHadron);
	+
	+ for (const Particle& bhad : bhads) {
	+ // Check for weak decay, i.e. no more bottom present in children
	+ if (bhad.children(lastParticleWith(hasBottom)).empty()) {
	+ const double xp = bhad.E()/meanBeamMom;
	+ _histXbweak->fill(xp, weight);
	+ _histMeanXbweak->fill(_histMeanXbweak->bin(0).xMid(), xp, weight);
	+ }
	+ }
	+ }
	+
	+
	+ // Finalize
	+ void finalize() {
	+ normalize(_histXbweak);
	+ }
	+
	+
	+ private:
	+
	+ Histo1DPtr _histXbweak;
	+ Profile1DPtr _histMeanXbweak;
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(DELPHI_2011_I890503);
	+
	+}
	diff --git a/src/Analyses/E735_1998_S3905616.cc b/src/Analyses/E735_1998_S3905616.cc
	--- a/src/Analyses/E735_1998_S3905616.cc
	+++ b/src/Analyses/E735_1998_S3905616.cc
	@@ -1,72 +1,72 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	#include "Rivet/Projections/TriggerCDFRun0Run1.hh"
	#include "Rivet/Projections/TriggerUA5.hh"

	namespace Rivet {


	/// @brief E735 charged multiplicity in NSD-triggered events
	class E735_1998_S3905616 : public Analysis {
	public:

	/// Constructor
	E735_1998_S3905616() : Analysis("E735_1998_S3905616") {
	_sumWTrig = 0;
	}


	/// @name Analysis methods
	//@{

	void init() {
	// Projections
	- addProjection(TriggerUA5(), "Trigger");
	- addProjection(ChargedFinalState(), "FS");
	+ declare(TriggerUA5(), "Trigger");
	+ declare(ChargedFinalState(), "FS");

	// Histo
	_hist_multiplicity = bookHisto1D(1, 1, 1);
	}


	void analyze(const Event& event) {
	- const bool trigger = applyProjection<TriggerUA5>(event, "Trigger").nsdDecision();
	+ const bool trigger = apply<TriggerUA5>(event, "Trigger").nsdDecision();
	if (!trigger) vetoEvent;
	const double weight = event.weight();
	_sumWTrig += weight;

	- const ChargedFinalState& fs = applyProjection<ChargedFinalState>(event, "FS");
	+ const ChargedFinalState& fs = apply<ChargedFinalState>(event, "FS");
	const size_t numParticles = fs.particles().size();
	_hist_multiplicity->fill(numParticles, weight);
	}


	void finalize() {
	scale(_hist_multiplicity, 1/_sumWTrig);
	}

	//@}


	private:

	/// @name Weight counter
	//@{
	double _sumWTrig;
	//@}

	/// @name Histograms
	//@{
	Histo1DPtr _hist_multiplicity;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(E735_1998_S3905616);

	}
	diff --git a/src/Analyses/EXAMPLE.cc b/src/Analyses/EXAMPLE.cc
	--- a/src/Analyses/EXAMPLE.cc
	+++ b/src/Analyses/EXAMPLE.cc
	@@ -1,128 +1,112 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/Sphericity.hh"

	namespace Rivet {


	/// @brief Just measures a few random things as an example.
	class EXAMPLE : public Analysis {
	public:

	/// Constructor
	- EXAMPLE()
	- : Analysis("EXAMPLE")
	- {
	- // No counters etc. to initialise, hence nothing to do here!
	- }
	-
	+ DEFAULT_RIVET_ANALYSIS_CTOR(EXAMPLE);

	/// @name Analysis methods
	//@{

	/// Set up projections and book histograms
	void init() {
	// Projections
	+ MSG_TRACE(0);
	const FinalState cnfs(Cuts::abseta < 4 && Cuts::pT > 500*MeV);
	+ MSG_TRACE(1);
	const ChargedFinalState cfs(cnfs);
	- addProjection(cnfs, "FS");
	- addProjection(cfs, "CFS");
	- addProjection(FastJets(cnfs, FastJets::KT, 0.7), "Jets");
	- addProjection(Thrust(cfs), "Thrust");
	- addProjection(Sphericity(cfs), "Sphericity");
	+ MSG_TRACE(2);
	+ declare(cnfs, "FS");
	+ MSG_TRACE(3);
	+ declare(cfs, "CFS");
	+ declare(FastJets(cnfs, FastJets::KT, 0.7), "Jets");
	+ declare(Thrust(cfs), "Thrust");
	+ declare(Sphericity(cfs), "Sphericity");

	// Histograms
	_histTot = bookHisto1D("TotalMult", 100, -0.5, 99.5);
	_histChTot = bookHisto1D("TotalChMult", 50, -1.0, 99.0);
	_histHadrTot = bookHisto1D("HadrTotalMult", 100, -0.5, 99.5);
	_histHadrChTot = bookHisto1D("HadrTotalChMult", 50, -1.0, 99.0);
	_histMajor = bookHisto1D("Major", 10, 0.0, 0.6);
	_histSphericity = bookHisto1D("Sphericity", 10, 0.0, 0.8);
	_histAplanarity = bookHisto1D("Aplanarity", 10, 0.0, 0.3);

	// Non-uniform binning example:
	double edges[11] = { 0.5, 0.6, 0.7, 0.80, 0.85, 0.9, 0.92, 0.94, 0.96, 0.98, 1.0 };
	vector<double> vedges(edges, edges+11);
	_histThrust = bookHisto1D("Thrust", vedges);
	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Make sure to always include the event weight in histogram fills!
	const double weight = event.weight();

	- const Particles& cnparticles = applyProjection<FinalState>(event, "FS").particles();
	+ const Particles& cnparticles = apply<FinalState>(event, "FS").particles();
	MSG_DEBUG("Total multiplicity = " << cnparticles.size());
	_histTot->fill(cnparticles.size(), weight);
	int cnhadronmult = 0;
	- foreach (const Particle& p, cnparticles) if (isHadron(p)) cnhadronmult += 1;
	+ for (const Particle& p : cnparticles)
	+ if (isHadron(p)) cnhadronmult += 1;
	MSG_DEBUG("Hadron multiplicity = " << cnhadronmult);
	_histHadrTot->fill(cnhadronmult, weight);

	- const Particles& cparticles = applyProjection<FinalState>(event, "CFS").particles();
	+ const Particles& cparticles = apply<FinalState>(event, "CFS").particles();
	MSG_DEBUG("Total charged multiplicity = " << cparticles.size());
	_histChTot->fill(cparticles.size(), weight);
	int chadronmult = 0;
	- foreach (const Particle& p, cparticles) if (isHadron(p)) chadronmult += 1;
	+ for (const Particle& p : cparticles)
	+ if (isHadron(p)) chadronmult += 1;
	MSG_DEBUG("Hadron charged multiplicity = " << chadronmult);
	_histHadrChTot->fill(chadronmult, weight);

	- const Thrust& t = applyProjection<Thrust>(event, "Thrust");
	+ const Thrust& t = apply<Thrust>(event, "Thrust");
	MSG_DEBUG("Thrust = " << t.thrust());
	_histThrust->fill(t.thrust(), weight);
	_histMajor->fill(t.thrustMajor(), weight);

	- const Sphericity& s = applyProjection<Sphericity>(event, "Sphericity");
	+ const Sphericity& s = apply<Sphericity>(event, "Sphericity");
	MSG_DEBUG("Sphericity = " << s.sphericity());
	_histSphericity->fill(s.sphericity(), weight);
	MSG_DEBUG("Aplanarity = " << s.aplanarity());
	_histAplanarity->fill(s.aplanarity(), weight);

	- const Jets jets = applyProjection<FastJets>(event, "Jets").jets(Cuts::pT > 5*GeV);
	+ const Jets jets = apply<FastJets>(event, "Jets").jets(Cuts::pT > 5*GeV);
	size_t num_b_jets = count_if(jets.begin(), jets.end(), [](const Jet& j){ return j.bTagged(Cuts::pT > 500*MeV); });
	MSG_DEBUG("Num B-jets with pT > 5 GeV = " << num_b_jets);
	}


	/// Finalize
	void finalize() {
	- normalize(_histTot);
	- normalize(_histChTot);
	- normalize(_histHadrTot);
	- normalize(_histHadrChTot);
	- normalize(_histThrust);
	- normalize(_histMajor);
	- normalize(_histSphericity);
	- normalize(_histAplanarity);
	+ normalize({_histTot, _histChTot, _histHadrTot, _histHadrChTot, _histThrust, _histMajor, _histSphericity, _histAplanarity});
	}

	//@}


	- private:
	-
	//@{
	/// Histograms
	- Histo1DPtr _histTot;
	- Histo1DPtr _histChTot;
	- Histo1DPtr _histHadrTot;
	- Histo1DPtr _histHadrChTot;
	- Histo1DPtr _histThrust;
	- Histo1DPtr _histMajor;
	- Histo1DPtr _histSphericity;
	- Histo1DPtr _histAplanarity;
	+ Histo1DPtr _histTot, _histChTot, _histHadrTot, _histHadrChTot, _histThrust, _histMajor, _histSphericity, _histAplanarity;
	//@}

	};


	-
	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(EXAMPLE);

	}
	diff --git a/src/Analyses/EXAMPLE_CUTS.cc b/src/Analyses/EXAMPLE_CUTS.cc
	--- a/src/Analyses/EXAMPLE_CUTS.cc
	+++ b/src/Analyses/EXAMPLE_CUTS.cc
	@@ -1,80 +1,73 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	-#include "Rivet/Cuts.hh"

	namespace Rivet {


	/// @brief Just measures a few random things as an example.
	class EXAMPLE_CUTS : public Analysis {
	public:

	/// Constructor
	- EXAMPLE_CUTS()
	- : Analysis("EXAMPLE_CUTS")
	- {
	- // No counters etc. to initialise, hence nothing to do here!
	- }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(EXAMPLE_CUTS);


	/// @name Analysis methods
	//@{

	/// Set up projections and book histograms
	void init() {
	+
	// Projections
	const FinalState cnfs(Cuts::abseta < 4);
	- addProjection(cnfs, "FS");
	+ declare(cnfs, "FS");

	// Histograms
	_histPt = bookHisto1D("pT", 30, 0, 30);
	_histMass = bookHisto1D("Mass", 20, 0, 1);

	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Make sure to always include the event weight in histogram fills!
	const double weight = event.weight();

	- const Particles ps = applyProjection<FinalState>(event, "FS").particlesByPt();
	+ const Particles ps = apply<FinalState>(event, "FS").particlesByPt();

	Cut ptcut = Cuts::range(Cuts::pT, 5, 20);
	Cut masscut = Cuts::range(Cuts::mass, 0, 0.2);
	- Cut combine = ptcut && masscut; //Possible to combine cuts
	+ Cut combine = ptcut && masscut; //< Possible to combine cuts

	- foreach(const Particle& p, ps) {
	+ for (const Particle& p : ps) {
	if ( ptcut->accept(p) )
	- _histPt->fill(p.momentum().pT(), weight);
	+ _histPt->fill(p.pT(), weight);
	if ( combine->accept(p) )
	- _histMass->fill(p.momentum().mass(), weight);
	+ _histMass->fill(p.mass(), weight);
	}
	}


	/// Finalize
	void finalize() {
	- normalize(_histPt);
	- normalize(_histMass);
	+ normalize({_histPt, _histMass});
	}

	//@}


	- private:
	-
	//@{
	/// Histograms
	Histo1DPtr _histPt, _histMass;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(EXAMPLE_CUTS);

	}
	diff --git a/src/Analyses/EXAMPLE_SMEAR.cc b/src/Analyses/EXAMPLE_SMEAR.cc
	--- a/src/Analyses/EXAMPLE_SMEAR.cc
	+++ b/src/Analyses/EXAMPLE_SMEAR.cc
	@@ -1,100 +1,238 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	+#include "Rivet/Projections/DressedLeptons.hh"
	+#include "Rivet/Projections/TauFinder.hh"
	#include "Rivet/Projections/SmearedJets.hh"
	#include "Rivet/Projections/SmearedParticles.hh"
	+#include "Rivet/Projections/SmearedMET.hh"

	namespace Rivet {


	class EXAMPLE_SMEAR : public Analysis {
	public:

	/// Constructor
	- EXAMPLE_SMEAR()
	- : Analysis("EXAMPLE_SMEAR")
	- { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(EXAMPLE_SMEAR);


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	+
	+ MissingMomentum mm(Cuts::abseta < 5);
	+ declare(mm, "MET0");
	+
	+ SmearedMET smm1(mm, MET_SMEAR_IDENTITY);
	+ declare(smm1, "MET1");
	+
	+ SmearedMET smm2(mm, [](const Vector3& met, double){ return P3_SMEAR_LEN_GAUSS(met, 0.1*met.mod()); });
	+ declare(smm2, "MET2");
	+
	+
	FastJets fj(FinalState(Cuts::abseta < 5), FastJets::ANTIKT, 0.4);
	- addProjection(fj, "Jets0");
	+ declare(fj, "Jets0");

	SmearedJets sj1(fj, JET_SMEAR_IDENTITY);
	- addProjection(sj1, "Jets1");
	+ declare(sj1, "Jets1");

	SmearedJets sj2(fj, JET_SMEAR_ATLAS_RUN1,
	- [](const Jet& j){ return j.bTagged() ? 0.7(1 - exp(-j.pT()/(10GeV))) : 0; } );
	- addProjection(sj2, "Jets2");
	+ [](const Jet& j){ return j.bTagged() ? 0.7(1 - exp(-j.pT()/(10GeV))) : 0.01; } );
	+ declare(sj2, "Jets2");

	SmearedJets sj3(fj,
	- [](const Jet& j) { return j; },
	- [](const Jet& j){ return j.bTagged() ? 0.7(1 - exp(-j.pT()/(10GeV))) : 0; },
	+ [](const Jet& j){ return j; },
	+ [](const Jet& j){ return j.bTagged() ? 0.7(1 - exp(-j.pT()/(10GeV))) : 0.01; },
	JET_CTAG_PERFECT,
	- JET_EFF_ZERO);
	- addProjection(sj3, "Jets3");
	+ [](const Jet& j){ return 0.8; });
	+ declare(sj3, "Jets3");

	- IdentifiedFinalState truthelectrons(Cuts::abseta < 2.5 && Cuts::pT > 10*GeV, {{PID::ELECTRON, PID::POSITRON}});
	- addProjection(truthelectrons, "Electrons0");
	- SmearedParticles recoelectrons(truthelectrons, ELECTRON_EFF_ATLAS_RUN1);
	- addProjection(recoelectrons, "Electrons1");

	- _h_njtrue = bookHisto1D("njets_true", 10, -0.5, 9.5);
	- _h_njreco = bookHisto1D("njets_reco", 10, -0.5, 9.5);
	- _h_netrue = bookHisto1D("nelec_true", 5, -0.5, 4.5);
	- _h_nereco = bookHisto1D("nelec_reco", 5, -0.5, 4.5);
	+ IdentifiedFinalState photons(Cuts::abseta < 5, PID::PHOTON);
	+
	+
	+ IdentifiedFinalState truthelectrons(Cuts::abseta < 5 && Cuts::pT > 10*GeV, {{PID::ELECTRON, PID::POSITRON}});
	+ declare(truthelectrons, "Electrons0");
	+ DressedLeptons dressedelectrons(photons, truthelectrons, 0.2);
	+ declare(dressedelectrons, "Electrons1");
	+ SmearedParticles recoelectrons(truthelectrons, ELECTRON_EFF_ATLAS_RUN1, ELECTRON_SMEAR_ATLAS_RUN1); //< @note Can't use dressedelectrons yet...
	+ declare(recoelectrons, "Electrons2");
	+
	+ IdentifiedFinalState truthmuons(Cuts::abseta < 5 && Cuts::pT > 10*GeV, {{PID::MUON, PID::ANTIMUON}});
	+ declare(truthmuons, "Muons0");
	+ DressedLeptons dressedmuons(photons, truthmuons, 0.2);
	+ declare(dressedmuons, "Muons1");
	+ SmearedParticles recomuons(truthmuons, MUON_EFF_ATLAS_RUN1, MUON_SMEAR_ATLAS_RUN1); //< @note Can't use dressedmuons yet...
	+ declare(recomuons, "Muons2");
	+
	+ TauFinder truthtaus(TauFinder::ANY, Cuts::abseta < 5 && Cuts::pT > 10*GeV);
	+ declare(truthtaus, "Taus0");
	+ DressedLeptons dressedtaus(photons, truthtaus, 0.2);
	+ declare(dressedtaus, "Taus1");
	+ SmearedParticles recotaus(truthtaus, TAU_EFF_ATLAS_RUN1, TAU_SMEAR_ATLAS_RUN1); //< @note Can't use dressedtaus yet...
	+ declare(recotaus, "Taus2");
	+
	+
	+ _h_met_true = bookHisto1D("met_true", 30, 0.0, 120);
	+ _h_met_reco = bookHisto1D("met_reco", 30, 0.0, 120);
	+
	+ _h_nj_true = bookHisto1D("jet_N_true", 10, -0.5, 9.5);
	+ _h_nj_reco = bookHisto1D("jet_N_reco", 10, -0.5, 9.5);
	+ _h_j1pt_true = bookHisto1D("jet_pt1_true", 30, 0.0, 120);
	+ _h_j1pt_reco = bookHisto1D("jet_pt1_reco", 30, 0.0, 120);
	+ _h_j1eta_true = bookHisto1D("jet_eta1_true", 20, -5.0, 5.0);
	+ _h_j1eta_reco = bookHisto1D("jet_eta1_reco", 20, -5.0, 5.0);
	+
	+ _h_ne_true = bookHisto1D("elec_N_true", 5, -0.5, 4.5);
	+ _h_ne_reco = bookHisto1D("elec_N_reco", 5, -0.5, 4.5);
	+ _h_e1pt_true = bookHisto1D("elec_pt1_true", 30, 0, 120);
	+ _h_e1pt_reco = bookHisto1D("elec_pt1_reco", 30, 0, 120);
	+ _h_e1eta_true = bookHisto1D("elec_eta1_true", 20, -5.0, 5.0);
	+ _h_e1eta_reco = bookHisto1D("elec_eta1_reco", 20, -5.0, 5.0);
	+
	+ _h_nm_true = bookHisto1D("muon_N_true", 5, -0.5, 4.5);
	+ _h_nm_reco = bookHisto1D("muon_N_reco", 5, -0.5, 4.5);
	+ _h_m1pt_true = bookHisto1D("muon_pt1_true", 30, 0, 120);
	+ _h_m1pt_reco = bookHisto1D("muon_pt1_reco", 30, 0, 120);
	+ _h_m1eta_true = bookHisto1D("muon_eta1_true", 20, -5.0, 5.0);
	+ _h_m1eta_reco = bookHisto1D("muon_eta1_reco", 20, -5.0, 5.0);
	+
	+ _h_nt_true = bookHisto1D("tau_N_true", 5, -0.5, 4.5);
	+ _h_nt_reco = bookHisto1D("tau_N_reco", 5, -0.5, 4.5);
	+ _h_t1pt_true = bookHisto1D("tau_pt1_true", 30, 0, 120);
	+ _h_t1pt_reco = bookHisto1D("tau_pt1_reco", 30, 0, 120);
	+ _h_t1eta_true = bookHisto1D("tau_eta1_true", 20, -5.0, 5.0);
	+ _h_t1eta_reco = bookHisto1D("tau_eta1_reco", 20, -5.0, 5.0);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	- const Jets jets0 = applyProjection<JetAlg>(event, "Jets0").jets(Cuts::pT > 10*GeV);
	- const Jets jets1 = applyProjection<JetAlg>(event, "Jets1").jets(Cuts::pT > 10*GeV);
	- const Jets jets2 = applyProjection<JetAlg>(event, "Jets2").jets(Cuts::pT > 10*GeV);
	- const Jets jets3 = applyProjection<JetAlg>(event, "Jets3").jets(Cuts::pT > 10*GeV);
	- MSG_INFO("Numbers of jets = " << jets0.size() << " true; "
	+ const double weight = event.weight();
	+
	+ const Vector3 met0 = apply<MissingMomentum>(event, "MET0").vectorEt();
	+ const Vector3 met1 = apply<SmearedMET>(event, "MET1").vectorEt();
	+ const Vector3 met2 = apply<SmearedMET>(event, "MET2").vectorEt();
	+ MSG_DEBUG("MET = " << met0.mod()/GeV << ", " << met1.mod()/GeV << ", " << met2.mod()/GeV << " GeV");
	+ _h_met_true->fill(met0.mod()/GeV, weight);
	+ _h_met_reco->fill(met2.mod()/GeV, weight);
	+
	+ const Jets jets0 = apply<JetAlg>(event, "Jets0").jetsByPt(Cuts::pT > 10*GeV);
	+ const Jets jets1 = apply<JetAlg>(event, "Jets1").jetsByPt(Cuts::pT > 10*GeV);
	+ const Jets jets2 = apply<JetAlg>(event, "Jets2").jetsByPt(Cuts::pT > 10*GeV);
	+ const Jets jets3 = apply<JetAlg>(event, "Jets3").jetsByPt(Cuts::pT > 10*GeV);
	+ MSG_DEBUG("Numbers of jets = " << jets0.size() << " true; "
	<< jets1.size() << ", " << jets2.size() << ", " << jets3.size());
	- _h_njtrue->fill(jets0.size());
	- _h_njreco->fill(jets1.size());
	+ _h_nj_true->fill(jets0.size(), weight);
	+ _h_nj_reco->fill(jets2.size(), weight);
	+ if (!jets0.empty()) {
	+ _h_j1pt_true->fill(jets0.front().pT()/GeV, weight);
	+ _h_j1eta_true->fill(jets0.front().eta(), weight);
	+ }
	+ if (!jets2.empty()) {
	+ _h_j1pt_reco->fill(jets2.front().pT()/GeV, weight);
	+ _h_j1eta_reco->fill(jets2.front().eta(), weight);
	+ }

	- const Particles& elecs0 = applyProjection<ParticleFinder>(event, "Electrons0").particles();
	- const Particles& elecs1 = applyProjection<ParticleFinder>(event, "Electrons1").particles();
	- MSG_INFO("Numbers of electrons = " << elecs0.size() << " true; " << elecs1.size() << " reco");
	- _h_netrue->fill(elecs0.size());
	- _h_nereco->fill(elecs1.size());
	+ const Particles& elecs1 = apply<ParticleFinder>(event, "Electrons1").particlesByPt();
	+ const Particles& elecs2 = apply<ParticleFinder>(event, "Electrons2").particlesByPt();
	+ MSG_DEBUG("Numbers of electrons = " << elecs1.size() << " true; " << elecs2.size() << " reco");
	+ _h_ne_true->fill(elecs1.size(), weight);
	+ _h_ne_reco->fill(elecs2.size(), weight);
	+ if (!elecs1.empty()) {
	+ _h_e1pt_true->fill(elecs1.front().pT()/GeV, weight);
	+ _h_e1eta_true->fill(elecs1.front().eta(), weight);
	+ }
	+ if (!elecs2.empty()) {
	+ _h_e1pt_reco->fill(elecs2.front().pT()/GeV, weight);
	+ _h_e1eta_reco->fill(elecs2.front().eta(), weight);
	+ }
	+
	+ const Particles& muons1 = apply<ParticleFinder>(event, "Muons1").particlesByPt();
	+ const Particles& muons2 = apply<ParticleFinder>(event, "Muons2").particlesByPt();
	+ MSG_DEBUG("Numbers of muons = " << muons1.size() << " true; " << muons2.size() << " reco");
	+ _h_nm_true->fill(muons1.size(), weight);
	+ _h_nm_reco->fill(muons2.size(), weight);
	+ if (!muons1.empty()) {
	+ _h_m1pt_true->fill(muons1.front().pT()/GeV, weight);
	+ _h_m1eta_true->fill(muons1.front().eta(), weight);
	+ }
	+ if (!muons2.empty()) {
	+ _h_m1pt_reco->fill(muons2.front().pT()/GeV, weight);
	+ _h_m1eta_reco->fill(muons2.front().eta(), weight);
	+ }
	+
	+ const Particles& taus1 = apply<ParticleFinder>(event, "Taus1").particlesByPt();
	+ const Particles& taus2 = apply<ParticleFinder>(event, "Taus2").particlesByPt();
	+ MSG_DEBUG("Numbers of taus = " << taus1.size() << " true; " << taus2.size() << " reco");
	+ _h_nt_true->fill(taus1.size(), weight);
	+ _h_nt_reco->fill(taus2.size(), weight);
	+ if (!taus1.empty()) {
	+ _h_t1pt_true->fill(taus1.front().pT()/GeV, weight);
	+ _h_t1eta_true->fill(taus1.front().eta(), weight);
	+ }
	+ if (!taus2.empty()) {
	+ _h_t1pt_reco->fill(taus2.front().pT()/GeV, weight);
	+ _h_t1eta_reco->fill(taus2.front().eta(), weight);
	+ }
	+
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	- normalize(_h_njtrue);
	- normalize(_h_njreco);
	- normalize(_h_netrue);
	- normalize(_h_nereco);
	+ normalize(_h_nj_true);
	+ normalize(_h_nj_reco);
	+ normalize(_h_j1pt_true, 1-_h_nj_true->bin(0).area());
	+ normalize(_h_j1pt_reco, 1-_h_nj_reco->bin(0).area());
	+ normalize(_h_j1eta_true, 1-_h_nj_true->bin(0).area());
	+ normalize(_h_j1eta_reco, 1-_h_nj_reco->bin(0).area());
	+
	+ normalize(_h_ne_true);
	+ normalize(_h_ne_reco);
	+ normalize(_h_e1pt_true, 1-_h_ne_true->bin(0).area());
	+ normalize(_h_e1pt_reco, 1-_h_ne_reco->bin(0).area());
	+ normalize(_h_e1eta_true, 1-_h_ne_true->bin(0).area());
	+ normalize(_h_e1eta_reco, 1-_h_ne_reco->bin(0).area());
	+
	+ normalize(_h_nm_true);
	+ normalize(_h_nm_reco);
	+ normalize(_h_m1pt_true, 1-_h_nm_true->bin(0).area());
	+ normalize(_h_m1pt_reco, 1-_h_nm_reco->bin(0).area());
	+ normalize(_h_m1eta_true, 1-_h_nm_true->bin(0).area());
	+ normalize(_h_m1eta_reco, 1-_h_nm_reco->bin(0).area());
	+
	+ normalize(_h_nt_true);
	+ normalize(_h_nt_reco);
	+ normalize(_h_t1pt_true, 1-_h_nt_true->bin(0).area());
	+ normalize(_h_t1pt_reco, 1-_h_nt_reco->bin(0).area());
	+ normalize(_h_t1eta_true, 1-_h_nt_true->bin(0).area());
	+ normalize(_h_t1eta_reco, 1-_h_nt_reco->bin(0).area());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	- Histo1DPtr _h_njtrue, _h_njreco, _h_netrue, _h_nereco;
	+ Histo1DPtr _h_met_true, _h_met_reco;
	+ Histo1DPtr _h_nj_true, _h_nj_reco, _h_ne_true, _h_ne_reco, _h_nm_true, _h_nm_reco, _h_nt_true, _h_nt_reco;
	+ Histo1DPtr _h_j1pt_true, _h_j1pt_reco, _h_e1pt_true, _h_e1pt_reco, _h_m1pt_true, _h_m1pt_reco, _h_t1pt_true, _h_t1pt_reco;
	+ Histo1DPtr _h_j1eta_true, _h_j1eta_reco, _h_e1eta_true, _h_e1eta_reco, _h_m1eta_true, _h_m1eta_reco, _h_t1eta_true, _h_t1eta_reco;
	//@}

	-
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(EXAMPLE_SMEAR);


	}
	diff --git a/src/Analyses/H1_1994_S2919893.cc b/src/Analyses/H1_1994_S2919893.cc
	--- a/src/Analyses/H1_1994_S2919893.cc
	+++ b/src/Analyses/H1_1994_S2919893.cc
	@@ -1,226 +1,226 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Math/Constants.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/DISKinematics.hh"

	namespace Rivet {


	/// @brief H1 energy flow and charged particle spectra
	/// @author Peter Richardson
	/// Based on the equivalent HZTool analysis
	class H1_1994_S2919893 : public Analysis {
	public:

	/// Constructor
	H1_1994_S2919893()
	: Analysis("H1_1994_S2919893")
	{

	// Initialise member variables
	_w77 = make_pair(0.0, 0.0);
	_w122 = make_pair(0.0, 0.0);
	_w169 = make_pair(0.0, 0.0);
	_w117 = make_pair(0.0, 0.0);
	_wEnergy = make_pair(0.0, 0.0);
	}


	/// @name Analysis methods
	//@{

	/// Initialise projections and histograms
	void init() {
	// Projections
	- addProjection(DISLepton(), "Lepton");
	- addProjection(DISKinematics(), "Kinematics");
	- addProjection(FinalState(), "FS");
	+ declare(DISLepton(), "Lepton");
	+ declare(DISKinematics(), "Kinematics");
	+ declare(FinalState(), "FS");

	// Histos
	_histEnergyFlowLowX = bookHisto1D(1, 1, 1);
	_histEnergyFlowHighX = bookHisto1D(1, 1, 2);

	_histEECLowX = bookHisto1D(2, 1, 1);
	_histEECHighX = bookHisto1D(2, 1, 2);

	_histSpectraW77 = bookHisto1D(3, 1, 1);
	_histSpectraW122 = bookHisto1D(3, 1, 2);
	_histSpectraW169 = bookHisto1D(3, 1, 3);
	_histSpectraW117 = bookHisto1D(3, 1, 4);

	_histPT2 = bookProfile1D(4, 1, 1);
	}


	/// Analyse each event
	void analyze(const Event& event) {

	// Get the DIS kinematics
	- const DISKinematics& dk = applyProjection<DISKinematics>(event, "Kinematics");
	+ const DISKinematics& dk = apply<DISKinematics>(event, "Kinematics");
	const double x = dk.x();
	const double w2 = dk.W2();
	const double w = sqrt(w2);

	// Momentum of the scattered lepton
	- const DISLepton& dl = applyProjection<DISLepton>(event,"Lepton");
	+ const DISLepton& dl = apply<DISLepton>(event,"Lepton");
	const FourMomentum leptonMom = dl.out();
	const double ptel = leptonMom.pT();
	const double enel = leptonMom.E();
	const double thel = leptonMom.angle(dk.beamHadron().mom())/degree;

	// Extract the particles other than the lepton
	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	Particles particles;
	particles.reserve(fs.particles().size());
	const GenParticle* dislepGP = dl.out().genParticle();
	foreach (const Particle& p, fs.particles()) {
	const GenParticle* loopGP = p.genParticle();
	if (loopGP == dislepGP) continue;
	particles.push_back(p);
	}

	// Cut on the forward energy
	double efwd = 0.0;
	foreach (const Particle& p, particles) {
	const double th = p.angle(dk.beamHadron())/degree;
	if (inRange(th, 4.4, 15)) efwd += p.E();
	}

	// Apply the cuts
	// Lepton energy and angle, w2 and forward energy
	MSG_DEBUG("enel/GeV = " << enel/GeV << ", thel = " << thel
	<< ", w2 = " << w2 << ", efwd/GeV = " << efwd/GeV);
	bool cut = enel/GeV > 14. && thel > 157. && thel < 172.5 && w2 >= 3000. && efwd/GeV > 0.5;
	if (!cut) vetoEvent;

	// Weight of the event
	const double weight = event.weight();
	(x < 1e-3 ? _wEnergy.first : _wEnergy.second) += weight;

	// Boost to hadronic CM
	const LorentzTransform hcmboost = dk.boostHCM();
	// Loop over the particles
	long ncharged(0);
	for (size_t ip1 = 0; ip1 < particles.size(); ++ip1) {
	const Particle& p = particles[ip1];

	const double th = p.angle(dk.beamHadron().momentum()) / degree;
	// Boost momentum to lab
	const FourMomentum hcmMom = hcmboost.transform(p.momentum());
	// Angular cut
	if (th <= 4.4) continue;

	// Energy flow histogram
	const double et = fabs(hcmMom.Et());
	const double eta = hcmMom.eta();
	(x < 1e-3 ? _histEnergyFlowLowX : _histEnergyFlowHighX)->fill(eta, et*weight);
	if (PID::threeCharge(p.pid()) != 0) {
	/// @todo Use units in w comparisons... what are the units?
	if (w > 50. && w <= 200.) {
	double xf= 2 * hcmMom.z() / w;
	double pt2 = hcmMom.pT2();
	if (w > 50. && w <= 100.) {
	_histSpectraW77 ->fill(xf, weight);
	} else if (w > 100. && w <= 150.) {
	_histSpectraW122->fill(xf, weight);
	} else if (w > 150. && w <= 200.) {
	_histSpectraW169->fill(xf, weight);
	}
	_histSpectraW117->fill(xf, weight);
	/// @todo Is this profile meant to be filled with 2 weight factors?
	_histPT2->fill(xf, pt2*weight/GeV2, weight);
	++ncharged;
	}
	}


	// Energy-energy correlation
	if (th <= 8.) continue;
	double phi1 = p.phi(ZERO_2PI);
	double eta1 = p.eta();
	double et1 = fabs(p.momentum().Et());
	for (size_t ip2 = ip1+1; ip2 < particles.size(); ++ip2) {
	const Particle& p2 = particles[ip2];

	//double th2 = beamAngle(p2.momentum(), order);
	double th2 = p2.angle(dk.beamHadron().momentum()) / degree;
	if (th2 <= 8.) continue;
	double phi2 = p2.phi(ZERO_2PI);

	/// @todo Use angle function
	double deltaphi = phi1 - phi2;
	if (fabs(deltaphi) > PI) deltaphi = fabs(fabs(deltaphi) - TWOPI);
	double eta2 = p2.eta();
	double omega = sqrt(sqr(eta1-eta2) + sqr(deltaphi));
	double et2 = fabs(p2.momentum().Et());
	double wt = et1et2 / sqr(ptel) weight;
	(x < 1e-3 ? _histEECLowX : _histEECHighX)->fill(omega, wt);
	}
	}

	// Factors for normalization
	if (w > 50. && w <= 200.) {
	if (w <= 100.) {
	_w77.first += ncharged*weight;
	_w77.second += weight;
	} else if (w <= 150.) {
	_w122.first += ncharged*weight;
	_w122.second += weight;
	} else {
	_w169.first += ncharged*weight;
	_w169.second += weight;
	}
	_w117.first += ncharged*weight;
	_w117.second += weight;
	}
	}


	// Normalize inclusive single particle distributions to the average number of charged particles per event.
	void finalize() {
	normalize(_histSpectraW77, _w77.first/_w77.second);
	normalize(_histSpectraW122, _w122.first/_w122.second);
	normalize(_histSpectraW169, _w169.first/_w169.second);
	normalize(_histSpectraW117, _w117.first/_w117.second);

	scale(_histEnergyFlowLowX , 1./_wEnergy.first );
	scale(_histEnergyFlowHighX, 1./_wEnergy.second);

	scale(_histEECLowX , 1./_wEnergy.first );
	scale(_histEECHighX, 1./_wEnergy.second);
	}

	//@}


	private:

	/// Polar angle with right direction of the beam
	inline double beamAngle(const FourVector& v, bool order) {
	double thel = v.polarAngle()/degree;
	if (thel < 0) thel += 180.;
	if (!order) thel = 180 - thel;
	return thel;
	}

	/// @name Histograms
	//@{
	Histo1DPtr _histEnergyFlowLowX, _histEnergyFlowHighX;
	Histo1DPtr _histEECLowX, _histEECHighX;
	Histo1DPtr _histSpectraW77, _histSpectraW122, _histSpectraW169, _histSpectraW117;
	Profile1DPtr _histPT2;
	//@}

	/// @name Storage of weights to calculate averages for normalisation
	//@{
	pair<double,double> _w77, _w122, _w169, _w117, _wEnergy;
	//@}

	};



	DECLARE_RIVET_PLUGIN(H1_1994_S2919893);

	}
	diff --git a/src/Analyses/H1_1995_S3167097.cc b/src/Analyses/H1_1995_S3167097.cc
	--- a/src/Analyses/H1_1995_S3167097.cc
	+++ b/src/Analyses/H1_1995_S3167097.cc
	@@ -1,120 +1,120 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/DISFinalState.hh"
	#include "Rivet/Projections/CentralEtHCM.hh"

	namespace Rivet {


	/// H1 energy flow in DIS
	///
	/// @todo Make histograms match those in HepData and use autobooking
	///
	/// @author Leif Lonnblad
	/// @author Andy Buckley
	class H1_1995_S3167097 : public Analysis {
	public:

	/// Constructor
	H1_1995_S3167097()
	: Analysis("H1_1995_S3167097")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	// Projections
	- const DISKinematics& diskin = addProjection(DISKinematics(), "Kinematics");
	- const DISFinalState& fshcm = addProjection(DISFinalState(diskin, DISFinalState::HCM), "FS");
	- addProjection(CentralEtHCM(fshcm), "Y1HCM");
	+ const DISKinematics& diskin = declare(DISKinematics(), "Kinematics");
	+ const DISFinalState& fshcm = declare(DISFinalState(diskin, DISFinalState::HCM), "FS");
	+ declare(CentralEtHCM(fshcm), "Y1HCM");

	// Histograms
	/// @todo Convert to use autobooking and correspond to HepData data tables
	_sumw.resize(9);
	_hEtFlow.resize(9);
	for (size_t i = 0; i < 9; ++i)
	_hEtFlow[i] = bookHisto1D(to_str(i), 24, -6, 6);
	_tmphAvEt = Histo1D(9, 1.0, 10.0);
	_tmphAvX = Histo1D(9, 1.0, 10.0);
	_tmphAvQ2 = Histo1D(9, 1.0, 10.0);
	_tmphN = Histo1D(9, 1.0, 10.0);
	}


	/// Calculate the bin number from the DISKinematics projection
	/// @todo Convert to use a HEPUtils Binning1D
	size_t _getbin(const DISKinematics& dk) {
	if (inRange(dk.Q2()/GeV2, 5.0, 10.0)) {
	if (inRange(dk.x(), 1e-4, 2e-4)) return 0;
	if (inRange(dk.x(), 2e-4, 5e-4) && dk.Q2() > 6.0*GeV2) return 1;
	} else if (inRange(dk.Q2()/GeV2, 10.0, 20.0)) {
	if (inRange(dk.x(), 2e-4, 5e-4)) return 2;
	if (inRange(dk.x(), 5e-4, 8e-4)) return 3;
	if (inRange(dk.x(), 8e-4, 1.5e-3)) return 4;
	if (inRange(dk.x(), 1.5e-3, 4e-3)) return 5;
	} else if (inRange(dk.Q2()/GeV2, 20.0, 50.0)) {
	if (inRange(dk.x(), 5e-4, 1.4e-3)) return 6;
	if (inRange(dk.x(), 1.4e-3, 3e-3)) return 7;
	if (inRange(dk.x(), 3e-3, 1e-2)) return 8;
	}
	return -1;
	}


	void analyze(const Event& event) {
	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	- const DISKinematics& dk = applyProjection<DISKinematics>(event, "Kinematics");
	- const CentralEtHCM& y1 = applyProjection<CentralEtHCM>(event, "Y1HCM");
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	+ const DISKinematics& dk = apply<DISKinematics>(event, "Kinematics");
	+ const CentralEtHCM& y1 = apply<CentralEtHCM>(event, "Y1HCM");

	const int ibin = _getbin(dk);
	if (ibin < 0) vetoEvent;

	const double weight = event.weight();
	_sumw[ibin] += weight;

	for (size_t i = 0, N = fs.particles().size(); i < N; ++i) {
	const double rap = fs.particles()[i].rapidity();
	const double et = fs.particles()[i].Et();
	_hEtFlow[ibin]->fill(rap, weight * et/GeV);
	}

	/// @todo Use fillBin?
	_tmphAvEt.fill(ibin + 1.5, weight * y1.sumEt()/GeV);
	_tmphAvX.fill(ibin + 1.5, weight * dk.x());
	_tmphAvQ2.fill(ibin + 1.5, weight * dk.Q2()/GeV2);
	_tmphN.fill(ibin + 1.5, weight);
	}


	void finalize() {
	for (size_t ibin = 0; ibin < 9; ++ibin)
	scale(_hEtFlow[ibin], 0.5/_sumw[ibin]);
	/// @todo Improve this!
	addAnalysisObject(make_shared<Scatter2D>(_tmphAvEt/_tmphN, histoPath("21")) );
	addAnalysisObject(make_shared<Scatter2D>(_tmphAvX/_tmphN, histoPath("22")) );
	addAnalysisObject(make_shared<Scatter2D>(_tmphAvQ2/_tmphN, histoPath("23")) );
	}

	//@}


	private:

	/// Histograms for the \f$ E_T \f$ flow
	vector<Histo1DPtr> _hEtFlow;

	/// Temporary histograms for averages in different kinematical bins.
	Histo1D _tmphAvEt, _tmphAvX, _tmphAvQ2, _tmphN;

	/// Weights counters for each kinematic bin
	vector<double> _sumw;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(H1_1995_S3167097);

	}
	diff --git a/src/Analyses/H1_2000_S4129130.cc b/src/Analyses/H1_2000_S4129130.cc
	--- a/src/Analyses/H1_2000_S4129130.cc
	+++ b/src/Analyses/H1_2000_S4129130.cc
	@@ -1,259 +1,259 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Math/Constants.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/DISKinematics.hh"

	namespace Rivet {


	/// @brief H1 energy flow and charged particle spectra
	///
	/// @author Peter Richardson
	///
	/// Based on the HZTOOL analysis HZ99091
	class H1_2000_S4129130 : public Analysis {
	public:

	/// Constructor
	H1_2000_S4129130()
	: Analysis("H1_2000_S4129130")
	{ }


	/// @name Analysis methods
	//@{

	/// Initialise projections and histograms
	void init() {
	// Projections
	- addProjection(DISLepton(), "Lepton");
	- addProjection(DISKinematics(), "Kinematics");
	- addProjection(FinalState(), "FS");
	+ declare(DISLepton(), "Lepton");
	+ declare(DISKinematics(), "Kinematics");
	+ declare(FinalState(), "FS");

	// Histos
	Histo1DPtr h;

	// Histograms and weight vectors for low Q^2 a
	for (size_t ix = 0; ix < 17; ++ix) {
	h = bookHisto1D(ix+1, 1, 1);
	_histETLowQa.push_back(h);
	_weightETLowQa.push_back(0.);
	}

	// Histograms and weight vectors for high Q^2 a
	for (size_t ix = 0; ix < 7; ++ix) {
	h = bookHisto1D(ix+18, 1, 1);
	_histETHighQa.push_back(h);
	_weightETHighQa.push_back(0.);
	}

	// Histograms and weight vectors for low Q^2 b
	for (size_t ix = 0; ix < 5; ++ix) {
	h = bookHisto1D(ix+25, 1, 1);
	_histETLowQb.push_back(h);
	_weightETLowQb.push_back(0.);
	}

	// Histograms and weight vectors for high Q^2 b
	for (size_t ix = 0; ix < 3; ++ix) {
	h = bookHisto1D(30+ix, 1, 1);
	_histETHighQb.push_back(h);
	_weightETHighQb.push_back(0.0);
	}

	// Histograms for the averages
	_histAverETCentral = bookProfile1D(33, 1, 1);
	_histAverETFrag = bookProfile1D(34, 1, 1);
	}


	/// Analyze each event
	void analyze(const Event& event) {

	// DIS kinematics
	- const DISKinematics& dk = applyProjection<DISKinematics>(event, "Kinematics");
	+ const DISKinematics& dk = apply<DISKinematics>(event, "Kinematics");
	double q2 = dk.Q2();
	double x = dk.x();
	double y = dk.y();
	double w2 = dk.W2();

	// Kinematics of the scattered lepton
	- const DISLepton& dl = applyProjection<DISLepton>(event,"Lepton");
	+ const DISLepton& dl = apply<DISLepton>(event,"Lepton");
	const FourMomentum leptonMom = dl.out();
	const double enel = leptonMom.E();
	const double thel = 180 - leptonMom.angle(dl.in().mom())/degree;

	// Extract the particles other than the lepton
	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	Particles particles; particles.reserve(fs.size());
	const GenParticle* dislepGP = dl.out().genParticle(); ///< @todo Is the GenParticle stuff necessary? (Not included in Particle::==?)
	foreach (const Particle& p, fs.particles()) {
	const GenParticle* loopGP = p.genParticle();
	if (loopGP == dislepGP) continue;
	particles.push_back(p);
	}

	// Cut on the forward energy
	double efwd = 0.;
	foreach (const Particle& p, particles) {
	const double th = 180 - p.angle(dl.in())/degree;
	if (inRange(th, 4.4, 15.0)) efwd += p.E();
	}
	// There are four possible selections for events
	bool evcut[4];
	// Low Q2 selection a
	evcut[0] = enel/GeV > 12. && w2 >= 4400.*GeV2 && efwd/GeV > 0.5 && inRange(thel,157.,176.);
	// Low Q2 selection b
	evcut[1] = enel/GeV > 12. && inRange(y,0.3,0.5);
	// High Q2 selection a
	evcut[2] = inRange(thel,12.,150.) && inRange(y,0.05,0.6) && w2 >= 4400.*GeV2 && efwd > 0.5;
	// High Q2 selection b
	evcut[3] = inRange(thel,12.,150.) && inRange(y,0.05,0.6) && inRange(w2,27110.GeV2,45182.GeV2);

	// Veto if fails all cuts
	/// @todo Can we use all()?
	if (! (evcut[0] \|\| evcut[1] \|\| evcut[2] \|\| evcut[3]) ) vetoEvent;

	// Find the bins
	int bin[4] = {-1,-1,-1,-1};
	// For the low Q2 selection a)
	if (q2 > 2.5GeV && q2 <= 5.GeV) {
	if (x > 0.00005 && x <= 0.0001 ) bin[0] = 0;
	if (x > 0.0001 && x <= 0.0002 ) bin[0] = 1;
	if (x > 0.0002 && x <= 0.00035) bin[0] = 2;
	if (x > 0.00035 && x <= 0.0010 ) bin[0] = 3;
	}
	else if (q2 > 5.GeV && q2 <= 10.GeV) {
	if (x > 0.0001 && x <= 0.0002 ) bin[0] = 4;
	if (x > 0.0002 && x <= 0.00035) bin[0] = 5;
	if (x > 0.00035 && x <= 0.0007 ) bin[0] = 6;
	if (x > 0.0007 && x <= 0.0020 ) bin[0] = 7;
	}
	else if (q2 > 10.GeV && q2 <= 20.GeV) {
	if (x > 0.0002 && x <= 0.0005) bin[0] = 8;
	if (x > 0.0005 && x <= 0.0008) bin[0] = 9;
	if (x > 0.0008 && x <= 0.0015) bin[0] = 10;
	if (x > 0.0015 && x <= 0.040 ) bin[0] = 11;
	}
	else if (q2 > 20.GeV && q2 <= 50.GeV) {
	if (x > 0.0005 && x <= 0.0014) bin[0] = 12;
	if (x > 0.0014 && x <= 0.0030) bin[0] = 13;
	if (x > 0.0030 && x <= 0.0100) bin[0] = 14;
	}
	else if (q2 > 50.GeV && q2 <= 100.GeV) {
	if (x >0.0008 && x <= 0.0030) bin[0] = 15;
	if (x >0.0030 && x <= 0.0200) bin[0] = 16;
	}
	// check in one of the bins
	evcut[0] &= bin[0] >= 0;
	// For the low Q2 selection b)
	if (q2 > 2.5GeV && q2 <= 5. GeV) bin[1] = 0;
	if (q2 > 5. GeV && q2 <= 10. GeV) bin[1] = 1;
	if (q2 > 10.GeV && q2 <= 20. GeV) bin[1] = 2;
	if (q2 > 20.GeV && q2 <= 50. GeV) bin[1] = 3;
	if (q2 > 50.GeV && q2 <= 100.GeV) bin[1] = 4;
	// check in one of the bins
	evcut[1] &= bin[1] >= 0;
	// for the high Q2 selection a)
	if (q2 > 100.GeV && q2 <= 400.GeV) {
	if (x > 0.00251 && x <= 0.00631) bin[2] = 0;
	if (x > 0.00631 && x <= 0.0158 ) bin[2] = 1;
	if (x > 0.0158 && x <= 0.0398 ) bin[2] = 2;
	}
	else if (q2 > 400.GeV && q2 <= 1100.GeV) {
	if (x > 0.00631 && x <= 0.0158 ) bin[2] = 3;
	if (x > 0.0158 && x <= 0.0398 ) bin[2] = 4;
	if (x > 0.0398 && x <= 1. ) bin[2] = 5;
	}
	else if (q2 > 1100.GeV && q2 <= 100000.GeV) {
	if (x > 0. && x <= 1.) bin[2] = 6;
	}
	// check in one of the bins
	evcut[2] &= bin[2] >= 0;
	// for the high Q2 selection b)
	if (q2 > 100.GeV && q2 <= 220.GeV) bin[3] = 0;
	else if (q2 > 220.GeV && q2 <= 400.GeV) bin[3] = 1;
	else if (q2 > 400. ) bin[3] = 2;
	// check in one of*GeV the bins
	evcut[3] &= bin[3] >= 0;

	// Veto if fails all cuts after bin selection
	/// @todo Can we use all()?
	if (! (evcut[0] \|\| evcut[1] \|\| evcut[2] \|\| evcut[3])) vetoEvent;

	// Increment the count for normalisation
	const double weight = event.weight();
	if (evcut[0]) _weightETLowQa [bin[0]] += weight;
	if (evcut[1]) _weightETLowQb [bin[1]] += weight;
	if (evcut[2]) _weightETHighQa[bin[2]] += weight;
	if (evcut[3]) _weightETHighQb[bin[3]] += weight;

	// Boost to hadronic CoM
	const LorentzTransform hcmboost = dk.boostHCM();

	// Loop over the particles
	double etcent = 0;
	double etfrag = 0;
	foreach (const Particle& p, particles) {
	// Boost momentum to CMS
	const FourMomentum hcmMom = hcmboost.transform(p.momentum());
	double et = fabs(hcmMom.Et());
	double eta = hcmMom.eta();
	// Averages in central and forward region
	if (fabs(eta) < .5 ) etcent += et;
	if (eta > 2 && eta <= 3.) etfrag += et;
	// Histograms of Et flow
	if (evcut[0]) _histETLowQa [bin[0]]->fill(eta, et*weight);
	if (evcut[1]) _histETLowQb [bin[1]]->fill(eta, et*weight);
	if (evcut[2]) _histETHighQa[bin[2]]->fill(eta, et*weight);
	if (evcut[3]) _histETHighQb[bin[3]]->fill(eta, et*weight);
	}
	// Fill histograms for the average quantities
	if (evcut[1] \|\| evcut[3]) {
	_histAverETCentral->fill(q2, etcent, weight);
	_histAverETFrag ->fill(q2, etfrag, weight);
	}
	}


	// Finalize
	void finalize() {
	// Normalization of the Et distributions
	/// @todo Simplify by using normalize() instead? Are all these being normalized to area=1?
	for (size_t ix = 0; ix < 17; ++ix) if (_weightETLowQa[ix] != 0) scale(_histETLowQa[ix], 1/_weightETLowQa[ix]);
	for (size_t ix = 0; ix < 7; ++ix) if (_weightETHighQa[ix] != 0) scale(_histETHighQa[ix], 1/_weightETHighQa[ix]);
	for (size_t ix = 0; ix < 5; ++ix) if (_weightETLowQb[ix] != 0) scale(_histETLowQb[ix], 1/_weightETLowQb[ix]);
	for (size_t ix = 0; ix < 3; ++ix) if (_weightETHighQb[ix] != 0) scale(_histETHighQb[ix], 1/_weightETHighQb[ix]);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	vector<Histo1DPtr> _histETLowQa;
	vector<Histo1DPtr> _histETHighQa;
	vector<Histo1DPtr> _histETLowQb;
	vector<Histo1DPtr> _histETHighQb;
	Profile1DPtr _histAverETCentral;
	Profile1DPtr _histAverETFrag;
	//@}

	/// @name storage of weights for normalisation
	//@{
	vector<double> _weightETLowQa;
	vector<double> _weightETHighQa;
	vector<double> _weightETLowQb;
	vector<double> _weightETHighQb;
	//@}

	};



	DECLARE_RIVET_PLUGIN(H1_2000_S4129130);

	}
	diff --git a/src/Analyses/JADE_1998_S3612880.cc b/src/Analyses/JADE_1998_S3612880.cc
	--- a/src/Analyses/JADE_1998_S3612880.cc
	+++ b/src/Analyses/JADE_1998_S3612880.cc
	@@ -1,133 +1,133 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/Hemispheres.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	/// @todo Include more projections as required, e.g. ChargedFinalState, FastJets, ZFinder...

	namespace Rivet {


	class JADE_1998_S3612880 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	JADE_1998_S3612880()
	: Analysis("JADE_1998_S3612880")
	{
	/// @todo Set whether your finalize method needs the generator cross section
	}



	/// Book histograms and initialise projections before the run
	void init() {
	const ChargedFinalState cfs(-MAXDOUBLE, MAXDOUBLE, 0.1/GeV);
	- addProjection(cfs, "CFS");
	- addProjection(FastJets(cfs, FastJets::DURHAM, 0.7), "DurhamJets");
	+ declare(cfs, "CFS");
	+ declare(FastJets(cfs, FastJets::DURHAM, 0.7), "DurhamJets");

	// Thrust
	const Thrust thrust(cfs);
	- addProjection(thrust, "Thrust");
	- addProjection(Hemispheres(thrust), "Hemispheres");
	+ declare(thrust, "Thrust");
	+ declare(Hemispheres(thrust), "Hemispheres");

	// Histos
	int offset = 0;
	switch (int(sqrtS()/GeV)) {

	case 44:
	offset = 0;
	_h_thrust = bookHisto1D( 2+offset, 1, 1);
	_h_MH = bookHisto1D( 3 + offset, 1, 1);
	_h_BT = bookHisto1D( 4 + offset, 1, 1);
	_h_BW = bookHisto1D( 5 + offset, 1, 1);
	_h_y23 = bookHisto1D(10, 1, 1);
	break;
	case 35:
	offset = 4;
	_h_thrust = bookHisto1D( 2+offset, 1, 1);
	_h_MH = bookHisto1D( 3 + offset, 1, 1);
	_h_BT = bookHisto1D( 4 + offset, 1, 1);
	_h_BW = bookHisto1D( 5 + offset, 1, 1);
	_h_y23 = bookHisto1D(11, 1, 1);
	break;
	case 22:
	_h_y23 = bookHisto1D(12, 1, 1);
	break;
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");

	// JADE hadronic event selection TODO: move this into a trigger definition
	if (cfs.particles().size() < 3 ) {
	vetoEvent;
	}
	- const Thrust& thrust = applyProjection<Thrust>(event, "Thrust");
	+ const Thrust& thrust = apply<Thrust>(event, "Thrust");
	const Vector3 & thrustAxis = thrust.thrustAxis ();
	double theta = thrustAxis.theta();
	if ( fabs(cos(theta)) >= 0.8 ) {
	MSG_DEBUG("Failed thrust angle cut: " << fabs(cos(theta)));
	vetoEvent;
	}
	// TODO Evis, pmiss, pbal

	- const Hemispheres& hemi = applyProjection<Hemispheres>(event, "Hemispheres");
	- const FastJets& durjet = applyProjection<FastJets>(event, "DurhamJets");
	+ const Hemispheres& hemi = apply<Hemispheres>(event, "Hemispheres");
	+ const FastJets& durjet = apply<FastJets>(event, "DurhamJets");

	double y23 = durjet.clusterSeq()->exclusive_ymerge_max(2);

	// Make sure we don't run into a segfault by trying to fill non-existing histos
	int s = int(sqrtS()/GeV);
	if (s == 44 \|\| s == 35) {
	_h_thrust->fill(1. - thrust.thrust(), weight);
	_h_MH->fill(sqrt(hemi.scaledM2high()), weight);
	_h_BT->fill(hemi.Bsum(), weight);
	_h_BW->fill(hemi.Bmax(), weight);
	}
	_h_y23->fill(y23, weight);
	}

	/// Normalise histograms etc., after the run
	void finalize() {
	// Make sure we don't try to normalise non-existing histos
	int s = int(sqrtS()/GeV);
	if (s == 44 \|\| s == 35) {
	normalize(_h_thrust);
	normalize(_h_MH);
	normalize(_h_BT);
	normalize(_h_BW);
	}
	normalize(_h_y23);


	}

	//@}


	private:

	Histo1DPtr _h_thrust;
	Histo1DPtr _h_MH;
	Histo1DPtr _h_BT;
	Histo1DPtr _h_BW;
	Histo1DPtr _h_y23;


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(JADE_1998_S3612880);

	}
	diff --git a/src/Analyses/JADE_OPAL_2000_S4300807.cc b/src/Analyses/JADE_OPAL_2000_S4300807.cc
	--- a/src/Analyses/JADE_OPAL_2000_S4300807.cc
	+++ b/src/Analyses/JADE_OPAL_2000_S4300807.cc
	@@ -1,187 +1,187 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	/// @brief Jet rates in \f$ e^+ e^- \f$ at OPAL and JADE
	/// @author Frank Siegert
	class JADE_OPAL_2000_S4300807 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	JADE_OPAL_2000_S4300807()
	: Analysis("JADE_OPAL_2000_S4300807")
	{ }

	//@}


	/// @name Analysis methods
	//@{

	void init() {
	// Projections
	const FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	FastJets jadeJets = FastJets(fs, FastJets::JADE, 0.7);
	FastJets durhamJets = FastJets(fs, FastJets::DURHAM, 0.7);
	jadeJets.useInvisibles(true);
	durhamJets.useInvisibles(true);
	- addProjection(jadeJets, "JadeJets");
	- addProjection(durhamJets, "DurhamJets");
	+ declare(jadeJets, "JadeJets");
	+ declare(durhamJets, "DurhamJets");

	// Histos
	int offset = 0;
	switch (int(sqrtS()/GeV + 0.5)) {
	case 35: offset = 7; break;
	case 44: offset = 8; break;
	case 91: offset = 9; break;
	case 133: offset = 10; break;
	case 161: offset = 11; break;
	case 172: offset = 12; break;
	case 183: offset = 13; break;
	case 189: offset = 14; break;
	default: break;
	}
	for (size_t i = 0; i < 5; ++i) {
	_h_R_Jade[i] = bookHisto1D(offset, 1, i+1);
	_h_R_Durham[i] = bookHisto1D(offset+9, 1, i+1);
	if (i < 4) _h_y_Durham[i] = bookHisto1D(offset+17, 1, i+1);
	}
	}



	void analyze(const Event& e) {
	const double weight = e.weight();
	- MSG_DEBUG("Num particles = " << applyProjection<FinalState>(e, "FS").particles().size());
	+ MSG_DEBUG("Num particles = " << apply<FinalState>(e, "FS").particles().size());

	- const FastJets& jadejet = applyProjection<FastJets>(e, "JadeJets");
	+ const FastJets& jadejet = apply<FastJets>(e, "JadeJets");
	if (jadejet.clusterSeq()) {
	const double y_23 = jadejet.clusterSeq()->exclusive_ymerge_max(2);
	const double y_34 = jadejet.clusterSeq()->exclusive_ymerge_max(3);
	const double y_45 = jadejet.clusterSeq()->exclusive_ymerge_max(4);
	const double y_56 = jadejet.clusterSeq()->exclusive_ymerge_max(5);

	for (size_t i = 0; i < _h_R_Jade[0]->numBins(); ++i) {
	double ycut = _h_R_Jade[0]->bin(i).xMid();
	double width = _h_R_Jade[0]->bin(i).xWidth();
	if (y_23 < ycut) {
	_h_R_Jade[0]->fillBin(i, weight*width);
	}
	}
	for (size_t i = 0; i < _h_R_Jade[1]->numBins(); ++i) {
	double ycut = _h_R_Jade[1]->bin(i).xMid();
	double width = _h_R_Jade[1]->bin(i).xWidth();
	if (y_34 < ycut && y_23 > ycut) {
	_h_R_Jade[1]->fillBin(i, weight*width);
	}
	}
	for (size_t i = 0; i < _h_R_Jade[2]->numBins(); ++i) {
	double ycut = _h_R_Jade[2]->bin(i).xMid();
	double width = _h_R_Jade[2]->bin(i).xWidth();
	if (y_45 < ycut && y_34 > ycut) {
	_h_R_Jade[2]->fillBin(i, weight*width);
	}
	}
	for (size_t i = 0; i < _h_R_Jade[3]->numBins(); ++i) {
	double ycut = _h_R_Jade[3]->bin(i).xMid();
	double width = _h_R_Jade[3]->bin(i).xWidth();
	if (y_56 < ycut && y_45 > ycut) {
	_h_R_Jade[3]->fillBin(i, weight*width);
	}
	}
	for (size_t i = 0; i < _h_R_Jade[4]->numBins(); ++i) {
	double ycut = _h_R_Jade[4]->bin(i).xMid();
	double width = _h_R_Jade[4]->bin(i).xWidth();
	if (y_56 > ycut) {
	_h_R_Jade[4]->fillBin(i, weight*width);
	}
	}
	}

	- const FastJets& durjet = applyProjection<FastJets>(e, "DurhamJets");
	+ const FastJets& durjet = apply<FastJets>(e, "DurhamJets");
	if (durjet.clusterSeq()) {
	const double y_23 = durjet.clusterSeq()->exclusive_ymerge_max(2);
	const double y_34 = durjet.clusterSeq()->exclusive_ymerge_max(3);
	const double y_45 = durjet.clusterSeq()->exclusive_ymerge_max(4);
	const double y_56 = durjet.clusterSeq()->exclusive_ymerge_max(5);

	_h_y_Durham[0]->fill(y_23, weight);
	_h_y_Durham[1]->fill(y_34, weight);
	_h_y_Durham[2]->fill(y_45, weight);
	_h_y_Durham[3]->fill(y_56, weight);

	for (size_t i = 0; i < _h_R_Durham[0]->numBins(); ++i) {
	double ycut = _h_R_Durham[0]->bin(i).xMid();
	double width = _h_R_Durham[0]->bin(i).xWidth();
	if (y_23 < ycut) {
	_h_R_Durham[0]->fillBin(i, weight*width);
	}
	}
	for (size_t i = 0; i < _h_R_Durham[1]->numBins(); ++i) {
	double ycut = _h_R_Durham[1]->bin(i).xMid();
	double width = _h_R_Durham[1]->bin(i).xWidth();
	if (y_34 < ycut && y_23 > ycut) {
	_h_R_Durham[1]->fillBin(i, weight*width);
	}
	}
	for (size_t i = 0; i < _h_R_Durham[2]->numBins(); ++i) {
	double ycut = _h_R_Durham[2]->bin(i).xMid();
	double width = _h_R_Durham[2]->bin(i).xWidth();
	if (y_45 < ycut && y_34 > ycut) {
	_h_R_Durham[2]->fillBin(i, weight*width);
	}
	}
	for (size_t i = 0; i < _h_R_Durham[3]->numBins(); ++i) {
	double ycut = _h_R_Durham[3]->bin(i).xMid();
	double width = _h_R_Durham[3]->bin(i).xWidth();
	if (y_56 < ycut && y_45 > ycut) {
	_h_R_Durham[3]->fillBin(i, weight*width);
	}
	}
	for (size_t i = 0; i < _h_R_Durham[4]->numBins(); ++i) {
	double ycut = _h_R_Durham[4]->bin(i).xMid();
	double width = _h_R_Durham[4]->bin(i).xWidth();
	if (y_56 > ycut) {
	_h_R_Durham[4]->fillBin(i, weight*width);
	}
	}
	}
	}



	/// Finalize
	void finalize() {
	for (size_t n = 0; n < 4; ++n) normalize(_h_y_Durham[n]);
	for (size_t n = 0; n < 5; ++n) scale(_h_R_Jade[n], 100/sumOfWeights());
	for (size_t n = 0; n < 5; ++n) scale(_h_R_Durham[n], 100/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_R_Jade[5];
	Histo1DPtr _h_R_Durham[5];
	Histo1DPtr _h_y_Durham[4];
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(JADE_OPAL_2000_S4300807);

	}
	diff --git a/src/Analyses/L3_1992_I336180.cc b/src/Analyses/L3_1992_I336180.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/L3_1992_I336180.cc
	@@ -0,0 +1,90 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/Beam.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief L3 inclusive eta production in hadronic Z0 decays
	+ /// @author Simone Amoroso
	+ class L3_1992_I336180 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(L3_1992_I336180);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	+
	+ // Book histograms
	+ _histXpEta = bookHisto1D( 1, 1, 1);
	+ _histLnXpEta = bookHisto1D( 2, 1, 1);
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	+ if (fs.particles().size() < 2) {
	+ MSG_DEBUG("Failed ncharged cut");
	+ vetoEvent;
	+ }
	+ MSG_DEBUG("Passed ncharged cut");
	+
	+ // Get event weight for histo filling
	+ const double weight = event.weight();
	+
	+ // Get beams and average beam momentum
	+ const ParticlePair& beams = apply<Beam>(event, "Beams").beams();
	+ const double meanBeamMom = ( beams.first.p3().mod() + beams.second.p3().mod() ) / 2.0;
	+ MSG_DEBUG("Avg beam momentum = " << meanBeamMom);
	+
	+ // Final state of unstable particles to get particle spectra
	+ const Particles& etas = apply<UnstableFinalState>(event, "UFS").particles(Cuts::abspid==PID::ETA);
	+
	+ foreach (const Particle& p, etas) {
	+ double xp = p.p3().mod()/meanBeamMom;
	+ MSG_DEBUG("Eta xp = " << xp);
	+ _histXpEta->fill(xp, weight);
	+ _histLnXpEta->fill(log(1./xp), weight);
	+ }
	+ }
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ scale(_histXpEta, 1./sumOfWeights());
	+ scale(_histLnXpEta, 1./sumOfWeights());
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ Histo1DPtr _histXpEta;
	+ Histo1DPtr _histLnXpEta;
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(L3_1992_I336180);
	+
	+
	+}
	diff --git a/src/Analyses/L3_2004_I652683.cc b/src/Analyses/L3_2004_I652683.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/L3_2004_I652683.cc
	@@ -0,0 +1,205 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/Beam.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+#include "Rivet/Projections/InitialQuarks.hh"
	+#include "Rivet/Projections/Thrust.hh"
	+#include "Rivet/Projections/ParisiTensor.hh"
	+#include "Rivet/Projections/Hemispheres.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// Jet rates and event shapes at LEP I+II
	+ class L3_2004_I652683 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(L3_2004_I652683);
	+ // L3_2004_I652683() : Analysis("L3_2004_I652683")
	+ // { }
	+
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Projections to use
	+ const FinalState FS;
	+ declare(FS, "FS");
	+ declare(Beam(), "beams");
	+ const ChargedFinalState CFS;
	+ declare(CFS, "CFS");
	+ const Thrust thrust(FS);
	+ declare(thrust, "thrust");
	+ declare(ParisiTensor(FS), "Parisi");
	+ declare(Hemispheres(thrust), "Hemispheres");
	+ declare(InitialQuarks(), "initialquarks");
	+
	+ // Book the histograms
	+ _h_Thrust_udsc = bookHisto1D(47, 1, 1);
	+ _h_Thrust_bottom = bookHisto1D(47, 1, 2);
	+ _h_heavyJetmass_udsc = bookHisto1D(48, 1, 1);
	+ _h_heavyJetmass_bottom = bookHisto1D(48, 1, 2);
	+ _h_totalJetbroad_udsc = bookHisto1D(49, 1, 1);
	+ _h_totalJetbroad_bottom = bookHisto1D(49, 1, 2);
	+ _h_wideJetbroad_udsc = bookHisto1D(50, 1, 1);
	+ _h_wideJetbroad_bottom = bookHisto1D(50, 1, 2);
	+ _h_Cparameter_udsc = bookHisto1D(51, 1, 1);
	+ _h_Cparameter_bottom = bookHisto1D(51, 1, 2);
	+ _h_Dparameter_udsc = bookHisto1D(52, 1, 1);
	+ _h_Dparameter_bottom = bookHisto1D(52, 1, 2);
	+ _h_Ncharged = bookHisto1D(59, 1, 1);
	+ _h_Ncharged_udsc = bookHisto1D(59, 1, 2);
	+ _h_Ncharged_bottom = bookHisto1D(59, 1, 3);
	+ _h_scaledMomentum = bookHisto1D(65, 1, 1);
	+ _h_scaledMomentum_udsc = bookHisto1D(65, 1, 2);
	+ _h_scaledMomentum_bottom = bookHisto1D(65, 1, 3);
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ // Get beam average momentum
	+ const ParticlePair& beams = apply<Beam>(event, "beams").beams();
	+ const double beamMomentum = ( beams.first.p3().mod() + beams.second.p3().mod() ) / 2.0;
	+
	+ // InitialQuarks projection to have udsc events separated from b events
	+ /// @todo Yuck!!! Eliminate when possible...
	+ int flavour = 0;
	+ const InitialQuarks& iqf = apply<InitialQuarks>(event, "initialquarks");
	+ Particles quarks;
	+ if ( iqf.particles().size() == 2 ) {
	+ flavour = iqf.particles().front().abspid();
	+ quarks = iqf.particles();
	+ } else {
	+ map<int, Particle> quarkmap;
	+ for (const Particle& p : iqf.particles()) {
	+ if (quarkmap.find(p.pid()) == quarkmap.end()) quarkmap[p.pid()] = p;
	+ else if (quarkmap[p.pid()].E() < p.E()) quarkmap[p.pid()] = p;
	+ }
	+ double max_energy = 0.;
	+ for (int i = 1; i <= 5; ++i) {
	+ double energy = 0.;
	+ if (quarkmap.find(i) != quarkmap.end())
	+ energy += quarkmap[ i].E();
	+ if (quarkmap.find(-i) != quarkmap.end())
	+ energy += quarkmap[-i].E();
	+ if (energy > max_energy)
	+ flavour = i;
	+ }
	+ if (quarkmap.find(flavour) != quarkmap.end())
	+ quarks.push_back(quarkmap[flavour]);
	+ if (quarkmap.find(-flavour) != quarkmap.end())
	+ quarks.push_back(quarkmap[-flavour]);
	+ }
	+
	+ // Flavour label
	+ /// @todo Change to a bool?
	+ const int iflav = (flavour == PID::DQUARK \|\| flavour == PID::UQUARK \|\| flavour == PID::SQUARK \|\| flavour == PID::CQUARK) ? 1 : (flavour == PID::BQUARK) ? 5 : 0;
	+
	+ // Update weight sums
	+ const double weight = event.weight();
	+ if (iflav == 1) {
	+ _sumW_udsc += weight;
	+ } else if (iflav == 5) {
	+ _sumW_b += weight;
	+ }
	+ _sumW_ch += weight;
	+
	+ // Charged multiplicity
	+ const FinalState& cfs = applyProjection<FinalState>(event, "CFS");
	+ _h_Ncharged->fill(cfs.size(), weight);
	+ if (iflav == 1) {
	+ _sumW_ch_udsc += weight;
	+ _h_Ncharged_udsc->fill(cfs.size(), weight);
	+ } else if (iflav == 5) {
	+ _sumW_ch_b += weight;
	+ _h_Ncharged_bottom->fill(cfs.size(), weight);
	+ }
	+
	+ // Scaled momentum
	+ const Particles& chparticles = cfs.particlesByPt();
	+ for (const Particle& p : chparticles) {
	+ const Vector3 momentum3 = p.p3();
	+ const double mom = momentum3.mod();
	+ const double scaledMom = mom/beamMomentum;
	+ const double logScaledMom = std::log(scaledMom);
	+ _h_scaledMomentum->fill(-logScaledMom, weight);
	+ if (iflav == 1) {
	+ _h_scaledMomentum_udsc->fill(-logScaledMom, weight);
	+ } else if (iflav == 5) {
	+ _h_scaledMomentum_bottom->fill(-logScaledMom, weight);
	+ }
	+ }
	+
	+ // Thrust
	+ const Thrust& thrust = applyProjection<Thrust>(event, "thrust");
	+ if (iflav == 1) {
	+ _h_Thrust_udsc->fill(thrust.thrust(), weight);
	+ } else if (iflav == 5) {
	+ _h_Thrust_bottom->fill(thrust.thrust(), weight);
	+ }
	+
	+ // C and D Parisi parameters
	+ const ParisiTensor& parisi = applyProjection<ParisiTensor>(event, "Parisi");
	+ if (iflav == 1) {
	+ _h_Cparameter_udsc->fill(parisi.C(), weight);
	+ _h_Dparameter_udsc->fill(parisi.D(), weight);
	+ } else if (iflav == 5) {
	+ _h_Cparameter_bottom->fill(parisi.C(), weight);
	+ _h_Dparameter_bottom->fill(parisi.D(), weight);
	+ }
	+
	+ // The hemisphere variables
	+ const Hemispheres& hemisphere = applyProjection<Hemispheres>(event, "Hemispheres");
	+ if (iflav == 1) {
	+ _h_heavyJetmass_udsc->fill(hemisphere.scaledM2high(), weight);
	+ _h_totalJetbroad_udsc->fill(hemisphere.Bsum(), weight);
	+ _h_wideJetbroad_udsc->fill(hemisphere.Bmax(), weight);
	+ } else if (iflav == 5) {
	+ _h_heavyJetmass_bottom->fill(hemisphere.scaledM2high(), weight);
	+ _h_totalJetbroad_bottom->fill(hemisphere.Bsum(), weight);
	+ _h_wideJetbroad_bottom->fill(hemisphere.Bmax(), weight);
	+ }
	+
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ scale({_h_Thrust_udsc, _h_heavyJetmass_udsc, _h_totalJetbroad_udsc, _h_wideJetbroad_udsc, _h_Cparameter_udsc, _h_Dparameter_udsc}, 1/_sumW_udsc);
	+ scale({_h_Thrust_bottom, _h_heavyJetmass_bottom, _h_totalJetbroad_bottom, _h_wideJetbroad_bottom, _h_Cparameter_bottom, _h_Dparameter_bottom}, 1./_sumW_b);
	+ scale(_h_Ncharged, 2/_sumW_ch);
	+ scale(_h_Ncharged_udsc, 2/_sumW_ch_udsc);
	+ scale(_h_Ncharged_bottom, 2/_sumW_ch_b);
	+ scale(_h_scaledMomentum, 1/_sumW_ch);
	+ scale(_h_scaledMomentum_udsc, 1/_sumW_ch_udsc);
	+ scale(_h_scaledMomentum_bottom, 1/_sumW_ch_b);
	+ }
	+
	+
	+ /// Weight counters
	+ double _sumW_udsc = 0, _sumW_b = 0, _sumW_ch = 0, _sumW_ch_udsc = 0, _sumW_ch_b = 0;
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _h_Thrust_udsc, _h_Thrust_bottom;
	+ Histo1DPtr _h_heavyJetmass_udsc, _h_heavyJetmass_bottom;
	+ Histo1DPtr _h_totalJetbroad_udsc, _h_totalJetbroad_bottom;
	+ Histo1DPtr _h_wideJetbroad_udsc, _h_wideJetbroad_bottom;
	+ Histo1DPtr _h_Cparameter_udsc, _h_Cparameter_bottom;
	+ Histo1DPtr _h_Dparameter_udsc, _h_Dparameter_bottom;
	+ Histo1DPtr _h_Ncharged, _h_Ncharged_udsc, _h_Ncharged_bottom;
	+ Histo1DPtr _h_scaledMomentum, _h_scaledMomentum_udsc, _h_scaledMomentum_bottom;
	+ //@}
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(L3_2004_I652683);
	+
	+}
	diff --git a/src/Analyses/LHCB_2010_S8758301.cc b/src/Analyses/LHCB_2010_S8758301.cc
	--- a/src/Analyses/LHCB_2010_S8758301.cc
	+++ b/src/Analyses/LHCB_2010_S8758301.cc
	@@ -1,341 +1,341 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Math/Constants.hh"
	#include "Rivet/Math/Units.hh"
	#include "HepMC/GenEvent.h"
	#include "HepMC/GenParticle.h"
	#include "HepMC/GenVertex.h"
	#include "HepMC/SimpleVector.h"

	namespace Rivet {

	using namespace HepMC;
	using namespace std;

	// Lifetime cut: longest living ancestor ctau < 10^-11 [m]
	namespace {
	const double MAX_CTAU = 1.0E-11; // [m]
	const double MIN_PT = 0.0001; // [GeV/c]
	}


	class LHCB_2010_S8758301 : public Analysis {
	public:
	/// @name Constructors etc.
	//@{
	/// Constructor
	LHCB_2010_S8758301()
	: Analysis("LHCB_2010_S8758301"),
	sumKs0_30(0.0), sumKs0_35(0.0),
	sumKs0_40(0.0), sumKs0_badnull(0),
	sumKs0_badlft(0), sumKs0_all(0),
	sumKs0_outup(0), sumKs0_outdwn(0),
	sum_low_pt_loss(0), sum_high_pt_loss(0)
	{ }


	//@}
	/// @name Analysis methods
	//@{
	/// Book histograms and initialise projections before the run
	void init() {
	MSG_DEBUG("Initializing analysis!");
	fillMap(partLftMap);
	_h_K0s_pt_30 = bookHisto1D(1,1,1);
	_h_K0s_pt_35 = bookHisto1D(1,1,2);
	_h_K0s_pt_40 = bookHisto1D(1,1,3);
	_h_K0s_pt_y_30 = bookHisto1D(2,1,1);
	_h_K0s_pt_y_35 = bookHisto1D(2,1,2);
	_h_K0s_pt_y_40 = bookHisto1D(2,1,3);
	_h_K0s_pt_y_all = bookHisto1D(3,1,1);
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	int id;
	double y, pT;
	const double weight = event.weight();
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");
	double ancestor_lftime;
	foreach (const Particle& p, ufs.particles()) {
	id = p.pid();
	if ((id != 310) && (id != -310)) continue;
	sumKs0_all ++;
	ancestor_lftime = 0.;
	const GenParticle* long_ancestor = getLongestLivedAncestor(p, ancestor_lftime);
	if ( !(long_ancestor) ) {
	sumKs0_badnull ++;
	continue;
	}
	if ( ancestor_lftime > MAX_CTAU ) {
	sumKs0_badlft ++;
	MSG_DEBUG("Ancestor " << long_ancestor->pdg_id() << ", ctau: " << ancestor_lftime << " [m]");
	continue;
	}
	const FourMomentum& qmom = p.momentum();
	y = 0.5 * log((qmom.E() + qmom.pz())/(qmom.E() - qmom.pz()));
	pT = sqrt((qmom.px() * qmom.px()) + (qmom.py() * qmom.py()));
	if (pT < MIN_PT) {
	sum_low_pt_loss ++;
	MSG_DEBUG("Small pT K^0_S: " << pT << " GeV/c.");
	}
	if (pT > 1.6) {
	sum_high_pt_loss ++;
	}
	if (y > 2.5 && y < 4.0) {
	_h_K0s_pt_y_all->fill(pT, weight);
	if (y > 2.5 && y < 3.0) {
	_h_K0s_pt_y_30->fill(pT, weight);
	_h_K0s_pt_30->fill(pT, weight);
	sumKs0_30 += weight;
	} else if (y > 3.0 && y < 3.5) {
	_h_K0s_pt_y_35->fill(pT, weight);
	_h_K0s_pt_35->fill(pT, weight);
	sumKs0_35 += weight;
	} else if (y > 3.5 && y < 4.0) {
	_h_K0s_pt_y_40->fill(pT, weight);
	_h_K0s_pt_40->fill(pT, weight);
	sumKs0_40 += weight;
	}
	} else if (y < 2.5) {
	sumKs0_outdwn ++;
	} else if (y > 4.0) {
	sumKs0_outup ++;
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	MSG_DEBUG("Total number Ks0: " << sumKs0_all << endl
	<< "Sum of weights: " << sumOfWeights() << endl
	<< "Weight Ks0 (2.5 < y < 3.0): " << sumKs0_30 << endl
	<< "Weight Ks0 (3.0 < y < 3.5): " << sumKs0_35 << endl
	<< "Weight Ks0 (3.5 < y < 4.0): " << sumKs0_40 << endl
	<< "Nb. unprompt Ks0 [null mother]: " << sumKs0_badnull << endl
	<< "Nb. unprompt Ks0 [mother lifetime exceeded]: " << sumKs0_badlft << endl
	<< "Nb. Ks0 (y > 4.0): " << sumKs0_outup << endl
	<< "Nb. Ks0 (y < 2.5): " << sumKs0_outdwn << endl
	<< "Nb. Ks0 (pT < " << (MIN_PT/MeV) << " MeV/c): " << sum_low_pt_loss << endl
	<< "Nb. Ks0 (pT > 1.6 GeV/c): " << sum_high_pt_loss << endl
	<< "Cross-section [mb]: " << crossSection()/millibarn << endl
	<< "Nb. events: " << numEvents());
	// Compute cross-section; multiply by bin width for correct scaling
	// cross-section given by Rivet in pb
	double xsection_factor = crossSection()/sumOfWeights();
	// Multiply bin width for correct scaling, xsection in mub
	scale(_h_K0s_pt_30, 0.2*xsection_factor/microbarn);
	scale(_h_K0s_pt_35, 0.2*xsection_factor/microbarn);
	scale(_h_K0s_pt_40, 0.2*xsection_factor/microbarn);
	// Divide by dy (rapidity window width), xsection in mb
	scale(_h_K0s_pt_y_30, xsection_factor/0.5/millibarn);
	scale(_h_K0s_pt_y_35, xsection_factor/0.5/millibarn);
	scale(_h_K0s_pt_y_40, xsection_factor/0.5/millibarn);
	scale(_h_K0s_pt_y_all, xsection_factor/1.5/millibarn);
	}

	//@}


	private:

	/// Get particle lifetime from hardcoded data
	double getLifeTime(int pid) {
	double lft = -1.0;
	if (pid < 0) pid = - pid;
	// Correct Pythia6 PIDs for f0(980), f0(1370) mesons
	if (pid == 10331) pid = 30221;
	if (pid == 10221) pid = 9010221;
	map<int, double>::iterator pPartLft = partLftMap.find(pid);
	// search stable particle list
	if (pPartLft == partLftMap.end()) {
	if (pid <= 100) return 0.0;
	for (unsigned int i=0; i < sizeof(stablePDGIds)/sizeof(unsigned int); i++ ) {
	if (pid == stablePDGIds[i]) { lft = 0.0; break; }
	}
	} else {
	lft = (*pPartLft).second;
	}
	if (lft < 0.0)
	MSG_ERROR("Could not determine lifetime for particle with PID " << pid
	<< "... This K_s^0 will be considered unprompt!");
	return lft;
	}

	const GenParticle* getLongestLivedAncestor(const Particle& p, double& lifeTime) {
	const GenParticle* ret = NULL;
	lifeTime = 1.;
	if (p.genParticle() == NULL) return NULL;
	const GenParticle* pmother = p.genParticle();
	double longest_ctau = 0.;
	double mother_ctau;
	int mother_pid, n_inparts;
	const GenVertex* ivertex = pmother->production_vertex();
	while (ivertex) {
	n_inparts = ivertex->particles_in_size();
	if (n_inparts < 1) {ret = NULL; break;} // error: should never happen!
	const GenVertex::particles_in_const_iterator iPart_invtx = ivertex->particles_in_const_begin();
	pmother = (*iPart_invtx); // first mother particle
	mother_pid = pmother->pdg_id();
	ivertex = pmother->production_vertex(); // get next vertex
	if ( (mother_pid == 2212) \|\| (mother_pid <= 100) ) {
	if (ret == NULL) ret = pmother;
	continue;
	}
	mother_ctau = getLifeTime(mother_pid);
	if (mother_ctau < 0.) { ret= NULL; break; } // error:should never happen!
	if (mother_ctau > longest_ctau) {
	longest_ctau = mother_ctau;
	ret = pmother;
	}
	}
	if (ret) lifeTime = longest_ctau * c_light;
	return ret;
	}

	// Fill the PDG Id to Lifetime[seconds] map
	// Data was extract from LHCb Particle Table using ParticleSvc
	bool fillMap(map<int, double> &m) {
	m[6] = 4.707703E-25; m[11] = 1.E+16; m[12] = 1.E+16;
	m[13] = 2.197019E-06; m[14] = 1.E+16; m[15] = 2.906E-13; m[16] = 1.E+16; m[22] = 1.E+16;
	m[23] = 2.637914E-25; m[24] = 3.075758E-25; m[25] = 9.4E-26; m[35] = 9.4E-26;
	m[36] = 9.4E-26; m[37] = 9.4E-26; m[84] = 3.335641E-13; m[85] = 1.290893E-12;
	m[111] = 8.4E-17; m[113] = 4.405704E-24; m[115] = 6.151516E-24; m[117] = 4.088275E-24;
	m[119] = 2.102914E-24; m[130] = 5.116E-08; m[150] = 1.525E-12; m[211] = 2.6033E-08;
	m[213] = 4.405704E-24; m[215] = 6.151516E-24; m[217] = 4.088275E-24; m[219] = 2.102914E-24;
	m[221] = 5.063171E-19; m[223] = 7.752794E-23; m[225] = 3.555982E-24; m[227] = 3.91793E-24;
	m[229] = 2.777267E-24; m[310] = 8.953E-11; m[313] = 1.308573E-23; m[315] = 6.038644E-24;
	m[317] = 4.139699E-24; m[319] = 3.324304E-24; m[321] = 1.238E-08; m[323] = 1.295693E-23;
	m[325] = 6.682357E-24; m[327] = 4.139699E-24; m[329] = 3.324304E-24; m[331] = 3.210791E-21;
	m[333] = 1.545099E-22; m[335] = 9.016605E-24; m[337] = 7.565657E-24; m[350] = 1.407125E-12;
	m[411] = 1.04E-12; m[413] = 6.856377E-21; m[415] = 1.778952E-23; m[421] = 4.101E-13;
	m[423] = 1.000003E-19; m[425] = 1.530726E-23; m[431] = 5.E-13; m[433] = 1.000003E-19;
	m[435] = 3.291061E-23; m[441] = 2.465214E-23; m[443] = 7.062363E-21; m[445] = 3.242425E-22;
	m[510] = 1.525E-12; m[511] = 1.525E-12; m[513] = 1.000019E-19; m[515] = 1.31E-23;
	m[521] = 1.638E-12; m[523] = 1.000019E-19; m[525] = 1.31E-23; m[530] = 1.536875E-12;
	m[531] = 1.472E-12; m[533] = 1.E-19; m[535] = 1.31E-23; m[541] = 4.5E-13;
	m[553] = 1.218911E-20; m[1112] = 4.539394E-24; m[1114] = 5.578069E-24; m[1116] = 1.994582E-24;
	m[1118] = 2.269697E-24; m[1212] = 4.539394E-24; m[1214] = 5.723584E-24; m[1216] = 1.994582E-24;
	m[1218] = 1.316424E-24; m[2112] = 8.857E+02; m[2114] = 5.578069E-24; m[2116] = 4.388081E-24;
	m[2118] = 2.269697E-24; m[2122] = 4.539394E-24; m[2124] = 5.723584E-24; m[2126] = 1.994582E-24;
	m[2128] = 1.316424E-24; m[2212] = 1.E+16; m[2214] = 5.578069E-24; m[2216] = 4.388081E-24;
	m[2218] = 2.269697E-24; m[2222] = 4.539394E-24; m[2224] = 5.578069E-24; m[2226] = 1.994582E-24;
	m[2228] = 2.269697E-24; m[3112] = 1.479E-10; m[3114] = 1.670589E-23; m[3116] = 5.485102E-24;
	m[3118] = 3.656734E-24; m[3122] = 2.631E-10; m[3124] = 4.219309E-23; m[3126] = 8.227653E-24;
	m[3128] = 3.291061E-24; m[3212] = 7.4E-20; m[3214] = 1.828367E-23; m[3216] = 5.485102E-24;
	m[3218] = 3.656734E-24; m[3222] = 8.018E-11; m[3224] = 1.838582E-23; m[3226] = 5.485102E-24;
	m[3228] = 3.656734E-24; m[3312] = 1.639E-10; m[3314] = 6.648608E-23; m[3322] = 2.9E-10;
	m[3324] = 7.233101E-23; m[3334] = 8.21E-11; m[4112] = 2.991874E-22; m[4114] = 4.088274E-23;
	m[4122] = 2.E-13; m[4132] = 1.12E-13; m[4212] = 3.999999E-22; m[4214] = 3.291061E-22;
	m[4222] = 2.951624E-22; m[4224] = 4.417531E-23; m[4232] = 4.42E-13; m[4332] = 6.9E-14;
	m[4412] = 3.335641E-13; m[4422] = 3.335641E-13; m[4432] = 3.335641E-13; m[5112] = 1.E-19;
	m[5122] = 1.38E-12; m[5132] = 1.42E-12; m[5142] = 1.290893E-12; m[5212] = 1.E-19;
	m[5222] = 1.E-19; m[5232] = 1.42E-12; m[5242] = 1.290893E-12; m[5312] = 1.E-19;
	m[5322] = 1.E-19; m[5332] = 1.55E-12; m[5342] = 1.290893E-12; m[5442] = 1.290893E-12;
	m[5512] = 1.290893E-12; m[5522] = 1.290893E-12; m[5532] = 1.290893E-12; m[5542] = 1.290893E-12;
	m[10111] = 2.48382E-24; m[10113] = 4.635297E-24; m[10115] = 2.54136E-24; m[10211] = 2.48382E-24;
	m[10213] = 4.635297E-24; m[10215] = 2.54136E-24; m[10223] = 1.828367E-24; m[10225] = 3.636531E-24;
	m[10311] = 2.437823E-24; m[10313] = 7.313469E-24; m[10315] = 3.538775E-24;
	m[10321] = 2.437823E-24; m[10323] = 7.313469E-24; m[10325] = 3.538775E-24;
	m[10331] = 4.804469E-24; m[10411] = 4.38E-24; m[10413] = 3.29E-23; m[10421] = 4.38E-24;
	m[10423] = 3.22653E-23; m[10431] = 6.5821E-22; m[10433] = 6.5821E-22; m[10441] = 6.453061E-23;
	m[10511] = 4.39E-24; m[10513] = 1.65E-23; m[10521] = 4.39E-24; m[10523] = 1.65E-23;
	m[10531] = 4.39E-24; m[10533] = 1.65E-23; m[11114] = 2.194041E-24; m[11116] = 1.828367E-24;
	m[11212] = 1.880606E-24; m[11216] = 1.828367E-24; m[12112] = 2.194041E-24;
	m[12114] = 2.194041E-24; m[12116] = 5.063171E-24; m[12126] = 1.828367E-24;
	m[12212] = 2.194041E-24; m[12214] = 2.194041E-24; m[12216] = 5.063171E-24;
	m[12224] = 2.194041E-24; m[12226] = 1.828367E-24; m[13112] = 6.582122E-24; m[13114] = 1.09702E-23;
	m[13116] = 5.485102E-24; m[13122] = 1.316424E-23; m[13124] = 1.09702E-23; m[13126] = 6.928549E-24;
	m[13212] = 6.582122E-24; m[13214] = 1.09702E-23; m[13216] = 5.485102E-24; m[13222] = 6.582122E-24;
	m[13224] = 1.09702E-23; m[13226] = 5.485102E-24;
	m[13312] = 4.135667E-22; m[13314] = 2.742551E-23;
	m[13324] = 2.742551E-23; m[14122] = 1.828367E-22; m[20022] = 1.E+16; m[20113] = 1.567172E-24;
	m[20213] = 1.567172E-24; m[20223] = 2.708692E-23; m[20313] = 3.782829E-24;
	m[20315] = 2.384827E-24; m[20323] = 3.782829E-24; m[20325] = 2.384827E-24;
	m[20333] = 1.198929E-23; m[20413] = 2.63E-24; m[20423] = 2.63E-24; m[20433] = 6.5821E-22;
	m[20443] = 7.395643E-22; m[20513] = 2.63E-24; m[20523] = 2.63E-24; m[20533] = 2.63E-24;
	m[21112] = 2.632849E-24; m[21114] = 3.291061E-24; m[21212] = 2.632849E-24;
	m[21214] = 6.582122E-24; m[22112] = 4.388081E-24; m[22114] = 3.291061E-24;
	m[22122] = 2.632849E-24; m[22124] = 6.582122E-24; m[22212] = 4.388081E-24;
	m[22214] = 3.291061E-24; m[22222] = 2.632849E-24; m[22224] = 3.291061E-24;
	m[23112] = 7.313469E-24; m[23114] = 2.991874E-24; m[23122] = 4.388081E-24;
	m[23124] = 6.582122E-24; m[23126] = 3.291061E-24; m[23212] = 7.313469E-24;
	m[23214] = 2.991874E-24; m[23222] = 7.313469E-24; m[23224] = 2.991874E-24;
	m[30113] = 2.632849E-24; m[30213] = 2.632849E-24; m[30221] = 1.880606E-24;
	m[30223] = 2.089563E-24; m[30313] = 2.056913E-24; m[30323] = 2.056913E-24;
	m[30443] = 2.419898E-23; m[31114] = 1.880606E-24; m[31214] = 3.291061E-24;
	m[32112] = 3.989164E-24; m[32114] = 1.880606E-24; m[32124] = 3.291061E-24;
	m[32212] = 3.989164E-24; m[32214] = 1.880606E-24; m[32224] = 1.880606E-24;
	m[33122] = 1.880606E-23; m[42112] = 6.582122E-24; m[42212] = 6.582122E-24;
	m[43122] = 2.194041E-24; m[53122] = 4.388081E-24; m[100111] = 1.645531E-24;
	m[100113] = 1.64553E-24; m[100211] = 1.645531E-24; m[100213] = 1.64553E-24;
	m[100221] = 1.196749E-23; m[100223] = 3.061452E-24; m[100313] = 2.837122E-24;
	m[100323] = 2.837122E-24; m[100331] = 4.459432E-25; m[100333] = 4.388081E-24;
	m[100441] = 4.701516E-23; m[100443] = 2.076379E-21; m[100553] = 2.056913E-20;
	m[200553] = 3.242425E-20; m[300553] = 3.210791E-23; m[9000111] = 8.776163E-24;
	m[9000211] = 8.776163E-24; m[9000443] = 8.227652E-24; m[9000553] = 5.983747E-24;
	m[9010111] = 3.164482E-24; m[9010211] = 3.164482E-24; m[9010221] = 9.403031E-24;
	m[9010443] = 8.438618E-24; m[9010553] = 8.3318E-24;
	m[9020221] = 8.093281E-23; m[9020443] = 1.061633E-23;
	m[9030221] = 6.038644E-24; m[9042413] = 2.07634E-21; m[9050225] = 1.394517E-24;
	m[9060225] = 3.291061E-24; m[9080225] = 4.388081E-24; m[9090225] = 2.056913E-24;
	m[9910445] = 2.07634E-21; m[9920443] = 2.07634E-21;
	return true;
	}

	/// @name Histograms
	//@{
	Histo1DPtr _h_K0s_pt_y_30; // histogram for 2.5 < y < 3.0 (d2sigma)
	Histo1DPtr _h_K0s_pt_y_35; // histogram for 3.0 < y < 3.5 (d2sigma)
	Histo1DPtr _h_K0s_pt_y_40; // histogram for 3.5 < y < 4.0 (d2sigma)
	Histo1DPtr _h_K0s_pt_30; // histogram for 2.5 < y < 3.0 (sigma)
	Histo1DPtr _h_K0s_pt_35; // histogram for 3.0 < y < 3.5 (sigma)
	Histo1DPtr _h_K0s_pt_40; // histogram for 3.5 < y < 4.0 (sigma)
	Histo1DPtr _h_K0s_pt_y_all; // histogram for 2.5 < y < 4.0 (d2sigma)
	double sumKs0_30; // Sum of weights 2.5 < y < 3.0
	double sumKs0_35; // Sum of weights 3.0 < y < 3.5
	double sumKs0_40; // Sum of weights 3.5 < y < 4.0
	// Various counters mainly for debugging and comparisons between different generators
	size_t sumKs0_badnull; // Nb of particles for which mother could not be identified
	size_t sumKs0_badlft; // Nb of mesons with long lived mothers
	size_t sumKs0_all; // Nb of all Ks0 generated
	size_t sumKs0_outup; // Nb of mesons with y > 4.0
	size_t sumKs0_outdwn; // Nb of mesons with y < 2.5
	size_t sum_low_pt_loss; // Nb of mesons with very low pT (indicates when units are mixed-up)
	size_t sum_high_pt_loss; // Nb of mesons with pT > 1.6 GeV/c
	// Map between PDG id and particle lifetimes in seconds
	std::map<int, double> partLftMap;
	// Set of PDG Ids for stable particles (PDG Id <= 100 are considered stable)
	static const int stablePDGIds[205];
	//@}
	};


	// Actual initialization according to ISO C++ requirements
	const int LHCB_2010_S8758301::stablePDGIds[205] = {
	311, 543, 545, 551, 555, 557, 1103, 2101, 2103, 2203, 3101, 3103, 3201, 3203, 3303,
	4101, 4103, 4124, 4201, 4203, 4301, 4303, 4312, 4314, 4322, 4324, 4334, 4403, 4414,
	4424, 4434, 4444, 5101, 5103, 5114, 5201, 5203, 5214, 5224, 5301, 5303, 5314, 5324,
	5334, 5401, 5403, 5412, 5414, 5422, 5424, 5432, 5434, 5444, 5503, 5514, 5524, 5534,
	5544, 5554, 10022, 10333, 10335, 10443, 10541, 10543, 10551, 10553, 10555, 11112,
	12118, 12122, 12218, 12222, 13316, 13326, 20543, 20553, 20555, 23314, 23324, 30343,
	30353, 30363, 30553, 33314, 33324, 41214, 42124, 52114, 52214, 100311, 100315, 100321,
	100325, 100411, 100413, 100421, 100423, 100551, 100555, 100557, 110551, 110553, 110555,
	120553, 120555, 130553, 200551, 200555, 210551, 210553, 220553, 1000001, 1000002,
	1000003, 1000004, 1000005, 1000006, 1000011, 1000012, 1000013, 1000014, 1000015,
	1000016, 1000021, 1000022, 1000023, 1000024, 1000025, 1000035, 1000037, 1000039,
	2000001, 2000002, 2000003, 2000004, 2000005, 2000006, 2000011, 2000012, 2000013,
	2000014, 2000015, 2000016, 3000111, 3000113, 3000211, 3000213, 3000221, 3000223,
	3000331, 3100021, 3100111, 3100113, 3200111, 3200113, 3300113, 3400113, 4000001,
	4000002, 4000011, 4000012, 5000039, 9000221, 9900012, 9900014, 9900016, 9900023,
	9900024, 9900041, 9900042};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(LHCB_2010_S8758301);

	}
	diff --git a/src/Analyses/LHCB_2011_I917009.cc b/src/Analyses/LHCB_2011_I917009.cc
	--- a/src/Analyses/LHCB_2011_I917009.cc
	+++ b/src/Analyses/LHCB_2011_I917009.cc
	@@ -1,323 +1,323 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	class LHCB_2011_I917009 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	LHCB_2011_I917009()
	: Analysis("LHCB_2011_I917009"),
	rap_beam(0.0), pt_min(0.0),
	pt1_edge(0.65), pt2_edge(1.0),
	pt3_edge(2.5), rap_min(2.),
	rap_max(0.0), dsShift(0)
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	int y_nbins = 4;
	fillMap(partLftMap);
	if (fuzzyEquals(sqrtS(), 0.9*TeV)) {
	rap_beam = 6.87;
	rap_max = 4.;
	pt_min = 0.25;
	} else if (fuzzyEquals(sqrtS(), 7*TeV)) {
	rap_beam = 8.92;
	rap_max = 4.5;
	pt_min = 0.15;
	y_nbins = 5;
	dsShift = 8;
	} else {
	MSG_ERROR("Incompatible beam energy!");
	}

	// Create the sets of temporary histograms that will be used to make the ratios in the finalize()
	for (size_t i = 0; i < 12; ++i) _tmphistos[i] = YODA::Histo1D(y_nbins, rap_min, rap_max);
	for (size_t i = 12; i < 15; ++i) _tmphistos[i] = YODA::Histo1D(refData(dsShift+5, 1, 1));
	for (size_t i = 15; i < 18; ++i) _tmphistos[i] = YODA::Histo1D(y_nbins, rap_beam - rap_max, rap_beam - rap_min);

	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");
	double ancestor_lftsum = 0.0;
	double y, pT;
	int id;
	int partIdx = -1;
	foreach (const Particle& p, ufs.particles()) {
	id = p.pid();
	// continue if particle not a K0s nor (anti-)Lambda
	if ( (id == 310) \|\| (id == -310) ) {
	partIdx = 2;
	} else if ( id == 3122 ) {
	partIdx = 1;
	} else if ( id == -3122 ) {
	partIdx = 0;
	} else {
	continue;
	}
	ancestor_lftsum = getMotherLifeTimeSum(p);
	// Lifetime cut: ctau sum of all particle ancestors < 10^-9 m according to the paper (see eq. 5)
	const double MAX_CTAU = 1.0E-9; // [m]
	if ( (ancestor_lftsum < 0.0) \|\| (ancestor_lftsum > MAX_CTAU) ) continue;
	const FourMomentum& qmom = p.momentum();
	y = log((qmom.E() + qmom.pz())/(qmom.E() - qmom.pz()))/2.;
	// skip this particle if it has too high or too low rapidity (extremely rare cases when E = +- pz)
	if ( std::isnan(y) \|\| std::isinf(y) ) continue;
	y = fabs(y);
	if (!inRange(y, rap_min, rap_max)) continue;
	pT = sqrt((qmom.px() * qmom.px()) + (qmom.py() * qmom.py()));
	if (!inRange(pT, pt_min, pt3_edge)) continue;
	// Filling corresponding temporary histograms for pT intervals
	if (inRange(pT, pt_min, pt1_edge)) _tmphistos[partIdx*3].fill(y, weight);
	if (inRange(pT, pt1_edge, pt2_edge)) _tmphistos[partIdx*3+1].fill(y, weight);
	if (inRange(pT, pt2_edge, pt3_edge)) _tmphistos[partIdx*3+2].fill(y, weight);
	// Fill histo in rapidity for whole pT interval
	_tmphistos[partIdx+9].fill(y, weight);
	// Fill histo in pT for whole rapidity interval
	_tmphistos[partIdx+12].fill(pT, weight);
	// Fill histo in rapidity loss for whole pT interval
	_tmphistos[partIdx+15].fill(rap_beam - y, weight);
	}
	}


	// Generate the ratio histograms
	void finalize() {
	int dsId = dsShift + 1;
	for (size_t j = 0; j < 3; ++j) {
	/// @todo Compactify to two one-liners
	Scatter2DPtr s1 = bookScatter2D(dsId, 1, j+1);
	divide(_tmphistos[j], _tmphistos[3+j], s1);
	Scatter2DPtr s2 = bookScatter2D(dsId+1, 1, j+1);
	divide(_tmphistos[j], _tmphistos[6+j], s2);
	}
	dsId += 2;
	for (size_t j = 3; j < 6; ++j) {
	/// @todo Compactify to two one-liners
	Scatter2DPtr s1 = bookScatter2D(dsId, 1, 1);
	divide(_tmphistos[3j], _tmphistos[3j+1], s1);
	dsId += 1;
	Scatter2DPtr s2 = bookScatter2D(dsId, 1, 1);
	divide(_tmphistos[3j], _tmphistos[3j+2], s2);
	dsId += 1;
	}
	}

	//@}

	private:


	// Get particle lifetime from hardcoded data
	double getLifeTime(int pid) {
	double lft = -1.0;
	if (pid < 0) pid = - pid;
	// Correct Pythia6 PIDs for f0(980), f0(1370) mesons
	if (pid == 10331) pid = 30221;
	if (pid == 10221) pid = 9010221;
	map<int, double>::iterator pPartLft = partLftMap.find(pid);
	// search stable particle list
	if (pPartLft == partLftMap.end()) {
	if (pid <= 100) return 0.0;
	for (size_t i=0; i < sizeof(stablePDGIds)/sizeof(unsigned int); i++) {
	if (pid == stablePDGIds[i]) { lft = 0.0; break; }
	}
	} else {
	lft = (*pPartLft).second;
	}
	if (lft < 0.0 && PID::isHadron(pid)) {
	MSG_ERROR("Could not determine lifetime for particle with PID " << pid
	<< "... This V^0 will be considered unprompt!");
	}
	return lft;
	}

	// Data members like post-cuts event weight counters go here
	const double getMotherLifeTimeSum(const Particle& p) {
	if (p.genParticle() == NULL) return -1.;
	double lftSum = 0.;
	double plft = 0.;
	const GenParticle* part = p.genParticle();
	const GenVertex* ivtx = part->production_vertex();
	while (ivtx) {
	if (ivtx->particles_in_size() < 1) { lftSum = -1.; break; };
	const GenVertex::particles_in_const_iterator iPart_invtx = ivtx->particles_in_const_begin();
	part = (*iPart_invtx);
	if ( !(part) ) { lftSum = -1.; break; };
	ivtx = part->production_vertex();
	if ( (part->pdg_id() == 2212) \|\| !(ivtx) ) break; //reached beam
	plft = getLifeTime(part->pdg_id());
	if (plft < 0.) { lftSum = -1.; break; };
	lftSum += plft;
	};
	return (lftSum * c_light);
	}

	/// @name Private variables
	//@{

	// The rapidity of the beam according to the selected beam energy
	double rap_beam;

	// The edges of the intervals of transverse momentum
	double pt_min, pt1_edge, pt2_edge, pt3_edge;

	// The limits of the rapidity window
	double rap_min;
	double rap_max;

	// Indicates which set of histograms will be output to yoda file (according to beam energy)
	int dsShift;

	// Map between PDG id and particle lifetimes in seconds
	std::map<int, double> partLftMap;

	// Set of PDG Ids for stable particles (PDG Id <= 100 are considered stable)
	static const int stablePDGIds[205];

	//@}

	/// @name Helper histograms
	//@{
	/// Histograms are defined in the following order: anti-Lambda, Lambda and K0s.
	/// First 3 suites of 3 histograms correspond to each particle in bins of y for the 3 pT intervals. (9 histos)
	/// Next 3 histograms contain the particles in y bins for the whole pT interval (3 histos)
	/// Next 3 histograms contain the particles in y_loss bins for the whole pT interval (3 histos)
	/// Last 3 histograms contain the particles in pT bins for the whole rapidity (y) interval (3 histos)
	YODA::Histo1D _tmphistos[18];
	//@}

	// Fill the PDG Id to Lifetime[seconds] map
	// Data was extracted from LHCb Particle Table through LHCb::ParticlePropertySvc
	bool fillMap(map<int, double>& m) {
	m[6] = 4.707703E-25; m[11] = 1.E+16; m[12] = 1.E+16;
	m[13] = 2.197019E-06; m[14] = 1.E+16; m[15] = 2.906E-13; m[16] = 1.E+16; m[22] = 1.E+16;
	m[23] = 2.637914E-25; m[24] = 3.075758E-25; m[25] = 9.4E-26; m[35] = 9.4E-26;
	m[36] = 9.4E-26; m[37] = 9.4E-26; m[84] = 3.335641E-13; m[85] = 1.290893E-12;
	m[111] = 8.4E-17; m[113] = 4.405704E-24; m[115] = 6.151516E-24; m[117] = 4.088275E-24;
	m[119] = 2.102914E-24; m[130] = 5.116E-08; m[150] = 1.525E-12; m[211] = 2.6033E-08;
	m[213] = 4.405704E-24; m[215] = 6.151516E-24; m[217] = 4.088275E-24; m[219] = 2.102914E-24;
	m[221] = 5.063171E-19; m[223] = 7.752794E-23; m[225] = 3.555982E-24; m[227] = 3.91793E-24;
	m[229] = 2.777267E-24; m[310] = 8.953E-11; m[313] = 1.308573E-23; m[315] = 6.038644E-24;
	m[317] = 4.139699E-24; m[319] = 3.324304E-24; m[321] = 1.238E-08; m[323] = 1.295693E-23;
	m[325] = 6.682357E-24; m[327] = 4.139699E-24; m[329] = 3.324304E-24; m[331] = 3.210791E-21;
	m[333] = 1.545099E-22; m[335] = 9.016605E-24; m[337] = 7.565657E-24; m[350] = 1.407125E-12;
	m[411] = 1.04E-12; m[413] = 6.856377E-21; m[415] = 1.778952E-23; m[421] = 4.101E-13;
	m[423] = 1.000003E-19; m[425] = 1.530726E-23; m[431] = 5.E-13; m[433] = 1.000003E-19;
	m[435] = 3.291061E-23; m[441] = 2.465214E-23; m[443] = 7.062363E-21; m[445] = 3.242425E-22;
	m[510] = 1.525E-12; m[511] = 1.525E-12; m[513] = 1.000019E-19; m[515] = 1.31E-23;
	m[521] = 1.638E-12; m[523] = 1.000019E-19; m[525] = 1.31E-23; m[530] = 1.536875E-12;
	m[531] = 1.472E-12; m[533] = 1.E-19; m[535] = 1.31E-23; m[541] = 4.5E-13;
	m[553] = 1.218911E-20; m[1112] = 4.539394E-24; m[1114] = 5.578069E-24; m[1116] = 1.994582E-24;
	m[1118] = 2.269697E-24; m[1212] = 4.539394E-24; m[1214] = 5.723584E-24; m[1216] = 1.994582E-24;
	m[1218] = 1.316424E-24; m[2112] = 8.857E+02; m[2114] = 5.578069E-24; m[2116] = 4.388081E-24;
	m[2118] = 2.269697E-24; m[2122] = 4.539394E-24; m[2124] = 5.723584E-24; m[2126] = 1.994582E-24;
	m[2128] = 1.316424E-24; m[2212] = 1.E+16; m[2214] = 5.578069E-24; m[2216] = 4.388081E-24;
	m[2218] = 2.269697E-24; m[2222] = 4.539394E-24; m[2224] = 5.578069E-24; m[2226] = 1.994582E-24;
	m[2228] = 2.269697E-24; m[3112] = 1.479E-10; m[3114] = 1.670589E-23; m[3116] = 5.485102E-24;
	m[3118] = 3.656734E-24; m[3122] = 2.631E-10; m[3124] = 4.219309E-23; m[3126] = 8.227653E-24;
	m[3128] = 3.291061E-24; m[3212] = 7.4E-20; m[3214] = 1.828367E-23; m[3216] = 5.485102E-24;
	m[3218] = 3.656734E-24; m[3222] = 8.018E-11; m[3224] = 1.838582E-23; m[3226] = 5.485102E-24;
	m[3228] = 3.656734E-24; m[3312] = 1.639E-10; m[3314] = 6.648608E-23; m[3322] = 2.9E-10;
	m[3324] = 7.233101E-23; m[3334] = 8.21E-11; m[4112] = 2.991874E-22; m[4114] = 4.088274E-23;
	m[4122] = 2.E-13; m[4132] = 1.12E-13; m[4212] = 3.999999E-22; m[4214] = 3.291061E-22;
	m[4222] = 2.951624E-22; m[4224] = 4.417531E-23; m[4232] = 4.42E-13; m[4332] = 6.9E-14;
	m[4412] = 3.335641E-13; m[4422] = 3.335641E-13; m[4432] = 3.335641E-13; m[5112] = 1.E-19;
	m[5122] = 1.38E-12; m[5132] = 1.42E-12; m[5142] = 1.290893E-12; m[5212] = 1.E-19;
	m[5222] = 1.E-19; m[5232] = 1.42E-12; m[5242] = 1.290893E-12; m[5312] = 1.E-19;
	m[5322] = 1.E-19; m[5332] = 1.55E-12; m[5342] = 1.290893E-12; m[5442] = 1.290893E-12;
	m[5512] = 1.290893E-12; m[5522] = 1.290893E-12; m[5532] = 1.290893E-12; m[5542] = 1.290893E-12;
	m[10111] = 2.48382E-24; m[10113] = 4.635297E-24; m[10115] = 2.54136E-24; m[10211] = 2.48382E-24;
	m[10213] = 4.635297E-24; m[10215] = 2.54136E-24; m[10223] = 1.828367E-24; m[10225] = 3.636531E-24;
	m[10311] = 2.437823E-24; m[10313] = 7.313469E-24; m[10315] = 3.538775E-24;
	m[10321] = 2.437823E-24; m[10323] = 7.313469E-24; m[10325] = 3.538775E-24;
	m[10331] = 4.804469E-24; m[10411] = 4.38E-24; m[10413] = 3.29E-23; m[10421] = 4.38E-24;
	m[10423] = 3.22653E-23; m[10431] = 6.5821E-22; m[10433] = 6.5821E-22; m[10441] = 6.453061E-23;
	m[10511] = 4.39E-24; m[10513] = 1.65E-23; m[10521] = 4.39E-24; m[10523] = 1.65E-23;
	m[10531] = 4.39E-24; m[10533] = 1.65E-23; m[11114] = 2.194041E-24; m[11116] = 1.828367E-24;
	m[11212] = 1.880606E-24; m[11216] = 1.828367E-24; m[12112] = 2.194041E-24;
	m[12114] = 2.194041E-24; m[12116] = 5.063171E-24; m[12126] = 1.828367E-24;
	m[12212] = 2.194041E-24; m[12214] = 2.194041E-24; m[12216] = 5.063171E-24;
	m[12224] = 2.194041E-24; m[12226] = 1.828367E-24; m[13112] = 6.582122E-24; m[13114] = 1.09702E-23;
	m[13116] = 5.485102E-24; m[13122] = 1.316424E-23; m[13124] = 1.09702E-23; m[13126] = 6.928549E-24;
	m[13212] = 6.582122E-24; m[13214] = 1.09702E-23; m[13216] = 5.485102E-24; m[13222] = 6.582122E-24;
	m[13224] = 1.09702E-23; m[13226] = 5.485102E-24; m[13314] = 2.742551E-23;
	m[13324] = 2.742551E-23; m[14122] = 1.828367E-22; m[20022] = 1.E+16; m[20113] = 1.567172E-24;
	m[20213] = 1.567172E-24; m[20223] = 2.708692E-23; m[20313] = 3.782829E-24;
	m[20315] = 2.384827E-24; m[20323] = 3.782829E-24; m[20325] = 2.384827E-24;
	m[20333] = 1.198929E-23; m[20413] = 2.63E-24; m[20423] = 2.63E-24; m[20433] = 6.5821E-22;
	m[20443] = 7.395643E-22; m[20513] = 2.63E-24; m[20523] = 2.63E-24; m[20533] = 2.63E-24;
	m[21112] = 2.632849E-24; m[21114] = 3.291061E-24; m[21212] = 2.632849E-24;
	m[21214] = 6.582122E-24; m[22112] = 4.388081E-24; m[22114] = 3.291061E-24;
	m[22122] = 2.632849E-24; m[22124] = 6.582122E-24; m[22212] = 4.388081E-24;
	m[22214] = 3.291061E-24; m[22222] = 2.632849E-24; m[22224] = 3.291061E-24;
	m[23112] = 7.313469E-24; m[23114] = 2.991874E-24; m[23122] = 4.388081E-24;
	m[23124] = 6.582122E-24; m[23126] = 3.291061E-24; m[23212] = 7.313469E-24;
	m[23214] = 2.991874E-24; m[23222] = 7.313469E-24; m[23224] = 2.991874E-24;
	m[30113] = 2.632849E-24; m[30213] = 2.632849E-24; m[30221] = 1.880606E-24;
	m[30223] = 2.089563E-24; m[30313] = 2.056913E-24; m[30323] = 2.056913E-24;
	m[30443] = 2.419898E-23; m[31114] = 1.880606E-24; m[31214] = 3.291061E-24;
	m[32112] = 3.989164E-24; m[32114] = 1.880606E-24; m[32124] = 3.291061E-24;
	m[32212] = 3.989164E-24; m[32214] = 1.880606E-24; m[32224] = 1.880606E-24;
	m[33122] = 1.880606E-23; m[42112] = 6.582122E-24; m[42212] = 6.582122E-24;
	m[43122] = 2.194041E-24; m[53122] = 4.388081E-24; m[100111] = 1.645531E-24;
	m[100113] = 1.64553E-24; m[100211] = 1.645531E-24; m[100213] = 1.64553E-24;
	m[100221] = 1.196749E-23; m[100223] = 3.061452E-24; m[100313] = 2.837122E-24;
	m[100323] = 2.837122E-24; m[100331] = 4.459432E-25; m[100333] = 4.388081E-24;
	m[100441] = 4.701516E-23; m[100443] = 2.076379E-21; m[100553] = 2.056913E-20;
	m[200553] = 3.242425E-20; m[300553] = 3.210791E-23; m[9000111] = 8.776163E-24;
	m[9000211] = 8.776163E-24; m[9000443] = 8.227652E-24; m[9000553] = 5.983747E-24;
	m[9010111] = 3.164482E-24; m[9010211] = 3.164482E-24; m[9010221] = 9.403031E-24;
	m[9010443] = 8.438618E-24; m[9010553] = 8.3318E-24; m[9020443] = 1.061633E-23;
	m[9030221] = 6.038644E-24; m[9042413] = 2.07634E-21; m[9050225] = 1.394517E-24;
	m[9060225] = 3.291061E-24; m[9080225] = 4.388081E-24; m[9090225] = 2.056913E-24;
	m[9910445] = 2.07634E-21; m[9920443] = 2.07634E-21;
	return true;
	}

	};


	const int LHCB_2011_I917009::stablePDGIds[205] = {
	311, 543, 545, 551, 555, 557, 1103, 2101, 2103, 2203, 3101, 3103, 3201, 3203, 3303,
	4101, 4103, 4124, 4201, 4203, 4301, 4303, 4312, 4314, 4322, 4324, 4334, 4403, 4414,
	4424, 4434, 4444, 5101, 5103, 5114, 5201, 5203, 5214, 5224, 5301, 5303, 5314, 5324,
	5334, 5401, 5403, 5412, 5414, 5422, 5424, 5432, 5434, 5444, 5503, 5514, 5524, 5534,
	5544, 5554, 10022, 10333, 10335, 10443, 10541, 10543, 10551, 10553, 10555, 11112,
	12118, 12122, 12218, 12222, 13316, 13326, 20543, 20553, 20555, 23314, 23324, 30343,
	30353, 30363, 30553, 33314, 33324, 41214, 42124, 52114, 52214, 100311, 100315, 100321,
	100325, 100411, 100413, 100421, 100423, 100551, 100555, 100557, 110551, 110553, 110555,
	120553, 120555, 130553, 200551, 200555, 210551, 210553, 220553, 1000001, 1000002,
	1000003, 1000004, 1000005, 1000006, 1000011, 1000012, 1000013, 1000014, 1000015,
	1000016, 1000021, 1000022, 1000023, 1000024, 1000025, 1000035, 1000037, 1000039,
	2000001, 2000002, 2000003, 2000004, 2000005, 2000006, 2000011, 2000012, 2000013,
	2000014, 2000015, 2000016, 3000111, 3000113, 3000211, 3000213, 3000221, 3000223,
	3000331, 3100021, 3100111, 3100113, 3200111, 3200113, 3300113, 3400113, 4000001,
	4000002, 4000011, 4000012, 5000039, 9000221, 9900012, 9900014, 9900016, 9900023,
	9900024, 9900041, 9900042 };


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(LHCB_2011_I917009);

	}
	diff --git a/src/Analyses/LHCB_2011_I919315.cc b/src/Analyses/LHCB_2011_I919315.cc
	--- a/src/Analyses/LHCB_2011_I919315.cc
	+++ b/src/Analyses/LHCB_2011_I919315.cc
	@@ -1,96 +1,96 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	class LHCB_2011_I919315 : public Analysis {
	public:
	/// @name Constructors etc.
	//@{

	/// Constructor
	LHCB_2011_I919315()
	: Analysis("LHCB_2011_I919315")
	{
	}

	//@}
	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");

	_h_Phi_pT_y.addHistogram( 2.44, 2.62, bookHisto1D(2, 1, 1));
	_h_Phi_pT_y.addHistogram( 2.62, 2.80, bookHisto1D(2, 1, 2));
	_h_Phi_pT_y.addHistogram( 2.80, 2.98, bookHisto1D(3, 1, 1));
	_h_Phi_pT_y.addHistogram( 2.98, 3.16, bookHisto1D(3, 1, 2));
	_h_Phi_pT_y.addHistogram( 3.16, 3.34, bookHisto1D(4, 1, 1));
	_h_Phi_pT_y.addHistogram( 3.34, 3.52, bookHisto1D(4, 1, 2));
	_h_Phi_pT_y.addHistogram( 3.52, 3.70, bookHisto1D(5, 1, 1));
	_h_Phi_pT_y.addHistogram( 3.70, 3.88, bookHisto1D(5, 1, 2));
	_h_Phi_pT_y.addHistogram( 3.88, 4.06, bookHisto1D(6, 1, 1));
	_h_Phi_pT = bookHisto1D(7, 1, 1);
	_h_Phi_y = bookHisto1D(8, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze (const Event& event) {
	const double weight = event.weight();
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState> (event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState> (event, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	const PdgId id = p.abspid();

	if (id == 333) { // id 333 = phi-meson
	double y = p.rapidity();
	double pT = p.perp();

	if (pT < 0.6GeV \|\| pT > 5.0GeV \|\| y < 2.44 \|\| y > 4.06) {
	continue;
	}

	_h_Phi_y->fill (y, weight);
	_h_Phi_pT->fill (pT/MeV, weight);
	_h_Phi_pT_y.fill(y, pT/GeV, weight);
	}
	}
	}

	/// Normalise histograms etc., after the run
	void finalize() {

	double scale_factor = crossSectionPerEvent()/microbarn;
	scale (_h_Phi_y, scale_factor);
	scale (_h_Phi_pT, scale_factor);
	_h_Phi_pT_y.scale(scale_factor/1000., this);
	}

	//@}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_Phi_y;
	Histo1DPtr _h_Phi_pT;
	BinnedHistogram<double> _h_Phi_pT_y;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(LHCB_2011_I919315);

	}

	//@}
	diff --git a/src/Analyses/LHCB_2012_I1119400.cc b/src/Analyses/LHCB_2012_I1119400.cc
	--- a/src/Analyses/LHCB_2012_I1119400.cc
	+++ b/src/Analyses/LHCB_2012_I1119400.cc
	@@ -1,357 +1,357 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class LHCB_2012_I1119400 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	LHCB_2012_I1119400() : Analysis("LHCB_2012_I1119400"),
	_p_min(5.0),
	_pt_min(0.0),_pt1_edge(0.8), _pt2_edge(1.2),
	//_eta_nbins(4),
	_eta_min(2.5),
	_eta_max(4.5)
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	fillMap(_partLftMap);

	int id_shift = 0;
	if (fuzzyEquals(sqrtS(), 7*TeV)) id_shift = 1;
	// define ratios if second pdgid in pair is -1, it means that is a antiparticle/particle ratio

	_ratiotype["pbarp"] = make_pair(2212, -1);
	_ratiotype["kminuskplus"] = make_pair(321, -1);
	_ratiotype["piminuspiplus"] = make_pair(211, -1);
	_ratiotype["ppi"] = make_pair(2212, 211);
	_ratiotype["kpi"] = make_pair(321, 211);
	_ratiotype["pk"] = make_pair(2212, 321);

	std::map<string, int > _hepdataid;
	_hepdataid["pbarp"] = 1 + id_shift;
	_hepdataid["kminuskplus"] = 3 + id_shift;
	_hepdataid["piminuspiplus"] = 5 + id_shift;
	_hepdataid["ppi"] = 7 + id_shift;
	_hepdataid["kpi"] = 9 + id_shift;
	_hepdataid["pk"] = 11 + id_shift;

	std::map<std::string, std::pair<int, int> >::iterator it;

	// booking histograms
	for (it=_ratiotype.begin(); it!=_ratiotype.end(); it++) {
	_h_ratio_lowpt [it->first] = bookScatter2D(_hepdataid[it->first], 1, 1);
	_h_ratio_midpt [it->first] = bookScatter2D(_hepdataid[it->first], 1, 2);
	_h_ratio_highpt[it->first] = bookScatter2D(_hepdataid[it->first], 1, 3);
	_h_num_lowpt [it->first] = bookHisto1D ("TMP/num_l_"+it->first,refData(_hepdataid[it->first], 1, 1));
	_h_num_midpt [it->first] = bookHisto1D ("TMP/num_m_"+it->first,refData(_hepdataid[it->first], 1, 2));
	_h_num_highpt [it->first] = bookHisto1D ("TMP/num_h_"+it->first,refData(_hepdataid[it->first], 1, 3));
	_h_den_lowpt [it->first] = bookHisto1D ("TMP/den_l_"+it->first,refData(_hepdataid[it->first], 1, 1));
	_h_den_midpt [it->first] = bookHisto1D ("TMP/den_m_"+it->first,refData(_hepdataid[it->first], 1, 2));
	_h_den_highpt [it->first] = bookHisto1D ("TMP/den_h_"+it->first,refData(_hepdataid[it->first], 1, 3));
	}

	- addProjection(ChargedFinalState(_eta_min, _eta_max, _pt_min*GeV), "CFS");
	+ declare(ChargedFinalState(_eta_min, _eta_max, _pt_min*GeV), "CFS");
	}


	// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");

	foreach (const Particle& p, cfs.particles()) {
	int id = p.pid();
	// continue if particle not a proton, a kaon or a pion
	if ( !( (abs(id) == 211) \|\| (abs(id) == 321) \|\| (abs(id) == 2212))) {
	continue;
	}

	// cut in momentum
	const FourMomentum& qmom = p.momentum();
	if (qmom.p3().mod() < _p_min) continue;

	// Lifetime cut: ctau sum of all particle ancestors < 10^-9 m according to the paper (see eq. 5)
	const double MAX_CTAU = 1.0e-9; // [m]
	double ancestor_lftsum = getMotherLifeTimeSum(p);
	if ( (ancestor_lftsum < 0.0) \|\| (ancestor_lftsum > MAX_CTAU) ) continue;

	double eta = qmom.eta();
	double pT = qmom.pT();

	std::map<std::string, std::pair<int, int> >::iterator it;

	for (it=_ratiotype.begin(); it!=_ratiotype.end(); it++) {
	// check what type of ratio is
	if ((it->second.second)==-1) {
	// check ptbin
	if (pT < _pt1_edge) {
	// filling histos for numerator and denominator
	if (id == -abs(it->second.first)) _h_num_lowpt[it->first]->fill(eta, weight);
	if (id == abs(it->second.first)) _h_den_lowpt[it->first]->fill(eta, weight);
	}
	else if (pT < _pt2_edge) {
	// filling histos for numerator and denominator
	if (id == -abs(it->second.first)) _h_num_midpt[it->first]->fill(eta, weight);
	if (id == abs(it->second.first)) _h_den_midpt[it->first]->fill(eta, weight);
	}
	else {
	// filling histos for numerator and denominator
	if (id == -abs(it->second.first)) _h_num_highpt[it->first]->fill(eta, weight);
	if (id == abs(it->second.first)) _h_den_highpt[it->first]->fill(eta, weight);
	}
	}
	else {
	// check what type of ratio is
	if (pT < _pt1_edge) {
	// filling histos for numerator and denominator
	if (abs(id) == abs(it->second.first)) _h_num_lowpt[it->first]->fill(eta, weight);
	if (abs(id) == abs(it->second.second)) _h_den_lowpt[it->first]->fill(eta, weight);
	}
	else if (pT < _pt2_edge) {
	// filling histos for numerator and denominator
	if (abs(id) == abs(it->second.first)) _h_num_midpt[it->first]->fill(eta, weight);
	if (abs(id) == abs(it->second.second)) _h_den_midpt[it->first]->fill(eta, weight);
	}
	else {
	// filling histos for numerator and denominator
	if (abs(id) == abs(it->second.first)) _h_num_highpt[it->first]->fill(eta, weight);
	if (abs(id) == abs(it->second.second)) _h_den_highpt[it->first]->fill(eta, weight);
	}
	}
	}
	}
	}


	// Generate the ratio histograms
	void finalize() {
	std::map<std::string, std::pair<int, int> >::iterator it;

	// booking histograms
	for (it=_ratiotype.begin(); it!=_ratiotype.end(); it++) {
	divide(_h_num_lowpt[it->first], _h_den_lowpt[it->first], _h_ratio_lowpt[it->first]);
	divide(_h_num_midpt[it->first], _h_den_midpt[it->first], _h_ratio_midpt[it->first]);
	divide(_h_num_highpt[it->first], _h_den_highpt[it->first], _h_ratio_highpt[it->first]);
	}
	}

	//@}


	private:


	// Get particle lifetime from hardcoded data
	double getLifeTime(int pid) {
	pid = abs(pid);
	double lft = -1.0;
	map<int, double>::iterator pPartLft = _partLftMap.find(pid);
	// search stable particle list
	if (pPartLft == _partLftMap.end()) {
	if (pid <= 100) return 0.0;
	for (size_t i=0; i < sizeof(_stablePDGIds)/sizeof(unsigned int); i++) {
	if (pid == _stablePDGIds[i]) {
	lft = 0.0;
	break;
	}
	}
	} else {
	lft = (*pPartLft).second;
	}
	if (lft < 0.0 && PID::isHadron(pid)) {
	MSG_WARNING("Lifetime map imcomplete --- " << pid
	<< "... assume zero lifetime");
	lft = 0.0;
	}
	return lft;
	}

	// Data members like post-cuts event weight counters go here
	const double getMotherLifeTimeSum(const Particle& p) {
	if (p.genParticle() == NULL) return -1.;
	double lftSum = 0.;
	double plft = 0.;
	const GenParticle* part = p.genParticle();
	const GenVertex* ivtx = part->production_vertex();
	while(ivtx)
	{
	if (ivtx->particles_in_size() < 1) { lftSum = -1.; break; };
	const GenVertex::particles_in_const_iterator iPart_invtx = ivtx->particles_in_const_begin();
	part = (*iPart_invtx);
	if ( !(part) ) { lftSum = -1.; break; };
	ivtx = part->production_vertex();
	if ( (part->pdg_id() == 2212) \|\| !(ivtx) ) break; // reached beam
	plft = getLifeTime(part->pdg_id());
	if (plft < 0.) { lftSum = -1.; break; };
	lftSum += plft;
	};
	return (lftSum * c_light);
	}

	/// @name Private variables
	// Momentum threshold
	double _p_min;

	// The edges of the intervals of transversal momentum
	double _pt_min;
	double _pt1_edge;
	double _pt2_edge;

	// The limits of the pseudorapidity window
	//int _eta_nbins;
	double _eta_min;
	double _eta_max;

	// Map between PDG id and particle lifetimes in seconds
	std::map<int, double> _partLftMap;

	// Set of PDG Ids for stable particles (PDG Id <= 100 are considered stable)
	static const int _stablePDGIds[205];

	// Define histograms
	// ratio
	std::map<std::string, Scatter2DPtr > _h_ratio_lowpt;
	std::map<std::string, Scatter2DPtr > _h_ratio_midpt;
	std::map<std::string, Scatter2DPtr > _h_ratio_highpt;
	// numerator
	std::map<std::string, Histo1DPtr > _h_num_lowpt;
	std::map<std::string, Histo1DPtr > _h_num_midpt;
	std::map<std::string, Histo1DPtr > _h_num_highpt;
	// denominator
	std::map<std::string, Histo1DPtr > _h_den_lowpt;
	std::map<std::string, Histo1DPtr > _h_den_midpt;
	std::map<std::string, Histo1DPtr > _h_den_highpt;

	// Map of ratios and IDs of numerator and denominator
	std::map<string, pair<int,int> > _ratiotype;

	// Fill the PDG Id to Lifetime[seconds] map
	// Data was extracted from LHCb Particle Table through LHCb::ParticlePropertySvc
	bool fillMap(map<int, double> &m) {
	m[6] = 4.707703E-25; m[11] = 1.E+16; m[12] = 1.E+16;
	m[13] = 2.197019E-06; m[14] = 1.E+16; m[15] = 2.906E-13; m[16] = 1.E+16; m[22] = 1.E+16;
	m[23] = 2.637914E-25; m[24] = 3.075758E-25; m[25] = 9.4E-26; m[35] = 9.4E-26;
	m[36] = 9.4E-26; m[37] = 9.4E-26; m[84] = 3.335641E-13; m[85] = 1.290893E-12;
	m[111] = 8.4E-17; m[113] = 4.405704E-24; m[115] = 6.151516E-24; m[117] = 4.088275E-24;
	m[119] = 2.102914E-24; m[130] = 5.116E-08; m[150] = 1.525E-12; m[211] = 2.6033E-08;
	m[213] = 4.405704E-24; m[215] = 6.151516E-24; m[217] = 4.088275E-24; m[219] = 2.102914E-24;
	m[221] = 5.063171E-19; m[223] = 7.752794E-23; m[225] = 3.555982E-24; m[227] = 3.91793E-24;
	m[229] = 2.777267E-24; m[310] = 8.953E-11; m[313] = 1.308573E-23; m[315] = 6.038644E-24;
	m[317] = 4.139699E-24; m[319] = 3.324304E-24; m[321] = 1.238E-08; m[323] = 1.295693E-23;
	m[325] = 6.682357E-24; m[327] = 4.139699E-24; m[329] = 3.324304E-24; m[331] = 3.210791E-21;
	m[333] = 1.545099E-22; m[335] = 9.016605E-24; m[337] = 7.565657E-24; m[350] = 1.407125E-12;
	m[411] = 1.04E-12; m[413] = 6.856377E-21; m[415] = 1.778952E-23; m[421] = 4.101E-13;
	m[423] = 1.000003E-19; m[425] = 1.530726E-23; m[431] = 5.E-13; m[433] = 1.000003E-19;
	m[435] = 3.291061E-23; m[441] = 2.465214E-23; m[443] = 7.062363E-21; m[445] = 3.242425E-22;
	m[510] = 1.525E-12; m[511] = 1.525E-12; m[513] = 1.000019E-19; m[515] = 1.31E-23;
	m[521] = 1.638E-12; m[523] = 1.000019E-19; m[525] = 1.31E-23; m[530] = 1.536875E-12;
	m[531] = 1.472E-12; m[533] = 1.E-19; m[535] = 1.31E-23; m[541] = 4.5E-13;
	m[553] = 1.218911E-20; m[1112] = 4.539394E-24; m[1114] = 5.578069E-24; m[1116] = 1.994582E-24;
	m[1118] = 2.269697E-24; m[1212] = 4.539394E-24; m[1214] = 5.723584E-24; m[1216] = 1.994582E-24;
	m[1218] = 1.316424E-24; m[2112] = 8.857E+02; m[2114] = 5.578069E-24; m[2116] = 4.388081E-24;
	m[2118] = 2.269697E-24; m[2122] = 4.539394E-24; m[2124] = 5.723584E-24; m[2126] = 1.994582E-24;
	m[2128] = 1.316424E-24; m[2212] = 1.E+16; m[2214] = 5.578069E-24; m[2216] = 4.388081E-24;
	m[2218] = 2.269697E-24; m[2222] = 4.539394E-24; m[2224] = 5.578069E-24; m[2226] = 1.994582E-24;
	m[2228] = 2.269697E-24; m[3112] = 1.479E-10; m[3114] = 1.670589E-23; m[3116] = 5.485102E-24;
	m[3118] = 3.656734E-24; m[3122] = 2.631E-10; m[3124] = 4.219309E-23; m[3126] = 8.227653E-24;
	m[3128] = 3.291061E-24; m[3212] = 7.4E-20; m[3214] = 1.828367E-23; m[3216] = 5.485102E-24;
	m[3218] = 3.656734E-24; m[3222] = 8.018E-11; m[3224] = 1.838582E-23; m[3226] = 5.485102E-24;
	m[3228] = 3.656734E-24; m[3312] = 1.639E-10; m[3314] = 6.648608E-23; m[3322] = 2.9E-10;
	m[3324] = 7.233101E-23; m[3334] = 8.21E-11; m[4112] = 2.991874E-22; m[4114] = 4.088274E-23;
	m[4122] = 2.E-13; m[4132] = 1.12E-13; m[4212] = 3.999999E-22; m[4214] = 3.291061E-22;
	m[4222] = 2.951624E-22; m[4224] = 4.417531E-23; m[4232] = 4.42E-13; m[4332] = 6.9E-14;
	m[4412] = 3.335641E-13; m[4422] = 3.335641E-13; m[4432] = 3.335641E-13; m[5112] = 1.E-19;
	m[5122] = 1.38E-12; m[5132] = 1.42E-12; m[5142] = 1.290893E-12; m[5212] = 1.E-19;
	m[5222] = 1.E-19; m[5232] = 1.42E-12; m[5242] = 1.290893E-12; m[5312] = 1.E-19;
	m[5322] = 1.E-19; m[5332] = 1.55E-12; m[5342] = 1.290893E-12; m[5442] = 1.290893E-12;
	m[5512] = 1.290893E-12; m[5522] = 1.290893E-12; m[5532] = 1.290893E-12; m[5542] = 1.290893E-12;
	m[10111] = 2.48382E-24; m[10113] = 4.635297E-24; m[10115] = 2.54136E-24; m[10211] = 2.48382E-24;
	m[10213] = 4.635297E-24; m[10215] = 2.54136E-24; m[10223] = 1.828367E-24; m[10225] = 3.636531E-24;
	m[10311] = 2.437823E-24; m[10313] = 7.313469E-24; m[10315] = 3.538775E-24;
	m[10321] = 2.437823E-24; m[10323] = 7.313469E-24; m[10325] = 3.538775E-24;
	m[10331] = 4.804469E-24; m[10411] = 4.38E-24; m[10413] = 3.29E-23; m[10421] = 4.38E-24;
	m[10423] = 3.22653E-23; m[10431] = 6.5821E-22; m[10433] = 6.5821E-22; m[10441] = 6.453061E-23;
	m[10511] = 4.39E-24; m[10513] = 1.65E-23; m[10521] = 4.39E-24; m[10523] = 1.65E-23;
	m[10531] = 4.39E-24; m[10533] = 1.65E-23; m[11114] = 2.194041E-24; m[11116] = 1.828367E-24;
	m[11212] = 1.880606E-24; m[11216] = 1.828367E-24; m[12112] = 2.194041E-24;
	m[12114] = 2.194041E-24; m[12116] = 5.063171E-24; m[12126] = 1.828367E-24;
	m[12212] = 2.194041E-24; m[12214] = 2.194041E-24; m[12216] = 5.063171E-24;
	m[12224] = 2.194041E-24; m[12226] = 1.828367E-24; m[13112] = 6.582122E-24; m[13114] = 1.09702E-23;
	m[13116] = 5.485102E-24; m[13122] = 1.316424E-23; m[13124] = 1.09702E-23; m[13126] = 6.928549E-24;
	m[13212] = 6.582122E-24; m[13214] = 1.09702E-23; m[13216] = 5.485102E-24; m[13222] = 6.582122E-24;
	m[13224] = 1.09702E-23; m[13226] = 5.485102E-24; m[13314] = 2.742551E-23;
	m[13324] = 2.742551E-23; m[14122] = 1.828367E-22; m[20022] = 1.E+16; m[20113] = 1.567172E-24;
	m[20213] = 1.567172E-24; m[20223] = 2.708692E-23; m[20313] = 3.782829E-24;
	m[20315] = 2.384827E-24; m[20323] = 3.782829E-24; m[20325] = 2.384827E-24;
	m[20333] = 1.198929E-23; m[20413] = 2.63E-24; m[20423] = 2.63E-24; m[20433] = 6.5821E-22;
	m[20443] = 7.395643E-22; m[20513] = 2.63E-24; m[20523] = 2.63E-24; m[20533] = 2.63E-24;
	m[21112] = 2.632849E-24; m[21114] = 3.291061E-24; m[21212] = 2.632849E-24;
	m[21214] = 6.582122E-24; m[22112] = 4.388081E-24; m[22114] = 3.291061E-24;
	m[22122] = 2.632849E-24; m[22124] = 6.582122E-24; m[22212] = 4.388081E-24;
	m[22214] = 3.291061E-24; m[22222] = 2.632849E-24; m[22224] = 3.291061E-24;
	m[23112] = 7.313469E-24; m[23114] = 2.991874E-24; m[23122] = 4.388081E-24;
	m[23124] = 6.582122E-24; m[23126] = 3.291061E-24; m[23212] = 7.313469E-24;
	m[23214] = 2.991874E-24; m[23222] = 7.313469E-24; m[23224] = 2.991874E-24;
	m[30113] = 2.632849E-24; m[30213] = 2.632849E-24; m[30221] = 1.880606E-24;
	m[30223] = 2.089563E-24; m[30313] = 2.056913E-24; m[30323] = 2.056913E-24;
	m[30443] = 2.419898E-23; m[31114] = 1.880606E-24; m[31214] = 3.291061E-24;
	m[32112] = 3.989164E-24; m[32114] = 1.880606E-24; m[32124] = 3.291061E-24;
	m[32212] = 3.989164E-24; m[32214] = 1.880606E-24; m[32224] = 1.880606E-24;
	m[33122] = 1.880606E-23; m[42112] = 6.582122E-24; m[42212] = 6.582122E-24;
	m[43122] = 2.194041E-24; m[53122] = 4.388081E-24; m[100111] = 1.645531E-24;
	m[100113] = 1.64553E-24; m[100211] = 1.645531E-24; m[100213] = 1.64553E-24;
	m[100221] = 1.196749E-23; m[100223] = 3.061452E-24; m[100313] = 2.837122E-24;
	m[100323] = 2.837122E-24; m[100331] = 4.459432E-25; m[100333] = 4.388081E-24;
	m[100441] = 4.701516E-23; m[100443] = 2.076379E-21; m[100553] = 2.056913E-20;
	m[200553] = 3.242425E-20; m[300553] = 3.210791E-23; m[9000111] = 8.776163E-24;
	m[9000211] = 8.776163E-24; m[9000443] = 8.227652E-24; m[9000553] = 5.983747E-24;
	m[9010111] = 3.164482E-24; m[9010211] = 3.164482E-24; m[9010221] = 9.403031E-24;
	m[9010443] = 8.438618E-24; m[9010553] = 8.3318E-24; m[9020443] = 1.061633E-23;
	m[9030221] = 6.038644E-24; m[9042413] = 2.07634E-21; m[9050225] = 1.394517E-24;
	m[9060225] = 3.291061E-24; m[9080225] = 4.388081E-24; m[9090225] = 2.056913E-24;
	m[9910445] = 2.07634E-21; m[9920443] = 2.07634E-21;
	return true;
	}

	};


	const int LHCB_2012_I1119400::_stablePDGIds[205] = {
	311, 543, 545, 551, 555, 557, 1103, 2101, 2103, 2203, 3101, 3103, 3201, 3203, 3303,
	4101, 4103, 4124, 4201, 4203, 4301, 4303, 4312, 4314, 4322, 4324, 4334, 4403, 4414,
	4424, 4434, 4444, 5101, 5103, 5114, 5201, 5203, 5214, 5224, 5301, 5303, 5314, 5324,
	5334, 5401, 5403, 5412, 5414, 5422, 5424, 5432, 5434, 5444, 5503, 5514, 5524, 5534,
	5544, 5554, 10022, 10333, 10335, 10443, 10541, 10543, 10551, 10553, 10555, 11112,
	12118, 12122, 12218, 12222, 13316, 13326, 20543, 20553, 20555, 23314, 23324, 30343,
	30353, 30363, 30553, 33314, 33324, 41214, 42124, 52114, 52214, 100311, 100315, 100321,
	100325, 100411, 100413, 100421, 100423, 100551, 100555, 100557, 110551, 110553, 110555,
	120553, 120555, 130553, 200551, 200555, 210551, 210553, 220553, 1000001, 1000002,
	1000003, 1000004, 1000005, 1000006, 1000011, 1000012, 1000013, 1000014, 1000015,
	1000016, 1000021, 1000022, 1000023, 1000024, 1000025, 1000035, 1000037, 1000039,
	2000001, 2000002, 2000003, 2000004, 2000005, 2000006, 2000011, 2000012, 2000013,
	2000014, 2000015, 2000016, 3000111, 3000113, 3000211, 3000213, 3000221, 3000223,
	3000331, 3100021, 3100111, 3100113, 3200111, 3200113, 3300113, 3400113, 4000001,
	4000002, 4000011, 4000012, 5000039, 9000221, 9900012, 9900014, 9900016, 9900023,
	9900024, 9900041, 9900042 };


	// Plugin hook
	DECLARE_RIVET_PLUGIN(LHCB_2012_I1119400);

	}
	diff --git a/src/Analyses/LHCB_2012_I1208102.cc b/src/Analyses/LHCB_2012_I1208102.cc
	--- a/src/Analyses/LHCB_2012_I1208102.cc
	+++ b/src/Analyses/LHCB_2012_I1208102.cc
	@@ -1,79 +1,79 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	/// Differential cross-sections of $\mathrm{Z}/\gamma^* \to e^{+}e^{-}$ vs rapidity and $\phi^*$
	class LHCB_2012_I1208102 : public Analysis {
	public:


	/// Constructor
	LHCB_2012_I1208102()
	: Analysis("LHCB_2012_I1208102")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	ZFinder zeefinder(FinalState(), Cuts::etaIn(2.0, 4.5) && Cuts::pT > 20GeV, PID::ELECTRON, 60GeV, 120*GeV);
	- addProjection(zeefinder, "ZeeFinder");
	+ declare(zeefinder, "ZeeFinder");

	_h_sigma_vs_y = bookHisto1D(2, 1, 1);
	_h_sigma_vs_phi = bookHisto1D(3, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& e) {
	- const ZFinder& zeefinder = applyProjection<ZFinder>(e, "ZeeFinder");
	+ const ZFinder& zeefinder = apply<ZFinder>(e, "ZeeFinder");
	if (zeefinder.empty()) vetoEvent;
	if (zeefinder.bosons().size() > 1)
	MSG_WARNING("Found multiple (" << zeefinder.bosons().size() << ") Z -> e+ e- decays!");

	// Z momenta
	const FourMomentum& zee = zeefinder.bosons()[0].momentum();
	const Particle& pozitron = zeefinder.constituents()[0];
	const Particle& electron = zeefinder.constituents()[1];

	// Calculation of the angular variable
	const double diffphi = deltaPhi(pozitron, electron);
	const double diffpsd = deltaEta(pozitron, electron);
	const double accphi = M_PI - diffphi;
	const double angular = tan(accphi/2) / cosh(diffpsd/2);

	// Fill histograms
	_h_sigma_vs_y->fill(zee.rapidity(), e.weight());
	_h_sigma_vs_phi->fill(angular, e.weight());
	}


	/// Finalize
	void finalize() {
	const double xs = crossSection()/picobarn;
	scale(_h_sigma_vs_y, xs/sumOfWeights());
	scale(_h_sigma_vs_phi, xs/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_sigma_vs_y, _h_sigma_vs_phi;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(LHCB_2012_I1208102);

	}
	diff --git a/src/Analyses/LHCB_2013_I1208105.cc b/src/Analyses/LHCB_2013_I1208105.cc
	--- a/src/Analyses/LHCB_2013_I1208105.cc
	+++ b/src/Analyses/LHCB_2013_I1208105.cc
	@@ -1,231 +1,231 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class LHCB_2013_I1208105 : public Analysis {
	public:

	LHCB_2013_I1208105()
	: Analysis("LHCB_2013_I1208105")
	{ }


	void init() {
	// Projections
	- addProjection(FinalState(1.9, 4.9), "forwardFS");
	- addProjection(FinalState(-3.5,-1.5), "backwardFS");
	- addProjection(ChargedFinalState(1.9, 4.9), "forwardCFS");
	- addProjection(ChargedFinalState(-3.5,-1.5), "backwardCFS");
	+ declare(FinalState(1.9, 4.9), "forwardFS");
	+ declare(FinalState(-3.5,-1.5), "backwardFS");
	+ declare(ChargedFinalState(1.9, 4.9), "forwardCFS");
	+ declare(ChargedFinalState(-3.5,-1.5), "backwardCFS");

	// Histos
	_s_chEF_minbias = bookScatter2D(1, 1, 1, true);
	_s_chEF_hard = bookScatter2D(2, 1, 1, true);
	_s_chEF_diff = bookScatter2D(3, 1, 1, true);
	_s_chEF_nondiff = bookScatter2D(4, 1, 1, true);
	_s_totEF_minbias = bookScatter2D(5, 1, 1, true);
	_s_totEF_hard = bookScatter2D(6, 1, 1, true);
	_s_totEF_diff = bookScatter2D(7, 1, 1, true);
	_s_totEF_nondiff = bookScatter2D(8, 1, 1, true);

	// Temporary profiles and histos
	/// @todo Convert to declared/registered temp histos
	_tp_chEF_minbias.reset(new YODA::Profile1D(refData(1,1,1)));
	_tp_chEF_hard.reset(new YODA::Profile1D(refData(2,1,1)));
	_tp_chEF_diff.reset(new YODA::Profile1D(refData(3,1,1)));
	_tp_chEF_nondiff.reset(new YODA::Profile1D(refData(4,1,1)));
	_tp_totEF_minbias.reset(new YODA::Profile1D(refData(5,1,1)));
	_tp_totEF_hard.reset(new YODA::Profile1D(refData(6,1,1)));
	_tp_totEF_diff.reset(new YODA::Profile1D(refData(7,1,1)));
	_tp_totEF_nondiff.reset(new YODA::Profile1D(refData(8,1,1)));
	//
	_th_chN_minbias.reset(new YODA::Histo1D(refData(1,1,1)));
	_th_chN_hard.reset(new YODA::Histo1D(refData(2,1,1)));
	_th_chN_diff.reset(new YODA::Histo1D(refData(3,1,1)));
	_th_chN_nondiff.reset(new YODA::Histo1D(refData(4,1,1)));
	_th_totN_minbias.reset(new YODA::Histo1D(refData(5,1,1)));
	_th_totN_hard.reset(new YODA::Histo1D(refData(6,1,1)));
	_th_totN_diff.reset(new YODA::Histo1D(refData(7,1,1)));
	_th_totN_nondiff.reset(new YODA::Histo1D(refData(8,1,1)));

	// Counters
	_mbSumW = 0.0; _hdSumW = 0.0; _dfSumW = 0.0; _ndSumW = 0.0;
	_mbchSumW = 0.0; _hdchSumW = 0.0; _dfchSumW = 0.0; _ndchSumW = 0.0;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const FinalState& ffs = applyProjection<FinalState>(event, "forwardFS");
	- const FinalState& bfs = applyProjection<FinalState>(event, "backwardFS");
	- const ChargedFinalState& fcfs = applyProjection<ChargedFinalState>(event, "forwardCFS");
	- const ChargedFinalState& bcfs = applyProjection<ChargedFinalState>(event, "backwardCFS");
	+ const FinalState& ffs = apply<FinalState>(event, "forwardFS");
	+ const FinalState& bfs = apply<FinalState>(event, "backwardFS");
	+ const ChargedFinalState& fcfs = apply<ChargedFinalState>(event, "forwardCFS");
	+ const ChargedFinalState& bcfs = apply<ChargedFinalState>(event, "backwardCFS");

	// Veto this event completely if there are no forward charged particles
	if (fcfs.empty()) vetoEvent;

	// Charged and neutral version
	{
	// Decide empirically if this is a "hard" or "diffractive" event
	bool ishardEvt = false;
	foreach (const Particle& p, ffs.particles()) {
	if (p.pT() > 3.0*GeV) { ishardEvt = true; break; }
	}
	// Decide empirically if this is a "diffractive" event
	/// @todo Can be "diffractive" and "hard"?
	bool isdiffEvt = (bfs.size() == 0);

	// Update event-type weight counters
	_mbSumW += weight;
	(isdiffEvt ? _dfSumW : _ndSumW) += weight;
	if (ishardEvt) _hdSumW += weight;

	// Plot energy flow
	foreach (const Particle& p, ffs.particles()) {
	const double eta = p.eta();
	const double energy = p.E();
	_tp_totEF_minbias->fill(eta, energy, weight);
	_th_totN_minbias->fill(eta, weight);
	if (ishardEvt) {
	_tp_totEF_hard->fill(eta, energy, weight);
	_th_totN_hard->fill(eta, weight);
	}
	if (isdiffEvt) {
	_tp_totEF_diff->fill(eta, energy, weight);
	_th_totN_diff->fill(eta, weight);
	} else {
	_tp_totEF_nondiff->fill(eta, energy, weight);
	_th_totN_nondiff->fill(eta, weight);
	}
	}
	}


	// Charged-only version
	{
	bool ishardEvt = false;
	foreach (const Particle& p, fcfs.particles()) {
	if (p.pT() > 3.0*GeV) { ishardEvt = true; break; }
	}
	// Decide empirically if this is a "diffractive" event
	/// @todo Can be "diffractive" and "hard"?
	bool isdiffEvt = (bcfs.size() == 0);

	// Update event-type weight counters
	_mbchSumW += weight;
	(isdiffEvt ? _dfchSumW : _ndchSumW) += weight;
	if (ishardEvt) _hdchSumW += weight;

	// Plot energy flow
	foreach (const Particle& p, fcfs.particles()) {
	const double eta = p.eta();
	const double energy = p.E();
	_tp_chEF_minbias->fill(eta, energy, weight);
	_th_chN_minbias->fill(eta, weight);
	if (ishardEvt) {
	_tp_chEF_hard->fill(eta, energy, weight);
	_th_chN_hard->fill(eta, weight);
	}
	if (isdiffEvt) {
	_tp_chEF_diff->fill(eta, energy, weight);
	_th_chN_diff->fill(eta, weight);
	} else {
	_tp_chEF_nondiff->fill(eta, energy, weight);
	_th_chN_nondiff->fill(eta, weight);
	}
	}
	}

	}


	void finalize() {
	for (size_t i = 0; i < _s_totEF_minbias->numPoints(); ++i) {
	const double val = _tp_totEF_minbias->bin(i).mean() * _th_totN_minbias->bin(i).height();
	const double err = (_tp_totEF_minbias->bin(i).mean() * _th_totN_minbias->bin(i).heightErr() +
	_tp_totEF_minbias->bin(i).stdErr() * _th_totN_minbias->bin(i).height());
	_s_totEF_minbias->point(i).setY(val/_mbSumW, err/_mbSumW);
	}
	for (size_t i = 0; i < _s_totEF_hard->numPoints(); ++i) {
	const double val = _tp_totEF_hard->bin(i).mean() * _th_totN_hard->bin(i).height();
	const double err = (_tp_totEF_hard->bin(i).mean() * _th_totN_hard->bin(i).heightErr() +
	_tp_totEF_hard->bin(i).stdErr() * _th_totN_hard->bin(i).height());
	_s_totEF_hard->point(i).setY(val/_hdSumW, err/_hdSumW);
	}
	for (size_t i = 0; i < _s_totEF_diff->numPoints(); ++i) {
	const double val = _tp_totEF_diff->bin(i).mean() * _th_totN_diff->bin(i).height();
	const double err = (_tp_totEF_diff->bin(i).mean() * _th_totN_diff->bin(i).heightErr() +
	_tp_totEF_diff->bin(i).stdErr() * _th_totN_diff->bin(i).height());
	_s_totEF_diff->point(i).setY(val/_dfSumW, err/_dfSumW);
	}
	for (size_t i = 0; i < _s_totEF_nondiff->numPoints(); ++i) {
	const double val = _tp_totEF_nondiff->bin(i).mean() * _th_totN_nondiff->bin(i).height();
	const double err = (_tp_totEF_nondiff->bin(i).mean() * _th_totN_nondiff->bin(i).heightErr() +
	_tp_totEF_nondiff->bin(i).stdErr() * _th_totN_nondiff->bin(i).height());
	_s_totEF_nondiff->point(i).setY(val/_ndSumW, err/_ndSumW);
	}
	for (size_t i = 0; i < _s_chEF_minbias->numPoints(); ++i) {
	const double val = _tp_chEF_minbias->bin(i).mean() * _th_chN_minbias->bin(i).height();
	const double err = (_tp_chEF_minbias->bin(i).mean() * _th_chN_minbias->bin(i).heightErr() +
	_tp_chEF_minbias->bin(i).stdErr() * _th_chN_minbias->bin(i).height());
	_s_chEF_minbias->point(i).setY(val/_mbchSumW, err/_mbchSumW);
	}
	for (size_t i = 0; i < _s_chEF_hard->numPoints(); ++i) {
	const double val = _tp_chEF_hard->bin(i).mean() * _th_chN_hard->bin(i).height();
	const double err = (_tp_chEF_hard->bin(i).mean() * _th_chN_hard->bin(i).heightErr() +
	_tp_chEF_hard->bin(i).stdErr() * _th_chN_hard->bin(i).height());
	_s_chEF_hard->point(i).setY(val/_hdchSumW, err/_hdchSumW);
	}
	for (size_t i = 0; i < _s_chEF_diff->numPoints(); ++i) {
	const double val = _tp_chEF_diff->bin(i).mean() * _th_chN_diff->bin(i).height();
	const double err = (_tp_chEF_diff->bin(i).mean() * _th_chN_diff->bin(i).heightErr() +
	_tp_chEF_diff->bin(i).stdErr() * _th_chN_diff->bin(i).height());
	_s_chEF_diff->point(i).setY(val/_dfchSumW, err/_dfchSumW);
	}
	for (size_t i = 0; i < _s_chEF_nondiff->numPoints(); ++i) {
	const double val = _tp_chEF_nondiff->bin(i).mean() * _th_chN_nondiff->bin(i).height();
	const double err = (_tp_chEF_nondiff->bin(i).mean() * _th_chN_nondiff->bin(i).heightErr() +
	_tp_chEF_nondiff->bin(i).stdErr() * _th_chN_nondiff->bin(i).height());
	_s_chEF_nondiff->point(i).setY(val/_ndchSumW, err/_ndchSumW);
	}
	}


	private:

	/// @name Histograms and counters
	///
	/// @note Histograms correspond to charged and total EF for each class of events:
	/// minimum bias, hard scattering, diffractive enriched and non-diffractive enriched.
	//@{

	// Scatters to be filled in finalize with 1/d_eta <N(eta)><E(eta)>
	Scatter2DPtr _s_totEF_minbias, _s_totEF_hard, _s_totEF_diff, _s_totEF_nondiff;
	Scatter2DPtr _s_chEF_minbias, _s_chEF_hard, _s_chEF_diff, _s_chEF_nondiff;

	// Temp profiles containing <E(eta)>
	std::shared_ptr<YODA::Profile1D> _tp_totEF_minbias, _tp_totEF_hard, _tp_totEF_diff, _tp_totEF_nondiff;
	std::shared_ptr<YODA::Profile1D> _tp_chEF_minbias, _tp_chEF_hard, _tp_chEF_diff, _tp_chEF_nondiff;

	// Temp profiles containing <N(eta)>
	std::shared_ptr<YODA::Histo1D> _th_totN_minbias, _th_totN_hard, _th_totN_diff, _th_totN_nondiff;
	std::shared_ptr<YODA::Histo1D> _th_chN_minbias, _th_chN_hard, _th_chN_diff, _th_chN_nondiff;

	// Sums of weights (~ #events) in each event class
	double _mbSumW, _hdSumW, _dfSumW, _ndSumW;
	double _mbchSumW, _hdchSumW, _dfchSumW, _ndchSumW;

	//@}

	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(LHCB_2013_I1208105);

	}
	diff --git a/src/Analyses/LHCB_2013_I1218996.cc b/src/Analyses/LHCB_2013_I1218996.cc
	--- a/src/Analyses/LHCB_2013_I1218996.cc
	+++ b/src/Analyses/LHCB_2013_I1218996.cc
	@@ -1,138 +1,138 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// LHCb prompt charm hadron pT and rapidity spectra
	class LHCB_2013_I1218996 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	LHCB_2013_I1218996()
	: Analysis("LHCB_2013_I1218996")
	{ }

	//@}


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(UnstableFinalState(), "UFS");

	/// Book histograms
	_h_pdg411_Dplus_pT_y.addHistogram( 2.0, 2.5, bookHisto1D(3, 1, 1));
	_h_pdg411_Dplus_pT_y.addHistogram( 2.5, 3.0, bookHisto1D(3, 1, 2));
	_h_pdg411_Dplus_pT_y.addHistogram( 3.0, 3.5, bookHisto1D(3, 1, 3));
	_h_pdg411_Dplus_pT_y.addHistogram( 3.5, 4.0, bookHisto1D(3, 1, 4));
	_h_pdg411_Dplus_pT_y.addHistogram( 4.0, 4.5, bookHisto1D(3, 1, 5));

	_h_pdg421_Dzero_pT_y.addHistogram( 2.0, 2.5, bookHisto1D(2, 1, 1));
	_h_pdg421_Dzero_pT_y.addHistogram( 2.5, 3.0, bookHisto1D(2, 1, 2));
	_h_pdg421_Dzero_pT_y.addHistogram( 3.0, 3.5, bookHisto1D(2, 1, 3));
	_h_pdg421_Dzero_pT_y.addHistogram( 3.5, 4.0, bookHisto1D(2, 1, 4));
	_h_pdg421_Dzero_pT_y.addHistogram( 4.0, 4.5, bookHisto1D(2, 1, 5));

	_h_pdg431_Dsplus_pT_y.addHistogram( 2.0, 2.5, bookHisto1D(5, 1, 1));
	_h_pdg431_Dsplus_pT_y.addHistogram( 2.5, 3.0, bookHisto1D(5, 1, 2));
	_h_pdg431_Dsplus_pT_y.addHistogram( 3.0, 3.5, bookHisto1D(5, 1, 3));
	_h_pdg431_Dsplus_pT_y.addHistogram( 3.5, 4.0, bookHisto1D(5, 1, 4));
	_h_pdg431_Dsplus_pT_y.addHistogram( 4.0, 4.5, bookHisto1D(5, 1, 5));

	_h_pdg413_Dstarplus_pT_y.addHistogram( 2.0, 2.5, bookHisto1D(4, 1, 1));
	_h_pdg413_Dstarplus_pT_y.addHistogram( 2.5, 3.0, bookHisto1D(4, 1, 2));
	_h_pdg413_Dstarplus_pT_y.addHistogram( 3.0, 3.5, bookHisto1D(4, 1, 3));
	_h_pdg413_Dstarplus_pT_y.addHistogram( 3.5, 4.0, bookHisto1D(4, 1, 4));
	_h_pdg413_Dstarplus_pT_y.addHistogram( 4.0, 4.5, bookHisto1D(4, 1, 5));

	_h_pdg4122_Lambdac_pT = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	/// @todo Use PrimaryHadrons to avoid double counting and automatically remove the contributions from unstable?
	- const UnstableFinalState &ufs = applyProjection<UnstableFinalState> (event, "UFS");
	+ const UnstableFinalState &ufs = apply<UnstableFinalState> (event, "UFS");
	foreach (const Particle& p, ufs.particles() ) {

	// We're only interested in charm hadrons
	if (!p.isHadron() \|\| !p.hasCharm()) continue;

	// Kinematic acceptance
	const double y = p.absrap(); ///< Double analysis efficiency with a "two-sided LHCb"
	const double pT = p.pT();

	// Fiducial acceptance of the measurements
	if (pT > 8.0*GeV \|\| y < 2.0 \|\| y > 4.5) continue;

	/// Experimental selection removes non-prompt charm hadrons: we ignore those from b decays
	if (p.fromBottom()) continue;

	switch (p.abspid()) {
	case 411:
	_h_pdg411_Dplus_pT_y.fill(y, pT/GeV, weight);
	break;
	case 421:
	_h_pdg421_Dzero_pT_y.fill(y, pT/GeV, weight);
	break;
	case 431:
	_h_pdg431_Dsplus_pT_y.fill(y, pT/GeV, weight);
	break;
	case 413:
	_h_pdg413_Dstarplus_pT_y.fill(y, pT/GeV, weight);
	break;
	case 4122:
	_h_pdg4122_Lambdac_pT->fill(pT/GeV, weight);
	break;
	}
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double scale_factor = 0.5 * crossSection()/microbarn / sumOfWeights();
	/// Avoid the implicit division by the bin width in the BinnedHistogram::scale method.
	foreach (Histo1DPtr h, _h_pdg411_Dplus_pT_y.getHistograms()) h->scaleW(scale_factor);
	foreach (Histo1DPtr h, _h_pdg421_Dzero_pT_y.getHistograms()) h->scaleW(scale_factor);
	foreach (Histo1DPtr h, _h_pdg431_Dsplus_pT_y.getHistograms()) h->scaleW(scale_factor);
	foreach (Histo1DPtr h, _h_pdg413_Dstarplus_pT_y.getHistograms()) h->scaleW(scale_factor);
	_h_pdg4122_Lambdac_pT->scaleW(scale_factor);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	BinnedHistogram<double> _h_pdg411_Dplus_pT_y;
	BinnedHistogram<double> _h_pdg421_Dzero_pT_y;
	BinnedHistogram<double> _h_pdg431_Dsplus_pT_y;
	BinnedHistogram<double> _h_pdg413_Dstarplus_pT_y;
	Histo1DPtr _h_pdg4122_Lambdac_pT;
	//@}


	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(LHCB_2013_I1218996);

	}
	diff --git a/src/Analyses/LHCB_2014_I1262703.cc b/src/Analyses/LHCB_2014_I1262703.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/LHCB_2014_I1262703.cc
	@@ -0,0 +1,106 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/ZFinder.hh"
	+#include "Rivet/Projections/FastJets.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief Study of forward Z + jet production at 7 TeV at LHCb
	+ /// @author W. Barter, A. Bursche, M. Sirendi (Rivet implementation)
	+ class LHCB_2014_I1262703 : public Analysis {
	+ public:
	+
	+ /// Default constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(LHCB_2014_I1262703);
	+
	+
	+ /// Initialise histograms and projections
	+ void init() {
	+
	+ // Projections
	+ const Cut mycut = Cuts::eta >= 2.0 && Cuts::eta <= 4.5 && Cuts::pT > 20*GeV;
	+ ZFinder zfinder(FinalState(), mycut, PID::MUON, 60GeV, 120GeV, 0., ZFinder::NOCLUSTER);
	+ declare(zfinder, "ZFinder");
	+ FastJets jetpro(zfinder.remainingFinalState(), FastJets::ANTIKT, 0.5);
	+ declare(jetpro, "Jets");
	+
	+ // Histograms
	+ _h_jet_pT = bookHisto1D(3, 1, 1);
	+ _h_jet_eta20 = bookHisto1D(4, 1, 1);
	+ _h_jet_eta10 = bookHisto1D(4, 1, 2);
	+ _h_Z_y20 = bookHisto1D(5, 1, 1);
	+ _h_Z_y10 = bookHisto1D(5, 1, 2);
	+ _h_Z_pT20 = bookHisto1D(6, 1, 1);
	+ _h_Z_pT10 = bookHisto1D(6, 1, 2);
	+ _h_dphi20 = bookHisto1D(7, 1, 1);
	+ _h_dphi10 = bookHisto1D(7, 1, 2);
	+ _h_dy20 = bookHisto1D(8, 1, 1);
	+ _h_dy10 = bookHisto1D(8, 1, 2);
	+ }
	+
	+
	+ /// Do the analysis
	+ void analyze(const Event & e) {
	+
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	+ if (zfinder.bosons().size() != 1) vetoEvent;
	+ const ParticleVector& leptons = zfinder.constituents();
	+
	+ const Cut jetSelector = Cuts::eta >= 2.0 && Cuts::eta <= 4.5 && Cuts::pT > 10*GeV;
	+ const Jets jets = apply<FastJets>(e, "Jets").jetsByPt(jetSelector);
	+
	+ // Clean the jets against the lepton candidates with a deltaR cut of 0.4
	+ const Jets cleanedJets = filter_discard(jets, [&](const Jet& j) { return any(leptons, deltaRLess(j, 0.4)); });
	+ // vector<const Jet*> cleanedJets;
	+ // for (size_t i = 0; i < jets.size(); i++) {
	+ // bool isolated = true;
	+ // for (size_t j = 0; j < 2; j++) {
	+ // if (deltaR(leptons[j], jets[i]) < 0.4) {
	+ // isolated = false;
	+ // break;
	+ // }
	+ // }
	+ // if (isolated) cleanedJets.push_back(&jets[i]);
	+ // }
	+
	+ // Require at least 1 survivor and note if it is above a 20 GeV jet pT threshold
	+ if (cleanedJets.empty()) vetoEvent;
	+ const bool above20 = cleanedJets[0].pT() > 20*GeV;
	+ const double dphi = deltaPhi(zfinder.boson(), cleanedJets[0]);
	+ const double drap = zfinder.boson().rap() - cleanedJets[0].rap();
	+
	+ // Fill histograms
	+ const double weight = e.weight();
	+ _h_jet_pT->fill(cleanedJets[0].pT()/GeV, weight);
	+ _h_jet_eta10->fill(cleanedJets[0].eta(), weight);
	+ _h_Z_y10->fill(zfinder.boson().rap(), weight);
	+ _h_Z_pT10->fill(zfinder.boson().pT()/GeV, weight);
	+ _h_dphi10->fill(dphi, weight);
	+ _h_dy10->fill(drap, weight);
	+ if (above20) {
	+ _h_jet_eta20->fill(cleanedJets[0].eta(), weight);
	+ _h_Z_y20->fill(zfinder.boson().rap(), weight);
	+ _h_Z_pT20->fill(zfinder.boson().pT()/GeV, weight);
	+ _h_dphi20->fill(dphi, weight);
	+ _h_dy20->fill(drap, weight);
	+ }
	+
	+ }
	+
	+
	+ /// Finalize
	+ void finalize() {
	+ normalize({_h_jet_pT, _h_jet_eta20, _h_jet_eta10, _h_Z_y20, _h_Z_y10, _h_Z_pT20, _h_Z_pT10, _h_dphi20, _h_dphi10, _h_dy20, _h_dy10});
	+ }
	+
	+
	+ /// Histograms
	+ Histo1DPtr _h_jet_pT, _h_jet_eta20, _h_jet_eta10, _h_Z_y20, _h_Z_y10, _h_Z_pT20, _h_Z_pT10, _h_dphi20, _h_dphi10, _h_dy20, _h_dy10;
	+
	+ };
	+
	+
	+ DECLARE_RIVET_PLUGIN(LHCB_2014_I1262703);
	+
	+}
	diff --git a/src/Analyses/LHCB_2014_I1281685.cc b/src/Analyses/LHCB_2014_I1281685.cc
	--- a/src/Analyses/LHCB_2014_I1281685.cc
	+++ b/src/Analyses/LHCB_2014_I1281685.cc
	@@ -1,1178 +1,1178 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	/// Charged particle multiplicities and densities in $pp$ collisions at $\sqrt{s} = 7$ TeV
	class LHCB_2014_I1281685 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	LHCB_2014_I1281685()
	: Analysis("LHCB_2014_I1281685"),
	_p_min(2.0),
	_pt_min(0.2),
	_eta_min(2.0),
	_eta_max(4.8),
	_maxlft(1.0e-11)
	{ }

	//@}


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	fillMap(_partLftMap);

	// Projections
	- addProjection(ChargedFinalState(_eta_min, _eta_max, _pt_min*GeV), "CFS");
	+ declare(ChargedFinalState(_eta_min, _eta_max, _pt_min*GeV), "CFS");

	// Book histograms
	_h_mult_total = bookHisto1D("d03-x01-y01", 50, 0.5, 50.5);

	_h_mult_eta[0] = bookHisto1D("d04-x01-y01", 21, -0.5, 20.5); //eta=[2.0,2.5]
	_h_mult_eta[1] = bookHisto1D("d04-x01-y02", 21, -0.5, 20.5); //eta=[2.5,3.0]
	_h_mult_eta[2] = bookHisto1D("d04-x01-y03", 21, -0.5, 20.5); //eta=[3.0,3.5]
	_h_mult_eta[3] = bookHisto1D("d04-x01-y04", 21, -0.5, 20.5); //eta=[3.5,4.0]
	_h_mult_eta[4] = bookHisto1D("d04-x01-y05", 21, -0.5, 20.5); //eta=[4.0,4.5]

	_h_mult_pt[0] = bookHisto1D("d05-x01-y01", 21, -0.5, 20.5); //pT=[0.2,0.3]GeV
	_h_mult_pt[1] = bookHisto1D("d05-x01-y02", 21, -0.5, 20.5); //pT=[0.3,0.4]GeV
	_h_mult_pt[2] = bookHisto1D("d05-x01-y03", 21, -0.5, 20.5); //pT=[0.4,0.6]GeV
	_h_mult_pt[3] = bookHisto1D("d05-x01-y04", 21, -0.5, 20.5); //pT=[0.6,1.0]GeV
	_h_mult_pt[4] = bookHisto1D("d05-x01-y05", 21, -0.5, 20.5); //pT=[1.0,2.0]GeV

	_h_dndeta = bookHisto1D("d01-x01-y01", 14, 2.0, 4.8); //eta=[2,4.8]
	_h_dndpt = bookHisto1D("d02-x01-y01", 18, 0.2, 2.0); //pT =[0,2]GeV

	// Counters
	_sumW = 0;
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {

	// Variable to store multiplicities per event
	int LHCbcountAll = 0; //count particles fulfiling all requirements
	int LHCbcountEta[8] = {0,0,0,0,0,0,0,0}; //count per eta-bin
	int LHCbcountPt[7] = {0,0,0,0,0,0,0}; //count per pT-bin
	vector<double> val_dNdEta;
	vector<double> val_dNdPt;
	val_dNdEta.clear();
	val_dNdPt.clear();

	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	foreach (const Particle& p, cfs.particles()) {
	int id = p.pdgId();
	// continue if particle is not a pion, kaon, proton, muon or electron
	if ( !( (abs(id) == 211) \|\| (abs(id) == 321) \|\| (abs(id) == 2212) \|\| (abs(id) == 13) \|\| (abs(id) == 11)) ) {
	continue;
	}

	const FourMomentum& qmom = p.momentum();
	const double eta = p.momentum().eta();
	const double pT = p.momentum().pT();
	//minimum momentum
	if (qmom.p3().mod() < _p_min) continue;
	//minimum tr. momentum
	if (pT < _pt_min) continue;
	//eta range
	if ((eta < _eta_min) \|\| (eta > _eta_max)) continue;

	/* Select only prompt particles via lifetime */
	//Sum of all mother lifetimes (PDG lifetime) < 10ps
	double ancestors_sumlft = getAncestorSumLifetime(p);
	if( (ancestors_sumlft > _maxlft) \|\| (ancestors_sumlft < 0) ) continue;

	//after all cuts;
	LHCbcountAll++; //count particles in whole kin. range

	//in eta bins
	if( eta >2.0 && eta <= 2.5) LHCbcountEta[0]++;
	if( eta >2.5 && eta <= 3.0) LHCbcountEta[1]++;
	if( eta >3.0 && eta <= 3.5) LHCbcountEta[2]++;
	if( eta >3.5 && eta <= 4.0) LHCbcountEta[3]++;
	if( eta >4.0 && eta <= 4.5) LHCbcountEta[4]++;
	if( eta >2.0 && eta <= 4.8) LHCbcountEta[5]++; //cross-check
	//in pT bins
	if( pT > 0.2 && pT <= 0.3) LHCbcountPt[0]++;
	if( pT > 0.3 && pT <= 0.4) LHCbcountPt[1]++;
	if( pT > 0.4 && pT <= 0.6) LHCbcountPt[2]++;
	if( pT > 0.6 && pT <= 1.0) LHCbcountPt[3]++;
	if( pT > 1.0 && pT <= 2.0) LHCbcountPt[4]++;
	if( pT > 0.2) LHCbcountPt[5]++; //cross-check

	//particle densities -> need proper normalization (finalize)
	val_dNdPt.push_back( pT );
	val_dNdEta.push_back( eta );
	}//end foreach


	// Fill histograms only, if at least 1 particle pre event was within the
	// kinematic range of the analysis!
	if (LHCbcountAll) {
	const double weight = event.weight();
	_sumW += weight;

	_h_mult_total->fill(LHCbcountAll, weight);

	_h_mult_eta[0]->fill(LHCbcountEta[0], weight);
	_h_mult_eta[1]->fill(LHCbcountEta[1], weight);
	_h_mult_eta[2]->fill(LHCbcountEta[2], weight);
	_h_mult_eta[3]->fill(LHCbcountEta[3], weight);
	_h_mult_eta[4]->fill(LHCbcountEta[4], weight);

	_h_mult_pt[0]->fill(LHCbcountPt[0], weight);
	_h_mult_pt[1]->fill(LHCbcountPt[1], weight);
	_h_mult_pt[2]->fill(LHCbcountPt[2], weight);
	_h_mult_pt[3]->fill(LHCbcountPt[3], weight);
	_h_mult_pt[4]->fill(LHCbcountPt[4], weight);

	for (size_t part = 0; part < val_dNdEta.size(); part++)
	_h_dndeta->fill(val_dNdEta[part], weight);

	for (size_t part = 0; part < val_dNdPt.size(); part++)
	_h_dndpt->fill(val_dNdPt[part], weight);

	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	const double scalefactor = 1.0/_sumW; // normalize multiplicity histograms by nEvents
	const double scale1k = 1000.; // to match '10^3' scale in reference histograms

	scale( _h_dndeta, scalefactor );
	scale( _h_dndpt, scalefactor*0.1 ); //additional factor 0.1 for [0.1 GeV/c]
	scale( _h_mult_total, scalefactor*scale1k);

	_h_mult_eta[0]->scaleW( scalefactor*scale1k );
	_h_mult_eta[1]->scaleW( scalefactor*scale1k );
	_h_mult_eta[2]->scaleW( scalefactor*scale1k );
	_h_mult_eta[3]->scaleW( scalefactor*scale1k );
	_h_mult_eta[4]->scaleW( scalefactor*scale1k );

	_h_mult_pt[0]->scaleW( scalefactor*scale1k );
	_h_mult_pt[1]->scaleW( scalefactor*scale1k );
	_h_mult_pt[2]->scaleW( scalefactor*scale1k );
	_h_mult_pt[3]->scaleW( scalefactor*scale1k );
	_h_mult_pt[4]->scaleW( scalefactor*scale1k );
	}

	//@}


	private:


	// Get mean PDG lifetime for particle with PID
	double getLifetime(int pid) {
	double lft = 0.;
	map<int, double>::iterator pPartLft = _partLftMap.find(pid);
	if (pPartLft != _partLftMap.end()) {
	lft = (*pPartLft).second;
	} else {
	// allow identifying missing life times only in debug mode
	MSG_DEBUG("Could not determine lifetime for particle with PID " << pid << "... Assume non-prompt particle");
	lft = -1;
	}
	return lft;
	}


	// Get sum of all ancestor particles
	const double getAncestorSumLifetime(const Particle& p) {
	double lftSum = 0.;
	double plft = 0.;
	const GenParticle* part = p.genParticle();
	if ( 0 == part ) return -1;
	const GenVertex* ivtx = part->production_vertex();
	while(ivtx) {
	if (ivtx->particles_in_size() < 1) { lftSum = -1.; break; };
	const GenVertex::particles_in_const_iterator iPart_invtx = ivtx->particles_in_const_begin();
	part = (*iPart_invtx);
	if ( !(part) ) { lftSum = -1.; break; };
	ivtx = part->production_vertex();
	if ( (part->pdg_id() == 2212) \|\| !(ivtx) ) break; // reached beam
	plft = getLifetime(part->pdg_id());
	if (plft < 0.) { lftSum = -1.; break; };
	lftSum += plft;
	}
	return (lftSum);
	}


	/// Hard-coded map linking PDG ID with PDG lifetime[s] (converted from ParticleTable.txt)
	bool fillMap(map<int, double>& m) {
	// PDGID = LIFETIME
	m[22] = 1.000000e+016;
	m[-11] = 1.000000e+016;
	m[11] = 1.000000e+016;
	m[12] = 1.000000e+016;
	m[-13] = 2.197036e-006;
	m[13] = 2.197036e-006;
	m[111] = 8.438618e-017;
	m[211] = 2.603276e-008;
	m[-211] = 2.603276e-008;
	m[130] = 5.174624e-008;
	m[321] = 1.238405e-008;
	m[-321] = 1.238405e-008;
	m[2112] = 885.646128;
	m[2212] = 1.000000e+016;
	m[-2212] = 1.000000e+016;
	m[310] = 8.934603e-011;
	m[221] = 5.578070e-019;
	m[3122] = 2.631796e-010;
	m[3222] = 8.018178e-011;
	m[3212] = 7.395643e-020;
	m[3112] = 1.479129e-010;
	m[3322] = 2.899613e-010;
	m[3312] = 1.637344e-010;
	m[3334] = 8.207135e-011;
	m[-2112] = 885.646128;
	m[-3122] = 2.631796e-010;
	m[-3222] = 8.018178e-011;
	m[-3212] = 7.395643e-020;
	m[-3112] = 1.479129e-010;
	m[-3322] = 2.899613e-010;
	m[-3312] = 1.637344e-010;
	m[-3334] = 8.207135e-011;
	m[113] = 4.411610e-024;
	m[213] = 4.411610e-024;
	m[-213] = 4.411610e-024;
	m[223] = 7.798723e-023;
	m[333] = 1.545099e-022;
	m[323] = 1.295693e-023;
	m[-323] = 1.295693e-023;
	m[313] = 1.298249e-023;
	m[-313] = 1.298249e-023;
	m[20213] = 1.500000e-024;
	m[-20213] = 1.500000e-024;
	m[450000000] = 1.000000e+015;
	m[460000000] = 1.000000e+015;
	m[470000000] = 1.000000e+015;
	m[480000000] = 1.000000e+015;
	m[490000000] = 1.000000e+015;
	m[20022] = 1.000000e+016;
	m[-15] = 2.906014e-013;
	m[15] = 2.906014e-013;
	m[24] = 3.104775e-025;
	m[-24] = 3.104775e-025;
	m[23] = 2.637914e-025;
	m[411] = 1.051457e-012;
	m[-411] = 1.051457e-012;
	m[421] = 4.116399e-013;
	m[-421] = 4.116399e-013;
	m[431] = 4.904711e-013;
	m[-431] = 4.904711e-013;
	m[4122] = 1.994582e-013;
	m[-4122] = 1.994582e-013;
	m[443] = 7.565657e-021;
	m[413] = 6.856377e-021;
	m[-413] = 6.856377e-021;
	m[423] = 1.000003e-019;
	m[-423] = 1.000003e-019;
	m[433] = 1.000003e-019;
	m[-433] = 1.000003e-019;
	m[521] = 1.671000e-012;
	m[-521] = 1.671000e-012;
	m[511] = 1.536000e-012;
	m[-511] = 1.536000e-012;
	m[531] = 1.461000e-012;
	m[-531] = 1.461000e-012;
	m[541] = 4.600000e-013;
	m[-541] = 4.600000e-013;
	m[5122] = 1.229000e-012;
	m[-5122] = 1.229000e-012;
	m[4112] = 4.388081e-022;
	m[-4112] = 4.388081e-022;
	m[4212] = 3.999999e-022;
	m[-4212] = 3.999999e-022;
	m[4222] = 3.291060e-022;
	m[-4222] = 3.291060e-022;
	m[25] = 9.400000e-026;
	m[35] = 9.400000e-026;
	m[36] = 9.400000e-026;
	m[37] = 9.400000e-026;
	m[-37] = 9.400000e-026;
	m[4312] = 9.800002e-014;
	m[-4312] = 9.800002e-014;
	m[4322] = 3.500001e-013;
	m[-4322] = 3.500001e-013;
	m[4332] = 6.453061e-014;
	m[-4332] = 6.453061e-014;
	m[4132] = 9.824063e-014;
	m[-4132] = 9.824063e-014;
	m[4232] = 4.417532e-013;
	m[-4232] = 4.417532e-013;
	m[5222] = 1.000000e-019;
	m[-5222] = 1.000000e-019;
	m[5212] = 1.000000e-019;
	m[-5212] = 1.000000e-019;
	m[5112] = 1.000000e-019;
	m[-5112] = 1.000000e-019;
	m[5312] = 1.000000e-019;
	m[-5312] = 1.000000e-019;
	m[5322] = 1.000000e-019;
	m[-5322] = 1.000000e-019;
	m[5332] = 1.550000e-012;
	m[-5332] = 1.550000e-012;
	m[5132] = 1.390000e-012;
	m[-5132] = 1.390000e-012;
	m[5232] = 1.390000e-012;
	m[-5232] = 1.390000e-012;
	m[100443] = 2.194041e-021;
	m[331] = 3.258476e-021;
	m[441] = 4.113826e-023;
	m[10441] = 4.063038e-023;
	m[20443] = 7.154480e-022;
	m[445] = 3.164482e-022;
	m[9000111] = 1.149997e-023;
	m[9000211] = 1.149997e-023;
	m[-9000211] = 1.149997e-023;
	m[20113] = 1.500000e-024;
	m[115] = 6.151516e-024;
	m[215] = 6.151516e-024;
	m[-215] = 6.151516e-024;
	m[10323] = 7.313469e-024;
	m[-10323] = 7.313469e-024;
	m[10313] = 7.313469e-024;
	m[-10313] = 7.313469e-024;
	m[20323] = 3.782829e-024;
	m[-20323] = 3.782829e-024;
	m[20313] = 3.782829e-024;
	m[-20313] = 3.782829e-024;
	m[10321] = 2.238817e-024;
	m[-10321] = 2.238817e-024;
	m[10311] = 2.238817e-024;
	m[-10311] = 2.238817e-024;
	m[325] = 6.682357e-024;
	m[-325] = 6.682357e-024;
	m[315] = 6.038644e-024;
	m[-315] = 6.038644e-024;
	m[10411] = 4.380000e-024;
	m[20413] = 2.630000e-024;
	m[10413] = 3.290000e-023;
	m[-415] = 2.632849e-023;
	m[-10411] = 4.380000e-024;
	m[-20413] = 2.630000e-024;
	m[-10413] = 3.290000e-023;
	m[415] = 2.632849e-023;
	m[10421] = 4.380000e-024;
	m[20423] = 2.630000e-024;
	m[10423] = 3.482604e-023;
	m[-425] = 2.861792e-023;
	m[-10421] = 4.380000e-024;
	m[-20423] = 2.630000e-024;
	m[-10423] = 3.482604e-023;
	m[425] = 2.861792e-023;
	m[10431] = 6.582100e-022;
	m[20433] = 6.582100e-022;
	m[10433] = 6.582100e-022;
	m[435] = 4.388100e-023;
	m[-10431] = 6.582100e-022;
	m[-20433] = 6.582100e-022;
	m[-10433] = 6.582100e-022;
	m[-435] = 4.388100e-023;
	m[2224] = 5.485102e-024;
	m[2214] = 5.485102e-024;
	m[2114] = 5.485102e-024;
	m[1114] = 5.485102e-024;
	m[-2224] = 5.485102e-024;
	m[-2214] = 5.485102e-024;
	m[-2114] = 5.485102e-024;
	m[-1114] = 5.485102e-024;
	m[-523] = 1.000019e-019;
	m[523] = 1.000019e-019;
	m[513] = 1.000019e-019;
	m[-513] = 1.000019e-019;
	m[533] = 1.000000e-019;
	m[-533] = 1.000000e-019;
	m[10521] = 4.390000e-024;
	m[20523] = 2.630000e-024;
	m[10523] = 1.650000e-023;
	m[525] = 1.310000e-023;
	m[-10521] = 4.390000e-024;
	m[-20523] = 2.630000e-024;
	m[-10523] = 1.650000e-023;
	m[-525] = 1.310000e-023;
	m[10511] = 4.390000e-024;
	m[20513] = 2.630000e-024;
	m[10513] = 1.650000e-023;
	m[515] = 1.310000e-023;
	m[-10511] = 4.390000e-024;
	m[-20513] = 2.630000e-024;
	m[-10513] = 1.650000e-023;
	m[-515] = 1.310000e-023;
	m[10531] = 4.390000e-024;
	m[20533] = 2.630000e-024;
	m[10533] = 1.650000e-023;
	m[535] = 1.310000e-023;
	m[-10531] = 4.390000e-024;
	m[-20533] = 2.630000e-024;
	m[-10533] = 1.650000e-023;
	m[-535] = 1.310000e-023;
	m[14] = 1.000000e+016;
	m[-14] = 1.000000e+016;
	m[-12] = 1.000000e+016;
	m[1] = 0.000000e+000;
	m[-1] = 0.000000e+000;
	m[2] = 0.000000e+000;
	m[-2] = 0.000000e+000;
	m[3] = 0.000000e+000;
	m[-3] = 0.000000e+000;
	m[4] = 0.000000e+000;
	m[-4] = 0.000000e+000;
	m[5] = 0.000000e+000;
	m[-5] = 0.000000e+000;
	m[6] = 4.707703e-025;
	m[-6] = 4.707703e-025;
	m[7] = 0.000000e+000;
	m[-7] = 0.000000e+000;
	m[8] = 0.000000e+000;
	m[-8] = 0.000000e+000;
	m[16] = 1.000000e+016;
	m[-16] = 1.000000e+016;
	m[17] = 0.000000e+000;
	m[-17] = 0.000000e+000;
	m[18] = 0.000000e+000;
	m[-18] = 0.000000e+000;
	m[21] = 0.000000e+000;
	m[32] = 0.000000e+000;
	m[33] = 0.000000e+000;
	m[34] = 0.000000e+000;
	m[-34] = 0.000000e+000;
	m[39] = 0.000000e+000;
	m[41] = 0.000000e+000;
	m[-41] = 0.000000e+000;
	m[42] = 0.000000e+000;
	m[-42] = 0.000000e+000;
	m[43] = 0.000000e+000;
	m[44] = 0.000000e+000;
	m[-44] = 0.000000e+000;
	m[81] = 0.000000e+000;
	m[82] = 0.000000e+000;
	m[-82] = 0.000000e+000;
	m[83] = 0.000000e+000;
	m[84] = 3.335641e-013;
	m[-84] = 3.335641e-013;
	m[85] = 1.290893e-012;
	m[-85] = 1.290893e-012;
	m[86] = 0.000000e+000;
	m[-86] = 0.000000e+000;
	m[87] = 0.000000e+000;
	m[-87] = 0.000000e+000;
	m[88] = 0.000000e+000;
	m[90] = 0.000000e+000;
	m[91] = 0.000000e+000;
	m[92] = 0.000000e+000;
	m[93] = 0.000000e+000;
	m[94] = 0.000000e+000;
	m[95] = 0.000000e+000;
	m[96] = 0.000000e+000;
	m[97] = 0.000000e+000;
	m[98] = 0.000000e+000;
	m[99] = 0.000000e+000;
	m[117] = 4.088275e-024;
	m[119] = 1.828367e-024;
	m[217] = 4.088275e-024;
	m[-217] = 4.088275e-024;
	m[219] = 1.828367e-024;
	m[-219] = 1.828367e-024;
	m[225] = 3.555982e-024;
	m[227] = 3.917930e-024;
	m[229] = 3.392846e-024;
	m[311] = 1.000000e+016;
	m[-311] = 1.000000e+016;
	m[317] = 4.139699e-024;
	m[-317] = 4.139699e-024;
	m[319] = 3.324304e-024;
	m[-319] = 3.324304e-024;
	m[327] = 4.139699e-024;
	m[-327] = 4.139699e-024;
	m[329] = 3.324304e-024;
	m[-329] = 3.324304e-024;
	m[335] = 8.660687e-024;
	m[337] = 7.565657e-024;
	m[543] = 0.000000e+000;
	m[-543] = 0.000000e+000;
	m[545] = 0.000000e+000;
	m[-545] = 0.000000e+000;
	m[551] = 0.000000e+000;
	m[553] = 1.253738e-020;
	m[555] = 1.000000e+016;
	m[557] = 0.000000e+000;
	m[-450000000] = 0.000000e+000;
	m[-490000000] = 0.000000e+000;
	m[-460000000] = 0.000000e+000;
	m[-470000000] = 0.000000e+000;
	m[1103] = 0.000000e+000;
	m[-1103] = 0.000000e+000;
	m[1112] = 4.388081e-024;
	m[-1112] = 4.388081e-024;
	m[1116] = 1.880606e-024;
	m[-1116] = 1.880606e-024;
	m[1118] = 2.194041e-024;
	m[-1118] = 2.194041e-024;
	m[1212] = 4.388081e-024;
	m[-1212] = 4.388081e-024;
	m[1214] = 5.485102e-024;
	m[-1214] = 5.485102e-024;
	m[1216] = 1.880606e-024;
	m[-1216] = 1.880606e-024;
	m[1218] = 1.462694e-024;
	m[-1218] = 1.462694e-024;
	m[2101] = 0.000000e+000;
	m[-2101] = 0.000000e+000;
	m[2103] = 0.000000e+000;
	m[-2103] = 0.000000e+000;
	m[2116] = 4.388081e-024;
	m[-2116] = 4.388081e-024;
	m[2118] = 2.194041e-024;
	m[-2118] = 2.194041e-024;
	m[2122] = 4.388081e-024;
	m[-2122] = 4.388081e-024;
	m[2124] = 5.485102e-024;
	m[-2124] = 5.485102e-024;
	m[2126] = 1.880606e-024;
	m[-2126] = 1.880606e-024;
	m[2128] = 1.462694e-024;
	m[-2128] = 1.462694e-024;
	m[2203] = 0.000000e+000;
	m[-2203] = 0.000000e+000;
	m[2216] = 4.388081e-024;
	m[-2216] = 4.388081e-024;
	m[2218] = 2.194041e-024;
	m[-2218] = 2.194041e-024;
	m[2222] = 4.388081e-024;
	m[-2222] = 4.388081e-024;
	m[2226] = 1.880606e-024;
	m[-2226] = 1.880606e-024;
	m[2228] = 2.194041e-024;
	m[-2228] = 2.194041e-024;
	m[3101] = 0.000000e+000;
	m[-3101] = 0.000000e+000;
	m[3103] = 0.000000e+000;
	m[-3103] = 0.000000e+000;
	m[3114] = 1.670589e-023;
	m[-3114] = 1.670589e-023;
	m[3116] = 5.485102e-024;
	m[-3116] = 5.485102e-024;
	m[3118] = 3.656734e-024;
	m[-3118] = 3.656734e-024;
	m[3124] = 4.219309e-023;
	m[-3124] = 4.219309e-023;
	m[3126] = 8.227653e-024;
	m[-3126] = 8.227653e-024;
	m[3128] = 3.291061e-024;
	m[-3128] = 3.291061e-024;
	m[3201] = 0.000000e+000;
	m[-3201] = 0.000000e+000;
	m[3203] = 0.000000e+000;
	m[-3203] = 0.000000e+000;
	m[3214] = 1.828367e-023;
	m[-3214] = 1.828367e-023;
	m[3216] = 5.485102e-024;
	m[-3216] = 5.485102e-024;
	m[3218] = 3.656734e-024;
	m[-3218] = 3.656734e-024;
	m[3224] = 1.838582e-023;
	m[-3224] = 1.838582e-023;
	m[3226] = 5.485102e-024;
	m[-3226] = 5.485102e-024;
	m[3228] = 3.656734e-024;
	m[-3228] = 3.656734e-024;
	m[3303] = 0.000000e+000;
	m[-3303] = 0.000000e+000;
	m[3314] = 6.648608e-023;
	m[-3314] = 6.648608e-023;
	m[3324] = 7.233101e-023;
	m[-3324] = 7.233101e-023;
	m[4101] = 0.000000e+000;
	m[-4101] = 0.000000e+000;
	m[4103] = 0.000000e+000;
	m[-4103] = 0.000000e+000;
	m[4114] = 0.000000e+000;
	m[-4114] = 0.000000e+000;
	m[4201] = 0.000000e+000;
	m[-4201] = 0.000000e+000;
	m[4203] = 0.000000e+000;
	m[-4203] = 0.000000e+000;
	m[4214] = 3.291061e-022;
	m[-4214] = 3.291061e-022;
	m[4224] = 0.000000e+000;
	m[-4224] = 0.000000e+000;
	m[4301] = 0.000000e+000;
	m[-4301] = 0.000000e+000;
	m[4303] = 0.000000e+000;
	m[-4303] = 0.000000e+000;
	m[4314] = 0.000000e+000;
	m[-4314] = 0.000000e+000;
	m[4324] = 0.000000e+000;
	m[-4324] = 0.000000e+000;
	m[4334] = 0.000000e+000;
	m[-4334] = 0.000000e+000;
	m[4403] = 0.000000e+000;
	m[-4403] = 0.000000e+000;
	m[4412] = 3.335641e-013;
	m[-4412] = 3.335641e-013;
	m[4414] = 3.335641e-013;
	m[-4414] = 3.335641e-013;
	m[4422] = 3.335641e-013;
	m[-4422] = 3.335641e-013;
	m[4424] = 3.335641e-013;
	m[-4424] = 3.335641e-013;
	m[4432] = 3.335641e-013;
	m[-4432] = 3.335641e-013;
	m[4434] = 3.335641e-013;
	m[-4434] = 3.335641e-013;
	m[4444] = 3.335641e-013;
	m[-4444] = 3.335641e-013;
	m[5101] = 0.000000e+000;
	m[-5101] = 0.000000e+000;
	m[5103] = 0.000000e+000;
	m[-5103] = 0.000000e+000;
	m[5114] = 0.000000e+000;
	m[-5114] = 0.000000e+000;
	m[5142] = 1.290893e-012;
	m[-5142] = 1.290893e-012;
	m[5201] = 0.000000e+000;
	m[-5201] = 0.000000e+000;
	m[5203] = 0.000000e+000;
	m[-5203] = 0.000000e+000;
	m[5214] = 0.000000e+000;
	m[-5214] = 0.000000e+000;
	m[5224] = 0.000000e+000;
	m[-5224] = 0.000000e+000;
	m[5242] = 1.290893e-012;
	m[-5242] = 1.290893e-012;
	m[5301] = 0.000000e+000;
	m[-5301] = 0.000000e+000;
	m[5303] = 0.000000e+000;
	m[-5303] = 0.000000e+000;
	m[5314] = 0.000000e+000;
	m[-5314] = 0.000000e+000;
	m[5324] = 0.000000e+000;
	m[-5324] = 0.000000e+000;
	m[5334] = 0.000000e+000;
	m[-5334] = 0.000000e+000;
	m[5342] = 1.290893e-012;
	m[-5342] = 1.290893e-012;
	m[5401] = 0.000000e+000;
	m[-5401] = 0.000000e+000;
	m[5403] = 0.000000e+000;
	m[-5403] = 0.000000e+000;
	m[5412] = 1.290893e-012;
	m[-5412] = 1.290893e-012;
	m[5414] = 1.290893e-012;
	m[-5414] = 1.290893e-012;
	m[5422] = 1.290893e-012;
	m[-5422] = 1.290893e-012;
	m[5424] = 1.290893e-012;
	m[-5424] = 1.290893e-012;
	m[5432] = 1.290893e-012;
	m[-5432] = 1.290893e-012;
	m[5434] = 1.290893e-012;
	m[-5434] = 1.290893e-012;
	m[5442] = 1.290893e-012;
	m[-5442] = 1.290893e-012;
	m[5444] = 1.290893e-012;
	m[-5444] = 1.290893e-012;
	m[5503] = 0.000000e+000;
	m[-5503] = 0.000000e+000;
	m[5512] = 1.290893e-012;
	m[-5512] = 1.290893e-012;
	m[5514] = 1.290893e-012;
	m[-5514] = 1.290893e-012;
	m[5522] = 1.290893e-012;
	m[-5522] = 1.290893e-012;
	m[5524] = 1.290893e-012;
	m[-5524] = 1.290893e-012;
	m[5532] = 1.290893e-012;
	m[-5532] = 1.290893e-012;
	m[5534] = 1.290893e-012;
	m[-5534] = 1.290893e-012;
	m[5542] = 1.290893e-012;
	m[-5542] = 1.290893e-012;
	m[5544] = 1.290893e-012;
	m[-5544] = 1.290893e-012;
	m[5554] = 1.290893e-012;
	m[-5554] = 1.290893e-012;
	m[10022] = 0.000000e+000;
	m[10111] = 2.483820e-024;
	m[10113] = 4.635297e-024;
	m[10115] = 2.541360e-024;
	m[10211] = 2.483820e-024;
	m[-10211] = 2.483820e-024;
	m[10213] = 4.635297e-024;
	m[-10213] = 4.635297e-024;
	m[10215] = 2.541360e-024;
	m[-10215] = 2.541360e-024;
	m[9010221] = 1.316424e-023;
	m[10223] = 1.828367e-024;
	m[10225] = 0.000000e+000;
	m[10315] = 3.538775e-024;
	m[-10315] = 3.538775e-024;
	m[10325] = 3.538775e-024;
	m[-10325] = 3.538775e-024;
	m[10331] = 5.265698e-024;
	m[10333] = 0.000000e+000;
	m[10335] = 0.000000e+000;
	m[10443] = 0.000000e+000;
	m[10541] = 0.000000e+000;
	m[-10541] = 0.000000e+000;
	m[10543] = 0.000000e+000;
	m[-10543] = 0.000000e+000;
	m[10551] = 1.000000e+016;
	m[10553] = 0.000000e+000;
	m[10555] = 0.000000e+000;
	m[11112] = 0.000000e+000;
	m[-11112] = 0.000000e+000;
	m[11114] = 2.194041e-024;
	m[-11114] = 2.194041e-024;
	m[11116] = 1.880606e-024;
	m[-11116] = 1.880606e-024;
	m[11212] = 1.880606e-024;
	m[-11212] = 1.880606e-024;
	m[11216] = 0.000000e+000;
	m[-11216] = 0.000000e+000;
	m[12112] = 1.880606e-024;
	m[-12112] = 1.880606e-024;
	m[12114] = 2.194041e-024;
	m[-12114] = 2.194041e-024;
	m[12116] = 5.063171e-024;
	m[-12116] = 5.063171e-024;
	m[12118] = 0.000000e+000;
	m[-12118] = 0.000000e+000;
	m[12122] = 0.000000e+000;
	m[-12122] = 0.000000e+000;
	m[12126] = 1.880606e-024;
	m[-12126] = 1.880606e-024;
	m[12212] = 1.880606e-024;
	m[-12212] = 1.880606e-024;
	m[12214] = 2.194041e-024;
	m[-12214] = 2.194041e-024;
	m[12216] = 5.063171e-024;
	m[-12216] = 5.063171e-024;
	m[12218] = 0.000000e+000;
	m[-12218] = 0.000000e+000;
	m[12222] = 0.000000e+000;
	m[-12222] = 0.000000e+000;
	m[12224] = 2.194041e-024;
	m[-12224] = 2.194041e-024;
	m[12226] = 1.880606e-024;
	m[-12226] = 1.880606e-024;
	m[13112] = 6.582122e-024;
	m[-13112] = 6.582122e-024;
	m[13114] = 1.097020e-023;
	m[-13114] = 1.097020e-023;
	m[13116] = 5.485102e-024;
	m[-13116] = 5.485102e-024;
	m[13122] = 1.316424e-023;
	m[-13122] = 1.316424e-023;
	m[13124] = 1.097020e-023;
	m[-13124] = 1.097020e-023;
	m[13126] = 6.928549e-024;
	m[-13126] = 6.928549e-024;
	m[13212] = 6.582122e-024;
	m[-13212] = 6.582122e-024;
	m[13214] = 1.097020e-023;
	m[-13214] = 1.097020e-023;
	m[13216] = 5.485102e-024;
	m[-13216] = 5.485102e-024;
	m[13222] = 6.582122e-024;
	m[-13222] = 6.582122e-024;
	m[13224] = 1.097020e-023;
	m[-13224] = 1.097020e-023;
	m[13226] = 5.485102e-024;
	m[-13226] = 5.485102e-024;
	m[13314] = 2.742551e-023;
	m[-13314] = 2.742551e-023;
	m[13316] = 0.000000e+000;
	m[-13316] = 0.000000e+000;
	m[13324] = 2.742551e-023;
	m[-13324] = 2.742551e-023;
	m[13326] = 0.000000e+000;
	m[-13326] = 0.000000e+000;
	m[14122] = 1.828367e-022;
	m[-14122] = 1.828367e-022;
	m[14124] = 0.000000e+000;
	m[-14124] = 0.000000e+000;
	m[10221] = 2.194040e-024;
	m[20223] = 2.742551e-023;
	m[20315] = 2.384827e-024;
	m[-20315] = 2.384827e-024;
	m[20325] = 2.384827e-024;
	m[-20325] = 2.384827e-024;
	m[20333] = 1.185968e-023;
	m[20543] = 0.000000e+000;
	m[-20543] = 0.000000e+000;
	m[20553] = 1.000000e+016;
	m[20555] = 0.000000e+000;
	m[21112] = 2.632849e-024;
	m[-21112] = 2.632849e-024;
	m[21114] = 3.291061e-024;
	m[-21114] = 3.291061e-024;
	m[21212] = 2.632849e-024;
	m[-21212] = 2.632849e-024;
	m[21214] = 6.582122e-024;
	m[-21214] = 6.582122e-024;
	m[22112] = 4.388081e-024;
	m[-22112] = 4.388081e-024;
	m[22114] = 3.291061e-024;
	m[-22114] = 3.291061e-024;
	m[22122] = 2.632849e-024;
	m[-22122] = 2.632849e-024;
	m[22124] = 6.582122e-024;
	m[-22124] = 6.582122e-024;
	m[22212] = 4.388081e-024;
	m[-22212] = 4.388081e-024;
	m[22214] = 3.291061e-024;
	m[-22214] = 3.291061e-024;
	m[22222] = 2.632849e-024;
	m[-22222] = 2.632849e-024;
	m[22224] = 3.291061e-024;
	m[-22224] = 3.291061e-024;
	m[23112] = 7.313469e-024;
	m[-23112] = 7.313469e-024;
	m[23114] = 2.991874e-024;
	m[-23114] = 2.991874e-024;
	m[23122] = 4.388081e-024;
	m[-23122] = 4.388081e-024;
	m[23124] = 6.582122e-024;
	m[-23124] = 6.582122e-024;
	m[23126] = 3.291061e-024;
	m[-23126] = 3.291061e-024;
	m[23212] = 7.313469e-024;
	m[-23212] = 7.313469e-024;
	m[23214] = 2.991874e-024;
	m[-23214] = 2.991874e-024;
	m[23222] = 7.313469e-024;
	m[-23222] = 7.313469e-024;
	m[23224] = 2.991874e-024;
	m[-23224] = 2.991874e-024;
	m[23314] = 0.000000e+000;
	m[-23314] = 0.000000e+000;
	m[23324] = 0.000000e+000;
	m[-23324] = 0.000000e+000;
	m[30113] = 2.742551e-024;
	m[30213] = 2.742551e-024;
	m[-30213] = 2.742551e-024;
	m[30223] = 2.991874e-024;
	m[30313] = 2.056913e-024;
	m[-30313] = 2.056913e-024;
	m[30323] = 2.056913e-024;
	m[-30323] = 2.056913e-024;
	m[30343] = 0.000000e+000;
	m[-30343] = 0.000000e+000;
	m[30353] = 0.000000e+000;
	m[-30353] = 0.000000e+000;
	m[30363] = 0.000000e+000;
	m[-30363] = 0.000000e+000;
	m[30411] = 0.000000e+000;
	m[-30411] = 0.000000e+000;
	m[30413] = 0.000000e+000;
	m[-30413] = 0.000000e+000;
	m[30421] = 0.000000e+000;
	m[-30421] = 0.000000e+000;
	m[30423] = 0.000000e+000;
	m[-30423] = 0.000000e+000;
	m[30443] = 2.789035e-023;
	m[30553] = 0.000000e+000;
	m[31114] = 1.880606e-024;
	m[-31114] = 1.880606e-024;
	m[31214] = 4.388081e-024;
	m[-31214] = 4.388081e-024;
	m[32112] = 4.388081e-024;
	m[-32112] = 4.388081e-024;
	m[32114] = 1.880606e-024;
	m[-32114] = 1.880606e-024;
	m[32124] = 4.388081e-024;
	m[-32124] = 4.388081e-024;
	m[32212] = 4.388081e-024;
	m[-32212] = 4.388081e-024;
	m[32214] = 1.880606e-024;
	m[-32214] = 1.880606e-024;
	m[32224] = 1.880606e-024;
	m[-32224] = 1.880606e-024;
	m[33122] = 1.880606e-023;
	m[-33122] = 1.880606e-023;
	m[33314] = 0.000000e+000;
	m[-33314] = 0.000000e+000;
	m[33324] = 0.000000e+000;
	m[-33324] = 0.000000e+000;
	m[41214] = 0.000000e+000;
	m[-41214] = 0.000000e+000;
	m[42112] = 6.582122e-024;
	m[-42112] = 6.582122e-024;
	m[42124] = 0.000000e+000;
	m[-42124] = 0.000000e+000;
	m[42212] = 6.582122e-024;
	m[-42212] = 6.582122e-024;
	m[43122] = 2.194041e-024;
	m[-43122] = 2.194041e-024;
	m[52114] = 0.000000e+000;
	m[-52114] = 0.000000e+000;
	m[52214] = 0.000000e+000;
	m[-52214] = 0.000000e+000;
	m[53122] = 4.388081e-024;
	m[-53122] = 4.388081e-024;
	m[100111] = 1.645531e-024;
	m[100113] = 2.123265e-024;
	m[100211] = 1.645531e-024;
	m[-100211] = 1.645531e-024;
	m[100213] = 2.123265e-024;
	m[-100213] = 2.123265e-024;
	m[100221] = 1.196749e-023;
	m[100223] = 3.871836e-024;
	m[100225] = 0.000000e+000;
	m[100311] = 0.000000e+000;
	m[-100311] = 0.000000e+000;
	m[100313] = 2.837122e-024;
	m[-100313] = 2.837122e-024;
	m[100315] = 0.000000e+000;
	m[-100315] = 0.000000e+000;
	m[100321] = 0.000000e+000;
	m[-100321] = 0.000000e+000;
	m[100323] = 2.837122e-024;
	m[-100323] = 2.837122e-024;
	m[100325] = 0.000000e+000;
	m[-100325] = 0.000000e+000;
	m[100331] = 0.000000e+000;
	m[100333] = 4.388081e-024;
	m[100335] = 3.291061e-024;
	m[100441] = 0.000000e+000;
	m[100551] = 0.000000e+000;
	m[100553] = 1.495937e-020;
	m[100555] = 1.000000e+016;
	m[100557] = 0.000000e+000;
	m[110551] = 1.000000e+016;
	m[110553] = 0.000000e+000;
	m[110555] = 0.000000e+000;
	m[120553] = 1.000000e+016;
	m[120555] = 0.000000e+000;
	m[130553] = 0.000000e+000;
	m[200111] = 3.134344e-024;
	m[200211] = 3.134344e-024;
	m[-200211] = 3.134344e-024;
	m[200551] = 0.000000e+000;
	m[200553] = 2.502708e-020;
	m[200555] = 0.000000e+000;
	m[210551] = 0.000000e+000;
	m[210553] = 0.000000e+000;
	m[220553] = 0.000000e+000;
	m[300553] = 4.701516e-023;
	m[9000221] = 0.000000e+000;
	m[9000443] = 1.265793e-023;
	m[9000553] = 5.983747e-024;
	m[9010443] = 8.438618e-024;
	m[9010553] = 8.331800e-024;
	m[9020221] = 6.038644e-024;
	m[9020443] = 1.530726e-023;
	m[9060225] = 4.388081e-024;
	m[9070225] = 2.056913e-024;
	m[1000001] = 0.000000e+000;
	m[-1000001] = 0.000000e+000;
	m[1000002] = 0.000000e+000;
	m[-1000002] = 0.000000e+000;
	m[1000003] = 0.000000e+000;
	m[-1000003] = 0.000000e+000;
	m[1000004] = 0.000000e+000;
	m[-1000004] = 0.000000e+000;
	m[1000005] = 0.000000e+000;
	m[-1000005] = 0.000000e+000;
	m[1000006] = 0.000000e+000;
	m[-1000006] = 0.000000e+000;
	m[1000011] = 0.000000e+000;
	m[-1000011] = 0.000000e+000;
	m[1000012] = 0.000000e+000;
	m[-1000012] = 0.000000e+000;
	m[1000013] = 0.000000e+000;
	m[-1000013] = 0.000000e+000;
	m[1000014] = 0.000000e+000;
	m[-1000014] = 0.000000e+000;
	m[1000015] = 0.000000e+000;
	m[-1000015] = 0.000000e+000;
	m[1000016] = 0.000000e+000;
	m[-1000016] = 0.000000e+000;
	m[1000021] = 0.000000e+000;
	m[1000022] = 0.000000e+000;
	m[1000023] = 0.000000e+000;
	m[1000024] = 0.000000e+000;
	m[-1000024] = 0.000000e+000;
	m[1000025] = 0.000000e+000;
	m[1000035] = 0.000000e+000;
	m[1000037] = 0.000000e+000;
	m[-1000037] = 0.000000e+000;
	m[1000039] = 0.000000e+000;
	m[2000001] = 0.000000e+000;
	m[-2000001] = 0.000000e+000;
	m[2000002] = 0.000000e+000;
	m[-2000002] = 0.000000e+000;
	m[2000003] = 0.000000e+000;
	m[-2000003] = 0.000000e+000;
	m[2000004] = 0.000000e+000;
	m[-2000004] = 0.000000e+000;
	m[2000005] = 0.000000e+000;
	m[-2000005] = 0.000000e+000;
	m[2000006] = 0.000000e+000;
	m[-2000006] = 0.000000e+000;
	m[2000011] = 0.000000e+000;
	m[-2000011] = 0.000000e+000;
	m[2000012] = 0.000000e+000;
	m[-2000012] = 0.000000e+000;
	m[2000013] = 0.000000e+000;
	m[-2000013] = 0.000000e+000;
	m[2000014] = 0.000000e+000;
	m[-2000014] = 0.000000e+000;
	m[2000015] = 0.000000e+000;
	m[-2000015] = 0.000000e+000;
	m[2000016] = 0.000000e+000;
	m[-2000016] = 0.000000e+000;
	m[3000111] = 0.000000e+000;
	m[3000113] = 0.000000e+000;
	m[3000211] = 0.000000e+000;
	m[-3000211] = 0.000000e+000;
	m[3000213] = 0.000000e+000;
	m[-3000213] = 0.000000e+000;
	m[3000221] = 0.000000e+000;
	m[3000223] = 0.000000e+000;
	m[3000331] = 0.000000e+000;
	m[3100021] = 0.000000e+000;
	m[3100111] = 0.000000e+000;
	m[3100113] = 0.000000e+000;
	m[3200111] = 0.000000e+000;
	m[3200113] = 0.000000e+000;
	m[3300113] = 0.000000e+000;
	m[3400113] = 0.000000e+000;
	m[4000001] = 0.000000e+000;
	m[-4000001] = 0.000000e+000;
	m[4000002] = 0.000000e+000;
	m[-4000002] = 0.000000e+000;
	m[4000011] = 0.000000e+000;
	m[-4000011] = 0.000000e+000;
	m[4000012] = 0.000000e+000;
	m[-4000012] = 0.000000e+000;
	m[5000039] = 0.000000e+000;
	m[9900012] = 0.000000e+000;
	m[9900014] = 0.000000e+000;
	m[9900016] = 0.000000e+000;
	m[9900023] = 0.000000e+000;
	m[9900024] = 0.000000e+000;
	m[-9900024] = 0.000000e+000;
	m[9900041] = 0.000000e+000;
	m[-9900041] = 0.000000e+000;
	m[9900042] = 0.000000e+000;
	m[-9900042] = 0.000000e+000;
	m[1027013000] = 0.000000e+000;
	m[1012006000] = 0.000000e+000;
	m[1063029000] = 0.000000e+000;
	m[1014007000] = 0.000000e+000;
	m[1016008000] = 0.000000e+000;
	m[1028014000] = 0.000000e+000;
	m[1065029000] = 0.000000e+000;
	m[1009004000] = 0.000000e+000;
	m[1019009000] = 0.000000e+000;
	m[1056026000] = 0.000000e+000;
	m[1207082000] = 0.000000e+000;
	m[1208082000] = 0.000000e+000;
	m[1029014000] = 0.000000e+000;
	m[1206082000] = 0.000000e+000;
	m[1054026000] = 0.000000e+000;
	m[1018008000] = 0.000000e+000;
	m[1030014000] = 0.000000e+000;
	m[1057026000] = 0.000000e+000;
	m[1204082000] = 0.000000e+000;
	m[-99000000] = 0.000000e+000;
	m[1028013000] = 0.000000e+000;
	m[1040018000] = 0.000000e+000;
	m[1011005000] = 0.000000e+000;
	m[1012005000] = 0.000000e+000;
	m[1013006000] = 0.000000e+000;
	m[1014006000] = 0.000000e+000;
	m[1052024000] = 0.000000e+000;
	m[1024012000] = 0.000000e+000;
	m[1026012000] = 0.000000e+000;
	m[1027012000] = 0.000000e+000;
	m[1015007000] = 0.000000e+000;
	m[1022010000] = 0.000000e+000;
	m[1058028000] = 0.000000e+000;
	m[1060028000] = 0.000000e+000;
	m[1062028000] = 0.000000e+000;
	m[1064028000] = 0.000000e+000;
	m[1007003000] = 0.000000e+000;
	m[1025012000] = 0.000000e+000;
	m[1053024000] = 0.000000e+000;
	m[1055025000] = 0.000000e+000;
	m[1008004000] = 0.000000e+000;
	m[1010004000] = 0.000000e+000;
	m[1010005000] = 0.000000e+000;
	m[1016007000] = 0.000000e+000;
	m[1017008000] = 0.000000e+000;
	m[1019008000] = 0.000000e+000;
	m[1023010000] = 0.000000e+000;
	m[1024011000] = 0.000000e+000;
	m[1031015000] = 0.000000e+000;
	m[1039017000] = 0.000000e+000;
	m[1040017000] = 0.000000e+000;
	m[1036018000] = 0.000000e+000;
	m[1050024000] = 0.000000e+000;
	m[1054024000] = 0.000000e+000;
	m[1059026000] = 0.000000e+000;
	m[1061028000] = 0.000000e+000;
	m[1063028000] = 0.000000e+000;
	m[1092042000] = 0.000000e+000;
	m[1095042000] = 0.000000e+000;
	m[1096042000] = 0.000000e+000;
	m[1097042000] = 0.000000e+000;
	m[1098042000] = 0.000000e+000;
	m[1100042000] = 0.000000e+000;
	m[1108046000] = 0.000000e+000;

	// Added by hand:
	m[9902210] = 0.000000e+000; //diffractive p-state -> assume no lifetime
	return true;
	}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_mult_total; // full kinematic range
	Histo1DPtr _h_mult_eta[5]; // in eta bins
	Histo1DPtr _h_mult_pt[5]; // in pT bins
	Histo1DPtr _h_dndeta; // density dn/deta
	Histo1DPtr _h_dndpt; // density dn/dpT
	//@}


	/// @name Private variables
	double _p_min;
	double _pt_min;
	double _eta_min;
	double _eta_max;
	double _maxlft;

	/// Count selected events
	double _sumW;

	map<int, double> _partLftMap; // Map <PDGID, PDGLIFETIME>

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(LHCB_2014_I1281685);

	}
	diff --git a/src/Analyses/LHCB_2015_I1333223.cc b/src/Analyses/LHCB_2015_I1333223.cc
	--- a/src/Analyses/LHCB_2015_I1333223.cc
	+++ b/src/Analyses/LHCB_2015_I1333223.cc
	@@ -1,113 +1,113 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Math/Units.hh"
	#include <vector>

	using namespace std;

	namespace Rivet {


	class LHCB_2015_I1333223 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	LHCB_2015_I1333223()
	: Analysis("LHCB_2015_I1333223")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	// Charged particles
	- addProjection(ChargedFinalState(Cuts::eta> 2.0 && Cuts::eta <4.5 && Cuts::pT >0.2*GeV), "CFS");
	+ declare(ChargedFinalState(Cuts::eta> 2.0 && Cuts::eta <4.5 && Cuts::pT >0.2*GeV), "CFS");
	// Reproducing only measurement for prompt charged particles
	_hInelasticXs = bookHisto1D(1, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ChargedFinalState &cfs = applyProjection<ChargedFinalState> (event, "CFS");
	+ const ChargedFinalState &cfs = apply<ChargedFinalState> (event, "CFS");

	// eliminate non-inelastic events and empty events in LHCb
	if (cfs.particles().size() == 0) vetoEvent;

	// See if this event has at least one prompt particle
	foreach (const Particle &myp, cfs.particles()){
	double dPV = getPVDCA(myp);
	// if IP > 200 microns the particle is not considered prompt
	if ((dPV < 0.) \|\| (dPV > 0.2 * millimeter)) {
	MSG_DEBUG(" Vetoing " << myp.pdgId() << " at " << dPV);
	continue;
	}
	// histo gets filled only for inelastic events (at least one prompt charged particle)
	_hInelasticXs->fill(sqrtS(), weight);
	break;
	} //end loop on particles

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_hInelasticXs, crossSection()/sumOfWeights()/millibarn);
	}

	//@}


	private:

	/*
	* Compute Distance of Closest Approach in z range for one particle.
	* Assuming length unit is mm.
	* Returns -1. if unable to compute the DCA to PV.
	*/
	double getPVDCA(const Particle& p) {
	const HepMC::GenVertex* vtx = p.genParticle()->production_vertex();
	if ( 0 == vtx ) return -1.;

	// Unit vector of particle's MOMENTUM three vector
	const Vector3 u = p.momentum().p3().unit();

	// The interaction point is always at (0, 0,0,0) hence the
	// vector pointing from the PV to the particle production vertex is:
	Vector3 d(vtx->position().x(), vtx->position().y(), vtx->position().z());

	// Subtract projection of d onto u from d
	double proj = d.dot(u);
	d -= (u * proj);

	// d should be orthogonal to u and it's length give the distance of
	// closest approach
	return d.mod();
	}


	/// @name Histograms
	//@{
	Histo1DPtr _hInelasticXs;
	//@}
	//
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(LHCB_2015_I1333223);

	}
	diff --git a/src/Analyses/LHCF_2012_I1115479.cc b/src/Analyses/LHCF_2012_I1115479.cc
	--- a/src/Analyses/LHCF_2012_I1115479.cc
	+++ b/src/Analyses/LHCF_2012_I1115479.cc
	@@ -1,65 +1,65 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Tools/BinnedHistogram.hh"

	namespace Rivet {


	class LHCF_2012_I1115479 : public Analysis {
	public:

	LHCF_2012_I1115479()
	: Analysis("LHCF_2012_I1115479")
	{ }


	public:

	void init() {
	- addProjection(UnstableFinalState(),"UFS");
	+ declare(UnstableFinalState(),"UFS");

	_binnedHistos_y_pT.addHistogram( 8.9, 9.0, bookHisto1D(1, 1, 1));
	_binnedHistos_y_pT.addHistogram( 9.0, 9.2, bookHisto1D(2, 1, 1));
	_binnedHistos_y_pT.addHistogram( 9.2, 9.4, bookHisto1D(3, 1, 1));
	_binnedHistos_y_pT.addHistogram( 9.4, 9.6, bookHisto1D(4, 1, 1));
	_binnedHistos_y_pT.addHistogram( 9.6, 10.0, bookHisto1D(5, 1, 1));
	_binnedHistos_y_pT.addHistogram(10.0, 11.0, bookHisto1D(6, 1, 1));
	}


	void analyze(const Event& event) {
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");

	const double weight = event.weight();
	const double dphi = TWOPI;

	foreach (const Particle& p, ufs.particles()) {
	if (p.pid() == 111) {
	double pT = p.pT();
	double y = p.rapidity();

	if (pT > 0.6*GeV) continue;

	const double scaled_weight = weight/(dphi*pT/GeV);
	_binnedHistos_y_pT.fill(y, pT/GeV, scaled_weight);
	}
	}
	}


	void finalize() {
	_binnedHistos_y_pT.scale( 1./sumOfWeights() , this);
	}

	private:

	BinnedHistogram<double> _binnedHistos_y_pT;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(LHCF_2012_I1115479);

	}
	diff --git a/src/Analyses/MC_CENTRALITY.cc b/src/Analyses/MC_CENTRALITY.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/MC_CENTRALITY.cc
	@@ -0,0 +1,192 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+#include "Rivet/Tools/CentralityHistogram.hh"
	+
	+namespace Rivet {
	+
	+/// Example of CentralityEstimator projection that uses summed Et in
	+/// the forward region.
	+class SumETFwdCentrality: public CentralityEstimator {
	+
	+public:
	+
	+ /// Constructor.
	+ SumETFwdCentrality() {
	+ declare(FinalState(3.2, 4.9, 100*MeV), "FSSumETFwdCentrality");
	+ }
	+
	+protected:
	+
	+ /// Perform the projection on the Event
	+ void project(const Event& e) {
	+ const FinalState & fsfwd =
	+ apply<FinalState>(e, "FSSumETFwdCentrality");
	+ _estimate = 0.0;
	+ for ( const Particle & p : fsfwd.particles() ) {
	+ _estimate += p.Et();
	+ }
	+ }
	+};
	+
	+
	+ /// Generic analysis looking at various distributions of final state particles
	+ class MC_CENTRALITY : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ MC_CENTRALITY() : Analysis("MC_CENTRALITY") {}
	+
	+
	+ public:
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Projections
	+ declare(ChargedFinalState(-2.5, 2.5, 500*MeV), "CFScent");
	+ declare(FinalState(3.2, 4.9, 100*MeV), "FSfwd");
	+
	+
	+ // Histograms
	+ // The sum Et in the forward region.
	+ _histETfwd = bookHisto1D("ETfwd", 100, 0.0, 500.0);
	+
	+ // The overall charged multiplicity distribution as a function
	+ // of eta.
	+ _histEtaAll = bookHisto1D("EtaAll", 50, -2.5, 2.5);
	+
	+ // Multiplicity distribution for different centrality intervals.
	+ // The notation is that the maximum centrality is 100% and the
	+ // lowest is 0%. THe _cent object will dynamically decide how to
	+ // cluster fills to the histogram together.
	+ _cent.add(_histEtaC95 = bookHisto1D("EtaC95", 50, -2.5, 2.5),
	+ 95.0, 100.0);
	+ _cent.add(_histEtaC90 = bookHisto1D("EtaC90", 50, -2.5, 2.5),
	+ 90.0, 95.0);
	+ _cent.add(_histEtaC80 = bookHisto1D("EtaC80", 50, -2.5, 2.5),
	+ 80.0, 90.0);
	+ _cent.add(_histEtaC60 = bookHisto1D("EtaC60", 50, -2.5, 2.5),
	+ 60.0, 80.0);
	+ _cent.add(_histEtaC00 = bookHisto1D("EtaC00", 50, -2.5, 2.5),
	+ 0.0, 60.0);
	+
	+ // Try also the facility of using a CentralityEstimator
	+ // projection.
	+ declare(SumETFwdCentrality(), "SumETFwdCentrality");
	+ _cent2.setProjection("SumETFwdCentrality");
	+ _cent2.add(_histEta2C95 = bookHisto1D("Eta2C95", 50, -2.5, 2.5),
	+ 95.0, 100.0);
	+ _cent2.add(_histEta2C90 = bookHisto1D("Eta2C90", 50, -2.5, 2.5),
	+ 90.0, 95.0);
	+ _cent2.add(_histEta2C80 = bookHisto1D("Eta2C80", 50, -2.5, 2.5),
	+ 80.0, 90.0);
	+ _cent2.add(_histEta2C60 = bookHisto1D("Eta2C60", 50, -2.5, 2.5),
	+ 60.0, 80.0);
	+ _cent2.add(_histEta2C00 = bookHisto1D("Eta2C00", 50, -2.5, 2.5),
	+ 0.0, 60.0);
	+
	+ /// Finally also try the case where we know the centrality bin
	+ /// edges beforehand.
	+ _cent3.setProjection("SumETFwdCentrality");
	+ _cent3.add(_histEta3C95 = bookHisto1D("Eta3C95", 50, -2.5, 2.5),
	+ 95.0, 100.0, 22.55, 1.0e20);
	+ _cent3.add(_histEta3C90 = bookHisto1D("Eta3C90", 50, -2.5, 2.5),
	+ 90.0, 95.0, 16.11, 22.55);
	+ _cent3.add(_histEta3C80 = bookHisto1D("Eta3C80", 50, -2.5, 2.5),
	+ 80.0, 90.0, 9.611, 16.11);
	+ _cent3.add(_histEta3C60 = bookHisto1D("Eta3C60", 50, -2.5, 2.5),
	+ 60.0, 80.0, 3.921, 9.611);
	+ _cent3.add(_histEta3C00 = bookHisto1D("Eta3C00", 50, -2.5, 2.5),
	+ 0.0, 60.0, 0.0, 3.921);
	+
	+
	+
	+ }
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+ const double weight = event.weight();
	+
	+ // First calculate the centrality estimator. In this case the
	+ // sumed transverse enegry in a forward region of the event, and
	+ // initialize the centrality bin.
	+ const FinalState & fsfwd = apply<FinalState>(event, "FSfwd");
	+ double sumet = 0.0;
	+ for ( const Particle & p : fsfwd.particles() ) {
	+ sumet += p.Et();
	+ }
	+ _cent.setup(event, sumet);
	+ _histETfwd->fill(sumet, weight);
	+
	+ // Also setup the other centrality binner.
	+ _cent2.setup(event);
	+
	+ // Then fill the selected centrality histogram.
	+ const ChargedFinalState & cfscent =
	+ apply<ChargedFinalState>(event, "CFScent");
	+ for ( const Particle & p : cfscent.particles() ) {
	+ _cent.fill(p.eta(), weight);
	+ _cent2.fill(p.eta(), weight);
	+ _cent3.fill(p.eta(), weight);
	+ }
	+ }
	+
	+
	+ /// Finalize
	+ void finalize() {
	+ normalize(_histETfwd, 1.0/sumOfWeights());
	+ _cent.finalize();
	+ _cent2.finalize();
	+ _cent3.finalize(); // This should be a noop.
	+ _cent.normalizePerEvent();
	+ _cent2.normalizePerEvent();
	+ _cent3.normalizePerEvent();
	+ _histEtaAll->normalize(1.0/sumOfWeights());
	+
	+ map<double,double> edges1 = _cent.edges();
	+ map<double,double> edges2 = _cent2.edges();
	+ map<double,double> edges3 = _cent3.edges();
	+ MSG_INFO("Cross check of centalty edges:"
	+ << setw(10) << "%" << setw(10) << "1"
	+ << setw(10) << "2" << setw(10) << "3");
	+ for ( auto e : edges3 ) {
	+ MSG_INFO(""
	+ << setw(10) << e.first << setw(10) << e.second << setw(10)
	+ << edges1[e.first] << setw(10) << edges2[e.first]);
	+ }
	+
	+
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ //@{
	+ Histo1DPtr _histETfwd;
	+ Histo1DPtr _histEtaAll;
	+ Histo1DPtr _histEtaC95, _histEtaC90, _histEtaC80, _histEtaC60, _histEtaC00;
	+ CentralityHistogram _cent;
	+ Histo1DPtr _histEta2C95, _histEta2C90, _histEta2C80,
	+ _histEta2C60, _histEta2C00;
	+ CentralityHistogram _cent2;
	+ Histo1DPtr _histEta3C95, _histEta3C90, _histEta3C80,
	+ _histEta3C60, _histEta3C00;
	+ CentralityHistogram _cent3;
	+ //@}
	+
	+
	+ };
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(MC_CENTRALITY);
	+
	+}
	diff --git a/src/Analyses/MC_DIJET.cc b/src/Analyses/MC_DIJET.cc
	deleted file mode 100644
	--- a/src/Analyses/MC_DIJET.cc
	+++ /dev/null
	@@ -1,121 +0,0 @@
	-// -- C++ --
	-#include "Rivet/Analysis.hh"
	-#include "Rivet/Projections/FinalState.hh"
	-#include "Rivet/Projections/ChargedFinalState.hh"
	-#include "Rivet/Projections/FastJets.hh"
	-
	-namespace Rivet {
	-
	-
	-
	-
	- /// @brief MC validation analysis for di-jet events
	- class MC_DIJET : public Analysis {
	- public:
	-
	- /// Default constructor
	- MC_DIJET() : Analysis("MC_DIJET")
	- { }
	-
	-
	- /// @name Analysis methods
	- //@{
	-
	- void init() {
	- FinalState fs(-4, 4, 0.5*GeV);
	- ChargedFinalState cfs(fs);
	- addProjection(fs, "FS");
	- addProjection(cfs, "CFS");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.7), "Jets");
	- addProjection(FastJets(cfs, FastJets::ANTIKT, 0.7), "ChargedJets");
	-
	- _hist_jetcount = bookHisto1D("d01-x01-y01", 5, 0., 10.);
	- _hist_jetpt = bookHisto1D("d02-x01-y01", 30, 30.,100.);
	- _hist_jetptlog = bookHisto1D("d03-x01-y01", 20, 0.,8.);
	- _hist_leadingjetpt = bookHisto1D("d04-x01-y01", 25, 30.,100.);
	- _hist_secondleadingjetpt = bookHisto1D("d05-x01-y01", 25, 30.,100.);
	- _hist_jetphi = bookHisto1D("d06-x01-y01",24, 0., 6.4);
	- _hist_jeteta = bookHisto1D("d07-x01-y01", 30, -6., 6.);
	- _hist_jetdphi = bookHisto1D("d08-x01-y01", 24, 0., 6.4);
	- _hist_jetdeta = bookHisto1D("d09-x01-y01", 24, 0., 6.);
	- _hist_chargemultiplicity = bookHisto1D("d10-x01-y01",30, 0.5, 250.5);
	- _hist_chargemeanpt = bookHisto1D("d11-x01-y01", 25, 0., 10.);
	- _hist_chargept = bookHisto1D("d12-x01-y01", 32, 0., 25.);
	- _hist_chargelogpt = bookHisto1D("d13-x01-y01", 32, 0., 6.);
	- _hist_chargermspt = bookHisto1D("d14-x01-y01", 32, 0., 10.);
	- }
	-
	-
	- void analyze(const Event& event) {
	- const FastJets& fastjets = applyProjection<FastJets>(event, "Jets");
	- const Jets jets = fastjets.jetsByPt(20.*GeV);
	- const double weight = event.weight();
	-
	- if (jets.size() < 2 \|\| jets.size() >= 3) vetoEvent;
	- const double angle = fabs(jets[1].phi() - jets[0].phi());
	- const double prapidity = fabs(jets[1].eta() - jets[0].eta());
	- _hist_jetcount->fill(jets.size(), weight);
	- _hist_leadingjetpt->fill(jets[0].pT(), weight);
	- _hist_secondleadingjetpt->fill(jets[1].pT(), weight);
	- _hist_jetdphi->fill(angle , weight);
	- _hist_jetdeta->fill(prapidity, weight);
	-
	- foreach(Jet j, fastjets.jetsByPt(20.*GeV)) {
	- _hist_jetpt->fill(j.pT(), weight);
	- _hist_jetptlog->fill(log(j.pT()), weight);
	- _hist_jetphi->fill(j.phi(), weight);
	- _hist_jeteta->fill(j.eta(), weight);
	- }
	-
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	- // const FastJets& cfastjets = applyProjection<FastJets>(event, "ChargedJets");
	- double meanpt(0), rmspt(0);
	- /// @todo Add jets
	- // foreach(Jet cj, cfastjets.jetsByPt(20.*GeV)){
	- _hist_chargemultiplicity->fill(cfs.particles().size(), weight);
	- foreach(Particle cp, cfs.particles()) {
	- meanpt= meanpt + cp.pT();
	- rmspt = rmspt + (cp.pT()*cp.pT());
	- _hist_chargept->fill(cp.pT(), weight);
	- _hist_chargelogpt->fill(log(cp.pT()), weight);
	- }
	- meanpt = meanpt / cfs.particles().size();
	- _hist_chargemeanpt->fill(meanpt, weight);
	- rmspt = sqrt(rmspt / cfs.particles().size());
	- _hist_chargermspt->fill(rmspt, weight);
	- // }
	- }
	-
	-
	- void finalize() {
	- /// @todo Normalise!
	- }
	-
	- //@}
	-
	-
	- private:
	-
	- Histo1DPtr _hist_jetcount;
	- Histo1DPtr _hist_jetpt;
	- Histo1DPtr _hist_jetptlog;
	- Histo1DPtr _hist_leadingjetpt;
	- Histo1DPtr _hist_secondleadingjetpt;
	- Histo1DPtr _hist_jetphi;
	- Histo1DPtr _hist_jetdphi;
	- Histo1DPtr _hist_jeteta;
	- Histo1DPtr _hist_jetdeta;
	- Histo1DPtr _hist_chargemultiplicity;
	- Histo1DPtr _hist_chargemeanpt;
	- Histo1DPtr _hist_chargept;
	- Histo1DPtr _hist_chargelogpt;
	- Histo1DPtr _hist_chargermspt;
	-
	- };
	-
	-
	-
	- // The hook for the plugin system
	- DECLARE_RIVET_PLUGIN(MC_DIJET);
	-
	-}
	diff --git a/src/Analyses/MC_DIPHOTON.cc b/src/Analyses/MC_DIPHOTON.cc
	--- a/src/Analyses/MC_DIPHOTON.cc
	+++ b/src/Analyses/MC_DIPHOTON.cc
	@@ -1,110 +1,110 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {




	/// @brief MC validation analysis for isolated di-photon events
	class MC_DIPHOTON : public Analysis {
	public:

	/// Constructor
	MC_DIPHOTON()
	: Analysis("MC_DIPHOTON")
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	IdentifiedFinalState ifs(Cuts::abseta < 2 && Cuts::pT > 20*GeV);
	ifs.acceptId(PID::PHOTON);
	- addProjection(ifs, "IFS");
	+ declare(ifs, "IFS");

	_h_m_PP = bookHisto1D("m_PP", logspace(50, 1.0, 0.25*(sqrtS()>0.?sqrtS():14000.)));
	_h_pT_PP = bookHisto1D("pT_PP", logspace(50, 1.0, 0.25*(sqrtS()>0.?sqrtS():14000.)));
	_h_pT_P1 = bookHisto1D("pT_P1", 50, 0.0, 70.0);
	_h_pT_P2 = bookHisto1D("pT_P2", 50, 0.0, 70.0);
	_h_dphi_PP = bookHisto1D("dphi_PP", 20, 0.0, M_PI);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- Particles photons = applyProjection<IdentifiedFinalState>(event, "IFS").particles();
	+ Particles photons = apply<IdentifiedFinalState>(event, "IFS").particles();

	if (photons.size() < 2) {
	vetoEvent;
	}

	// Isolate photons with ET_sum in cone
	Particles isolated_photons;
	- Particles fs = applyProjection<FinalState>(event, "FS").particlesByPt();
	+ Particles fs = apply<FinalState>(event, "FS").particlesByPt();
	foreach (const Particle& photon, photons) {
	FourMomentum mom_in_cone;
	double eta_P = photon.eta();
	double phi_P = photon.phi();
	foreach (const Particle& p, fs) {
	if (deltaR(eta_P, phi_P, p.eta(), p.phi()) < 0.4) {
	mom_in_cone += p.momentum();
	}
	}
	if (mom_in_cone.Et()-photon.Et() < 4.0*GeV) {
	isolated_photons.push_back(photon);
	}
	}

	if (isolated_photons.size() != 2) {
	vetoEvent;
	}

	_h_pT_P1->fill(isolated_photons[0].pT(), weight);
	_h_pT_P2->fill(isolated_photons[1].pT(), weight);
	FourMomentum mom_PP = isolated_photons[0].momentum() + isolated_photons[1].momentum();
	_h_m_PP->fill(mom_PP.mass(), weight);
	_h_pT_PP->fill(mom_PP.pT(), weight);
	_h_dphi_PP->fill(deltaPhi(isolated_photons[0].phi(),
	isolated_photons[1].phi()), weight);
	}


	void finalize() {
	scale(_h_m_PP, crossSection()/sumOfWeights());
	scale(_h_pT_PP, crossSection()/sumOfWeights());
	scale(_h_pT_P1, crossSection()/sumOfWeights());
	scale(_h_pT_P2, crossSection()/sumOfWeights());
	scale(_h_dphi_PP, crossSection()/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_m_PP;
	Histo1DPtr _h_pT_PP;
	Histo1DPtr _h_pT_P1;
	Histo1DPtr _h_pT_P2;
	Histo1DPtr _h_dphi_PP;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_DIPHOTON);

	}
	diff --git a/src/Analyses/MC_ELECTRONS.cc b/src/Analyses/MC_ELECTRONS.cc
	--- a/src/Analyses/MC_ELECTRONS.cc
	+++ b/src/Analyses/MC_ELECTRONS.cc
	@@ -1,44 +1,44 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_ParticleAnalysis.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {


	/// @brief MC validation analysis for electrons
	class MC_ELECTRONS : public MC_ParticleAnalysis {
	public:

	MC_ELECTRONS()
	: MC_ParticleAnalysis("MC_ELECTRONS", 2, "electron")
	{ }


	public:

	void init() {
	IdentifiedFinalState electrons;
	electrons.acceptIdPair(PID::ELECTRON);
	- addProjection(electrons, "Electrons");
	+ declare(electrons, "Electrons");

	MC_ParticleAnalysis::init();
	}


	void analyze(const Event& event) {
	- const Particles es = applyProjection<FinalState>(event, "Electrons").particlesByPt(Cuts::pT > 0.5*GeV);
	+ const Particles es = apply<FinalState>(event, "Electrons").particlesByPt(Cuts::pT > 0.5*GeV);
	MC_ParticleAnalysis::_analyze(event, es);
	}


	void finalize() {
	MC_ParticleAnalysis::finalize();
	}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_ELECTRONS);

	}
	diff --git a/src/Analyses/MC_GENERIC.cc b/src/Analyses/MC_GENERIC.cc
	--- a/src/Analyses/MC_GENERIC.cc
	+++ b/src/Analyses/MC_GENERIC.cc
	@@ -1,177 +1,140 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {

	-
	-

	/// Generic analysis looking at various distributions of final state particles
	class MC_GENERIC : public Analysis {
	public:

	/// Constructor
	- MC_GENERIC()
	- : Analysis("MC_GENERIC")
	- { }
	+ DEFAULT_RIVET_ANALYSIS_CTOR(MC_GENERIC);


	- public:
	-
	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Projections
	- const FinalState cnfs(-5.0, 5.0, 500*MeV);
	- addProjection(cnfs, "FS");
	- addProjection(ChargedFinalState(-5.0, 5.0, 500*MeV), "CFS");
	+ const FinalState fs(Cuts::abseta < 5 && Cuts::pT > 500*MeV);
	+ declare(fs, "FS");
	+ declare(ChargedFinalState(fs), "CFS");

	// Histograms
	- // @todo Choose E/pT ranged based on input energies... can't do anything about kin. cuts, though
	+ /// @todo Choose E/pT ranged based on input energies... can't do anything about kin. cuts, though
	_histMult = bookHisto1D("Mult", 100, -0.5, 199.5);
	_histMultCh = bookHisto1D("MultCh", 100, -0.5, 199.5);

	_histPt = bookHisto1D("Pt", 300, 0, 30);
	_histPtCh = bookHisto1D("PtCh", 300, 0, 30);

	_histE = bookHisto1D("E", 100, 0, 200);
	_histECh = bookHisto1D("ECh", 100, 0, 200);

	_histEtaSumEt = bookProfile1D("EtaSumEt", 25, 0, 5);

	_histEta = bookHisto1D("Eta", 50, -5, 5);
	_histEtaCh = bookHisto1D("EtaCh", 50, -5, 5);
	_tmphistEtaPlus = Histo1D(25, 0, 5);
	_tmphistEtaMinus = Histo1D(25, 0, 5);
	_tmphistEtaChPlus = Histo1D(25, 0, 5);
	_tmphistEtaChMinus = Histo1D(25, 0, 5);

	_histRapidity = bookHisto1D("Rapidity", 50, -5, 5);
	_histRapidityCh = bookHisto1D("RapidityCh", 50, -5, 5);
	_tmphistRapPlus = Histo1D(25, 0, 5);
	_tmphistRapMinus = Histo1D(25, 0, 5);
	_tmphistRapChPlus = Histo1D(25, 0, 5);
	_tmphistRapChMinus = Histo1D(25, 0, 5);

	_histPhi = bookHisto1D("Phi", 50, 0, TWOPI);
	_histPhiCh = bookHisto1D("PhiCh", 50, 0, TWOPI);

	_histEtaPMRatio = bookScatter2D("EtaPMRatio");
	_histEtaChPMRatio = bookScatter2D("EtaChPMRatio");
	_histRapidityPMRatio = bookScatter2D("RapidityPMRatio");
	_histRapidityChPMRatio = bookScatter2D("RapidityChPMRatio");
	}


	-
	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Charged + neutral final state
	- const FinalState& cnfs = applyProjection<FinalState>(event, "FS");
	- MSG_DEBUG("Total multiplicity = " << cnfs.size());
	- _histMult->fill(cnfs.size(), weight);
	- foreach (const Particle& p, cnfs.particles()) {
	- const double eta = p.eta();
	- _histEta->fill(eta, weight);
	- _histEtaSumEt->fill(fabs(eta), p.Et(), weight);
	- if (eta > 0) _tmphistEtaPlus.fill(fabs(eta), weight);
	- else _tmphistEtaMinus.fill(fabs(eta), weight);
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	+ MSG_DEBUG("Total multiplicity = " << fs.size());
	+ _histMult->fill(fs.size(), weight);
	+ for (const Particle& p : fs.particles()) {
	+ _histEta->fill(p.eta(), weight);
	+ _histEtaSumEt->fill(p.abseta(), p.Et(), weight);
	+ (p.eta() > 0 ? _tmphistEtaPlus : _tmphistEtaMinus).fill(p.abseta(), weight);
	//
	- const double rapidity = p.rapidity();
	- _histRapidity->fill(rapidity, weight);
	- if (rapidity > 0) _tmphistRapPlus.fill(fabs(rapidity), weight);
	- else _tmphistRapMinus.fill(fabs(rapidity), weight);
	+ _histRapidity->fill(p.rap(), weight);
	+ (p.rap() > 0 ? _tmphistRapPlus : _tmphistRapMinus).fill(p.absrap(), weight);
	//
	_histPt->fill(p.pT()/GeV, weight);
	_histE->fill(p.E()/GeV, weight);
	_histPhi->fill(p.phi(), weight);
	}

	- const FinalState& cfs = applyProjection<FinalState>(event, "CFS");
	+ // Same for the charged FS particles only
	+ const FinalState& cfs = apply<FinalState>(event, "CFS");
	MSG_DEBUG("Total charged multiplicity = " << cfs.size());
	_histMultCh->fill(cfs.size(), weight);
	- foreach (const Particle& p, cfs.particles()) {
	- const double eta = p.eta();
	- _histEtaCh->fill(eta, weight);
	- if (eta > 0) {
	- _tmphistEtaChPlus.fill(fabs(eta), weight);
	- } else {
	- _tmphistEtaChMinus.fill(fabs(eta), weight);
	- }
	- const double rapidity = p.rapidity();
	- _histRapidityCh->fill(rapidity, weight);
	- if (rapidity > 0) {
	- _tmphistRapChPlus.fill(fabs(rapidity), weight);
	- } else {
	- _tmphistRapChMinus.fill(fabs(rapidity), weight);
	- }
	+ for (const Particle& p : cfs.particles()) {
	+ _histEtaCh->fill(p.eta(), weight);
	+ (p.eta() > 0 ? _tmphistEtaChPlus : _tmphistEtaChMinus).fill(p.abseta(), weight);
	+ //
	+ _histRapidityCh->fill(p.rap(), weight);
	+ (p.rap() > 0 ? _tmphistRapChPlus : _tmphistRapChMinus).fill(p.absrap(), weight);
	+ //
	_histPtCh->fill(p.pT()/GeV, weight);
	_histECh->fill(p.E()/GeV, weight);
	_histPhiCh->fill(p.phi(), weight);
	}

	}


	/// Finalize
	void finalize() {
	- normalize(_histMult);
	- normalize(_histMultCh);
	- normalize(_histEta);
	- normalize(_histEtaCh);
	- normalize(_histRapidity);
	- normalize(_histRapidityCh);
	- normalize(_histPt);
	- normalize(_histPtCh);
	- normalize(_histE);
	- normalize(_histECh);
	- normalize(_histPhi);
	- normalize(_histPhiCh);
	+ normalize({_histMult, _histEta, _histRapidity, _histPt, _histE, _histPhi});
	+ normalize({_histMultCh, _histEtaCh, _histRapidityCh, _histPtCh, _histECh, _histPhiCh});
	divide(_tmphistEtaPlus, _tmphistEtaMinus, _histEtaPMRatio);
	divide(_tmphistEtaChPlus, _tmphistEtaChMinus, _histEtaChPMRatio);
	divide(_tmphistRapPlus, _tmphistRapMinus, _histRapidityPMRatio);
	divide(_tmphistRapChPlus, _tmphistRapChMinus, _histRapidityChPMRatio);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	- Histo1DPtr _histMult, _histMultCh;
	+ Histo1DPtr _histMult, _histEta, _histRapidity, _histPt, _histE, _histPhi;
	+ Histo1DPtr _histMultCh, _histEtaCh, _histRapidityCh, _histPtCh, _histECh, _histPhiCh;
	Profile1DPtr _histEtaSumEt;
	- Histo1DPtr _histEta, _histEtaCh;
	- Histo1DPtr _histRapidity, _histRapidityCh;
	- Histo1DPtr _histPt, _histPtCh;
	- Histo1DPtr _histE, _histECh;
	- Histo1DPtr _histPhi, _histPhiCh;
	- Scatter2DPtr _histEtaPMRatio;
	- Scatter2DPtr _histEtaChPMRatio;
	- Scatter2DPtr _histRapidityPMRatio;
	- Scatter2DPtr _histRapidityChPMRatio;
	+ Scatter2DPtr _histEtaPMRatio, _histEtaChPMRatio, _histRapidityPMRatio, _histRapidityChPMRatio;
	//@}

	- /// @name Temporary histos used to calculate eta+/eta- ratio plots
	+ /// @name Temporary histos used to calculate +/- rapidity ratio plots
	//@{
	- Histo1D _tmphistEtaPlus, _tmphistEtaMinus;
	- Histo1D _tmphistEtaChPlus, _tmphistEtaChMinus;
	- Histo1D _tmphistRapPlus, _tmphistRapMinus;
	- Histo1D _tmphistRapChPlus, _tmphistRapChMinus;
	+ Histo1D _tmphistEtaPlus, _tmphistEtaMinus, _tmphistEtaChPlus, _tmphistEtaChMinus;
	+ Histo1D _tmphistRapPlus, _tmphistRapMinus, _tmphistRapChPlus, _tmphistRapChMinus;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_GENERIC);

	}
	diff --git a/src/Analyses/MC_HFJETS.cc b/src/Analyses/MC_HFJETS.cc
	--- a/src/Analyses/MC_HFJETS.cc
	+++ b/src/Analyses/MC_HFJETS.cc
	@@ -1,151 +1,151 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/PrimaryHadrons.hh"
	#include "Rivet/Projections/HeavyHadrons.hh"

	namespace Rivet {




	class MC_HFJETS : public Analysis {
	public:

	/// Constructor
	MC_HFJETS()
	: Analysis("MC_HFJETS")
	{ }


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	FastJets fj(FinalState(-5, 5), FastJets::ANTIKT, 0.6);
	fj.useInvisibles();
	- addProjection(fj, "Jets");
	- addProjection(HeavyHadrons(Cuts::abseta < 5 && Cuts::pT > 500*MeV), "BCHadrons");
	+ declare(fj, "Jets");
	+ declare(HeavyHadrons(Cuts::abseta < 5 && Cuts::pT > 500*MeV), "BCHadrons");

	_h_ptCJetLead = bookHisto1D("ptCJetLead", linspace(5, 0, 20, false) + logspace(25, 20, 200));
	_h_ptCHadrLead = bookHisto1D("ptCHadrLead", linspace(5, 0, 10, false) + logspace(25, 10, 200));
	_h_ptFracC = bookHisto1D("ptfracC", 50, 0, 1.5);
	_h_eFracC = bookHisto1D("efracC", 50, 0, 1.5);

	_h_ptBJetLead = bookHisto1D("ptBJetLead", linspace(5, 0, 20, false) + logspace(25, 20, 200));
	_h_ptBHadrLead = bookHisto1D("ptBHadrLead", linspace(5, 0, 10, false) + logspace(25, 10, 200));
	_h_ptFracB = bookHisto1D("ptfracB", 50, 0, 1.5);
	_h_eFracB = bookHisto1D("efracB", 50, 0, 1.5);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Get jets and heavy hadrons
	- const Jets& jets = applyProjection<JetAlg>(event, "Jets").jetsByPt();
	- const Particles bhadrons = sortByPt(applyProjection<HeavyHadrons>(event, "BCHadrons").bHadrons());
	- const Particles chadrons = sortByPt(applyProjection<HeavyHadrons>(event, "BCHadrons").cHadrons());
	+ const Jets& jets = apply<JetAlg>(event, "Jets").jetsByPt();
	+ const Particles bhadrons = sortByPt(apply<HeavyHadrons>(event, "BCHadrons").bHadrons());
	+ const Particles chadrons = sortByPt(apply<HeavyHadrons>(event, "BCHadrons").cHadrons());
	MSG_DEBUG("# b hadrons = " << bhadrons.size() << ", # c hadrons = " << chadrons.size());

	// Max HF hadron--jet axis dR to be regarded as a jet tag
	const double MAX_DR = 0.3;

	// Tag the leading b and c jets with a deltaR < 0.3 match
	// b-tagged jet are excluded from also being considered as c-tagged
	/// @todo Do this again with the ghost match?
	MSG_DEBUG("Getting b/c-tags");
	bool gotLeadingB = false, gotLeadingC = false;;
	foreach (const Jet& j, jets) {
	if (!gotLeadingB) {
	FourMomentum leadBJet, leadBHadr;
	double dRmin = MAX_DR;
	foreach (const Particle& b, bhadrons) {
	const double dRcand = min(dRmin, deltaR(j, b));
	if (dRcand < dRmin) {
	dRmin = dRcand;
	leadBJet = j.momentum();
	leadBHadr = b.momentum();
	MSG_DEBUG("New closest b-hadron jet tag candidate: dR = " << dRmin
	<< " for jet pT = " << j.pT()/GeV << " GeV, "
	<< " b hadron pT = " << b.pT()/GeV << " GeV, PID = " << b.pid());
	}
	}
	if (dRmin < MAX_DR) {
	// A jet has been tagged, so fill the histos and break the loop
	_h_ptBJetLead->fill(leadBJet.pT()/GeV, weight);
	_h_ptBHadrLead->fill(leadBHadr.pT()/GeV, weight);
	_h_ptFracB->fill(leadBHadr.pT() / leadBJet.pT(), weight);
	_h_eFracB->fill(leadBHadr.E() / leadBJet.E(), weight);
	gotLeadingB = true;
	continue; // escape this loop iteration so the same jet isn't c-tagged
	}
	}
	if (!gotLeadingC) {
	FourMomentum leadCJet, leadCHadr;
	double dRmin = MAX_DR;
	foreach (const Particle& c, chadrons) {
	const double dRcand = min(dRmin, deltaR(j, c));
	if (dRcand < dRmin) {
	dRmin = dRcand;
	leadCJet = j.momentum();
	leadCHadr = c.momentum();
	MSG_DEBUG("New closest c-hadron jet tag candidate: dR = " << dRmin
	<< " for jet pT = " << j.pT()/GeV << " GeV, "
	<< " c hadron pT = " << c.pT()/GeV << " GeV, PID = " << c.pid());
	}
	}
	if (dRmin < MAX_DR) {
	// A jet has been tagged, so fill the histos and break the loop
	_h_ptCJetLead->fill(leadCJet.pT()/GeV, weight);
	_h_ptCHadrLead->fill(leadCHadr.pT()/GeV, weight);
	_h_ptFracC->fill(leadCHadr.pT() / leadCJet.pT(), weight);
	_h_eFracC->fill(leadCHadr.E() / leadCJet.E(), weight);
	gotLeadingB = true;
	}
	}
	// If we've found both a leading b and a leading c jet, break the loop over jets
	if (gotLeadingB && gotLeadingC) break;
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	normalize(_h_ptCJetLead);
	normalize(_h_ptCHadrLead);
	normalize(_h_ptFracC);
	normalize(_h_eFracC);
	normalize(_h_ptBJetLead);
	normalize(_h_ptBHadrLead);
	normalize(_h_ptFracB);
	normalize(_h_eFracB);
	}

	//@}

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_ptCJetLead, _h_ptCHadrLead, _h_ptFracC, _h_eFracC;
	Histo1DPtr _h_ptBJetLead, _h_ptBHadrLead, _h_ptFracB, _h_eFracB;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_HFJETS);

	}
	diff --git a/src/Analyses/MC_HHJETS.cc b/src/Analyses/MC_HHJETS.cc
	--- a/src/Analyses/MC_HHJETS.cc
	+++ b/src/Analyses/MC_HHJETS.cc
	@@ -1,137 +1,137 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetAnalysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {

	/// @brief MC validation analysis for higgs pairs events (stable Higgses)
	class MC_HHJETS : public MC_JetAnalysis {
	public:

	/// Default constructor
	MC_HHJETS()
	: MC_JetAnalysis("MC_HHJETS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	IdentifiedFinalState ifs(Cuts::abseta < 10.0 && Cuts::pT > 0*GeV);
	ifs.acceptId(25);
	- addProjection(ifs,"IFS");
	+ declare(ifs,"IFS");

	VetoedFinalState vfs;
	vfs.addVetoPairId(25);
	- addProjection(FastJets(vfs, FastJets::ANTIKT, 0.4), "Jets");
	+ declare(FastJets(vfs, FastJets::ANTIKT, 0.4), "Jets");

	_h_HH_mass = bookHisto1D("HH_mass", 250, 240, 4000.0);
	_h_HH_dR = bookHisto1D("HH_dR", 25, 0.5, 10.0);
	_h_HH_dPhi = bookHisto1D("HH_dPhi", 64, 0, 3.2);
	_h_HH_deta= bookHisto1D("HH_deta", 50, -5, 5);
	_h_H_pT = bookHisto1D("H_pT", 50, 0, 2000.0);
	_h_HH_pT = bookHisto1D("HH_pT", 200, 0, 2000.0);
	_h_H_pT1 = bookHisto1D("H_pT1", 200, 0, 2000.0);
	_h_H_pT2 = bookHisto1D("H_pT2", 200, 0, 2000.0);
	_h_H_eta = bookHisto1D("H_eta", 50, -5.0, 5.0);
	_h_H_eta1 = bookHisto1D("H_eta1", 50, -5.0, 5.0);
	_h_H_eta2 = bookHisto1D("H_eta2", 50, -5.0, 5.0);
	_h_H_phi = bookHisto1D("H_phi", 25, 0.0, TWOPI);
	_h_H_jet1_deta = bookHisto1D("H_jet1_deta", 50, -5.0, 5.0);
	_h_H_jet1_dR = bookHisto1D("H_jet1_dR", 25, 0.5, 7.0);

	MC_JetAnalysis::init();
	}



	/// Do the analysis
	void analyze(const Event & e) {

	- const IdentifiedFinalState& ifs = applyProjection<IdentifiedFinalState>(e, "IFS");
	+ const IdentifiedFinalState& ifs = apply<IdentifiedFinalState>(e, "IFS");
	Particles allp = ifs.particlesByPt();
	if (allp.empty()) vetoEvent;

	const double weight = e.weight();

	FourMomentum hmom = allp[0].momentum();
	if (allp.size() > 1) {
	FourMomentum hmom2(allp[1].momentum());
	_h_HH_dR->fill(deltaR(hmom, hmom2), weight);
	_h_HH_dPhi->fill(deltaPhi(hmom, hmom2), weight);
	_h_HH_deta->fill(hmom.eta()-hmom2.eta(), weight);
	_h_HH_pT->fill((hmom+hmom2).pT(), weight);
	_h_HH_mass->fill((hmom+hmom2).mass(), weight);

	if (hmom.pT() > hmom2.pT()) {
	_h_H_pT1->fill(hmom.pT(), weight);
	_h_H_eta1->fill(hmom.eta(), weight);
	_h_H_pT2->fill(hmom2.pT(), weight);
	_h_H_eta2->fill(hmom2.eta(), weight);
	} else {
	_h_H_pT1->fill(hmom2.pT(), weight);
	_h_H_eta1->fill(hmom2.eta(), weight);
	_h_H_pT2->fill(hmom.pT(), weight);
	_h_H_eta2->fill(hmom.eta(), weight);
	}
	}
	_h_H_pT->fill(hmom.pT(), weight);
	_h_H_eta->fill(hmom.eta(), weight);
	_h_H_phi->fill(hmom.azimuthalAngle(), weight);


	// Get the jet candidates
	- Jets jets = applyProjection<FastJets>(e, "Jets").jetsByPt(20.0*GeV);
	+ Jets jets = apply<FastJets>(e, "Jets").jetsByPt(20.0*GeV);
	if (!jets.empty()) {
	_h_H_jet1_deta->fill(deltaEta(hmom, jets[0]), weight);
	_h_H_jet1_dR->fill(deltaR(hmom, jets[0]), weight);
	}

	MC_JetAnalysis::analyze(e);
	}


	/// Finalize
	void finalize() {
	scale(_h_HH_mass, crossSection()/sumOfWeights());
	scale(_h_HH_dR, crossSection()/sumOfWeights());
	scale(_h_HH_deta, crossSection()/sumOfWeights());
	scale(_h_HH_dPhi, crossSection()/sumOfWeights());
	scale(_h_H_pT, crossSection()/sumOfWeights());
	scale(_h_H_pT1, crossSection()/sumOfWeights());
	scale(_h_H_pT2, crossSection()/sumOfWeights());
	scale(_h_HH_pT, crossSection()/sumOfWeights());
	scale(_h_H_eta, crossSection()/sumOfWeights());
	scale(_h_H_eta1, crossSection()/sumOfWeights());
	scale(_h_H_eta2, crossSection()/sumOfWeights());
	scale(_h_H_phi, crossSection()/sumOfWeights());
	scale(_h_H_jet1_deta, crossSection()/sumOfWeights());
	scale(_h_H_jet1_dR, crossSection()/sumOfWeights());

	MC_JetAnalysis::finalize();
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_HH_mass, _h_HH_pT, _h_HH_dR, _h_HH_deta, _h_HH_dPhi;
	Histo1DPtr _h_H_pT, _h_H_pT1, _h_H_pT2, _h_H_eta, _h_H_eta1, _h_H_eta2, _h_H_phi;
	Histo1DPtr _h_H_jet1_deta, _h_H_jet1_dR;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_HHJETS);

	}
	diff --git a/src/Analyses/MC_HINC.cc b/src/Analyses/MC_HINC.cc
	--- a/src/Analyses/MC_HINC.cc
	+++ b/src/Analyses/MC_HINC.cc
	@@ -1,91 +1,91 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {


	/// @brief MC validation analysis for higgs [-> tau tau] events
	class MC_HINC : public Analysis {
	public:

	/// Default constructor
	MC_HINC()
	: Analysis("MC_HINC")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	/// @todo Urk, abuse! Need explicit HiggsFinder and TauFinder?
	ZFinder hfinder(FinalState(), cut, PID::TAU, 115GeV, 135GeV, 0.0, ZFinder::NOCLUSTER, ZFinder::NOTRACK, 125*GeV);
	- addProjection(hfinder, "Hfinder");
	+ declare(hfinder, "Hfinder");
	_h_H_mass = bookHisto1D("H_mass", 50, 119.7, 120.3);
	_h_H_pT = bookHisto1D("H_pT", logspace(100, 1.0, 0.5*(sqrtS()>0.?sqrtS():14000.)/GeV));
	_h_H_pT_peak = bookHisto1D("H_pT_peak", 25, 0.0, 25.0);
	_h_H_y = bookHisto1D("H_y", 40, -4, 4);
	_h_H_phi = bookHisto1D("H_phi", 25, 0.0, TWOPI);
	_h_lepton_pT = bookHisto1D("lepton_pT", logspace(100, 10.0, 0.25*(sqrtS()>0.?sqrtS():14000.)/GeV));
	_h_lepton_eta = bookHisto1D("lepton_eta", 40, -4, 4);
	}


	/// Do the analysis
	void analyze(const Event & e) {
	- const ZFinder& hfinder = applyProjection<ZFinder>(e, "Hfinder");
	+ const ZFinder& hfinder = apply<ZFinder>(e, "Hfinder");
	if (hfinder.bosons().size() != 1) vetoEvent;
	const double weight = e.weight();

	FourMomentum hmom(hfinder.bosons()[0].momentum());
	_h_H_mass->fill(hmom.mass()/GeV, weight);
	_h_H_pT->fill(hmom.pT()/GeV, weight);
	_h_H_pT_peak->fill(hmom.pT()/GeV, weight);
	_h_H_y->fill(hmom.rapidity(), weight);
	_h_H_phi->fill(hmom.phi(), weight);
	foreach (const Particle& l, hfinder.constituents()) {
	_h_lepton_pT->fill(l.pT()/GeV, weight);
	_h_lepton_eta->fill(l.eta(), weight);
	}
	}


	/// Finalize
	void finalize() {
	const double xsec = crossSection()/picobarn;
	normalize(_h_H_mass, xsec);
	normalize(_h_H_pT, xsec);
	normalize(_h_H_pT_peak, xsec);
	normalize(_h_H_y, xsec);
	normalize(_h_H_phi, xsec);
	normalize(_h_lepton_pT, xsec);
	normalize(_h_lepton_eta, xsec);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_H_mass;
	Histo1DPtr _h_H_pT;
	Histo1DPtr _h_H_pT_peak;
	Histo1DPtr _h_H_y;
	Histo1DPtr _h_H_phi;
	Histo1DPtr _h_lepton_pT;
	Histo1DPtr _h_lepton_eta;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_HINC);

	}
	diff --git a/src/Analyses/MC_HJETS.cc b/src/Analyses/MC_HJETS.cc
	--- a/src/Analyses/MC_HJETS.cc
	+++ b/src/Analyses/MC_HJETS.cc
	@@ -1,81 +1,81 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetAnalysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief MC validation analysis for Higgs [-> tau tau] + jets events
	class MC_HJETS : public MC_JetAnalysis {
	public:

	/// Default constructor
	MC_HJETS()
	: MC_JetAnalysis("MC_HJETS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	/// @todo Urk, abuse! Need explicit HiggsFinder (and TauFinder?)
	ZFinder hfinder(FinalState(), cut, PID::TAU, 115GeV, 135GeV, 0.0, ZFinder::NOCLUSTER, ZFinder::NOTRACK, 125*GeV);
	- addProjection(hfinder, "Hfinder");
	+ declare(hfinder, "Hfinder");
	FastJets jetpro(hfinder.remainingFinalState(), FastJets::ANTIKT, 0.4);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	_h_H_jet1_deta = bookHisto1D("H_jet1_deta", 50, -5.0, 5.0);
	_h_H_jet1_dR = bookHisto1D("H_jet1_dR", 25, 0.5, 7.0);

	MC_JetAnalysis::init();
	}



	/// Do the analysis
	void analyze(const Event & e) {
	- const ZFinder& hfinder = applyProjection<ZFinder>(e, "Hfinder");
	+ const ZFinder& hfinder = apply<ZFinder>(e, "Hfinder");
	if (hfinder.bosons().size() != 1) vetoEvent;
	const double weight = e.weight();

	FourMomentum hmom(hfinder.bosons()[0].momentum());
	- const Jets& jets = applyProjection<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	+ const Jets& jets = apply<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	if (jets.size() > 0) {
	_h_H_jet1_deta->fill(hmom.eta()-jets[0].eta(), weight);
	_h_H_jet1_dR->fill(deltaR(hmom, jets[0].momentum()), weight);
	}

	MC_JetAnalysis::analyze(e);
	}


	/// Finalize
	void finalize() {
	normalize(_h_H_jet1_deta, crossSection()/picobarn);
	normalize(_h_H_jet1_dR, crossSection()/picobarn);
	MC_JetAnalysis::finalize();
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_H_jet1_deta;
	Histo1DPtr _h_H_jet1_dR;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_HJETS);

	}
	diff --git a/src/Analyses/MC_HKTSPLITTINGS.cc b/src/Analyses/MC_HKTSPLITTINGS.cc
	--- a/src/Analyses/MC_HKTSPLITTINGS.cc
	+++ b/src/Analyses/MC_HKTSPLITTINGS.cc
	@@ -1,60 +1,60 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetSplittings.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// @brief MC validation analysis for higgs [-> tau tau] + jets events
	class MC_HKTSPLITTINGS : public MC_JetSplittings {
	public:

	/// Default constructor
	MC_HKTSPLITTINGS()
	: MC_JetSplittings("MC_HKTSPLITTINGS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	/// @todo Urk, abuse! Need explicit HiggsFinder and TauFinder
	ZFinder hfinder(FinalState(), cut, PID::TAU, 115GeV, 135GeV, 0.0, ZFinder::NOCLUSTER, ZFinder::NOTRACK, 125*GeV);
	- addProjection(hfinder, "Hfinder");
	+ declare(hfinder, "Hfinder");
	FastJets jetpro(hfinder.remainingFinalState(), FastJets::KT, 0.6);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	MC_JetSplittings::init();
	}



	/// Do the analysis
	void analyze(const Event & e) {
	- const ZFinder& hfinder = applyProjection<ZFinder>(e, "Hfinder");
	+ const ZFinder& hfinder = apply<ZFinder>(e, "Hfinder");
	if (hfinder.bosons().size() != 1) vetoEvent;
	MC_JetSplittings::analyze(e);
	}


	/// Finalize
	void finalize() {
	MC_JetSplittings::finalize();
	}

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_HKTSPLITTINGS);

	}
	diff --git a/src/Analyses/MC_IDENTIFIED.cc b/src/Analyses/MC_IDENTIFIED.cc
	--- a/src/Analyses/MC_IDENTIFIED.cc
	+++ b/src/Analyses/MC_IDENTIFIED.cc
	@@ -1,104 +1,104 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// Generic analysis looking at various distributions of final state particles
	/// @todo Rename as MC_HADRONS
	class MC_IDENTIFIED : public Analysis {
	public:

	/// Constructor
	MC_IDENTIFIED()
	: Analysis("MC_IDENTIFIED")
	{ }


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Projections
	const FinalState cnfs(Cuts::abseta < 5.0 && Cuts::pT > 500*MeV);
	- addProjection(cnfs, "FS");
	- addProjection(UnstableFinalState(Cuts::abseta < 5.0 && Cuts::pT > 500*MeV), "UFS");
	+ declare(cnfs, "FS");
	+ declare(UnstableFinalState(Cuts::abseta < 5.0 && Cuts::pT > 500*MeV), "UFS");

	// Histograms
	// @todo Choose E/pT ranged based on input energies... can't do anything about kin. cuts, though

	_histStablePIDs = bookHisto1D("MultsStablePIDs", 3335, -0.5, 3334.5);
	_histDecayedPIDs = bookHisto1D("MultsDecayedPIDs", 3335, -0.5, 3334.5);
	_histAllPIDs = bookHisto1D("MultsAllPIDs", 3335, -0.5, 3334.5);

	_histEtaPi = bookHisto1D("EtaPi", 25, 0, 5);
	_histEtaK = bookHisto1D("EtaK", 25, 0, 5);
	_histEtaLambda = bookHisto1D("EtaLambda", 25, 0, 5);
	}



	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Unphysical (debug) plotting of all PIDs in the event, physical or otherwise
	foreach (const GenParticle* gp, particles(event.genEvent())) {
	_histAllPIDs->fill(abs(gp->pdg_id()), weight);
	}

	// Charged + neutral final state PIDs
	- const FinalState& cnfs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& cnfs = apply<FinalState>(event, "FS");
	foreach (const Particle& p, cnfs.particles()) {
	_histStablePIDs->fill(p.abspid(), weight);
	}

	// Unstable PIDs and identified particle eta spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");
	foreach (const Particle& p, ufs.particles()) {
	_histDecayedPIDs->fill(p.pid(), weight);
	const double eta_abs = p.abseta();
	const PdgId pid = p.abspid(); //if (PID::isMeson(pid) && PID::hasStrange()) {
	if (pid == 211 \|\| pid == 111) _histEtaPi->fill(eta_abs, weight);
	else if (pid == 321 \|\| pid == 130 \|\| pid == 310) _histEtaK->fill(eta_abs, weight);
	else if (pid == 3122) _histEtaLambda->fill(eta_abs, weight);
	}

	}



	/// Finalize
	void finalize() {
	scale(_histStablePIDs, 1/sumOfWeights());
	scale(_histDecayedPIDs, 1/sumOfWeights());
	scale(_histAllPIDs, 1/sumOfWeights());
	scale(_histEtaPi, 1/sumOfWeights());
	scale(_histEtaK, 1/sumOfWeights());
	scale(_histEtaLambda, 1/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _histStablePIDs, _histDecayedPIDs, _histAllPIDs;
	Histo1DPtr _histEtaPi, _histEtaK, _histEtaLambda;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_IDENTIFIED);

	}
	diff --git a/src/Analyses/MC_JETS.cc b/src/Analyses/MC_JETS.cc
	--- a/src/Analyses/MC_JETS.cc
	+++ b/src/Analyses/MC_JETS.cc
	@@ -1,46 +1,42 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetAnalysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {

	-


	/// @brief MC validation analysis for jet events
	class MC_JETS : public MC_JetAnalysis {
	public:

	MC_JETS()
	: MC_JetAnalysis("MC_JETS", 4, "Jets")
	{ }


	- public:
	-
	void init() {
	FinalState fs;
	FastJets jetpro(fs, FastJets::ANTIKT, 0.4);
	- addProjection(jetpro, "Jets");
	-
	+ declare(jetpro, "Jets");
	MC_JetAnalysis::init();
	}


	void analyze(const Event& event) {
	MC_JetAnalysis::analyze(event);
	}


	void finalize() {
	MC_JetAnalysis::finalize();
	}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_JETS);

	}
	diff --git a/src/Analyses/MC_JETTAGS.cc b/src/Analyses/MC_JETTAGS.cc
	--- a/src/Analyses/MC_JETTAGS.cc
	+++ b/src/Analyses/MC_JETTAGS.cc
	@@ -1,72 +1,71 @@
	// -- C++ --
	-#include "Rivet/Analyses/MC_JetAnalysis.hh"
	+#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {

	-


	/// @brief MC validation analysis for jet events
	class MC_JETTAGS : public Analysis {
	public:

	MC_JETTAGS()
	: Analysis("MC_JETTAGS")
	{ }


	void init() {
	FinalState fs;
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.4), "Jets04");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.6), "Jets06");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.4), "Jets04");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.6), "Jets06");

	_h_numBTagsPerJet[0] = bookHisto1D("numBTagsPer04Jet", 5, -0.5, 4.5);
	_h_numBTagsPerJet[1] = bookHisto1D("numBTagsPer06Jet", 5, -0.5, 4.5);
	_h_numCTagsPerJet[0] = bookHisto1D("numCTagsPer04Jet", 5, -0.5, 4.5);
	_h_numCTagsPerJet[1] = bookHisto1D("numCTagsPer06Jet", 5, -0.5, 4.5);
	_h_numTauTagsPerJet[0] = bookHisto1D("numTauTagsPer04Jet", 5, -0.5, 4.5);
	_h_numTauTagsPerJet[1] = bookHisto1D("numTauTagsPer06Jet", 5, -0.5, 4.5);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const Jets jets04 = applyProjection<FastJets>(event, "Jets04").jetsByPt(20*GeV);
	- const Jets jets06 = applyProjection<FastJets>(event, "Jets06").jetsByPt(20*GeV);
	+ const Jets jets04 = apply<FastJets>(event, "Jets04").jetsByPt(20*GeV);
	+ const Jets jets06 = apply<FastJets>(event, "Jets06").jetsByPt(20*GeV);

	- foreach (const Jet& j, jets04) {
	+ for (const Jet& j : jets04) {
	_h_numBTagsPerJet[0]->fill(j.bTags().size(), weight);
	_h_numCTagsPerJet[0]->fill(j.cTags().size(), weight);
	_h_numTauTagsPerJet[0]->fill(j.tauTags().size(), weight);
	}
	- foreach (const Jet& j, jets06) {
	+ for (const Jet& j : jets06) {
	_h_numBTagsPerJet[1]->fill(j.bTags().size(), weight);
	_h_numCTagsPerJet[1]->fill(j.cTags().size(), weight);
	_h_numTauTagsPerJet[1]->fill(j.tauTags().size(), weight);
	}
	}


	void finalize() {
	for (size_t i = 0; i < 2; ++i) {
	normalize(_h_numBTagsPerJet[i]);
	normalize(_h_numCTagsPerJet[i]);
	normalize(_h_numTauTagsPerJet[i]);
	}
	}


	private:

	Histo1DPtr _h_numBTagsPerJet[2], _h_numCTagsPerJet[2], _h_numTauTagsPerJet[2];

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_JETTAGS);

	}
	diff --git a/src/Analyses/MC_JetAnalysis.cc b/src/Analyses/MC_JetAnalysis.cc
	--- a/src/Analyses/MC_JetAnalysis.cc
	+++ b/src/Analyses/MC_JetAnalysis.cc
	@@ -1,171 +1,179 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetAnalysis.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	MC_JetAnalysis::MC_JetAnalysis(const string& name,
	size_t njet,
	const string& jetpro_name,
	double jetptcut)
	: Analysis(name), _njet(njet), _jetpro_name(jetpro_name), _jetptcut(jetptcut),
	_h_pT_jet(njet),
	_h_eta_jet(njet), _h_eta_jet_plus(njet), _h_eta_jet_minus(njet),
	_h_rap_jet(njet), _h_rap_jet_plus(njet), _h_rap_jet_minus(njet),
	_h_mass_jet(njet)
	{
	setNeedsCrossSection(true); // legitimate use, since a base class has no .info file!
	}



	// Book histograms
	void MC_JetAnalysis::init() {
	const double sqrts = sqrtS() ? sqrtS() : 14000.*GeV;

	for (size_t i = 0; i < _njet; ++i) {
	const string pTname = "jet_pT_" + to_str(i+1);
	const double pTmax = 1.0/(double(i)+2.0) * sqrts/GeV/2.0;
	const int nbins_pT = 100/(i+1);
	_h_pT_jet[i] = bookHisto1D(pTname, logspace(nbins_pT, 10.0, pTmax));

	const string massname = "jet_mass_" + to_str(i+1);
	const double mmax = 100.0;
	const int nbins_m = 100/(i+1);
	_h_mass_jet[i] = bookHisto1D(massname, logspace(nbins_m, 1.0, mmax));

	const string etaname = "jet_eta_" + to_str(i+1);
	_h_eta_jet[i] = bookHisto1D(etaname, i > 1 ? 25 : 50, -5.0, 5.0);
	_h_eta_jet_plus[i].reset(new Histo1D(i > 1 ? 15 : 25, 0, 5));
	_h_eta_jet_minus[i].reset(new Histo1D(i > 1 ? 15 : 25, 0, 5));

	const string rapname = "jet_y_" + to_str(i+1);
	_h_rap_jet[i] = bookHisto1D(rapname, i>1 ? 25 : 50, -5.0, 5.0);
	_h_rap_jet_plus[i].reset(new Histo1D(i > 1 ? 15 : 25, 0, 5));
	_h_rap_jet_minus[i].reset(new Histo1D(i > 1 ? 15 : 25, 0, 5));

	for (size_t j = i+1; j < min(size_t(3), _njet); ++j) {
	const std::pair<size_t, size_t> ij = std::make_pair(i, j);

	string detaname = "jets_deta_" + to_str(i+1) + to_str(j+1);
	_h_deta_jets.insert(make_pair(ij, bookHisto1D(detaname, 25, -5.0, 5.0)));

	string dphiname = "jets_dphi_" + to_str(i+1) + to_str(j+1);
	_h_dphi_jets.insert(make_pair(ij, bookHisto1D(dphiname, 25, 0.0, M_PI)));

	string dRname = "jets_dR_" + to_str(i+1) + to_str(j+1);
	_h_dR_jets.insert(make_pair(ij, bookHisto1D(dRname, 25, 0.0, 5.0)));
	}
	}

	_h_jet_multi_exclusive = bookHisto1D("jet_multi_exclusive", _njet+3, -0.5, _njet+3-0.5);
	_h_jet_multi_inclusive = bookHisto1D("jet_multi_inclusive", _njet+3, -0.5, _njet+3-0.5);
	_h_jet_multi_ratio = bookScatter2D("jet_multi_ratio");
	_h_jet_HT = bookHisto1D("jet_HT", logspace(50, _jetptcut, sqrts/GeV/2.0));
	+ _h_mjj_jets = bookHisto1D("jets_mjj", 40, 0.0, sqrts/GeV/2.0);
	}


	// Do the analysis
	void MC_JetAnalysis::analyze(const Event & e) {
	const double weight = e.weight();

	- const Jets& jets = applyProjection<FastJets>(e, _jetpro_name).jetsByPt(_jetptcut);
	+ const Jets& jets = apply<FastJets>(e, _jetpro_name).jetsByPt(_jetptcut);

	for (size_t i = 0; i < _njet; ++i) {
	if (jets.size() < i+1) continue;
	_h_pT_jet[i]->fill(jets[i].pT()/GeV, weight);
	// Check for numerical precision issues with jet masses
	double m2_i = jets[i].mass2();
	if (m2_i < 0) {
	if (m2_i < -1e-4) {
	MSG_WARNING("Jet mass2 is negative: " << m2_i << " GeV^2. "
	<< "Truncating to 0.0, assuming numerical precision is to blame.");
	}
	m2_i = 0.0;
	}

	// Jet mass
	_h_mass_jet[i]->fill(sqrt(m2_i)/GeV, weight);

	// Jet eta
	const double eta_i = jets[i].eta();
	_h_eta_jet[i]->fill(eta_i, weight);
	(eta_i > 0.0 ? _h_eta_jet_plus : _h_eta_jet_minus)[i]->fill(fabs(eta_i), weight);

	// Jet rapidity
	const double rap_i = jets[i].rapidity();
	_h_rap_jet[i]->fill(rap_i, weight);
	(rap_i > 0.0 ? _h_rap_jet_plus : _h_rap_jet_minus)[i]->fill(fabs(rap_i), weight);

	// Inter-jet properties
	for (size_t j = i+1; j < min(size_t(3),_njet); ++j) {
	if (jets.size() < j+1) continue;
	std::pair<size_t, size_t> ij = std::make_pair(i, j);
	double deta = jets[i].eta()-jets[j].eta();
	double dphi = deltaPhi(jets[i].momentum(),jets[j].momentum());
	double dR = deltaR(jets[i].momentum(), jets[j].momentum());
	_h_deta_jets[ij]->fill(deta, weight);
	_h_dphi_jets[ij]->fill(dphi, weight);
	_h_dR_jets[ij]->fill(dR, weight);
	}
	}

	// Multiplicities
	_h_jet_multi_exclusive->fill(jets.size(), weight);
	for (size_t i = 0; i < _njet+2; ++i) {
	if (jets.size() >= i) {
	_h_jet_multi_inclusive->fill(i, weight);
	}
	}

	// HT
	double HT = 0.0;
	foreach (const Jet& jet, jets) {
	HT += jet.pT();
	}
	_h_jet_HT->fill(HT, weight);
	+
	+ // mjj
	+ if (jets.size() > 1) {
	+ double mjj = (jets[0].momentum() + jets[1].momentum()).mass();
	+ _h_mjj_jets->fill(mjj, weight);
	+ }
	}


	// Finalize
	void MC_JetAnalysis::finalize() {
	for (size_t i = 0; i < _njet; ++i) {
	scale(_h_pT_jet[i], crossSection()/sumOfWeights());
	scale(_h_mass_jet[i], crossSection()/sumOfWeights());
	scale(_h_eta_jet[i], crossSection()/sumOfWeights());
	scale(_h_rap_jet[i], crossSection()/sumOfWeights());

	// Create eta/rapidity ratio plots
	divide(_h_eta_jet_plus[i], _h_eta_jet_minus[i], bookScatter2D("jet_eta_pmratio_" + to_str(i+1)));
	divide(_h_rap_jet_plus[i], _h_rap_jet_minus[i], bookScatter2D("jet_y_pmratio_" + to_str(i+1)));
	}

	// Scale the d{eta,phi,R} histograms
	typedef map<pair<size_t, size_t>, Histo1DPtr> HistMap;
	foreach (HistMap::value_type& it, _h_deta_jets) scale(it.second, crossSection()/sumOfWeights());
	foreach (HistMap::value_type& it, _h_dphi_jets) scale(it.second, crossSection()/sumOfWeights());
	foreach (HistMap::value_type& it, _h_dR_jets) scale(it.second, crossSection()/sumOfWeights());

	// Fill inclusive jet multi ratio
	int Nbins = _h_jet_multi_inclusive->numBins();
	for (int i = 0; i < Nbins-1; ++i) {
	_h_jet_multi_ratio->addPoint(i+1, 0, 0.5, 0);
	if (_h_jet_multi_inclusive->bin(i).sumW() > 0.0) {
	const double ratio = _h_jet_multi_inclusive->bin(i+1).sumW()/_h_jet_multi_inclusive->bin(i).sumW();
	const double relerr_i = _h_jet_multi_inclusive->bin(i).relErr();
	const double relerr_j = _h_jet_multi_inclusive->bin(i+1).relErr();
	const double err = ratio * (relerr_i + relerr_j);
	_h_jet_multi_ratio->point(i).setY(ratio, err);
	}
	}

	scale(_h_jet_multi_exclusive, crossSection()/sumOfWeights());
	scale(_h_jet_multi_inclusive, crossSection()/sumOfWeights());
	scale(_h_jet_HT, crossSection()/sumOfWeights());
	+ scale(_h_mjj_jets, crossSection()/sumOfWeights());
	}


	}
	diff --git a/src/Analyses/MC_JetSplittings.cc b/src/Analyses/MC_JetSplittings.cc
	--- a/src/Analyses/MC_JetSplittings.cc
	+++ b/src/Analyses/MC_JetSplittings.cc
	@@ -1,93 +1,93 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetSplittings.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	MC_JetSplittings::MC_JetSplittings(const string& name,
	size_t njet,
	const string& jetpro_name)
	: Analysis(name), m_njet(njet), m_jetpro_name(jetpro_name),
	_h_log10_d(njet), _h_log10_R(njet+1)
	{
	setNeedsCrossSection(true); // legitimate use, since a base class has no .info file!
	}


	// Book histograms
	void MC_JetSplittings::init() {
	const double sqrts = sqrtS() ? sqrtS() : 14000.*GeV;

	for (size_t i = 0; i < m_njet; ++i) {
	string dname = "log10_d_" + to_str(i) + to_str(i+1);
	_h_log10_d[i] = bookHisto1D(dname, 100, 0.2, log10(0.5*sqrts/GeV));
	string Rname = "log10_R_" + to_str(i);
	_h_log10_R[i] = bookScatter2D(Rname, 50, 0.2, log10(0.5*sqrts/GeV));
	}
	string Rname = "log10_R_" + to_str(m_njet);
	_h_log10_R[m_njet] = bookScatter2D(Rname, 50, 0.2, log10(0.5*sqrts/GeV));
	}



	// Do the analysis
	void MC_JetSplittings::analyze(const Event & e) {
	const double weight = e.weight();

	- const FastJets& jetpro = applyProjection<FastJets>(e, m_jetpro_name);
	+ const FastJets& jetpro = apply<FastJets>(e, m_jetpro_name);
	const auto seq = jetpro.clusterSeq();
	if (!seq) vetoEvent; //< the cseq is the whole point in this sort of analysis!!

	// Jet resolutions and integrated jet rates
	double previous_dij = 10.0;
	for (size_t i = 0; i < min(m_njet,(size_t)seq->n_particles()); ++i) {
	const double d_ij2 = seq->exclusive_dmerge_max(i);
	if (d_ij2 <= 0) continue; ///< @todo Is < 0 possible? Feels like no; I should check ;-)
	// Jet resolution i -> j
	const double d_ij = log10(sqrt(d_ij2));

	// Fill differential jet resolution
	_h_log10_d[i]->fill(d_ij, weight);

	// Fill integrated jet resolution
	for (size_t ibin = 0; ibin < _h_log10_R[i]->numPoints(); ++ibin) {
	Point2D& dp = _h_log10_R[i]->point(ibin);
	if (dp.x() > d_ij && dp.x() < previous_dij) {
	dp.setY(dp.y() + weight);
	}
	}
	previous_dij = d_ij;
	}
	// One remaining integrated jet resolution
	for (size_t ibin = 0; ibin<_h_log10_R[m_njet]->numPoints(); ++ibin) {
	Point2D & dp = _h_log10_R[m_njet]->point(ibin);
	if (dp.x() < previous_dij) {
	dp.setY(dp.y() + weight);
	}
	}

	}


	// Finalize
	void MC_JetSplittings::finalize() {
	const double xsec_unitw = crossSection()/picobarn/sumOfWeights();
	for (size_t i = 0; i < m_njet; ++i) {
	scale(_h_log10_d[i], xsec_unitw);
	for (size_t ibin = 0; ibin<_h_log10_R[i]->numPoints(); ++ibin) {
	Point2D& dp = _h_log10_R[i]->point(ibin);
	dp.setY(dp.y()*xsec_unitw);
	}
	}

	for (size_t ibin = 0; ibin < _h_log10_R[m_njet]->numPoints(); ++ibin) {
	Point2D& dp =_h_log10_R[m_njet]->point(ibin);
	dp.setY(dp.y()*xsec_unitw);
	}
	}


	}
	diff --git a/src/Analyses/MC_KTSPLITTINGS.cc b/src/Analyses/MC_KTSPLITTINGS.cc
	--- a/src/Analyses/MC_KTSPLITTINGS.cc
	+++ b/src/Analyses/MC_KTSPLITTINGS.cc
	@@ -1,44 +1,44 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetSplittings.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// @brief MC validation analysis for jet events
	class MC_KTSPLITTINGS : public MC_JetSplittings {
	public:

	MC_KTSPLITTINGS()
	: MC_JetSplittings("MC_KTSPLITTINGS", 4, "Jets")
	{ }


	public:

	void init() {
	FastJets jetpro(FinalState(), FastJets::KT, 0.6);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");
	MC_JetSplittings::init();
	}


	void analyze(const Event& event) {
	MC_JetSplittings::analyze(event);
	}


	void finalize() {
	MC_JetSplittings::finalize();
	}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_KTSPLITTINGS);

	}
	diff --git a/src/Analyses/MC_LEADJETUE.cc b/src/Analyses/MC_LEADJETUE.cc
	--- a/src/Analyses/MC_LEADJETUE.cc
	+++ b/src/Analyses/MC_LEADJETUE.cc
	@@ -1,170 +1,170 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// @brief MC validation analysis for underlying event in jet events
	/// @author Andy Buckley
	class MC_LEADJETUE : public Analysis {
	public:

	/// Constructor
	MC_LEADJETUE()
	: Analysis("MC_LEADJETUE")
	{ }


	/// @name Analysis methods
	//@{

	// Book histograms
	void init() {
	// Final state for the jet finding
	const FinalState fsj(-4.0, 4.0, 0.0*GeV);
	- addProjection(fsj, "FSJ");
	- addProjection(FastJets(fsj, FastJets::KT, 0.7), "Jets");
	+ declare(fsj, "FSJ");
	+ declare(FastJets(fsj, FastJets::KT, 0.7), "Jets");

	// Charged final state for the distributions
	const ChargedFinalState cfs(-1.0, 1.0, 0.5*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	const double maxpt1 = 500.0;
	_hist_pnchg = bookProfile1D("trans-nchg", 50, 0.0, maxpt1);
	_hist_pmaxnchg = bookProfile1D("trans-maxnchg", 50, 0.0, maxpt1);
	_hist_pminnchg = bookProfile1D("trans-minnchg", 50, 0.0, maxpt1);
	_hist_pcptsum = bookProfile1D("trans-ptsum", 50, 0.0, maxpt1);
	_hist_pmaxcptsum = bookProfile1D("trans-maxptsum", 50, 0.0, maxpt1);
	_hist_pmincptsum = bookProfile1D("trans-minptsum", 50, 0.0, maxpt1);
	_hist_pcptave = bookProfile1D("trans-ptavg", 50, 0.0, maxpt1);
	}


	// Do the analysis
	void analyze(const Event& e) {

	- const FinalState& fsj = applyProjection<FinalState>(e, "FSJ");
	+ const FinalState& fsj = apply<FinalState>(e, "FSJ");
	if (fsj.particles().empty()) {
	MSG_DEBUG("Failed multiplicity cut");
	vetoEvent;
	}

	- const FastJets& jetpro = applyProjection<FastJets>(e, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(e, "Jets");
	const Jets jets = jetpro.jetsByPt();
	MSG_DEBUG("Jet multiplicity = " << jets.size());

	// Require the leading jet to be within \|eta\| < 2
	if (jets.size() < 1 \|\| fabs(jets[0].eta()) > 2) {
	MSG_DEBUG("Failed jet cut");
	vetoEvent;
	}

	const double jetphi = jets[0].phi();
	const double jetpT = jets[0].pT();
	MSG_DEBUG("Leading jet: pT = " << jetpT/GeV << " GeV"
	<< ", eta = " << jets[0].eta()
	<< ", phi = " << jetphi);

	// Get the event weight
	const double weight = e.weight();

	// Get the final states to work with for filling the distributions
	- const FinalState& cfs = applyProjection<ChargedFinalState>(e, "CFS");
	+ const FinalState& cfs = apply<ChargedFinalState>(e, "CFS");

	size_t numOverall(0), numToward(0), numTrans1(0), numTrans2(0), numAway(0);
	double ptSumOverall(0.0), ptSumToward(0.0), ptSumTrans1(0.0), ptSumTrans2(0.0), ptSumAway(0.0);
	double ptMaxOverall(0.0), ptMaxToward(0.0), ptMaxTrans1(0.0), ptMaxTrans2(0.0), ptMaxAway(0.0);

	// Calculate all the charged stuff
	foreach (const Particle& p, cfs.particles()) {
	const double dPhi = deltaPhi(p.phi(), jetphi);
	const double pT = p.pT();
	const double phi = p.phi();
	const double rotatedphi = phi - jetphi;

	ptSumOverall += pT;
	++numOverall;
	if (pT > ptMaxOverall) ptMaxOverall = pT;

	if (dPhi < PI/3.0) {
	ptSumToward += pT;
	++numToward;
	if (pT > ptMaxToward) ptMaxToward = pT;
	}
	else if (dPhi < 2*PI/3.0) {
	if (rotatedphi <= PI) {
	ptSumTrans1 += pT;
	++numTrans1;
	if (pT > ptMaxTrans1) ptMaxTrans1 = pT;
	} else {
	ptSumTrans2 += pT;
	++numTrans2;
	if (pT > ptMaxTrans2) ptMaxTrans2 = pT;
	}
	}
	else {
	ptSumAway += pT;
	++numAway;
	if (pT > ptMaxAway) ptMaxAway = pT;
	}
	}


	// Fill the histograms
	//_hist_tnchg->fill(jetpT/GeV, numToward/(4*PI/3), weight);
	_hist_pnchg->fill(jetpT/GeV, (numTrans1+numTrans2)/(4*PI/3), weight);
	_hist_pmaxnchg->fill(jetpT/GeV, (numTrans1>numTrans2 ? numTrans1 : numTrans2)/(2*PI/3), weight);
	_hist_pminnchg->fill(jetpT/GeV, (numTrans1<numTrans2 ? numTrans1 : numTrans2)/(2*PI/3), weight);
	//_hist_pdifnchg->fill(jetpT/GeV, abs(numTrans1-numTrans2)/(2*PI/3), weight);
	//_hist_anchg->fill(jetpT/GeV, numAway/(4*PI/3), weight);

	//_hist_tcptsum->fill(jetpT/GeV, ptSumToward/GeV/(4*PI/3), weight);
	_hist_pcptsum->fill(jetpT/GeV, (ptSumTrans1+ptSumTrans2)/GeV/(4*PI/3), weight);
	_hist_pmaxcptsum->fill(jetpT/GeV, (ptSumTrans1>ptSumTrans2 ? ptSumTrans1 : ptSumTrans2)/GeV/(2*PI/3), weight);
	_hist_pmincptsum->fill(jetpT/GeV, (ptSumTrans1<ptSumTrans2 ? ptSumTrans1 : ptSumTrans2)/GeV/(2*PI/3), weight);
	//_hist_pdifcptsum->fill(jetpT/GeV, fabs(ptSumTrans1-ptSumTrans2)/GeV/(2*PI/3), weight);
	//_hist_acptsum->fill(jetpT/GeV, ptSumAway/GeV/(4*PI/3), weight);

	//if (numToward > 0) {
	// _hist_tcptave->fill(jetpT/GeV, ptSumToward/GeV/numToward, weight);
	// _hist_tcptmax->fill(jetpT/GeV, ptMaxToward/GeV, weight);
	//}
	if ((numTrans1+numTrans2) > 0) {
	_hist_pcptave->fill(jetpT/GeV, (ptSumTrans1+ptSumTrans2)/GeV/(numTrans1+numTrans2), weight);
	//_hist_pcptmax->fill(jetpT/GeV, (ptMaxTrans1 > ptMaxTrans2 ? ptMaxTrans1 : ptMaxTrans2)/GeV, weight);
	}
	//if (numAway > 0) {
	// _hist_acptave->fill(jetpT/GeV, ptSumAway/GeV/numAway, weight);
	// _hist_acptmax->fill(jetpT/GeV, ptMaxAway/GeV, weight);
	//}
	}


	void finalize() {
	//
	}


	private:

	Profile1DPtr _hist_pnchg;
	Profile1DPtr _hist_pmaxnchg;
	Profile1DPtr _hist_pminnchg;
	Profile1DPtr _hist_pcptsum;
	Profile1DPtr _hist_pmaxcptsum;
	Profile1DPtr _hist_pmincptsum;
	Profile1DPtr _hist_pcptave;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_LEADJETUE);

	}
	diff --git a/src/Analyses/MC_MET.cc b/src/Analyses/MC_MET.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/MC_MET.cc
	@@ -0,0 +1,66 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/MissingMomentum.hh"
	+
	+namespace Rivet {
	+
	+
	+
	+ /// @brief MC validation analysis for truth-MET measurement
	+ /// @todo Add plots for MET based on prompt invisibles
	+ class MC_MET : public Analysis {
	+ public:
	+
	+ MC_MET()
	+ : Analysis("MC_MET")
	+ { }
	+
	+
	+ void init() {
	+ FinalState inclfs;
	+ FinalState calofs(Cuts::abseta < 5);
	+ declare(MissingMomentum(inclfs), "InclMET");
	+ declare(MissingMomentum(calofs), "CaloMET");
	+
	+ _h_met_incl = bookHisto1D("met_incl", logspace(30, 1, 150));
	+ _h_met_calo = bookHisto1D("met_calo", logspace(30, 1, 150));
	+ _h_set_incl = bookHisto1D("set_incl", logspace(30, 1, sqrtS()/GeV/2));
	+ _h_set_calo = bookHisto1D("set_calo", logspace(30, 1, sqrtS()/GeV/2));
	+ }
	+
	+
	+ void analyze(const Event& event) {
	+ const double weight = event.weight();
	+
	+ const MissingMomentum& mmincl = apply<MissingMomentum>(event, "InclMET");
	+ _h_met_incl->fill(mmincl.met()/GeV, weight);
	+ _h_set_incl->fill(mmincl.set()/GeV, weight);
	+
	+ const MissingMomentum& mmcalo = apply<MissingMomentum>(event, "CaloMET");
	+ _h_met_calo->fill(mmcalo.met()/GeV, weight);
	+ _h_set_calo->fill(mmcalo.set()/GeV, weight);
	+
	+ }
	+
	+
	+ void finalize() {
	+ normalize({_h_met_incl, _h_set_incl});
	+ normalize({_h_met_calo, _h_set_calo});
	+ }
	+
	+
	+ private:
	+
	+ Histo1DPtr _h_met_incl, _h_set_incl;
	+ Histo1DPtr _h_met_calo, _h_set_calo;
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(MC_MET);
	+
	+
	+}
	diff --git a/src/Analyses/MC_MUONS.cc b/src/Analyses/MC_MUONS.cc
	--- a/src/Analyses/MC_MUONS.cc
	+++ b/src/Analyses/MC_MUONS.cc
	@@ -1,44 +1,44 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_ParticleAnalysis.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {


	/// @brief MC validation analysis for muons
	class MC_MUONS : public MC_ParticleAnalysis {
	public:

	MC_MUONS()
	: MC_ParticleAnalysis("MC_MUONS", 2, "muon")
	{ }


	public:

	void init() {
	IdentifiedFinalState muons;
	muons.acceptIdPair(PID::MUON);
	- addProjection(muons, "Muons");
	+ declare(muons, "Muons");

	MC_ParticleAnalysis::init();
	}


	void analyze(const Event& event) {
	- const Particles mus = applyProjection<FinalState>(event, "Muons").particlesByPt(Cuts::pT > 0.5*GeV);
	+ const Particles mus = apply<FinalState>(event, "Muons").particlesByPt(Cuts::pT > 0.5*GeV);
	MC_ParticleAnalysis::_analyze(event, mus);
	}


	void finalize() {
	MC_ParticleAnalysis::finalize();
	}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_MUONS);

	}
	diff --git a/src/Analyses/MC_PDFS.cc b/src/Analyses/MC_PDFS.cc
	--- a/src/Analyses/MC_PDFS.cc
	+++ b/src/Analyses/MC_PDFS.cc
	@@ -1,96 +1,96 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	// #include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {

	/// Generic analysis looking at various distributions of final state particles
	class MC_PDFS : public Analysis {
	public:

	/// Constructor
	MC_PDFS()
	: Analysis("MC_PDFS")
	{ }


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	// Projections
	- // addProjection(ChargedFinalState(-5.0, 5.0, 500*MeV), "CFS");
	+ // declare(ChargedFinalState(-5.0, 5.0, 500*MeV), "CFS");

	// Histograms
	_histPdfX = bookHisto1D("PdfX", logspace(50, 0.000001, 1.0));
	_histPdfXmin = bookHisto1D("PdfXmin", logspace(50, 0.000001, 1.0));
	_histPdfXmax = bookHisto1D("PdfXmax", logspace(50, 0.000001, 1.0));
	_histPdfQ = bookHisto1D("PdfQ", 50, 0.0, 30.0);
	_histPdfXQ = bookHisto2D("PdfXQ", logspace(50, 0.000001, 1.0), linspace(50, 0.0, 30.0));
	// _histPdfTrackptVsX = bookProfile1D("PdfTrackptVsX", logspace(50, 0.000001, 1.0));
	// _histPdfTrackptVsQ = bookProfile1D("PdfTrackptVsQ", 50, 0.0, 30.0);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// This analysis needs a valid HepMC PDF info object to do anything
	if (event.genEvent()->pdf_info() == 0) vetoEvent;
	HepMC::PdfInfo pdfi = *(event.genEvent()->pdf_info());

	MSG_DEBUG("PDF Q = " << pdfi.scalePDF() << " for (id, x) = "
	<< "(" << pdfi.id1() << ", " << pdfi.x1() << ") "
	<< "(" << pdfi.id2() << ", " << pdfi.x2() << ")");
	_histPdfX->fill(pdfi.x1(), weight);
	_histPdfX->fill(pdfi.x2(), weight);
	_histPdfXmin->fill(std::min(pdfi.x1(), pdfi.x2()), weight);
	_histPdfXmax->fill(std::max(pdfi.x1(), pdfi.x2()), weight);
	_histPdfQ->fill(pdfi.scalePDF(), weight); // always in GeV?
	_histPdfXQ->fill(pdfi.x1(), pdfi.scalePDF(), weight); // always in GeV?
	_histPdfXQ->fill(pdfi.x2(), pdfi.scalePDF(), weight); // always in GeV?

	- // const FinalState& cfs = applyProjection<FinalState>(event, "CFS");
	+ // const FinalState& cfs = apply<FinalState>(event, "CFS");
	// foreach (const Particle& p, cfs.particles()) {
	// if (fabs(eta) < 2.5 && p.pT() > 10*GeV) {
	// _histPdfTrackptVsX->fill(pdfi.x1(), p.pT()/GeV, weight);
	// _histPdfTrackptVsX->fill(pdfi.x2(), p.pT()/GeV, weight);
	// _histPdfTrackptVsQ->fill(pdfi.scalePDF(), p.pT()/GeV, weight);
	// }
	// }

	}



	/// Finalize
	void finalize() {
	scale(_histPdfX, 1/sumOfWeights());
	scale(_histPdfXmin, 1/sumOfWeights());
	scale(_histPdfXmax, 1/sumOfWeights());
	scale(_histPdfQ, 1/sumOfWeights());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _histPdfX, _histPdfXmin, _histPdfXmax, _histPdfQ;
	Histo2DPtr _histPdfXQ;
	// Profile1DPtr _histPdfTrackptVsX, _histPdfTrackptVsQ;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_PDFS);

	}
	diff --git a/src/Analyses/MC_PHOTONINC.cc b/src/Analyses/MC_PHOTONINC.cc
	--- a/src/Analyses/MC_PHOTONINC.cc
	+++ b/src/Analyses/MC_PHOTONINC.cc
	@@ -1,109 +1,109 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {




	/// @brief MC validation analysis for single photon events
	class MC_PHOTONINC : public Analysis {
	public:

	/// Default constructor
	MC_PHOTONINC()
	: Analysis("MC_PHOTONINC")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	// General FS
	FinalState fs(-5.0, 5.0);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Get leading photon
	LeadingParticlesFinalState photonfs(FinalState(-1.0, 1.0, 30.0*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// FS for isolation excludes the leading photon
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(photonfs);
	- addProjection(vfs, "JetFS");
	+ declare(vfs, "JetFS");

	_h_photon_pT = bookHisto1D("photon_pT", logspace(50, 30.0, 0.5*(sqrtS()>0.?sqrtS():14000.)));
	_h_photon_pT_lin = bookHisto1D("photon_pT_lin", 50, 0.0, 70.0);
	_h_photon_y = bookHisto1D("photon_y", 50, -5.0, 5.0);
	}


	/// Do the analysis
	void analyze(const Event& e) {
	// Get the photon
	- const Particles photons = applyProjection<FinalState>(e, "LeadingPhoton").particles();
	+ const Particles photons = apply<FinalState>(e, "LeadingPhoton").particles();
	if (photons.size() != 1) {
	vetoEvent;
	}
	const FourMomentum photon = photons.front().momentum();

	// Get all charged particles
	- const FinalState& fs = applyProjection<FinalState>(e, "JetFS");
	+ const FinalState& fs = apply<FinalState>(e, "JetFS");
	if (fs.empty()) {
	vetoEvent;
	}

	// Passed cuts, so get the weight
	const double weight = e.weight();

	// Isolate photon by ensuring that a 0.4 cone around it contains less than 7% of the photon's energy
	const double egamma = photon.E();
	double econe = 0.0;
	foreach (const Particle& p, fs.particles()) {
	if (deltaR(photon, p.momentum()) < 0.4) {
	econe += p.E();
	// Veto as soon as E_cone gets larger
	if (econe/egamma > 0.07) {
	vetoEvent;
	}
	}
	}

	_h_photon_pT->fill(photon.pT(),weight);
	_h_photon_pT_lin->fill(photon.pT(),weight);
	_h_photon_y->fill(photon.rapidity(),weight);
	}


	// Finalize
	void finalize() {
	scale(_h_photon_pT, crossSectionPerEvent());
	scale(_h_photon_pT_lin, crossSectionPerEvent());
	scale(_h_photon_y, crossSectionPerEvent());
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_photon_pT;
	Histo1DPtr _h_photon_pT_lin;
	Histo1DPtr _h_photon_y;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_PHOTONINC);

	}
	diff --git a/src/Analyses/MC_PHOTONJETS.cc b/src/Analyses/MC_PHOTONJETS.cc
	--- a/src/Analyses/MC_PHOTONJETS.cc
	+++ b/src/Analyses/MC_PHOTONJETS.cc
	@@ -1,122 +1,122 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetAnalysis.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// @brief MC validation analysis for photon + jets events
	class MC_PHOTONJETS : public MC_JetAnalysis {
	public:

	/// Default constructor
	MC_PHOTONJETS()
	: MC_JetAnalysis("MC_PHOTONJETS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	// General FS
	FinalState fs(-5.0, 5.0);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Get leading photon
	LeadingParticlesFinalState photonfs(FinalState(-1.0, 1.0, 30.0*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// FS for jets excludes the leading photon
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(photonfs);
	- addProjection(vfs, "JetFS");
	+ declare(vfs, "JetFS");
	FastJets jetpro(vfs, FastJets::ANTIKT, 0.4);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	_h_photon_jet1_deta = bookHisto1D("photon_jet1_deta", 50, -5.0, 5.0);
	_h_photon_jet1_dphi = bookHisto1D("photon_jet1_dphi", 20, 0.0, M_PI);
	_h_photon_jet1_dR = bookHisto1D("photon_jet1_dR", 25, 0.5, 7.0);

	MC_JetAnalysis::init();
	}


	/// Do the analysis
	void analyze(const Event& e) {
	// Get the photon
	/// @todo share IsolatedPhoton projection between all MC_PHOTON analyses
	- const Particles photons = applyProjection<FinalState>(e, "LeadingPhoton").particles();
	+ const Particles photons = apply<FinalState>(e, "LeadingPhoton").particles();
	if (photons.size() != 1) {
	vetoEvent;
	}
	const FourMomentum photon = photons.front().momentum();

	// Get all charged particles
	- const FinalState& fs = applyProjection<FinalState>(e, "JetFS");
	+ const FinalState& fs = apply<FinalState>(e, "JetFS");
	if (fs.empty()) {
	vetoEvent;
	}

	// Passed cuts, so get the weight
	const double weight = e.weight();

	// Isolate photon by ensuring that a 0.4 cone around it contains less than 7% of the photon's energy
	const double egamma = photon.E();
	double econe = 0.0;
	foreach (const Particle& p, fs.particles()) {
	if (deltaR(photon, p.momentum()) < 0.4) {
	econe += p.E();
	// Veto as soon as E_cone gets larger
	if (econe/egamma > 0.07) {
	vetoEvent;
	}
	}
	}

	- const Jets& jets = applyProjection<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	+ const Jets& jets = apply<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	if (jets.size()>0) {
	_h_photon_jet1_deta->fill(photon.eta()-jets[0].eta(), weight);
	_h_photon_jet1_dphi->fill(mapAngle0ToPi(photon.phi()-jets[0].phi()), weight);
	_h_photon_jet1_dR->fill(deltaR(photon, jets[0].momentum()), weight);
	}

	MC_JetAnalysis::analyze(e);
	}


	// Finalize
	void finalize() {
	scale(_h_photon_jet1_deta, crossSectionPerEvent());
	scale(_h_photon_jet1_dphi, crossSectionPerEvent());
	scale(_h_photon_jet1_dR, crossSectionPerEvent());

	MC_JetAnalysis::finalize();
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_photon_jet1_deta;
	Histo1DPtr _h_photon_jet1_dphi;
	Histo1DPtr _h_photon_jet1_dR;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_PHOTONJETS);

	}
	diff --git a/src/Analyses/MC_PHOTONKTSPLITTINGS.cc b/src/Analyses/MC_PHOTONKTSPLITTINGS.cc
	--- a/src/Analyses/MC_PHOTONKTSPLITTINGS.cc
	+++ b/src/Analyses/MC_PHOTONKTSPLITTINGS.cc
	@@ -1,93 +1,93 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetSplittings.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// @brief MC validation analysis for photon + jets events
	class MC_PHOTONKTSPLITTINGS : public MC_JetSplittings {
	public:

	/// Default constructor
	MC_PHOTONKTSPLITTINGS()
	: MC_JetSplittings("MC_PHOTONKTSPLITTINGS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	// General FS
	FinalState fs(-5.0, 5.0);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	// Get leading photon
	LeadingParticlesFinalState photonfs(FinalState(-1.0, 1.0, 30.0*GeV));
	photonfs.addParticleId(PID::PHOTON);
	- addProjection(photonfs, "LeadingPhoton");
	+ declare(photonfs, "LeadingPhoton");

	// FS for jets excludes the leading photon
	VetoedFinalState vfs(fs);
	vfs.addVetoOnThisFinalState(photonfs);
	- addProjection(vfs, "JetFS");
	+ declare(vfs, "JetFS");
	FastJets jetpro(vfs, FastJets::KT, 0.6);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	MC_JetSplittings::init();
	}


	/// Do the analysis
	void analyze(const Event& e) {
	// Get the photon
	- const Particles photons = applyProjection<FinalState>(e, "LeadingPhoton").particles();
	+ const Particles photons = apply<FinalState>(e, "LeadingPhoton").particles();
	if (photons.size() != 1) {
	vetoEvent;
	}
	const FourMomentum photon = photons.front().momentum();

	// Get all charged particles
	- const FinalState& fs = applyProjection<FinalState>(e, "JetFS");
	+ const FinalState& fs = apply<FinalState>(e, "JetFS");
	if (fs.empty()) {
	vetoEvent;
	}

	// Isolate photon by ensuring that a 0.4 cone around it contains less than 7% of the photon's energy
	const double egamma = photon.E();
	double econe = 0.0;
	foreach (const Particle& p, fs.particles()) {
	if (deltaR(photon, p.momentum()) < 0.4) {
	econe += p.E();
	// Veto as soon as E_cone gets larger
	if (econe/egamma > 0.07) {
	vetoEvent;
	}
	}
	}

	MC_JetSplittings::analyze(e);
	}


	// Finalize
	void finalize() {
	MC_JetSplittings::finalize();
	}

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_PHOTONKTSPLITTINGS);

	}
	diff --git a/src/Analyses/MC_PHOTONS.cc b/src/Analyses/MC_PHOTONS.cc
	--- a/src/Analyses/MC_PHOTONS.cc
	+++ b/src/Analyses/MC_PHOTONS.cc
	@@ -1,152 +1,152 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {




	/// @brief MC validation analysis for photons
	/// @todo Rename to MC_DRESSEDPHOTONS, or add these plots to the generic particle analysis photons
	class MC_PHOTONS : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	MC_PHOTONS()
	: Analysis("MC_PHOTONS")
	{ }

	//@}


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	IdentifiedFinalState leptons(Cuts::abseta < 5.0 && Cuts::pT > 10*GeV);
	leptons.acceptChLeptons();
	- addProjection(leptons, "lFS");
	+ declare(leptons, "lFS");

	IdentifiedFinalState photons(Cuts::abseta < 5.0);
	photons.acceptId(PID::PHOTON);
	- addProjection(photons, "gammaFS");
	+ declare(photons, "gammaFS");

	_h_Ptgamma = bookHisto1D("Ptgamma", logspace(50, 0.01, 30));
	_h_Egamma = bookHisto1D("Egamma", logspace(50, 0.01, 200));
	_h_sumPtgamma = bookHisto1D("sumPtgamma", 50, 0, 100);
	_h_sumEgamma = bookHisto1D("sumEgamma", 50, 0, (sqrtS()>0.?sqrtS():14000.)/GeV/5.0);
	_h_DelR = bookHisto1D("DeltaR", 50, 0, 2);
	_h_DelR_weighted = bookHisto1D("DeltaR_ptweighted", 50, 0, 2);
	_h_DelR_R = bookHisto1D("DeltaR_R", 50, 0, 2);
	_h_DelR_R_weighted = bookHisto1D("DeltaR_R_ptweighted", 50, 0, 2);
	_p_DelR_vs_pTl = bookProfile1D("DeltaR_vs_pTlep", 50, 10, 120);
	_p_DelR_weighted_vs_pTl = bookProfile1D("DeltaR_ptweighted_vs_pTlep", 50, 10, 120);
	_p_DelR_R_vs_pTl = bookProfile1D("DeltaR_R_vs_pTlep", 50, 10, 120);
	_p_DelR_R_weighted_vs_pTl = bookProfile1D("DeltaR_R_ptweighted_vs_pTlep", 50, 10, 120);
	_p_sumPtgamma_vs_pTl = bookProfile1D("sumPtGamma_vs_pTlep", 50, 10, 120);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	/// Get photons and leptons
	- const Particles& photons = applyProjection<FinalState>(event, "gammaFS").particles();
	+ const Particles& photons = apply<FinalState>(event, "gammaFS").particles();
	MSG_DEBUG("Photon multiplicity = " << photons.size());
	- const Particles& leptons = applyProjection<FinalState>(event, "lFS").particles();
	+ const Particles& leptons = apply<FinalState>(event, "lFS").particles();
	MSG_DEBUG("Photon multiplicity = " << leptons.size());

	// Initialise a map of sumPtgamma for each lepton
	map<size_t, double> sumpT_per_lep;
	for (size_t il = 0; il < leptons.size(); ++il) sumpT_per_lep[il] = 0;

	// Calculate photon energies and transverse momenta
	double sumPtgamma(0), sumEgamma(0);
	foreach (const Particle& p, photons) {
	// Individual and summed pTs and energies
	double pTgamma = p.pT()/GeV;
	double Egamma = p.E()/GeV;
	_h_Ptgamma->fill(pTgamma, weight);
	_h_Egamma->fill(Egamma, weight);
	sumPtgamma += pTgamma;
	sumEgamma += Egamma;

	// Calculate delta R with respect to the nearest lepton
	int ilep = -1;
	double delR = 10000;
	for (size_t il = 0; il < leptons.size(); ++il) {
	const double tmpdelR = deltaR(leptons[il].momentum(), p.momentum());
	if (tmpdelR < delR) {
	ilep = il;
	delR = tmpdelR;
	}
	}
	if (ilep != -1) {
	_h_DelR->fill(delR, weight);
	_h_DelR_weighted->fill(delR, weight*pTgamma/GeV);
	_h_DelR_R->fill(delR, weight/(delR+1e-5));
	_h_DelR_R_weighted->fill(delR, weight*pTgamma/GeV/(delR+1e-5));
	_p_DelR_vs_pTl->fill(leptons[ilep].pT()/GeV, delR, weight);
	_p_DelR_weighted_vs_pTl->fill(leptons[ilep].pT()/GeV, delR, weight*pTgamma/GeV);
	_p_DelR_R_vs_pTl->fill(leptons[ilep].pT()/GeV, delR, weight/(delR+1e-5));
	_p_DelR_R_weighted_vs_pTl->fill(leptons[ilep].pT()/GeV, delR, weight*pTgamma/GeV/(delR+1e-5));
	sumpT_per_lep[ilep] += pTgamma;
	}
	}

	// Histogram whole-event photon HT/energy
	_h_sumPtgamma->fill(sumPtgamma/GeV, weight);
	_h_sumEgamma->fill(sumEgamma/GeV, weight);

	// Histogram per-lepton sum(pT)
	for (size_t il = 0; il < leptons.size(); ++il) {
	_p_sumPtgamma_vs_pTl->fill(leptons[il].pT()/GeV, sumpT_per_lep[il]/GeV, weight);
	}

	}


	/// Normalise histograms etc., after the run
	void finalize() {
	normalize(_h_Ptgamma);
	normalize(_h_Egamma);
	normalize(_h_sumPtgamma);
	normalize(_h_sumEgamma);
	normalize(_h_DelR);
	normalize(_h_DelR_weighted);
	normalize(_h_DelR_R);
	normalize(_h_DelR_R_weighted);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_Ptgamma, _h_Egamma;
	Histo1DPtr _h_sumPtgamma, _h_sumEgamma;
	Histo1DPtr _h_DelR, _h_DelR_weighted;
	Histo1DPtr _h_DelR_R, _h_DelR_R_weighted;
	Profile1DPtr _p_DelR_vs_pTl, _p_DelR_weighted_vs_pTl;
	Profile1DPtr _p_DelR_R_vs_pTl, _p_DelR_R_weighted_vs_pTl;
	Profile1DPtr _p_sumPtgamma_vs_pTl;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_PHOTONS);


	}
	diff --git a/src/Analyses/MC_QCD_PARTONS.cc b/src/Analyses/MC_QCD_PARTONS.cc
	--- a/src/Analyses/MC_QCD_PARTONS.cc
	+++ b/src/Analyses/MC_QCD_PARTONS.cc
	@@ -1,68 +1,68 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetSplittings.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// Generic analysis looking at kt splitting scales of partons
	class MC_QCD_PARTONS : public MC_JetSplittings {
	public:

	/// Constructor
	MC_QCD_PARTONS()
	: MC_JetSplittings("MC_QCD_PARTONS", 4, "Jets")
	{ }


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	// Projections
	IdentifiedFinalState partonfs;
	for (int i=1; i<6; ++i) partonfs.acceptIdPair(i);
	partonfs.acceptId(PID::GLUON);
	- addProjection(FastJets(partonfs, FastJets::KT, 0.6), "Jets");
	+ declare(FastJets(partonfs, FastJets::KT, 0.6), "Jets");

	MC_JetSplittings::init();
	}



	/// Perform the per-event analysis
	void analyze(const Event& event) {
	MC_JetSplittings::analyze(event);
	}



	/// Finalize
	void finalize() {
	MC_JetSplittings::finalize();
	}

	//@}


	private:

	/// @name Histograms
	//@{
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_QCD_PARTONS);

	}
	diff --git a/src/Analyses/MC_SUSY.cc b/src/Analyses/MC_SUSY.cc
	--- a/src/Analyses/MC_SUSY.cc
	+++ b/src/Analyses/MC_SUSY.cc
	@@ -1,321 +1,321 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/LeadingParticlesFinalState.hh"

	namespace Rivet {




	/// @brief MC validation analysis for SUSY events
	/// @author Andy Buckley
	class MC_SUSY : public Analysis {
	public:

	/// Constructor
	MC_SUSY()
	: Analysis("MC_SUSY")
	{ }


	/// @name Analysis methods
	//@{

	// Book histograms
	void init() {
	// Basic final state
	const FinalState fs(-4.0, 4.0, 10*GeV);

	// Tracks and jets
	- addProjection(ChargedFinalState(fs), "Tracks");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.7), "Jets");
	+ declare(ChargedFinalState(fs), "Tracks");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.7), "Jets");

	IdentifiedFinalState photonfs(fs);
	photonfs.acceptId(PID::PHOTON);
	- addProjection(photonfs, "AllPhotons");
	+ declare(photonfs, "AllPhotons");

	IdentifiedFinalState efs(fs);
	efs.acceptIdPair(PID::ELECTRON);
	- addProjection(efs, "Electrons");
	+ declare(efs, "Electrons");

	IdentifiedFinalState mufs(fs);
	mufs.acceptIdPair(PID::MUON);
	- addProjection(mufs, "Muons");
	+ declare(mufs, "Muons");

	MissingMomentum missing(fs);
	- addProjection(missing, "MET");
	+ declare(missing, "MET");

	LeadingParticlesFinalState lpfs(fs);
	lpfs.addParticleIdPair(PID::ELECTRON);
	lpfs.addParticleIdPair(PID::MUON);
	- addProjection(lpfs, "LeadingParticles");
	+ declare(lpfs, "LeadingParticles");

	_hist_n_trk = bookHisto1D("n-trk", 50, 0.5, 300.5);
	_hist_phi_trk = bookHisto1D("phi-trk", 50, -PI, PI);
	_hist_eta_trk = bookHisto1D("eta-trk", 50, -4, 4);
	_hist_pt_trk = bookHisto1D("pt-trk", 100, 0.0, 1500);

	_hist_n_jet = bookHisto1D("n-jet", 21, -0.5, 20.5);
	_hist_phi_jet = bookHisto1D("phi-jet", 50, -PI, PI);
	_hist_eta_jet = bookHisto1D("eta-jet", 50, -4, 4);
	_hist_pt_jet = bookHisto1D("pt-jet", 100, 0.0, 1500);

	_hist_n_e = bookHisto1D("n-e", 11, -0.5, 10.5);
	_hist_phi_e = bookHisto1D("phi-e", 50, -PI, PI);
	_hist_eta_e = bookHisto1D("eta-e", 50, -4, 4);
	_hist_pt_e = bookHisto1D("pt-e", 100, 0.0, 500);

	_hist_n_mu = bookHisto1D("n-mu", 11, -0.5, 10.5);
	_hist_phi_mu = bookHisto1D("phi-mu", 50, -PI, PI);
	_hist_eta_mu = bookHisto1D("eta-mu", 50, -4, 4);
	_hist_pt_mu = bookHisto1D("pt-mu", 100, 0.0, 500);

	_hist_n_gamma = bookHisto1D("n-gamma", 11, -0.5, 10.5);
	_hist_phi_gamma = bookHisto1D("phi-gamma", 50, -PI, PI);
	_hist_eta_gamma = bookHisto1D("eta-gamma", 50, -4, 4);
	_hist_pt_gamma = bookHisto1D("pt-gamma", 100, 0.0, 500);

	_hist_n_gammaiso = bookHisto1D("n-gamma-iso", 11, -0.5, 10.5);
	_hist_phi_gammaiso = bookHisto1D("phi-gamma-iso", 50, -PI, PI);
	_hist_eta_gammaiso = bookHisto1D("eta-gamma-iso", 50, -4, 4);
	_hist_pt_gammaiso = bookHisto1D("pt-gamma-iso", 100, 0.0, 500);

	_hist_met = bookHisto1D("Etmiss", 100, 0.0, 1500);

	_hist_mll_ossf_ee = bookHisto1D("mll-ossf-ee", 50, 0.0, 500);
	_hist_mll_ossf_mumu = bookHisto1D("mll-ossf-mumu", 50, 0.0, 500);
	_hist_mll_osof_emu = bookHisto1D("mll-osof-emu", 50, 0.0, 500);

	_hist_mll_all_ossf_ee = bookHisto1D("mll-all-ossf-ee", 50, 0.0, 500);
	_hist_mll_all_ossf_mumu = bookHisto1D("mll-all-ossf-mumu", 50, 0.0, 500);
	_hist_mll_all_osof_emu = bookHisto1D("mll-all-osof-emu", 50, 0.0, 500);

	_hist_mll_2_ossf_ee = bookHisto1D("mll-2-ossf-ee", 50, 0.0, 500);
	_hist_mll_2_ossf_mumu = bookHisto1D("mll-2-ossf-mumu", 50, 0.0, 500);
	_hist_mll_2_osof_emu = bookHisto1D("mll-2-osof-emu", 50, 0.0, 500);

	/// @todo LSP eta, pT, phi, mass: no reliable cross-scenario LSP PID but
	/// maybe plot for all of chi^0_1, gravitino, sneutrino, gluino, ... or
	/// identify the LSP as any PID::isSUSY (?) particle with status = 1?
	}


	// Do the analysis
	void analyze(const Event& evt) {
	- const FinalState& tracks = applyProjection<FinalState>(evt, "Tracks");
	+ const FinalState& tracks = apply<FinalState>(evt, "Tracks");
	if (tracks.particles().empty()) {
	MSG_DEBUG("Failed multiplicity cut");
	vetoEvent;
	}

	// Get event weight
	const double weight = evt.weight();

	// Fill track histos
	_hist_n_trk->fill(tracks.size(), weight);
	foreach (const Particle& t, tracks.particles()) {
	const FourMomentum& p = t.momentum();
	_hist_phi_trk->fill(mapAngleMPiToPi(p.phi()), weight);
	_hist_eta_trk->fill(p.eta(), weight);
	_hist_pt_trk->fill(p.pT()/GeV, weight);
	}

	// Get jets and fill jet histos
	- const FastJets& jetpro = applyProjection<FastJets>(evt, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(evt, "Jets");
	const Jets jets = jetpro.jetsByPt();
	MSG_DEBUG("Jet multiplicity = " << jets.size());
	_hist_n_jet->fill(jets.size(), weight);
	foreach (const Jet& j, jets) {
	const FourMomentum& pj = j.momentum();
	_hist_phi_jet->fill(mapAngleMPiToPi(pj.phi()), weight);
	_hist_eta_jet->fill(pj.eta(), weight);
	_hist_pt_jet->fill(pj.pT()/GeV, weight);
	}

	/// @todo Resum photons around electrons

	// Fill final state electron/positron histos
	- const FinalState& efs = applyProjection<FinalState>(evt, "Electrons");
	+ const FinalState& efs = apply<FinalState>(evt, "Electrons");
	_hist_n_e->fill(efs.size(), weight);
	vector<FourMomentum> epluses, eminuses;
	foreach (const Particle& e, efs.particles()) {
	const FourMomentum& p = e.momentum();
	_hist_phi_e->fill(mapAngleMPiToPi(p.phi()), weight);
	_hist_eta_e->fill(p.eta(), weight);
	_hist_pt_e->fill(p.pT()/GeV, weight);
	// Add sufficiently hard leptons to collections for m_ll histo
	if (p.pT()/GeV > 20) {
	if (PID::threeCharge(e.pid()) > 0) epluses += p; else eminuses += p;
	}
	}

	/// @todo Resum photons around muons

	// Fill final state muon/antimuon histos
	- const FinalState& mufs = applyProjection<FinalState>(evt, "Muons");
	+ const FinalState& mufs = apply<FinalState>(evt, "Muons");
	_hist_n_mu->fill(mufs.size(), weight);
	vector<FourMomentum> mupluses, muminuses;
	foreach (const Particle& mu, mufs.particles()) {
	const FourMomentum& p = mu.momentum();
	_hist_phi_mu->fill(mapAngleMPiToPi(p.phi()), weight);
	_hist_eta_mu->fill(p.eta(), weight);
	_hist_pt_mu->fill(p.pT()/GeV, weight);
	// Add sufficiently hard leptons to collections for m_ll histo
	if (p.pT()/GeV > 20) {
	if (PID::threeCharge(mu.pid()) > 0) mupluses += p; else muminuses += p;
	}
	}

	// Fill final state non-isolated photon histos
	- const FinalState& allphotonfs = applyProjection<FinalState>(evt, "AllPhotons");
	+ const FinalState& allphotonfs = apply<FinalState>(evt, "AllPhotons");
	_hist_n_gamma->fill(allphotonfs.size(), weight);
	Particles isolatedphotons;
	foreach (const Particle& ph, allphotonfs.particles()) {
	const FourMomentum& p = ph.momentum();
	_hist_phi_gamma->fill(mapAngleMPiToPi(p.phi()), weight);
	_hist_eta_gamma->fill(p.eta(), weight);
	_hist_pt_gamma->fill(p.pT()/GeV, weight);
	// Select isolated photons
	bool isolated = true;
	foreach (const Jet& j, jets) {
	if (deltaR(j.momentum(), p) < 0.2) {
	isolated = false;
	break;
	}
	}
	if (isolated) isolatedphotons += ph;
	}


	// Fill final state isolated photon histos
	_hist_n_gammaiso->fill(isolatedphotons.size(), weight);
	foreach (const Particle& ph_iso, isolatedphotons) {
	const FourMomentum& p = ph_iso.momentum();
	_hist_phi_gammaiso->fill(mapAngleMPiToPi(p.phi()), weight);
	_hist_eta_gammaiso->fill(p.eta(), weight);
	_hist_pt_gammaiso->fill(p.pT()/GeV, weight);
	}

	// Calculate and fill missing Et histos
	- const MissingMomentum& met = applyProjection<MissingMomentum>(evt, "MET");
	+ const MissingMomentum& met = apply<MissingMomentum>(evt, "MET");
	_hist_met->fill(met.vectorEt().mod()/GeV);

	// Choose highest-pT leptons of each sign and flavour for dilepton mass edges
	- const FinalState& lpfs = applyProjection<FinalState>(evt, "LeadingParticles");
	+ const FinalState& lpfs = apply<FinalState>(evt, "LeadingParticles");
	bool eplus_ok(false), eminus_ok(false), muplus_ok(false), muminus_ok(false);
	FourMomentum peplus, peminus, pmuplus, pmuminus;
	foreach (const Particle& p, lpfs.particles()) {
	// Only use leptons above 20 GeV
	if (p.pT()/GeV < 20) continue;
	// Identify the PID
	const PdgId pid = p.pid();
	if (pid == PID::ELECTRON) {
	eminus_ok = true;
	peminus = p.momentum();
	} else if (pid == PID::POSITRON) {
	eplus_ok = true;
	peplus = p.momentum();
	} else if (pid == PID::MUON) {
	muminus_ok = true;
	pmuminus = p.momentum();
	} else if (pid == PID::ANTIMUON) {
	muplus_ok = true;
	pmuplus = p.momentum();
	} else {
	throw Error("Unexpected particle type in leading particles FS!");
	}
	}
	// m_ee
	if (eminus_ok && eplus_ok) {
	const double m_ee = FourMomentum(peplus + peminus).mass();
	_hist_mll_ossf_ee->fill(m_ee/GeV, weight);
	if (epluses.size() == 1 && eminuses.size() == 1)
	_hist_mll_2_ossf_ee->fill(m_ee/GeV, weight);
	}
	// m_mumu
	if (muminus_ok && muplus_ok) {
	const double m_mumu = FourMomentum(pmuplus + pmuminus).mass();
	_hist_mll_ossf_mumu->fill(m_mumu/GeV, weight);
	if (mupluses.size() == 1 && muminuses.size() == 1)
	_hist_mll_2_ossf_mumu->fill(m_mumu/GeV, weight);
	}
	// m_emu (both configurations)
	if (eminus_ok && muplus_ok) {
	const double m_emu = FourMomentum(pmuplus + peminus).mass();
	_hist_mll_osof_emu->fill(m_emu/GeV, weight);
	if (mupluses.size() == 1 && eminuses.size() == 1)
	_hist_mll_2_osof_emu->fill(m_emu/GeV, weight);

	}
	if (muminus_ok && eplus_ok) {
	const double m_mue = FourMomentum(peplus + pmuminus).mass();
	_hist_mll_osof_emu->fill(m_mue/GeV, weight);
	if (epluses.size() == 1 && muminuses.size() == 1)
	_hist_mll_2_osof_emu->fill(m_mue/GeV, weight);
	}


	// m_ll plots using all electrons, positrons, muons and antimuons
	// m_ee
	foreach (const FourMomentum& peplus, epluses) {
	foreach (const FourMomentum& peminus, eminuses) {
	const double m_ee = FourMomentum(peplus + peminus).mass();
	_hist_mll_all_ossf_ee->fill(m_ee/GeV, weight);
	}
	}
	// m_mumu
	foreach (const FourMomentum& pmuplus, mupluses) {
	foreach (const FourMomentum& pmuminus, muminuses) {
	const double m_mumu = FourMomentum(pmuplus + pmuminus).mass();
	_hist_mll_all_ossf_mumu->fill(m_mumu/GeV, weight);
	}
	}
	// m_emu (both configurations)
	foreach (const FourMomentum& pmuplus, mupluses) {
	foreach (const FourMomentum& peminus, eminuses) {
	const double m_emu = FourMomentum(pmuplus + peminus).mass();
	_hist_mll_all_osof_emu->fill(m_emu/GeV, weight);
	}
	}
	foreach (const FourMomentum& peplus, epluses) {
	foreach (const FourMomentum& pmuminus, muminuses) {
	const double m_mue = FourMomentum(peplus + pmuminus).mass();
	_hist_mll_all_osof_emu->fill(m_mue/GeV, weight);
	}
	}

	}


	void finalize() {
	/// @todo Normalisations
	}

	//@}


	private:

	Histo1DPtr _hist_n_trk, _hist_phi_trk, _hist_eta_trk, _hist_pt_trk;
	Histo1DPtr _hist_n_jet, _hist_phi_jet, _hist_eta_jet, _hist_pt_jet;
	Histo1DPtr _hist_n_e, _hist_phi_e, _hist_eta_e, _hist_pt_e;
	Histo1DPtr _hist_n_mu, _hist_phi_mu, _hist_eta_mu, _hist_pt_mu;
	Histo1DPtr _hist_n_gamma, _hist_phi_gamma, _hist_eta_gamma, _hist_pt_gamma;
	Histo1DPtr _hist_n_gammaiso, _hist_phi_gammaiso, _hist_eta_gammaiso, _hist_pt_gammaiso;
	Histo1DPtr _hist_met;
	Histo1DPtr _hist_mll_2_ossf_ee, _hist_mll_2_ossf_mumu, _hist_mll_2_osof_emu;
	Histo1DPtr _hist_mll_ossf_ee, _hist_mll_ossf_mumu, _hist_mll_osof_emu;
	Histo1DPtr _hist_mll_all_ossf_ee, _hist_mll_all_ossf_mumu, _hist_mll_all_osof_emu;
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_SUSY);

	}
	diff --git a/src/Analyses/MC_TAUS.cc b/src/Analyses/MC_TAUS.cc
	--- a/src/Analyses/MC_TAUS.cc
	+++ b/src/Analyses/MC_TAUS.cc
	@@ -1,44 +1,44 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_ParticleAnalysis.hh"
	#include "Rivet/Projections/TauFinder.hh"

	namespace Rivet {


	/// @brief MC validation analysis for taus
	class MC_TAUS : public MC_ParticleAnalysis {
	public:

	MC_TAUS()
	: MC_ParticleAnalysis("MC_TAUS", 2, "tau")
	{ }


	public:

	void init() {
	IdentifiedFinalState taus;
	taus.acceptIdPair(PID::TAU);
	- addProjection(taus, "Taus");
	+ declare(taus, "Taus");

	MC_ParticleAnalysis::init();
	}


	void analyze(const Event& event) {
	- const Particles taus = applyProjection<TauFinder>(event, "Taus").particlesByPt(0.5*GeV);
	+ const Particles taus = apply<TauFinder>(event, "Taus").particlesByPt(0.5*GeV);
	MC_ParticleAnalysis::_analyze(event, taus);
	}


	void finalize() {
	MC_ParticleAnalysis::finalize();
	}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_TAUS);

	}
	diff --git a/src/Analyses/MC_TTBAR.cc b/src/Analyses/MC_TTBAR.cc
	--- a/src/Analyses/MC_TTBAR.cc
	+++ b/src/Analyses/MC_TTBAR.cc
	@@ -1,300 +1,300 @@
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/ChargedLeptons.hh"
	#include "Rivet/Projections/MissingMomentum.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/AnalysisLoader.hh"

	namespace Rivet {




	class MC_TTBAR : public Analysis {
	public:

	/// Minimal constructor
	MC_TTBAR() : Analysis("MC_TTBAR")
	{
	}


	/// @name Analysis methods
	//@{

	/// Set up projections and book histograms
	void init() {

	// A FinalState is used to select particles within \|eta\| < 4.2 and with pT
	// > 30 GeV, out of which the ChargedLeptons projection picks only the
	// electrons and muons, to be accessed later as "LFS".
	ChargedLeptons lfs(FinalState(-4.2, 4.2, 30*GeV));
	- addProjection(lfs, "LFS");
	+ declare(lfs, "LFS");
	// A second FinalState is used to select all particles in \|eta\| < 4.2,
	// with no pT cut. This is used to construct jets and measure missing
	// transverse energy.
	VetoedFinalState fs(FinalState(-4.2, 4.2, 0*GeV));
	fs.addVetoOnThisFinalState(lfs);
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.6), "Jets");
	- addProjection(MissingMomentum(fs), "MissingET");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.6), "Jets");
	+ declare(MissingMomentum(fs), "MissingET");

	// Booking of histograms
	_h_njets = bookHisto1D("jet_mult", 11, -0.5, 10.5);
	//
	_h_jet_1_pT = bookHisto1D("jet_1_pT", logspace(50, 20.0, 500.0));
	_h_jet_2_pT = bookHisto1D("jet_2_pT", logspace(50, 20.0, 400.0));
	_h_jet_3_pT = bookHisto1D("jet_3_pT", logspace(50, 20.0, 300.0));
	_h_jet_4_pT = bookHisto1D("jet_4_pT", logspace(50, 20.0, 200.0));
	_h_jet_HT = bookHisto1D("jet_HT", logspace(50, 100.0, 2000.0));
	//
	_h_bjet_1_pT = bookHisto1D("jetb_1_pT", logspace(50, 20.0, 400.0));
	_h_bjet_2_pT = bookHisto1D("jetb_2_pT", logspace(50, 20.0, 300.0));
	//
	_h_ljet_1_pT = bookHisto1D("jetl_1_pT", logspace(50, 20.0, 400.0));
	_h_ljet_2_pT = bookHisto1D("jetl_2_pT", logspace(50, 20.0, 300.0));
	//
	_h_W_mass = bookHisto1D("W_mass", 75, 30, 180);
	_h_t_mass = bookHisto1D("t_mass", 150, 130, 430);
	_h_t_mass_W_cut = bookHisto1D("t_mass_W_cut", 150, 130, 430);
	//
	_h_jetb_1_jetb_2_dR = bookHisto1D("jetb_1_jetb_2_dR", 20, 0.0, 7.0);
	_h_jetb_1_jetb_2_deta = bookHisto1D("jetb_1_jetb_2_deta", 20, 0.0, 7.0);
	_h_jetb_1_jetb_2_dphi = bookHisto1D("jetb_1_jetb_2_dphi", 20, 0.0, M_PI);
	_h_jetb_1_jetl_1_dR = bookHisto1D("jetb_1_jetl_1_dR", 20, 0.0, 7.0);
	_h_jetb_1_jetl_1_deta = bookHisto1D("jetb_1_jetl_1_deta", 20, 0.0, 7.0);
	_h_jetb_1_jetl_1_dphi = bookHisto1D("jetb_1_jetl_1_dphi", 20, 0.0, M_PI);
	_h_jetl_1_jetl_2_dR = bookHisto1D("jetl_1_jetl_2_dR", 20, 0.0, 7.0);
	_h_jetl_1_jetl_2_deta = bookHisto1D("jetl_1_jetl_2_deta", 20, 0.0, 7.0);
	_h_jetl_1_jetl_2_dphi = bookHisto1D("jetl_1_jetl_2_dphi", 20, 0.0, M_PI);
	_h_jetb_1_W_dR = bookHisto1D("jetb_1_W_dR", 20, 0.0, 7.0);
	_h_jetb_1_W_deta = bookHisto1D("jetb_1_W_deta", 20, 0.0, 7.0);
	_h_jetb_1_W_dphi = bookHisto1D("jetb_1_W_dphi", 20, 0.0, M_PI);
	_h_jetb_1_l_dR = bookHisto1D("jetb_1_l_dR", 20, 0.0, 7.0);
	_h_jetb_1_l_deta = bookHisto1D("jetb_1_l_deta", 20, 0.0, 7.0);
	_h_jetb_1_l_dphi = bookHisto1D("jetb_1_l_dphi", 20, 0.0, M_PI);
	_h_jetb_1_l_mass = bookHisto1D("jetb_1_l_mass", 40, 0.0, 500.0);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	// Use the "LFS" projection to require at least one hard charged
	// lepton. This is an experimental signature for the leptonically decaying
	// W. This helps to reduce pure QCD backgrounds.
	- const ChargedLeptons& lfs = applyProjection<ChargedLeptons>(event, "LFS");
	+ const ChargedLeptons& lfs = apply<ChargedLeptons>(event, "LFS");
	MSG_DEBUG("Charged lepton multiplicity = " << lfs.chargedLeptons().size());
	foreach (const Particle& lepton, lfs.chargedLeptons()) {
	MSG_DEBUG("Lepton pT = " << lepton.pT());
	}
	if (lfs.chargedLeptons().empty()) {
	MSG_DEBUG("Event failed lepton multiplicity cut");
	vetoEvent;
	}

	// Use a missing ET cut to bias toward events with a hard neutrino from
	// the leptonically decaying W. This helps to reduce pure QCD backgrounds.
	- const MissingMomentum& met = applyProjection<MissingMomentum>(event, "MissingET");
	+ const MissingMomentum& met = apply<MissingMomentum>(event, "MissingET");
	MSG_DEBUG("Vector ET = " << met.vectorEt().mod() << " GeV");
	if (met.vectorEt().mod() < 30*GeV) {
	MSG_DEBUG("Event failed missing ET cut");
	vetoEvent;
	}

	// Use the "Jets" projection to check that there are at least 4 jets of
	// any pT. Getting the jets sorted by pT ensures that the first jet is the
	// hardest, and so on. We apply no pT cut here only because we want to
	// plot all jet pTs to help optimise our jet pT cut.
	- const FastJets& jetpro = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& jetpro = apply<FastJets>(event, "Jets");
	const Jets alljets = jetpro.jetsByPt();
	if (alljets.size() < 4) {
	MSG_DEBUG("Event failed jet multiplicity cut");
	vetoEvent;
	}

	// Update passed-cuts counter and fill all-jets histograms
	_h_jet_1_pT->fill(alljets[0].pT()/GeV, weight);
	_h_jet_2_pT->fill(alljets[1].pT()/GeV, weight);
	_h_jet_3_pT->fill(alljets[2].pT()/GeV, weight);
	_h_jet_4_pT->fill(alljets[3].pT()/GeV, weight);

	// Insist that the hardest 4 jets pass pT hardness cuts. If we don't find
	// at least 4 such jets, we abandon this event.
	const Jets jets = jetpro.jetsByPt(30*GeV);
	_h_njets->fill(jets.size(), weight);
	double ht = 0.0;
	foreach (const Jet& j, jets) { ht += j.pT(); }
	_h_jet_HT->fill(ht/GeV, weight);
	if (jets.size() < 4 \|\|
	jets[0].pT() < 60*GeV \|\|
	jets[1].pT() < 50*GeV \|\|
	jets[3].pT() < 30*GeV) {
	MSG_DEBUG("Event failed jet cuts");
	vetoEvent;
	}

	// Sort the jets into b-jets and light jets. We expect one hard b-jet from
	// each top decay, so our 4 hardest jets should include two b-jets. The
	// Jet::bTagged() method is equivalent to perfect experimental
	// b-tagging, in a generator-independent way.
	Jets bjets, ljets;
	foreach (const Jet& jet, jets) {
	// // Don't count jets that overlap with the hard leptons
	bool isolated = true;
	foreach (const Particle& lepton, lfs.chargedLeptons()) {
	if (deltaR(jet.momentum(), lepton.momentum()) < 0.3) {
	isolated = false;
	break;
	}
	}
	if (!isolated) {
	MSG_DEBUG("Jet failed lepton isolation cut");
	break;
	}
	if (jet.bTagged()) {
	bjets.push_back(jet);
	} else {
	ljets.push_back(jet);
	}
	}
	MSG_DEBUG("Number of b-jets = " << bjets.size());
	MSG_DEBUG("Number of l-jets = " << ljets.size());
	if (bjets.size() != 2) {
	MSG_DEBUG("Event failed post-lepton-isolation b-tagging cut");
	vetoEvent;
	}
	if (ljets.size() < 2) {
	MSG_DEBUG("Event failed since not enough light jets remaining after lepton-isolation");
	vetoEvent;
	}

	// Plot the pTs of the identified jets.
	_h_bjet_1_pT->fill(bjets[0].pT(), weight);
	_h_bjet_2_pT->fill(bjets[1].pT(), weight);
	_h_ljet_1_pT->fill(ljets[0].pT(), weight);
	_h_ljet_2_pT->fill(ljets[1].pT(), weight);

	// Construct the hadronically decaying W momentum 4-vector from pairs of
	// non-b-tagged jets. The pair which best matches the W mass is used. We start
	// with an always terrible 4-vector estimate which should always be "beaten" by
	// a real jet pair.
	FourMomentum W(10*(sqrtS()>0.?sqrtS():14000.), 0, 0, 0);
	for (size_t i = 0; i < ljets.size()-1; ++i) {
	for (size_t j = i + 1; j < ljets.size(); ++j) {
	const FourMomentum Wcand = ljets[i].momentum() + ljets[j].momentum();
	MSG_TRACE(i << "," << j << ": candidate W mass = " << Wcand.mass()/GeV
	<< " GeV, vs. incumbent candidate with " << W.mass()/GeV << " GeV");
	if (fabs(Wcand.mass() - 80.4GeV) < fabs(W.mass() - 80.4GeV)) {
	W = Wcand;
	}
	}
	}
	MSG_DEBUG("Candidate W mass = " << W.mass() << " GeV");

	// There are two b-jets with which this can be combined to make the
	// hadronically decaying top, one of which is correct and the other is
	// not... but we have no way to identify which is which, so we construct
	// both possible top momenta and fill the histograms with both.
	const FourMomentum t1 = W + bjets[0].momentum();
	const FourMomentum t2 = W + bjets[1].momentum();
	_h_W_mass->fill(W.mass(), weight);
	_h_t_mass->fill(t1.mass(), weight);
	_h_t_mass->fill(t2.mass(), weight);

	// Placing a cut on the well-known W mass helps to reduce backgrounds
	if (inRange(W.mass()/GeV, 75.0, 85.0)) {
	MSG_DEBUG("W found with mass " << W.mass()/GeV << " GeV");
	_h_t_mass_W_cut->fill(t1.mass(), weight);
	_h_t_mass_W_cut->fill(t2.mass(), weight);

	_h_jetb_1_jetb_2_dR->fill(deltaR(bjets[0].momentum(), bjets[1].momentum()),weight);
	_h_jetb_1_jetb_2_deta->fill(fabs(bjets[0].eta()-bjets[1].eta()),weight);
	_h_jetb_1_jetb_2_dphi->fill(deltaPhi(bjets[0].momentum(),bjets[1].momentum()),weight);

	_h_jetb_1_jetl_1_dR->fill(deltaR(bjets[0].momentum(), ljets[0].momentum()),weight);
	_h_jetb_1_jetl_1_deta->fill(fabs(bjets[0].eta()-ljets[0].eta()),weight);
	_h_jetb_1_jetl_1_dphi->fill(deltaPhi(bjets[0].momentum(),ljets[0].momentum()),weight);

	_h_jetl_1_jetl_2_dR->fill(deltaR(ljets[0].momentum(), ljets[1].momentum()),weight);
	_h_jetl_1_jetl_2_deta->fill(fabs(ljets[0].eta()-ljets[1].eta()),weight);
	_h_jetl_1_jetl_2_dphi->fill(deltaPhi(ljets[0].momentum(),ljets[1].momentum()),weight);

	_h_jetb_1_W_dR->fill(deltaR(bjets[0].momentum(), W),weight);
	_h_jetb_1_W_deta->fill(fabs(bjets[0].eta()-W.eta()),weight);
	_h_jetb_1_W_dphi->fill(deltaPhi(bjets[0].momentum(),W),weight);

	FourMomentum l=lfs.chargedLeptons()[0].momentum();
	_h_jetb_1_l_dR->fill(deltaR(bjets[0].momentum(), l),weight);
	_h_jetb_1_l_deta->fill(fabs(bjets[0].eta()-l.eta()),weight);
	_h_jetb_1_l_dphi->fill(deltaPhi(bjets[0].momentum(),l),weight);
	_h_jetb_1_l_mass->fill(FourMomentum(bjets[0].momentum()+l).mass(), weight);
	}

	}


	void finalize() {
	normalize(_h_njets);
	normalize(_h_jet_1_pT);
	normalize(_h_jet_2_pT);
	normalize(_h_jet_3_pT);
	normalize(_h_jet_4_pT);
	normalize(_h_jet_HT);
	normalize(_h_bjet_1_pT);
	normalize(_h_bjet_2_pT);
	normalize(_h_ljet_1_pT);
	normalize(_h_ljet_2_pT);
	normalize(_h_W_mass);
	normalize(_h_t_mass);
	normalize(_h_t_mass_W_cut);
	normalize(_h_jetb_1_jetb_2_dR);
	normalize(_h_jetb_1_jetb_2_deta);
	normalize(_h_jetb_1_jetb_2_dphi);
	normalize(_h_jetb_1_jetl_1_dR);
	normalize(_h_jetb_1_jetl_1_deta);
	normalize(_h_jetb_1_jetl_1_dphi);
	normalize(_h_jetl_1_jetl_2_dR);
	normalize(_h_jetl_1_jetl_2_deta);
	normalize(_h_jetl_1_jetl_2_dphi);
	normalize(_h_jetb_1_W_dR);
	normalize(_h_jetb_1_W_deta);
	normalize(_h_jetb_1_W_dphi);
	normalize(_h_jetb_1_l_dR);
	normalize(_h_jetb_1_l_deta);
	normalize(_h_jetb_1_l_dphi);
	normalize(_h_jetb_1_l_mass);
	}

	//@}


	private:

	// @name Histogram data members
	//@{

	Histo1DPtr _h_njets;
	Histo1DPtr _h_jet_1_pT, _h_jet_2_pT, _h_jet_3_pT, _h_jet_4_pT;
	Histo1DPtr _h_jet_HT;
	Histo1DPtr _h_bjet_1_pT, _h_bjet_2_pT;
	Histo1DPtr _h_ljet_1_pT, _h_ljet_2_pT;
	Histo1DPtr _h_W_mass;
	Histo1DPtr _h_t_mass, _h_t_mass_W_cut;
	Histo1DPtr _h_jetb_1_jetb_2_dR, _h_jetb_1_jetb_2_deta, _h_jetb_1_jetb_2_dphi;
	Histo1DPtr _h_jetb_1_jetl_1_dR, _h_jetb_1_jetl_1_deta, _h_jetb_1_jetl_1_dphi;
	Histo1DPtr _h_jetl_1_jetl_2_dR, _h_jetl_1_jetl_2_deta, _h_jetl_1_jetl_2_dphi;
	Histo1DPtr _h_jetb_1_W_dR, _h_jetb_1_W_deta, _h_jetb_1_W_dphi;
	Histo1DPtr _h_jetb_1_l_dR, _h_jetb_1_l_deta, _h_jetb_1_l_dphi,_h_jetb_1_l_mass;


	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_TTBAR);

	}
	diff --git a/src/Analyses/MC_VH2BB.cc b/src/Analyses/MC_VH2BB.cc
	--- a/src/Analyses/MC_VH2BB.cc
	+++ b/src/Analyses/MC_VH2BB.cc
	@@ -1,271 +1,262 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Math/LorentzTrans.hh"
	-#include "Rivet/Math/Constants.hh"
	-#include <cmath>
	-#include <vector>

	namespace Rivet {


	class MC_VH2BB : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	MC_VH2BB()
	: Analysis("MC_VH2BB")
	{ }

	//@}


	- public:
	-
	/// @name Analysis methods
	//@{

	- vector<double> boostAngles(const FourMomentum& b1, const FourMomentum& b2, const FourMomentum& vb){
	-
	- // This should take in the four-momenta of two b's (jets/hadrons) and a vector boson, for the process VB*->VBH with H->bb
	- // It should return the smallest angle between the virtual vector boson and one of the b's, in the rest frame of the Higgs boson.
	- // It should also return (as the second element of the vector) the angle between the b's, in the rest frame of the Higgs boson.
	-
	- FourMomentum higgsMomentum = b1 + b2;
	- FourMomentum virtualVBMomentum = higgsMomentum + vb;
	-
	- LorentzTransform lt( -higgsMomentum.boostVector() );
	-
	- FourMomentum virtualVBMomentumBOOSTED = lt.transform(virtualVBMomentum);
	- FourMomentum b1BOOSTED = lt.transform(b1);
	- FourMomentum b2BOOSTED = lt.transform(b2);
	-
	- double angle1 = b1BOOSTED.angle(virtualVBMomentumBOOSTED);
	- double angle2 = b2BOOSTED.angle(virtualVBMomentumBOOSTED);
	-
	- double anglebb = b1BOOSTED.angle(b2BOOSTED);
	-
	- vector<double> toReturn;
	- toReturn.push_back(angle1 < angle2 ? angle1 : angle2);
	- toReturn.push_back(anglebb);
	-
	- return toReturn;
	- }
	-
	-
	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	ZFinder zeefinder(fs, cut, PID::ELECTRON, 65GeV, 115GeV, 0.2);
	- addProjection(zeefinder, "ZeeFinder");
	+ declare(zeefinder, "ZeeFinder");
	ZFinder zmmfinder(fs, cut, PID::MUON, 65GeV, 115GeV, 0.2);
	- addProjection(zmmfinder, "ZmmFinder");
	+ declare(zmmfinder, "ZmmFinder");
	WFinder wefinder(fs, cut, PID::ELECTRON, 60GeV, 100GeV, 25*GeV, 0.2);
	- addProjection(wefinder, "WeFinder");
	+ declare(wefinder, "WeFinder");
	WFinder wmfinder(fs, cut, PID::MUON, 60GeV, 100GeV, 25*GeV, 0.2);
	- addProjection(wmfinder, "WmFinder");
	+ declare(wmfinder, "WmFinder");

	- addProjection(fs, "FinalState");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.4), "AntiKT04");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.5), "AntiKT05");
	- addProjection(FastJets(fs, FastJets::ANTIKT, 0.6), "AntiKT06");
	+ declare(fs, "FinalState");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.4), "AntiKT04");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.5), "AntiKT05");
	+ declare(FastJets(fs, FastJets::ANTIKT, 0.6), "AntiKT06");

	/// Book histograms
	_h_jet_bb_Delta_eta = bookHisto1D("jet_bb_Delta_eta", 50, 0, 4);
	_h_jet_bb_Delta_phi = bookHisto1D("jet_bb_Delta_phi", 50, 0, M_PI);
	_h_jet_bb_Delta_pT = bookHisto1D("jet_bb_Delta_pT", 50,0, 500);
	_h_jet_bb_Delta_R = bookHisto1D("jet_bb_Delta_R", 50, 0, 5);
	_h_jet_b_jet_eta = bookHisto1D("jet_b_jet_eta", 50, -4, 4);
	_h_jet_b_jet_multiplicity = bookHisto1D("jet_b_jet_multiplicity", 11, -0.5, 10.5);
	_h_jet_b_jet_phi = bookHisto1D("jet_b_jet_phi", 50, 0, 2.*M_PI);
	_h_jet_b_jet_pT = bookHisto1D("jet_b_jet_pT", 50, 0, 500);
	_h_jet_H_eta_using_bb = bookHisto1D("jet_H_eta_using_bb", 50, -4, 4);
	_h_jet_H_mass_using_bb = bookHisto1D("jet_H_mass_using_bb", 50, 50, 200);
	_h_jet_H_phi_using_bb = bookHisto1D("jet_H_phi_using_bb", 50, 0, 2.*M_PI);
	_h_jet_H_pT_using_bb = bookHisto1D("jet_H_pT_using_bb", 50, 0, 500);
	_h_jet_eta = bookHisto1D("jet_eta", 50, -4, 4);
	_h_jet_multiplicity = bookHisto1D("jet_multiplicity", 11, -0.5, 10.5);
	_h_jet_phi = bookHisto1D("jet_phi", 50, 0, 2.*M_PI);
	_h_jet_pT = bookHisto1D("jet_pT", 50, 0, 500);
	_h_jet_VBbb_Delta_eta = bookHisto1D("jet_VBbb_Delta_eta", 50, 0, 4);
	_h_jet_VBbb_Delta_phi = bookHisto1D("jet_VBbb_Delta_phi", 50, 0, M_PI);
	_h_jet_VBbb_Delta_pT = bookHisto1D("jet_VBbb_Delta_pT", 50, 0, 500);
	_h_jet_VBbb_Delta_R = bookHisto1D("jet_VBbb_Delta_R", 50, 0, 8);

	_h_VB_eta = bookHisto1D("VB_eta", 50, -4, 4);
	_h_VB_mass = bookHisto1D("VB_mass", 50, 60, 110);
	_h_Z_multiplicity = bookHisto1D("Z_multiplicity", 11, -0.5, 10.5);
	_h_W_multiplicity = bookHisto1D("W_multiplicity", 11, -0.5, 10.5);
	_h_VB_phi = bookHisto1D("VB_phi", 50, 0, 2.*M_PI);
	_h_VB_pT = bookHisto1D("VB_pT", 50, 0, 500);

	_h_jet_bVB_angle_Hframe = bookHisto1D("jet_bVB_angle_Hframe", 50, 0, M_PI);
	_h_jet_bVB_cosangle_Hframe = bookHisto1D("jet_bVB_cosangle_Hframe", 50, -1, 1);
	_h_jet_bb_angle_Hframe = bookHisto1D("jet_bb_angle_Hframe", 50, 0, M_PI);
	_h_jet_bb_cosangle_Hframe = bookHisto1D("jet_bb_cosangle_Hframe", 50, -1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	const double JETPTCUT = 30*GeV;

	- const ZFinder& zeefinder = applyProjection<ZFinder>(event, "ZeeFinder");
	- const ZFinder& zmmfinder = applyProjection<ZFinder>(event, "ZmmFinder");
	- const WFinder& wefinder = applyProjection<WFinder>(event, "WeFinder");
	- const WFinder& wmfinder = applyProjection<WFinder>(event, "WmFinder");
	+ const ZFinder& zeefinder = apply<ZFinder>(event, "ZeeFinder");
	+ const ZFinder& zmmfinder = apply<ZFinder>(event, "ZmmFinder");
	+ const WFinder& wefinder = apply<WFinder>(event, "WeFinder");
	+ const WFinder& wmfinder = apply<WFinder>(event, "WmFinder");
	const Particles vectorBosons = zeefinder.bosons() + zmmfinder.bosons() + wefinder.bosons() + wmfinder.bosons();
	_h_Z_multiplicity->fill(zeefinder.bosons().size() + zmmfinder.bosons().size(), weight);
	_h_W_multiplicity->fill(wefinder.bosons().size() + wmfinder.bosons().size(), weight);

	- const Jets jets = applyProjection<FastJets>(event, "AntiKT04").jetsByPt(JETPTCUT);
	+ const Jets jets = apply<FastJets>(event, "AntiKT04").jetsByPt(JETPTCUT);
	_h_jet_multiplicity->fill(jets.size(), weight);

	// Identify the b-jets
	Jets bjets;
	foreach (const Jet& jet, jets) {
	const double jetEta = jet.eta();
	const double jetPhi = jet.phi();
	const double jetPt = jet.pT();
	_h_jet_eta->fill(jetEta, weight);
	_h_jet_phi->fill(jetPhi, weight);
	_h_jet_pT->fill(jetPt/GeV, weight);

	if (jet.bTagged() && jet.pT() > JETPTCUT) {
	bjets.push_back(jet);
	_h_jet_b_jet_eta->fill( jetEta , weight );
	_h_jet_b_jet_phi->fill( jetPhi , weight );
	_h_jet_b_jet_pT->fill( jetPt , weight );
	}
	}
	_h_jet_b_jet_multiplicity->fill(bjets.size(), weight);

	// Plot vector boson properties
	foreach (const Particle& v, vectorBosons) {
	_h_VB_phi->fill(v.phi(), weight);
	_h_VB_pT->fill(v.pT(), weight);
	_h_VB_eta->fill(v.eta(), weight);
	_h_VB_mass->fill(v.mass(), weight);
	}

	// rest of analysis requires at least 1 b jets
	if(bjets.empty()) vetoEvent;

	// Construct Higgs candidates from pairs of b-jets
	for (size_t i = 0; i < bjets.size()-1; ++i) {
	for (size_t j = i+1; j < bjets.size(); ++j) {
	const Jet& jet1 = bjets[i];
	const Jet& jet2 = bjets[j];

	const double deltaEtaJJ = fabs(jet1.eta() - jet2.eta());
	const double deltaPhiJJ = deltaPhi(jet1.momentum(), jet2.momentum());
	const double deltaRJJ = deltaR(jet1.momentum(), jet2.momentum());
	const double deltaPtJJ = fabs(jet1.pT() - jet2.pT());
	_h_jet_bb_Delta_eta->fill(deltaEtaJJ, weight);
	_h_jet_bb_Delta_phi->fill(deltaPhiJJ, weight);
	_h_jet_bb_Delta_pT->fill(deltaPtJJ, weight);
	_h_jet_bb_Delta_R->fill(deltaRJJ, weight);

	const FourMomentum phiggs = jet1.momentum() + jet2.momentum();
	_h_jet_H_eta_using_bb->fill(phiggs.eta(), weight);
	_h_jet_H_mass_using_bb->fill(phiggs.mass(), weight);
	_h_jet_H_phi_using_bb->fill(phiggs.phi(), weight);
	_h_jet_H_pT_using_bb->fill(phiggs.pT(), weight);

	foreach (const Particle& v, vectorBosons) {
	const double deltaEtaVH = fabs(phiggs.eta() - v.eta());
	const double deltaPhiVH = deltaPhi(phiggs, v.momentum());
	const double deltaRVH = deltaR(phiggs, v.momentum());
	const double deltaPtVH = fabs(phiggs.pT() - v.pT());
	_h_jet_VBbb_Delta_eta->fill(deltaEtaVH, weight);
	_h_jet_VBbb_Delta_phi->fill(deltaPhiVH, weight);
	_h_jet_VBbb_Delta_pT->fill(deltaPtVH, weight);
	_h_jet_VBbb_Delta_R->fill(deltaRVH, weight);

	// Calculate boost angles
	const vector<double> angles = boostAngles(jet1.momentum(), jet2.momentum(), v.momentum());
	_h_jet_bVB_angle_Hframe->fill(angles[0], weight);
	_h_jet_bb_angle_Hframe->fill(angles[1], weight);
	_h_jet_bVB_cosangle_Hframe->fill(cos(angles[0]), weight);
	_h_jet_bb_cosangle_Hframe->fill(cos(angles[1]), weight);
	}

	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_jet_bb_Delta_eta, crossSection()/sumOfWeights());
	scale(_h_jet_bb_Delta_phi, crossSection()/sumOfWeights());
	scale(_h_jet_bb_Delta_pT, crossSection()/sumOfWeights());
	scale(_h_jet_bb_Delta_R, crossSection()/sumOfWeights());
	scale(_h_jet_b_jet_eta, crossSection()/sumOfWeights());
	scale(_h_jet_b_jet_multiplicity, crossSection()/sumOfWeights());
	scale(_h_jet_b_jet_phi, crossSection()/sumOfWeights());
	scale(_h_jet_b_jet_pT, crossSection()/sumOfWeights());
	scale(_h_jet_H_eta_using_bb, crossSection()/sumOfWeights());
	scale(_h_jet_H_mass_using_bb, crossSection()/sumOfWeights());
	scale(_h_jet_H_phi_using_bb, crossSection()/sumOfWeights());
	scale(_h_jet_H_pT_using_bb, crossSection()/sumOfWeights());
	scale(_h_jet_eta, crossSection()/sumOfWeights());
	scale(_h_jet_multiplicity, crossSection()/sumOfWeights());
	scale(_h_jet_phi, crossSection()/sumOfWeights());
	scale(_h_jet_pT, crossSection()/sumOfWeights());
	scale(_h_jet_VBbb_Delta_eta, crossSection()/sumOfWeights());
	scale(_h_jet_VBbb_Delta_phi, crossSection()/sumOfWeights());
	scale(_h_jet_VBbb_Delta_pT, crossSection()/sumOfWeights());
	scale(_h_jet_VBbb_Delta_R, crossSection()/sumOfWeights());

	scale(_h_VB_eta, crossSection()/sumOfWeights());
	scale(_h_VB_mass, crossSection()/sumOfWeights());
	scale(_h_Z_multiplicity, crossSection()/sumOfWeights());
	scale(_h_W_multiplicity, crossSection()/sumOfWeights());
	scale(_h_VB_phi, crossSection()/sumOfWeights());
	scale(_h_VB_pT, crossSection()/sumOfWeights());

	scale(_h_jet_bVB_angle_Hframe, crossSection()/sumOfWeights());
	scale(_h_jet_bb_angle_Hframe, crossSection()/sumOfWeights());
	scale(_h_jet_bVB_cosangle_Hframe, crossSection()/sumOfWeights());
	scale(_h_jet_bb_cosangle_Hframe, crossSection()/sumOfWeights());
	}

	+
	+ /// This should take in the four-momenta of two b's (jets/hadrons) and a vector boson, for the process VB*->VBH with H->bb
	+ /// It should return the smallest angle between the virtual vector boson and one of the b's, in the rest frame of the Higgs boson.
	+ /// It should also return (as the second element of the vector) the angle between the b's, in the rest frame of the Higgs boson.
	+ vector<double> boostAngles(const FourMomentum& b1, const FourMomentum& b2, const FourMomentum& vb) {
	+ const FourMomentum higgsMomentum = b1 + b2;
	+ const FourMomentum virtualVBMomentum = higgsMomentum + vb;
	+ const LorentzTransform lt = LorentzTransform::mkFrameTransformFromBeta(higgsMomentum.betaVec());
	+
	+ const FourMomentum virtualVBMomentumBOOSTED = lt.transform(virtualVBMomentum);
	+ const FourMomentum b1BOOSTED = lt.transform(b1);
	+ const FourMomentum b2BOOSTED = lt.transform(b2);
	+
	+ const double angle1 = b1BOOSTED.angle(virtualVBMomentumBOOSTED);
	+ const double angle2 = b2BOOSTED.angle(virtualVBMomentumBOOSTED);
	+
	+ const double anglebb = b1BOOSTED.angle(b2BOOSTED);
	+
	+ vector<double> rtn;
	+ rtn.push_back(angle1 < angle2 ? angle1 : angle2);
	+ rtn.push_back(anglebb);
	+ return rtn;
	+ }
	+
	//@}


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_Z_multiplicity, _h_W_multiplicity;
	Histo1DPtr _h_jet_bb_Delta_eta, _h_jet_bb_Delta_phi, _h_jet_bb_Delta_pT, _h_jet_bb_Delta_R;
	Histo1DPtr _h_jet_b_jet_eta, _h_jet_b_jet_multiplicity, _h_jet_b_jet_phi, _h_jet_b_jet_pT;
	Histo1DPtr _h_jet_H_eta_using_bb, _h_jet_H_mass_using_bb, _h_jet_H_phi_using_bb, _h_jet_H_pT_using_bb;
	Histo1DPtr _h_jet_eta, _h_jet_multiplicity, _h_jet_phi, _h_jet_pT;
	Histo1DPtr _h_jet_VBbb_Delta_eta, _h_jet_VBbb_Delta_phi, _h_jet_VBbb_Delta_pT, _h_jet_VBbb_Delta_R;
	Histo1DPtr _h_VB_eta, _h_VB_mass, _h_VB_phi, _h_VB_pT;
	Histo1DPtr _h_jet_bVB_angle_Hframe, _h_jet_bb_angle_Hframe, _h_jet_bVB_cosangle_Hframe, _h_jet_bb_cosangle_Hframe;
	//Histo1DPtr _h_jet_cuts_bb_deltaR_v_HpT;

	//@}

	};


	// This global object acts as a hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_VH2BB);

	}
	diff --git a/src/Analyses/MC_WINC.cc b/src/Analyses/MC_WINC.cc
	--- a/src/Analyses/MC_WINC.cc
	+++ b/src/Analyses/MC_WINC.cc
	@@ -1,191 +1,191 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/WFinder.hh"

	namespace Rivet {



	/// @brief MC validation analysis for inclusive W events
	class MC_WINC : public Analysis {
	public:

	/// Default constructor
	MC_WINC(string name="MC_WINC")
	: Analysis(name)
	{
	_dR=0.2;
	_lepton=PID::ELECTRON;
	}


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	WFinder wfinder(fs, Cuts::abseta < 3.5 && Cuts::pT > 25GeV, _lepton, 60.0GeV, 100.0GeV, 25.0GeV, _dR);
	- addProjection(wfinder, "WFinder");
	+ declare(wfinder, "WFinder");

	double sqrts = sqrtS()>0. ? sqrtS() : 14000.;
	_h_W_mass = bookHisto1D("W_mass", 50, 55.0, 105.0);
	_h_W_pT = bookHisto1D("W_pT", logspace(100, 1.0, 0.5*sqrts));
	_h_W_pT_peak = bookHisto1D("W_pT_peak", 25, 0.0, 125.0);
	_h_W_y = bookHisto1D("W_y", 40, -4.0, 4.0);
	_h_W_phi = bookHisto1D("W_phi", 25, 0.0, TWOPI);
	_h_Wplus_pT = bookHisto1D("Wplus_pT", logspace(25, 10.0, 0.5*sqrts));
	_h_Wminus_pT = bookHisto1D("Wminus_pT", logspace(25, 10.0, 0.5*sqrts));
	_h_lepton_pT = bookHisto1D("lepton_pT", logspace(100, 10.0, 0.25*sqrts));
	_h_lepton_eta = bookHisto1D("lepton_eta", 40, -4.0, 4.0);
	_htmp_dsigminus_deta = bookHisto1D("lepton_dsigminus_deta", 20, 0.0, 4.0);
	_htmp_dsigplus_deta = bookHisto1D("lepton_dsigplus_deta", 20, 0.0, 4.0);

	_h_asym = bookScatter2D("W_chargeasymm_eta");
	_h_asym_pT = bookScatter2D("W_chargeasymm_pT");
	}



	/// Do the analysis
	void analyze(const Event & e) {
	const double weight = e.weight();

	- const WFinder& wfinder = applyProjection<WFinder>(e, "WFinder");
	+ const WFinder& wfinder = apply<WFinder>(e, "WFinder");
	if (wfinder.bosons().size() != 1) {
	vetoEvent;
	}

	double charge3_x_eta = 0;
	int charge3 = 0;
	FourMomentum emom;
	FourMomentum wmom(wfinder.bosons().front().momentum());
	_h_W_mass->fill(wmom.mass(), weight);
	_h_W_pT->fill(wmom.pT(), weight);
	_h_W_pT_peak->fill(wmom.pT(), weight);
	_h_W_y->fill(wmom.rapidity(), weight);
	_h_W_phi->fill(wmom.phi(), weight);
	Particle l=wfinder.constituentLeptons()[0];
	_h_lepton_pT->fill(l.pT(), weight);
	_h_lepton_eta->fill(l.eta(), weight);
	if (PID::threeCharge(l.pid()) != 0) {
	emom = l.momentum();
	charge3_x_eta = PID::threeCharge(l.pid()) * emom.eta();
	charge3 = PID::threeCharge(l.pid());
	}
	assert(charge3_x_eta != 0);
	assert(charge3!=0);
	if (emom.Et() > 30/GeV) {
	if (charge3_x_eta < 0) {
	_htmp_dsigminus_deta->fill(emom.eta(), weight);
	} else {
	_htmp_dsigplus_deta->fill(emom.eta(), weight);
	}
	}
	if (charge3 < 0) {
	_h_Wminus_pT->fill(wmom.pT(), weight);
	} else {
	_h_Wplus_pT->fill(wmom.pT(), weight);
	}
	}


	/// Finalize
	void finalize() {
	scale(_h_W_mass, crossSection()/sumOfWeights());
	scale(_h_W_pT, crossSection()/sumOfWeights());
	scale(_h_W_pT_peak, crossSection()/sumOfWeights());
	scale(_h_W_y, crossSection()/sumOfWeights());
	scale(_h_W_phi, crossSection()/sumOfWeights());
	scale(_h_lepton_pT, crossSection()/sumOfWeights());
	scale(_h_lepton_eta, crossSection()/sumOfWeights());

	// Construct asymmetry: (dsig+/deta - dsig-/deta) / (dsig+/deta + dsig-/deta) for each Et region
	divide(_htmp_dsigplus_deta - _htmp_dsigminus_deta,
	_htmp_dsigplus_deta + _htmp_dsigminus_deta,
	_h_asym);

	// // W charge asymmetry vs. pTW: dsig+/dpT / dsig-/dpT
	divide(_h_Wplus_pT, _h_Wminus_pT,
	_h_asym_pT);

	scale(_h_Wplus_pT, crossSection()/picobarn/sumOfWeights());
	scale(_h_Wminus_pT, crossSection()/picobarn/sumOfWeights());
	}

	//@}


	protected:

	/// @name Parameters for specialised e/mu and dressed/bare subclassing
	//@{
	double _dR;
	PdgId _lepton;
	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_W_mass;
	Histo1DPtr _h_W_pT;
	Histo1DPtr _h_W_pT_peak;
	Histo1DPtr _h_W_y;
	Histo1DPtr _h_W_phi;
	Histo1DPtr _h_Wplus_pT;
	Histo1DPtr _h_Wminus_pT;
	Histo1DPtr _h_lepton_pT;
	Histo1DPtr _h_lepton_eta;

	Histo1DPtr _htmp_dsigminus_deta;
	Histo1DPtr _htmp_dsigplus_deta;

	Scatter2DPtr _h_asym;
	Scatter2DPtr _h_asym_pT;
	//@}

	};



	struct MC_WINC_EL : public MC_WINC {
	MC_WINC_EL() : MC_WINC("MC_WINC_EL") {
	_dR = 0.2;
	_lepton = PID::ELECTRON;
	}
	};

	struct MC_WINC_EL_BARE : public MC_WINC {
	MC_WINC_EL_BARE() : MC_WINC("MC_WINC_EL_BARE") {
	_dR = 0;
	_lepton = PID::ELECTRON;
	}
	};

	struct MC_WINC_MU : public MC_WINC {
	MC_WINC_MU() : MC_WINC("MC_WINC_MU") {
	_dR = 0.2;
	_lepton = PID::MUON;
	}
	};

	struct MC_WINC_MU_BARE : public MC_WINC {
	MC_WINC_MU_BARE() : MC_WINC("MC_WINC_MU_BARE") {
	_dR = 0;
	_lepton = PID::MUON;
	}
	};



	// The hooks for the plugin system
	DECLARE_RIVET_PLUGIN(MC_WINC);
	DECLARE_RIVET_PLUGIN(MC_WINC_EL);
	DECLARE_RIVET_PLUGIN(MC_WINC_EL_BARE);
	DECLARE_RIVET_PLUGIN(MC_WINC_MU);
	DECLARE_RIVET_PLUGIN(MC_WINC_MU_BARE);


	}
	diff --git a/src/Analyses/MC_WJETS.cc b/src/Analyses/MC_WJETS.cc
	--- a/src/Analyses/MC_WJETS.cc
	+++ b/src/Analyses/MC_WJETS.cc
	@@ -1,130 +1,130 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetAnalysis.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Analysis.hh"

	namespace Rivet {


	/// @brief MC validation analysis for W + jets events
	class MC_WJETS : public MC_JetAnalysis {
	public:

	/// Default constructor
	MC_WJETS(string name="MC_WJETS")
	: MC_JetAnalysis(name, 4, "Jets")
	{
	_dR=0.2;
	_lepton=PID::ELECTRON;
	}


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	WFinder wfinder(fs, Cuts::abseta < 3.5 && Cuts::pT > 25GeV, _lepton, 60.0GeV, 100.0GeV, 25.0GeV, _dR);
	- addProjection(wfinder, "WFinder");
	+ declare(wfinder, "WFinder");
	FastJets jetpro(wfinder.remainingFinalState(), FastJets::ANTIKT, 0.4);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	_h_W_jet1_deta = bookHisto1D("W_jet1_deta", 50, -5.0, 5.0);
	_h_W_jet1_dR = bookHisto1D("W_jet1_dR", 25, 0.5, 7.0);

	MC_JetAnalysis::init();
	}



	/// Do the analysis
	void analyze(const Event & e) {
	const double weight = e.weight();

	- const WFinder& wfinder = applyProjection<WFinder>(e, "WFinder");
	+ const WFinder& wfinder = apply<WFinder>(e, "WFinder");
	if (wfinder.bosons().size() != 1) {
	vetoEvent;
	}
	FourMomentum wmom(wfinder.bosons().front().momentum());

	- const Jets& jets = applyProjection<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	+ const Jets& jets = apply<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	if (jets.size() > 0) {
	_h_W_jet1_deta->fill(wmom.eta()-jets[0].eta(), weight);
	_h_W_jet1_dR->fill(deltaR(wmom, jets[0].momentum()), weight);
	}

	MC_JetAnalysis::analyze(e);
	}


	/// Finalize
	void finalize() {
	scale(_h_W_jet1_deta, crossSection()/picobarn/sumOfWeights());
	scale(_h_W_jet1_dR, crossSection()/picobarn/sumOfWeights());
	MC_JetAnalysis::finalize();
	}

	//@}


	protected:

	/// @name Parameters for specialised e/mu and dressed/bare subclassing
	//@{
	double _dR;
	PdgId _lepton;
	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_W_jet1_deta;
	Histo1DPtr _h_W_jet1_dR;
	//@}

	};



	struct MC_WJETS_EL : public MC_WJETS {
	MC_WJETS_EL() : MC_WJETS("MC_WJETS_EL") {
	_dR = 0.2;
	_lepton = PID::ELECTRON;
	}
	};

	struct MC_WJETS_EL_BARE : public MC_WJETS {
	MC_WJETS_EL_BARE() : MC_WJETS("MC_WJETS_EL_BARE") {
	_dR = 0;
	_lepton = PID::ELECTRON;
	}
	};

	struct MC_WJETS_MU : public MC_WJETS {
	MC_WJETS_MU() : MC_WJETS("MC_WJETS_MU") {
	_dR = 0.2;
	_lepton = PID::MUON;
	}
	};

	struct MC_WJETS_MU_BARE : public MC_WJETS {
	MC_WJETS_MU_BARE() : MC_WJETS("MC_WJETS_MU_BARE") {
	_dR = 0;
	_lepton = PID::MUON;
	}
	};



	// The hooks for the plugin system
	DECLARE_RIVET_PLUGIN(MC_WJETS);
	DECLARE_RIVET_PLUGIN(MC_WJETS_EL);
	DECLARE_RIVET_PLUGIN(MC_WJETS_EL_BARE);
	DECLARE_RIVET_PLUGIN(MC_WJETS_MU);
	DECLARE_RIVET_PLUGIN(MC_WJETS_MU_BARE);

	}
	diff --git a/src/Analyses/MC_WKTSPLITTINGS.cc b/src/Analyses/MC_WKTSPLITTINGS.cc
	--- a/src/Analyses/MC_WKTSPLITTINGS.cc
	+++ b/src/Analyses/MC_WKTSPLITTINGS.cc
	@@ -1,60 +1,60 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetSplittings.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// @brief MC validation analysis for kt splitting scales in W + jets events
	class MC_WKTSPLITTINGS : public MC_JetSplittings {
	public:

	/// Default constructor
	MC_WKTSPLITTINGS()
	: MC_JetSplittings("MC_WKTSPLITTINGS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	WFinder wfinder(fs, Cuts::abseta < 3.5 && Cuts::pT > 25GeV, PID::ELECTRON, 60.0GeV, 100.0GeV, 25.0GeV, 0.2);
	- addProjection(wfinder, "WFinder");
	+ declare(wfinder, "WFinder");
	FastJets jetpro(wfinder.remainingFinalState(), FastJets::KT, 0.6);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	MC_JetSplittings::init();
	}


	/// Do the analysis
	void analyze(const Event & e) {

	- const WFinder& wfinder = applyProjection<WFinder>(e, "WFinder");
	+ const WFinder& wfinder = apply<WFinder>(e, "WFinder");
	if (wfinder.bosons().size() != 1) {
	vetoEvent;
	}

	MC_JetSplittings::analyze(e);
	}


	/// Finalize
	void finalize() {
	MC_JetSplittings::finalize();
	}

	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_WKTSPLITTINGS);

	}
	diff --git a/src/Analyses/MC_WPOL.cc b/src/Analyses/MC_WPOL.cc
	--- a/src/Analyses/MC_WPOL.cc
	+++ b/src/Analyses/MC_WPOL.cc
	@@ -1,157 +1,155 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/Beam.hh"

	namespace Rivet {


	-
	-
	/// @brief MC validation analysis for W polarisation
	class MC_WPOL : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	MC_WPOL()
	: Analysis("MC_WPOL")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	FinalState fs;
	WFinder wfinder(fs, Cuts::open(), PID::ELECTRON,
	60.0GeV, 100.0GeV, 0.0*GeV, 0.0);
	- addProjection(wfinder, "WFinder");
	+ declare(wfinder, "WFinder");
	Beam beams;
	- addProjection(beams, "Beams");
	+ declare(beams, "Beams");

	vector<string> tags{"_wplus", "_wminus"};
	_h_dists.resize(tags.size());
	_h_histos.resize(tags.size());
	for (size_t i=0; i<tags.size(); ++i) {
	_h_dists[i].resize(11,Profile1DPtr());
	double sqrts = sqrtS()>0. ? sqrtS() : 14000.;
	_h_dists[i][0] = bookProfile1D("A0"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][1] = bookProfile1D("A1"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][2] = bookProfile1D("A2"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][3] = bookProfile1D("A3"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][4] = bookProfile1D("A4"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][5] = bookProfile1D("A5"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][6] = bookProfile1D("A6"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][7] = bookProfile1D("A7"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][8] = bookProfile1D("fL"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][9] = bookProfile1D("fR"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_dists[i][10] = bookProfile1D("f0"+tags[i],logspace(100, 1.0, 0.5*sqrts));
	_h_histos[i].resize(4,Histo1DPtr());
	_h_histos[i][0] = bookHisto1D("thetastar"+tags[i],100,-1.0,1.0);
	_h_histos[i][1] = bookHisto1D("phistar"+tags[i],90,0.0,360.0);
	_h_histos[i][2] = bookHisto1D("thetastar_ptw20"+tags[i],100,-1.0,1.0);
	_h_histos[i][3] = bookHisto1D("phistar_ptw20"+tags[i],90,0.0,360.0);
	}
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	- const WFinder& wfinder = applyProjection<WFinder>(event, "WFinder");
	+ const WFinder& wfinder = apply<WFinder>(event, "WFinder");
	if (wfinder.bosons().size() != 1) {
	vetoEvent;
	}
	- const ParticlePair& beams = applyProjection<Beam>(event, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(event, "Beams").beams();

	FourMomentum pb1(beams.second.momentum()), pb2(beams.first.momentum());
	- Particle lepton=wfinder.constituentLeptons()[0];
	+ Particle lepton = wfinder.constituentLeptons()[0];
	FourMomentum pl(lepton.momentum());
	size_t idx = (PID::threeCharge(lepton.pid())>0 ? 0 : 1);
	FourMomentum plnu(wfinder.bosons()[0].momentum());

	- LorentzTransform cms(-plnu.boostVector());
	+ const LorentzTransform cms = LorentzTransform::mkFrameTransformFromBeta(plnu.betaVec());
	Matrix3 zrot(plnu.p3(), Vector3(0.0, 0.0, 1.0));
	pl=cms.transform(pl);
	pb1=cms.transform(pb1);
	pb2=cms.transform(pb2);
	Vector3 pl3=pl.p3();
	Vector3 pb13=pb1.p3();
	Vector3 pb23=pb2.p3();
	pl3=zrot*pl3;
	pb13=zrot*pb13;
	pb23=zrot*pb23;
	Vector3 xref(cos(pb13.theta())>cos(pb23.theta())?pb13:pb23);
	Matrix3 xrot(Vector3(xref.x(), xref.y(), 0.0), Vector3(1.0, 0.0, 0.0));
	pl3=xrot*pl3;

	double ptw(wfinder.bosons()[0].pT()/GeV);
	double thetas(pl3.theta()), phis(pl3.phi());
	double costhetas(cos(thetas)), sinthetas(sin(thetas));
	double cosphis(cos(phis)), sinphis(sin(phis));
	if (phis<0.0) phis+=2.0*M_PI;

	_h_histos[idx][0]->fill(costhetas,weight);
	_h_histos[idx][1]->fill(phis*180.0/M_PI,weight);
	if (ptw>20.0) {
	_h_histos[idx][2]->fill(costhetas,weight);
	_h_histos[idx][3]->fill(phis*180.0/M_PI,weight);
	}
	_h_dists[idx][0]->fill(ptw,10.0/3.0(1.0-3.0sqr(costhetas))+2.0/3.0,weight);
	_h_dists[idx][1]->fill(ptw,10.0sinthetascosthetas*cosphis,weight);
	_h_dists[idx][2]->fill(ptw,10.0sqr(sinthetas)(sqr(cosphis)-sqr(sinphis)),weight);
	_h_dists[idx][3]->fill(ptw,4.0sinthetascosphis,weight);
	_h_dists[idx][4]->fill(ptw,4.0*costhetas,weight);
	_h_dists[idx][5]->fill(ptw,4.0sinthetassinphis,weight);
	_h_dists[idx][6]->fill(ptw,10.0costhetassinthetas*sinphis,weight);
	_h_dists[idx][7]->fill(ptw,10.0sqr(sinthetas)cosphis*sinphis,weight);
	_h_dists[idx][8]->fill(ptw,0.5sqr(1.0-costhetas)-(1.0-2.0sqr(costhetas)),weight);
	_h_dists[idx][9]->fill(ptw,0.5sqr(1.0+costhetas)-(1.0-2.0sqr(costhetas)),weight);
	_h_dists[idx][10]->fill(ptw,5.0*sqr(sinthetas)-3.0,weight);

	}


	/// Normalise histograms etc., after the run
	void finalize() {

	for (size_t i=0; i<_h_histos.size(); ++i) {
	foreach (Histo1DPtr histo, _h_histos[i]) {
	scale(histo, crossSection()/picobarn/sumOfWeights());
	}
	}

	}

	//@}


	private:

	/// @name Histograms
	//@{

	vector<vector<Profile1DPtr> > _h_dists;
	vector<vector<Histo1DPtr> > _h_histos;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_WPOL);

	}
	diff --git a/src/Analyses/MC_WWINC.cc b/src/Analyses/MC_WWINC.cc
	--- a/src/Analyses/MC_WWINC.cc
	+++ b/src/Analyses/MC_WWINC.cc
	@@ -1,184 +1,184 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief MC validation analysis for W^+[enu]W^-[munu] events
	class MC_WWINC : public Analysis {
	public:

	/// Default constructor
	MC_WWINC()
	: Analysis("MC_WWINC")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	WFinder wenufinder(fs, Cuts::abseta < 3.5 && Cuts::pT > 25GeV, PID::ELECTRON, 60.0GeV, 100.0GeV, 25.0GeV, 0.2);
	- addProjection(wenufinder, "WenuFinder");
	+ declare(wenufinder, "WenuFinder");

	VetoedFinalState wmnuinput;
	wmnuinput.addVetoOnThisFinalState(wenufinder);
	WFinder wmnufinder(wmnuinput, Cuts::abseta < 3.5 && Cuts::pT > 25GeV, PID::MUON, 60.0GeV, 100.0GeV, 25.0GeV, 0.2);
	- addProjection(wmnufinder, "WmnuFinder");
	+ declare(wmnufinder, "WmnuFinder");

	// properties of the pair momentum
	double sqrts = sqrtS()>0. ? sqrtS() : 14000.;
	_h_WW_pT = bookHisto1D("WW_pT", logspace(100, 1.0, 0.5*sqrts));
	_h_WW_pT_peak = bookHisto1D("WW_pT_peak", 25, 0.0, 25.0);
	_h_WW_eta = bookHisto1D("WW_eta", 40, -7.0, 7.0);
	_h_WW_phi = bookHisto1D("WW_phi", 25, 0.0, TWOPI);
	_h_WW_m = bookHisto1D("WW_m", logspace(100, 150.0, 180.0+0.25*sqrts));

	// correlations between the WW
	_h_WW_dphi = bookHisto1D("WW_dphi", 25, 0.0, PI); /// @todo non-linear?
	_h_WW_deta = bookHisto1D("WW_deta", 25, -7.0, 7.0);
	_h_WW_dR = bookHisto1D("WW_dR", 25, 0.5, 7.0);
	_h_WW_dpT = bookHisto1D("WW_dpT", logspace(100, 1.0, 0.5*sqrts));
	_h_WW_costheta_planes = bookHisto1D("WW_costheta_planes", 25, -1.0, 1.0);

	/// @todo fuer WW: missing ET

	// properties of the W bosons
	_h_W_pT = bookHisto1D("W_pT", logspace(100, 10.0, 0.25*sqrts));
	_h_W_eta = bookHisto1D("W_eta", 70, -7.0, 7.0);

	// properties of the leptons
	_h_Wl_pT = bookHisto1D("Wl_pT", logspace(100, 30.0, 0.1
	*sqrts));
	_h_Wl_eta = bookHisto1D("Wl_eta", 40, -3.5, 3.5);

	// correlations between the opposite charge leptons
	_h_WeWm_dphi = bookHisto1D("WeWm_dphi", 25, 0.0, PI);
	_h_WeWm_deta = bookHisto1D("WeWm_deta", 25, -5.0, 5.0);
	_h_WeWm_dR = bookHisto1D("WeWm_dR", 25, 0.5, 5.0);
	_h_WeWm_m = bookHisto1D("WeWm_m", 100, 0.0, 300.0);
	}



	/// Do the analysis
	void analyze(const Event & e) {
	const double weight = e.weight();

	- const WFinder& wenufinder = applyProjection<WFinder>(e, "WenuFinder");
	+ const WFinder& wenufinder = apply<WFinder>(e, "WenuFinder");
	if (wenufinder.bosons().size()!=1) {
	vetoEvent;
	}

	- const WFinder& wmnufinder = applyProjection<WFinder>(e, "WmnuFinder");
	+ const WFinder& wmnufinder = apply<WFinder>(e, "WmnuFinder");
	if (wmnufinder.bosons().size()!=1) {
	vetoEvent;
	}

	FourMomentum wenu(wenufinder.bosons()[0].momentum());
	FourMomentum wmnu(wmnufinder.bosons()[0].momentum());
	FourMomentum ww(wenu+wmnu);
	// find leptons
	FourMomentum ep=wenufinder.constituentLeptons()[0].momentum();
	FourMomentum enu=wenufinder.constituentNeutrinos()[0].momentum();
	FourMomentum mm=wmnufinder.constituentLeptons()[0].momentum();
	FourMomentum mnu=wmnufinder.constituentNeutrinos()[0].momentum();

	_h_WW_pT->fill(ww.pT(),weight);
	_h_WW_pT_peak->fill(ww.pT(),weight);
	_h_WW_eta->fill(ww.eta(),weight);
	_h_WW_phi->fill(ww.phi(),weight);
	double mww2=ww.mass2();
	if (mww2>0.0) _h_WW_m->fill(sqrt(mww2), weight);

	_h_WW_dphi->fill(mapAngle0ToPi(wenu.phi()-wmnu.phi()), weight);
	_h_WW_deta->fill(wenu.eta()-wmnu.eta(), weight);
	_h_WW_dR->fill(deltaR(wenu,wmnu), weight);
	_h_WW_dpT->fill(fabs(wenu.pT()-wmnu.pT()), weight);

	Vector3 crossWenu = ep.p3().cross(enu.p3());
	Vector3 crossWmnu = mm.p3().cross(mnu.p3());
	double costheta = crossWenu.dot(crossWmnu)/crossWenu.mod()/crossWmnu.mod();
	_h_WW_costheta_planes->fill(costheta, weight);

	_h_W_pT->fill(wenu.pT(),weight);
	_h_W_pT->fill(wmnu.pT(),weight);
	_h_W_eta->fill(wenu.eta(),weight);
	_h_W_eta->fill(wmnu.eta(),weight);

	_h_Wl_pT->fill(ep.pT(), weight);
	_h_Wl_pT->fill(mm.pT(), weight);
	_h_Wl_eta->fill(ep.eta(), weight);
	_h_Wl_eta->fill(mm.eta(), weight);

	_h_WeWm_dphi->fill(mapAngle0ToPi(ep.phi()-mm.phi()), weight);
	_h_WeWm_deta->fill(ep.eta()-mm.eta(), weight);
	_h_WeWm_dR->fill(deltaR(ep,mm), weight);
	double m2=FourMomentum(ep+mm).mass2();
	if (m2 < 0) m2 = 0.0;
	_h_WeWm_m->fill(sqrt(m2), weight);
	}


	/// Finalize
	void finalize() {
	const double norm = crossSection()/picobarn/sumOfWeights();
	scale(_h_WW_pT, norm);
	scale(_h_WW_pT_peak, norm);
	scale(_h_WW_eta, norm);
	scale(_h_WW_phi, norm);
	scale(_h_WW_m, norm);
	scale(_h_WW_dphi, norm);
	scale(_h_WW_deta, norm);
	scale(_h_WW_dR, norm);
	scale(_h_WW_dpT, norm);
	scale(_h_WW_costheta_planes, norm);
	scale(_h_W_pT, norm);
	scale(_h_W_eta, norm);
	scale(_h_Wl_pT, norm);
	scale(_h_Wl_eta, norm);
	scale(_h_WeWm_dphi, norm);
	scale(_h_WeWm_deta, norm);
	scale(_h_WeWm_dR, norm);
	scale(_h_WeWm_m, norm);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_WW_pT;
	Histo1DPtr _h_WW_pT_peak;
	Histo1DPtr _h_WW_eta;
	Histo1DPtr _h_WW_phi;
	Histo1DPtr _h_WW_m;
	Histo1DPtr _h_WW_dphi;
	Histo1DPtr _h_WW_deta;
	Histo1DPtr _h_WW_dR;
	Histo1DPtr _h_WW_dpT;
	Histo1DPtr _h_WW_costheta_planes;
	Histo1DPtr _h_W_pT;
	Histo1DPtr _h_W_eta;
	Histo1DPtr _h_Wl_pT;
	Histo1DPtr _h_Wl_eta;
	Histo1DPtr _h_WeWm_dphi;
	Histo1DPtr _h_WeWm_deta;
	Histo1DPtr _h_WeWm_dR;
	Histo1DPtr _h_WeWm_m;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_WWINC);

	}
	diff --git a/src/Analyses/MC_WWJETS.cc b/src/Analyses/MC_WWJETS.cc
	--- a/src/Analyses/MC_WWJETS.cc
	+++ b/src/Analyses/MC_WWJETS.cc
	@@ -1,129 +1,129 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetAnalysis.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {




	/// @brief MC validation analysis for W^+[enu]W^-[munu] + jets events
	class MC_WWJETS : public MC_JetAnalysis {
	public:

	/// Default constructor
	MC_WWJETS()
	: MC_JetAnalysis("MC_WWJETS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	WFinder wenufinder(fs, Cuts::abseta < 3.5 && Cuts::pT > 25GeV, PID::ELECTRON, 60.0GeV, 100.0GeV, 25.0GeV, 0.2);
	- addProjection(wenufinder, "WenuFinder");
	+ declare(wenufinder, "WenuFinder");

	VetoedFinalState wmnuinput;
	wmnuinput.addVetoOnThisFinalState(wenufinder);
	WFinder wmnufinder(wmnuinput, Cuts::abseta < 3.5 && Cuts::pT > 25GeV, PID::MUON, 60.0GeV, 100.0GeV, 25.0GeV, 0.2);
	- addProjection(wmnufinder, "WmnuFinder");
	+ declare(wmnufinder, "WmnuFinder");

	VetoedFinalState jetinput;
	jetinput
	.addVetoOnThisFinalState(wenufinder)
	.addVetoOnThisFinalState(wmnufinder);
	FastJets jetpro(jetinput, FastJets::ANTIKT, 0.4);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	// correlations with jets
	_h_WW_jet1_deta = bookHisto1D("WW_jet1_deta", 70, -7.0, 7.0);
	_h_WW_jet1_dR = bookHisto1D("WW_jet1_dR", 25, 1.5, 7.0);
	_h_We_jet1_dR = bookHisto1D("We_jet1_dR", 25, 0.0, 7.0);

	// global stuff
	_h_HT = bookHisto1D("HT", logspace(100, 100.0, 0.5*(sqrtS()>0.?sqrtS():14000.)));
	_h_jets_m_12 = bookHisto1D("jets_m_12", logspace(100, 1.0, 0.25*(sqrtS()>0.?sqrtS():14000.)));

	MC_JetAnalysis::init();
	}



	/// Do the analysis
	void analyze(const Event& e) {
	const double weight = e.weight();

	- const WFinder& wenufinder = applyProjection<WFinder>(e, "WenuFinder");
	+ const WFinder& wenufinder = apply<WFinder>(e, "WenuFinder");
	if (wenufinder.bosons().size() !=1 ) vetoEvent;

	- const WFinder& wmnufinder = applyProjection<WFinder>(e, "WmnuFinder");
	+ const WFinder& wmnufinder = apply<WFinder>(e, "WmnuFinder");
	if (wmnufinder.bosons().size() !=1 ) vetoEvent;

	FourMomentum wenu = wenufinder.bosons()[0].momentum();
	FourMomentum wmnu = wmnufinder.bosons()[0].momentum();
	FourMomentum ww = wenu + wmnu;
	// find leptons
	FourMomentum ep = wenufinder.constituentLeptons()[0].momentum();
	FourMomentum enu = wenufinder.constituentNeutrinos()[0].momentum();
	FourMomentum mm = wmnufinder.constituentLeptons()[0].momentum();
	FourMomentum mnu = wmnufinder.constituentNeutrinos()[0].momentum();

	- const Jets& jets = applyProjection<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	+ const Jets& jets = apply<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	if (jets.size() > 0) {
	_h_WW_jet1_deta->fill(ww.eta()-jets[0].eta(), weight);
	_h_WW_jet1_dR->fill(deltaR(ww, jets[0].momentum()), weight);
	_h_We_jet1_dR->fill(deltaR(ep, jets[0].momentum()), weight);
	}

	double HT = ep.pT() + mm.pT() + FourMomentum(enu+mnu).pT();
	foreach (const Jet& jet, jets) HT += jet.pT();
	if (HT > 0.0) _h_HT->fill(HT/GeV, weight);

	if (jets.size() > 1) {
	const FourMomentum jet1 = jets[0].momentum();
	const FourMomentum jet2 = jets[1].momentum();
	_h_jets_m_12->fill((jet1+jet2).mass()/GeV, weight);
	}

	MC_JetAnalysis::analyze(e);
	}


	/// Finalize
	void finalize() {
	const double norm = crossSection()/picobarn/sumOfWeights();
	scale(_h_WW_jet1_deta, norm);
	scale(_h_WW_jet1_dR, norm);
	scale(_h_We_jet1_dR, norm);
	scale(_h_jets_m_12, norm);
	scale(_h_HT, norm);
	MC_JetAnalysis::finalize();
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_WW_jet1_deta;
	Histo1DPtr _h_WW_jet1_dR;
	Histo1DPtr _h_We_jet1_dR;
	Histo1DPtr _h_jets_m_12;
	Histo1DPtr _h_HT;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_WWJETS);

	}
	diff --git a/src/Analyses/MC_WWKTSPLITTINGS.cc b/src/Analyses/MC_WWKTSPLITTINGS.cc
	--- a/src/Analyses/MC_WWKTSPLITTINGS.cc
	+++ b/src/Analyses/MC_WWKTSPLITTINGS.cc
	@@ -1,76 +1,76 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetSplittings.hh"
	#include "Rivet/Projections/WFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief MC validation analysis for W^+[enu]W^-[munu] + jets events
	class MC_WWKTSPLITTINGS : public MC_JetSplittings {
	public:

	/// Default constructor
	MC_WWKTSPLITTINGS()
	: MC_JetSplittings("MC_WWKTSPLITTINGS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	WFinder wenufinder(fs, Cuts::abseta < 3.5 && Cuts::pT > 25GeV, PID::ELECTRON, 60.0GeV, 100.0GeV, 25.0GeV, 0.2);
	- addProjection(wenufinder, "WenuFinder");
	+ declare(wenufinder, "WenuFinder");

	VetoedFinalState wmnuinput;
	wmnuinput.addVetoOnThisFinalState(wenufinder);
	WFinder wmnufinder(wmnuinput, Cuts::abseta < 3.5 && Cuts::pT > 25GeV, PID::MUON, 60.0GeV, 100.0GeV, 25.0GeV, 0.2);
	- addProjection(wmnufinder, "WmnuFinder");
	+ declare(wmnufinder, "WmnuFinder");

	VetoedFinalState jetinput;
	jetinput
	.addVetoOnThisFinalState(wenufinder)
	.addVetoOnThisFinalState(wmnufinder);
	FastJets jetpro(jetinput, FastJets::KT, 0.6);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	MC_JetSplittings::init();
	}



	/// Do the analysis
	void analyze(const Event & e) {
	- const WFinder& wenufinder = applyProjection<WFinder>(e, "WenuFinder");
	+ const WFinder& wenufinder = apply<WFinder>(e, "WenuFinder");
	if (wenufinder.bosons().size()!=1) {
	vetoEvent;
	}

	- const WFinder& wmnufinder = applyProjection<WFinder>(e, "WmnuFinder");
	+ const WFinder& wmnufinder = apply<WFinder>(e, "WmnuFinder");
	if (wmnufinder.bosons().size()!=1) {
	vetoEvent;
	}

	MC_JetSplittings::analyze(e);
	}


	/// Finalize
	void finalize() {
	MC_JetSplittings::finalize();
	}

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_WWKTSPLITTINGS);

	}
	diff --git a/src/Analyses/MC_ZINC.cc b/src/Analyses/MC_ZINC.cc
	--- a/src/Analyses/MC_ZINC.cc
	+++ b/src/Analyses/MC_ZINC.cc
	@@ -1,143 +1,143 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"

	namespace Rivet {



	/// @brief MC validation analysis for Z events
	class MC_ZINC : public Analysis {
	public:

	/// Default constructor
	MC_ZINC(string name="MC_ZINC")
	: Analysis(name) {
	_dR=0.2;
	_lepton=PID::ELECTRON;
	}


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	ZFinder zfinder(fs, cut, _lepton, 65.0GeV, 115.0GeV, _dR, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");

	_h_Z_mass = bookHisto1D("Z_mass", 50, 66.0, 116.0);
	_h_Z_pT = bookHisto1D("Z_pT", logspace(100, 1.0, 0.5*(sqrtS()>0.?sqrtS():14000.)/GeV));
	_h_Z_pT_peak = bookHisto1D("Z_pT_peak", 25, 0.0, 25.0);
	_h_Z_y = bookHisto1D("Z_y", 40, -4.0, 4.0);
	_h_Z_phi = bookHisto1D("Z_phi", 25, 0.0, TWOPI);
	_h_lepton_pT = bookHisto1D("lepton_pT", logspace(100, 10.0, 0.25*(sqrtS()>0.?sqrtS():14000.)/GeV));
	_h_lepton_eta = bookHisto1D("lepton_eta", 40, -4.0, 4.0);

	}



	/// Do the analysis
	void analyze(const Event & e) {
	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	if (zfinder.bosons().size()!=1) {
	vetoEvent;
	}
	const double weight = e.weight();

	FourMomentum zmom(zfinder.bosons()[0].momentum());
	_h_Z_mass->fill(zmom.mass()/GeV, weight);
	_h_Z_pT->fill(zmom.pT()/GeV, weight);
	_h_Z_pT_peak->fill(zmom.pT()/GeV, weight);
	_h_Z_y->fill(zmom.rapidity(), weight);
	_h_Z_phi->fill(zmom.phi(), weight);
	foreach (const Particle& l, zfinder.constituents()) {
	_h_lepton_pT->fill(l.pT()/GeV, weight);
	_h_lepton_eta->fill(l.eta(), weight);
	}
	}


	/// Finalize
	void finalize() {
	const double s = crossSection()/picobarn/sumOfWeights();
	scale(_h_Z_mass, s);
	scale(_h_Z_pT, s);
	scale(_h_Z_pT_peak, s);
	scale(_h_Z_y, s);
	scale(_h_Z_phi, s);
	scale(_h_lepton_pT, s);
	scale(_h_lepton_eta, s);
	}

	//@}


	protected:

	/// @name Parameters for specialised e/mu and dressed/bare subclassing
	//@{
	double _dR;
	PdgId _lepton;
	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_Z_mass;
	Histo1DPtr _h_Z_pT;
	Histo1DPtr _h_Z_pT_peak;
	Histo1DPtr _h_Z_y;
	Histo1DPtr _h_Z_phi;
	Histo1DPtr _h_lepton_pT;
	Histo1DPtr _h_lepton_eta;
	//@}

	};



	struct MC_ZINC_EL : public MC_ZINC {
	MC_ZINC_EL() : MC_ZINC("MC_ZINC_EL") {
	_dR = 0.2;
	_lepton = PID::ELECTRON;
	}
	};

	struct MC_ZINC_EL_BARE : public MC_ZINC {
	MC_ZINC_EL_BARE() : MC_ZINC("MC_ZINC_EL_BARE") {
	_dR = 0;
	_lepton = PID::ELECTRON;
	}
	};

	struct MC_ZINC_MU : public MC_ZINC {
	MC_ZINC_MU() : MC_ZINC("MC_ZINC_MU") {
	_dR = 0.2;
	_lepton = PID::MUON;
	}
	};

	struct MC_ZINC_MU_BARE : public MC_ZINC {
	MC_ZINC_MU_BARE() : MC_ZINC("MC_ZINC_MU_BARE") {
	_dR = 0;
	_lepton = PID::MUON;
	}
	};



	// The hooks for the plugin system
	DECLARE_RIVET_PLUGIN(MC_ZINC);
	DECLARE_RIVET_PLUGIN(MC_ZINC_EL);
	DECLARE_RIVET_PLUGIN(MC_ZINC_EL_BARE);
	DECLARE_RIVET_PLUGIN(MC_ZINC_MU);
	DECLARE_RIVET_PLUGIN(MC_ZINC_MU_BARE);


	}
	diff --git a/src/Analyses/MC_ZJETS.cc b/src/Analyses/MC_ZJETS.cc
	--- a/src/Analyses/MC_ZJETS.cc
	+++ b/src/Analyses/MC_ZJETS.cc
	@@ -1,127 +1,127 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetAnalysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief MC validation analysis for Z + jets events
	class MC_ZJETS : public MC_JetAnalysis {
	public:

	/// Default constructor
	MC_ZJETS(string name = "MC_ZJETS")
	: MC_JetAnalysis(name, 4, "Jets")
	{
	_dR=0.2;
	_lepton=PID::ELECTRON;
	}


	/// @name Analysis methods
	//@{

	/// Initialize
	void init() {
	FinalState fs;
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	ZFinder zfinder(fs, cut, _lepton, 65GeV, 115GeV, _dR, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");
	FastJets jetpro(zfinder.remainingFinalState(), FastJets::ANTIKT, 0.4);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	_h_Z_jet1_deta = bookHisto1D("Z_jet1_deta", 50, -5, 5);
	_h_Z_jet1_dR = bookHisto1D("Z_jet1_dR", 25, 0.5, 7.0);

	MC_JetAnalysis::init();
	}



	/// Do the analysis
	void analyze(const Event & e) {
	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	if (zfinder.bosons().size() != 1) vetoEvent;
	const FourMomentum& zmom = zfinder.bosons()[0].momentum();

	- const Jets& jets = applyProjection<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	+ const Jets& jets = apply<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	if (jets.size() > 0) {
	const double weight = e.weight();
	_h_Z_jet1_deta->fill(zmom.eta()-jets[0].eta(), weight);
	_h_Z_jet1_dR->fill(deltaR(zmom, jets[0].momentum()), weight);
	}

	MC_JetAnalysis::analyze(e);
	}


	/// Finalize
	void finalize() {
	scale(_h_Z_jet1_deta, crossSection()/picobarn/sumOfWeights());
	scale(_h_Z_jet1_dR, crossSection()/picobarn/sumOfWeights());
	MC_JetAnalysis::finalize();
	}

	//@}


	protected:

	/// @name Parameters for specialised e/mu and dressed/bare subclassing
	//@{
	double _dR;
	PdgId _lepton;
	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_Z_jet1_deta;
	Histo1DPtr _h_Z_jet1_dR;
	//@}

	};



	struct MC_ZJETS_EL : public MC_ZJETS {
	MC_ZJETS_EL() : MC_ZJETS("MC_ZJETS_EL") {
	_dR = 0.2;
	_lepton = PID::ELECTRON;
	}
	};

	struct MC_ZJETS_EL_BARE : public MC_ZJETS {
	MC_ZJETS_EL_BARE() : MC_ZJETS("MC_ZJETS_EL_BARE") {
	_dR = 0;
	_lepton = PID::ELECTRON;
	}
	};

	struct MC_ZJETS_MU : public MC_ZJETS {
	MC_ZJETS_MU() : MC_ZJETS("MC_ZJETS_MU") {
	_dR = 0.2;
	_lepton = PID::MUON;
	}
	};

	struct MC_ZJETS_MU_BARE : public MC_ZJETS {
	MC_ZJETS_MU_BARE() : MC_ZJETS("MC_ZJETS_MU_BARE") {
	_dR = 0;
	_lepton = PID::MUON;
	}
	};



	// The hooks for the plugin system
	DECLARE_RIVET_PLUGIN(MC_ZJETS);
	DECLARE_RIVET_PLUGIN(MC_ZJETS_EL);
	DECLARE_RIVET_PLUGIN(MC_ZJETS_EL_BARE);
	DECLARE_RIVET_PLUGIN(MC_ZJETS_MU);
	DECLARE_RIVET_PLUGIN(MC_ZJETS_MU_BARE);

	}
	diff --git a/src/Analyses/MC_ZKTSPLITTINGS.cc b/src/Analyses/MC_ZKTSPLITTINGS.cc
	--- a/src/Analyses/MC_ZKTSPLITTINGS.cc
	+++ b/src/Analyses/MC_ZKTSPLITTINGS.cc
	@@ -1,61 +1,61 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetSplittings.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {




	/// @brief MC validation analysis for Z + jets events
	class MC_ZKTSPLITTINGS : public MC_JetSplittings {
	public:

	/// Default constructor
	MC_ZKTSPLITTINGS()
	: MC_JetSplittings("MC_ZKTSPLITTINGS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	FinalState fs;
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	ZFinder zfinder(fs, cut, PID::ELECTRON, 65GeV, 115GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zfinder, "ZFinder");
	+ declare(zfinder, "ZFinder");
	FastJets jetpro(zfinder.remainingFinalState(), FastJets::KT, 0.6);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	MC_JetSplittings::init();
	}



	/// Do the analysis
	void analyze(const Event & e) {
	- const ZFinder& zfinder = applyProjection<ZFinder>(e, "ZFinder");
	+ const ZFinder& zfinder = apply<ZFinder>(e, "ZFinder");
	if (zfinder.bosons().size() != 1) vetoEvent;

	MC_JetSplittings::analyze(e);
	}


	/// Finalize
	void finalize() {
	MC_JetSplittings::finalize();
	}

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_ZKTSPLITTINGS);

	}
	diff --git a/src/Analyses/MC_ZZINC.cc b/src/Analyses/MC_ZZINC.cc
	--- a/src/Analyses/MC_ZZINC.cc
	+++ b/src/Analyses/MC_ZZINC.cc
	@@ -1,183 +1,183 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief MC validation analysis for Z[ee]Z[mumu] events
	class MC_ZZINC : public Analysis {
	public:

	/// Default constructor
	MC_ZZINC()
	: Analysis("MC_ZZINC")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	ZFinder zeefinder(FinalState(), cut, PID::ELECTRON, 65GeV, 115GeV,
	0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zeefinder, "ZeeFinder");
	+ declare(zeefinder, "ZeeFinder");

	VetoedFinalState zmminput;
	zmminput.addVetoOnThisFinalState(zeefinder);
	ZFinder zmmfinder(zmminput, cut, PID::MUON, 65GeV, 115GeV,
	0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zmmfinder, "ZmmFinder");
	+ declare(zmmfinder, "ZmmFinder");

	// Properties of the pair momentum
	double sqrts = sqrtS()>0. ? sqrtS() : 14000.;
	_h_ZZ_pT = bookHisto1D("ZZ_pT", logspace(100, 1.0, 0.5*sqrts/GeV));
	_h_ZZ_pT_peak = bookHisto1D("ZZ_pT_peak", 25, 0.0, 25.0);
	_h_ZZ_eta = bookHisto1D("ZZ_eta", 40, -7.0, 7.0);
	_h_ZZ_phi = bookHisto1D("ZZ_phi", 25, 0.0, TWOPI);
	_h_ZZ_m = bookHisto1D("ZZ_m", logspace(100, 150.0, 180.0 + 0.25*sqrts/GeV));

	// Correlations between the ZZ
	_h_ZZ_dphi = bookHisto1D("ZZ_dphi", 25, 0.0, PI); /// @todo non-linear?
	_h_ZZ_deta = bookHisto1D("ZZ_deta", 25, -7.0, 7.0);
	_h_ZZ_dR = bookHisto1D("ZZ_dR", 25, 0.5, 7.0);
	_h_ZZ_dpT = bookHisto1D("ZZ_dpT", logspace(100, 1.0, 0.5*sqrts/GeV));
	_h_ZZ_costheta_planes = bookHisto1D("ZZ_costheta_planes", 25, -1.0, 1.0);

	// Properties of the Z bosons
	_h_Z_pT = bookHisto1D("Z_pT", logspace(100, 10.0, 0.25*sqrts/GeV));
	_h_Z_eta = bookHisto1D("Z_eta", 70, -7.0, 7.0);

	// Properties of the leptons
	_h_Zl_pT = bookHisto1D("Zl_pT", logspace(100, 30.0, 0.1*sqrts/GeV));
	_h_Zl_eta = bookHisto1D("Zl_eta", 40, -3.5, 3.5);

	// Correlations between the opposite charge leptons
	_h_ZeZm_dphi = bookHisto1D("ZeZm_dphi", 25, 0.0, PI);
	_h_ZeZm_deta = bookHisto1D("ZeZm_deta", 25, -5.0, 5.0);
	_h_ZeZm_dR = bookHisto1D("ZeZm_dR", 25, 0.5, 5.0);
	_h_ZeZm_m = bookHisto1D("ZeZm_m", 100, 0.0, 300.0);

	}



	/// Do the analysis
	void analyze(const Event& e) {
	- const ZFinder& zeefinder = applyProjection<ZFinder>(e, "ZeeFinder");
	+ const ZFinder& zeefinder = apply<ZFinder>(e, "ZeeFinder");
	if (zeefinder.bosons().size() != 1) vetoEvent;
	- const ZFinder& zmmfinder = applyProjection<ZFinder>(e, "ZmmFinder");
	+ const ZFinder& zmmfinder = apply<ZFinder>(e, "ZmmFinder");
	if (zmmfinder.bosons().size() != 1) vetoEvent;

	// Z momenta
	const FourMomentum& zee = zeefinder.bosons()[0].momentum();
	const FourMomentum& zmm = zmmfinder.bosons()[0].momentum();
	const FourMomentum zz = zee + zmm;
	// Lepton momenta
	const FourMomentum& ep = zeefinder.constituents()[0].momentum();
	const FourMomentum& em = zeefinder.constituents()[1].momentum();
	const FourMomentum& mp = zmmfinder.constituents()[0].momentum();
	const FourMomentum& mm = zmmfinder.constituents()[1].momentum();

	const double weight = e.weight();
	_h_ZZ_pT->fill(zz.pT()/GeV, weight);
	_h_ZZ_pT_peak->fill(zz.pT()/GeV, weight);
	_h_ZZ_eta->fill(zz.eta(), weight);
	_h_ZZ_phi->fill(zz.phi(), weight);
	if (zz.mass2() > 0.0) ///< @todo Protection still needed?
	_h_ZZ_m->fill(zz.mass()/GeV, weight);

	_h_ZZ_dphi->fill(deltaPhi(zee, zmm), weight);
	_h_ZZ_deta->fill(zee.eta()-zmm.eta(), weight);
	_h_ZZ_dR->fill(deltaR(zee,zmm), weight);
	_h_ZZ_dpT->fill(fabs(zee.pT()-zmm.pT()), weight);

	const Vector3 crossZee = ep.p3().cross(em.p3());
	const Vector3 crossZmm = mp.p3().cross(mm.p3());
	const double costheta = crossZee.dot(crossZmm)/crossZee.mod()/crossZmm.mod();
	_h_ZZ_costheta_planes->fill(costheta, weight);

	_h_Z_pT->fill(zee.pT()/GeV, weight);
	_h_Z_pT->fill(zmm.pT()/GeV, weight);
	_h_Z_eta->fill(zee.eta(), weight);
	_h_Z_eta->fill(zmm.eta(), weight);

	_h_Zl_pT->fill(ep.pT()/GeV, weight);
	_h_Zl_pT->fill(em.pT()/GeV, weight);
	_h_Zl_pT->fill(mp.pT()/GeV, weight);
	_h_Zl_pT->fill(mm.pT()/GeV, weight);
	_h_Zl_eta->fill(ep.eta(), weight);
	_h_Zl_eta->fill(em.eta(), weight);
	_h_Zl_eta->fill(mp.eta(), weight);
	_h_Zl_eta->fill(mm.eta(), weight);

	_h_ZeZm_dphi->fill(deltaPhi(ep, mm), weight);
	_h_ZeZm_deta->fill(ep.eta()-mm.eta(), weight);
	_h_ZeZm_dR->fill(deltaR(ep, mm), weight);
	const FourMomentum epmm = ep + mm;
	const double m_epmm = (epmm.mass2() > 0) ? epmm.mass() : 0; ///< @todo Protection still needed?
	_h_ZeZm_m->fill(m_epmm/GeV, weight);
	}


	/// Finalize
	void finalize() {
	const double s = crossSection()/picobarn/sumOfWeights();
	scale(_h_ZZ_pT, s);
	scale(_h_ZZ_pT_peak, s);
	scale(_h_ZZ_eta, s);
	scale(_h_ZZ_phi, s);
	scale(_h_ZZ_m, s);
	scale(_h_ZZ_dphi, s);
	scale(_h_ZZ_deta, s);
	scale(_h_ZZ_dR, s);
	scale(_h_ZZ_dpT, s);
	scale(_h_ZZ_costheta_planes, s);
	scale(_h_Z_pT, s);
	scale(_h_Z_eta, s);
	scale(_h_Zl_pT, s);
	scale(_h_Zl_eta, s);
	scale(_h_ZeZm_dphi, s);
	scale(_h_ZeZm_deta, s);
	scale(_h_ZeZm_dR, s);
	scale(_h_ZeZm_m, s);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_ZZ_pT;
	Histo1DPtr _h_ZZ_pT_peak;
	Histo1DPtr _h_ZZ_eta;
	Histo1DPtr _h_ZZ_phi;
	Histo1DPtr _h_ZZ_m;
	Histo1DPtr _h_ZZ_dphi;
	Histo1DPtr _h_ZZ_deta;
	Histo1DPtr _h_ZZ_dR;
	Histo1DPtr _h_ZZ_dpT;
	Histo1DPtr _h_ZZ_costheta_planes;
	Histo1DPtr _h_Z_pT;
	Histo1DPtr _h_Z_eta;
	Histo1DPtr _h_Zl_pT;
	Histo1DPtr _h_Zl_eta;
	Histo1DPtr _h_ZeZm_dphi;
	Histo1DPtr _h_ZeZm_deta;
	Histo1DPtr _h_ZeZm_dR;
	Histo1DPtr _h_ZeZm_m;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_ZZINC);

	}
	diff --git a/src/Analyses/MC_ZZJETS.cc b/src/Analyses/MC_ZZJETS.cc
	--- a/src/Analyses/MC_ZZJETS.cc
	+++ b/src/Analyses/MC_ZZJETS.cc
	@@ -1,120 +1,120 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetAnalysis.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief MC validation analysis for Z[ee]Z[mumu] + jets events
	class MC_ZZJETS : public MC_JetAnalysis {
	public:

	/// Default constructor
	MC_ZZJETS()
	: MC_JetAnalysis("MC_ZZJETS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	ZFinder zeefinder(FinalState(), cut, PID::ELECTRON, 65GeV, 115GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zeefinder, "ZeeFinder");
	+ declare(zeefinder, "ZeeFinder");

	VetoedFinalState zmminput;
	zmminput.addVetoOnThisFinalState(zeefinder);
	ZFinder zmmfinder(zmminput, cut, PID::MUON, 65GeV, 115GeV, 0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zmmfinder, "ZmmFinder");
	+ declare(zmmfinder, "ZmmFinder");

	VetoedFinalState jetinput;
	jetinput
	.addVetoOnThisFinalState(zeefinder)
	.addVetoOnThisFinalState(zmmfinder);
	FastJets jetpro(jetinput, FastJets::ANTIKT, 0.4);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	// Correlations with jets
	_h_ZZ_jet1_deta = bookHisto1D("ZZ_jet1_deta", 70, -7.0, 7.0);
	_h_ZZ_jet1_dR = bookHisto1D("ZZ_jet1_dR", 25, 1.5, 7.0);
	_h_Ze_jet1_dR = bookHisto1D("Ze_jet1_dR", 25, 0.0, 7.0);

	// Global stuff
	_h_HT = bookHisto1D("HT", logspace(100, 100.0, 0.5*(sqrtS()>0.?sqrtS():14000.)/GeV));

	MC_JetAnalysis::init();
	}



	/// Do the analysis
	void analyze(const Event& e) {
	const double weight = e.weight();

	- const ZFinder& zeefinder = applyProjection<ZFinder>(e, "ZeeFinder");
	+ const ZFinder& zeefinder = apply<ZFinder>(e, "ZeeFinder");
	if (zeefinder.bosons().size() != 1) vetoEvent;

	- const ZFinder& zmmfinder = applyProjection<ZFinder>(e, "ZmmFinder");
	+ const ZFinder& zmmfinder = apply<ZFinder>(e, "ZmmFinder");
	if (zmmfinder.bosons().size() != 1) vetoEvent;

	// Z momenta
	const FourMomentum& zee = zeefinder.bosons()[0].momentum();
	const FourMomentum& zmm = zmmfinder.bosons()[0].momentum();
	const FourMomentum zz = zee + zmm;
	// Lepton momenta
	const FourMomentum& ep = zeefinder.constituents()[0].momentum();
	const FourMomentum& em = zeefinder.constituents()[1].momentum();
	const FourMomentum& mp = zmmfinder.constituents()[0].momentum();
	const FourMomentum& mm = zmmfinder.constituents()[1].momentum();

	- const Jets& jets = applyProjection<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	+ const Jets& jets = apply<FastJets>(e, "Jets").jetsByPt(_jetptcut);
	if (jets.size() > 0) {
	const FourMomentum j0 = jets[0].momentum();
	_h_ZZ_jet1_deta->fill(zz.eta()-j0.eta(), weight);
	_h_ZZ_jet1_dR->fill(deltaR(zz, j0), weight);
	_h_Ze_jet1_dR->fill(deltaR(ep, j0), weight);
	}

	double HT = ep.pT() + em.pT() + mp.pT() + mm.pT();
	foreach (const Jet& jet, jets) HT += jet.pT();
	if (HT > 0.0) _h_HT->fill(HT/GeV, weight);

	MC_JetAnalysis::analyze(e);
	}


	/// Finalize
	void finalize() {
	const double s = crossSection()/picobarn/sumOfWeights();
	scale(_h_ZZ_jet1_deta, s);
	scale(_h_ZZ_jet1_dR, s);
	scale(_h_Ze_jet1_dR, s);
	scale(_h_HT, s);
	MC_JetAnalysis::finalize();
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_ZZ_jet1_deta;
	Histo1DPtr _h_ZZ_jet1_dR;
	Histo1DPtr _h_Ze_jet1_dR;
	Histo1DPtr _h_HT;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_ZZJETS);

	}
	diff --git a/src/Analyses/MC_ZZKTSPLITTINGS.cc b/src/Analyses/MC_ZZKTSPLITTINGS.cc
	--- a/src/Analyses/MC_ZZKTSPLITTINGS.cc
	+++ b/src/Analyses/MC_ZZKTSPLITTINGS.cc
	@@ -1,71 +1,71 @@
	// -- C++ --
	#include "Rivet/Analyses/MC_JetSplittings.hh"
	#include "Rivet/Projections/ZFinder.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"

	namespace Rivet {


	/// @brief MC validation analysis for Z[ee]Z[mumu] + jets events
	class MC_ZZKTSPLITTINGS : public MC_JetSplittings {
	public:

	/// Default constructor
	MC_ZZKTSPLITTINGS()
	: MC_JetSplittings("MC_ZZKTSPLITTINGS", 4, "Jets")
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms
	void init() {
	Cut cut = Cuts::abseta < 3.5 && Cuts::pT > 25*GeV;
	ZFinder zeefinder(FinalState(), cut, PID::ELECTRON, 65GeV, 115GeV,
	0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zeefinder, "ZeeFinder");
	+ declare(zeefinder, "ZeeFinder");

	VetoedFinalState zmminput;
	zmminput.addVetoOnThisFinalState(zeefinder);
	ZFinder zmmfinder(zmminput, cut, PID::MUON, 65GeV, 115GeV,
	0.2, ZFinder::CLUSTERNODECAY, ZFinder::TRACK);
	- addProjection(zmmfinder, "ZmmFinder");
	+ declare(zmmfinder, "ZmmFinder");

	VetoedFinalState jetinput;
	jetinput
	.addVetoOnThisFinalState(zeefinder)
	.addVetoOnThisFinalState(zmmfinder);
	FastJets jetpro(jetinput, FastJets::KT, 0.6);
	- addProjection(jetpro, "Jets");
	+ declare(jetpro, "Jets");

	MC_JetSplittings::init();
	}


	/// Do the analysis
	void analyze(const Event & e) {
	- const ZFinder& zeefinder = applyProjection<ZFinder>(e, "ZeeFinder");
	+ const ZFinder& zeefinder = apply<ZFinder>(e, "ZeeFinder");
	if (zeefinder.bosons().size() != 1) vetoEvent;
	- const ZFinder& zmmfinder = applyProjection<ZFinder>(e, "ZmmFinder");
	+ const ZFinder& zmmfinder = apply<ZFinder>(e, "ZmmFinder");
	if (zmmfinder.bosons().size() != 1) vetoEvent;
	MC_JetSplittings::analyze(e);
	}


	/// Finalize
	void finalize() {
	MC_JetSplittings::finalize();
	}

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(MC_ZZKTSPLITTINGS);

	}
	diff --git a/src/Analyses/Makefile.am b/src/Analyses/Makefile.am
	--- a/src/Analyses/Makefile.am
	+++ b/src/Analyses/Makefile.am
	@@ -1,485 +1,624 @@
	+AUTOMAKE_OPTIONS = -Wno-portability
	+
	## Flags for building all plugins
	AM_LDFLAGS = $(LDFLAGS) -module -avoid-version -L$(FASTJETLIBPATH)
	LIBS = $(FASTJETCONFIGLIBADD)
	lib_LTLIBRARIES =

	+BUILT_SOURCES =
	+DISTCLEANFILES =
	+
	+EXTRA_DIST = cat_with_lines
	+
	noinst_LTLIBRARIES = libRivetAnalysisTools.la
	libRivetAnalysisTools_la_SOURCES = \
	MC_ParticleAnalysis.cc \
	MC_JetAnalysis.cc \
	MC_JetSplittings.cc

	-## ANALYSIS CATEGORIES
	-##
	-## Unvalidated analyses: add new standard analyses here, and only
	-## move them into the collider-specific standard plugin libraries
	-## once they have been finished and checked. The --enable-unvalidated
	-## flag is needed to install the unvalidated analyses.
	-##
	-## Preliminary analyses: validated analyses whose experimental paper has not
	-## been fully accepted for publication should go here. Analyses in this group
	-## are considered safe to use but the reference data may yet change. In
	-## progressing from preliminary status to a permanent published analyses
	-## collection, the analysis name is very likely to change, so you should ensure
	-## that any Rivet-using scripts are not broken by such name changes when
	-## upgrading between Rivet versions. These analyses will not be available if
	-## Rivet is built with the --disable-preliminary configure flag.
	-##
	-## Obsolete analyses: as mentioned above, when a preliminary analysis becomes
	-## permanent its name will change to reflect its newly published status via the
	-## publication's SPIRES ID. The previous form of the analysis, possibly with
	-## different reference histograms, will be retained for one major version of
	-## Rivet with a status of "obsolete" before being removed, to give users time to
	-## migrate their run scripts, i.e. if an analysis is marked as obsolete in
	-## version 1.4.2, it will remain in Rivet's distribution until version
	-## 1.5.0. Obsolete analyses will not be available if Rivet is built with the
	-## --disable-obsolete configure flag.
	+%__all.cc :
	+ $(srcdir)/cat_with_lines $^ > $@

	if ENABLE_ANALYSES

	lib_LTLIBRARIES += RivetALICEAnalyses.la
	-RivetALICEAnalyses_la_SOURCES = \
	+
	+nodist_RivetALICEAnalyses_la_SOURCES = ALICE__all.cc
	+BUILT_SOURCES += ALICE__all.cc
	+DISTCLEANFILES += ALICE__all.cc
	+
	+ALICE__all.cc : $(ALICE_ALL)
	+
	+EXTRA_DIST += $(ALICE_ALL)
	+
	+ALICE_ALL = \
	ALICE_2010_S8624100.cc \
	ALICE_2010_S8625980.cc \
	ALICE_2010_S8706239.cc \
	ALICE_2011_S8909580.cc \
	ALICE_2011_S8945144.cc \
	+ ALICE_2012_I1116147.cc \
	ALICE_2012_I1181770.cc \
	ALICE_2014_I1300380.cc \
	ALICE_2015_I1357424.cc


	lib_LTLIBRARIES += RivetATLASAnalyses.la
	-RivetATLASAnalyses_la_SOURCES = \
	+
	+nodist_RivetATLASAnalyses_la_SOURCES = ATLAS_1__all.cc ATLAS_2__all.cc
	+BUILT_SOURCES += ATLAS_1__all.cc ATLAS_2__all.cc
	+DISTCLEANFILES += ATLAS_1__all.cc ATLAS_2__all.cc
	+
	+ATLAS_1__all.cc : $(ATLAS_ALL_1)
	+ATLAS_2__all.cc : $(ATLAS_ALL_2)
	+
	+EXTRA_DIST += $(ATLAS_ALL_1) $(ATLAS_ALL_2)
	+
	+ATLAS_ALL_1 = \
	ATLAS_2010_S8591806.cc \
	ATLAS_2010_S8817804.cc \
	ATLAS_2010_S8894728.cc \
	ATLAS_2010_S8914702.cc \
	ATLAS_2010_S8918562.cc \
	ATLAS_2010_S8919674.cc \
	ATLAS_2011_S8924791.cc \
	ATLAS_2011_S8971293.cc \
	ATLAS_2011_S8994773.cc \
	ATLAS_2011_S8983313.cc \
	ATLAS_2011_S9002537.cc \
	ATLAS_2011_S9120807.cc \
	ATLAS_2011_S9126244.cc \
	ATLAS_2011_S9128077.cc \
	ATLAS_2011_S9131140.cc \
	ATLAS_2011_S9212183.cc \
	ATLAS_2011_S9225137.cc \
	ATLAS_2011_S9019561.cc \
	ATLAS_2011_I894867.cc \
	ATLAS_2011_I919017.cc \
	ATLAS_2011_I921594.cc \
	ATLAS_2011_I925932.cc \
	ATLAS_2011_I926145.cc \
	+ ATLAS_2011_I929691.cc \
	ATLAS_2011_I930220.cc \
	ATLAS_2011_I944826.cc \
	ATLAS_2011_I945498.cc \
	ATLAS_2011_I954993.cc \
	ATLAS_2011_I928289_W.cc \
	ATLAS_2011_I928289_Z.cc \
	ATLAS_2011_S9035664.cc \
	ATLAS_2012_I943401.cc \
	+ ATLAS_2012_I1082009.cc \
	ATLAS_2012_I1082936.cc \
	ATLAS_2012_I1083318.cc \
	ATLAS_2012_I1084540.cc \
	ATLAS_2012_I1091481.cc \
	ATLAS_2012_I1093734.cc \
	ATLAS_2012_I1093738.cc \
	ATLAS_2012_I1094564.cc \
	ATLAS_2012_I1094568.cc \
	ATLAS_2012_I1112263.cc \
	ATLAS_2012_I1117704.cc \
	ATLAS_2012_I1118269.cc \
	ATLAS_2012_I1119557.cc \
	ATLAS_2012_I1124167.cc \
	ATLAS_2012_I1125575.cc \
	ATLAS_2012_I1125961.cc \
	ATLAS_2012_I1183818.cc \
	ATLAS_2012_I1188891.cc \
	ATLAS_2012_I1199269.cc \
	ATLAS_2012_I1203852.cc \
	ATLAS_2012_I1204447.cc \
	ATLAS_2012_I1204784.cc \
	ATLAS_2013_I1190187.cc \
	ATLAS_2013_I1217867.cc \
	ATLAS_2013_I1219109.cc \
	ATLAS_2013_I1230812.cc \
	ATLAS_2013_I1243871.cc \
	ATLAS_2013_I1263495.cc \
	ATLAS_2014_I1268975.cc \
	ATLAS_2014_I1279489.cc \
	ATLAS_2014_I1282441.cc \
	ATLAS_2014_I1298811.cc \
	ATLAS_2014_I1304688.cc \
	ATLAS_2014_I1307756.cc \
	ATLAS_2014_I1306294.cc \
	ATLAS_2014_I1315949.cc \
	ATLAS_2014_I1325553.cc \
	ATLAS_2014_I1300647.cc \
	ATLAS_2014_I1288706.cc \
	ATLAS_2014_I1307243.cc \
	- ATLAS_2014_I1312627.cc \
	+ ATLAS_2014_I1312627.cc
	+
	+ATLAS_ALL_2 = \
	ATLAS_2013_I1217863_W.cc \
	ATLAS_2013_I1217863_Z.cc \
	ATLAS_2014_I1306615.cc \
	ATLAS_2013_I1216670.cc \
	ATLAS_2013_I1244522.cc \
	ATLAS_2014_I1282447.cc \
	ATLAS_2014_I1298023.cc \
	ATLAS_2014_I1319490.cc \
	ATLAS_2014_I1326641.cc \
	ATLAS_2014_I1327229.cc \
	ATLAS_2015_I1345452.cc \
	+ ATLAS_2015_I1351916.cc \
	ATLAS_2015_I1364361.cc \
	ATLAS_2015_I1376945.cc \
	ATLAS_2015_I1387176.cc \
	+ ATLAS_2015_I1390114.cc \
	+ ATLAS_2015_I1393758.cc \
	ATLAS_2015_I1394679.cc \
	- ATLAS_2016_I1424838.cc
	-if ENABLE_PRELIMINARY
	-RivetATLASAnalyses_la_SOURCES += \
	+ ATLAS_2015_I1397635.cc \
	+ ATLAS_2015_I1397637.cc \
	+ ATLAS_2015_I1404878.cc \
	+ ATLAS_2015_I1408516.cc \
	+ ATLAS_2016_I1419070.cc \
	+ ATLAS_2016_I1419652.cc \
	+ ATLAS_2016_I1424838.cc \
	+ ATLAS_2016_I1426695.cc \
	+ ATLAS_2016_I1444991.cc \
	+ ATLAS_2016_I1452559.cc \
	+ ATLAS_2016_I1457605.cc \
	+ ATLAS_2016_I1458270.cc \
	+ ATLAS_2016_I1468168.cc \
	+ ATLAS_2016_I1467230.cc \
	+ ATLAS_2016_I1467454.cc \
	+ ATLAS_2016_I1468167.cc \
	+ ATLAS_2016_I1479760.cc
	+
	+# PRELIMINARY / OBSOLETE
	+ATLAS_ALL_2 += \
	ATLAS_2012_CONF_2012_001.cc \
	- ATLAS_2015_CONF_2015_041.cc
	-endif
	-if ENABLE_OBSOLETE
	-RivetATLASAnalyses_la_SOURCES += \
	ATLAS_2010_CONF_2010_049.cc \
	ATLAS_2011_CONF_2011_090.cc \
	ATLAS_2011_CONF_2011_098.cc \
	- ATLAS_2011_S9041966.cc \
	- ATLAS_2011_S9212353.cc \
	ATLAS_2012_CONF_2012_103.cc \
	ATLAS_2012_CONF_2012_104.cc \
	ATLAS_2012_CONF_2012_105.cc \
	ATLAS_2012_CONF_2012_109.cc \
	+ ATLAS_2012_CONF_2012_153.cc \
	+ ATLAS_2015_CONF_2015_041.cc \
	+ ATLAS_2016_CONF_2016_037.cc \
	+ ATLAS_2016_CONF_2016_054.cc \
	+ ATLAS_2016_CONF_2016_078.cc \
	+ ATLAS_2016_CONF_2016_094.cc \
	+ ATLAS_2011_S9041966.cc \
	+ ATLAS_2011_S9212353.cc \
	ATLAS_2012_I946427.cc
	-endif
	-if ENABLE_UNVALIDATED
	-RivetATLASAnalyses_la_SOURCES += \
	+# UNVALIDATED
	+ATLAS_ALL_2 += \
	ATLAS_2011_S9108483.cc \
	ATLAS_2012_I1095236.cc \
	- ATLAS_2012_I1082009.cc \
	ATLAS_2012_I1126136.cc \
	ATLAS_2012_I1180197.cc \
	ATLAS_2012_I1186556.cc \
	- ATLAS_2012_I1190891.cc \
	- ATLAS_2012_CONF_2012_153.cc
	-endif
	+ ATLAS_2012_I1190891.cc


	lib_LTLIBRARIES += RivetCMSAnalyses.la
	-RivetCMSAnalyses_la_SOURCES = \
	+
	+nodist_RivetCMSAnalyses_la_SOURCES = CMS__all.cc
	+BUILT_SOURCES += CMS__all.cc
	+DISTCLEANFILES += CMS__all.cc
	+
	+CMS__all.cc : $(CMS_ALL)
	+
	+EXTRA_DIST += $(CMS_ALL)
	+
	+
	+
	+CMS_ALL = \
	CMS_2010_S8547297.cc \
	CMS_2010_S8656010.cc \
	CMS_2011_S8884919.cc \
	CMS_2011_S8941262.cc \
	CMS_2011_S8950903.cc \
	CMS_2011_S8957746.cc \
	CMS_2011_S8968497.cc \
	CMS_2011_S8973270.cc \
	CMS_2011_S8978280.cc \
	CMS_2011_S9086218.cc \
	CMS_2011_S9088458.cc \
	CMS_2011_S9120041.cc \
	CMS_2011_S9215166.cc \
	CMS_2012_I941555.cc \
	CMS_2011_I954992.cc \
	CMS_2012_I1087342.cc \
	CMS_2012_I1090423.cc \
	CMS_2012_I1102908.cc \
	CMS_2012_I1107658.cc \
	CMS_2012_I1184941.cc \
	CMS_2012_I1193338.cc \
	CMS_2013_I1122847.cc \
	CMS_2013_I1208923.cc \
	CMS_2013_I1209721.cc \
	CMS_2013_I1218372.cc \
	+ CMS_2013_I1223519.cc \
	CMS_2013_I1224539_DIJET.cc \
	CMS_2013_I1224539_WJET.cc \
	CMS_2013_I1224539_ZJET.cc \
	CMS_2013_I1256943.cc \
	CMS_2013_I1258128.cc \
	CMS_2013_I1261026.cc \
	CMS_2013_I1265659.cc \
	CMS_2013_I1272853.cc \
	CMS_2013_I1273574.cc \
	+ CMS_2012_I1298807.cc \
	CMS_2014_I1298810.cc \
	CMS_2014_I1303894.cc \
	+ CMS_2014_I1305624.cc \
	CMS_2015_I1310737.cc \
	CMS_2015_I1327224.cc \
	CMS_2015_I1346843.cc \
	CMS_2015_I1356998.cc \
	CMS_2015_I1370682.cc \
	CMS_2015_I1384119.cc \
	CMS_2015_I1385107.cc \
	+ CMS_2015_I1397174.cc \
	+ CMS_2016_I1459051.cc \
	+ CMS_2016_I1473674.cc \
	CMSTOTEM_2014_I1294140.cc \
	TOTEM_2014_I1328627.cc
	-if ENABLE_PRELIMINARY
	-RivetCMSAnalyses_la_SOURCES += \
	- CMS_QCD_10_024.cc \
	- CMS_2012_PAS_QCD_11_010.cc
	-endif
	+# PRELIMINARY
	+CMS_ALL += \
	+ CMS_2010_PAS_QCD_10_024.cc \
	+ CMS_2012_PAS_QCD_11_010.cc \
	+ CMS_2012_PAS_FSQ_12_020.cc \
	+ CMS_2016_PAS_SUS_16_14.cc


	lib_LTLIBRARIES += RivetLHCbAnalyses.la
	-RivetLHCbAnalyses_la_SOURCES = \
	+
	+nodist_RivetLHCbAnalyses_la_SOURCES = LHCb__all.cc
	+BUILT_SOURCES += LHCb__all.cc
	+DISTCLEANFILES += LHCb__all.cc
	+
	+LHCb__all.cc : $(LHCb_ALL)
	+
	+EXTRA_DIST += $(LHCb_ALL)
	+
	+LHCb_ALL = \
	LHCB_2010_I867355.cc \
	+ LHCB_2010_S8758301.cc \
	+ LHCB_2011_I917009.cc \
	+ LHCB_2011_I919315.cc \
	+ LHCB_2012_I1119400.cc \
	LHCB_2012_I1208102.cc \
	LHCB_2013_I1218996.cc \
	LHCB_2013_I1208105.cc \
	+ LHCB_2014_I1262703.cc \
	LHCB_2014_I1281685.cc \
	LHCB_2015_I1333223.cc
	-if ENABLE_UNVALIDATED
	-RivetLHCbAnalyses_la_SOURCES += \
	- LHCB_2010_S8758301.cc \
	- LHCB_2011_I917009.cc \
	- LHCB_2011_I919315.cc \
	- LHCB_2012_I1119400.cc
	-endif


	lib_LTLIBRARIES += RivetLHCfAnalyses.la
	RivetLHCfAnalyses_la_SOURCES = \
	LHCF_2012_I1115479.cc


	lib_LTLIBRARIES += RivetTOTEMAnalyses.la
	RivetTOTEMAnalyses_la_SOURCES = \
	TOTEM_2012_I1115294.cc \
	- TOTEM_2012_002.cc # TODO: update to Inspire ID
	+ TOTEM_2012_I1220862.cc


	lib_LTLIBRARIES += RivetCDFAnalyses.la
	-RivetCDFAnalyses_la_SOURCES = \
	+
	+nodist_RivetCDFAnalyses_la_SOURCES = CDF__all.cc
	+BUILT_SOURCES += CDF__all.cc
	+DISTCLEANFILES += CDF__all.cc
	+
	+CDF__all.cc : $(CDF_ALL)
	+
	+EXTRA_DIST += $(CDF_ALL)
	+
	+
	+
	+CDF_ALL = \
	CDF_1988_S1865951.cc \
	CDF_1990_S2089246.cc \
	CDF_1994_S2952106.cc \
	CDF_1996_S3418421.cc \
	CDF_1998_S3618439.cc \
	CDF_2000_S4155203.cc \
	CDF_2000_S4266730.cc \
	CDF_2001_S4517016.cc \
	CDF_2001_S4751469.cc \
	CDF_2002_S4796047.cc \
	CDF_2004_S5839831.cc \
	CDF_2005_S6080774.cc \
	CDF_2005_S6217184.cc \
	CDF_2006_S6450792.cc \
	CDF_2006_S6653332.cc \
	CDF_2007_S7057202.cc \
	CDF_2008_S7540469.cc \
	+ CDF_2008_S7541902.cc \
	+ CDF_2008_S7782535.cc \
	CDF_2008_S7828950.cc \
	CDF_2008_S8093652.cc \
	CDF_2008_S8095620.cc \
	CDF_2009_S8233977.cc \
	- CDF_2009_S8383952.cc \
	+ CDF_2009_I856131.cc \
	CDF_2009_S8436959.cc \
	CDF_2010_S8591881_DY.cc \
	CDF_2010_S8591881_QCD.cc \
	- CDF_2012_I1124333.cc
	-if ENABLE_PRELIMINARY
	-RivetCDFAnalyses_la_SOURCES += \
	+ CDF_2012_I1124333.cc \
	+ CDF_2015_1388868.cc
	+# PRELIMINARY
	+CDF_ALL += \
	CDF_2009_NOTE_9936.cc \
	CDF_2012_NOTE10874.cc
	-endif
	-
	-if ENABLE_UNVALIDATED
	-RivetCDFAnalyses_la_SOURCES += \
	+# UNVALIDATED
	+CDF_ALL += \
	CDF_1993_S2742446.cc \
	CDF_1996_S3108457.cc \
	CDF_1996_S3349578.cc \
	CDF_1997_S3541940.cc \
	- CDF_2001_S4563131.cc \
	- CDF_2008_S7541902.cc \
	- CDF_2008_S7782535.cc
	-endif
	+ CDF_2001_S4563131.cc


	lib_LTLIBRARIES += RivetD0Analyses.la
	-RivetD0Analyses_la_SOURCES = \
	+
	+nodist_RivetD0Analyses_la_SOURCES = D0__all.cc
	+BUILT_SOURCES += D0__all.cc
	+DISTCLEANFILES += D0__all.cc
	+
	+D0__all.cc : $(D0_ALL)
	+
	+EXTRA_DIST += $(D0_ALL)
	+
	+
	+
	+D0_ALL = \
	+ D0_1995_I398175.cc \
	D0_2000_I499943.cc \
	+ D0_2000_S4480767.cc \
	D0_2001_S4674421.cc \
	D0_2004_S5992206.cc \
	D0_2006_S6438750.cc \
	D0_2007_S7075677.cc \
	D0_2008_S6879055.cc \
	D0_2008_S7554427.cc \
	D0_2008_S7662670.cc \
	D0_2008_S7719523.cc \
	D0_2008_S7837160.cc \
	D0_2008_S7863608.cc \
	D0_2009_S8202443.cc \
	D0_2009_S8320160.cc \
	D0_2009_S8349509.cc \
	D0_2010_S8566488.cc \
	D0_2010_S8570965.cc \
	D0_2010_S8671338.cc \
	D0_2010_S8821313.cc \
	D0_2011_I895662.cc \
	D0_2015_I1324946.cc \
	D0_2000_I503361.cc
	-if ENABLE_UNVALIDATED
	-RivetD0Analyses_la_SOURCES += \
	- D0_2000_S4480767.cc \
	+# UNVALIDATED
	+D0_ALL += \
	D0_1996_S3214044.cc \
	D0_1996_S3324664.cc
	-endif


	lib_LTLIBRARIES += RivetHERAAnalyses.la
	-RivetHERAAnalyses_la_SOURCES = \
	+
	+nodist_RivetHERAAnalyses_la_SOURCES = HERA__all.cc
	+BUILT_SOURCES += HERA__all.cc
	+DISTCLEANFILES += HERA__all.cc
	+
	+HERA__all.cc : $(HERA_ALL)
	+
	+EXTRA_DIST += $(HERA_ALL)
	+
	+
	+
	+HERA_ALL = \
	H1_1994_S2919893.cc \
	H1_2000_S4129130.cc
	-if ENABLE_UNVALIDATED
	-RivetHERAAnalyses_la_SOURCES += \
	+# UNVALIDATED
	+HERA_ALL += \
	H1_1995_S3167097.cc \
	ZEUS_2001_S4815815.cc
	-endif
	+

	lib_LTLIBRARIES += RivetPetraAnalyses.la
	RivetPetraAnalyses_la_SOURCES = \
	JADE_1998_S3612880.cc \
	TASSO_1990_S2148048.cc

	lib_LTLIBRARIES += RivetLEPAnalyses.la
	-RivetLEPAnalyses_la_SOURCES = \
	+
	+nodist_RivetLEPAnalyses_la_SOURCES = LEP__all.cc
	+BUILT_SOURCES += LEP__all.cc
	+DISTCLEANFILES += LEP__all.cc
	+
	+LEP__all.cc : $(LEP_ALL)
	+
	+EXTRA_DIST += $(LEP_ALL)
	+
	+
	+
	+LEP_ALL = \
	ALEPH_1991_S2435284.cc \
	+ ALEPH_1995_I382179.cc \
	ALEPH_1996_S3486095.cc \
	ALEPH_1996_S3196992.cc \
	ALEPH_1999_S4193598.cc \
	ALEPH_2001_S4656318.cc \
	ALEPH_2002_S4823664.cc \
	ALEPH_2004_S5765862.cc \
	DELPHI_1995_S3137023.cc \
	DELPHI_1996_S3430090.cc \
	DELPHI_1999_S3960137.cc \
	DELPHI_2000_S4328825.cc \
	+ DELPHI_2011_I890503.cc \
	+ L3_1992_I336180.cc \
	+ L3_2004_I652683.cc \
	+ OPAL_1993_I342766.cc \
	OPAL_1994_S2927284.cc \
	OPAL_1995_S3198391.cc \
	OPAL_1996_S3257789.cc \
	OPAL_1997_S3396100.cc \
	OPAL_1997_S3608263.cc \
	OPAL_1998_S3702294.cc \
	OPAL_1998_S3749908.cc \
	OPAL_1998_S3780481.cc \
	OPAL_2000_S4418603.cc \
	OPAL_2001_S4553896.cc \
	OPAL_2002_S5361494.cc \
	+ OPAL_2003_I599181.cc \
	OPAL_2004_S6132243.cc \
	SLD_1996_S3398250.cc \
	SLD_1999_S3743934.cc \
	SLD_2002_S4869273.cc \
	SLD_2004_S5693039.cc
	-if ENABLE_PRELIMINARY
	-RivetLEPAnalyses_la_SOURCES += \
	+# UNVALIDATED
	+LEP_ALL += \
	+ OPAL_1993_S2692198.cc
	+# OBSOLETE
	+LEP_ALL += \
	DELPHI_2002_069_CONF_603.cc
	-endif
	-if ENABLE_UNVALIDATED
	-RivetLEPAnalyses_la_SOURCES += \
	- OPAL_1993_S2692198.cc
	-endif


	lib_LTLIBRARIES += RivetRHICAnalyses.la
	-RivetRHICAnalyses_la_SOURCES = \
	+
	+nodist_RivetRHICAnalyses_la_SOURCES = RHIC__all.cc
	+BUILT_SOURCES += RHIC__all.cc
	+DISTCLEANFILES += RHIC__all.cc
	+
	+RHIC__all.cc : $(RHIC_ALL)
	+
	+EXTRA_DIST += $(RHIC_ALL)
	+
	+
	+
	+RHIC_ALL = \
	STAR_2006_S6500200.cc \
	STAR_2006_S6860818.cc \
	STAR_2006_S6870392.cc
	-if ENABLE_PRELIMINARY
	-RivetRHICAnalyses_la_SOURCES += \
	+# PRELIMINARY
	+RHIC_ALL += \
	STAR_2009_UE_HELEN.cc
	-endif
	-if ENABLE_UNVALIDATED
	-RivetRHICAnalyses_la_SOURCES += \
	+# UNVALIDATED
	+RHIC_ALL += \
	STAR_2008_S7869363.cc \
	STAR_2008_S7993412.cc
	-endif


	lib_LTLIBRARIES += RivetSPSAnalyses.la
	-RivetSPSAnalyses_la_SOURCES = \
	+
	+nodist_RivetSPSAnalyses_la_SOURCES = SPS__all.cc
	+BUILT_SOURCES += SPS__all.cc
	+DISTCLEANFILES += SPS__all.cc
	+
	+SPS__all.cc : $(SPS_ALL)
	+
	+EXTRA_DIST += $(SPS_ALL)
	+
	+
	+
	+SPS_ALL = \
	UA1_1990_S2044935.cc \
	UA5_1982_S875503.cc \
	UA5_1986_S1583476.cc \
	UA5_1987_S1640666.cc \
	UA5_1988_S1867512.cc \
	UA5_1989_S1926373.cc


	lib_LTLIBRARIES += RivetMiscAnalyses.la
	-RivetMiscAnalyses_la_SOURCES = \
	+
	+nodist_RivetMiscAnalyses_la_SOURCES = Misc__all.cc
	+BUILT_SOURCES += Misc__all.cc
	+DISTCLEANFILES += Misc__all.cc
	+
	+Misc__all.cc : $(Misc_ALL)
	+
	+EXTRA_DIST += $(Misc_ALL)
	+
	+
	+
	+Misc_ALL = \
	+ E735_1998_S3905616.cc \
	PDG_HADRON_MULTIPLICITIES.cc \
	PDG_HADRON_MULTIPLICITIES_RATIOS.cc \
	PDG_TAUS.cc \
	JADE_OPAL_2000_S4300807.cc \
	ARGUS_1993_S2653028.cc \
	ARGUS_1993_S2669951.cc \
	ARGUS_1993_S2789213.cc \
	BABAR_2003_I593379.cc \
	BABAR_2005_S6181155.cc \
	BABAR_2007_S6895344.cc \
	BABAR_2007_S7266081.cc \
	+ BABAR_2013_I1116411.cc \
	BABAR_2013_I1238276.cc \
	+ BABAR_2015_I1334693.cc \
	BELLE_2001_S4598261.cc \
	BELLE_2008_I786560.cc \
	+ BELLE_2011_I878990.cc \
	BELLE_2013_I1216515.cc \
	+ BELLE_2013_I1238273.cc \
	+ BELLE_2015_I1397632.cc \
	CLEO_2004_S5809304.cc
	-if ENABLE_UNVALIDATED
	-RivetMiscAnalyses_la_SOURCES += \
	- E735_1998_S3905616.cc \
	+# UNVALIDATED
	+Misc_ALL += \
	SFM_1984_S1178091.cc
	-endif


	lib_LTLIBRARIES += RivetMCAnalyses.la
	-RivetMCAnalyses_la_SOURCES = \
	+
	+nodist_RivetMCAnalyses_la_SOURCES = MC__all.cc
	+BUILT_SOURCES += MC__all.cc
	+DISTCLEANFILES += MC__all.cc
	+
	+MC__all.cc : $(MC_ALL)
	+
	+EXTRA_DIST += $(MC_ALL)
	+
	+
	+
	+MC_ALL = \
	EXAMPLE.cc \
	EXAMPLE_CUTS.cc \
	EXAMPLE_SMEAR.cc \
	MC_QCD_PARTONS.cc \
	+ MC_CENTRALITY.cc \
	MC_DIPHOTON.cc \
	MC_ELECTRONS.cc \
	MC_GENERIC.cc \
	MC_HINC.cc \
	MC_HJETS.cc \
	MC_HHJETS.cc \
	MC_HKTSPLITTINGS.cc \
	MC_IDENTIFIED.cc \
	MC_JETS.cc \
	MC_JETTAGS.cc \
	MC_HFJETS.cc \
	MC_LEADJETUE.cc \
	+ MC_MET.cc \
	MC_MUONS.cc \
	MC_PDFS.cc \
	MC_PHOTONINC.cc \
	MC_PHOTONJETS.cc \
	MC_PHOTONKTSPLITTINGS.cc \
	MC_PHOTONS.cc \
	MC_PRINTEVENT.cc \
	MC_SUSY.cc \
	MC_TTBAR.cc \
	MC_VH2BB.cc \
	MC_WINC.cc \
	MC_WJETS.cc \
	MC_WKTSPLITTINGS.cc \
	MC_WPOL.cc \
	MC_WWINC.cc \
	MC_WWJETS.cc \
	MC_WWKTSPLITTINGS.cc \
	MC_XS.cc \
	MC_ZINC.cc \
	MC_ZJETS.cc \
	MC_ZKTSPLITTINGS.cc \
	MC_ZZINC.cc \
	MC_ZZJETS.cc \
	MC_ZZKTSPLITTINGS.cc

	-
	-if ENABLE_UNVALIDATED
	-RivetMCAnalyses_la_SOURCES += \
	- MC_DIJET.cc
	endif
	-
	-endif
	diff --git a/src/Analyses/OPAL_1993_I342766.cc b/src/Analyses/OPAL_1993_I342766.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/OPAL_1993_I342766.cc
	@@ -0,0 +1,91 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/FinalState.hh"
	+#include "Rivet/Projections/ChargedFinalState.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+#include "Rivet/Projections/Beam.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief A Measurement of K*+- (892) production in hadronic Z0 decays
	+ /// @author Simone Amoroso
	+ class OPAL_1993_I342766 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(OPAL_1993_I342766);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+ // Initialise and register projections
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	+ // Book histograms
	+ _histXeKStar892 = bookHisto1D( 1, 1, 1);
	+ _histMeanKStar892 = bookHisto1D( 2, 1, 1);
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	+ const size_t numParticles = fs.particles().size();
	+
	+ // Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	+ if (numParticles < 2) {
	+ MSG_DEBUG("Failed leptonic event cut");
	+ vetoEvent;
	+ }
	+ MSG_DEBUG("Passed leptonic event cut");
	+
	+ // Get event weight for histo filling
	+ const double weight = event.weight();
	+
	+ // Get beams and average beam momentum
	+ const ParticlePair& beams = apply<Beam>(event, "Beams").beams();
	+ const double meanBeamMom = ( beams.first.p3().mod() +
	+ beams.second.p3().mod() ) / 2.0;
	+ MSG_DEBUG("Avg beam momentum = " << meanBeamMom);
	+
	+ // Final state of unstable particles to get particle spectra
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");
	+
	+ foreach (const Particle& p, ufs.particles(Cuts::abspid==323)) {
	+ double xp = p.p3().mod()/meanBeamMom;
	+ _histXeKStar892->fill(xp, weight);
	+ _histMeanKStar892->fill(_histMeanKStar892->bin(0).xMid(), weight);
	+ }
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ scale(_histXeKStar892, 1./sumOfWeights());
	+ scale(_histMeanKStar892, 1./sumOfWeights());
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ /// @name Histograms
	+ Histo1DPtr _histXeKStar892;
	+ Histo1DPtr _histMeanKStar892;
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(OPAL_1993_I342766);
	+
	+
	+}
	diff --git a/src/Analyses/OPAL_1993_S2692198.cc b/src/Analyses/OPAL_1993_S2692198.cc
	--- a/src/Analyses/OPAL_1993_S2692198.cc
	+++ b/src/Analyses/OPAL_1993_S2692198.cc
	@@ -1,163 +1,163 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "fastjet/JadePlugin.hh"

	namespace Rivet {


	/// @brief OPAL photon production
	/// @author Peter Richardson
	class OPAL_1993_S2692198 : public Analysis {
	public:

	/// Constructor
	OPAL_1993_S2692198()
	: Analysis("OPAL_1993_S2692198")
	{ }


	/// @name Analysis methods
	//@{

	void analyze(const Event& e) {
	// Get event weight for histo filling
	const double weight = e.weight();

	// Extract the photons
	Particles photons;
	Particles nonPhotons;
	FourMomentum ptotal;
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	foreach (const Particle& p, fs.particles()) {
	ptotal+= p.momentum();
	if (p.pid() == PID::PHOTON) {
	photons.push_back(p);
	} else {
	nonPhotons.push_back(p);
	}
	}
	// No photon return but still count for normalisation
	if (photons.empty()) return;
	// Definition of the Durham algorithm
	fastjet::JetDefinition durham_def(fastjet::ee_kt_algorithm, fastjet::E_scheme, fastjet::Best);
	// Definition of the JADE algorithm
	fastjet::JadePlugin jade;
	fastjet::JetDefinition jade_def = fastjet::JetDefinition(&jade);
	// Now for the weird jet algorithm
	double evis = ptotal.mass();
	vector<fastjet::PseudoJet> input_particles;
	// Pseudo-jets from the non photons
	foreach (const Particle& p, nonPhotons) {
	const FourMomentum p4 = p.momentum();
	input_particles.push_back(fastjet::PseudoJet(p4.px(), p4.py(), p4.pz(), p4.E()));
	}
	// Pseudo-jets from all bar the first photon
	for (size_t ix = 1; ix < photons.size(); ++ix) {
	const FourMomentum p4 = photons[ix].momentum();
	input_particles.push_back(fastjet::PseudoJet(p4.px(), p4.py(), p4.pz(), p4.E()));
	}
	// Now loop over the photons
	for (size_t ix = 0; ix < photons.size(); ++ix) {
	FourMomentum pgamma = photons[ix].momentum();
	// Run the jet clustering DURHAM
	fastjet::ClusterSequence clust_seq(input_particles, durham_def);
	// Cluster the jets
	for (size_t j = 0; j < _nPhotonDurham->numBins(); ++j) {
	bool accept(true);
	double ycut = _nPhotonDurham->bin(j).xMid(); ///< @todo Should this be xMin?
	double dcut = sqr(evis)*ycut;
	vector<fastjet::PseudoJet> exclusive_jets = sorted_by_E(clust_seq.exclusive_jets(dcut));
	for (size_t iy = 0; iy < exclusive_jets.size(); ++iy) {
	FourMomentum pjet(momentum(exclusive_jets[iy]));
	double cost = pjet.p3().unit().dot(pgamma.p3().unit());
	double ygamma = 2 * min(sqr(pjet.E()/evis), sqr(pgamma.E()/evis)) * (1 - cost);
	if (ygamma < ycut) {
	accept = false;
	break;
	}
	}
	if (!accept) continue;
	_nPhotonDurham->fill(ycut, weight*_nPhotonDurham->bin(j).xWidth());
	size_t njet = min(size_t(4), exclusive_jets.size()) - 1;
	if (j < _nPhotonJetDurham[njet]->numBins()) {
	_nPhotonJetDurham[njet]->fillBin(j, weight*_nPhotonJetDurham[njet]->bin(j).xWidth());
	}
	}
	// Run the jet clustering JADE
	fastjet::ClusterSequence clust_seq2(input_particles, jade_def);
	for (size_t j = 0; j < _nPhotonJade->numBins(); ++j) {
	bool accept(true);
	double ycut = _nPhotonJade->bin(j).xMid(); ///< @todo Should this be xMin?
	double dcut = sqr(evis)*ycut;
	vector<fastjet::PseudoJet> exclusive_jets = sorted_by_E(clust_seq2.exclusive_jets(dcut));
	for (size_t iy = 0; iy < exclusive_jets.size(); ++iy) {
	FourMomentum pjet(momentum(exclusive_jets[iy]));
	double cost = pjet.p3().unit().dot(pgamma.p3().unit());
	double ygamma = 2.pjet.E()pgamma.E()/sqr(evis)*(1.-cost);
	if (ygamma < ycut) {
	accept = false;
	break;
	}
	}
	if (!accept) continue;
	/// @todo Really want to use a "bar graph" here (i.e. ignore bin width)
	_nPhotonJade->fill(ycut, weight*_nPhotonJade->bin(j).xWidth());
	size_t njet = min(size_t(4), exclusive_jets.size()) - 1;
	if (j < _nPhotonJetJade[njet]->numBins()) {
	_nPhotonJetJade[njet]->fillBin(j, weight*_nPhotonJetJade[njet]->bin(j).xWidth());
	}
	}
	// Add this photon back in for the next iteration of the loop
	if (ix+1 != photons.size()) {
	input_particles[nonPhotons.size()+ix] = fastjet::PseudoJet(pgamma.px(), pgamma.py(), pgamma.pz(), pgamma.E());
	}
	}
	}


	void init() {
	// Projections
	- addProjection(FinalState(), "FS");
	+ declare(FinalState(), "FS");

	// Book datasets
	_nPhotonJade = bookHisto1D(1, 1, 1);
	_nPhotonDurham = bookHisto1D(2, 1, 1);
	for (size_t ix = 0; ix < 4; ++ix) {
	_nPhotonJetJade [ix] = bookHisto1D(3 , 1, 1+ix);
	_nPhotonJetDurham[ix] = bookHisto1D(4 , 1, 1+ix);
	}
	}


	/// Finalize
	void finalize() {
	const double fact = 1000/sumOfWeights();
	scale(_nPhotonJade, fact);
	scale(_nPhotonDurham, fact);
	for (size_t ix = 0; ix < 4; ++ix) {
	scale(_nPhotonJetJade [ix],fact);
	scale(_nPhotonJetDurham[ix],fact);
	}
	}

	//@}

	private:

	Histo1DPtr _nPhotonJade;
	Histo1DPtr _nPhotonDurham;
	Histo1DPtr _nPhotonJetJade [4];
	Histo1DPtr _nPhotonJetDurham[4];

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_1993_S2692198);

	}
	diff --git a/src/Analyses/OPAL_1994_S2927284.cc b/src/Analyses/OPAL_1994_S2927284.cc
	--- a/src/Analyses/OPAL_1994_S2927284.cc
	+++ b/src/Analyses/OPAL_1994_S2927284.cc
	@@ -1,88 +1,88 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	/// @brief OPAL charged particle fragmentation functions
	/// @author Peter Richardson
	class OPAL_1994_S2927284 : public Analysis {
	public:

	/// Constructor
	OPAL_1994_S2927284()
	: Analysis("OPAL_1994_S2927284")
	{ }


	/// @name Analysis methods
	//@{

	void analyze(const Event& e) {

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	if (fs.particles().size() < 2) {
	MSG_DEBUG("Failed ncharged cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed ncharged cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	foreach (const Particle& p, fs.particles()) {
	int id = p.abspid();
	// charged pions
	if (id == PID::PIPLUS) {
	_histXpPiPlus->fill(p.p3().mod(), weight);
	} else if(id == PID::KPLUS) {
	_histXpKPlus->fill(p.p3().mod(), weight);
	} else if(id == PID::PROTON) {
	_histXpProton->fill(p.p3().mod(), weight);
	}
	}
	}


	void init() {
	// Projections
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");

	_histXpPiPlus = bookHisto1D( 1, 1, 1);
	_histXpKPlus = bookHisto1D( 2, 1, 1);
	_histXpProton = bookHisto1D( 3, 1, 1);
	}


	/// Finalize
	void finalize() {
	scale(_histXpPiPlus,1./sumOfWeights());
	scale(_histXpKPlus ,1./sumOfWeights());
	scale(_histXpProton,1./sumOfWeights());
	}

	//@}

	private:

	Histo1DPtr _histXpPiPlus;
	Histo1DPtr _histXpKPlus;
	Histo1DPtr _histXpProton;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_1994_S2927284);

	}
	diff --git a/src/Analyses/OPAL_1995_S3198391.cc b/src/Analyses/OPAL_1995_S3198391.cc
	--- a/src/Analyses/OPAL_1995_S3198391.cc
	+++ b/src/Analyses/OPAL_1995_S3198391.cc
	@@ -1,84 +1,84 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief OPAL Delta++ fragmentation function paper
	/// @author Peter Richardson
	class OPAL_1995_S3198391 : public Analysis {
	public:

	/// Constructor
	OPAL_1995_S3198391()
	: Analysis("OPAL_1995_S3198391")
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	_histXpDelta = bookHisto1D( 1, 1, 1);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	if(p.abspid()==2224) {
	double xp = p.p3().mod()/meanBeamMom;
	_histXpDelta->fill(xp, weight);
	}
	}
	}


	/// Finalize
	void finalize() {
	scale(_histXpDelta, 1./sumOfWeights());
	}

	//@}


	private:

	Histo1DPtr _histXpDelta;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_1995_S3198391);

	}
	diff --git a/src/Analyses/OPAL_1996_S3257789.cc b/src/Analyses/OPAL_1996_S3257789.cc
	--- a/src/Analyses/OPAL_1996_S3257789.cc
	+++ b/src/Analyses/OPAL_1996_S3257789.cc
	@@ -1,97 +1,97 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief OPAL J/Psi fragmentation function paper
	/// @author Peter Richardson
	class OPAL_1996_S3257789 : public Analysis {
	public:

	/// Constructor
	OPAL_1996_S3257789()
	: Analysis("OPAL_1996_S3257789"), _weightSum(0.)
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	_histXpJPsi = bookHisto1D( 1, 1, 1);
	_multJPsi = bookHisto1D( 2, 1, 1);
	_multPsiPrime = bookHisto1D( 2, 1, 2);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	if(p.abspid()==443) {
	double xp = p.p3().mod()/meanBeamMom;
	_histXpJPsi->fill(xp, weight);
	_multJPsi->fill(91.2,weight);
	_weightSum += weight;
	}
	else if(p.abspid()==100443) {
	_multPsiPrime->fill(91.2,weight);
	}
	}
	}


	/// Finalize
	void finalize() {
	if(_weightSum>0.)
	scale(_histXpJPsi , 0.1/_weightSum);
	scale(_multJPsi , 1./sumOfWeights());
	scale(_multPsiPrime, 1./sumOfWeights());
	}

	//@}


	private:

	double _weightSum;
	Histo1DPtr _histXpJPsi;
	Histo1DPtr _multJPsi;
	Histo1DPtr _multPsiPrime;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_1996_S3257789);

	}
	diff --git a/src/Analyses/OPAL_1997_S3396100.cc b/src/Analyses/OPAL_1997_S3396100.cc
	--- a/src/Analyses/OPAL_1997_S3396100.cc
	+++ b/src/Analyses/OPAL_1997_S3396100.cc
	@@ -1,163 +1,163 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief OPAL strange baryon paper
	/// @author Peter Richardson
	class OPAL_1997_S3396100 : public Analysis {
	public:

	/// Constructor
	OPAL_1997_S3396100()
	: Analysis("OPAL_1997_S3396100"),
	_weightedTotalNumLambda(0.) ,_weightedTotalNumXiMinus(0.),
	_weightedTotalNumSigma1385Plus(0.),_weightedTotalNumSigma1385Minus(0.),
	_weightedTotalNumXi1530(0.) ,_weightedTotalNumLambda1520(0.)
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	_histXpLambda = bookHisto1D( 1, 1, 1);
	_histXiLambda = bookHisto1D( 2, 1, 1);
	_histXpXiMinus = bookHisto1D( 3, 1, 1);
	_histXiXiMinus = bookHisto1D( 4, 1, 1);
	_histXpSigma1385Plus = bookHisto1D( 5, 1, 1);
	_histXiSigma1385Plus = bookHisto1D( 6, 1, 1);
	_histXpSigma1385Minus = bookHisto1D( 7, 1, 1);
	_histXiSigma1385Minus = bookHisto1D( 8, 1, 1);
	_histXpXi1530 = bookHisto1D( 9, 1, 1);
	_histXiXi1530 = bookHisto1D(10, 1, 1);
	_histXpLambda1520 = bookHisto1D(11, 1, 1);
	_histXiLambda1520 = bookHisto1D(12, 1, 1);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	const int id = p.abspid();
	double xp = p.p3().mod()/meanBeamMom;
	double xi = -log(xp);
	switch (id) {
	case 3312:
	_histXpXiMinus->fill(xp, weight);
	_histXiXiMinus->fill(xi, weight);
	_weightedTotalNumXiMinus += weight;
	break;
	case 3224:
	_histXpSigma1385Plus->fill(xp, weight);
	_histXiSigma1385Plus->fill(xi, weight);
	_weightedTotalNumSigma1385Plus += weight;
	break;
	case 3114:
	_histXpSigma1385Minus->fill(xp, weight);
	_histXiSigma1385Minus->fill(xi, weight);
	_weightedTotalNumSigma1385Minus += weight;
	break;
	case 3122:
	_histXpLambda->fill(xp, weight);
	_histXiLambda->fill(xi, weight);
	_weightedTotalNumLambda += weight;
	break;
	case 3324:
	_histXpXi1530->fill(xp, weight);
	_histXiXi1530->fill(xi, weight);
	_weightedTotalNumXi1530 += weight;
	break;
	case 3124:
	_histXpLambda1520->fill(xp, weight);
	_histXiLambda1520->fill(xi, weight);
	_weightedTotalNumLambda1520 += weight;
	break;
	}
	}
	}


	/// Finalize
	void finalize() {
	normalize(_histXpLambda , _weightedTotalNumLambda /sumOfWeights());
	normalize(_histXiLambda , _weightedTotalNumLambda /sumOfWeights());
	normalize(_histXpXiMinus , _weightedTotalNumXiMinus /sumOfWeights());
	normalize(_histXiXiMinus , _weightedTotalNumXiMinus /sumOfWeights());
	normalize(_histXpSigma1385Plus , _weightedTotalNumSigma1385Plus/sumOfWeights());
	normalize(_histXiSigma1385Plus , _weightedTotalNumSigma1385Plus/sumOfWeights());
	normalize(_histXpSigma1385Minus, _weightedTotalNumSigma1385Plus/sumOfWeights());
	normalize(_histXiSigma1385Minus, _weightedTotalNumSigma1385Plus/sumOfWeights());
	normalize(_histXpXi1530 , _weightedTotalNumXi1530 /sumOfWeights());
	normalize(_histXiXi1530 , _weightedTotalNumXi1530 /sumOfWeights());
	normalize(_histXpLambda1520 , _weightedTotalNumLambda1520 /sumOfWeights());
	normalize(_histXiLambda1520 , _weightedTotalNumLambda1520 /sumOfWeights());
	}

	//@}


	private:

	/// Store the weighted sums of numbers of charged / charged+neutral
	/// particles - used to calculate average number of particles for the
	/// inclusive single particle distributions' normalisations.
	double _weightedTotalNumLambda;
	double _weightedTotalNumXiMinus;
	double _weightedTotalNumSigma1385Plus;
	double _weightedTotalNumSigma1385Minus;
	double _weightedTotalNumXi1530;
	double _weightedTotalNumLambda1520;

	Histo1DPtr _histXpLambda ;
	Histo1DPtr _histXiLambda ;
	Histo1DPtr _histXpXiMinus ;
	Histo1DPtr _histXiXiMinus ;
	Histo1DPtr _histXpSigma1385Plus ;
	Histo1DPtr _histXiSigma1385Plus ;
	Histo1DPtr _histXpSigma1385Minus;
	Histo1DPtr _histXiSigma1385Minus;
	Histo1DPtr _histXpXi1530 ;
	Histo1DPtr _histXiXi1530 ;
	Histo1DPtr _histXpLambda1520 ;
	Histo1DPtr _histXiLambda1520 ;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_1997_S3396100);

	}
	diff --git a/src/Analyses/OPAL_1997_S3608263.cc b/src/Analyses/OPAL_1997_S3608263.cc
	--- a/src/Analyses/OPAL_1997_S3608263.cc
	+++ b/src/Analyses/OPAL_1997_S3608263.cc
	@@ -1,85 +1,85 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief OPAL K*0 fragmentation function paper
	/// @author Peter Richardson
	class OPAL_1997_S3608263 : public Analysis {
	public:

	/// Constructor
	OPAL_1997_S3608263()
	: Analysis("OPAL_1997_S3608263")
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	_histXeK0 = bookHisto1D( 1, 1, 1);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	const int id = p.abspid();
	if (id==313) {
	double xp = p.p3().mod()/meanBeamMom;
	_histXeK0->fill(xp, weight);
	}
	}
	}


	/// Finalize
	void finalize() {
	scale(_histXeK0, 1./sumOfWeights());
	}

	//@}


	private:

	Histo1DPtr _histXeK0;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_1997_S3608263);

	}
	diff --git a/src/Analyses/OPAL_1998_S3702294.cc b/src/Analyses/OPAL_1998_S3702294.cc
	--- a/src/Analyses/OPAL_1998_S3702294.cc
	+++ b/src/Analyses/OPAL_1998_S3702294.cc
	@@ -1,99 +1,99 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief OPAL f0,f2 and phi fragmentation function paper
	/// @author Peter Richardson
	class OPAL_1998_S3702294 : public Analysis {
	public:

	/// Constructor
	OPAL_1998_S3702294()
	: Analysis("OPAL_1998_S3702294")
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	_histXpf0 = bookHisto1D( 2, 1, 1);
	_histXpf2 = bookHisto1D( 2, 1, 2);
	_histXpPhi = bookHisto1D( 2, 1, 3);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	const int id = p.abspid();
	double xp = p.p3().mod()/meanBeamMom;
	switch (id) {
	case 9010221:
	_histXpf0->fill(xp, weight);
	break;
	case 225:
	_histXpf2->fill(xp, weight);
	break;
	case 333:
	_histXpPhi->fill(xp, weight);
	break;
	}
	}
	}


	/// Finalize
	void finalize() {
	scale(_histXpf0 , 1./sumOfWeights());
	scale(_histXpf2 , 1./sumOfWeights());
	scale(_histXpPhi, 1./sumOfWeights());
	}

	//@}


	private:

	Histo1DPtr _histXpf0;
	Histo1DPtr _histXpf2;
	Histo1DPtr _histXpPhi;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_1998_S3702294);

	}
	diff --git a/src/Analyses/OPAL_1998_S3749908.cc b/src/Analyses/OPAL_1998_S3749908.cc
	--- a/src/Analyses/OPAL_1998_S3749908.cc
	+++ b/src/Analyses/OPAL_1998_S3749908.cc
	@@ -1,152 +1,152 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief OPAL photon/light meson paper
	/// @author Peter Richardson
	class OPAL_1998_S3749908 : public Analysis {
	public:

	/// Constructor
	OPAL_1998_S3749908()
	: Analysis("OPAL_1998_S3749908")
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	_histXePhoton = bookHisto1D( 2, 1, 1);
	_histXiPhoton = bookHisto1D( 3, 1, 1);
	_histXePi = bookHisto1D( 4, 1, 1);
	_histXiPi = bookHisto1D( 5, 1, 1);
	_histXeEta = bookHisto1D( 6, 1, 1);
	_histXiEta = bookHisto1D( 7, 1, 1);
	_histXeRho = bookHisto1D( 8, 1, 1);
	_histXiRho = bookHisto1D( 9, 1, 1);
	_histXeOmega = bookHisto1D(10, 1, 1);
	_histXiOmega = bookHisto1D(11, 1, 1);
	_histXeEtaPrime = bookHisto1D(12, 1, 1);
	_histXiEtaPrime = bookHisto1D(13, 1, 1);
	_histXeA0 = bookHisto1D(14, 1, 1);
	_histXiA0 = bookHisto1D(15, 1, 1);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	const int id = p.abspid();
	double xi = -log(p.p3().mod()/meanBeamMom);
	double xE = p.E()/meanBeamMom;
	switch (id) {
	case 22: // Photons
	_histXePhoton->fill(xE, weight);
	_histXiPhoton->fill(xi, weight);
	break;
	case 111: // Neutral pions
	_histXePi->fill(xE, weight);
	_histXiPi->fill(xi, weight);
	break;
	case 221: // eta
	_histXeEta->fill(xE, weight);
	_histXiEta->fill(xi, weight);
	break;
	case 213: // Charged rho (770)
	_histXeRho->fill(xE, weight);
	_histXiRho->fill(xi, weight);
	break;
	case 223: // omega (782)
	_histXeOmega->fill(xE, weight);
	_histXiOmega->fill(xi, weight);
	break;
	case 331: // eta' (958)
	_histXeEtaPrime->fill(xE, weight);
	_histXiEtaPrime->fill(xi, weight);
	break;
	case 9000211: // Charged a_0 (980)
	_histXeA0->fill(xE, weight);
	_histXiA0->fill(xi, weight);
	break;
	}
	}
	}


	/// Finalize
	void finalize() {
	scale(_histXePhoton , 1./sumOfWeights());
	scale(_histXiPhoton , 1./sumOfWeights());
	scale(_histXePi , 1./sumOfWeights());
	scale(_histXiPi , 1./sumOfWeights());
	scale(_histXeEta , 1./sumOfWeights());
	scale(_histXiEta , 1./sumOfWeights());
	scale(_histXeRho , 1./sumOfWeights());
	scale(_histXiRho , 1./sumOfWeights());
	scale(_histXeOmega , 1./sumOfWeights());
	scale(_histXiOmega , 1./sumOfWeights());
	scale(_histXeEtaPrime, 1./sumOfWeights());
	scale(_histXiEtaPrime, 1./sumOfWeights());
	scale(_histXeA0 , 1./sumOfWeights());
	scale(_histXiA0 , 1./sumOfWeights());
	}

	//@}


	private:

	Histo1DPtr _histXePhoton ;
	Histo1DPtr _histXiPhoton ;
	Histo1DPtr _histXePi ;
	Histo1DPtr _histXiPi ;
	Histo1DPtr _histXeEta ;
	Histo1DPtr _histXiEta ;
	Histo1DPtr _histXeRho ;
	Histo1DPtr _histXiRho ;
	Histo1DPtr _histXeOmega ;
	Histo1DPtr _histXiOmega ;
	Histo1DPtr _histXeEtaPrime;
	Histo1DPtr _histXiEtaPrime;
	Histo1DPtr _histXeA0 ;
	Histo1DPtr _histXiA0 ;
	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_1998_S3749908);

	}
	diff --git a/src/Analyses/OPAL_1998_S3780481.cc b/src/Analyses/OPAL_1998_S3780481.cc
	--- a/src/Analyses/OPAL_1998_S3780481.cc
	+++ b/src/Analyses/OPAL_1998_S3780481.cc
	@@ -1,195 +1,195 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/InitialQuarks.hh"

	namespace Rivet {


	/// @brief OPAL flavour-dependent fragmentation paper
	/// @author Hendrik Hoeth
	class OPAL_1998_S3780481 : public Analysis {
	public:

	/// Constructor
	OPAL_1998_S3780481() : Analysis("OPAL_1998_S3780481") {
	// Counters
	_weightedTotalPartNum = 0;
	_SumOfudsWeights = 0;
	_SumOfcWeights = 0;
	_SumOfbWeights = 0;
	}


	/// @name Analysis methods
	//@{

	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed ncharged cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed ncharged cut");

	// Get event weight for histo filling
	const double weight = e.weight();
	_weightedTotalPartNum += numParticles * weight;

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	int flavour = 0;
	- const InitialQuarks& iqf = applyProjection<InitialQuarks>(e, "IQF");
	+ const InitialQuarks& iqf = apply<InitialQuarks>(e, "IQF");

	// If we only have two quarks (qqbar), just take the flavour.
	// If we have more than two quarks, look for the highest energetic q-qbar pair.
	/// @todo Yuck... does this really have to be quark-based?!?
	if (iqf.particles().size() == 2) {
	flavour = iqf.particles().front().abspid();
	} else {
	map<int, double> quarkmap;
	foreach (const Particle& p, iqf.particles()) {
	if (quarkmap[p.pid()] < p.E()) {
	quarkmap[p.pid()] = p.E();
	}
	}
	double maxenergy = 0.;
	for (int i = 1; i <= 5; ++i) {
	if (quarkmap[i]+quarkmap[-i] > maxenergy) {
	flavour = i;
	}
	}
	}

	switch (flavour) {
	case 1:
	case 2:
	case 3:
	_SumOfudsWeights += weight;
	break;
	case 4:
	_SumOfcWeights += weight;
	break;
	case 5:
	_SumOfbWeights += weight;
	break;
	}

	foreach (const Particle& p, fs.particles()) {
	const double xp = p.p3().mod()/meanBeamMom;
	const double logxp = -std::log(xp);
	_histXpall->fill(xp, weight);
	_histLogXpall->fill(logxp, weight);
	_histMultiChargedall->fill(_histMultiChargedall->bin(0).xMid(), weight);
	switch (flavour) {
	/// @todo Use PDG code enums
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_histXpuds->fill(xp, weight);
	_histLogXpuds->fill(logxp, weight);
	_histMultiChargeduds->fill(_histMultiChargeduds->bin(0).xMid(), weight);
	break;
	case PID::CQUARK:
	_histXpc->fill(xp, weight);
	_histLogXpc->fill(logxp, weight);
	_histMultiChargedc->fill(_histMultiChargedc->bin(0).xMid(), weight);
	break;
	case PID::BQUARK:
	_histXpb->fill(xp, weight);
	_histLogXpb->fill(logxp, weight);
	_histMultiChargedb->fill(_histMultiChargedb->bin(0).xMid(), weight);
	break;
	}
	}

	}


	void init() {
	// Projections
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(InitialQuarks(), "IQF");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(InitialQuarks(), "IQF");

	// Book histos
	_histXpuds = bookHisto1D(1, 1, 1);
	_histXpc = bookHisto1D(2, 1, 1);
	_histXpb = bookHisto1D(3, 1, 1);
	_histXpall = bookHisto1D(4, 1, 1);
	_histLogXpuds = bookHisto1D(5, 1, 1);
	_histLogXpc = bookHisto1D(6, 1, 1);
	_histLogXpb = bookHisto1D(7, 1, 1);
	_histLogXpall = bookHisto1D(8, 1, 1);
	_histMultiChargeduds = bookHisto1D(9, 1, 1);
	_histMultiChargedc = bookHisto1D(9, 1, 2);
	_histMultiChargedb = bookHisto1D(9, 1, 3);
	_histMultiChargedall = bookHisto1D(9, 1, 4);
	}


	/// Finalize
	void finalize() {
	const double avgNumParts = _weightedTotalPartNum / sumOfWeights();
	normalize(_histXpuds , avgNumParts);
	normalize(_histXpc , avgNumParts);
	normalize(_histXpb , avgNumParts);
	normalize(_histXpall , avgNumParts);
	normalize(_histLogXpuds , avgNumParts);
	normalize(_histLogXpc , avgNumParts);
	normalize(_histLogXpb , avgNumParts);
	normalize(_histLogXpall , avgNumParts);

	scale(_histMultiChargeduds, 1.0/_SumOfudsWeights);
	scale(_histMultiChargedc , 1.0/_SumOfcWeights);
	scale(_histMultiChargedb , 1.0/_SumOfbWeights);
	scale(_histMultiChargedall, 1.0/sumOfWeights());
	}

	//@}


	private:

	/// Store the weighted sums of numbers of charged / charged+neutral
	/// particles - used to calculate average number of particles for the
	/// inclusive single particle distributions' normalisations.
	double _weightedTotalPartNum;

	double _SumOfudsWeights;
	double _SumOfcWeights;
	double _SumOfbWeights;

	Histo1DPtr _histXpuds;
	Histo1DPtr _histXpc;
	Histo1DPtr _histXpb;
	Histo1DPtr _histXpall;
	Histo1DPtr _histLogXpuds;
	Histo1DPtr _histLogXpc;
	Histo1DPtr _histLogXpb;
	Histo1DPtr _histLogXpall;
	Histo1DPtr _histMultiChargeduds;
	Histo1DPtr _histMultiChargedc;
	Histo1DPtr _histMultiChargedb;
	Histo1DPtr _histMultiChargedall;

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_1998_S3780481);

	}
	diff --git a/src/Analyses/OPAL_2000_S4418603.cc b/src/Analyses/OPAL_2000_S4418603.cc
	--- a/src/Analyses/OPAL_2000_S4418603.cc
	+++ b/src/Analyses/OPAL_2000_S4418603.cc
	@@ -1,86 +1,86 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief OPAL K0 fragmentation function paper
	/// @author Peter Richardson
	class OPAL_2000_S4418603 : public Analysis {
	public:

	/// Constructor
	OPAL_2000_S4418603()
	: Analysis("OPAL_2000_S4418603")
	{}


	/// @name Analysis methods
	//@{

	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	_histXeK0 = bookHisto1D( 3, 1, 1);
	}


	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	foreach (const Particle& p, ufs.particles()) {
	const int id = p.abspid();
	if (id == PID::K0S \|\| id == PID::K0L) {
	double xE = p.E()/meanBeamMom;
	_histXeK0->fill(xE, weight);
	}
	}
	}


	/// Finalize
	void finalize() {
	scale(_histXeK0, 1./sumOfWeights());
	}

	//@}


	private:

	Histo1DPtr _histXeK0;
	//@}

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_2000_S4418603);

	}
	diff --git a/src/Analyses/OPAL_2001_S4553896.cc b/src/Analyses/OPAL_2001_S4553896.cc
	--- a/src/Analyses/OPAL_2001_S4553896.cc
	+++ b/src/Analyses/OPAL_2001_S4553896.cc
	@@ -1,157 +1,159 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	namespace {

	/// @name Jet angle calculator functions
	//@{
	/// @todo Move to utils? (taken from DELPHI_2003)

	/// @todo Use Jet or FourMomentum interface rather than PseudoJet
	/// @todo Move to utils?
	double calc_BZ(const vector<fastjet::PseudoJet>& jets) {
	assert(jets.size() == 4);
	Vector3 p12 = cross( momentum3(jets[0]), momentum3(jets[1]));
	Vector3 p34 = cross( momentum3(jets[2]), momentum3(jets[3]));
	return dot(p12,p34) / (p12.mod()*p34.mod());
	}


	/// @todo Use Jet or FourMomentum interface rather than PseudoJet
	/// @todo Move to utils?
	double calc_KSW(const vector<fastjet::PseudoJet>& jets) {
	assert(jets.size() == 4);
	Vector3 p13 = cross( momentum3(jets[0]), momentum3(jets[2]));
	Vector3 p24 = cross( momentum3(jets[1]), momentum3(jets[3]));
	Vector3 p14 = cross( momentum3(jets[0]), momentum3(jets[3]));
	Vector3 p23 = cross( momentum3(jets[1]), momentum3(jets[2]));
	return cos (0.5( acos (dot(p14,p23) / (p14.mod()p23.mod())) +
	acos (dot(p13,p24) / (p13.mod()*p24.mod())) ));
	}


	/// @todo Use Jet or FourMomentum interface rather than PseudoJet
	/// @todo Move to utils?
	double calc_NR(const vector<fastjet::PseudoJet>& jets) {
	assert(jets.size() == 4);
	Vector3 p12 = momentum3(jets[0]) - momentum3(jets[1]);
	Vector3 p34 = momentum3(jets[2]) - momentum3(jets[3]);
	return dot(p12,p34) / (p12.mod()*p34.mod());
	}

	/// @todo Use Jet or FourMomentum interface rather than PseudoJet
	/// @todo Move to utils?
	double calc_ALPHA34(const vector<fastjet::PseudoJet>& jets) {
	assert(jets.size() == 4);
	Vector3 p3 = momentum3(jets[2]);
	Vector3 p4 = momentum3(jets[3]);
	return dot(p3,p4) / (p3.mod()*p4.mod());
	}

	//@}

	}


	class OPAL_2001_S4553896 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	OPAL_2001_S4553896()
	: Analysis("OPAL_2001_S4553896")
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	/// Initialise and register projections here
	const FinalState fs;
	- addProjection(fs, "FS");
	- addProjection(FastJets(fs, FastJets::DURHAM, 0.7), "Jets");
	+ declare(fs, "FS");
	+ declare(FastJets(fs, FastJets::DURHAM, 0.7), "Jets");


	/// @todo Book histograms here, e.g.:
	_h_BZ = bookHisto1D(3, 1, 1);
	_h_KSW = bookHisto1D(4, 1, 1);
	_h_NR = bookHisto1D(5, 1, 1);
	_h_ALPHA34 = bookHisto1D(6, 1, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	- if (applyProjection<FinalState>(event, "FS").particles().size() < 2) {
	+ if (apply<FinalState>(event, "FS").particles().size() < 2) {
	vetoEvent;
	}

	- const FastJets& fastjets = applyProjection<FastJets>(event, "Jets");
	+ const FastJets& fastjets = apply<FastJets>(event, "Jets");
	if (fastjets.clusterSeq()) {
	vector<fastjet::PseudoJet> jets;
	foreach (const fastjet::PseudoJet& jet,
	fastjet::sorted_by_E(fastjets.clusterSeq()->exclusive_jets_ycut(0.008))) {
	if (jet.E()>3.0*GeV) jets.push_back(jet);
	}
	if (jets.size() == 4) {
	- _h_BZ->fill(fabs(calc_BZ(jets)), weight);
	+ // Prevent nan-fill due to division by zero in calc_BZ
	+ double bz = fabs(calc_BZ(jets));
	+ if (!std::isnan(bz)) _h_BZ->fill(bz, weight);
	_h_KSW->fill(calc_KSW(jets), weight);
	_h_NR->fill(fabs(calc_NR(jets)), weight);
	_h_ALPHA34->fill(calc_ALPHA34(jets), weight);
	}
	}


	}


	/// Normalise histograms etc., after the run
	void finalize() {

	/// Normalise, scale and otherwise manipulate histograms here
	normalize(_h_BZ);
	normalize(_h_KSW);
	normalize(_h_NR);
	normalize(_h_ALPHA34);

	}

	//@}


	private:

	/// @name Histograms
	//@{

	Histo1DPtr _h_BZ;
	Histo1DPtr _h_KSW;
	Histo1DPtr _h_NR;
	Histo1DPtr _h_ALPHA34;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_2001_S4553896);

	}
	diff --git a/src/Analyses/OPAL_2002_S5361494.cc b/src/Analyses/OPAL_2002_S5361494.cc
	--- a/src/Analyses/OPAL_2002_S5361494.cc
	+++ b/src/Analyses/OPAL_2002_S5361494.cc
	@@ -1,139 +1,139 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/Sphericity.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ParisiTensor.hh"
	#include "Rivet/Projections/Hemispheres.hh"
	#include "Rivet/Projections/InitialQuarks.hh"
	#include <cmath>

	namespace Rivet {


	/// @brief OPAL multiplicities at various energies
	/// @author Peter Richardson
	class OPAL_2002_S5361494 : public Analysis {
	public:

	/// Constructor
	OPAL_2002_S5361494()
	: Analysis("OPAL_2002_S5361494"),
	_weightedTotalChargedPartNumLight(0.),
	_weightedTotalChargedPartNumCharm(0.),
	_weightedTotalChargedPartNumBottom(0.),
	_weightLight(0.),_weightCharm(0.),_weightBottom(0.)
	{}

	/// @name Analysis methods
	//@{


	void init() {
	// Projections
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "CFS");
	- addProjection(InitialQuarks(), "IQF");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "CFS");
	+ declare(InitialQuarks(), "IQF");

	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	- const FinalState& cfs = applyProjection<FinalState>(event, "CFS");
	+ const FinalState& cfs = apply<FinalState>(event, "CFS");
	if (cfs.size() < 2) vetoEvent;


	int flavour = 0;
	- const InitialQuarks& iqf = applyProjection<InitialQuarks>(event, "IQF");
	+ const InitialQuarks& iqf = apply<InitialQuarks>(event, "IQF");

	// If we only have two quarks (qqbar), just take the flavour.
	// If we have more than two quarks, look for the highest energetic q-qbar pair.
	if (iqf.particles().size() == 2) {
	flavour = iqf.particles().front().abspid();
	}
	else {
	map<int, double> quarkmap;
	foreach (const Particle& p, iqf.particles()) {
	if (quarkmap[p.pid()] < p.E()) {
	quarkmap[p.pid()] = p.E();
	}
	}
	double maxenergy = 0.;
	for (int i = 1; i <= 5; ++i) {
	if (quarkmap[i]+quarkmap[-i] > maxenergy) {
	flavour = i;
	}
	}
	}
	const size_t numParticles = cfs.particles().size();
	switch (flavour) {
	case 1: case 2: case 3:
	_weightLight += weight;
	_weightedTotalChargedPartNumLight += numParticles * weight;
	break;
	case 4:
	_weightCharm += weight;
	_weightedTotalChargedPartNumCharm += numParticles * weight;
	break;
	case 5:
	_weightBottom += weight;
	_weightedTotalChargedPartNumBottom += numParticles * weight;
	break;
	}

	}


	void finalize() {
	Histo1D temphisto(refData(1, 1, 1));

	const double avgNumPartsBottom = _weightBottom != 0. ? _weightedTotalChargedPartNumBottom / _weightBottom : 0.;
	const double avgNumPartsCharm = _weightCharm != 0. ? _weightedTotalChargedPartNumCharm / _weightCharm : 0.;
	const double avgNumPartsLight = _weightLight != 0. ? _weightedTotalChargedPartNumLight / _weightLight : 0.;
	Scatter2DPtr h_bottom = bookScatter2D(1, 1, 1);
	Scatter2DPtr h_charm = bookScatter2D(1, 1, 2);
	Scatter2DPtr h_light = bookScatter2D(1, 1, 3);
	Scatter2DPtr h_diff = bookScatter2D(1, 1, 4); // bottom minus light
	for (size_t b = 0; b < temphisto.numBins(); b++) {
	const double x = temphisto.bin(b).xMid();
	const double ex = temphisto.bin(b).xWidth()/2.;
	if (inRange(sqrtS()/GeV, x-ex, x+ex)) {
	// @TODO: Fix y-error:
	h_bottom->addPoint(x, avgNumPartsBottom, ex, 0.);
	h_charm->addPoint(x, avgNumPartsCharm, ex, 0.);
	h_light->addPoint(x, avgNumPartsLight, ex, 0.);
	h_diff->addPoint(x, avgNumPartsBottom-avgNumPartsLight, ex, 0.);
	}
	}
	}

	//@}


	private:

	/// @name Multiplicities
	//@{
	double _weightedTotalChargedPartNumLight;
	double _weightedTotalChargedPartNumCharm;
	double _weightedTotalChargedPartNumBottom;
	//@}

	/// @name Weights
	//@{
	double _weightLight;
	double _weightCharm;
	double _weightBottom;
	//@}
	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_2002_S5361494);

	}
	diff --git a/src/Analyses/OPAL_2003_I599181.cc b/src/Analyses/OPAL_2003_I599181.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Analyses/OPAL_2003_I599181.cc
	@@ -0,0 +1,83 @@
	+// -- C++ --
	+#include "Rivet/Analysis.hh"
	+#include "Rivet/Projections/UnstableFinalState.hh"
	+#include "Rivet/Projections/Beam.hh"
	+
	+namespace Rivet {
	+
	+
	+ /// @brief OPAL b-fragmentation measurement for weak B-hadron decays
	+ /// @author Simone Amoroso
	+ class OPAL_2003_I599181 : public Analysis {
	+ public:
	+
	+ /// Constructor
	+ DEFAULT_RIVET_ANALYSIS_CTOR(OPAL_2003_I599181);
	+
	+
	+ /// @name Analysis methods
	+ //@{
	+
	+ /// Book histograms and initialise projections before the run
	+ void init() {
	+
	+ // Initialise and register projections
	+ declare(Beam(), "Beams");
	+ declare(UnstableFinalState(), "UFS");
	+
	+ // Book histograms
	+ _histXbweak = bookHisto1D(1, 1, 1);
	+ _histMeanXbweak = bookProfile1D(2, 1, 1);
	+
	+ }
	+
	+
	+ /// Perform the per-event analysis
	+ void analyze(const Event& event) {
	+
	+
	+ // Get event weight for histo filling
	+ const double weight = event.weight();
	+
	+ // Get beams and average beam momentum
	+ const ParticlePair& beams = apply<Beam>(event, "Beams").beams();
	+ const double meanBeamMom = ( beams.first.p3().mod() +beams.second.p3().mod() ) / 2.0;
	+ MSG_DEBUG("Avg beam momentum = " << meanBeamMom);
	+
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");
	+ // Get Bottom hadrons
	+ const Particles bhads = filter_select(ufs.particles(), isBottomHadron);
	+
	+ for (const Particle& bhad : bhads) {
	+ // Check for weak decay, i.e. no more bottom present in children
	+ if (bhad.children(lastParticleWith(hasBottom)).empty()) {
	+ const double xp = bhad.E()/meanBeamMom;
	+ _histXbweak->fill(xp, weight);
	+ _histMeanXbweak->fill(_histMeanXbweak->bin(0).xMid(), xp, weight);
	+ }
	+ }
	+ }
	+
	+
	+ /// Normalise histograms etc., after the run
	+ void finalize() {
	+ normalize(_histXbweak);
	+ }
	+
	+ //@}
	+
	+
	+ private:
	+
	+ Histo1DPtr _histXbweak;
	+ Profile1DPtr _histMeanXbweak;
	+
	+ };
	+
	+
	+
	+ // The hook for the plugin system
	+ DECLARE_RIVET_PLUGIN(OPAL_2003_I599181);
	+
	+
	+}
	diff --git a/src/Analyses/OPAL_2004_S6132243.cc b/src/Analyses/OPAL_2004_S6132243.cc
	--- a/src/Analyses/OPAL_2004_S6132243.cc
	+++ b/src/Analyses/OPAL_2004_S6132243.cc
	@@ -1,273 +1,273 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/Sphericity.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ParisiTensor.hh"
	#include "Rivet/Projections/Hemispheres.hh"
	#include <cmath>

	namespace Rivet {


	/// @brief OPAL event shapes and moments at 91, 133, 177, and 197 GeV
	/// @author Andy Buckley
	class OPAL_2004_S6132243 : public Analysis {
	public:

	/// Constructor
	OPAL_2004_S6132243()
	: Analysis("OPAL_2004_S6132243"),
	_isqrts(-1), _sumWTrack2(0.0), _sumWJet3(0.0)
	{
	//
	}


	/// @name Analysis methods
	//@{

	/// Energies: 91, 133, 177 (161-183), 197 (189-209) => index 0..4
	int getHistIndex(double sqrts) {
	int ih = -1;
	if (inRange(sqrts/GeV, 89.9, 91.5)) {
	ih = 0;
	} else if (fuzzyEquals(sqrts/GeV, 133)) {
	ih = 1;
	} else if (fuzzyEquals(sqrts/GeV, 177)) { // (161-183)
	ih = 2;
	} else if (fuzzyEquals(sqrts/GeV, 197)) { // (189-209)
	ih = 3;
	} else {
	stringstream ss;
	ss << "Invalid energy for OPAL_2004 analysis: "
	<< sqrts/GeV << " GeV != 91, 133, 177, or 197 GeV";
	throw Error(ss.str());
	}
	assert(ih >= 0);
	return ih;
	}


	void init() {
	// Projections
	- addProjection(Beam(), "Beams");
	+ declare(Beam(), "Beams");
	const FinalState fs;
	- addProjection(fs, "FS");
	+ declare(fs, "FS");
	const ChargedFinalState cfs;
	- addProjection(cfs, "CFS");
	- addProjection(FastJets(fs, FastJets::DURHAM, 0.7), "DurhamJets");
	- addProjection(Sphericity(fs), "Sphericity");
	- addProjection(ParisiTensor(fs), "Parisi");
	+ declare(cfs, "CFS");
	+ declare(FastJets(fs, FastJets::DURHAM, 0.7), "DurhamJets");
	+ declare(Sphericity(fs), "Sphericity");
	+ declare(ParisiTensor(fs), "Parisi");
	const Thrust thrust(fs);
	- addProjection(thrust, "Thrust");
	- addProjection(Hemispheres(thrust), "Hemispheres");
	+ declare(thrust, "Thrust");
	+ declare(Hemispheres(thrust), "Hemispheres");

	// Get beam energy index
	_isqrts = getHistIndex(sqrtS());

	// Book histograms
	_hist1MinusT[_isqrts] = bookHisto1D(1, 1, _isqrts+1);
	_histHemiMassH[_isqrts] = bookHisto1D(2, 1, _isqrts+1);
	_histCParam[_isqrts] = bookHisto1D(3, 1, _isqrts+1);
	_histHemiBroadT[_isqrts] = bookHisto1D(4, 1, _isqrts+1);
	_histHemiBroadW[_isqrts] = bookHisto1D(5, 1, _isqrts+1);
	_histY23Durham[_isqrts] = bookHisto1D(6, 1, _isqrts+1);
	_histTMajor[_isqrts] = bookHisto1D(7, 1, _isqrts+1);
	_histTMinor[_isqrts] = bookHisto1D(8, 1, _isqrts+1);
	_histAplanarity[_isqrts] = bookHisto1D(9, 1, _isqrts+1);
	_histSphericity[_isqrts] = bookHisto1D(10, 1, _isqrts+1);
	_histOblateness[_isqrts] = bookHisto1D(11, 1, _isqrts+1);
	_histHemiMassL[_isqrts] = bookHisto1D(12, 1, _isqrts+1);
	_histHemiBroadN[_isqrts] = bookHisto1D(13, 1, _isqrts+1);
	_histDParam[_isqrts] = bookHisto1D(14, 1, _isqrts+1);
	//
	_hist1MinusTMom[_isqrts] = bookHisto1D(15, 1, _isqrts+1);
	_histHemiMassHMom[_isqrts] = bookHisto1D(16, 1, _isqrts+1);
	_histCParamMom[_isqrts] = bookHisto1D(17, 1, _isqrts+1);
	_histHemiBroadTMom[_isqrts] = bookHisto1D(18, 1, _isqrts+1);
	_histHemiBroadWMom[_isqrts] = bookHisto1D(19, 1, _isqrts+1);
	_histY23DurhamMom[_isqrts] = bookHisto1D(20, 1, _isqrts+1);
	_histTMajorMom[_isqrts] = bookHisto1D(21, 1, _isqrts+1);
	_histTMinorMom[_isqrts] = bookHisto1D(22, 1, _isqrts+1);
	_histSphericityMom[_isqrts] = bookHisto1D(23, 1, _isqrts+1);
	_histOblatenessMom[_isqrts] = bookHisto1D(24, 1, _isqrts+1);
	_histHemiMassLMom[_isqrts] = bookHisto1D(25, 1, _isqrts+1);
	_histHemiBroadNMom[_isqrts] = bookHisto1D(26, 1, _isqrts+1);
	}


	void analyze(const Event& event) {
	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	- const FinalState& cfs = applyProjection<FinalState>(event, "CFS");
	+ const FinalState& cfs = apply<FinalState>(event, "CFS");
	if (cfs.size() < 2) vetoEvent;

	// Increment passed-cuts weight sum
	const double weight = event.weight();
	_sumWTrack2 += weight;

	// Thrusts
	- const Thrust& thrust = applyProjection<Thrust>(event, "Thrust");
	+ const Thrust& thrust = apply<Thrust>(event, "Thrust");
	_hist1MinusT[_isqrts]->fill(1-thrust.thrust(), weight);
	_histTMajor[_isqrts]->fill(thrust.thrustMajor(), weight);
	_histTMinor[_isqrts]->fill(thrust.thrustMinor(), weight);
	_histOblateness[_isqrts]->fill(thrust.oblateness(), weight);
	for (int n = 1; n <= 5; ++n) {
	_hist1MinusTMom[_isqrts]->fill(n, pow(1-thrust.thrust(), n)*weight);
	_histTMajorMom[_isqrts]->fill(n, pow(thrust.thrustMajor(), n)*weight);
	_histTMinorMom[_isqrts]->fill(n, pow(thrust.thrustMinor(), n)*weight);
	_histOblatenessMom[_isqrts]->fill(n, pow(thrust.oblateness(), n)*weight);
	}

	// Jets
	- const FastJets& durjet = applyProjection<FastJets>(event, "DurhamJets");
	+ const FastJets& durjet = apply<FastJets>(event, "DurhamJets");
	if (durjet.clusterSeq()) {
	_sumWJet3 += weight;
	const double y23 = durjet.clusterSeq()->exclusive_ymerge_max(2);
	if (y23>0.0) {
	_histY23Durham[_isqrts]->fill(y23, weight);
	for (int n = 1; n <= 5; ++n) {
	_histY23DurhamMom[_isqrts]->fill(n, pow(y23, n)*weight);
	}
	}
	}

	// Sphericities
	- const Sphericity& sphericity = applyProjection<Sphericity>(event, "Sphericity");
	+ const Sphericity& sphericity = apply<Sphericity>(event, "Sphericity");
	const double sph = sphericity.sphericity();
	const double apl = sphericity.aplanarity();
	_histSphericity[_isqrts]->fill(sph, weight);
	_histAplanarity[_isqrts]->fill(apl, weight);
	for (int n = 1; n <= 5; ++n) {
	_histSphericityMom[_isqrts]->fill(n, pow(sph, n)*weight);
	}

	// C & D params
	- const ParisiTensor& parisi = applyProjection<ParisiTensor>(event, "Parisi");
	+ const ParisiTensor& parisi = apply<ParisiTensor>(event, "Parisi");
	const double cparam = parisi.C();
	const double dparam = parisi.D();
	_histCParam[_isqrts]->fill(cparam, weight);
	_histDParam[_isqrts]->fill(dparam, weight);
	for (int n = 1; n <= 5; ++n) {
	_histCParamMom[_isqrts]->fill(n, pow(cparam, n)*weight);
	}

	// Hemispheres
	- const Hemispheres& hemi = applyProjection<Hemispheres>(event, "Hemispheres");
	+ const Hemispheres& hemi = apply<Hemispheres>(event, "Hemispheres");
	// The paper says that M_H/L are scaled by sqrt(s), but scaling by E_vis is the way that fits the data...
	const double hemi_mh = hemi.scaledMhigh();
	const double hemi_ml = hemi.scaledMlow();
	/// @todo This shouldn't be necessary... what's going on? Memory corruption suspected :(
	// if (std::isnan(hemi_ml)) {
	// MSG_ERROR("NaN in HemiL! Event = " << numEvents());
	// MSG_ERROR(hemi.M2low() << ", " << hemi.E2vis());
	// }
	if (!std::isnan(hemi_mh) && !std::isnan(hemi_ml)) {
	const double hemi_bmax = hemi.Bmax();
	const double hemi_bmin = hemi.Bmin();
	const double hemi_bsum = hemi.Bsum();
	_histHemiMassH[_isqrts]->fill(hemi_mh, weight);
	_histHemiMassL[_isqrts]->fill(hemi_ml, weight);
	_histHemiBroadW[_isqrts]->fill(hemi_bmax, weight);
	_histHemiBroadN[_isqrts]->fill(hemi_bmin, weight);
	_histHemiBroadT[_isqrts]->fill(hemi_bsum, weight);
	for (int n = 1; n <= 5; ++n) {
	// if (std::isnan(pow(hemi_ml, n))) MSG_ERROR("NaN in HemiL moment! Event = " << numEvents());
	_histHemiMassHMom[_isqrts]->fill(n, pow(hemi_mh, n)*weight);
	_histHemiMassLMom[_isqrts]->fill(n, pow(hemi_ml, n)*weight);
	_histHemiBroadWMom[_isqrts]->fill(n, pow(hemi_bmax, n)*weight);
	_histHemiBroadNMom[_isqrts]->fill(n, pow(hemi_bmin, n)*weight);
	_histHemiBroadTMom[_isqrts]->fill(n, pow(hemi_bsum, n)*weight);
	}
	}
	}


	void finalize() {
	scale(_hist1MinusT[_isqrts], 1.0/_sumWTrack2);
	scale(_histTMajor[_isqrts], 1.0/_sumWTrack2);
	scale(_histTMinor[_isqrts], 1.0/_sumWTrack2);
	scale(_histOblateness[_isqrts], 1.0/_sumWTrack2);
	scale(_histSphericity[_isqrts], 1.0/_sumWTrack2);
	scale(_histAplanarity[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiMassH[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiMassL[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiBroadW[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiBroadN[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiBroadT[_isqrts], 1.0/_sumWTrack2);
	scale(_histCParam[_isqrts], 1.0/_sumWTrack2);
	scale(_histDParam[_isqrts], 1.0/_sumWTrack2);
	scale(_histY23Durham[_isqrts], 1.0/_sumWJet3);
	//
	scale(_hist1MinusTMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histTMajorMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histTMinorMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histOblatenessMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histSphericityMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiMassHMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiMassLMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiBroadWMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiBroadNMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histHemiBroadTMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histCParamMom[_isqrts], 1.0/_sumWTrack2);
	scale(_histY23DurhamMom[_isqrts], 1.0/_sumWJet3);
	}

	//@}


	private:

	/// Beam energy index for histograms
	int _isqrts;

	/// @name Counters of event weights passing the cuts
	//@{
	double _sumWTrack2, _sumWJet3;
	//@}

	/// @name Event shape histos at 4 energies
	//@{
	Histo1DPtr _hist1MinusT[4];
	Histo1DPtr _histHemiMassH[4];
	Histo1DPtr _histCParam[4];
	Histo1DPtr _histHemiBroadT[4];
	Histo1DPtr _histHemiBroadW[4];
	Histo1DPtr _histY23Durham[4];
	Histo1DPtr _histTMajor[4];
	Histo1DPtr _histTMinor[4];
	Histo1DPtr _histAplanarity[4];
	Histo1DPtr _histSphericity[4];
	Histo1DPtr _histOblateness[4];
	Histo1DPtr _histHemiMassL[4];
	Histo1DPtr _histHemiBroadN[4];
	Histo1DPtr _histDParam[4];
	//@}

	/// @name Event shape moment histos at 4 energies
	//@{
	Histo1DPtr _hist1MinusTMom[4];
	Histo1DPtr _histHemiMassHMom[4];
	Histo1DPtr _histCParamMom[4];
	Histo1DPtr _histHemiBroadTMom[4];
	Histo1DPtr _histHemiBroadWMom[4];
	Histo1DPtr _histY23DurhamMom[4];
	Histo1DPtr _histTMajorMom[4];
	Histo1DPtr _histTMinorMom[4];
	Histo1DPtr _histSphericityMom[4];
	Histo1DPtr _histOblatenessMom[4];
	Histo1DPtr _histHemiMassLMom[4];
	Histo1DPtr _histHemiBroadNMom[4];
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(OPAL_2004_S6132243);

	}
	diff --git a/src/Analyses/PDG_HADRON_MULTIPLICITIES.cc b/src/Analyses/PDG_HADRON_MULTIPLICITIES.cc
	--- a/src/Analyses/PDG_HADRON_MULTIPLICITIES.cc
	+++ b/src/Analyses/PDG_HADRON_MULTIPLICITIES.cc
	@@ -1,770 +1,770 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief Implementation of PDG hadron multiplicities
	/// @author Hendrik Hoeth
	class PDG_HADRON_MULTIPLICITIES : public Analysis {
	public:

	/// Constructor
	PDG_HADRON_MULTIPLICITIES() : Analysis("PDG_HADRON_MULTIPLICITIES")
	{
	}


	/// @name Analysis methods
	//@{

	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	MSG_DEBUG("sqrt(s) = " << sqrtS()/GeV << " GeV");

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	if (sqrtS()/GeV >= 9.5 && sqrtS()/GeV <= 10.5) {
	foreach (const Particle& p, ufs.particles()) {
	const PdgId id = p.abspid();
	switch (id) {
	case 211:
	_histMeanMultiPiPlus->fill(_histMeanMultiPiPlus->bin(0).xMid(), weight);
	break;
	case 111:
	_histMeanMultiPi0->fill(_histMeanMultiPi0->bin(0).xMid(), weight);
	break;
	case 321:
	_histMeanMultiKPlus->fill(_histMeanMultiKPlus->bin(0).xMid(), weight);
	break;
	case 130:
	case 310:
	_histMeanMultiK0->fill(_histMeanMultiK0->bin(0).xMid(), weight);
	break;
	case 221:
	_histMeanMultiEta->fill(_histMeanMultiEta->bin(0).xMid(), weight);
	break;
	case 331:
	_histMeanMultiEtaPrime->fill(_histMeanMultiEtaPrime->bin(0).xMid(), weight);
	break;
	case 411:
	_histMeanMultiDPlus->fill(_histMeanMultiDPlus->bin(0).xMid(), weight);
	break;
	case 421:
	_histMeanMultiD0->fill(_histMeanMultiD0->bin(0).xMid(), weight);
	break;
	case 431:
	_histMeanMultiDPlus_s->fill(_histMeanMultiDPlus_s->bin(0).xMid(), weight);
	break;
	case 9010221:
	_histMeanMultiF0_980->fill(_histMeanMultiF0_980->bin(0).xMid(), weight);
	break;
	case 113:
	_histMeanMultiRho770_0->fill(_histMeanMultiRho770_0->bin(0).xMid(), weight);
	break;
	case 223:
	_histMeanMultiOmega782->fill(_histMeanMultiOmega782->bin(0).xMid(), weight);
	break;
	case 323:
	_histMeanMultiKStar892Plus->fill(_histMeanMultiKStar892Plus->bin(0).xMid(), weight);
	break;
	case 313:
	_histMeanMultiKStar892_0->fill(_histMeanMultiKStar892_0->bin(0).xMid(), weight);
	break;
	case 333:
	_histMeanMultiPhi1020->fill(_histMeanMultiPhi1020->bin(0).xMid(), weight);
	break;
	case 413:
	_histMeanMultiDStar2010Plus->fill(_histMeanMultiDStar2010Plus->bin(0).xMid(), weight);
	break;
	case 423:
	_histMeanMultiDStar2007_0->fill(_histMeanMultiDStar2007_0->bin(0).xMid(), weight);
	break;
	case 433:
	_histMeanMultiDStar_s2112Plus->fill(_histMeanMultiDStar_s2112Plus->bin(0).xMid(), weight);
	break;
	case 443:
	_histMeanMultiJPsi1S->fill(_histMeanMultiJPsi1S->bin(0).xMid(), weight);
	break;
	case 225:
	_histMeanMultiF2_1270->fill(_histMeanMultiF2_1270->bin(0).xMid(), weight);
	break;
	case 2212:
	_histMeanMultiP->fill(_histMeanMultiP->bin(0).xMid(), weight);
	break;
	case 3122:
	_histMeanMultiLambda->fill(_histMeanMultiLambda->bin(0).xMid(), weight);
	break;
	case 3212:
	_histMeanMultiSigma0->fill(_histMeanMultiSigma0->bin(0).xMid(), weight);
	break;
	case 3312:
	_histMeanMultiXiMinus->fill(_histMeanMultiXiMinus->bin(0).xMid(), weight);
	break;
	case 2224:
	_histMeanMultiDelta1232PlusPlus->fill(_histMeanMultiDelta1232PlusPlus->bin(0).xMid(), weight);
	break;
	case 3114:
	_histMeanMultiSigma1385Minus->fill(_histMeanMultiSigma1385Minus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3224:
	_histMeanMultiSigma1385Plus->fill(_histMeanMultiSigma1385Plus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3324:
	_histMeanMultiXi1530_0->fill(_histMeanMultiXi1530_0->bin(0).xMid(), weight);
	break;
	case 3334:
	_histMeanMultiOmegaMinus->fill(_histMeanMultiOmegaMinus->bin(0).xMid(), weight);
	break;
	case 4122:
	_histMeanMultiLambda_c_Plus->fill(_histMeanMultiLambda_c_Plus->bin(0).xMid(), weight);
	break;
	case 4222:
	case 4112:
	_histMeanMultiSigma_c_PlusPlus_0->fill(_histMeanMultiSigma_c_PlusPlus_0->bin(0).xMid(), weight);
	break;
	case 3124:
	_histMeanMultiLambda1520->fill(_histMeanMultiLambda1520->bin(0).xMid(), weight);
	break;
	}
	}
	}

	if (sqrtS()/GeV >= 29 && sqrtS()/GeV <= 35) {
	foreach (const Particle& p, ufs.particles()) {
	const PdgId id = p.abspid();
	switch (id) {
	case 211:
	_histMeanMultiPiPlus->fill(_histMeanMultiPiPlus->bin(0).xMid(), weight);
	break;
	case 111:
	_histMeanMultiPi0->fill(_histMeanMultiPi0->bin(0).xMid(), weight);
	break;
	case 321:
	_histMeanMultiKPlus->fill(_histMeanMultiKPlus->bin(0).xMid(), weight);
	break;
	case 130:
	case 310:
	_histMeanMultiK0->fill(_histMeanMultiK0->bin(0).xMid(), weight);
	break;
	case 221:
	_histMeanMultiEta->fill(_histMeanMultiEta->bin(0).xMid(), weight);
	break;
	case 331:
	_histMeanMultiEtaPrime->fill(_histMeanMultiEtaPrime->bin(0).xMid(), weight);
	break;
	case 411:
	_histMeanMultiDPlus->fill(_histMeanMultiDPlus->bin(0).xMid(), weight);
	break;
	case 421:
	_histMeanMultiD0->fill(_histMeanMultiD0->bin(0).xMid(), weight);
	break;
	case 431:
	_histMeanMultiDPlus_s->fill(_histMeanMultiDPlus_s->bin(0).xMid(), weight);
	break;
	case 9010221:
	_histMeanMultiF0_980->fill(_histMeanMultiF0_980->bin(0).xMid(), weight);
	break;
	case 113:
	_histMeanMultiRho770_0->fill(_histMeanMultiRho770_0->bin(0).xMid(), weight);
	break;
	case 323:
	_histMeanMultiKStar892Plus->fill(_histMeanMultiKStar892Plus->bin(0).xMid(), weight);
	break;
	case 313:
	_histMeanMultiKStar892_0->fill(_histMeanMultiKStar892_0->bin(0).xMid(), weight);
	break;
	case 333:
	_histMeanMultiPhi1020->fill(_histMeanMultiPhi1020->bin(0).xMid(), weight);
	break;
	case 413:
	_histMeanMultiDStar2010Plus->fill(_histMeanMultiDStar2010Plus->bin(0).xMid(), weight);
	break;
	case 423:
	_histMeanMultiDStar2007_0->fill(_histMeanMultiDStar2007_0->bin(0).xMid(), weight);
	break;
	case 225:
	_histMeanMultiF2_1270->fill(_histMeanMultiF2_1270->bin(0).xMid(), weight);
	break;
	case 325:
	_histMeanMultiK2Star1430Plus->fill(_histMeanMultiK2Star1430Plus->bin(0).xMid(), weight);
	break;
	case 315:
	_histMeanMultiK2Star1430_0->fill(_histMeanMultiK2Star1430_0->bin(0).xMid(), weight);
	break;
	case 2212:
	_histMeanMultiP->fill(_histMeanMultiP->bin(0).xMid(), weight);
	break;
	case 3122:
	_histMeanMultiLambda->fill(_histMeanMultiLambda->bin(0).xMid(), weight);
	break;
	case 3312:
	_histMeanMultiXiMinus->fill(_histMeanMultiXiMinus->bin(0).xMid(), weight);
	break;
	case 3114:
	_histMeanMultiSigma1385Minus->fill(_histMeanMultiSigma1385Minus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3224:
	_histMeanMultiSigma1385Plus->fill(_histMeanMultiSigma1385Plus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3334:
	_histMeanMultiOmegaMinus->fill(_histMeanMultiOmegaMinus->bin(0).xMid(), weight);
	break;
	case 4122:
	_histMeanMultiLambda_c_Plus->fill(_histMeanMultiLambda_c_Plus->bin(0).xMid(), weight);
	break;
	}
	}
	}

	if (sqrtS()/GeV >= 89.5 && sqrtS()/GeV <= 91.8) {
	foreach (const Particle& p, ufs.particles()) {
	const PdgId id = p.abspid();
	switch (id) {
	case 211:
	_histMeanMultiPiPlus->fill(_histMeanMultiPiPlus->bin(0).xMid(), weight);
	break;
	case 111:
	_histMeanMultiPi0->fill(_histMeanMultiPi0->bin(0).xMid(), weight);
	break;
	case 321:
	_histMeanMultiKPlus->fill(_histMeanMultiKPlus->bin(0).xMid(), weight);
	break;
	case 130:
	case 310:
	_histMeanMultiK0->fill(_histMeanMultiK0->bin(0).xMid(), weight);
	break;
	case 221:
	_histMeanMultiEta->fill(_histMeanMultiEta->bin(0).xMid(), weight);
	break;
	case 331:
	_histMeanMultiEtaPrime->fill(_histMeanMultiEtaPrime->bin(0).xMid(), weight);
	break;
	case 411:
	_histMeanMultiDPlus->fill(_histMeanMultiDPlus->bin(0).xMid(), weight);
	break;
	case 421:
	_histMeanMultiD0->fill(_histMeanMultiD0->bin(0).xMid(), weight);
	break;
	case 431:
	_histMeanMultiDPlus_s->fill(_histMeanMultiDPlus_s->bin(0).xMid(), weight);
	break;
	case 511:
	_histMeanMultiBPlus_B0_d->fill(_histMeanMultiBPlus_B0_d->bin(0).xMid(), weight);
	break;
	case 521:
	_histMeanMultiBPlus_B0_d->fill(_histMeanMultiBPlus_B0_d->bin(0).xMid(), weight);
	_histMeanMultiBPlus_u->fill(_histMeanMultiBPlus_u->bin(0).xMid(), weight);
	break;
	case 531:
	_histMeanMultiB0_s->fill(_histMeanMultiB0_s->bin(0).xMid(), weight);
	break;
	case 9010221:
	_histMeanMultiF0_980->fill(_histMeanMultiF0_980->bin(0).xMid(), weight);
	break;
	case 9000211:
	_histMeanMultiA0_980Plus->fill(_histMeanMultiA0_980Plus->bin(0).xMid(), weight);
	break;
	case 113:
	_histMeanMultiRho770_0->fill(_histMeanMultiRho770_0->bin(0).xMid(), weight);
	break;
	case 213:
	_histMeanMultiRho770Plus->fill(_histMeanMultiRho770Plus->bin(0).xMid(), weight);
	break;
	case 223:
	_histMeanMultiOmega782->fill(_histMeanMultiOmega782->bin(0).xMid(), weight);
	break;
	case 323:
	_histMeanMultiKStar892Plus->fill(_histMeanMultiKStar892Plus->bin(0).xMid(), weight);
	break;
	case 313:
	_histMeanMultiKStar892_0->fill(_histMeanMultiKStar892_0->bin(0).xMid(), weight);
	break;
	case 333:
	_histMeanMultiPhi1020->fill(_histMeanMultiPhi1020->bin(0).xMid(), weight);
	break;
	case 413:
	_histMeanMultiDStar2010Plus->fill(_histMeanMultiDStar2010Plus->bin(0).xMid(), weight);
	break;
	case 433:
	_histMeanMultiDStar_s2112Plus->fill(_histMeanMultiDStar_s2112Plus->bin(0).xMid(), weight);
	break;
	case 513:
	case 523:
	case 533:
	_histMeanMultiBStar->fill(_histMeanMultiBStar->bin(0).xMid(), weight);
	break;
	case 443:
	_histMeanMultiJPsi1S->fill(_histMeanMultiJPsi1S->bin(0).xMid(), weight);
	break;
	case 100443:
	_histMeanMultiPsi2S->fill(_histMeanMultiPsi2S->bin(0).xMid(), weight);
	break;
	case 553:
	_histMeanMultiUpsilon1S->fill(_histMeanMultiUpsilon1S->bin(0).xMid(), weight);
	break;
	case 20223:
	_histMeanMultiF1_1285->fill(_histMeanMultiF1_1285->bin(0).xMid(), weight);
	break;
	case 20333:
	_histMeanMultiF1_1420->fill(_histMeanMultiF1_1420->bin(0).xMid(), weight);
	break;
	case 445:
	_histMeanMultiChi_c1_3510->fill(_histMeanMultiChi_c1_3510->bin(0).xMid(), weight);
	break;
	case 225:
	_histMeanMultiF2_1270->fill(_histMeanMultiF2_1270->bin(0).xMid(), weight);
	break;
	case 335:
	_histMeanMultiF2Prime1525->fill(_histMeanMultiF2Prime1525->bin(0).xMid(), weight);
	break;
	case 315:
	_histMeanMultiK2Star1430_0->fill(_histMeanMultiK2Star1430_0->bin(0).xMid(), weight);
	break;
	case 515:
	case 525:
	case 535:
	_histMeanMultiBStarStar->fill(_histMeanMultiBStarStar->bin(0).xMid(), weight);
	break;
	case 10433:
	case 20433:
	_histMeanMultiDs1Plus->fill(_histMeanMultiDs1Plus->bin(0).xMid(), weight);
	break;
	case 435:
	_histMeanMultiDs2Plus->fill(_histMeanMultiDs2Plus->bin(0).xMid(), weight);
	break;
	case 2212:
	_histMeanMultiP->fill(_histMeanMultiP->bin(0).xMid(), weight);
	break;
	case 3122:
	_histMeanMultiLambda->fill(_histMeanMultiLambda->bin(0).xMid(), weight);
	break;
	case 3212:
	_histMeanMultiSigma0->fill(_histMeanMultiSigma0->bin(0).xMid(), weight);
	break;
	case 3112:
	_histMeanMultiSigmaMinus->fill(_histMeanMultiSigmaMinus->bin(0).xMid(), weight);
	_histMeanMultiSigmaPlusMinus->fill(_histMeanMultiSigmaPlusMinus->bin(0).xMid(), weight);
	break;
	case 3222:
	_histMeanMultiSigmaPlus->fill(_histMeanMultiSigmaPlus->bin(0).xMid(), weight);
	_histMeanMultiSigmaPlusMinus->fill(_histMeanMultiSigmaPlusMinus->bin(0).xMid(), weight);
	break;
	case 3312:
	_histMeanMultiXiMinus->fill(_histMeanMultiXiMinus->bin(0).xMid(), weight);
	break;
	case 2224:
	_histMeanMultiDelta1232PlusPlus->fill(_histMeanMultiDelta1232PlusPlus->bin(0).xMid(), weight);
	break;
	case 3114:
	_histMeanMultiSigma1385Minus->fill(_histMeanMultiSigma1385Minus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3224:
	_histMeanMultiSigma1385Plus->fill(_histMeanMultiSigma1385Plus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3324:
	_histMeanMultiXi1530_0->fill(_histMeanMultiXi1530_0->bin(0).xMid(), weight);
	break;
	case 3334:
	_histMeanMultiOmegaMinus->fill(_histMeanMultiOmegaMinus->bin(0).xMid(), weight);
	break;
	case 4122:
	_histMeanMultiLambda_c_Plus->fill(_histMeanMultiLambda_c_Plus->bin(0).xMid(), weight);
	break;
	case 5122:
	_histMeanMultiLambda_b_0->fill(_histMeanMultiLambda_b_0->bin(0).xMid(), weight);
	break;
	case 3124:
	_histMeanMultiLambda1520->fill(_histMeanMultiLambda1520->bin(0).xMid(), weight);
	break;
	}
	}
	}

	if (sqrtS()/GeV >= 130 && sqrtS()/GeV <= 200) {
	foreach (const Particle& p, ufs.particles()) {
	const PdgId id = p.abspid();
	switch (id) {
	case 211:
	_histMeanMultiPiPlus->fill(_histMeanMultiPiPlus->bin(0).xMid(), weight);
	break;
	case 321:
	_histMeanMultiKPlus->fill(_histMeanMultiKPlus->bin(0).xMid(), weight);
	break;
	case 130:
	case 310:
	_histMeanMultiK0->fill(_histMeanMultiK0->bin(0).xMid(), weight);
	break;
	case 2212:
	_histMeanMultiP->fill(_histMeanMultiP->bin(0).xMid(), weight);
	break;
	case 3122:
	_histMeanMultiLambda->fill(_histMeanMultiLambda->bin(0).xMid(), weight);
	break;
	}
	}
	}

	}



	void init() {
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");

	if (sqrtS()/GeV >= 9.5 && sqrtS()/GeV <= 10.5) {
	_histMeanMultiPiPlus = bookHisto1D( 1, 1, 1);
	_histMeanMultiPi0 = bookHisto1D( 2, 1, 1);
	_histMeanMultiKPlus = bookHisto1D( 3, 1, 1);
	_histMeanMultiK0 = bookHisto1D( 4, 1, 1);
	_histMeanMultiEta = bookHisto1D( 5, 1, 1);
	_histMeanMultiEtaPrime = bookHisto1D( 6, 1, 1);
	_histMeanMultiDPlus = bookHisto1D( 7, 1, 1);
	_histMeanMultiD0 = bookHisto1D( 8, 1, 1);
	_histMeanMultiDPlus_s = bookHisto1D( 9, 1, 1);
	_histMeanMultiF0_980 = bookHisto1D(13, 1, 1);
	_histMeanMultiRho770_0 = bookHisto1D(15, 1, 1);
	_histMeanMultiOmega782 = bookHisto1D(17, 1, 1);
	_histMeanMultiKStar892Plus = bookHisto1D(18, 1, 1);
	_histMeanMultiKStar892_0 = bookHisto1D(19, 1, 1);
	_histMeanMultiPhi1020 = bookHisto1D(20, 1, 1);
	_histMeanMultiDStar2010Plus = bookHisto1D(21, 1, 1);
	_histMeanMultiDStar2007_0 = bookHisto1D(22, 1, 1);
	_histMeanMultiDStar_s2112Plus = bookHisto1D(23, 1, 1);
	_histMeanMultiJPsi1S = bookHisto1D(25, 1, 1);
	_histMeanMultiF2_1270 = bookHisto1D(31, 1, 1);
	_histMeanMultiP = bookHisto1D(38, 1, 1);
	_histMeanMultiLambda = bookHisto1D(39, 1, 1);
	_histMeanMultiSigma0 = bookHisto1D(40, 1, 1);
	_histMeanMultiXiMinus = bookHisto1D(44, 1, 1);
	_histMeanMultiDelta1232PlusPlus = bookHisto1D(45, 1, 1);
	_histMeanMultiSigma1385Minus = bookHisto1D(46, 1, 1);
	_histMeanMultiSigma1385Plus = bookHisto1D(47, 1, 1);
	_histMeanMultiSigma1385PlusMinus = bookHisto1D(48, 1, 1);
	_histMeanMultiXi1530_0 = bookHisto1D(49, 1, 1);
	_histMeanMultiOmegaMinus = bookHisto1D(50, 1, 1);
	_histMeanMultiLambda_c_Plus = bookHisto1D(51, 1, 1);
	_histMeanMultiSigma_c_PlusPlus_0 = bookHisto1D(53, 1, 1);
	_histMeanMultiLambda1520 = bookHisto1D(54, 1, 1);
	}

	if (sqrtS()/GeV >= 29 && sqrtS()/GeV <= 35) {
	_histMeanMultiPiPlus = bookHisto1D( 1, 1, 2);
	_histMeanMultiPi0 = bookHisto1D( 2, 1, 2);
	_histMeanMultiKPlus = bookHisto1D( 3, 1, 2);
	_histMeanMultiK0 = bookHisto1D( 4, 1, 2);
	_histMeanMultiEta = bookHisto1D( 5, 1, 2);
	_histMeanMultiEtaPrime = bookHisto1D( 6, 1, 2);
	_histMeanMultiDPlus = bookHisto1D( 7, 1, 2);
	_histMeanMultiD0 = bookHisto1D( 8, 1, 2);
	_histMeanMultiDPlus_s = bookHisto1D( 9, 1, 2);
	_histMeanMultiF0_980 = bookHisto1D(13, 1, 2);
	_histMeanMultiRho770_0 = bookHisto1D(15, 1, 2);
	_histMeanMultiKStar892Plus = bookHisto1D(18, 1, 2);
	_histMeanMultiKStar892_0 = bookHisto1D(19, 1, 2);
	_histMeanMultiPhi1020 = bookHisto1D(20, 1, 2);
	_histMeanMultiDStar2010Plus = bookHisto1D(21, 1, 2);
	_histMeanMultiDStar2007_0 = bookHisto1D(22, 1, 2);
	_histMeanMultiF2_1270 = bookHisto1D(31, 1, 2);
	_histMeanMultiK2Star1430Plus = bookHisto1D(33, 1, 1);
	_histMeanMultiK2Star1430_0 = bookHisto1D(34, 1, 1);
	_histMeanMultiP = bookHisto1D(38, 1, 2);
	_histMeanMultiLambda = bookHisto1D(39, 1, 2);
	_histMeanMultiXiMinus = bookHisto1D(44, 1, 2);
	_histMeanMultiSigma1385Minus = bookHisto1D(46, 1, 2);
	_histMeanMultiSigma1385Plus = bookHisto1D(47, 1, 2);
	_histMeanMultiSigma1385PlusMinus = bookHisto1D(48, 1, 2);
	_histMeanMultiOmegaMinus = bookHisto1D(50, 1, 2);
	_histMeanMultiLambda_c_Plus = bookHisto1D(51, 1, 2);
	}

	if (sqrtS()/GeV >= 89.5 && sqrtS()/GeV <= 91.8) {
	_histMeanMultiPiPlus = bookHisto1D( 1, 1, 3);
	_histMeanMultiPi0 = bookHisto1D( 2, 1, 3);
	_histMeanMultiKPlus = bookHisto1D( 3, 1, 3);
	_histMeanMultiK0 = bookHisto1D( 4, 1, 3);
	_histMeanMultiEta = bookHisto1D( 5, 1, 3);
	_histMeanMultiEtaPrime = bookHisto1D( 6, 1, 3);
	_histMeanMultiDPlus = bookHisto1D( 7, 1, 3);
	_histMeanMultiD0 = bookHisto1D( 8, 1, 3);
	_histMeanMultiDPlus_s = bookHisto1D( 9, 1, 3);
	_histMeanMultiBPlus_B0_d = bookHisto1D(10, 1, 1);
	_histMeanMultiBPlus_u = bookHisto1D(11, 1, 1);
	_histMeanMultiB0_s = bookHisto1D(12, 1, 1);
	_histMeanMultiF0_980 = bookHisto1D(13, 1, 3);
	_histMeanMultiA0_980Plus = bookHisto1D(14, 1, 1);
	_histMeanMultiRho770_0 = bookHisto1D(15, 1, 3);
	_histMeanMultiRho770Plus = bookHisto1D(16, 1, 1);
	_histMeanMultiOmega782 = bookHisto1D(17, 1, 2);
	_histMeanMultiKStar892Plus = bookHisto1D(18, 1, 3);
	_histMeanMultiKStar892_0 = bookHisto1D(19, 1, 3);
	_histMeanMultiPhi1020 = bookHisto1D(20, 1, 3);
	_histMeanMultiDStar2010Plus = bookHisto1D(21, 1, 3);
	_histMeanMultiDStar_s2112Plus = bookHisto1D(23, 1, 2);
	_histMeanMultiBStar = bookHisto1D(24, 1, 1);
	_histMeanMultiJPsi1S = bookHisto1D(25, 1, 2);
	_histMeanMultiPsi2S = bookHisto1D(26, 1, 1);
	_histMeanMultiUpsilon1S = bookHisto1D(27, 1, 1);
	_histMeanMultiF1_1285 = bookHisto1D(28, 1, 1);
	_histMeanMultiF1_1420 = bookHisto1D(29, 1, 1);
	_histMeanMultiChi_c1_3510 = bookHisto1D(30, 1, 1);
	_histMeanMultiF2_1270 = bookHisto1D(31, 1, 3);
	_histMeanMultiF2Prime1525 = bookHisto1D(32, 1, 1);
	_histMeanMultiK2Star1430_0 = bookHisto1D(34, 1, 2);
	_histMeanMultiBStarStar = bookHisto1D(35, 1, 1);
	_histMeanMultiDs1Plus = bookHisto1D(36, 1, 1);
	_histMeanMultiDs2Plus = bookHisto1D(37, 1, 1);
	_histMeanMultiP = bookHisto1D(38, 1, 3);
	_histMeanMultiLambda = bookHisto1D(39, 1, 3);
	_histMeanMultiSigma0 = bookHisto1D(40, 1, 2);
	_histMeanMultiSigmaMinus = bookHisto1D(41, 1, 1);
	_histMeanMultiSigmaPlus = bookHisto1D(42, 1, 1);
	_histMeanMultiSigmaPlusMinus = bookHisto1D(43, 1, 1);
	_histMeanMultiXiMinus = bookHisto1D(44, 1, 3);
	_histMeanMultiDelta1232PlusPlus = bookHisto1D(45, 1, 2);
	_histMeanMultiSigma1385Minus = bookHisto1D(46, 1, 3);
	_histMeanMultiSigma1385Plus = bookHisto1D(47, 1, 3);
	_histMeanMultiSigma1385PlusMinus = bookHisto1D(48, 1, 3);
	_histMeanMultiXi1530_0 = bookHisto1D(49, 1, 2);
	_histMeanMultiOmegaMinus = bookHisto1D(50, 1, 3);
	_histMeanMultiLambda_c_Plus = bookHisto1D(51, 1, 3);
	_histMeanMultiLambda_b_0 = bookHisto1D(52, 1, 1);
	_histMeanMultiLambda1520 = bookHisto1D(54, 1, 2);
	}

	if (sqrtS()/GeV >= 130 && sqrtS()/GeV <= 200) {
	_histMeanMultiPiPlus = bookHisto1D( 1, 1, 4);
	_histMeanMultiKPlus = bookHisto1D( 3, 1, 4);
	_histMeanMultiK0 = bookHisto1D( 4, 1, 4);
	_histMeanMultiP = bookHisto1D(38, 1, 4);
	_histMeanMultiLambda = bookHisto1D(39, 1, 4);
	}
	}



	// Finalize
	void finalize() {
	if (sqrtS()/GeV >= 9.5 && sqrtS()/GeV <= 10.5) {
	scale(_histMeanMultiPiPlus , 1.0/sumOfWeights());
	scale(_histMeanMultiPi0 , 1.0/sumOfWeights());
	scale(_histMeanMultiKPlus , 1.0/sumOfWeights());
	scale(_histMeanMultiK0 , 1.0/sumOfWeights());
	scale(_histMeanMultiEta , 1.0/sumOfWeights());
	scale(_histMeanMultiEtaPrime , 1.0/sumOfWeights());
	scale(_histMeanMultiDPlus , 1.0/sumOfWeights());
	scale(_histMeanMultiD0 , 1.0/sumOfWeights());
	scale(_histMeanMultiDPlus_s , 1.0/sumOfWeights());
	scale(_histMeanMultiF0_980 , 1.0/sumOfWeights());
	scale(_histMeanMultiRho770_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiOmega782 , 1.0/sumOfWeights());
	scale(_histMeanMultiKStar892Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiKStar892_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiPhi1020 , 1.0/sumOfWeights());
	scale(_histMeanMultiDStar2010Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiDStar2007_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiDStar_s2112Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiJPsi1S , 1.0/sumOfWeights());
	scale(_histMeanMultiF2_1270 , 1.0/sumOfWeights());
	scale(_histMeanMultiP , 1.0/sumOfWeights());
	scale(_histMeanMultiLambda , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma0 , 1.0/sumOfWeights());
	scale(_histMeanMultiXiMinus , 1.0/sumOfWeights());
	scale(_histMeanMultiDelta1232PlusPlus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma1385Minus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma1385Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma1385PlusMinus, 1.0/sumOfWeights());
	scale(_histMeanMultiXi1530_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiOmegaMinus , 1.0/sumOfWeights());
	scale(_histMeanMultiLambda_c_Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma_c_PlusPlus_0, 1.0/sumOfWeights());
	scale(_histMeanMultiLambda1520 , 1.0/sumOfWeights());
	}

	if (sqrtS()/GeV >= 29 && sqrtS()/GeV <= 35) {
	scale(_histMeanMultiPiPlus , 5.0/sumOfWeights());
	scale(_histMeanMultiPi0 , 5.0/sumOfWeights());
	scale(_histMeanMultiKPlus , 5.0/sumOfWeights());
	scale(_histMeanMultiK0 , 5.0/sumOfWeights());
	scale(_histMeanMultiEta , 5.0/sumOfWeights());
	scale(_histMeanMultiEtaPrime , 5.0/sumOfWeights());
	scale(_histMeanMultiDPlus , 5.0/sumOfWeights());
	scale(_histMeanMultiD0 , 5.0/sumOfWeights());
	scale(_histMeanMultiDPlus_s , 5.0/sumOfWeights());
	scale(_histMeanMultiF0_980 , 5.0/sumOfWeights());
	scale(_histMeanMultiRho770_0 , 5.0/sumOfWeights());
	scale(_histMeanMultiKStar892Plus , 5.0/sumOfWeights());
	scale(_histMeanMultiKStar892_0 , 5.0/sumOfWeights());
	scale(_histMeanMultiPhi1020 , 5.0/sumOfWeights());
	scale(_histMeanMultiDStar2010Plus , 5.0/sumOfWeights());
	scale(_histMeanMultiDStar2007_0 , 5.0/sumOfWeights());
	scale(_histMeanMultiF2_1270 , 5.0/sumOfWeights());
	scale(_histMeanMultiK2Star1430Plus , 5.0/sumOfWeights());
	scale(_histMeanMultiK2Star1430_0 , 5.0/sumOfWeights());
	scale(_histMeanMultiP , 5.0/sumOfWeights());
	scale(_histMeanMultiLambda , 5.0/sumOfWeights());
	scale(_histMeanMultiXiMinus , 5.0/sumOfWeights());
	scale(_histMeanMultiSigma1385Minus , 5.0/sumOfWeights());
	scale(_histMeanMultiSigma1385Plus , 5.0/sumOfWeights());
	scale(_histMeanMultiSigma1385PlusMinus, 5.0/sumOfWeights());
	scale(_histMeanMultiOmegaMinus , 5.0/sumOfWeights());
	scale(_histMeanMultiLambda_c_Plus , 5.0/sumOfWeights());
	}

	if (sqrtS()/GeV >= 89.5 && sqrtS()/GeV <= 91.8) {
	scale(_histMeanMultiPiPlus , 1.0/sumOfWeights());
	scale(_histMeanMultiPi0 , 1.0/sumOfWeights());
	scale(_histMeanMultiKPlus , 1.0/sumOfWeights());
	scale(_histMeanMultiK0 , 1.0/sumOfWeights());
	scale(_histMeanMultiEta , 1.0/sumOfWeights());
	scale(_histMeanMultiEtaPrime , 1.0/sumOfWeights());
	scale(_histMeanMultiDPlus , 1.0/sumOfWeights());
	scale(_histMeanMultiD0 , 1.0/sumOfWeights());
	scale(_histMeanMultiDPlus_s , 1.0/sumOfWeights());
	scale(_histMeanMultiBPlus_B0_d , 1.0/sumOfWeights());
	scale(_histMeanMultiBPlus_u , 1.0/sumOfWeights());
	scale(_histMeanMultiB0_s , 1.0/sumOfWeights());
	scale(_histMeanMultiF0_980 , 1.0/sumOfWeights());
	scale(_histMeanMultiA0_980Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiRho770_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiRho770Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiOmega782 , 1.0/sumOfWeights());
	scale(_histMeanMultiKStar892Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiKStar892_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiPhi1020 , 1.0/sumOfWeights());
	scale(_histMeanMultiDStar2010Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiDStar_s2112Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiBStar , 1.0/sumOfWeights());
	scale(_histMeanMultiJPsi1S , 1.0/sumOfWeights());
	scale(_histMeanMultiPsi2S , 1.0/sumOfWeights());
	scale(_histMeanMultiUpsilon1S , 1.0/sumOfWeights());
	scale(_histMeanMultiF1_1285 , 1.0/sumOfWeights());
	scale(_histMeanMultiF1_1420 , 1.0/sumOfWeights());
	scale(_histMeanMultiChi_c1_3510 , 1.0/sumOfWeights());
	scale(_histMeanMultiF2_1270 , 1.0/sumOfWeights());
	scale(_histMeanMultiF2Prime1525 , 1.0/sumOfWeights());
	scale(_histMeanMultiK2Star1430_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiBStarStar , 1.0/sumOfWeights());
	scale(_histMeanMultiDs1Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiDs2Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiP , 1.0/sumOfWeights());
	scale(_histMeanMultiLambda , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma0 , 1.0/sumOfWeights());
	scale(_histMeanMultiSigmaMinus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigmaPlus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigmaPlusMinus , 1.0/sumOfWeights());
	scale(_histMeanMultiXiMinus , 1.0/sumOfWeights());
	scale(_histMeanMultiDelta1232PlusPlus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma1385Minus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma1385Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiSigma1385PlusMinus, 1.0/sumOfWeights());
	scale(_histMeanMultiXi1530_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiOmegaMinus , 1.0/sumOfWeights());
	scale(_histMeanMultiLambda_c_Plus , 1.0/sumOfWeights());
	scale(_histMeanMultiLambda_b_0 , 1.0/sumOfWeights());
	scale(_histMeanMultiLambda1520 , 1.0/sumOfWeights());
	}

	if (sqrtS()/GeV >= 130 && sqrtS()/GeV <= 200) {
	scale(_histMeanMultiPiPlus , 70.0/sumOfWeights());
	scale(_histMeanMultiKPlus , 70.0/sumOfWeights());
	scale(_histMeanMultiK0 , 70.0/sumOfWeights());
	scale(_histMeanMultiP , 70.0/sumOfWeights());
	scale(_histMeanMultiLambda , 70.0/sumOfWeights());
	}
	}

	//@}


	private:

	Histo1DPtr _histMeanMultiPiPlus;
	Histo1DPtr _histMeanMultiPi0;
	Histo1DPtr _histMeanMultiKPlus;
	Histo1DPtr _histMeanMultiK0;
	Histo1DPtr _histMeanMultiEta;
	Histo1DPtr _histMeanMultiEtaPrime;
	Histo1DPtr _histMeanMultiDPlus;
	Histo1DPtr _histMeanMultiD0;
	Histo1DPtr _histMeanMultiDPlus_s;
	Histo1DPtr _histMeanMultiBPlus_B0_d;
	Histo1DPtr _histMeanMultiBPlus_u;
	Histo1DPtr _histMeanMultiB0_s;
	Histo1DPtr _histMeanMultiF0_980;
	Histo1DPtr _histMeanMultiA0_980Plus;
	Histo1DPtr _histMeanMultiRho770_0;
	Histo1DPtr _histMeanMultiRho770Plus;
	Histo1DPtr _histMeanMultiOmega782;
	Histo1DPtr _histMeanMultiKStar892Plus;
	Histo1DPtr _histMeanMultiKStar892_0;
	Histo1DPtr _histMeanMultiPhi1020;
	Histo1DPtr _histMeanMultiDStar2010Plus;
	Histo1DPtr _histMeanMultiDStar2007_0;
	Histo1DPtr _histMeanMultiDStar_s2112Plus;
	Histo1DPtr _histMeanMultiBStar;
	Histo1DPtr _histMeanMultiJPsi1S;
	Histo1DPtr _histMeanMultiPsi2S;
	Histo1DPtr _histMeanMultiUpsilon1S;
	Histo1DPtr _histMeanMultiF1_1285;
	Histo1DPtr _histMeanMultiF1_1420;
	Histo1DPtr _histMeanMultiChi_c1_3510;
	Histo1DPtr _histMeanMultiF2_1270;
	Histo1DPtr _histMeanMultiF2Prime1525;
	Histo1DPtr _histMeanMultiK2Star1430Plus;
	Histo1DPtr _histMeanMultiK2Star1430_0;
	Histo1DPtr _histMeanMultiBStarStar;
	Histo1DPtr _histMeanMultiDs1Plus;
	Histo1DPtr _histMeanMultiDs2Plus;
	Histo1DPtr _histMeanMultiP;
	Histo1DPtr _histMeanMultiLambda;
	Histo1DPtr _histMeanMultiSigma0;
	Histo1DPtr _histMeanMultiSigmaMinus;
	Histo1DPtr _histMeanMultiSigmaPlus;
	Histo1DPtr _histMeanMultiSigmaPlusMinus;
	Histo1DPtr _histMeanMultiXiMinus;
	Histo1DPtr _histMeanMultiDelta1232PlusPlus;
	Histo1DPtr _histMeanMultiSigma1385Minus;
	Histo1DPtr _histMeanMultiSigma1385Plus;
	Histo1DPtr _histMeanMultiSigma1385PlusMinus;
	Histo1DPtr _histMeanMultiXi1530_0;
	Histo1DPtr _histMeanMultiOmegaMinus;
	Histo1DPtr _histMeanMultiLambda_c_Plus;
	Histo1DPtr _histMeanMultiLambda_b_0;
	Histo1DPtr _histMeanMultiSigma_c_PlusPlus_0;
	Histo1DPtr _histMeanMultiLambda1520;

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(PDG_HADRON_MULTIPLICITIES);

	}
	diff --git a/src/Analyses/PDG_HADRON_MULTIPLICITIES_RATIOS.cc b/src/Analyses/PDG_HADRON_MULTIPLICITIES_RATIOS.cc
	--- a/src/Analyses/PDG_HADRON_MULTIPLICITIES_RATIOS.cc
	+++ b/src/Analyses/PDG_HADRON_MULTIPLICITIES_RATIOS.cc
	@@ -1,764 +1,764 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief Implementation of PDG hadron multiplicities as ratios to \f$ \pi^\pm \f$ multiplicity
	/// @author Holger Schulz
	class PDG_HADRON_MULTIPLICITIES_RATIOS : public Analysis {
	public:

	/// Constructor
	PDG_HADRON_MULTIPLICITIES_RATIOS() : Analysis("PDG_HADRON_MULTIPLICITIES_RATIOS")
	{
	_weightedTotalNumPiPlus = 0;
	}


	/// @name Analysis methods
	//@{

	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed leptonic event cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed leptonic event cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	MSG_DEBUG("sqrt(S) = " << sqrtS()/GeV << " GeV");

	// Final state of unstable particles to get particle spectra
	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");

	if (sqrtS()/GeV >= 9.5 && sqrtS()/GeV <= 10.5) {
	foreach (const Particle& p, ufs.particles()) {
	const PdgId id = p.abspid();
	switch (id) {
	case 211:
	_weightedTotalNumPiPlus += weight;
	break;
	case 111:
	_histMeanMultiPi0->fill(_histMeanMultiPi0->bin(0).xMid(), weight);
	break;
	case 321:
	_histMeanMultiKPlus->fill(_histMeanMultiKPlus->bin(0).xMid(), weight);
	break;
	case 130:
	case 310:
	_histMeanMultiK0->fill(_histMeanMultiK0->bin(0).xMid(), weight);
	break;
	case 221:
	_histMeanMultiEta->fill(_histMeanMultiEta->bin(0).xMid(), weight);
	break;
	case 331:
	_histMeanMultiEtaPrime->fill(_histMeanMultiEtaPrime->bin(0).xMid(), weight);
	break;
	case 411:
	_histMeanMultiDPlus->fill(_histMeanMultiDPlus->bin(0).xMid(), weight);
	break;
	case 421:
	_histMeanMultiD0->fill(_histMeanMultiD0->bin(0).xMid(), weight);
	break;
	case 431:
	_histMeanMultiDPlus_s->fill(_histMeanMultiDPlus_s->bin(0).xMid(), weight);
	break;
	case 9010221:
	_histMeanMultiF0_980->fill(_histMeanMultiF0_980->bin(0).xMid(), weight);
	break;
	case 113:
	_histMeanMultiRho770_0->fill(_histMeanMultiRho770_0->bin(0).xMid(), weight);
	break;
	case 223:
	_histMeanMultiOmega782->fill(_histMeanMultiOmega782->bin(0).xMid(), weight);
	break;
	case 323:
	_histMeanMultiKStar892Plus->fill(_histMeanMultiKStar892Plus->bin(0).xMid(), weight);
	break;
	case 313:
	_histMeanMultiKStar892_0->fill(_histMeanMultiKStar892_0->bin(0).xMid(), weight);
	break;
	case 333:
	_histMeanMultiPhi1020->fill(_histMeanMultiPhi1020->bin(0).xMid(), weight);
	break;
	case 413:
	_histMeanMultiDStar2010Plus->fill(_histMeanMultiDStar2010Plus->bin(0).xMid(), weight);
	break;
	case 423:
	_histMeanMultiDStar2007_0->fill(_histMeanMultiDStar2007_0->bin(0).xMid(), weight);
	break;
	case 433:
	_histMeanMultiDStar_s2112Plus->fill(_histMeanMultiDStar_s2112Plus->bin(0).xMid(), weight);
	break;
	case 443:
	_histMeanMultiJPsi1S->fill(_histMeanMultiJPsi1S->bin(0).xMid(), weight);
	break;
	case 225:
	_histMeanMultiF2_1270->fill(_histMeanMultiF2_1270->bin(0).xMid(), weight);
	break;
	case 2212:
	_histMeanMultiP->fill(_histMeanMultiP->bin(0).xMid(), weight);
	break;
	case 3122:
	_histMeanMultiLambda->fill(_histMeanMultiLambda->bin(0).xMid(), weight);
	break;
	case 3212:
	_histMeanMultiSigma0->fill(_histMeanMultiSigma0->bin(0).xMid(), weight);
	break;
	case 3312:
	_histMeanMultiXiMinus->fill(_histMeanMultiXiMinus->bin(0).xMid(), weight);
	break;
	case 2224:
	_histMeanMultiDelta1232PlusPlus->fill(_histMeanMultiDelta1232PlusPlus->bin(0).xMid(), weight);
	break;
	case 3114:
	_histMeanMultiSigma1385Minus->fill(_histMeanMultiSigma1385Minus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3224:
	_histMeanMultiSigma1385Plus->fill(_histMeanMultiSigma1385Plus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3324:
	_histMeanMultiXi1530_0->fill(_histMeanMultiXi1530_0->bin(0).xMid(), weight);
	break;
	case 3334:
	_histMeanMultiOmegaMinus->fill(_histMeanMultiOmegaMinus->bin(0).xMid(), weight);
	break;
	case 4122:
	_histMeanMultiLambda_c_Plus->fill(_histMeanMultiLambda_c_Plus->bin(0).xMid(), weight);
	break;
	case 4222:
	case 4112:
	_histMeanMultiSigma_c_PlusPlus_0->fill(_histMeanMultiSigma_c_PlusPlus_0->bin(0).xMid(), weight);
	break;
	case 3124:
	_histMeanMultiLambda1520->fill(_histMeanMultiLambda1520->bin(0).xMid(), weight);
	break;
	}
	}
	}

	if (sqrtS()/GeV >= 29 && sqrtS()/GeV <= 35) {
	foreach (const Particle& p, ufs.particles()) {
	const PdgId id = p.abspid();
	switch (id) {
	case 211:
	_weightedTotalNumPiPlus += weight;
	break;
	case 111:
	_histMeanMultiPi0->fill(_histMeanMultiPi0->bin(0).xMid(), weight);
	break;
	case 321:
	_histMeanMultiKPlus->fill(_histMeanMultiKPlus->bin(0).xMid(), weight);
	break;
	case 130:
	case 310:
	_histMeanMultiK0->fill(_histMeanMultiK0->bin(0).xMid(), weight);
	break;
	case 221:
	_histMeanMultiEta->fill(_histMeanMultiEta->bin(0).xMid(), weight);
	break;
	case 331:
	_histMeanMultiEtaPrime->fill(_histMeanMultiEtaPrime->bin(0).xMid(), weight);
	break;
	case 411:
	_histMeanMultiDPlus->fill(_histMeanMultiDPlus->bin(0).xMid(), weight);
	break;
	case 421:
	_histMeanMultiD0->fill(_histMeanMultiD0->bin(0).xMid(), weight);
	break;
	case 431:
	_histMeanMultiDPlus_s->fill(_histMeanMultiDPlus_s->bin(0).xMid(), weight);
	break;
	case 9010221:
	_histMeanMultiF0_980->fill(_histMeanMultiF0_980->bin(0).xMid(), weight);
	break;
	case 113:
	_histMeanMultiRho770_0->fill(_histMeanMultiRho770_0->bin(0).xMid(), weight);
	break;
	case 323:
	_histMeanMultiKStar892Plus->fill(_histMeanMultiKStar892Plus->bin(0).xMid(), weight);
	break;
	case 313:
	_histMeanMultiKStar892_0->fill(_histMeanMultiKStar892_0->bin(0).xMid(), weight);
	break;
	case 333:
	_histMeanMultiPhi1020->fill(_histMeanMultiPhi1020->bin(0).xMid(), weight);
	break;
	case 413:
	_histMeanMultiDStar2010Plus->fill(_histMeanMultiDStar2010Plus->bin(0).xMid(), weight);
	break;
	case 423:
	_histMeanMultiDStar2007_0->fill(_histMeanMultiDStar2007_0->bin(0).xMid(), weight);
	break;
	case 225:
	_histMeanMultiF2_1270->fill(_histMeanMultiF2_1270->bin(0).xMid(), weight);
	break;
	case 325:
	_histMeanMultiK2Star1430Plus->fill(_histMeanMultiK2Star1430Plus->bin(0).xMid(), weight);
	break;
	case 315:
	_histMeanMultiK2Star1430_0->fill(_histMeanMultiK2Star1430_0->bin(0).xMid(), weight);
	break;
	case 2212:
	_histMeanMultiP->fill(_histMeanMultiP->bin(0).xMid(), weight);
	break;
	case 3122:
	_histMeanMultiLambda->fill(_histMeanMultiLambda->bin(0).xMid(), weight);
	break;
	case 3312:
	_histMeanMultiXiMinus->fill(_histMeanMultiXiMinus->bin(0).xMid(), weight);
	break;
	case 3114:
	_histMeanMultiSigma1385Minus->fill(_histMeanMultiSigma1385Minus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3224:
	_histMeanMultiSigma1385Plus->fill(_histMeanMultiSigma1385Plus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3334:
	_histMeanMultiOmegaMinus->fill(_histMeanMultiOmegaMinus->bin(0).xMid(), weight);
	break;
	case 4122:
	_histMeanMultiLambda_c_Plus->fill(_histMeanMultiLambda_c_Plus->bin(0).xMid(), weight);
	break;
	}
	}
	}

	if (sqrtS()/GeV >= 89.5 && sqrtS()/GeV <= 91.8) {
	foreach (const Particle& p, ufs.particles()) {
	const PdgId id = p.abspid();
	switch (id) {
	case 211:
	_weightedTotalNumPiPlus += weight;
	break;
	case 111:
	_histMeanMultiPi0->fill(_histMeanMultiPi0->bin(0).xMid(), weight);
	break;
	case 321:
	_histMeanMultiKPlus->fill(_histMeanMultiKPlus->bin(0).xMid(), weight);
	break;
	case 130:
	case 310:
	_histMeanMultiK0->fill(_histMeanMultiK0->bin(0).xMid(), weight);
	break;
	case 221:
	_histMeanMultiEta->fill(_histMeanMultiEta->bin(0).xMid(), weight);
	break;
	case 331:
	_histMeanMultiEtaPrime->fill(_histMeanMultiEtaPrime->bin(0).xMid(), weight);
	break;
	case 411:
	_histMeanMultiDPlus->fill(_histMeanMultiDPlus->bin(0).xMid(), weight);
	break;
	case 421:
	_histMeanMultiD0->fill(_histMeanMultiD0->bin(0).xMid(), weight);
	break;
	case 431:
	_histMeanMultiDPlus_s->fill(_histMeanMultiDPlus_s->bin(0).xMid(), weight);
	break;
	case 511:
	_histMeanMultiBPlus_B0_d->fill(_histMeanMultiBPlus_B0_d->bin(0).xMid(), weight);
	break;
	case 521:
	_histMeanMultiBPlus_B0_d->fill(_histMeanMultiBPlus_B0_d->bin(0).xMid(), weight);
	_histMeanMultiBPlus_u->fill(_histMeanMultiBPlus_u->bin(0).xMid(), weight);
	break;
	case 531:
	_histMeanMultiB0_s->fill(_histMeanMultiB0_s->bin(0).xMid(), weight);
	break;
	case 9010221:
	_histMeanMultiF0_980->fill(_histMeanMultiF0_980->bin(0).xMid(), weight);
	break;
	case 9000211:
	_histMeanMultiA0_980Plus->fill(_histMeanMultiA0_980Plus->bin(0).xMid(), weight);
	break;
	case 113:
	_histMeanMultiRho770_0->fill(_histMeanMultiRho770_0->bin(0).xMid(), weight);
	break;
	case 213:
	_histMeanMultiRho770Plus->fill(_histMeanMultiRho770Plus->bin(0).xMid(), weight);
	break;
	case 223:
	_histMeanMultiOmega782->fill(_histMeanMultiOmega782->bin(0).xMid(), weight);
	break;
	case 323:
	_histMeanMultiKStar892Plus->fill(_histMeanMultiKStar892Plus->bin(0).xMid(), weight);
	break;
	case 313:
	_histMeanMultiKStar892_0->fill(_histMeanMultiKStar892_0->bin(0).xMid(), weight);
	break;
	case 333:
	_histMeanMultiPhi1020->fill(_histMeanMultiPhi1020->bin(0).xMid(), weight);
	break;
	case 413:
	_histMeanMultiDStar2010Plus->fill(_histMeanMultiDStar2010Plus->bin(0).xMid(), weight);
	break;
	case 433:
	_histMeanMultiDStar_s2112Plus->fill(_histMeanMultiDStar_s2112Plus->bin(0).xMid(), weight);
	break;
	case 513:
	case 523:
	case 533:
	_histMeanMultiBStar->fill(_histMeanMultiBStar->bin(0).xMid(), weight);
	break;
	case 443:
	_histMeanMultiJPsi1S->fill(_histMeanMultiJPsi1S->bin(0).xMid(), weight);
	break;
	case 100443:
	_histMeanMultiPsi2S->fill(_histMeanMultiPsi2S->bin(0).xMid(), weight);
	break;
	case 553:
	_histMeanMultiUpsilon1S->fill(_histMeanMultiUpsilon1S->bin(0).xMid(), weight);
	break;
	case 20223:
	_histMeanMultiF1_1285->fill(_histMeanMultiF1_1285->bin(0).xMid(), weight);
	break;
	case 20333:
	_histMeanMultiF1_1420->fill(_histMeanMultiF1_1420->bin(0).xMid(), weight);
	break;
	case 445:
	_histMeanMultiChi_c1_3510->fill(_histMeanMultiChi_c1_3510->bin(0).xMid(), weight);
	break;
	case 225:
	_histMeanMultiF2_1270->fill(_histMeanMultiF2_1270->bin(0).xMid(), weight);
	break;
	case 335:
	_histMeanMultiF2Prime1525->fill(_histMeanMultiF2Prime1525->bin(0).xMid(), weight);
	break;
	case 315:
	_histMeanMultiK2Star1430_0->fill(_histMeanMultiK2Star1430_0->bin(0).xMid(), weight);
	break;
	case 515:
	case 525:
	case 535:
	_histMeanMultiBStarStar->fill(_histMeanMultiBStarStar->bin(0).xMid(), weight);
	break;
	case 10433:
	case 20433:
	_histMeanMultiDs1Plus->fill(_histMeanMultiDs1Plus->bin(0).xMid(), weight);
	break;
	case 435:
	_histMeanMultiDs2Plus->fill(_histMeanMultiDs2Plus->bin(0).xMid(), weight);
	break;
	case 2212:
	_histMeanMultiP->fill(_histMeanMultiP->bin(0).xMid(), weight);
	break;
	case 3122:
	_histMeanMultiLambda->fill(_histMeanMultiLambda->bin(0).xMid(), weight);
	break;
	case 3212:
	_histMeanMultiSigma0->fill(_histMeanMultiSigma0->bin(0).xMid(), weight);
	break;
	case 3112:
	_histMeanMultiSigmaMinus->fill(_histMeanMultiSigmaMinus->bin(0).xMid(), weight);
	_histMeanMultiSigmaPlusMinus->fill(_histMeanMultiSigmaPlusMinus->bin(0).xMid(), weight);
	break;
	case 3222:
	_histMeanMultiSigmaPlus->fill(_histMeanMultiSigmaPlus->bin(0).xMid(), weight);
	_histMeanMultiSigmaPlusMinus->fill(_histMeanMultiSigmaPlusMinus->bin(0).xMid(), weight);
	break;
	case 3312:
	_histMeanMultiXiMinus->fill(_histMeanMultiXiMinus->bin(0).xMid(), weight);
	break;
	case 2224:
	_histMeanMultiDelta1232PlusPlus->fill(_histMeanMultiDelta1232PlusPlus->bin(0).xMid(), weight);
	break;
	case 3114:
	_histMeanMultiSigma1385Minus->fill(_histMeanMultiSigma1385Minus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3224:
	_histMeanMultiSigma1385Plus->fill(_histMeanMultiSigma1385Plus->bin(0).xMid(), weight);
	_histMeanMultiSigma1385PlusMinus->fill(_histMeanMultiSigma1385PlusMinus->bin(0).xMid(), weight);
	break;
	case 3324:
	_histMeanMultiXi1530_0->fill(_histMeanMultiXi1530_0->bin(0).xMid(), weight);
	break;
	case 3334:
	_histMeanMultiOmegaMinus->fill(_histMeanMultiOmegaMinus->bin(0).xMid(), weight);
	break;
	case 4122:
	_histMeanMultiLambda_c_Plus->fill(_histMeanMultiLambda_c_Plus->bin(0).xMid(), weight);
	break;
	case 5122:
	_histMeanMultiLambda_b_0->fill(_histMeanMultiLambda_b_0->bin(0).xMid(), weight);
	break;
	case 3124:
	_histMeanMultiLambda1520->fill(_histMeanMultiLambda1520->bin(0).xMid(), weight);
	break;
	}
	}
	}

	if (sqrtS()/GeV >= 130 && sqrtS()/GeV <= 200) {
	foreach (const Particle& p, ufs.particles()) {
	const PdgId id = p.abspid();
	switch (id) {
	case 211:
	_weightedTotalNumPiPlus += weight;
	break;
	case 321:
	_histMeanMultiKPlus->fill(_histMeanMultiKPlus->bin(0).xMid(), weight);
	break;
	case 130:
	case 310:
	_histMeanMultiK0->fill(_histMeanMultiK0->bin(0).xMid(), weight);
	break;
	case 2212:
	_histMeanMultiP->fill(_histMeanMultiP->bin(0).xMid(), weight);
	break;
	case 3122:
	_histMeanMultiLambda->fill(_histMeanMultiLambda->bin(0).xMid(), weight);
	break;
	}
	}
	}

	}



	void init() {
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");

	if (sqrtS()/GeV >= 9.5 && sqrtS()/GeV <= 10.5) {
	_histMeanMultiPi0 = bookHisto1D( 2, 1, 1);
	_histMeanMultiKPlus = bookHisto1D( 3, 1, 1);
	_histMeanMultiK0 = bookHisto1D( 4, 1, 1);
	_histMeanMultiEta = bookHisto1D( 5, 1, 1);
	_histMeanMultiEtaPrime = bookHisto1D( 6, 1, 1);
	_histMeanMultiDPlus = bookHisto1D( 7, 1, 1);
	_histMeanMultiD0 = bookHisto1D( 8, 1, 1);
	_histMeanMultiDPlus_s = bookHisto1D( 9, 1, 1);
	_histMeanMultiF0_980 = bookHisto1D(13, 1, 1);
	_histMeanMultiRho770_0 = bookHisto1D(15, 1, 1);
	_histMeanMultiOmega782 = bookHisto1D(17, 1, 1);
	_histMeanMultiKStar892Plus = bookHisto1D(18, 1, 1);
	_histMeanMultiKStar892_0 = bookHisto1D(19, 1, 1);
	_histMeanMultiPhi1020 = bookHisto1D(20, 1, 1);
	_histMeanMultiDStar2010Plus = bookHisto1D(21, 1, 1);
	_histMeanMultiDStar2007_0 = bookHisto1D(22, 1, 1);
	_histMeanMultiDStar_s2112Plus = bookHisto1D(23, 1, 1);
	_histMeanMultiJPsi1S = bookHisto1D(25, 1, 1);
	_histMeanMultiF2_1270 = bookHisto1D(31, 1, 1);
	_histMeanMultiP = bookHisto1D(38, 1, 1);
	_histMeanMultiLambda = bookHisto1D(39, 1, 1);
	_histMeanMultiSigma0 = bookHisto1D(40, 1, 1);
	_histMeanMultiXiMinus = bookHisto1D(44, 1, 1);
	_histMeanMultiDelta1232PlusPlus = bookHisto1D(45, 1, 1);
	_histMeanMultiSigma1385Minus = bookHisto1D(46, 1, 1);
	_histMeanMultiSigma1385Plus = bookHisto1D(47, 1, 1);
	_histMeanMultiSigma1385PlusMinus = bookHisto1D(48, 1, 1);
	_histMeanMultiXi1530_0 = bookHisto1D(49, 1, 1);
	_histMeanMultiOmegaMinus = bookHisto1D(50, 1, 1);
	_histMeanMultiLambda_c_Plus = bookHisto1D(51, 1, 1);
	_histMeanMultiSigma_c_PlusPlus_0 = bookHisto1D(53, 1, 1);
	_histMeanMultiLambda1520 = bookHisto1D(54, 1, 1);
	}

	if (sqrtS()/GeV >= 29 && sqrtS()/GeV <= 35) {
	_histMeanMultiPi0 = bookHisto1D( 2, 1, 2);
	_histMeanMultiKPlus = bookHisto1D( 3, 1, 2);
	_histMeanMultiK0 = bookHisto1D( 4, 1, 2);
	_histMeanMultiEta = bookHisto1D( 5, 1, 2);
	_histMeanMultiEtaPrime = bookHisto1D( 6, 1, 2);
	_histMeanMultiDPlus = bookHisto1D( 7, 1, 2);
	_histMeanMultiD0 = bookHisto1D( 8, 1, 2);
	_histMeanMultiDPlus_s = bookHisto1D( 9, 1, 2);
	_histMeanMultiF0_980 = bookHisto1D(13, 1, 2);
	_histMeanMultiRho770_0 = bookHisto1D(15, 1, 2);
	_histMeanMultiKStar892Plus = bookHisto1D(18, 1, 2);
	_histMeanMultiKStar892_0 = bookHisto1D(19, 1, 2);
	_histMeanMultiPhi1020 = bookHisto1D(20, 1, 2);
	_histMeanMultiDStar2010Plus = bookHisto1D(21, 1, 2);
	_histMeanMultiDStar2007_0 = bookHisto1D(22, 1, 2);
	_histMeanMultiF2_1270 = bookHisto1D(31, 1, 2);
	_histMeanMultiK2Star1430Plus = bookHisto1D(33, 1, 1);
	_histMeanMultiK2Star1430_0 = bookHisto1D(34, 1, 1);
	_histMeanMultiP = bookHisto1D(38, 1, 2);
	_histMeanMultiLambda = bookHisto1D(39, 1, 2);
	_histMeanMultiXiMinus = bookHisto1D(44, 1, 2);
	_histMeanMultiSigma1385Minus = bookHisto1D(46, 1, 2);
	_histMeanMultiSigma1385Plus = bookHisto1D(47, 1, 2);
	_histMeanMultiSigma1385PlusMinus = bookHisto1D(48, 1, 2);
	_histMeanMultiOmegaMinus = bookHisto1D(50, 1, 2);
	_histMeanMultiLambda_c_Plus = bookHisto1D(51, 1, 2);
	}

	if (sqrtS()/GeV >= 89.5 && sqrtS()/GeV <= 91.8) {
	_histMeanMultiPi0 = bookHisto1D( 2, 1, 3);
	_histMeanMultiKPlus = bookHisto1D( 3, 1, 3);
	_histMeanMultiK0 = bookHisto1D( 4, 1, 3);
	_histMeanMultiEta = bookHisto1D( 5, 1, 3);
	_histMeanMultiEtaPrime = bookHisto1D( 6, 1, 3);
	_histMeanMultiDPlus = bookHisto1D( 7, 1, 3);
	_histMeanMultiD0 = bookHisto1D( 8, 1, 3);
	_histMeanMultiDPlus_s = bookHisto1D( 9, 1, 3);
	_histMeanMultiBPlus_B0_d = bookHisto1D(10, 1, 1);
	_histMeanMultiBPlus_u = bookHisto1D(11, 1, 1);
	_histMeanMultiB0_s = bookHisto1D(12, 1, 1);
	_histMeanMultiF0_980 = bookHisto1D(13, 1, 3);
	_histMeanMultiA0_980Plus = bookHisto1D(14, 1, 1);
	_histMeanMultiRho770_0 = bookHisto1D(15, 1, 3);
	_histMeanMultiRho770Plus = bookHisto1D(16, 1, 1);
	_histMeanMultiOmega782 = bookHisto1D(17, 1, 2);
	_histMeanMultiKStar892Plus = bookHisto1D(18, 1, 3);
	_histMeanMultiKStar892_0 = bookHisto1D(19, 1, 3);
	_histMeanMultiPhi1020 = bookHisto1D(20, 1, 3);
	_histMeanMultiDStar2010Plus = bookHisto1D(21, 1, 3);
	_histMeanMultiDStar_s2112Plus = bookHisto1D(23, 1, 2);
	_histMeanMultiBStar = bookHisto1D(24, 1, 1);
	_histMeanMultiJPsi1S = bookHisto1D(25, 1, 2);
	_histMeanMultiPsi2S = bookHisto1D(26, 1, 1);
	_histMeanMultiUpsilon1S = bookHisto1D(27, 1, 1);
	_histMeanMultiF1_1285 = bookHisto1D(28, 1, 1);
	_histMeanMultiF1_1420 = bookHisto1D(29, 1, 1);
	_histMeanMultiChi_c1_3510 = bookHisto1D(30, 1, 1);
	_histMeanMultiF2_1270 = bookHisto1D(31, 1, 3);
	_histMeanMultiF2Prime1525 = bookHisto1D(32, 1, 1);
	_histMeanMultiK2Star1430_0 = bookHisto1D(34, 1, 2);
	_histMeanMultiBStarStar = bookHisto1D(35, 1, 1);
	_histMeanMultiDs1Plus = bookHisto1D(36, 1, 1);
	_histMeanMultiDs2Plus = bookHisto1D(37, 1, 1);
	_histMeanMultiP = bookHisto1D(38, 1, 3);
	_histMeanMultiLambda = bookHisto1D(39, 1, 3);
	_histMeanMultiSigma0 = bookHisto1D(40, 1, 2);
	_histMeanMultiSigmaMinus = bookHisto1D(41, 1, 1);
	_histMeanMultiSigmaPlus = bookHisto1D(42, 1, 1);
	_histMeanMultiSigmaPlusMinus = bookHisto1D(43, 1, 1);
	_histMeanMultiXiMinus = bookHisto1D(44, 1, 3);
	_histMeanMultiDelta1232PlusPlus = bookHisto1D(45, 1, 2);
	_histMeanMultiSigma1385Minus = bookHisto1D(46, 1, 3);
	_histMeanMultiSigma1385Plus = bookHisto1D(47, 1, 3);
	_histMeanMultiSigma1385PlusMinus = bookHisto1D(48, 1, 3);
	_histMeanMultiXi1530_0 = bookHisto1D(49, 1, 2);
	_histMeanMultiOmegaMinus = bookHisto1D(50, 1, 3);
	_histMeanMultiLambda_c_Plus = bookHisto1D(51, 1, 3);
	_histMeanMultiLambda_b_0 = bookHisto1D(52, 1, 1);
	_histMeanMultiLambda1520 = bookHisto1D(54, 1, 2);
	}

	if (sqrtS()/GeV >= 130 && sqrtS()/GeV <= 200) {
	_histMeanMultiKPlus = bookHisto1D( 3, 1, 4);
	_histMeanMultiK0 = bookHisto1D( 4, 1, 4);
	_histMeanMultiP = bookHisto1D(38, 1, 4);
	_histMeanMultiLambda = bookHisto1D(39, 1, 4);
	}
	}



	// Finalize
	void finalize() {
	if (sqrtS()/GeV >= 9.5 && sqrtS()/GeV <= 10.5) {
	scale(_histMeanMultiPi0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiKPlus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiK0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiEta , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiEtaPrime , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDPlus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiD0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDPlus_s , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiF0_980 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiRho770_0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiOmega782 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiKStar892Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiKStar892_0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiPhi1020 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDStar2010Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDStar2007_0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDStar_s2112Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiJPsi1S , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiF2_1270 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiP , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiXiMinus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDelta1232PlusPlus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma1385Minus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma1385Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma1385PlusMinus, 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiXi1530_0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiOmegaMinus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda_c_Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma_c_PlusPlus_0, 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda1520 , 1.0/_weightedTotalNumPiPlus);
	}

	if (sqrtS()/GeV >= 29 && sqrtS()/GeV <= 35) {
	scale(_histMeanMultiPi0 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiKPlus , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiK0 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiEta , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiEtaPrime , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDPlus , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiD0 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDPlus_s , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiF0_980 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiRho770_0 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiKStar892Plus , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiKStar892_0 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiPhi1020 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDStar2010Plus , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDStar2007_0 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiF2_1270 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiK2Star1430Plus , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiK2Star1430_0 , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiP , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiXiMinus , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma1385Minus , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma1385Plus , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma1385PlusMinus, 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiOmegaMinus , 5.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda_c_Plus , 5.0/_weightedTotalNumPiPlus);
	}

	if (sqrtS()/GeV >= 89.5 && sqrtS()/GeV <= 91.8) {
	scale(_histMeanMultiPi0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiKPlus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiK0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiEta , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiEtaPrime , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDPlus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiD0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDPlus_s , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiBPlus_B0_d , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiBPlus_u , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiB0_s , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiF0_980 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiA0_980Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiRho770_0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiRho770Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiOmega782 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiKStar892Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiKStar892_0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiPhi1020 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDStar2010Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDStar_s2112Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiBStar , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiJPsi1S , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiPsi2S , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiUpsilon1S , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiF1_1285 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiF1_1420 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiChi_c1_3510 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiF2_1270 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiF2Prime1525 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiK2Star1430_0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiBStarStar , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDs1Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDs2Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiP , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigmaMinus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigmaPlus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigmaPlusMinus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiXiMinus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiDelta1232PlusPlus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma1385Minus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma1385Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiSigma1385PlusMinus, 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiXi1530_0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiOmegaMinus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda_c_Plus , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda_b_0 , 1.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda1520 , 1.0/_weightedTotalNumPiPlus);
	}

	if (sqrtS()/GeV >= 130 && sqrtS()/GeV <= 200) {
	scale(_histMeanMultiKPlus , 70.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiK0 , 70.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiP , 70.0/_weightedTotalNumPiPlus);
	scale(_histMeanMultiLambda , 70.0/_weightedTotalNumPiPlus);
	}
	}

	//@}


	private:

	double _weightedTotalNumPiPlus;

	Histo1DPtr _histMeanMultiPi0;
	Histo1DPtr _histMeanMultiKPlus;
	Histo1DPtr _histMeanMultiK0;
	Histo1DPtr _histMeanMultiEta;
	Histo1DPtr _histMeanMultiEtaPrime;
	Histo1DPtr _histMeanMultiDPlus;
	Histo1DPtr _histMeanMultiD0;
	Histo1DPtr _histMeanMultiDPlus_s;
	Histo1DPtr _histMeanMultiBPlus_B0_d;
	Histo1DPtr _histMeanMultiBPlus_u;
	Histo1DPtr _histMeanMultiB0_s;
	Histo1DPtr _histMeanMultiF0_980;
	Histo1DPtr _histMeanMultiA0_980Plus;
	Histo1DPtr _histMeanMultiRho770_0;
	Histo1DPtr _histMeanMultiRho770Plus;
	Histo1DPtr _histMeanMultiOmega782;
	Histo1DPtr _histMeanMultiKStar892Plus;
	Histo1DPtr _histMeanMultiKStar892_0;
	Histo1DPtr _histMeanMultiPhi1020;
	Histo1DPtr _histMeanMultiDStar2010Plus;
	Histo1DPtr _histMeanMultiDStar2007_0;
	Histo1DPtr _histMeanMultiDStar_s2112Plus;
	Histo1DPtr _histMeanMultiBStar;
	Histo1DPtr _histMeanMultiJPsi1S;
	Histo1DPtr _histMeanMultiPsi2S;
	Histo1DPtr _histMeanMultiUpsilon1S;
	Histo1DPtr _histMeanMultiF1_1285;
	Histo1DPtr _histMeanMultiF1_1420;
	Histo1DPtr _histMeanMultiChi_c1_3510;
	Histo1DPtr _histMeanMultiF2_1270;
	Histo1DPtr _histMeanMultiF2Prime1525;
	Histo1DPtr _histMeanMultiK2Star1430Plus;
	Histo1DPtr _histMeanMultiK2Star1430_0;
	Histo1DPtr _histMeanMultiBStarStar;
	Histo1DPtr _histMeanMultiDs1Plus;
	Histo1DPtr _histMeanMultiDs2Plus;
	Histo1DPtr _histMeanMultiP;
	Histo1DPtr _histMeanMultiLambda;
	Histo1DPtr _histMeanMultiSigma0;
	Histo1DPtr _histMeanMultiSigmaMinus;
	Histo1DPtr _histMeanMultiSigmaPlus;
	Histo1DPtr _histMeanMultiSigmaPlusMinus;
	Histo1DPtr _histMeanMultiXiMinus;
	Histo1DPtr _histMeanMultiDelta1232PlusPlus;
	Histo1DPtr _histMeanMultiSigma1385Minus;
	Histo1DPtr _histMeanMultiSigma1385Plus;
	Histo1DPtr _histMeanMultiSigma1385PlusMinus;
	Histo1DPtr _histMeanMultiXi1530_0;
	Histo1DPtr _histMeanMultiOmegaMinus;
	Histo1DPtr _histMeanMultiLambda_c_Plus;
	Histo1DPtr _histMeanMultiLambda_b_0;
	Histo1DPtr _histMeanMultiSigma_c_PlusPlus_0;
	Histo1DPtr _histMeanMultiLambda1520;

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(PDG_HADRON_MULTIPLICITIES_RATIOS);

	}
	diff --git a/src/Analyses/PDG_TAUS.cc b/src/Analyses/PDG_TAUS.cc
	--- a/src/Analyses/PDG_TAUS.cc
	+++ b/src/Analyses/PDG_TAUS.cc
	@@ -1,216 +1,214 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/TauFinder.hh"

	namespace Rivet {


	class PDG_TAUS : public Analysis {
	public:

	/// Constructor
	PDG_TAUS()
	: Analysis("PDG_TAUS"),
	_weights_had(0),
	_weights_mu(0),
	_weights_el(0)
	{ }


	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {

	TauFinder tauleptonic(TauFinder::LEPTONIC); // open cuts, leptonic decays
	- addProjection(tauleptonic, "TauLeptonic");
	+ declare(tauleptonic, "TauLeptonic");

	TauFinder tauhadronic(TauFinder::HADRONIC); // open cuts, hadronic decays
	- addProjection(tauhadronic, "TauHadronic");
	+ declare(tauhadronic, "TauHadronic");

	populateDecayMap();

	_h_ratio_mu = bookHisto1D(1, 1, 1);
	_h_ratio_el = bookHisto1D(1, 1, 2);
	_h_1prong_pinu = bookHisto1D(2, 1, 1);
	_h_1prong_Kpnu = bookHisto1D(2, 1, 2);
	_h_1prong_pipinu = bookHisto1D(2, 1, 3);
	_h_1prong_Kppinu = bookHisto1D(2, 1, 4);
	_h_1prong_pipipinu = bookHisto1D(2, 1, 5);
	_h_1prong_Knpinu = bookHisto1D(2, 1, 6);
	_h_3prong_pipipinu = bookHisto1D(2, 2, 1);
	_h_5prong = bookHisto1D(2, 3, 1);
	}


	/// Perform the per-event analysis
	void analyze(const Event& e) {
	const double weight = e.weight();

	- const TauFinder& taulep = applyProjection<TauFinder>(e, "TauLeptonic");
	- const TauFinder& tauhad = applyProjection<TauFinder>(e, "TauHadronic");
	+ const TauFinder& taulep = apply<TauFinder>(e, "TauLeptonic");
	+ const TauFinder& tauhad = apply<TauFinder>(e, "TauHadronic");

	// Hadronic tau decays --- prong decays
	foreach(const Particle& tau, tauhad.taus()) {
	_weights_had += weight;
	int prongs = countProngs(tau); // number of charged particles among decay products
	// Only do 1 prong decays here
	if (prongs == 1) {
	////// Exclusive decay modes "1-prong"
	if (analyzeDecay(tau, decay_pids["pinu"], true)) _h_1prong_pinu->fill(1, weight);
	if (analyzeDecay(tau, decay_pids["Kpnu"], true)) _h_1prong_Kpnu->fill(1, weight);
	if (analyzeDecay(tau, decay_pids["pipinu"], true)) _h_1prong_pipinu->fill(1, weight);
	if (analyzeDecay(tau, decay_pids["Kppinu"] , true)) _h_1prong_Kppinu->fill(1, weight);
	if (analyzeDecay(tau, decay_pids["pipipinu"], true)) _h_1prong_pipipinu->fill(1, weight);
	// Kshort, Klong --- (twice) filling the K0 labelled PDG histo
	if (analyzeDecay(tau, decay_pids["KSpinu"] , true)) _h_1prong_Knpinu->fill(1, weight);
	if (analyzeDecay(tau, decay_pids["KLpinu"] , true)) _h_1prong_Knpinu->fill(1, weight);
	}
	else if (prongs == 3) {
	if (analyzeDecay(tau, decay_pids["3pipipinu"], true)) _h_3prong_pipipinu->fill(1, weight);
	}
	else if (prongs == 5 && !any(tau.children(), HasAbsPID(310))) _h_5prong->fill(1, weight);
	}

	// Leptonic tau decays --- look for radiative and non-radiative 1 prong decays
	foreach(const Particle& tau, taulep.taus()) {
	int prongs = countProngs(tau); // number of charged particles among decay products
	// Only do 1 prong decays here
	if (prongs == 1) {
	analyzeRadiativeDecay(tau, decay_pids["muids"], _weights_mu, weight, true, _h_ratio_mu);
	analyzeRadiativeDecay(tau, decay_pids["elids"], _weights_el, weight, true, _h_ratio_el);
	}
	}
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	scale(_h_ratio_mu, 1./_weights_mu);
	scale(_h_ratio_el, 1./_weights_el);

	const double norm = _weights_had + _weights_mu + _weights_el;
	scale(_h_1prong_pinu, 1./norm);
	scale(_h_1prong_Kpnu, 1./norm);
	scale(_h_1prong_pipinu, 1./norm);
	scale(_h_1prong_Kppinu, 1./norm);
	scale(_h_1prong_pipipinu, 1./norm);
	scale(_h_1prong_Knpinu, 1./norm);
	scale(_h_3prong_pipipinu, 1./norm);
	scale(_h_5prong, 1./norm);
	}


	// Short hand
	bool contains(Particle& mother, int id, bool abs=false) {
	if (abs) return any(mother.children(), HasAbsPID(id));
	return any(mother.children(), HasPID(id));
	}


	// Count charged decay products
	int countProngs(Particle mother) {
	int n_prongs = 0;
	foreach(Particle p, mother.children())
	if (p.threeCharge()!=0) ++n_prongs;
	return n_prongs;
	}


	// Set up a lookup table for decays
	void populateDecayMap() {
	decay_pids["muids"] = {{ 13,14,16 }};
	decay_pids["elids"] = {{ 11,12,16 }};
	decay_pids["pinu"] = {{ 211,16 }};
	decay_pids["Kpnu"] = {{ 321,16 }};
	decay_pids["pipinu"] = {{ 111,211,16 }};
	decay_pids["Kppinu"] = {{ 111,321,16 }};
	decay_pids["pipipinu"] = {{ 111,111,211,16 }};
	decay_pids["KSpinu"] = {{ 211,310,16 }};
	decay_pids["KLpinu"] = {{ 211,130,16 }};
	decay_pids["3pipipinu"] = {{ 211,211,211,16 }};
	}


	bool analyzeDecay(Particle mother, vector<int> ids, bool absolute) {
	// There is no point in looking for decays with less particles than to be analysed
	if (mother.children().size() == ids.size()) {
	bool decayfound = true;
	foreach (int id, ids) {
	if (!contains(mother, id, absolute)) decayfound = false;
	}
	return decayfound;
	} // end of first if
	return false;
	}


	// Look for radiative (and non-radiative) tau decays to fill a ratio histo
	void analyzeRadiativeDecay(Particle mother, vector<int> ids, double &w_incl, double e_weight, bool absolute, Histo1DPtr h_ratio) {
	// w_incl ... reference to a global weight counter for all leptonic tau decays
	// e_weight ... the current event weight
	// h_ratio ... pointer to ratio histo --- filled with e_weight in case of radiative events only

	// There is no point in looking for decays with less particles than to be analysed
	if (mother.children().size() >= ids.size()) {
	bool decayfound = true;
	foreach (int id, ids) {
	if (!contains(mother, id, absolute)) decayfound = false;
	}
	// Do not increment counters if the specified decay products were not found
	if (decayfound) {
	w_incl += e_weight; // the (global) weight counter for leptonic decays
	bool radiative = any(mother.children(), HasPID(PID::PHOTON));

	// Only fill the histo if there is a radiative decay
	if (radiative) {
	- // Iterate over decay products to find photon with 5MeV energy
	+ // Iterate over decay products to find photon with 5 MeV energy
	foreach (const Particle& son, mother.children()) {
	if (son.pid() == PID::PHOTON) {
	// Require photons to have at least 5 MeV energy in the rest frame of the tau
	// boosted taus
	- if (!mother.momentum().boostVector().isZero()) {
	- LorentzTransform cms_boost;
	- Vector3 bv = -mother.momentum().boostVector();
	- cms_boost = LorentzTransform(bv);
	- if (cms_boost.transform(son.momentum())[0]/MeV > 5.) {
	- h_ratio->fill(1, e_weight);
	- break;
	- }
	+ if (!mother.momentum().betaVec().isZero()) {
	+ LorentzTransform cms_boost = LorentzTransform::mkFrameTransformFromBeta(mother.momentum().betaVec());
	+ if (cms_boost.transform(son.momentum())[0]/MeV > 5.) {
	+ h_ratio->fill(1, e_weight);
	+ break;
	+ }
	}
	// not boosted taus
	else {
	if (son.momentum()[0]/MeV > 5.) {
	h_ratio->fill(1, e_weight);
	break;
	}
	}
	}
	} // end loop over decay products
	} // end of radiative
	} // end of decayfound
	} // end of first if
	}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_ratio_mu, _h_ratio_el;
	Histo1DPtr _h_1prong_pinu, _h_1prong_Kpnu, _h_1prong_Kppinu, _h_1prong_pipinu, _h_1prong_pipipinu, _h_1prong_Knpinu;
	Histo1DPtr _h_3prong_pipipinu;
	Histo1DPtr _h_5prong;
	//@}

	double _weights_had, _weights_mu, _weights_el;
	map<string, vector<int> > decay_pids;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(PDG_TAUS);

	}
	diff --git a/src/Analyses/SFM_1984_S1178091.cc b/src/Analyses/SFM_1984_S1178091.cc
	--- a/src/Analyses/SFM_1984_S1178091.cc
	+++ b/src/Analyses/SFM_1984_S1178091.cc
	@@ -1,134 +1,100 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	/// @brief SFM charged multiplicities in NSD and inelastic minbias events
	class SFM_1984_S1178091 : public Analysis {
	public:

	/// Constructor
	- SFM_1984_S1178091() : Analysis("SFM_1984_S1178091") {
	- _sumW = 0;
	- _sumWDiff = 0;
	- }
	+ SFM_1984_S1178091() : Analysis("SFM_1984_S1178091") {}


	/// @name Analysis methods
	//@{

	void init() {
	// Projections
	- /// @todo Corrected to full phase space?
	- addProjection(ChargedFinalState(-10,10,250*MeV), "FS");
	+ //
	+ declare(ChargedFinalState(Cuts::absrap<5 && Cuts::pT>250MeV && Cuts::pT<3GeV), "FS");

	// Histograms
	if (fuzzyEquals(sqrtS()/GeV, 30.4, 1E-1)) {
	_hist_multiplicity_inel = bookHisto1D(1, 1, 1);
	_hist_multiplicity_nsd = bookHisto1D(2, 1, 1);
	} else if (fuzzyEquals(sqrtS(), 44.5, 1E-1)) {
	_hist_multiplicity_inel = bookHisto1D(1, 1, 2);
	_hist_multiplicity_nsd = bookHisto1D(2, 1, 2);
	} else if (fuzzyEquals(sqrtS(), 52.2, 1E-1)) {
	_hist_multiplicity_inel = bookHisto1D(1, 1, 3);
	_hist_multiplicity_nsd = bookHisto1D(2, 1, 3);
	} else if (fuzzyEquals(sqrtS(), 62.2, 1E-1)) {
	_hist_multiplicity_inel = bookHisto1D(1, 1, 4);
	_hist_multiplicity_nsd = bookHisto1D(2, 1, 4);
	}

	}


	// Analyse each event
	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ChargedFinalState& fs = applyProjection<ChargedFinalState>(event, "FS");
	- //const size_t numParticles = fs.particles().size();
	- size_t N=0;
	+ const ChargedFinalState& fs = apply<ChargedFinalState>(event, "FS");

	- /// @todo Any trigger?
	- //
	// Trigger
	- //if (numParticles <1 ) vetoEvent;
	+ if (fs.particles().size() <1 ) vetoEvent;

	- // Decide whether event is of diffractive type or not
	- // @todo It is not so clear in the paper how this distinction is made.
	- // They seem to require either exactly one particle with Feynman x larger
	- // than 0.8 to call an event diffractive or that there are no tracks
	- // reconstructed in either of the two hemispheres. For the latter
	- // they require in addition also the number of charged particles
	- // to be smaller than 8.
	+ // Event classification:
	int n_left(0), n_right(0), n_large_x(0);
	foreach (const Particle& p, fs.particles()) {
	// Calculate the particles' Feynman x
	- if (p.pT() <=3*GeV) {
	- N++;
	- const double x_feyn = 2.0 * fabs(p.pz())/sqrtS();
	- if (x_feyn > 0.8 ) n_large_x += 1;
	+ const double x_feyn = 2.0 * fabs(p.pz())/sqrtS();
	+ if (x_feyn > 0.8 ) n_large_x += 1;

	- // Pseudorapidity
	- const double eta = p.eta();
	- if (eta > 0.0) n_right += 1;
	- else if (eta < 0.0) n_left += 1;
	- }
	+ // Pseudorapidity
	+ const double eta = p.eta();
	+ if (eta > 0.0) n_right += 1;
	+ else if (eta < 0.0) n_left += 1;
	}
	MSG_DEBUG("N_left: " << n_left << ", "
	<< "N_right: " << n_right << ", "
	<< "N_large_x: " << n_large_x);

	- if ( N < 1 ) vetoEvent;
	- // Not sure about the "=="!
	- // @todo Not sure about the "== 1", the paper says no charged particle
	- // that was reconstructed so the incoming protons must run down the beam
	- // pipe. Since we look a the complete final state here no particle being
	- // reconstructed should be equal to one particle (proton) in each
	- // hemisphere. The "< 8" is also not certain.
	- const bool isDiffractive = (n_large_x == 1) \|\|
	- (( (n_left + n_right) == 1) && (N < 7) );
	- //((n_left == 1 \|\| n_right == 1) && N < 8 );
	- //((n_left == 1 \|\| n_right == 1) && numParticles < 8 );
	+
	+ // Single diffractive: either one large x particle or 0 particles in the one hemisphere but more than 7 in the other hemisphere
	+ bool isDiffractive = (n_large_x == 1) \|\| ( ((n_left==0) && (fs.particles().size() < 7)) \|\| ((n_right==0) && (fs.particles().size() < 7)) );

	- // Increment weight counters
	- _sumW += weight;
	- _sumWDiff += weight;

	- // Fill histos of charged multiplicity distributions
	- //_hist_multiplicity_inel->fill(numParticles, weight);
	- //if (!isDiffractive) _hist_multiplicity_nsd->fill(numParticles, weight);
	- _hist_multiplicity_inel->fill(N, weight);
	- if (!isDiffractive) _hist_multiplicity_nsd->fill(N, weight);
	+ _hist_multiplicity_inel->fill(fs.particles().size(), weight);
	+ if (!isDiffractive) _hist_multiplicity_nsd->fill(fs.particles().size(), weight);
	}


	void finalize() {
	- scale(_hist_multiplicity_inel, 1.0/_sumWDiff);
	- scale(_hist_multiplicity_nsd, 1.0/_sumW );
	+ normalize(_hist_multiplicity_inel);
	+ normalize(_hist_multiplicity_nsd);
	}

	//@}


	private:

	- /// @name Weight counters
	- //@{
	- double _sumW, _sumWDiff;
	- //@}

	/// @name Histograms
	//@{
	Histo1DPtr _hist_multiplicity_inel;
	Histo1DPtr _hist_multiplicity_nsd;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(SFM_1984_S1178091);

	}
	diff --git a/src/Analyses/SLD_1996_S3398250.cc b/src/Analyses/SLD_1996_S3398250.cc
	--- a/src/Analyses/SLD_1996_S3398250.cc
	+++ b/src/Analyses/SLD_1996_S3398250.cc
	@@ -1,134 +1,134 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/Sphericity.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "Rivet/Projections/ParisiTensor.hh"
	#include "Rivet/Projections/Hemispheres.hh"
	#include "Rivet/Projections/InitialQuarks.hh"
	#include <cmath>

	namespace Rivet {


	/// @brief SLD multiplicities at mZ
	/// @author Peter Richardson
	class SLD_1996_S3398250 : public Analysis {
	public:

	/// Constructor
	SLD_1996_S3398250()
	: Analysis("SLD_1996_S3398250"),
	_weightLight(0.),_weightCharm(0.),_weightBottom(0.)
	{}

	/// @name Analysis methods
	//@{


	void init() {
	// Projections
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "CFS");
	- addProjection(InitialQuarks(), "IQF");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "CFS");
	+ declare(InitialQuarks(), "IQF");

	_h_bottom = bookHisto1D(1, 1, 1);
	_h_charm = bookHisto1D(2, 1, 1);
	_h_light = bookHisto1D(3, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();
	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	- const FinalState& cfs = applyProjection<FinalState>(event, "CFS");
	+ const FinalState& cfs = apply<FinalState>(event, "CFS");
	if (cfs.size() < 2) vetoEvent;


	int flavour = 0;
	- const InitialQuarks& iqf = applyProjection<InitialQuarks>(event, "IQF");
	+ const InitialQuarks& iqf = apply<InitialQuarks>(event, "IQF");

	// If we only have two quarks (qqbar), just take the flavour.
	// If we have more than two quarks, look for the highest energetic q-qbar pair.
	if (iqf.particles().size() == 2) {
	flavour = iqf.particles().front().abspid();
	}
	else {
	map<int, double> quarkmap;
	foreach (const Particle& p, iqf.particles()) {
	if (quarkmap[p.pid()] < p.E()) {
	quarkmap[p.pid()] = p.E();
	}
	}
	double maxenergy = 0.;
	for (int i = 1; i <= 5; ++i) {
	if (quarkmap[i]+quarkmap[-i] > maxenergy) {
	flavour = i;
	}
	}
	}
	const size_t numParticles = cfs.particles().size();
	switch (flavour) {
	case 1: case 2: case 3:
	_weightLight += weight;
	_h_light->fillBin(0, numParticles*weight);
	break;
	case 4:
	_weightCharm += weight;
	_h_charm->fillBin(0, numParticles*weight);
	break;
	case 5:
	_weightBottom += weight;
	_h_bottom->fillBin(0, numParticles*weight);
	break;
	}

	}


	void multiplicity_subtract(const Histo1DPtr first, const Histo1DPtr second, int a, int b, int c) {
	const double x = first->bin(0).xMid();
	const double ex = first->bin(0).xWidth()/2.;
	const double y = first->bin(0).area() - second->bin(0).area();
	const double ey = sqrt(sqr(first->bin(0).areaErr()) + sqr(second->bin(0).areaErr()));
	Scatter2DPtr scatter = bookScatter2D(a, b, c);
	scatter->addPoint(x, y, ex, ey);
	}


	void finalize() {
	if (_weightBottom != 0) scale(_h_bottom, 1./_weightBottom);
	if (_weightCharm != 0) scale(_h_charm, 1./_weightCharm );
	if (_weightLight != 0) scale(_h_light, 1./_weightLight );

	multiplicity_subtract(_h_charm, _h_light, 4, 1, 1);
	multiplicity_subtract(_h_bottom, _h_light, 5, 1, 1);
	}

	//@}


	private:


	/// @name Weights
	//@{
	double _weightLight;
	double _weightCharm;
	double _weightBottom;
	//@}

	Histo1DPtr _h_bottom;
	Histo1DPtr _h_charm;
	Histo1DPtr _h_light;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(SLD_1996_S3398250);

	}
	diff --git a/src/Analyses/SLD_1999_S3743934.cc b/src/Analyses/SLD_1999_S3743934.cc
	--- a/src/Analyses/SLD_1999_S3743934.cc
	+++ b/src/Analyses/SLD_1999_S3743934.cc
	@@ -1,642 +1,642 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/InitialQuarks.hh"
	#include "Rivet/Projections/Thrust.hh"

	namespace Rivet {


	/// @brief SLD flavour-dependent fragmentation paper
	/// @author Peter Richardson
	class SLD_1999_S3743934 : public Analysis {
	public:

	/// Constructor
	SLD_1999_S3743934()
	: Analysis("SLD_1999_S3743934"),
	_SumOfudsWeights(0.), _SumOfcWeights(0.),
	_SumOfbWeights(0.),
	_multPiPlus(4,0.),_multKPlus(4,0.),_multK0(4,0.),
	_multKStar0(4,0.),_multPhi(4,0.),
	_multProton(4,0.),_multLambda(4,0.)
	{ }


	/// @name Analysis methods
	//@{

	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 4 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed ncharged cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed ncharged cut");
	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);
	int flavour = 0;
	- const InitialQuarks& iqf = applyProjection<InitialQuarks>(e, "IQF");
	+ const InitialQuarks& iqf = apply<InitialQuarks>(e, "IQF");

	// If we only have two quarks (qqbar), just take the flavour.
	// If we have more than two quarks, look for the highest energetic q-qbar pair.
	/// @todo Can we make this based on hadron flavour instead?
	Particles quarks;
	if (iqf.particles().size() == 2) {
	flavour = iqf.particles().front().abspid();
	quarks = iqf.particles();
	} else {
	map<int, Particle > quarkmap;
	foreach (const Particle& p, iqf.particles()) {
	if (quarkmap.find(p.pid()) == quarkmap.end()) quarkmap[p.pid()] = p;
	else if (quarkmap[p.pid()].E() < p.E()) quarkmap[p.pid()] = p;
	}
	double maxenergy = 0.;
	for (int i = 1; i <= 5; ++i) {
	double energy(0.);
	if (quarkmap.find( i) != quarkmap.end())
	energy += quarkmap[ i].E();
	if (quarkmap.find(-i) != quarkmap.end())
	energy += quarkmap[-i].E();
	if (energy > maxenergy)
	flavour = i;
	}
	if (quarkmap.find(flavour) != quarkmap.end())
	quarks.push_back(quarkmap[flavour]);
	if (quarkmap.find(-flavour) != quarkmap.end())
	quarks.push_back(quarkmap[-flavour]);
	}
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_SumOfudsWeights += weight;
	break;
	case PID::CQUARK:
	_SumOfcWeights += weight;
	break;
	case PID::BQUARK:
	_SumOfbWeights += weight;
	break;
	}
	// thrust axis for projections
	- Vector3 axis = applyProjection<Thrust>(e, "Thrust").thrustAxis();
	+ Vector3 axis = apply<Thrust>(e, "Thrust").thrustAxis();
	double dot(0.);
	if (!quarks.empty()) {
	dot = quarks[0].p3().dot(axis);
	if (quarks[0].pid() < 0) dot *= -1;
	}

	foreach (const Particle& p, fs.particles()) {
	const double xp = p.p3().mod()/meanBeamMom;
	// if in quark or antiquark hemisphere
	bool quark = p.p3().dot(axis)*dot > 0.;
	_h_XpChargedN->fill(xp, weight);
	_temp_XpChargedN1->fill(xp, weight);
	_temp_XpChargedN2->fill(xp, weight);
	_temp_XpChargedN3->fill(xp, weight);
	int id = p.abspid();
	// charged pions
	if (id == PID::PIPLUS) {
	_h_XpPiPlusN->fill(xp, weight);
	_multPiPlus[0] += weight;
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_multPiPlus[1] += weight;
	_h_XpPiPlusLight->fill(xp, weight);
	if( ( quark && p.pid()>0 ) \|\| ( !quark && p.pid()<0 ))
	_h_RPiPlus->fill(xp, weight);
	else
	_h_RPiMinus->fill(xp, weight);
	break;
	case PID::CQUARK:
	_multPiPlus[2] += weight;
	_h_XpPiPlusCharm->fill(xp, weight);
	break;
	case PID::BQUARK:
	_multPiPlus[3] += weight;
	_h_XpPiPlusBottom->fill(xp, weight);
	break;
	}
	}
	else if (id == PID::KPLUS) {
	_h_XpKPlusN->fill(xp, weight);
	_multKPlus[0] += weight;
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_multKPlus[1] += weight;
	_temp_XpKPlusLight->fill(xp, weight);
	_h_XpKPlusLight->fill(xp, weight);
	if( ( quark && p.pid()>0 ) \|\| ( !quark && p.pid()<0 ))
	_h_RKPlus->fill(xp, weight);
	else
	_h_RKMinus->fill(xp, weight);
	break;
	break;
	case PID::CQUARK:
	_multKPlus[2] += weight;
	_h_XpKPlusCharm->fill(xp, weight);
	_temp_XpKPlusCharm->fill(xp, weight);
	break;
	case PID::BQUARK:
	_multKPlus[3] += weight;
	_h_XpKPlusBottom->fill(xp, weight);
	break;
	}
	}
	else if (id == PID::PROTON) {
	_h_XpProtonN->fill(xp, weight);
	_multProton[0] += weight;
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_multProton[1] += weight;
	_temp_XpProtonLight->fill(xp, weight);
	_h_XpProtonLight->fill(xp, weight);
	if( ( quark && p.pid()>0 ) \|\| ( !quark && p.pid()<0 ))
	_h_RProton->fill(xp, weight);
	else
	_h_RPBar ->fill(xp, weight);
	break;
	break;
	case PID::CQUARK:
	_multProton[2] += weight;
	_temp_XpProtonCharm->fill(xp, weight);
	_h_XpProtonCharm->fill(xp, weight);
	break;
	case PID::BQUARK:
	_multProton[3] += weight;
	_h_XpProtonBottom->fill(xp, weight);
	break;
	}
	}
	}

	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(e, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(e, "UFS");
	foreach (const Particle& p, ufs.particles()) {
	const double xp = p.p3().mod()/meanBeamMom;
	// if in quark or antiquark hemisphere
	bool quark = p.p3().dot(axis)*dot>0.;
	int id = p.abspid();
	if (id == PID::LAMBDA) {
	_multLambda[0] += weight;
	_h_XpLambdaN->fill(xp, weight);
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_multLambda[1] += weight;
	_h_XpLambdaLight->fill(xp, weight);
	if( ( quark && p.pid()>0 ) \|\| ( !quark && p.pid()<0 ))
	_h_RLambda->fill(xp, weight);
	else
	_h_RLBar ->fill(xp, weight);
	break;
	case PID::CQUARK:
	_multLambda[2] += weight;
	_h_XpLambdaCharm->fill(xp, weight);
	break;
	case PID::BQUARK:
	_multLambda[3] += weight;
	_h_XpLambdaBottom->fill(xp, weight);
	break;
	}
	}
	else if (id == 313) {
	_multKStar0[0] += weight;
	_h_XpKStar0N->fill(xp, weight);
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_multKStar0[1] += weight;
	_temp_XpKStar0Light->fill(xp, weight);
	_h_XpKStar0Light->fill(xp, weight);
	if ( ( quark && p.pid()>0 ) \|\| ( !quark && p.pid()<0 ))
	_h_RKS0 ->fill(xp, weight);
	else
	_h_RKSBar0->fill(xp, weight);
	break;
	break;
	case PID::CQUARK:
	_multKStar0[2] += weight;
	_temp_XpKStar0Charm->fill(xp, weight);
	_h_XpKStar0Charm->fill(xp, weight);
	break;
	case PID::BQUARK:
	_multKStar0[3] += weight;
	_h_XpKStar0Bottom->fill(xp, weight);
	break;
	}
	}
	else if (id == 333) {
	_multPhi[0] += weight;
	_h_XpPhiN->fill(xp, weight);
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_multPhi[1] += weight;
	_h_XpPhiLight->fill(xp, weight);
	break;
	case PID::CQUARK:
	_multPhi[2] += weight;
	_h_XpPhiCharm->fill(xp, weight);
	break;
	case PID::BQUARK:
	_multPhi[3] += weight;
	_h_XpPhiBottom->fill(xp, weight);
	break;
	}
	}
	else if (id == PID::K0S \|\| id == PID::K0L) {
	_multK0[0] += weight;
	_h_XpK0N->fill(xp, weight);
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_multK0[1] += weight;
	_h_XpK0Light->fill(xp, weight);
	break;
	case PID::CQUARK:
	_multK0[2] += weight;
	_h_XpK0Charm->fill(xp, weight);
	break;
	case PID::BQUARK:
	_multK0[3] += weight;
	_h_XpK0Bottom->fill(xp, weight);
	break;
	}
	}
	}
	}


	void init() {
	// Projections
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(UnstableFinalState(), "UFS");
	- addProjection(InitialQuarks(), "IQF");
	- addProjection(Thrust(FinalState()), "Thrust");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(UnstableFinalState(), "UFS");
	+ declare(InitialQuarks(), "IQF");
	+ declare(Thrust(FinalState()), "Thrust");

	_temp_XpChargedN1 = bookHisto1D("TMP/XpChargedN1", refData( 1, 1, 1));
	_temp_XpChargedN2 = bookHisto1D("TMP/XpChargedN2", refData( 2, 1, 1));
	_temp_XpChargedN3 = bookHisto1D("TMP/XpChargedN3", refData( 3, 1, 1));

	_h_XpPiPlusN = bookHisto1D( 1, 1, 2);
	_h_XpKPlusN = bookHisto1D( 2, 1, 2);
	_h_XpProtonN = bookHisto1D( 3, 1, 2);
	_h_XpChargedN = bookHisto1D( 4, 1, 1);
	_h_XpK0N = bookHisto1D( 5, 1, 1);
	_h_XpLambdaN = bookHisto1D( 7, 1, 1);
	_h_XpKStar0N = bookHisto1D( 8, 1, 1);
	_h_XpPhiN = bookHisto1D( 9, 1, 1);

	_h_XpPiPlusLight = bookHisto1D(10, 1, 1);
	_h_XpPiPlusCharm = bookHisto1D(10, 1, 2);
	_h_XpPiPlusBottom = bookHisto1D(10, 1, 3);
	_h_XpKPlusLight = bookHisto1D(12, 1, 1);
	_h_XpKPlusCharm = bookHisto1D(12, 1, 2);
	_h_XpKPlusBottom = bookHisto1D(12, 1, 3);
	_h_XpKStar0Light = bookHisto1D(14, 1, 1);
	_h_XpKStar0Charm = bookHisto1D(14, 1, 2);
	_h_XpKStar0Bottom = bookHisto1D(14, 1, 3);
	_h_XpProtonLight = bookHisto1D(16, 1, 1);
	_h_XpProtonCharm = bookHisto1D(16, 1, 2);
	_h_XpProtonBottom = bookHisto1D(16, 1, 3);
	_h_XpLambdaLight = bookHisto1D(18, 1, 1);
	_h_XpLambdaCharm = bookHisto1D(18, 1, 2);
	_h_XpLambdaBottom = bookHisto1D(18, 1, 3);
	_h_XpK0Light = bookHisto1D(20, 1, 1);
	_h_XpK0Charm = bookHisto1D(20, 1, 2);
	_h_XpK0Bottom = bookHisto1D(20, 1, 3);
	_h_XpPhiLight = bookHisto1D(22, 1, 1);
	_h_XpPhiCharm = bookHisto1D(22, 1, 2);
	_h_XpPhiBottom = bookHisto1D(22, 1, 3);

	_temp_XpKPlusCharm = bookHisto1D("TMP/XpKPlusCharm", refData(13, 1, 1));
	_temp_XpKPlusLight = bookHisto1D("TMP/XpKPlusLight", refData(13, 1, 1));
	_temp_XpKStar0Charm = bookHisto1D("TMP/XpKStar0Charm", refData(15, 1, 1));
	_temp_XpKStar0Light = bookHisto1D("TMP/XpKStar0Light", refData(15, 1, 1));
	_temp_XpProtonCharm = bookHisto1D("TMP/XpProtonCharm", refData(17, 1, 1));
	_temp_XpProtonLight = bookHisto1D("TMP/XpProtonLight", refData(17, 1, 1));

	_h_RPiPlus = bookHisto1D( 26, 1, 1);
	_h_RPiMinus = bookHisto1D( 26, 1, 2);
	_h_RKS0 = bookHisto1D( 28, 1, 1);
	_h_RKSBar0 = bookHisto1D( 28, 1, 2);
	_h_RKPlus = bookHisto1D( 30, 1, 1);
	_h_RKMinus = bookHisto1D( 30, 1, 2);
	_h_RProton = bookHisto1D( 32, 1, 1);
	_h_RPBar = bookHisto1D( 32, 1, 2);
	_h_RLambda = bookHisto1D( 34, 1, 1);
	_h_RLBar = bookHisto1D( 34, 1, 2);

	_s_Xp_PiPl_Ch = bookScatter2D(1, 1, 1);
	_s_Xp_KPl_Ch = bookScatter2D(2, 1, 1);
	_s_Xp_Pr_Ch = bookScatter2D(3, 1, 1);
	_s_Xp_PiPlCh_PiPlLi = bookScatter2D(11, 1, 1);
	_s_Xp_PiPlBo_PiPlLi = bookScatter2D(11, 1, 2);
	_s_Xp_KPlCh_KPlLi = bookScatter2D(13, 1, 1);
	_s_Xp_KPlBo_KPlLi = bookScatter2D(13, 1, 2);
	_s_Xp_KS0Ch_KS0Li = bookScatter2D(15, 1, 1);
	_s_Xp_KS0Bo_KS0Li = bookScatter2D(15, 1, 2);
	_s_Xp_PrCh_PrLi = bookScatter2D(17, 1, 1);
	_s_Xp_PrBo_PrLi = bookScatter2D(17, 1, 2);
	_s_Xp_LaCh_LaLi = bookScatter2D(19, 1, 1);
	_s_Xp_LaBo_LaLi = bookScatter2D(19, 1, 2);
	_s_Xp_K0Ch_K0Li = bookScatter2D(21, 1, 1);
	_s_Xp_K0Bo_K0Li = bookScatter2D(21, 1, 2);
	_s_Xp_PhiCh_PhiLi = bookScatter2D(23, 1, 1);
	_s_Xp_PhiBo_PhiLi = bookScatter2D(23, 1, 2);

	_s_PiM_PiP = bookScatter2D(27, 1, 1);
	_s_KSBar0_KS0 = bookScatter2D(29, 1, 1);
	_s_KM_KP = bookScatter2D(31, 1, 1);
	_s_Pr_PBar = bookScatter2D(33, 1, 1);
	_s_Lam_LBar = bookScatter2D(35, 1, 1);
	}


	/// Finalize
	void finalize() {
	// Get the ratio plots sorted out first
	divide(_h_XpPiPlusN, _temp_XpChargedN1, _s_Xp_PiPl_Ch);
	divide(_h_XpKPlusN, _temp_XpChargedN2, _s_Xp_KPl_Ch);
	divide(_h_XpProtonN, _temp_XpChargedN3, _s_Xp_Pr_Ch);
	divide(_h_XpPiPlusCharm, _h_XpPiPlusLight, _s_Xp_PiPlCh_PiPlLi);
	_s_Xp_PiPlCh_PiPlLi->scale(1.,_SumOfudsWeights/_SumOfcWeights);
	divide(_h_XpPiPlusBottom, _h_XpPiPlusLight, _s_Xp_PiPlBo_PiPlLi);
	_s_Xp_PiPlBo_PiPlLi->scale(1.,_SumOfudsWeights/_SumOfbWeights);
	divide(_temp_XpKPlusCharm , _temp_XpKPlusLight, _s_Xp_KPlCh_KPlLi);
	_s_Xp_KPlCh_KPlLi->scale(1.,_SumOfudsWeights/_SumOfcWeights);
	divide(_h_XpKPlusBottom, _h_XpKPlusLight, _s_Xp_KPlBo_KPlLi);
	_s_Xp_KPlBo_KPlLi->scale(1.,_SumOfudsWeights/_SumOfbWeights);
	divide(_temp_XpKStar0Charm, _temp_XpKStar0Light, _s_Xp_KS0Ch_KS0Li);
	_s_Xp_KS0Ch_KS0Li->scale(1.,_SumOfudsWeights/_SumOfcWeights);
	divide(_h_XpKStar0Bottom, _h_XpKStar0Light, _s_Xp_KS0Bo_KS0Li);
	_s_Xp_KS0Bo_KS0Li->scale(1.,_SumOfudsWeights/_SumOfbWeights);
	divide(_temp_XpProtonCharm, _temp_XpProtonLight, _s_Xp_PrCh_PrLi);
	_s_Xp_PrCh_PrLi->scale(1.,_SumOfudsWeights/_SumOfcWeights);
	divide(_h_XpProtonBottom, _h_XpProtonLight, _s_Xp_PrBo_PrLi);
	_s_Xp_PrBo_PrLi->scale(1.,_SumOfudsWeights/_SumOfbWeights);
	divide(_h_XpLambdaCharm, _h_XpLambdaLight, _s_Xp_LaCh_LaLi);
	_s_Xp_LaCh_LaLi->scale(1.,_SumOfudsWeights/_SumOfcWeights);
	divide(_h_XpLambdaBottom, _h_XpLambdaLight, _s_Xp_LaBo_LaLi);
	_s_Xp_LaBo_LaLi->scale(1.,_SumOfudsWeights/_SumOfbWeights);
	divide(_h_XpK0Charm, _h_XpK0Light, _s_Xp_K0Ch_K0Li);
	_s_Xp_K0Ch_K0Li->scale(1.,_SumOfudsWeights/_SumOfcWeights);
	divide(_h_XpK0Bottom, _h_XpK0Light, _s_Xp_K0Bo_K0Li);
	_s_Xp_K0Bo_K0Li->scale(1.,_SumOfudsWeights/_SumOfbWeights);
	divide(_h_XpPhiCharm, _h_XpPhiLight, _s_Xp_PhiCh_PhiLi);
	_s_Xp_PhiCh_PhiLi->scale(1.,_SumOfudsWeights/_SumOfcWeights);
	divide(_h_XpPhiBottom, _h_XpPhiLight, _s_Xp_PhiBo_PhiLi);
	_s_Xp_PhiBo_PhiLi->scale(1.,_SumOfudsWeights/_SumOfbWeights);

	// Then the leading particles
	divide(_h_RPiMinus - _h_RPiPlus, _h_RPiMinus + _h_RPiPlus, _s_PiM_PiP);
	divide(_h_RKSBar0 - _h_RKS0, _h_RKSBar0 + _h_RKS0, _s_KSBar0_KS0);
	divide(_h_RKMinus - _h_RKPlus, _h_RKMinus + _h_RKPlus, _s_KM_KP);
	divide(_h_RProton - _h_RPBar, _h_RProton + _h_RPBar, _s_Pr_PBar);
	divide(_h_RLambda - _h_RLBar, _h_RLambda + _h_RLBar, _s_Lam_LBar);

	// Then the rest
	scale(_h_XpPiPlusN, 1/sumOfWeights());
	scale(_h_XpKPlusN, 1/sumOfWeights());
	scale(_h_XpProtonN, 1/sumOfWeights());
	scale(_h_XpChargedN, 1/sumOfWeights());
	scale(_h_XpK0N, 1/sumOfWeights());
	scale(_h_XpLambdaN, 1/sumOfWeights());
	scale(_h_XpKStar0N, 1/sumOfWeights());
	scale(_h_XpPhiN, 1/sumOfWeights());
	scale(_h_XpPiPlusLight, 1/_SumOfudsWeights);
	scale(_h_XpPiPlusCharm, 1/_SumOfcWeights);
	scale(_h_XpPiPlusBottom, 1/_SumOfbWeights);
	scale(_h_XpKPlusLight, 1/_SumOfudsWeights);
	scale(_h_XpKPlusCharm, 1/_SumOfcWeights);
	scale(_h_XpKPlusBottom, 1/_SumOfbWeights);
	scale(_h_XpKStar0Light, 1/_SumOfudsWeights);
	scale(_h_XpKStar0Charm, 1/_SumOfcWeights);
	scale(_h_XpKStar0Bottom, 1/_SumOfbWeights);
	scale(_h_XpProtonLight, 1/_SumOfudsWeights);
	scale(_h_XpProtonCharm, 1/_SumOfcWeights);
	scale(_h_XpProtonBottom, 1/_SumOfbWeights);
	scale(_h_XpLambdaLight, 1/_SumOfudsWeights);
	scale(_h_XpLambdaCharm, 1/_SumOfcWeights);
	scale(_h_XpLambdaBottom, 1/_SumOfbWeights);
	scale(_h_XpK0Light, 1/_SumOfudsWeights);
	scale(_h_XpK0Charm, 1/_SumOfcWeights);
	scale(_h_XpK0Bottom, 1/_SumOfbWeights);
	scale(_h_XpPhiLight, 1/_SumOfudsWeights);
	scale(_h_XpPhiCharm , 1/_SumOfcWeights);
	scale(_h_XpPhiBottom, 1/_SumOfbWeights);
	scale(_h_RPiPlus, 1/_SumOfudsWeights);
	scale(_h_RPiMinus, 1/_SumOfudsWeights);
	scale(_h_RKS0, 1/_SumOfudsWeights);
	scale(_h_RKSBar0, 1/_SumOfudsWeights);
	scale(_h_RKPlus, 1/_SumOfudsWeights);
	scale(_h_RKMinus, 1/_SumOfudsWeights);
	scale(_h_RProton, 1/_SumOfudsWeights);
	scale(_h_RPBar, 1/_SumOfudsWeights);
	scale(_h_RLambda, 1/_SumOfudsWeights);
	scale(_h_RLBar, 1/_SumOfudsWeights);

	// Multiplicities
	double avgNumPartsAll, avgNumPartsLight,avgNumPartsCharm, avgNumPartsBottom;
	// pi+/-
	// all
	avgNumPartsAll = _multPiPlus[0]/sumOfWeights();
	bookScatter2D(24, 1, 1, true)->point(0).setY(avgNumPartsAll);
	// light
	avgNumPartsLight = _multPiPlus[1]/_SumOfudsWeights;
	bookScatter2D(24, 1, 2, true)->point(0).setY(avgNumPartsLight);
	// charm
	avgNumPartsCharm = _multPiPlus[2]/_SumOfcWeights;
	bookScatter2D(24, 1, 3, true)->point(0).setY(avgNumPartsCharm);
	// bottom
	avgNumPartsBottom = _multPiPlus[3]/_SumOfbWeights;
	bookScatter2D(24, 1, 4, true)->point(0).setY(avgNumPartsBottom);
	// charm-light
	bookScatter2D(25, 1, 1, true)->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
	// bottom-light
	bookScatter2D(25, 1, 2, true)->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
	// K+/-
	// all
	avgNumPartsAll = _multKPlus[0]/sumOfWeights();
	bookScatter2D(24, 2, 1, true)->point(0).setY(avgNumPartsAll);
	// light
	avgNumPartsLight = _multKPlus[1]/_SumOfudsWeights;
	bookScatter2D(24, 2, 2, true)->point(0).setY(avgNumPartsLight);
	// charm
	avgNumPartsCharm = _multKPlus[2]/_SumOfcWeights;
	bookScatter2D(24, 2, 3, true)->point(0).setY(avgNumPartsCharm);
	// bottom
	avgNumPartsBottom = _multKPlus[3]/_SumOfbWeights;
	bookScatter2D(24, 2, 4, true)->point(0).setY(avgNumPartsBottom);
	// charm-light
	bookScatter2D(25, 2, 1, true)->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
	// bottom-light
	bookScatter2D(25, 2, 2, true)->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
	// K0
	// all
	avgNumPartsAll = _multK0[0]/sumOfWeights();
	bookScatter2D(24, 3, 1, true)->point(0).setY(avgNumPartsAll);
	// light
	avgNumPartsLight = _multK0[1]/_SumOfudsWeights;
	bookScatter2D(24, 3, 2, true)->point(0).setY(avgNumPartsLight);
	// charm
	avgNumPartsCharm = _multK0[2]/_SumOfcWeights;
	bookScatter2D(24, 3, 3, true)->point(0).setY(avgNumPartsCharm);
	// bottom
	avgNumPartsBottom = _multK0[3]/_SumOfbWeights;
	bookScatter2D(24, 3, 4, true)->point(0).setY(avgNumPartsBottom);
	// charm-light
	bookScatter2D(25, 3, 1, true)->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
	// bottom-light
	bookScatter2D(25, 3, 2, true)->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
	// K*0
	// all
	avgNumPartsAll = _multKStar0[0]/sumOfWeights();
	bookScatter2D(24, 4, 1, true)->point(0).setY(avgNumPartsAll);
	// light
	avgNumPartsLight = _multKStar0[1]/_SumOfudsWeights;
	bookScatter2D(24, 4, 2, true)->point(0).setY(avgNumPartsLight);
	// charm
	avgNumPartsCharm = _multKStar0[2]/_SumOfcWeights;
	bookScatter2D(24, 4, 3, true)->point(0).setY(avgNumPartsCharm);
	// bottom
	avgNumPartsBottom = _multKStar0[3]/_SumOfbWeights;
	bookScatter2D(24, 4, 4, true)->point(0).setY(avgNumPartsBottom);
	// charm-light
	bookScatter2D(25, 4, 1, true)->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
	// bottom-light
	bookScatter2D(25, 4, 2, true)->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
	// phi
	// all
	avgNumPartsAll = _multPhi[0]/sumOfWeights();
	bookScatter2D(24, 5, 1, true)->point(0).setY(avgNumPartsAll);
	// light
	avgNumPartsLight = _multPhi[1]/_SumOfudsWeights;
	bookScatter2D(24, 5, 2, true)->point(0).setY(avgNumPartsLight);
	// charm
	avgNumPartsCharm = _multPhi[2]/_SumOfcWeights;
	bookScatter2D(24, 5, 3, true)->point(0).setY(avgNumPartsCharm);
	// bottom
	avgNumPartsBottom = _multPhi[3]/_SumOfbWeights;
	bookScatter2D(24, 5, 4, true)->point(0).setY(avgNumPartsBottom);
	// charm-light
	bookScatter2D(25, 5, 1, true)->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
	// bottom-light
	bookScatter2D(25, 5, 2, true)->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
	// p
	// all
	avgNumPartsAll = _multProton[0]/sumOfWeights();
	bookScatter2D(24, 6, 1, true)->point(0).setY(avgNumPartsAll);
	// light
	avgNumPartsLight = _multProton[1]/_SumOfudsWeights;
	bookScatter2D(24, 6, 2, true)->point(0).setY(avgNumPartsLight);
	// charm
	avgNumPartsCharm = _multProton[2]/_SumOfcWeights;
	bookScatter2D(24, 6, 3, true)->point(0).setY(avgNumPartsCharm);
	// bottom
	avgNumPartsBottom = _multProton[3]/_SumOfbWeights;
	bookScatter2D(24, 6, 4, true)->point(0).setY(avgNumPartsBottom);
	// charm-light
	bookScatter2D(25, 6, 1, true)->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
	// bottom-light
	bookScatter2D(25, 6, 2, true)->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
	// Lambda
	// all
	avgNumPartsAll = _multLambda[0]/sumOfWeights();
	bookScatter2D(24, 7, 1, true)->point(0).setY(avgNumPartsAll);
	// light
	avgNumPartsLight = _multLambda[1]/_SumOfudsWeights;
	bookScatter2D(24, 7, 2, true)->point(0).setY(avgNumPartsLight);
	// charm
	avgNumPartsCharm = _multLambda[2]/_SumOfcWeights;
	bookScatter2D(24, 7, 3, true)->point(0).setY(avgNumPartsCharm);
	// bottom
	avgNumPartsBottom = _multLambda[3]/_SumOfbWeights;
	bookScatter2D(24, 7, 4, true)->point(0).setY(avgNumPartsBottom);
	// charm-light
	bookScatter2D(25, 7, 1, true)->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
	// bottom-light
	bookScatter2D(25, 7, 2, true)->point(0).setY(avgNumPartsBottom - avgNumPartsLight);
	}

	//@}


	private:

	/// Store the weighted sums of numbers of charged / charged+neutral
	/// particles. Used to calculate average number of particles for the
	/// inclusive single particle distributions' normalisations.
	double _SumOfudsWeights, _SumOfcWeights, _SumOfbWeights;
	vector<double> _multPiPlus, _multKPlus, _multK0,
	_multKStar0, _multPhi, _multProton, _multLambda;

	Histo1DPtr _h_XpPiPlusSig, _h_XpPiPlusN;
	Histo1DPtr _h_XpKPlusSig, _h_XpKPlusN;
	Histo1DPtr _h_XpProtonSig, _h_XpProtonN;
	Histo1DPtr _h_XpChargedN;
	Histo1DPtr _h_XpK0N, _h_XpLambdaN;
	Histo1DPtr _h_XpKStar0N, _h_XpPhiN;
	Histo1DPtr _h_XpPiPlusLight, _h_XpPiPlusCharm, _h_XpPiPlusBottom;
	Histo1DPtr _h_XpKPlusLight, _h_XpKPlusCharm, _h_XpKPlusBottom;
	Histo1DPtr _h_XpKStar0Light, _h_XpKStar0Charm, _h_XpKStar0Bottom;
	Histo1DPtr _h_XpProtonLight, _h_XpProtonCharm, _h_XpProtonBottom;
	Histo1DPtr _h_XpLambdaLight, _h_XpLambdaCharm, _h_XpLambdaBottom;
	Histo1DPtr _h_XpK0Light, _h_XpK0Charm, _h_XpK0Bottom;
	Histo1DPtr _h_XpPhiLight, _h_XpPhiCharm, _h_XpPhiBottom;

	Histo1DPtr _temp_XpChargedN1, _temp_XpChargedN2, _temp_XpChargedN3;
	Histo1DPtr _temp_XpKPlusCharm , _temp_XpKPlusLight;
	Histo1DPtr _temp_XpKStar0Charm, _temp_XpKStar0Light;
	Histo1DPtr _temp_XpProtonCharm, _temp_XpProtonLight;

	Histo1DPtr _h_RPiPlus, _h_RPiMinus;
	Histo1DPtr _h_RKS0, _h_RKSBar0;
	Histo1DPtr _h_RKPlus, _h_RKMinus;
	Histo1DPtr _h_RProton, _h_RPBar;
	Histo1DPtr _h_RLambda, _h_RLBar;

	Scatter2DPtr _s_Xp_PiPl_Ch, _s_Xp_KPl_Ch, _s_Xp_Pr_Ch;
	Scatter2DPtr _s_Xp_PiPlCh_PiPlLi, _s_Xp_PiPlBo_PiPlLi;
	Scatter2DPtr _s_Xp_KPlCh_KPlLi, _s_Xp_KPlBo_KPlLi;
	Scatter2DPtr _s_Xp_KS0Ch_KS0Li, _s_Xp_KS0Bo_KS0Li;
	Scatter2DPtr _s_Xp_PrCh_PrLi, _s_Xp_PrBo_PrLi;
	Scatter2DPtr _s_Xp_LaCh_LaLi, _s_Xp_LaBo_LaLi;
	Scatter2DPtr _s_Xp_K0Ch_K0Li, _s_Xp_K0Bo_K0Li;
	Scatter2DPtr _s_Xp_PhiCh_PhiLi, _s_Xp_PhiBo_PhiLi;

	Scatter2DPtr _s_PiM_PiP, _s_KSBar0_KS0, _s_KM_KP, _s_Pr_PBar, _s_Lam_LBar;

	//@}

	};

	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(SLD_1999_S3743934);

	}
	diff --git a/src/Analyses/SLD_2002_S4869273.cc b/src/Analyses/SLD_2002_S4869273.cc
	--- a/src/Analyses/SLD_2002_S4869273.cc
	+++ b/src/Analyses/SLD_2002_S4869273.cc
	@@ -1,107 +1,107 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"


	/// @todo Use inline PID functions instead
	#define IS_PARTON_PDGID(id) ( abs(id) <= 100 && abs(id) != 22 && (abs(id) < 11 \|\| abs(id) > 18) )
	#define IS_BHADRON_PDGID(id) ( ((abs(id)/100)%10 == 5) \|\| (abs(id) >= 5000 && abs(id) <= 5999) )

	namespace Rivet {


	/// @brief SLD b-fragmentation measurement
	/// @author Peter Richardson
	class SLD_2002_S4869273 : public Analysis {
	public:

	/// Constructor
	SLD_2002_S4869273()
	: Analysis("SLD_2002_S4869273")
	{
	}


	/// @name Analysis methods
	//@{

	/// Book projections and histograms
	void init() {
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");

	_histXbweak = bookHisto1D(1, 1, 1);
	}


	void analyze(const Event& e) {
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed ncharged cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed ncharged cut");

	// Get event weight for histo filling
	const double weight = e.weight();

	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);


	foreach (const GenParticle* p, particles(e.genEvent())) {
	const GenVertex* dv = p->end_vertex();
	if (IS_BHADRON_PDGID(p->pdg_id())) {
	const double xp = p->momentum().e()/meanBeamMom;

	// If the B-hadron has no B-hadron as a child, it decayed weakly:
	if (dv) {
	bool is_weak = true;
	for (GenVertex::particles_out_const_iterator pp = dv->particles_out_const_begin() ;
	pp != dv->particles_out_const_end() ; ++pp) {
	if (IS_BHADRON_PDGID((*pp)->pdg_id())) {
	is_weak = false;
	}
	}
	if (is_weak) {
	_histXbweak->fill(xp, weight);
	}
	}

	}
	}
	}


	// Finalize
	void finalize() {
	normalize(_histXbweak);
	}


	private:

	/// Store the weighted sums of numbers of charged / charged+neutral
	/// particles - used to calculate average number of particles for the
	/// inclusive single particle distributions' normalisations.

	Histo1DPtr _histXbweak;

	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(SLD_2002_S4869273);

	}
	diff --git a/src/Analyses/SLD_2004_S5693039.cc b/src/Analyses/SLD_2004_S5693039.cc
	--- a/src/Analyses/SLD_2004_S5693039.cc
	+++ b/src/Analyses/SLD_2004_S5693039.cc
	@@ -1,363 +1,363 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/InitialQuarks.hh"
	#include "Rivet/Projections/Thrust.hh"

	namespace Rivet {


	/// @brief SLD flavour-dependent fragmentation paper
	/// @author Peter Richardson
	class SLD_2004_S5693039 : public Analysis {
	public:

	/// Constructor
	SLD_2004_S5693039() : Analysis("SLD_2004_S5693039"),
	_weightedTotalChargedPartNumLight(0.),
	_weightedTotalChargedPartNumCharm(0.),
	_weightedTotalChargedPartNumBottom(0.),
	_weightLight(0.),_weightCharm(0.),_weightBottom(0.)
	{}

	/// @name Analysis methods
	//@{

	void analyze(const Event& e) {
	// First, veto on leptonic events by requiring at least 2 charged FS particles
	- const FinalState& fs = applyProjection<FinalState>(e, "FS");
	+ const FinalState& fs = apply<FinalState>(e, "FS");
	const size_t numParticles = fs.particles().size();

	// Even if we only generate hadronic events, we still need a cut on numCharged >= 2.
	if (numParticles < 2) {
	MSG_DEBUG("Failed ncharged cut");
	vetoEvent;
	}
	MSG_DEBUG("Passed ncharged cut");
	// Get event weight for histo filling
	const double weight = e.weight();
	// Get beams and average beam momentum
	- const ParticlePair& beams = applyProjection<Beam>(e, "Beams").beams();
	+ const ParticlePair& beams = apply<Beam>(e, "Beams").beams();
	const double meanBeamMom = ( beams.first.p3().mod() +
	beams.second.p3().mod() ) / 2.0;
	MSG_DEBUG("Avg beam momentum = " << meanBeamMom);
	int flavour = 0;
	- const InitialQuarks& iqf = applyProjection<InitialQuarks>(e, "IQF");
	+ const InitialQuarks& iqf = apply<InitialQuarks>(e, "IQF");

	// If we only have two quarks (qqbar), just take the flavour.
	// If we have more than two quarks, look for the highest energetic q-qbar pair.
	Particles quarks;
	if (iqf.particles().size() == 2) {
	flavour = iqf.particles().front().abspid();
	quarks = iqf.particles();
	}
	else {
	map<int, Particle > quarkmap;
	foreach (const Particle& p, iqf.particles()) {
	if (quarkmap.find(p.pid())==quarkmap.end())
	quarkmap[p.pid()] = p;
	else if (quarkmap[p.pid()].E() < p.E())
	quarkmap[p.pid()] = p;
	}
	double maxenergy = 0.;
	for (int i = 1; i <= 5; ++i) {
	double energy(0.);
	if(quarkmap.find( i)!=quarkmap.end())
	energy += quarkmap[ i].E();
	if(quarkmap.find(-i)!=quarkmap.end())
	energy += quarkmap[-i].E();
	if (energy > maxenergy) flavour = i;
	}
	if(quarkmap.find( flavour)!=quarkmap.end())
	quarks.push_back(quarkmap[ flavour]);
	if(quarkmap.find(-flavour)!=quarkmap.end())
	quarks.push_back(quarkmap[-flavour]);
	}

	// total multiplicities
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_weightLight += weight;
	_weightedTotalChargedPartNumLight += numParticles * weight;
	break;
	case PID::CQUARK:
	_weightCharm += weight;
	_weightedTotalChargedPartNumCharm += numParticles * weight;
	break;
	case PID::BQUARK:
	_weightBottom += weight;
	_weightedTotalChargedPartNumBottom += numParticles * weight;
	break;
	}
	// thrust axis for projections
	- Vector3 axis = applyProjection<Thrust>(e, "Thrust").thrustAxis();
	+ Vector3 axis = apply<Thrust>(e, "Thrust").thrustAxis();
	double dot(0.);
	if(!quarks.empty()) {
	dot = quarks[0].p3().dot(axis);
	if(quarks[0].pid()<0) dot *= -1.;
	}
	// spectra and individual multiplicities
	foreach (const Particle& p, fs.particles()) {
	double pcm = p.p3().mod();
	const double xp = pcm/meanBeamMom;

	// if in quark or antiquark hemisphere
	bool quark = p.p3().dot(axis)*dot>0.;

	_h_PCharged ->fill(pcm , weight);
	// all charged
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_h_XpChargedL->fill(xp, weight);
	break;
	case PID::CQUARK:
	_h_XpChargedC->fill(xp, weight);
	break;
	case PID::BQUARK:
	_h_XpChargedB->fill(xp, weight);
	break;
	}

	int id = p.abspid();
	// charged pions
	if (id == PID::PIPLUS) {
	_h_XpPiPlus->fill(xp, weight);
	_h_XpPiPlusTotal->fill(xp, weight);
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_h_XpPiPlusL->fill(xp, weight);
	_h_NPiPlusL->fill(sqrtS(), weight);
	if( ( quark && p.pid()>0 ) \|\| ( !quark && p.pid()<0 ))
	_h_RPiPlus->fill(xp, weight);
	else
	_h_RPiMinus->fill(xp, weight);
	break;
	case PID::CQUARK:
	_h_XpPiPlusC->fill(xp, weight);
	_h_NPiPlusC->fill(sqrtS(), weight);
	break;
	case PID::BQUARK:
	_h_XpPiPlusB->fill(xp, weight);
	_h_NPiPlusB->fill(sqrtS(), weight);
	break;
	}
	}
	else if (id == PID::KPLUS) {
	_h_XpKPlus->fill(xp, weight);
	_h_XpKPlusTotal->fill(xp, weight);
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_h_XpKPlusL->fill(xp, weight);
	_h_NKPlusL->fill(sqrtS(), weight);
	if( ( quark && p.pid()>0 ) \|\| ( !quark && p.pid()<0 ))
	_h_RKPlus->fill(xp, weight);
	else
	_h_RKMinus->fill(xp, weight);
	break;
	case PID::CQUARK:
	_h_XpKPlusC->fill(xp, weight);
	_h_NKPlusC->fill(sqrtS(), weight);
	break;
	case PID::BQUARK:
	_h_XpKPlusB->fill(xp, weight);
	_h_NKPlusB->fill(sqrtS(), weight);
	break;
	}
	}
	else if (id == PID::PROTON) {
	_h_XpProton->fill(xp, weight);
	_h_XpProtonTotal->fill(xp, weight);
	switch (flavour) {
	case PID::DQUARK:
	case PID::UQUARK:
	case PID::SQUARK:
	_h_XpProtonL->fill(xp, weight);
	_h_NProtonL->fill(sqrtS(), weight);
	if( ( quark && p.pid()>0 ) \|\| ( !quark && p.pid()<0 ))
	_h_RProton->fill(xp, weight);
	else
	_h_RPBar ->fill(xp, weight);
	break;
	case PID::CQUARK:
	_h_XpProtonC->fill(xp, weight);
	_h_NProtonC->fill(sqrtS(), weight);
	break;
	case PID::BQUARK:
	_h_XpProtonB->fill(xp, weight);
	_h_NProtonB->fill(sqrtS(), weight);
	break;
	}
	}
	}
	}


	void init() {
	// Projections
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(), "FS");
	- addProjection(InitialQuarks(), "IQF");
	- addProjection(Thrust(FinalState()), "Thrust");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(), "FS");
	+ declare(InitialQuarks(), "IQF");
	+ declare(Thrust(FinalState()), "Thrust");

	// Book histograms
	_h_PCharged = bookHisto1D( 1, 1, 1);
	_h_XpPiPlus = bookHisto1D( 2, 1, 2);
	_h_XpKPlus = bookHisto1D( 3, 1, 2);
	_h_XpProton = bookHisto1D( 4, 1, 2);
	_h_XpPiPlusTotal = bookHisto1D( 2, 2, 2);
	_h_XpKPlusTotal = bookHisto1D( 3, 2, 2);
	_h_XpProtonTotal = bookHisto1D( 4, 2, 2);
	_h_XpPiPlusL = bookHisto1D( 5, 1, 1);
	_h_XpPiPlusC = bookHisto1D( 5, 1, 2);
	_h_XpPiPlusB = bookHisto1D( 5, 1, 3);
	_h_XpKPlusL = bookHisto1D( 6, 1, 1);
	_h_XpKPlusC = bookHisto1D( 6, 1, 2);
	_h_XpKPlusB = bookHisto1D( 6, 1, 3);
	_h_XpProtonL = bookHisto1D( 7, 1, 1);
	_h_XpProtonC = bookHisto1D( 7, 1, 2);
	_h_XpProtonB = bookHisto1D( 7, 1, 3);
	_h_XpChargedL = bookHisto1D( 8, 1, 1);
	_h_XpChargedC = bookHisto1D( 8, 1, 2);
	_h_XpChargedB = bookHisto1D( 8, 1, 3);

	_h_NPiPlusL = bookHisto1D( 5, 2, 1);
	_h_NPiPlusC = bookHisto1D( 5, 2, 2);
	_h_NPiPlusB = bookHisto1D( 5, 2, 3);
	_h_NKPlusL = bookHisto1D( 6, 2, 1);
	_h_NKPlusC = bookHisto1D( 6, 2, 2);
	_h_NKPlusB = bookHisto1D( 6, 2, 3);
	_h_NProtonL = bookHisto1D( 7, 2, 1);
	_h_NProtonC = bookHisto1D( 7, 2, 2);
	_h_NProtonB = bookHisto1D( 7, 2, 3);

	_h_RPiPlus = bookHisto1D( 9, 1, 1);
	_h_RPiMinus = bookHisto1D( 9, 1, 2);
	_h_RKPlus = bookHisto1D(10, 1, 1);
	_h_RKMinus = bookHisto1D(10, 1, 2);
	_h_RProton = bookHisto1D(11, 1, 1);
	_h_RPBar = bookHisto1D(11, 1, 2);

	// Ratios: used as target of divide() later
	_s_PiM_PiP = bookScatter2D(9, 1, 3);
	_s_KM_KP = bookScatter2D(10, 1, 3);
	_s_Pr_PBar = bookScatter2D(11, 1, 3);

	}


	/// Finalize
	void finalize() {

	// Multiplicities
	/// @todo Include errors
	const double avgNumPartsLight = _weightedTotalChargedPartNumLight / _weightLight;
	const double avgNumPartsCharm = _weightedTotalChargedPartNumCharm / _weightCharm;
	const double avgNumPartsBottom = _weightedTotalChargedPartNumBottom / _weightBottom;
	bookScatter2D(8, 2, 1, true)->point(0).setY(avgNumPartsLight);
	bookScatter2D(8, 2, 2, true)->point(0).setY(avgNumPartsCharm);
	bookScatter2D(8, 2, 3, true)->point(0).setY(avgNumPartsBottom);
	bookScatter2D(8, 3, 2, true)->point(0).setY(avgNumPartsCharm - avgNumPartsLight);
	bookScatter2D(8, 3, 3, true)->point(0).setY(avgNumPartsBottom - avgNumPartsLight);

	// Do divisions
	divide(_h_RPiMinus - _h_RPiPlus, _h_RPiMinus + _h_RPiPlus, _s_PiM_PiP);
	divide(_h_RKMinus - _h_RKPlus, _h_RKMinus + _h_RKPlus, _s_KM_KP);
	divide(_h_RProton - _h_RPBar, _h_RProton + _h_RPBar, _s_Pr_PBar);

	// Scale histograms
	scale(_h_PCharged, 1./sumOfWeights());
	scale(_h_XpPiPlus, 1./sumOfWeights());
	scale(_h_XpKPlus, 1./sumOfWeights());
	scale(_h_XpProton, 1./sumOfWeights());
	scale(_h_XpPiPlusTotal, 1./sumOfWeights());
	scale(_h_XpKPlusTotal, 1./sumOfWeights());
	scale(_h_XpProtonTotal, 1./sumOfWeights());
	scale(_h_XpPiPlusL, 1./_weightLight);
	scale(_h_XpPiPlusC, 1./_weightCharm);
	scale(_h_XpPiPlusB, 1./_weightBottom);
	scale(_h_XpKPlusL, 1./_weightLight);
	scale(_h_XpKPlusC, 1./_weightCharm);
	scale(_h_XpKPlusB, 1./_weightBottom);
	scale(_h_XpProtonL, 1./_weightLight);
	scale(_h_XpProtonC, 1./_weightCharm);
	scale(_h_XpProtonB, 1./_weightBottom);

	scale(_h_XpChargedL, 1./_weightLight);
	scale(_h_XpChargedC, 1./_weightCharm);
	scale(_h_XpChargedB, 1./_weightBottom);

	scale(_h_NPiPlusL, 1./_weightLight);
	scale(_h_NPiPlusC, 1./_weightCharm);
	scale(_h_NPiPlusB, 1./_weightBottom);
	scale(_h_NKPlusL, 1./_weightLight);
	scale(_h_NKPlusC, 1./_weightCharm);
	scale(_h_NKPlusB, 1./_weightBottom);
	scale(_h_NProtonL, 1./_weightLight);
	scale(_h_NProtonC, 1./_weightCharm);
	scale(_h_NProtonB, 1./_weightBottom);

	// Paper suggests this should be 0.5/weight but it has to be 1.0 to get normalisations right...
	scale(_h_RPiPlus, 1./_weightLight);
	scale(_h_RPiMinus, 1./_weightLight);
	scale(_h_RKPlus, 1./_weightLight);
	scale(_h_RKMinus, 1./_weightLight);
	scale(_h_RProton, 1./_weightLight);
	scale(_h_RPBar, 1./_weightLight);

	// convert ratio to %
	_s_PiM_PiP->scale(1.,100.);
	_s_KM_KP ->scale(1.,100.);
	_s_Pr_PBar->scale(1.,100.);
	}

	//@}


	private:

	/// @name Multiplicities
	//@{
	double _weightedTotalChargedPartNumLight;
	double _weightedTotalChargedPartNumCharm;
	double _weightedTotalChargedPartNumBottom;
	//@}

	/// @name Weights
	//@{
	double _weightLight, _weightCharm, _weightBottom;
	//@}

	// Histograms
	//@{
	Histo1DPtr _h_PCharged;
	Histo1DPtr _h_XpPiPlus, _h_XpKPlus, _h_XpProton;
	Histo1DPtr _h_XpPiPlusTotal, _h_XpKPlusTotal, _h_XpProtonTotal;
	Histo1DPtr _h_XpPiPlusL, _h_XpPiPlusC, _h_XpPiPlusB;
	Histo1DPtr _h_XpKPlusL, _h_XpKPlusC, _h_XpKPlusB;
	Histo1DPtr _h_XpProtonL, _h_XpProtonC, _h_XpProtonB;
	Histo1DPtr _h_XpChargedL, _h_XpChargedC, _h_XpChargedB;
	Histo1DPtr _h_NPiPlusL, _h_NPiPlusC, _h_NPiPlusB;
	Histo1DPtr _h_NKPlusL, _h_NKPlusC, _h_NKPlusB;
	Histo1DPtr _h_NProtonL, _h_NProtonC, _h_NProtonB;
	Histo1DPtr _h_RPiPlus, _h_RPiMinus, _h_RKPlus;
	Histo1DPtr _h_RKMinus, _h_RProton, _h_RPBar;
	Scatter2DPtr _s_PiM_PiP, _s_KM_KP, _s_Pr_PBar;
	//@}

	};


	// Hook for the plugin system
	DECLARE_RIVET_PLUGIN(SLD_2004_S5693039);

	}
	diff --git a/src/Analyses/STAR_2006_S6500200.cc b/src/Analyses/STAR_2006_S6500200.cc
	--- a/src/Analyses/STAR_2006_S6500200.cc
	+++ b/src/Analyses/STAR_2006_S6500200.cc
	@@ -1,108 +1,108 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {


	/// @brief STAR identified hadron spectra in pp at 200 GeV
	class STAR_2006_S6500200 : public Analysis {
	public:

	/// Constructor
	STAR_2006_S6500200()
	: Analysis("STAR_2006_S6500200"),
	_sumWeightSelected(0.0)
	{ }


	/// Book projections and histograms
	void init() {
	ChargedFinalState bbc1(-5.0,-3.3, 0.0*GeV); // beam-beam-counter trigger
	ChargedFinalState bbc2( 3.3, 5.0, 0.0*GeV); // beam-beam-counter trigger
	- addProjection(bbc1, "BBC1");
	- addProjection(bbc2, "BBC2");
	+ declare(bbc1, "BBC1");
	+ declare(bbc2, "BBC2");

	IdentifiedFinalState pionfs(Cuts::abseta < 2.5 && Cuts::pT > 0.3*GeV);
	IdentifiedFinalState protonfs(Cuts::abseta < 2.5 && Cuts::pT > 0.4*GeV);
	pionfs.acceptIdPair(PID::PIPLUS);
	protonfs.acceptIdPair(PID::PROTON);
	- addProjection(pionfs, "PionFS");
	- addProjection(protonfs, "ProtonFS");
	+ declare(pionfs, "PionFS");
	+ declare(protonfs, "ProtonFS");

	_h_pT_piplus = bookHisto1D(1, 1, 1); // full range pion binning
	_h_pT_piminus = bookHisto1D(1, 2, 1); // full range pion binning
	_tmp_pT_piplus = bookHisto1D("TMP/pT_piplus", refData(2, 3, 1)); // pi histo compatible with more restricted proton binning
	_tmp_pT_piminus = bookHisto1D("TMP/pT_piminus", refData(2, 4, 1)); // pi histo compatible with more restricted proton binning
	_h_pT_proton = bookHisto1D(1, 3, 1);
	_h_pT_antiproton = bookHisto1D(1, 4, 1);

	_s_piminus_piplus = bookScatter2D(2, 1, 1);
	_s_antipr_pr = bookScatter2D(2, 2, 1);
	_s_pr_piplus = bookScatter2D(2, 3, 1);
	_s_antipr_piminus = bookScatter2D(2, 4, 1);
	}


	/// Do the analysis
	void analyze(const Event& event) {
	- const ChargedFinalState& bbc1 = applyProjection<ChargedFinalState>(event, "BBC1");
	- const ChargedFinalState& bbc2 = applyProjection<ChargedFinalState>(event, "BBC2");
	+ const ChargedFinalState& bbc1 = apply<ChargedFinalState>(event, "BBC1");
	+ const ChargedFinalState& bbc2 = apply<ChargedFinalState>(event, "BBC2");
	if (bbc1.size() < 1 \|\| bbc2.size() < 1) {
	MSG_DEBUG("Failed beam-beam-counter trigger");
	vetoEvent;
	}

	const double weight = event.weight();

	- const IdentifiedFinalState& pionfs = applyProjection<IdentifiedFinalState>(event, "PionFS");
	+ const IdentifiedFinalState& pionfs = apply<IdentifiedFinalState>(event, "PionFS");
	foreach (const Particle& p, pionfs.particles()) {
	if (p.absrap() < 0.5) {
	/// @todo Use a binned counter to avoid this bin width cancellation hack
	const double pT = p.pT() / GeV;
	((p.pid() > 0) ? _h_pT_piplus : _h_pT_piminus)->fill(pT, weight/pT);
	((p.pid() > 0) ? _tmp_pT_piplus : _tmp_pT_piminus)->fill(pT, weight/pT);
	}
	}

	- const IdentifiedFinalState& protonfs = applyProjection<IdentifiedFinalState>(event, "ProtonFS");
	+ const IdentifiedFinalState& protonfs = apply<IdentifiedFinalState>(event, "ProtonFS");
	foreach (const Particle& p, protonfs.particles()) {
	if (p.absrap() < 0.5) {
	/// @todo Use a binned counter to avoid this bin width cancellation hack
	const double pT = p.pT() / GeV;
	((p.pid() > 0) ? _h_pT_proton : _h_pT_antiproton)->fill(pT, weight/pT);
	}
	}
	_sumWeightSelected += event.weight();
	}


	/// Finalize
	void finalize() {
	divide(_h_pT_piminus, _h_pT_piplus, _s_piminus_piplus);
	divide(_h_pT_antiproton, _h_pT_proton, _s_antipr_pr);
	divide(_h_pT_proton, _tmp_pT_piplus, _s_pr_piplus);
	divide(_h_pT_antiproton, _tmp_pT_piminus, _s_antipr_piminus);
	scale(_h_pT_piplus, 1/(2M_PI_sumWeightSelected));
	scale(_h_pT_piminus, 1/(2M_PI_sumWeightSelected));
	scale(_h_pT_proton, 1/(2M_PI_sumWeightSelected));
	scale(_h_pT_antiproton, 1/(2M_PI_sumWeightSelected));
	}


	private:

	double _sumWeightSelected;
	Histo1DPtr _h_pT_piplus, _h_pT_piminus, _h_pT_proton, _h_pT_antiproton;
	Histo1DPtr _tmp_pT_piplus, _tmp_pT_piminus;
	Scatter2DPtr _s_piminus_piplus, _s_antipr_pr, _s_pr_piplus, _s_antipr_piminus;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(STAR_2006_S6500200);

	}
	diff --git a/src/Analyses/STAR_2006_S6860818.cc b/src/Analyses/STAR_2006_S6860818.cc
	--- a/src/Analyses/STAR_2006_S6860818.cc
	+++ b/src/Analyses/STAR_2006_S6860818.cc
	@@ -1,193 +1,193 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/UnstableFinalState.hh"

	namespace Rivet {


	/// @brief STAR strange particle spectra in pp at 200 GeV
	class STAR_2006_S6860818 : public Analysis {
	public:

	/// Constructor
	STAR_2006_S6860818()
	: Analysis("STAR_2006_S6860818"),
	_sumWeightSelected(0.0)
	{
	for (size_t i = 0; i < 4; i++) {
	_nBaryon[i] = 0;
	_nAntiBaryon[i] = 0;
	_nWeightedBaryon[i] = 0.;
	_nWeightedAntiBaryon[i] = 0.;
	}
	}

	/// Book projections and histograms
	void init() {
	ChargedFinalState bbc1(Cuts::etaIn(-5.0, -3.5)); // beam-beam-counter trigger
	ChargedFinalState bbc2(Cuts::etaIn( 3.5, 5.0)); // beam-beam-counter trigger
	- addProjection(bbc1, "BBC1");
	- addProjection(bbc2, "BBC2");
	+ declare(bbc1, "BBC1");
	+ declare(bbc2, "BBC2");

	UnstableFinalState ufs(Cuts::abseta < 2.5);
	- addProjection(ufs, "UFS");
	+ declare(ufs, "UFS");

	_h_pT_k0s = bookHisto1D(1, 1, 1);
	_h_pT_kminus = bookHisto1D(1, 2, 1);
	_h_pT_kplus = bookHisto1D(1, 3, 1);
	_h_pT_lambda = bookHisto1D(1, 4, 1);
	_h_pT_lambdabar = bookHisto1D(1, 5, 1);
	_h_pT_ximinus = bookHisto1D(1, 6, 1);
	_h_pT_xiplus = bookHisto1D(1, 7, 1);
	//_h_pT_omega = bookHisto1D(1, 8, 1);
	_h_antibaryon_baryon_ratio = bookScatter2D(2, 1, 1);
	_h_lambar_lam = bookScatter2D(2, 2, 1);
	_h_xiplus_ximinus = bookScatter2D(2, 3, 1);
	_h_pT_vs_mass = bookProfile1D(3, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& event) {
	- const ChargedFinalState& bbc1 = applyProjection<ChargedFinalState>(event, "BBC1");
	- const ChargedFinalState& bbc2 = applyProjection<ChargedFinalState>(event, "BBC2");
	+ const ChargedFinalState& bbc1 = apply<ChargedFinalState>(event, "BBC1");
	+ const ChargedFinalState& bbc2 = apply<ChargedFinalState>(event, "BBC2");
	if (bbc1.size()<1 \|\| bbc2.size()<1) {
	MSG_DEBUG("Failed beam-beam-counter trigger");
	vetoEvent;
	}

	const double weight = event.weight();

	- const UnstableFinalState& ufs = applyProjection<UnstableFinalState>(event, "UFS");
	+ const UnstableFinalState& ufs = apply<UnstableFinalState>(event, "UFS");
	foreach (const Particle& p, ufs.particles()) {
	if (p.absrap() < 0.5) {
	const PdgId pid = p.pid();
	const double pT = p.pT() / GeV;
	switch (abs(pid)) {
	case PID::PIPLUS:
	if (pid < 0) _h_pT_vs_mass->fill(0.1396, pT, weight);
	break;
	case PID::PROTON:
	if (pid < 0) _h_pT_vs_mass->fill(0.9383, pT, weight);
	if (pT > 0.4) {
	pid > 0 ? _nBaryon[0]++ : _nAntiBaryon[0]++;
	pid > 0 ? _nWeightedBaryon[0]+=weight : _nWeightedAntiBaryon[0]+=weight;
	}
	break;
	case PID::K0S:
	if (pT > 0.2) {
	_h_pT_k0s->fill(pT, weight/pT);
	}
	_h_pT_vs_mass->fill(0.5056, pT, weight);
	break;
	case PID::K0L:
	_h_pT_vs_mass->fill(0.5056, pT, weight);
	break;
	case 113: // rho0(770)
	_h_pT_vs_mass->fill(0.7755, pT, weight);
	break;
	case 313: // K0*(892)
	_h_pT_vs_mass->fill(0.8960, pT, weight);
	break;
	case 333: // phi(1020)
	_h_pT_vs_mass->fill(1.0190, pT, weight);
	break;
	case 3214: // Sigma(1385)
	_h_pT_vs_mass->fill(1.3840, pT, weight);
	break;
	case 3124: // Lambda(1520)
	_h_pT_vs_mass->fill(1.5200, pT, weight);
	break;
	case PID::KPLUS:
	if (pid < 0) _h_pT_vs_mass->fill(0.4856, pT, weight);
	if (pT > 0.2) {
	pid > 0 ? _h_pT_kplus->fill(pT, weight/pT) : _h_pT_kminus->fill(pT, weight/pT);
	}
	break;
	case PID::LAMBDA:
	pid > 0 ? _h_pT_vs_mass->fill(1.1050, pT, weight) : _h_pT_vs_mass->fill(1.1250, pT, weight);
	if (pT > 0.3) {
	pid > 0 ? _h_pT_lambda->fill(pT, weight/pT) : _h_pT_lambdabar->fill(pT, weight/pT);
	pid > 0 ? _nBaryon[1]++ : _nAntiBaryon[1]++;
	pid > 0 ? _nWeightedBaryon[1]+=weight : _nWeightedAntiBaryon[1]+=weight;
	}
	break;
	case PID::XIMINUS:
	pid > 0 ? _h_pT_vs_mass->fill(1.3120, pT, weight) : _h_pT_vs_mass->fill(1.3320, pT, weight);
	if (pT > 0.5) {
	pid > 0 ? _h_pT_ximinus->fill(pT, weight/pT) : _h_pT_xiplus->fill(pT, weight/pT);
	pid > 0 ? _nBaryon[2]++ : _nAntiBaryon[2]++;
	pid > 0 ? _nWeightedBaryon[2]+=weight : _nWeightedAntiBaryon[2]+=weight;
	}
	break;
	case PID::OMEGAMINUS:
	_h_pT_vs_mass->fill(1.6720, pT, weight);
	if (pT > 0.5) {
	//_h_pT_omega->fill(pT, weight/pT);
	pid > 0 ? _nBaryon[3]++ : _nAntiBaryon[3]++;
	pid > 0 ? _nWeightedBaryon[3]+=weight : _nWeightedAntiBaryon[3]+=weight;
	}
	break;
	}

	}
	}

	_sumWeightSelected += event.weight();
	}


	/// Finalize
	void finalize() {
	std::vector<Point2D> points;
	for (size_t i=0 ; i<4 ; i++) {
	if (_nWeightedBaryon[i]==0 \|\| _nWeightedAntiBaryon[i]==0) {
	points.push_back(Point2D(i,0,0.5,0));
	} else {
	double y = _nWeightedAntiBaryon[i]/_nWeightedBaryon[i];
	double dy = sqrt( 1./_nAntiBaryon[i] + 1./_nBaryon[i] );
	points.push_back(Point2D(i,y,0.5,y*dy));
	}
	}
	_h_antibaryon_baryon_ratio->addPoints( points );

	divide(_h_pT_lambdabar,_h_pT_lambda, _h_lambar_lam);
	divide(_h_pT_xiplus,_h_pT_ximinus, _h_xiplus_ximinus);

	scale(_h_pT_k0s, 1./(2M_PI_sumWeightSelected));
	scale(_h_pT_kminus, 1./(2M_PI_sumWeightSelected));
	scale(_h_pT_kplus, 1./(2M_PI_sumWeightSelected));
	scale(_h_pT_lambda, 1./(2M_PI_sumWeightSelected));
	scale(_h_pT_lambdabar, 1./(2M_PI_sumWeightSelected));
	scale(_h_pT_ximinus, 1./(2M_PI_sumWeightSelected));
	scale(_h_pT_xiplus, 1./(2M_PI_sumWeightSelected));
	//scale(_h_pT_omega, 1./(2M_PI_sumWeightSelected));
	MSG_DEBUG("sumOfWeights() = " << sumOfWeights());
	MSG_DEBUG("_sumWeightSelected = " << _sumWeightSelected);
	}

	private:

	double _sumWeightSelected;
	int _nBaryon[4];
	int _nAntiBaryon[4];
	double _nWeightedBaryon[4];
	double _nWeightedAntiBaryon[4];

	Histo1DPtr _h_pT_k0s, _h_pT_kminus, _h_pT_kplus, _h_pT_lambda, _h_pT_lambdabar, _h_pT_ximinus, _h_pT_xiplus;
	//Histo1DPtr _h_pT_omega;
	Scatter2DPtr _h_antibaryon_baryon_ratio;
	Profile1DPtr _h_pT_vs_mass;
	Scatter2DPtr _h_lambar_lam;
	Scatter2DPtr _h_xiplus_ximinus;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(STAR_2006_S6860818);


	}
	diff --git a/src/Analyses/STAR_2006_S6870392.cc b/src/Analyses/STAR_2006_S6870392.cc
	--- a/src/Analyses/STAR_2006_S6870392.cc
	+++ b/src/Analyses/STAR_2006_S6870392.cc
	@@ -1,88 +1,88 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief STAR inclusive jet cross-section in pp at 200 GeV
	class STAR_2006_S6870392 : public Analysis {
	public:

	/// Constructor
	STAR_2006_S6870392()
	: Analysis("STAR_2006_S6870392")
	{ }


	/// @name Analysis methods
	//@{

	/// Book projections and histograms
	void init() {
	FinalState fs(-2.0, 2.0);
	- addProjection(fs, "FS");
	- addProjection(FastJets(fs, FastJets::CDFMIDPOINT, 0.4,
	+ declare(fs, "FS");
	+ declare(FastJets(fs, FastJets::CDFMIDPOINT, 0.4,
	JetAlg::ALL_MUONS, JetAlg::NO_INVISIBLES,
	nullptr, 0.5), "MidpointJets");

	_h_jet_pT_MB = bookHisto1D(1, 1, 1);
	_h_jet_pT_HT = bookHisto1D(2, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& event) {
	const double weight = event.weight();

	// Skip if the event is empty
	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	if (fs.empty()) {
	MSG_DEBUG("Skipping event " << numEvents() << " because no final state found ");
	vetoEvent;
	}

	// Find jets
	- const FastJets& jetpro = applyProjection<FastJets>(event, "MidpointJets");
	+ const FastJets& jetpro = apply<FastJets>(event, "MidpointJets");
	const Jets& jets = jetpro.jetsByPt();
	if (!jets.empty()) {
	const Jet& j1 = jets.front();
	if (inRange(fabs(j1.eta()), 0.2, 0.8)) {
	foreach (const Jet& j, jets) {
	const FourMomentum pj = j.momentum();
	_h_jet_pT_MB->fill(pj.pT(), weight);
	_h_jet_pT_HT->fill(pj.pT(), weight);
	}
	}
	}
	}



	/// Finalize
	void finalize() {
	double normalisation = crossSection()/picobarn/sumOfWeights()/(20.62*M_PI);
	scale(_h_jet_pT_MB, normalisation);
	scale(_h_jet_pT_HT, normalisation);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_jet_pT_MB;
	Histo1DPtr _h_jet_pT_HT;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(STAR_2006_S6870392);

	}
	diff --git a/src/Analyses/STAR_2008_S7869363.cc b/src/Analyses/STAR_2008_S7869363.cc
	--- a/src/Analyses/STAR_2008_S7869363.cc
	+++ b/src/Analyses/STAR_2008_S7869363.cc
	@@ -1,167 +1,168 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/LossyFinalState.hh"

	namespace Rivet {


	+ /// @todo Replace with SmearedParticles
	class STARRandomFilter {
	public:

	STARRandomFilter() { }

	// Return true to throw away a particle
	bool operator()(const Particle& p) {
	/// @todo Use a better RNG?
	size_t idx = int(floor(p.pT()/MeV/50));
	if (idx > 11) idx = 11;
	return (rand()/static_cast<double>(RAND_MAX) > _trkeff[idx]);
	}

	int compare(const STARRandomFilter& other) const {
	return true;
	}

	private:

	const static double _trkeff[12];

	};


	// Here we have the track reconstruction efficiencies for tracks with pT from 0 to 600 MeV
	// in steps of 50 MeV. The efficiency is assumed to be 0.88 for pT >= 600 MeV
	const double STARRandomFilter::_trkeff[12] = {0,0,0.38,0.72,0.78,0.81,0.82,0.84,0.85,0.86,0.87,0.88};



	class STAR_2008_S7869363 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	STAR_2008_S7869363()
	: Analysis("STAR_2008_S7869363"),
	nCutsPassed(0),
	nPi(0), nPiPlus(0), nKaon(0), nKaonPlus(0), nProton(0), nAntiProton(0)
	{ }

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	const ChargedFinalState cfs(-0.5, 0.5, 0.2*GeV);
	const LossyFinalState<STARRandomFilter> lfs(cfs, STARRandomFilter());
	- addProjection(lfs, "FS");
	+ declare(lfs, "FS");

	_h_dNch = bookHisto1D(1, 1, 1);
	_h_dpT_Pi = bookHisto1D(2, 1, 1);
	_h_dpT_Piplus = bookHisto1D(2, 1, 2);
	_h_dpT_Kaon = bookHisto1D(2, 1, 3);
	_h_dpT_Kaonplus = bookHisto1D(2, 1, 4);
	_h_dpT_AntiProton = bookHisto1D(2, 1, 5);
	_h_dpT_Proton = bookHisto1D(2, 1, 6);
	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	- const FinalState& charged = applyProjection<FinalState>(event, "FS");
	+ const FinalState& charged = apply<FinalState>(event, "FS");

	// Vertex reconstruction efficiencies as a function of charged multiplicity.
	// For events with more than 23 reconstructed tracks the efficiency is 100%.
	double vtxeffs[24] = { 0.000000,0.512667,0.739365,0.847131,0.906946,0.940922,0.959328,0.96997,
	0.975838,0.984432,0.988311,0.990327,0.990758,0.995767,0.99412,0.992271,
	0.996631,0.994802,0.99635,0.997384,0.998986,0.996441,0.994513,1.000000 };

	double vtxeff = 1.0;
	if (charged.particles().size() < 24) {
	vtxeff = vtxeffs[charged.particles().size()];
	}

	const double weight = vtxeff * event.weight();

	foreach (const Particle& p, charged.particles()) {
	double pT = p.pT()/GeV;
	double y = p.rapidity();
	if (fabs(y) < 0.1) {
	nCutsPassed += weight;
	const PdgId id = p.pid();
	switch (id) {
	case -211:
	_h_dpT_Pi->fill(pT, weight/(TWOPIpT0.2));
	nPi += weight;
	break;
	case 211:
	_h_dpT_Piplus->fill(pT, weight/(TWOPIpT0.2));
	nPiPlus += weight;
	break;
	case -321:
	_h_dpT_Kaon->fill(pT, weight/(TWOPIpT0.2));
	nKaon += weight;
	break;
	case 321:
	_h_dpT_Kaonplus->fill(pT, weight/(TWOPIpT0.2));
	nKaonPlus += weight;
	break;
	case -2212:
	_h_dpT_AntiProton->fill(pT, weight/(TWOPIpT0.2));
	nAntiProton += weight;
	break;
	case 2212:
	_h_dpT_Proton->fill(pT, weight/(TWOPIpT0.2));
	nProton += weight;
	break;
	}
	}
	else {
	continue;
	}
	}
	_h_dNch->fill(charged.particles().size(), weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	//double nTot = nPi + nPiPlus + nKaon + nKaonPlus + nProton + nAntiProton;
	normalize(_h_dNch);

	/// @todo Norm to data!
	normalize(_h_dpT_Pi , 0.389825 );
	normalize(_h_dpT_Piplus , 0.396025 );
	normalize(_h_dpT_Kaon , 0.03897 );
	normalize(_h_dpT_Kaonplus , 0.04046 );
	normalize(_h_dpT_AntiProton, 0.0187255);
	normalize(_h_dpT_Proton , 0.016511 );
	}


	private:


	Histo1DPtr _h_dNch;

	Histo1DPtr _h_dpT_Pi, _h_dpT_Piplus;
	Histo1DPtr _h_dpT_Kaon, _h_dpT_Kaonplus;
	Histo1DPtr _h_dpT_AntiProton, _h_dpT_Proton;

	Profile1DPtr _h_pT_vs_Nch;
	double nCutsPassed, nPi, nPiPlus, nKaon, nKaonPlus, nProton, nAntiProton;
	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(STAR_2008_S7869363);

	}
	diff --git a/src/Analyses/STAR_2008_S7993412.cc b/src/Analyses/STAR_2008_S7993412.cc
	--- a/src/Analyses/STAR_2008_S7993412.cc
	+++ b/src/Analyses/STAR_2008_S7993412.cc
	@@ -1,81 +1,81 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	/// @brief STAR di-hadron correlations in d-Au at 200 GeV
	class STAR_2008_S7993412 : public Analysis {
	public:

	STAR_2008_S7993412() : Analysis("STAR_2008_S7993412")
	{
	}


	/// @name Analysis methods
	//@{

	/// Book projections and histograms
	void init() {
	ChargedFinalState fs(-1.0, 1.0, 1.0*GeV);
	- addProjection(fs, "FS");
	+ declare(fs, "FS");

	_h_Y_jet_trigger = bookProfile1D(1, 1, 1);
	_h_Y_jet_associated = bookProfile1D(2, 1, 1);
	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Skip if the event is empty
	- const FinalState& fs = applyProjection<FinalState>(event, "FS");
	+ const FinalState& fs = apply<FinalState>(event, "FS");
	if (fs.empty()) {
	MSG_DEBUG("Skipping event " << numEvents() << " because no final state found ");
	vetoEvent;
	}

	const double weight = event.weight();

	foreach (const Particle& tp, fs.particles()) {
	const double triggerpT = tp.pT();
	if (triggerpT >= 2.0 && triggerpT < 5.0) {
	int n_associated = 0;
	foreach (const Particle& ap, fs.particles()) {
	if (!inRange(ap.pT()/GeV, 1.5, triggerpT)) continue;
	if (deltaPhi(tp.phi(), ap.phi()) > 1) continue;
	if (fabs(tp.eta() - ap.eta()) > 1.75) continue;
	n_associated += 1;
	}
	//const double dPhidEta = 2 * 2*1.75;
	//_h_Y_jet_trigger->fill(triggerpT, n_associated/dPhidEta, weight);
	_h_Y_jet_trigger->fill(triggerpT, n_associated, weight);
	}
	}
	}


	/// Finalize
	void finalize() {
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Profile1DPtr _h_Y_jet_trigger;
	Profile1DPtr _h_Y_jet_associated;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(STAR_2008_S7993412);

	}
	diff --git a/src/Analyses/STAR_2009_UE_HELEN.cc b/src/Analyses/STAR_2009_UE_HELEN.cc
	--- a/src/Analyses/STAR_2009_UE_HELEN.cc
	+++ b/src/Analyses/STAR_2009_UE_HELEN.cc
	@@ -1,168 +1,168 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/NeutralFinalState.hh"
	#include "Rivet/Projections/MergedFinalState.hh"
	#include "Rivet/Projections/VetoedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"
	#include "fastjet/SISConePlugin.hh"

	namespace Rivet {


	/// @brief STAR underlying event
	/// @author Hendrik Hoeth
	class STAR_2009_UE_HELEN : public Analysis {
	public:

	/// Constructor
	STAR_2009_UE_HELEN()
	: Analysis("STAR_2009_UE_HELEN")
	{
	}


	/// @name Analysis methods
	//@{

	void init() {
	// Charged final state, \|eta\|<1, pT>0.2GeV
	const ChargedFinalState cfs(-1.0, 1.0, 0.2*GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	// Neutral final state, \|eta\|<1, ET>0.2GeV (needed for the jets)
	const NeutralFinalState nfs(-1.0, 1.0, 0.2*GeV);
	- addProjection(nfs, "NFS");
	+ declare(nfs, "NFS");

	// STAR can't see neutrons and K^0_L
	VetoedFinalState vfs(nfs);
	vfs.vetoNeutrinos();
	vfs.addVetoPairId(PID::K0L);
	vfs.addVetoPairId(PID::NEUTRON);
	- addProjection(vfs, "VFS");
	+ declare(vfs, "VFS");

	// Jets are reconstructed from charged and neutral particles,
	// and the cuts are different (pT vs. ET), so we need to merge them.
	const MergedFinalState jfs(cfs, vfs);
	- addProjection(jfs, "JFS");
	+ declare(jfs, "JFS");

	// SISCone, R = 0.7, overlap_threshold = 0.75
	- addProjection(FastJets(jfs, FastJets::SISCONE, 0.7), "AllJets");
	+ declare(FastJets(jfs, FastJets::SISCONE, 0.7), "AllJets");

	// Book histograms
	_hist_pmaxnchg = bookProfile1D( 1, 1, 1);
	_hist_pminnchg = bookProfile1D( 2, 1, 1);
	_hist_anchg = bookProfile1D( 3, 1, 1);
	}


	// Do the analysis
	void analyze(const Event& e) {
	- const FinalState& cfs = applyProjection<ChargedFinalState>(e, "CFS");
	+ const FinalState& cfs = apply<ChargedFinalState>(e, "CFS");
	if (cfs.particles().size() < 1) {
	MSG_DEBUG("Failed multiplicity cut");
	vetoEvent;
	}

	- const Jets& alljets = applyProjection<FastJets>(e, "AllJets").jetsByPt();
	+ const Jets& alljets = apply<FastJets>(e, "AllJets").jetsByPt();
	MSG_DEBUG("Total jet multiplicity = " << alljets.size());

	// The jet acceptance region is \|eta\|<(1-R)=0.3 (with R = jet radius)
	// Jets also must have a neutral energy fraction of < 0.7
	Jets jets;
	foreach (const Jet jet, alljets) {
	if (jet.neutralEnergy()/jet.totalEnergy() < 0.7 &&
	jet.abseta() < 0.3)
	jets.push_back(jet);
	}

	// This analysis requires a di-jet like event.
	// WARNING: There is more data in preparation, some of which
	// does _not_ have this constraint!
	if (jets.size() != 2) {
	MSG_DEBUG("Failed jet multiplicity cut");
	vetoEvent;
	}

	// The di-jet constraints in this analysis are:
	// - 2 and only 2 jets in the acceptance region
	// - delta(Phi) between the jets is > 150 degrees
	// - Pt_awayjet/Pt_towards_jet > 0.7
	if (deltaPhi(jets[0].phi(), jets[1].phi()) <= 5*PI/6 \|\|
	jets[1].pT()/jets[0].pT() <= 0.7)
	{
	MSG_DEBUG("Failed di-jet criteria");
	vetoEvent;
	}

	// Now lets start ...
	const double jetphi = jets[0].phi();
	const double jetpT = jets[0].pT();

	// Get the event weight
	const double weight = e.weight();

	size_t numTrans1(0), numTrans2(0), numAway(0);

	// Calculate all the charged stuff
	foreach (const Particle& p, cfs.particles()) {
	const double dPhi = deltaPhi(p.phi(), jetphi);
	const double pT = p.pT();
	const double phi = p.phi();
	double rotatedphi = phi - jetphi;
	while (rotatedphi < 0) rotatedphi += 2*PI;

	// @TODO: WARNING: The following lines are a hack to correct
	// for the STAR tracking efficiency. Once we have the
	// final numbers (corrected to hadron level), we need
	// to remove this!!!!
	if (1.0rand()/static_cast<double>(RAND_MAX) > 0.87834-exp(-1.48994-0.788432pT)) {
	continue;
	}
	// -------- end of efficiency hack -------

	if (dPhi < PI/3.0) {
	// toward
	}
	else if (dPhi < 2*PI/3.0) {
	if (rotatedphi <= PI) {
	++numTrans1;
	}
	else {
	++numTrans2;
	}
	}
	else {
	++numAway;
	}
	} // end charged particle loop

	// Fill the histograms
	_hist_pmaxnchg->fill(jetpT, (numTrans1>numTrans2 ? numTrans1 : numTrans2)/(2*PI/3), weight);
	_hist_pminnchg->fill(jetpT, (numTrans1<numTrans2 ? numTrans1 : numTrans2)/(2*PI/3), weight);
	_hist_anchg->fill(jetpT, numAway/(PI0.70.7), weight); // jet area = pi*R^2

	}


	void finalize() {
	//
	}

	//@}


	private:

	Profile1DPtr _hist_pmaxnchg;
	Profile1DPtr _hist_pminnchg;
	Profile1DPtr _hist_anchg;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(STAR_2009_UE_HELEN);

	}
	diff --git a/src/Analyses/TASSO_1990_S2148048.cc b/src/Analyses/TASSO_1990_S2148048.cc
	--- a/src/Analyses/TASSO_1990_S2148048.cc
	+++ b/src/Analyses/TASSO_1990_S2148048.cc
	@@ -1,166 +1,166 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	//#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/Thrust.hh"
	#include "Rivet/Projections/Sphericity.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	/// @todo Include more projections as required, e.g. ChargedFinalState, FastJets, ZFinder...

	namespace Rivet {


	class TASSO_1990_S2148048 : public Analysis {
	public:

	/// @name Constructors etc.
	//@{

	/// Constructor
	TASSO_1990_S2148048()
	: Analysis("TASSO_1990_S2148048")
	{
	/// @todo Set whether your finalize method needs the generator cross section
	//_sumWPassed = 0;
	}

	//@}


	public:

	/// @name Analysis methods
	//@{

	/// Book histograms and initialise projections before the run
	void init() {
	const ChargedFinalState cfs(-MAXDOUBLE, MAXDOUBLE, 0.1/GeV);
	- addProjection(cfs, "CFS");
	+ declare(cfs, "CFS");

	//// Beams -- needed for x_p calculation
	- //addProjection(Beam(), "Beams");
	+ //declare(Beam(), "Beams");

	// Thrust
	- addProjection(Thrust(cfs), "Thrust");
	+ declare(Thrust(cfs), "Thrust");

	// For Sphericity and the like
	- addProjection(Sphericity(cfs), "Sphericity");
	+ declare(Sphericity(cfs), "Sphericity");

	// Histos
	int offset = 0;
	switch (int(sqrtS()/GeV)) {
	case 14:
	offset = 0;
	break;
	case 22:
	offset = 1;
	break;
	case 35:
	offset = 2;
	break;
	case 44:
	offset = 3;
	break;
	}
	//_h_xp = bookHisto1D( 2, 1, 1+offset);
	_h_sphericity = bookHisto1D( 6, 1, 1+offset);
	_h_aplanarity = bookHisto1D( 7, 1, 1+offset);
	_h_thrust = bookHisto1D( 8, 1, 1+offset);
	}



	/// Perform the per-event analysis
	void analyze(const Event& event) {
	const double weight = event.weight();
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");

	//// Get beams and average beam momentum
	- //const ParticlePair& beams = applyProjection<Beam>(event, "Beams").beams();
	+ //const ParticlePair& beams = apply<Beam>(event, "Beams").beams();
	//const double meanBeamMom = ( beams.first.p3().mod() +
	//beams.second.p3().mod() ) / 2.0;

	// TASSO hadronic event selection TODO: move this into a trigger definition
	// See page 2 in publication
	// Condition 1) --- require at least 5 (4) 'good' tracks
	int nch = cfs.particles().size();
	if ( (int(sqrtS()/GeV) > 27 && nch < 5) \|\| (int(sqrtS()/GeV) <= 27 && nch < 4 ) ) {
	MSG_DEBUG("Failed # good tracks cut: " << nch);
	vetoEvent;
	}
	// Condition 2) ---
	// Condition 5) --- scalar momentum (not pT!!!) sum >= 0.265*s
	double momsum = 0.0;
	foreach (const Particle& p, cfs.particles()) {
	const double mom = p.p3().mod();
	momsum += mom;
	}
	if (momsum <=0.265 * sqrtS()/GeV) {
	MSG_DEBUG("Failed pTsum cut: " << momsum << " < " << 0.265 * sqrtS()/GeV);
	vetoEvent;
	}

	// Raise counter for events that pass trigger conditions
	//_sumWPassed += event.weight();

	- const Thrust& thrust = applyProjection<Thrust>(event, "Thrust");
	+ const Thrust& thrust = apply<Thrust>(event, "Thrust");
	//const Vector3 & thrustAxis = thrust.thrustAxis ();
	//double theta = thrustAxis.theta();
	//if ( fabs(cos(theta)) >= 0.8 ) {
	//MSG_DEBUG("Failed thrust angle cut: " << fabs(cos(theta)));
	//vetoEvent;
	//}

	- const Sphericity& sphericity = applyProjection<Sphericity>(event, "Sphericity");
	+ const Sphericity& sphericity = apply<Sphericity>(event, "Sphericity");

	//// Fill histograms in order of appearance in paper
	//foreach (const Particle& p, cfs.particles()) {
	//// Get momentum and energy of each particle.
	//const Vector3 mom3 = p.p3();
	//// Scaled momenta.
	//const double mom = mom3.mod();
	//const double scaledMom = mom/meanBeamMom;
	//_h_xp->fill(scaledMom, weight);
	//}
	//
	_h_sphericity->fill(sphericity.sphericity(), weight);
	_h_aplanarity->fill(sphericity.aplanarity(), weight);
	_h_thrust->fill(thrust.thrust(), weight);
	}


	/// Normalise histograms etc., after the run
	void finalize() {
	//scale(_h_xp, _sumWPassed/(crossSection()*sumOfWeights()));
	normalize(_h_sphericity);
	normalize(_h_aplanarity);
	normalize(_h_thrust );
	}

	//@}


	private:

	// Data members like post-cuts event weight counters go here

	//double _sumWPassed;

	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_xp ;
	Histo1DPtr _h_sphericity;
	Histo1DPtr _h_aplanarity;
	Histo1DPtr _h_thrust ;
	//@}


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(TASSO_1990_S2148048);

	}
	diff --git a/src/Analyses/TOTEM_2012_I1115294.cc b/src/Analyses/TOTEM_2012_I1115294.cc
	--- a/src/Analyses/TOTEM_2012_I1115294.cc
	+++ b/src/Analyses/TOTEM_2012_I1115294.cc
	@@ -1,64 +1,64 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class TOTEM_2012_I1115294 : public Analysis {
	public:

	TOTEM_2012_I1115294()
	: Analysis("TOTEM_2012_I1115294")
	{ }


	public:

	void init() {
	ChargedFinalState cfsm(-6.50, -5.35, 40.*MeV);
	ChargedFinalState cfsp( 5.35, 6.50, 40.*MeV);
	- addProjection(cfsm, "CFSM");
	- addProjection(cfsp, "CFSP");
	+ declare(cfsm, "CFSM");
	+ declare(cfsp, "CFSP");

	_h_eta = bookHisto1D(1, 1, 1);
	_sumofweights = 0.;
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ChargedFinalState cfsm = applyProjection<ChargedFinalState>(event, "CFSM");
	- const ChargedFinalState cfsp = applyProjection<ChargedFinalState>(event, "CFSP");
	+ const ChargedFinalState cfsm = apply<ChargedFinalState>(event, "CFSM");
	+ const ChargedFinalState cfsp = apply<ChargedFinalState>(event, "CFSP");

	if (cfsm.size() == 0 && cfsp.size() == 0) vetoEvent;

	_sumofweights += weight;

	foreach (const Particle& p, cfsm.particles() + cfsp.particles()) {
	_h_eta->fill(p.abseta(), weight);
	}

	}


	void finalize() {
	scale(_h_eta, 1./(2*_sumofweights));
	}


	private:

	double _sumofweights;
	Histo1DPtr _h_eta;


	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(TOTEM_2012_I1115294);

	}
	diff --git a/src/Analyses/TOTEM_2012_002.cc b/src/Analyses/TOTEM_2012_I1220862.cc
	rename from src/Analyses/TOTEM_2012_002.cc
	rename to src/Analyses/TOTEM_2012_I1220862.cc
	--- a/src/Analyses/TOTEM_2012_002.cc
	+++ b/src/Analyses/TOTEM_2012_I1220862.cc
	@@ -1,62 +1,57 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	/// TOTEM elastic and total cross-section measurement
	- class TOTEM_2012_002 : public Analysis {
	+ class TOTEM_2012_I1220862 : public Analysis {
	public:

	- TOTEM_2012_002()
	- : Analysis("TOTEM_2012_002")
	+ TOTEM_2012_I1220862()
	+ : Analysis("TOTEM_2012_I1220862")
	{ }


	- public:
	-
	void init() {
	- addProjection(ChargedFinalState(), "CFS");
	+ declare(ChargedFinalState(), "CFS");
	_hist_tlow = bookHisto1D(1, 1, 1);
	_hist_thigh = bookHisto1D(2, 1, 1);
	_hist_sigma = bookHisto1D(3, 1, 1);
	}


	void analyze(const Event& event) {
	const double weight = event.weight();

	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	- if (cfs.size() > 2) MSG_WARNING("Final state includes more than two charged particles !");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");
	+ if (cfs.size() > 2) MSG_WARNING("Final state includes more than two charged particles!");
	_hist_sigma->fill(sqrtS()/GeV, weight);

	- foreach (const Particle& p, cfs.particles()) {
	- if (p.eta() > 0. && p.pid() == PID::PROTON) {
	- double t = sqr(p.pT());
	- _hist_tlow->fill(t, weight);
	- _hist_thigh->fill(t, weight);
	- }
	+ for (const Particle& p : cfs.particles(Cuts::eta > 0)) { // && Cuts::pid == PID::PROTON)) {
	+ if (p.pid() != PID::PROTON) continue;
	+ const double t = sqr(p.pT());
	+ _hist_tlow->fill(t, weight);
	+ _hist_thigh->fill(t, weight);
	}
	}


	void finalize() {
	normalize(_hist_tlow, crossSection()/millibarn);
	normalize(_hist_thigh, crossSection()/millibarn);
	normalize(_hist_sigma, crossSection()/millibarn);
	}


	private:

	- Histo1DPtr _hist_tlow;
	- Histo1DPtr _hist_thigh;
	- Histo1DPtr _hist_sigma;
	+ Histo1DPtr _hist_tlow, _hist_thigh, _hist_sigma;

	};


	- DECLARE_RIVET_PLUGIN(TOTEM_2012_002);
	+ DECLARE_ALIASED_RIVET_PLUGIN(TOTEM_2012_I1220862, TOTEM_2012_002);

	}
	diff --git a/src/Analyses/TOTEM_2014_I1328627.cc b/src/Analyses/TOTEM_2014_I1328627.cc
	--- a/src/Analyses/TOTEM_2014_I1328627.cc
	+++ b/src/Analyses/TOTEM_2014_I1328627.cc
	@@ -1,58 +1,58 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class TOTEM_2014_I1328627 : public Analysis {
	public:


	TOTEM_2014_I1328627()
	: Analysis("TOTEM_2014_I1328627")
	{ }



	void init() {
	ChargedFinalState cfsm(-7.0, -6.0, 0.0*GeV);
	ChargedFinalState cfsp( 3.7, 4.8, 0.0*GeV);
	- addProjection(cfsm, "CFSM");
	- addProjection(cfsp, "CFSP");
	+ declare(cfsm, "CFSM");
	+ declare(cfsp, "CFSP");

	_h_eta = bookHisto1D(1, 1, 1);
	_sumofweights = 0.;
	}


	void analyze(const Event& event) {
	- const ChargedFinalState cfsm = applyProjection<ChargedFinalState>(event, "CFSM");
	- const ChargedFinalState cfsp = applyProjection<ChargedFinalState>(event, "CFSP");
	+ const ChargedFinalState cfsm = apply<ChargedFinalState>(event, "CFSM");
	+ const ChargedFinalState cfsp = apply<ChargedFinalState>(event, "CFSP");
	if (cfsm.size() == 0 && cfsp.size() == 0) vetoEvent;

	_sumofweights += event.weight();
	foreach (const Particle& p, cfsm.particles() + cfsp.particles()) {
	_h_eta->fill(p.abseta(), event.weight());
	}
	}


	void finalize() {
	scale(_h_eta, 1./_sumofweights);
	}


	private:

	double _sumofweights;
	Histo1DPtr _h_eta;

	};


	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(TOTEM_2014_I1328627);


	}
	diff --git a/src/Analyses/UA1_1990_S2044935.cc b/src/Analyses/UA1_1990_S2044935.cc
	--- a/src/Analyses/UA1_1990_S2044935.cc
	+++ b/src/Analyses/UA1_1990_S2044935.cc
	@@ -1,177 +1,177 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/FinalState.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/MissingMomentum.hh"

	namespace Rivet {


	/// @brief UA1 minbias track multiplicities, \f$ p_\perp \f$ and \f$ E_\perp \f$
	class UA1_1990_S2044935 : public Analysis {
	public:

	/// Constructor
	UA1_1990_S2044935() : Analysis("UA1_1990_S2044935") {
	_sumwTrig = 0;
	_sumwTrig08 = 0;
	_sumwTrig40 = 0;
	_sumwTrig80 = 0;
	}


	/// @name Analysis methods
	//@{

	/// Book projections and histograms
	void init() {
	- addProjection(ChargedFinalState(-5.5, 5.5), "TriggerFS");
	- addProjection(ChargedFinalState(-2.5, 2.5), "TrackFS");
	+ declare(ChargedFinalState(-5.5, 5.5), "TriggerFS");
	+ declare(ChargedFinalState(-2.5, 2.5), "TrackFS");
	const FinalState trkcalofs(-2.5, 2.5);
	- addProjection(MissingMomentum(trkcalofs), "MET25");
	+ declare(MissingMomentum(trkcalofs), "MET25");
	const FinalState calofs(-6.0, 6.0);
	- addProjection(MissingMomentum(calofs), "MET60");
	+ declare(MissingMomentum(calofs), "MET60");

	if (fuzzyEquals(sqrtS()/GeV, 63)) {
	_hist_Pt = bookProfile1D(8,1,1);
	} else if (fuzzyEquals(sqrtS()/GeV, 200)) {
	_hist_Nch = bookHisto1D(1,1,1);
	_hist_Esigd3p = bookHisto1D(2,1,1);
	_hist_Pt = bookProfile1D(6,1,1);
	_hist_Et = bookHisto1D(9,1,1);
	_hist_Etavg = bookProfile1D(12,1,1);
	} else if (fuzzyEquals(sqrtS()/GeV, 500)) {
	_hist_Nch = bookHisto1D(1,1,2);
	_hist_Esigd3p = bookHisto1D(2,1,2);
	_hist_Et = bookHisto1D(10,1,1);
	_hist_Etavg = bookProfile1D(12,1,2);
	} else if (fuzzyEquals(sqrtS()/GeV, 900)) {
	_hist_Nch = bookHisto1D(1,1,3);
	_hist_Esigd3p = bookHisto1D(2,1,3);
	_hist_Pt = bookProfile1D(7,1,1);
	_hist_Et = bookHisto1D(11,1,1);
	_hist_Etavg = bookProfile1D(12,1,3);
	_hist_Esigd3p08 = bookHisto1D(3,1,1);
	_hist_Esigd3p40 = bookHisto1D(4,1,1);
	_hist_Esigd3p80 = bookHisto1D(5,1,1);
	}

	}


	void analyze(const Event& event) {
	// Trigger
	- const FinalState& trigfs = applyProjection<FinalState>(event, "TriggerFS");
	+ const FinalState& trigfs = apply<FinalState>(event, "TriggerFS");
	unsigned int n_minus(0), n_plus(0);
	foreach (const Particle& p, trigfs.particles()) {
	const double eta = p.eta();
	if (inRange(eta, -5.5, -1.5)) n_minus++;
	else if (inRange(eta, 1.5, 5.5)) n_plus++;
	}
	MSG_DEBUG("Trigger -: " << n_minus << ", Trigger +: " << n_plus);
	if (n_plus == 0 \|\| n_minus == 0) vetoEvent;
	const double weight = event.weight();
	_sumwTrig += weight;

	// Use good central detector tracks
	- const FinalState& cfs = applyProjection<FinalState>(event, "TrackFS");
	- const double Et25 = applyProjection<MissingMomentum>(event, "MET25").scalarEt();
	- const double Et60 = applyProjection<MissingMomentum>(event, "MET60").scalarEt();
	+ const FinalState& cfs = apply<FinalState>(event, "TrackFS");
	+ const double Et25 = apply<MissingMomentum>(event, "MET25").scalarEt();
	+ const double Et60 = apply<MissingMomentum>(event, "MET60").scalarEt();
	const unsigned int nch = cfs.size();

	// Event level histos
	if (!fuzzyEquals(sqrtS()/GeV, 63, 1E-3)) {
	_hist_Nch->fill(nch, weight);
	_hist_Et->fill(Et60/GeV, weight);
	_hist_Etavg->fill(nch, Et25/GeV, weight);
	}

	// Particle/track level histos
	const double deta = 2 * 5.0;
	const double dphi = TWOPI;
	const double dnch_deta = nch/deta;
	foreach (const Particle& p, cfs.particles()) {
	const double pt = p.pT();
	const double scaled_weight = weight/(detadphipt/GeV);
	if (!fuzzyEquals(sqrtS()/GeV, 500, 1E-3)) {
	_hist_Pt->fill(nch, pt/GeV, weight);
	}
	if (!fuzzyEquals(sqrtS()/GeV, 63, 1E-3)) {
	_hist_Esigd3p->fill(pt/GeV, scaled_weight);
	}
	// Also fill for specific dn/deta ranges at 900 GeV
	if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) {
	if (inRange(dnch_deta, 0.8, 4.0)) {
	_sumwTrig08 += weight;
	_hist_Esigd3p08->fill(pt/GeV, scaled_weight);
	} else if (inRange(dnch_deta, 4.0, 8.0)) {
	_sumwTrig40 += weight;
	_hist_Esigd3p40->fill(pt/GeV, scaled_weight);
	} else {
	//MSG_WARNING(dnch_deta);
	if (dnch_deta > 8.0) {
	_sumwTrig80 += weight;
	_hist_Esigd3p80->fill(pt/GeV, scaled_weight);
	}
	}
	}
	}

	}


	void finalize() {
	if (_sumwTrig <= 0) {
	MSG_WARNING("No events passed the trigger!");
	return;
	}
	const double xsec = crossSectionPerEvent();
	if (!fuzzyEquals(sqrtS()/GeV, 63, 1E-3)) {
	scale(_hist_Nch, 2*xsec/millibarn); ///< Factor of 2 for Nch bin widths?
	scale(_hist_Esigd3p, xsec/millibarn);
	scale(_hist_Et, xsec/millibarn);
	}
	if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) {
	// NB. Ref data is normalised to a fixed value not reproducible from MC.
	const double scale08 = (_hist_Esigd3p08->bin(0).area() > 0) ?
	0.933e5/_hist_Esigd3p08->bin(0).height() : 0;
	scale(_hist_Esigd3p08, scale08);
	const double scale40 = (_hist_Esigd3p40->bin(0).area() > 0) ?
	1.369e5/_hist_Esigd3p40->bin(0).height() : 0;
	scale(_hist_Esigd3p40, scale40);
	const double scale80 = (_hist_Esigd3p80->bin(0).area() > 0) ?
	1.657e5/_hist_Esigd3p80->bin(0).height() : 0;
	scale(_hist_Esigd3p80, scale80);
	}
	}

	//@}


	private:

	/// @name Weight counters
	//@{
	double _sumwTrig, _sumwTrig08, _sumwTrig40, _sumwTrig80;
	//@}

	/// @name Histogram collections
	//@{
	Histo1DPtr _hist_Nch;
	Histo1DPtr _hist_Esigd3p;
	Histo1DPtr _hist_Esigd3p08;
	Histo1DPtr _hist_Esigd3p40;
	Histo1DPtr _hist_Esigd3p80;
	Profile1DPtr _hist_Pt;
	Profile1DPtr _hist_Etavg;
	Histo1DPtr _hist_Et;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(UA1_1990_S2044935);

	}
	diff --git a/src/Analyses/UA5_1982_S875503.cc b/src/Analyses/UA5_1982_S875503.cc
	--- a/src/Analyses/UA5_1982_S875503.cc
	+++ b/src/Analyses/UA5_1982_S875503.cc
	@@ -1,93 +1,93 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/TriggerUA5.hh"

	namespace Rivet {


	/// @brief UA5 multiplicity and \f$ \eta \f$ distributions
	class UA5_1982_S875503 : public Analysis {
	public:

	/// Default constructor
	UA5_1982_S875503() : Analysis("UA5_1982_S875503") {
	_sumWTrig = 0;
	}


	/// @name Analysis methods
	//@{

	/// Set up projections and book histos
	void init() {
	- addProjection(TriggerUA5(), "Trigger");
	- addProjection(ChargedFinalState(-3.5, 3.5), "CFS");
	+ declare(TriggerUA5(), "Trigger");
	+ declare(ChargedFinalState(-3.5, 3.5), "CFS");

	// Book histos based on pp or ppbar beams
	if (beamIds().first == beamIds().second) {
	_hist_nch = bookHisto1D(2,1,1);
	_hist_eta = bookHisto1D(3,1,1);
	} else {
	_hist_nch = bookHisto1D(2,1,2);
	_hist_eta = bookHisto1D(4,1,1);
	}
	}


	void analyze(const Event& event) {
	// Trigger
	- const TriggerUA5& trigger = applyProjection<TriggerUA5>(event, "Trigger");
	+ const TriggerUA5& trigger = apply<TriggerUA5>(event, "Trigger");
	if (!trigger.nsdDecision()) vetoEvent;
	const double weight = event.weight();
	_sumWTrig += weight;

	// Get tracks
	- const ChargedFinalState& cfs = applyProjection<ChargedFinalState>(event, "CFS");
	+ const ChargedFinalState& cfs = apply<ChargedFinalState>(event, "CFS");

	// Fill mean charged multiplicity histos
	_hist_nch->fill(_hist_nch->bin(0).xMid(), cfs.size()*weight);

	// Iterate over all tracks and fill eta histograms
	foreach (const Particle& p, cfs.particles()) {
	const double eta = p.abseta();
	_hist_eta->fill(eta, weight);
	}

	}


	void finalize() {
	/// @todo Why the factor of 2 on Nch for ppbar?
	if (beamIds().first == beamIds().second) {
	scale(_hist_nch, 1.0/_sumWTrig);
	} else {
	scale(_hist_nch, 0.5/_sumWTrig);
	}
	scale(_hist_eta, 0.5/_sumWTrig);
	}

	//@}


	private:

	/// @name Counters
	//@{
	double _sumWTrig;
	//@}

	/// @name Histogram collections
	//@{
	Histo1DPtr _hist_nch;
	Histo1DPtr _hist_eta;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(UA5_1982_S875503);

	}
	diff --git a/src/Analyses/UA5_1986_S1583476.cc b/src/Analyses/UA5_1986_S1583476.cc
	--- a/src/Analyses/UA5_1986_S1583476.cc
	+++ b/src/Analyses/UA5_1986_S1583476.cc
	@@ -1,119 +1,119 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/TriggerUA5.hh"

	namespace Rivet {


	/// @brief UA5 \f$ \eta \f$ distributions at 200 and 900 GeV
	class UA5_1986_S1583476 : public Analysis {
	public:

	/// Constructor
	UA5_1986_S1583476() : Analysis("UA5_1986_S1583476") {
	_sumWTrig = 0;
	_sumWTrigNSD = 0;
	}


	/// @name Analysis methods
	//@{

	/// Set up projections and histograms
	void init() {
	- addProjection(TriggerUA5(), "Trigger");
	- addProjection(Beam(), "Beams");
	- addProjection(ChargedFinalState(-5.0, 5.0), "CFS50");
	+ declare(TriggerUA5(), "Trigger");
	+ declare(Beam(), "Beams");
	+ declare(ChargedFinalState(-5.0, 5.0), "CFS50");

	// Histograms
	if (fuzzyEquals(sqrtS()/GeV, 200.0, 1E-4)) {
	_hist_eta_nsd = bookHisto1D(1,1,1);
	_hist_eta_inelastic = bookHisto1D(1,1,2);
	for (int i = 1; i <= 6; ++i) {
	_sumWn += 0.0;
	_hists_eta_nsd += bookHisto1D(2,1,i);
	}
	} else if (fuzzyEquals(sqrtS()/GeV, 900.0, 1E-4)) {
	_hist_eta_nsd = bookHisto1D(1,1,3);
	_hist_eta_inelastic = bookHisto1D(1,1,4);
	for (int i = 1; i <= 9; ++i) {
	_sumWn += 0.0;
	_hists_eta_nsd += bookHisto1D(3,1,i);
	}
	}
	}


	/// Fill eta histograms (in Nch bins)
	void analyze(const Event& event) {
	// Trigger
	- const TriggerUA5& trigger = applyProjection<TriggerUA5>(event, "Trigger");
	+ const TriggerUA5& trigger = apply<TriggerUA5>(event, "Trigger");
	if (!trigger.sdDecision()) vetoEvent;
	const bool isNSD = trigger.nsdDecision();

	// Get the index corresponding to the max Nch range histo/sum(w) vector index
	- const ChargedFinalState& cfs50 = applyProjection<ChargedFinalState>(event, "CFS50");
	+ const ChargedFinalState& cfs50 = apply<ChargedFinalState>(event, "CFS50");
	const int numP = cfs50.size();
	const int ni = (int)floor(static_cast<float>(numP-2)/10.0);
	const int num_idx = min(ni, (int)_sumWn.size()-1);
	MSG_TRACE("Multiplicity index: " << numP << " charged particles -> #" << num_idx);

	// Update weights
	const double weight = event.weight();
	_sumWTrig += weight;
	if (isNSD) {
	_sumWTrigNSD += weight;
	if (num_idx >= 0) _sumWn[num_idx] += weight;
	}

	// Fill histos
	foreach (const Particle& p, cfs50.particles()) {
	const double eta = p.abseta();
	_hist_eta_inelastic->fill(eta, weight);
	if (isNSD) {
	_hist_eta_nsd->fill(eta, weight);
	if (num_idx >= 0) _hists_eta_nsd[num_idx]->fill(eta, weight);
	}
	}
	}


	/// Scale histos
	void finalize() {
	MSG_DEBUG("sumW_NSD,inel = " << _sumWTrigNSD << ", " << _sumWTrig);
	scale(_hist_eta_nsd, 0.5/_sumWTrigNSD);
	scale(_hist_eta_inelastic, 0.5/_sumWTrig);
	//
	MSG_DEBUG("sumW[n] = " << _sumWn);
	for (size_t i = 0; i < _hists_eta_nsd.size(); ++i) {
	scale(_hists_eta_nsd[i], 0.5/_sumWn[i]);
	}
	}


	private:

	/// @name Weight counters
	//@{
	double _sumWTrig;
	double _sumWTrigNSD;
	vector<double> _sumWn;
	//@}

	/// @name Histograms
	//@{
	Histo1DPtr _hist_eta_nsd;
	Histo1DPtr _hist_eta_inelastic;
	vector<Histo1DPtr> _hists_eta_nsd;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(UA5_1986_S1583476);

	}
	diff --git a/src/Analyses/UA5_1987_S1640666.cc b/src/Analyses/UA5_1987_S1640666.cc
	--- a/src/Analyses/UA5_1987_S1640666.cc
	+++ b/src/Analyses/UA5_1987_S1640666.cc
	@@ -1,73 +1,73 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/TriggerUA5.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"

	namespace Rivet {


	class UA5_1987_S1640666 : public Analysis {
	public:

	/// Constructor
	UA5_1987_S1640666()
	: Analysis("UA5_1987_S1640666")
	{
	_sumWPassed = 0;

	}

	/// Book histograms and initialise projections before the run
	void init() {
	- addProjection(TriggerUA5(), "Trigger");
	- addProjection(ChargedFinalState(-5.0, 5.0), "CFS");
	+ declare(TriggerUA5(), "Trigger");
	+ declare(ChargedFinalState(-5.0, 5.0), "CFS");

	_hist_mean_nch = bookHisto1D(1, 1, 1);
	_hist_nch = bookHisto1D(3, 1, 1);

	}


	/// Perform the per-event analysis
	void analyze(const Event& event) {
	// Trigger
	- const TriggerUA5& trigger = applyProjection<TriggerUA5>(event, "Trigger");
	+ const TriggerUA5& trigger = apply<TriggerUA5>(event, "Trigger");
	if (!trigger.nsdDecision()) vetoEvent;

	const double weight = event.weight();
	_sumWPassed += weight;

	// Count final state particles in several eta regions
	- const int Nch = applyProjection<ChargedFinalState>(event, "CFS").size();
	+ const int Nch = apply<ChargedFinalState>(event, "CFS").size();

	// Fill histograms
	_hist_nch->fill(Nch, weight);
	_hist_mean_nch->fill(_hist_mean_nch->bin(0).xMid(), Nch*weight);

	}


	/// Normalise histograms etc., after the run
	void finalize() {

	scale(_hist_nch, 1.0/_sumWPassed);
	scale(_hist_mean_nch, 1.0/_sumWPassed);

	}

	private:

	double _sumWPassed;

	Histo1DPtr _hist_mean_nch;
	Histo1DPtr _hist_nch;

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(UA5_1987_S1640666);


	}
	diff --git a/src/Analyses/UA5_1988_S1867512.cc b/src/Analyses/UA5_1988_S1867512.cc
	--- a/src/Analyses/UA5_1988_S1867512.cc
	+++ b/src/Analyses/UA5_1988_S1867512.cc
	@@ -1,193 +1,193 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/TriggerUA5.hh"

	namespace Rivet {


	namespace {
	/// @brief Helper function to fill correlation points into scatter plot
	Point2D correlation_helper(double x, double xerr, const vector<int> & nf, const vector<int> & nb, double sumWPassed) {
	return Point2D(x, correlation(nf, nb), xerr, correlation_err(nf, nb)/sqrt(sumWPassed));
	}
	}


	/// @brief UA5 charged particle correlations at 200, 546 and 900 GeV
	class UA5_1988_S1867512 : public Analysis {
	public:

	UA5_1988_S1867512()
	: Analysis("UA5_1988_S1867512"), _sumWPassed(0)
	{ }


	/// @name Analysis methods
	//@{

	void init() {
	// Projections
	- addProjection(TriggerUA5(), "Trigger");
	+ declare(TriggerUA5(), "Trigger");

	// Symmetric eta interval
	- addProjection(ChargedFinalState(-0.5, 0.5), "CFS05");
	+ declare(ChargedFinalState(-0.5, 0.5), "CFS05");

	// Asymmetric intervals first
	// Forward eta intervals
	- addProjection(ChargedFinalState(0.0, 1.0), "CFS10F");
	- addProjection(ChargedFinalState(0.5, 1.5), "CFS15F");
	- addProjection(ChargedFinalState(1.0, 2.0), "CFS20F");
	- addProjection(ChargedFinalState(1.5, 2.5), "CFS25F");
	- addProjection(ChargedFinalState(2.0, 3.0), "CFS30F");
	- addProjection(ChargedFinalState(2.5, 3.5), "CFS35F");
	- addProjection(ChargedFinalState(3.0, 4.0), "CFS40F");
	+ declare(ChargedFinalState(0.0, 1.0), "CFS10F");
	+ declare(ChargedFinalState(0.5, 1.5), "CFS15F");
	+ declare(ChargedFinalState(1.0, 2.0), "CFS20F");
	+ declare(ChargedFinalState(1.5, 2.5), "CFS25F");
	+ declare(ChargedFinalState(2.0, 3.0), "CFS30F");
	+ declare(ChargedFinalState(2.5, 3.5), "CFS35F");
	+ declare(ChargedFinalState(3.0, 4.0), "CFS40F");

	// Backward eta intervals
	- addProjection(ChargedFinalState(-1.0, 0.0), "CFS10B");
	- addProjection(ChargedFinalState(-1.5, -0.5), "CFS15B");
	- addProjection(ChargedFinalState(-2.0, -1.0), "CFS20B");
	- addProjection(ChargedFinalState(-2.5, -1.5), "CFS25B");
	- addProjection(ChargedFinalState(-3.0, -2.0), "CFS30B");
	- addProjection(ChargedFinalState(-3.5, -2.5), "CFS35B");
	- addProjection(ChargedFinalState(-4.0, -3.0), "CFS40B");
	+ declare(ChargedFinalState(-1.0, 0.0), "CFS10B");
	+ declare(ChargedFinalState(-1.5, -0.5), "CFS15B");
	+ declare(ChargedFinalState(-2.0, -1.0), "CFS20B");
	+ declare(ChargedFinalState(-2.5, -1.5), "CFS25B");
	+ declare(ChargedFinalState(-3.0, -2.0), "CFS30B");
	+ declare(ChargedFinalState(-3.5, -2.5), "CFS35B");
	+ declare(ChargedFinalState(-4.0, -3.0), "CFS40B");

	// Histogram booking, we have sqrt(s) = 200, 546 and 900 GeV
	// TODO use Scatter2D to be able to output errors
	if (fuzzyEquals(sqrtS()/GeV, 200.0, 1E-4)) {
	_hist_correl = bookScatter2D(2, 1, 1);
	_hist_correl_asym = bookScatter2D(3, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 546.0, 1E-4)) {
	_hist_correl = bookScatter2D(2, 1, 2);
	_hist_correl_asym = bookScatter2D(3, 1, 2);
	} else if (fuzzyEquals(sqrtS()/GeV, 900.0, 1E-4)) {
	_hist_correl = bookScatter2D(2, 1, 3);
	_hist_correl_asym = bookScatter2D(3, 1, 3);
	}
	}


	void analyze(const Event& event) {
	// Trigger
	- const bool trigger = applyProjection<TriggerUA5>(event, "Trigger").nsdDecision();
	+ const bool trigger = apply<TriggerUA5>(event, "Trigger").nsdDecision();
	if (!trigger) vetoEvent;
	_sumWPassed += event.weight();

	// Count forward/backward particles
	- n_10f.push_back(applyProjection<ChargedFinalState>(event, "CFS10F").size());
	- n_15f.push_back(applyProjection<ChargedFinalState>(event, "CFS15F").size());
	- n_20f.push_back(applyProjection<ChargedFinalState>(event, "CFS20F").size());
	- n_25f.push_back(applyProjection<ChargedFinalState>(event, "CFS25F").size());
	- n_30f.push_back(applyProjection<ChargedFinalState>(event, "CFS30F").size());
	- n_35f.push_back(applyProjection<ChargedFinalState>(event, "CFS35F").size());
	- n_40f.push_back(applyProjection<ChargedFinalState>(event, "CFS40F").size());
	+ n_10f.push_back(apply<ChargedFinalState>(event, "CFS10F").size());
	+ n_15f.push_back(apply<ChargedFinalState>(event, "CFS15F").size());
	+ n_20f.push_back(apply<ChargedFinalState>(event, "CFS20F").size());
	+ n_25f.push_back(apply<ChargedFinalState>(event, "CFS25F").size());
	+ n_30f.push_back(apply<ChargedFinalState>(event, "CFS30F").size());
	+ n_35f.push_back(apply<ChargedFinalState>(event, "CFS35F").size());
	+ n_40f.push_back(apply<ChargedFinalState>(event, "CFS40F").size());
	//
	- n_10b.push_back(applyProjection<ChargedFinalState>(event, "CFS10B").size());
	- n_15b.push_back(applyProjection<ChargedFinalState>(event, "CFS15B").size());
	- n_20b.push_back(applyProjection<ChargedFinalState>(event, "CFS20B").size());
	- n_25b.push_back(applyProjection<ChargedFinalState>(event, "CFS25B").size());
	- n_30b.push_back(applyProjection<ChargedFinalState>(event, "CFS30B").size());
	- n_35b.push_back(applyProjection<ChargedFinalState>(event, "CFS35B").size());
	- n_40b.push_back(applyProjection<ChargedFinalState>(event, "CFS40B").size());
	+ n_10b.push_back(apply<ChargedFinalState>(event, "CFS10B").size());
	+ n_15b.push_back(apply<ChargedFinalState>(event, "CFS15B").size());
	+ n_20b.push_back(apply<ChargedFinalState>(event, "CFS20B").size());
	+ n_25b.push_back(apply<ChargedFinalState>(event, "CFS25B").size());
	+ n_30b.push_back(apply<ChargedFinalState>(event, "CFS30B").size());
	+ n_35b.push_back(apply<ChargedFinalState>(event, "CFS35B").size());
	+ n_40b.push_back(apply<ChargedFinalState>(event, "CFS40B").size());
	//
	- n_05 .push_back(applyProjection<ChargedFinalState>(event, "CFS05").size());
	+ n_05 .push_back(apply<ChargedFinalState>(event, "CFS05").size());
	}


	void finalize() {
	// The correlation strength is defined in formulas
	// 4.1 and 4.2

	// Fill histos, gap width histo comes first
	// * Set the errors as Delta b / sqrt(sumWPassed) with
	// Delta b being the absolute uncertainty of b according to
	// Gaussian error-propagation (linear limit) and assuming
	// Poissonian uncertainties for the number of particles in
	// the eta-intervals
	//

	// Define vectors to be able to fill Scatter2Ds
	vector<Point2D> points;
	// Fill the y-value vector
	points.push_back(correlation_helper(0, 0.5, n_10f, n_10b, _sumWPassed));
	points.push_back(correlation_helper(1, 0.5, n_15f, n_15b, _sumWPassed));
	points.push_back(correlation_helper(2, 0.5, n_20f, n_20b, _sumWPassed));
	points.push_back(correlation_helper(3, 0.5, n_25f, n_25b, _sumWPassed));
	points.push_back(correlation_helper(4, 0.5, n_30f, n_30b, _sumWPassed));
	points.push_back(correlation_helper(5, 0.5, n_35f, n_35b, _sumWPassed));
	points.push_back(correlation_helper(6, 0.5, n_40f, n_40b, _sumWPassed));

	// Fill the DPS
	_hist_correl->addPoints(points);

	// Fill gap-center histo (Fig 15)
	//
	// The first bin contains the c_str strengths of
	// the gap size histo that has ane eta gap of two
	//
	// Now do the other histo -- clear already defined vectors first
	points.clear();

	points.push_back(correlation_helper(0, 0.25, n_20f, n_20b, _sumWPassed));
	points.push_back(correlation_helper(0.5, 0.25, n_25f, n_15b, _sumWPassed));
	points.push_back(correlation_helper(1, 0.25, n_30f, n_10b, _sumWPassed));
	points.push_back(correlation_helper(1.5, 0.25, n_35f, n_05 , _sumWPassed));
	points.push_back(correlation_helper(2, 0.25, n_40f, n_10f, _sumWPassed));

	// Fill in correlation strength for assymetric intervals,
	// see Tab. 5
	// Fill the DPS
	_hist_correl_asym->addPoints(points);
	}

	//@}


	private:

	/// @name Counters
	//@{
	double _sumWPassed;
	//@}


	/// @name Vectors for storing the number of particles in the different eta intervals per event.
	/// @todo Is there a better way?
	//@{
	std::vector<int> n_10f;
	std::vector<int> n_15f;
	std::vector<int> n_20f;
	std::vector<int> n_25f;
	std::vector<int> n_30f;
	std::vector<int> n_35f;
	std::vector<int> n_40f;
	//
	std::vector<int> n_10b;
	std::vector<int> n_15b;
	std::vector<int> n_20b;
	std::vector<int> n_25b;
	std::vector<int> n_30b;
	std::vector<int> n_35b;
	std::vector<int> n_40b;
	//
	std::vector<int> n_05;
	//@}


	/// @name Histograms
	//@{
	// Symmetric eta intervals
	Scatter2DPtr _hist_correl;
	// For asymmetric eta intervals
	Scatter2DPtr _hist_correl_asym;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(UA5_1988_S1867512);

	}
	diff --git a/src/Analyses/UA5_1989_S1926373.cc b/src/Analyses/UA5_1989_S1926373.cc
	--- a/src/Analyses/UA5_1989_S1926373.cc
	+++ b/src/Analyses/UA5_1989_S1926373.cc
	@@ -1,112 +1,112 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/ChargedFinalState.hh"
	#include "Rivet/Projections/TriggerUA5.hh"

	namespace Rivet {


	/// @brief UA5 min bias charged multiplicities in central \f$ \eta \f$ ranges
	class UA5_1989_S1926373 : public Analysis {
	public:

	/// Constructor
	UA5_1989_S1926373() : Analysis("UA5_1989_S1926373") {
	_sumWPassed = 0;
	}


	/// @name Analysis methods
	//@{

	/// Book histograms and projections
	void init() {
	- addProjection(TriggerUA5(), "Trigger");
	- addProjection(ChargedFinalState(-0.5, 0.5), "CFS05");
	- addProjection(ChargedFinalState(-1.5, 1.5), "CFS15");
	- addProjection(ChargedFinalState(-3.0, 3.0), "CFS30");
	- addProjection(ChargedFinalState(-5.0, 5.0), "CFS50");
	+ declare(TriggerUA5(), "Trigger");
	+ declare(ChargedFinalState(-0.5, 0.5), "CFS05");
	+ declare(ChargedFinalState(-1.5, 1.5), "CFS15");
	+ declare(ChargedFinalState(-3.0, 3.0), "CFS30");
	+ declare(ChargedFinalState(-5.0, 5.0), "CFS50");

	// NB. _hist_nch and _hist_ncheta50 use the same data but different binning
	if (fuzzyEquals(sqrtS()/GeV, 200, 1E-3)) {
	_hist_nch = bookHisto1D(1, 1, 1);
	_hist_nch_eta05 = bookHisto1D(3, 1, 1);
	_hist_nch_eta15 = bookHisto1D(4, 1, 1);
	_hist_nch_eta30 = bookHisto1D(5, 1, 1);
	_hist_nch_eta50 = bookHisto1D(6, 1, 1);
	_hist_mean_nch = bookHisto1D(11, 1, 1);
	} else if (fuzzyEquals(sqrtS()/GeV, 900, 1E-3)) {
	_hist_nch = bookHisto1D(2, 1, 1);
	_hist_nch_eta05 = bookHisto1D(7, 1, 1);
	_hist_nch_eta15 = bookHisto1D(8, 1, 1);
	_hist_nch_eta30 = bookHisto1D(9, 1, 1);
	_hist_nch_eta50 = bookHisto1D(10, 1, 1);
	_hist_mean_nch = bookHisto1D(12, 1, 1);
	}

	/// @todo Moments of distributions
	}


	/// Do the analysis
	void analyze(const Event& event) {
	// Trigger
	- const TriggerUA5& trigger = applyProjection<TriggerUA5>(event, "Trigger");
	+ const TriggerUA5& trigger = apply<TriggerUA5>(event, "Trigger");
	if (!trigger.nsdDecision()) vetoEvent;

	const double weight = event.weight();
	_sumWPassed += weight;

	// Count final state particles in several eta regions
	- const int numP05 = applyProjection<ChargedFinalState>(event, "CFS05").size();
	- const int numP15 = applyProjection<ChargedFinalState>(event, "CFS15").size();
	- const int numP30 = applyProjection<ChargedFinalState>(event, "CFS30").size();
	- const int numP50 = applyProjection<ChargedFinalState>(event, "CFS50").size();
	+ const int numP05 = apply<ChargedFinalState>(event, "CFS05").size();
	+ const int numP15 = apply<ChargedFinalState>(event, "CFS15").size();
	+ const int numP30 = apply<ChargedFinalState>(event, "CFS30").size();
	+ const int numP50 = apply<ChargedFinalState>(event, "CFS50").size();

	// Fill histograms
	_hist_nch->fill(numP50, weight);
	_hist_nch_eta05->fill(numP05, weight);
	_hist_nch_eta15->fill(numP15, weight);
	_hist_nch_eta30->fill(numP30, weight);
	_hist_nch_eta50->fill(numP50, weight);
	_hist_mean_nch->fill(_hist_mean_nch->bin(0).xMid(), numP50*weight);
	}


	void finalize() {
	scale(_hist_nch, 1.0/_sumWPassed);
	scale(_hist_nch_eta05, 1.0/_sumWPassed);
	scale(_hist_nch_eta15, 1.0/_sumWPassed);
	scale(_hist_nch_eta30, 1.0/_sumWPassed);
	scale(_hist_nch_eta50, 1.0/_sumWPassed);
	scale(_hist_mean_nch, 1.0/_sumWPassed);
	}

	//@}


	private:

	/// @name Counters
	//@{
	double _sumWPassed;
	//@}

	/// @name Histograms
	//@{
	Histo1DPtr _hist_nch;
	Histo1DPtr _hist_nch_eta05;
	Histo1DPtr _hist_nch_eta15;
	Histo1DPtr _hist_nch_eta30;
	Histo1DPtr _hist_nch_eta50;
	Histo1DPtr _hist_mean_nch;
	//@}

	};



	// The hook for the plugin system
	DECLARE_RIVET_PLUGIN(UA5_1989_S1926373);

	}
	diff --git a/src/Analyses/ZEUS_2001_S4815815.cc b/src/Analyses/ZEUS_2001_S4815815.cc
	--- a/src/Analyses/ZEUS_2001_S4815815.cc
	+++ b/src/Analyses/ZEUS_2001_S4815815.cc
	@@ -1,166 +1,178 @@
	// -- C++ --
	#include "Rivet/Analysis.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "Rivet/Projections/IdentifiedFinalState.hh"
	#include "Rivet/Projections/FastJets.hh"

	namespace Rivet {


	/// @brief ZEUS dijet photoproduction study used in the ZEUS jets PDF fit
	///
	/// This class is a reproduction of the HZTool routine for the ZEUS
	/// dijet photoproduction paper which was used in the ZEUS jets PDF fit.
	///
	- /// @author Jon Butterworth
	+ /// @note Cleaning cuts on event pT/sqrt(Et) and y_e are not needed in MC analysis.
	+ ///
	+ /// @author Andy Buckley
	class ZEUS_2001_S4815815 : public Analysis {
	public:

	/// Constructor
	- ZEUS_2001_S4815815()
	- : Analysis("ZEUS_2001_S4815815")
	- { }
	-
	+ DEFAULT_RIVET_ANALYSIS_CTOR(ZEUS_2001_S4815815);

	/// @name Analysis methods
	//@{

	// Book projections and histograms
	void init() {
	- /// @todo Force conventional event rotation with proton along +z?
	+
	+ /// @todo Acceptance
	FinalState fs;
	- addProjection(FastJets(fs, FastJets::KT, 0.7), "Jets");
	+ declare(FastJets(fs, FastJets::KT, 1.0), "Jets"); //< R=1 checked with Matt Wing

	+ /// @todo Dress the lepton?
	IdentifiedFinalState positrons(fs, PID::POSITRON);
	- addProjection(positrons, "Positrons");
	+ declare(positrons, "Positrons");

	// Table 1
	_h_costh[0] = bookHisto1D(1, 1, 1);
	_h_costh[1] = bookHisto1D(1, 1, 2);
	// Table 2
	_h_etjet1[1][0] = bookHisto1D(2, 1, 1);
	_h_etjet1[1][1] = bookHisto1D(3, 1, 1);
	_h_etjet1[1][2] = bookHisto1D(4, 1, 1);
	_h_etjet1[1][3] = bookHisto1D(5, 1, 1);
	_h_etjet1[1][4] = bookHisto1D(6, 1, 1);
	_h_etjet1[1][5] = bookHisto1D(7, 1, 1);
	// Table 3
	_h_etjet1[0][0] = bookHisto1D(8, 1, 1);
	_h_etjet1[0][1] = bookHisto1D(9, 1, 1);
	_h_etjet1[0][2] = bookHisto1D(10, 1, 1);
	_h_etjet1[0][3] = bookHisto1D(11, 1, 1);
	_h_etjet1[0][4] = bookHisto1D(12, 1, 1);
	_h_etjet1[0][5] = bookHisto1D(13, 1, 1);
	// Table 4
	_h_etajet2[1][0] = bookHisto1D(14, 1, 1);
	_h_etajet2[1][1] = bookHisto1D(15, 1, 1);
	_h_etajet2[1][2] = bookHisto1D(16, 1, 1);
	// Table 5
	_h_etajet2[0][0] = bookHisto1D(17, 1, 1);
	_h_etajet2[0][1] = bookHisto1D(18, 1, 1);
	_h_etajet2[0][2] = bookHisto1D(19, 1, 1);
	// Table 6
	_h_xobsy[0] = bookHisto1D(20, 1, 1);
	_h_xobsy[1] = bookHisto1D(21, 1, 1);
	_h_xobsy[2] = bookHisto1D(22, 1, 1);
	_h_xobsy[3] = bookHisto1D(23, 1, 1);
	}


	// Do the analysis
	void analyze(const Event& event) {

	+ // Determine event orientation, since coord system is for +z = proton direction
	+ const ParticlePair bs = event.beams();
	+ if (bs.first.pid() != PID::POSITRON && bs.second.pid() != PID::POSITRON) vetoEvent;
	+ const Particle& bpositron = (bs.first.pid() == PID::POSITRON ? bs.first : bs.second);
	+ if (bs.first.pid() != PID::PROTON && bs.second.pid() != PID::PROTON) vetoEvent;
	+ const Particle& bproton = (bs.first.pid() == PID::PROTON) ? bs.first : bs.second;
	+ const int orientation = sign(bproton.momentum().pz());
	+ MSG_DEBUG("Beam proton = " << bproton.mom() << " GeV => orientation = " << orientation);
	+
	// Jet selection
	- const Jets jets = applyProjection<FastJets>(event, "Jets").jets(Cuts::pT > 11*GeV && Cuts::etaIn(-1, 2.4), cmpMomByEt);
	+ const Jets jets = apply<FastJets>(event, "Jets") \
	+ .jets(Cuts::pT > 11GeV && Cuts::etaIn(-1orientation, 2.4*orientation), cmpMomByEt);
	+ MSG_DEBUG("Jet multiplicity = " << jets.size());
	if (jets.size() < 2) vetoEvent;
	- if (jets[0].pT() < 14*GeV) vetoEvent;
	- MSG_DEBUG("Jet multiplicity = " << jets.size());
	-
	- /// @todo Cut on pT/sqrt(Et)?
	-
	- // Leading jets and etabar & cos(theta*) computation
	const Jet& j1 = jets[0];
	const Jet& j2 = jets[1];
	- const double etabar = (j1.eta() - j2.eta())/2.;
	- const double costhetastar = tanh(etabar);
	+ if (j1.pT() < 14*GeV) vetoEvent;

	- // Get the scattered positron candidate
	- const Particles positrons = applyProjection<FinalState>(event, "Positrons").particlesByPt();
	+ // eta and cos(theta*) computation
	+ const double eta1 = orientationj1.eta(), eta2 = orientationj2.eta();
	+ const double etabar = (eta1 + eta2)/2;
	+ const double etadiff = eta1 - eta2;
	+ const double costhetastar = tanh(etadiff/2);
	+
	+ // Get the scattered positron
	+ const Particles positrons = apply<FinalState>(event, "Positrons").particlesByPt();
	if (positrons.empty()) vetoEvent;
	- const Particle& positron = positrons[0];
	- const double Eeprime = positron.E();
	+ const Particle& positron = positrons.front();

	- // Get the beams, for kinematics extraction
	- const ParticlePair bs = beams();
	- const double Ee = (bs.first.pid() == PID::POSITRON ? bs.first : bs.second).E();
	+ // Calculate the photon 4-vector
	+ const FourMomentum qphoton = positron.mom() - bpositron.mom();

	- // Cuts on inelasticity y, and computation of x_y^obs
	- const double inelasticity = 1 - (Eeprime/Ee/2.0)*(1 - positron.theta());
	- if (!inRange(inelasticity, 0.2, 0.85)) vetoEvent; ///< @note The cuts on y_e and Y_JB look contradictory! These are just y_JB
	- const double xyobs = (j1.Et() * exp(-j1.eta()) + j2.Et() * exp(-j2.eta())) / (2inelasticityEe);
	+ // Computation and cut on inelasticity
	+ const double inelasticity = dot(bproton.mom(), qphoton) / dot(bproton.mom(), bpositron.mom());
	+ if (!inRange(inelasticity, 0.2, 0.85)) vetoEvent;
	+
	+ // Computation of x_y^obs
	+ // (I assume Ee is the lab frame positron momentum, not in proton rest frame cf. the ambiguous phrase in the paper)
	+ const double xyobs = (j1.Et() * exp(-eta1) + j2.Et() * exp(-eta2)) / (2inelasticitybpositron.E());
	const size_t i_xyobs = (xyobs < 0.75) ? 0 : 1;

	// Fill histograms
	const double weight = event.weight();
	// T1
	if ((j1.mom()+j2.mom()).mass() > 42*GeV && inRange(etabar, 0.1, 0.3))
	_h_costh[i_xyobs]->fill(abs(costhetastar), weight);
	// T2, T3
	- if (inRange(j1.eta(), -1, 0) && inRange(j2.eta(), -1, 0))
	+ if (inRange(eta1, -1, 0) && inRange(eta2, -1, 0))
	_h_etjet1[i_xyobs][0]->fill(j1.Et()/GeV, weight);
	- else if (inRange(j1.eta(), 0, 1) && inRange(j2.eta(), -1, 0))
	+ else if (inRange(eta1, 0, 1) && inRange(eta2, -1, 0))
	_h_etjet1[i_xyobs][1]->fill(j1.Et()/GeV, weight);
	- else if (inRange(j1.eta(), 0, 1) && inRange(j2.eta(), 0, 1))
	+ else if (inRange(eta1, 0, 1) && inRange(eta2, 0, 1))
	_h_etjet1[i_xyobs][2]->fill(j1.Et()/GeV, weight);
	- else if (inRange(j1.eta(), 1, 2.4) && inRange(j2.eta(), -1, 0))
	+ else if (inRange(eta1, 1, 2.4) && inRange(eta2, -1, 0))
	_h_etjet1[i_xyobs][3]->fill(j1.Et()/GeV, weight);
	- else if (inRange(j1.eta(), 1, 2.4) && inRange(j2.eta(), 0, 1))
	+ else if (inRange(eta1, 1, 2.4) && inRange(eta2, 0, 1))
	_h_etjet1[i_xyobs][4]->fill(j1.Et()/GeV, weight);
	- else if (inRange(j1.eta(), 1, 2.4) && inRange(j2.eta(), 1, 2.4))
	+ else if (inRange(eta1, 1, 2.4) && inRange(eta2, 1, 2.4))
	_h_etjet1[i_xyobs][5]->fill(j1.Et()/GeV, weight);
	// T4, T5
	- if (inRange(j1.eta(), -1, 0))
	- _h_etajet2[i_xyobs][0]->fill(j2.eta(), weight);
	- else if (inRange(j1.eta(), 0, 1))
	- _h_etajet2[i_xyobs][1]->fill(j2.eta(), weight);
	- else if (inRange(j1.eta(), 1, 2.4))
	- _h_etajet2[i_xyobs][2]->fill(j2.eta(), weight);
	+ if (inRange(eta1, -1, 0))
	+ _h_etajet2[i_xyobs][0]->fill(eta2, weight);
	+ else if (inRange(eta1, 0, 1))
	+ _h_etajet2[i_xyobs][1]->fill(eta2, weight);
	+ else if (inRange(eta1, 1, 2.4))
	+ _h_etajet2[i_xyobs][2]->fill(eta2, weight);
	// T6
	if (inRange(j1.Et()/GeV, 14, 17))
	_h_xobsy[0]->fill(xyobs, weight);
	else if (inRange(j1.Et()/GeV, 17, 25))
	_h_xobsy[1]->fill(xyobs, weight);
	else if (inRange(j1.Et()/GeV, 25, 35))
	_h_xobsy[2]->fill(xyobs, weight);
	else if (inRange(j1.Et()/GeV, 35, 90))
	_h_xobsy[3]->fill(xyobs, weight);
	}


	// Finalize
	void finalize() {
	const double sf = crossSection()/picobarn/sumOfWeights();
	for (size_t ix = 0; ix < 2; ++ix) {
	scale(_h_costh[ix], sf);
	for (auto& h : _h_etjet1[ix]) scale(h, sf);
	for (auto& h : _h_etajet2[ix]) scale(h, sf);
	}
	for (auto& h : _h_xobsy) scale(h, sf);
	}

	//@}


	private:

	/// @name Histograms
	//@{
	Histo1DPtr _h_costh[2], _h_etjet1[2][6], _h_etajet2[2][3], _h_xobsy[4];
	//@}

	};


	DECLARE_RIVET_PLUGIN(ZEUS_2001_S4815815);

	}
	diff --git a/src/Analyses/cat_with_lines b/src/Analyses/cat_with_lines
	new file mode 100755
	--- /dev/null
	+++ b/src/Analyses/cat_with_lines
	@@ -0,0 +1,6 @@
	+#! /bin/bash
	+for i in "$@"
	+do
	+ echo "#line 1 \"$i\""
	+ cat "$i"
	+done
	diff --git a/src/Core/Analysis.cc b/src/Core/Analysis.cc
	--- a/src/Core/Analysis.cc
	+++ b/src/Core/Analysis.cc
	@@ -1,787 +1,818 @@
	// -- C++ --
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Analysis.hh"
	#include "Rivet/AnalysisHandler.hh"
	#include "Rivet/AnalysisInfo.hh"
	-#include "Rivet/BeamConstraint.hh"
	-#include "Rivet/Tools/RivetYODA.hh"
	-#include "Rivet/Tools/Logging.hh"
	+#include "Rivet/Tools/BeamConstraint.hh"

	namespace Rivet {


	Analysis::Analysis(const string& name)
	: _crossSection(-1.0),
	_gotCrossSection(false),
	_analysishandler(NULL)
	{
	ProjectionApplier::_allowProjReg = false;
	_defaultname = name;

	unique_ptr<AnalysisInfo> ai = AnalysisInfo::make(name);
	assert(ai);
	_info = move(ai);
	assert(_info);
	}

	double Analysis::sqrtS() const {
	return handler().sqrtS();
	}

	const ParticlePair& Analysis::beams() const {
	return handler().beams();
	}

	const PdgIdPair Analysis::beamIds() const {
	return handler().beamIds();
	}


	const string Analysis::histoDir() const {
	/// @todo Cache in a member variable
	string _histoDir;
	if (_histoDir.empty()) {
	_histoDir = "/" + name();
	if (handler().runName().length() > 0) {
	_histoDir = "/" + handler().runName() + _histoDir;
	}
	replace_all(_histoDir, "//", "/"); //< iterates until none
	}
	return _histoDir;
	}


	const string Analysis::histoPath(const string& hname) const {
	const string path = histoDir() + "/" + hname;
	return path;
	}


	const string Analysis::histoPath(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const {
	return histoDir() + "/" + makeAxisCode(datasetId, xAxisId, yAxisId);
	}


	const string Analysis::makeAxisCode(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const {
	stringstream axisCode;
	axisCode << "d";
	if (datasetId < 10) axisCode << 0;
	axisCode << datasetId;
	axisCode << "-x";
	if (xAxisId < 10) axisCode << 0;
	axisCode << xAxisId;
	axisCode << "-y";
	if (yAxisId < 10) axisCode << 0;
	axisCode << yAxisId;
	return axisCode.str();
	}


	Log& Analysis::getLog() const {
	string logname = "Rivet.Analysis." + name();
	return Log::getLog(logname);
	}


	size_t Analysis::numEvents() const {
	return handler().numEvents();
	}


	double Analysis::sumOfWeights() const {
	return handler().sumOfWeights();
	}


	///////////////////////////////////////////


	bool Analysis::isCompatible(const ParticlePair& beams) const {
	return isCompatible(beams.first.pid(), beams.second.pid(),
	beams.first.energy(), beams.second.energy());
	}


	bool Analysis::isCompatible(PdgId beam1, PdgId beam2, double e1, double e2) const {
	PdgIdPair beams(beam1, beam2);
	pair<double,double> energies(e1, e2);
	return isCompatible(beams, energies);
	}


	bool Analysis::isCompatible(const PdgIdPair& beams, const pair<double,double>& energies) const {
	// First check the beam IDs
	bool beamIdsOk = false;
	foreach (const PdgIdPair& bp, requiredBeams()) {
	if (compatible(beams, bp)) {
	beamIdsOk = true;
	break;
	}
	}
	if (!beamIdsOk) return false;

	// Next check that the energies are compatible (within 1% or 1 GeV, whichever is larger, for a bit of UI forgiveness)

	/// @todo Use some sort of standard ordering to improve comparisons, esp. when the two beams are different particles
	bool beamEnergiesOk = requiredEnergies().size() > 0 ? false : true;
	typedef pair<double,double> DoublePair;
	foreach (const DoublePair& ep, requiredEnergies()) {
	if ((fuzzyEquals(ep.first, energies.first, 0.01) && fuzzyEquals(ep.second, energies.second, 0.01)) \|\|
	(fuzzyEquals(ep.first, energies.second, 0.01) && fuzzyEquals(ep.second, energies.first, 0.01)) \|\|
	(abs(ep.first - energies.first) < 1GeV && abs(ep.second - energies.second) < 1GeV) \|\|
	(abs(ep.first - energies.second) < 1GeV && abs(ep.second - energies.first) < 1GeV)) {
	beamEnergiesOk = true;
	break;
	}
	}
	return beamEnergiesOk;

	/// @todo Need to also check internal consistency of the analysis'
	/// beam requirements with those of the projections it uses.
	}


	///////////////////////////////////////////


	Analysis& Analysis::setCrossSection(double xs) {
	_crossSection = xs;
	_gotCrossSection = true;
	return *this;
	}

	double Analysis::crossSection() const {
	if (!_gotCrossSection \|\| std::isnan(_crossSection)) {
	string errMsg = "You did not set the cross section for the analysis " + name();
	throw Error(errMsg);
	}
	return _crossSection;
	}

	double Analysis::crossSectionPerEvent() const {
	const double sumW = sumOfWeights();
	assert(sumW != 0.0);
	return _crossSection / sumW;
	}



	////////////////////////////////////////////////////////////
	// Histogramming


	void Analysis::_cacheRefData() const {
	if (_refdata.empty()) {
	MSG_TRACE("Getting refdata cache for paper " << name());
	_refdata = getRefData(name());
	}
	}


	const Scatter2D& Analysis::refData(const string& hname) const {
	_cacheRefData();
	MSG_TRACE("Using histo bin edges for " << name() << ":" << hname);
	if (!_refdata[hname]) {
	MSG_ERROR("Can't find reference histogram " << hname);
	throw Exception("Reference data " + hname + " not found.");
	}
	return dynamic_cast<Scatter2D&>(*_refdata[hname]);
	}


	const Scatter2D& Analysis::refData(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId) const {
	const string hname = makeAxisCode(datasetId, xAxisId, yAxisId);
	return refData(hname);
	}


	CounterPtr Analysis::bookCounter(const string& cname,
	const string& title) {
	// const string& xtitle,
	// const string& ytitle) {
	const string path = histoPath(cname);
	CounterPtr ctr = make_shared<Counter>(path, title);
	addAnalysisObject(ctr);
	MSG_TRACE("Made counter " << cname << " for " << name());
	// hist->setAnnotation("XLabel", xtitle);
	// hist->setAnnotation("YLabel", ytitle);
	return ctr;
	}


	+ CounterPtr Analysis::bookCounter(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	+ const string& title) {
	+ // const string& xtitle,
	+ // const string& ytitle) {
	+ const string axisCode = makeAxisCode(datasetId, xAxisId, yAxisId);
	+ return bookCounter(axisCode, title);
	+ }
	+
	+
	Histo1DPtr Analysis::bookHisto1D(const string& hname,
	size_t nbins, double lower, double upper,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string path = histoPath(hname);
	Histo1DPtr hist = make_shared<Histo1D>(nbins, lower, upper, path, title);
	addAnalysisObject(hist);
	MSG_TRACE("Made histogram " << hname << " for " << name());
	hist->setAnnotation("XLabel", xtitle);
	hist->setAnnotation("YLabel", ytitle);
	return hist;
	}


	Histo1DPtr Analysis::bookHisto1D(const string& hname,
	const vector<double>& binedges,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string path = histoPath(hname);
	Histo1DPtr hist = make_shared<Histo1D>(binedges, path, title);
	addAnalysisObject(hist);
	MSG_TRACE("Made histogram " << hname << " for " << name());
	hist->setAnnotation("XLabel", xtitle);
	hist->setAnnotation("YLabel", ytitle);
	return hist;
	}


	Histo1DPtr Analysis::bookHisto1D(const string& hname,
	const Scatter2D& refscatter,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string path = histoPath(hname);
	Histo1DPtr hist = make_shared<Histo1D>(refscatter, path);
	addAnalysisObject(hist);
	MSG_TRACE("Made histogram " << hname << " for " << name());
	hist->setTitle(title);
	hist->setAnnotation("XLabel", xtitle);
	hist->setAnnotation("YLabel", ytitle);
	return hist;
	}


	Histo1DPtr Analysis::bookHisto1D(const string& hname,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const Scatter2D& refdata = refData(hname);
	return bookHisto1D(hname, refdata, title, xtitle, ytitle);
	}


	Histo1DPtr Analysis::bookHisto1D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string axisCode = makeAxisCode(datasetId, xAxisId, yAxisId);
	return bookHisto1D(axisCode, title, xtitle, ytitle);
	}


	/// @todo Add booking methods which take a path, titles and a reference Scatter from which to book


	/////////////////


	Histo2DPtr Analysis::bookHisto2D(const string& hname,
	size_t nxbins, double xlower, double xupper,
	size_t nybins, double ylower, double yupper,
	const string& title,
	const string& xtitle,
	const string& ytitle,
	const string& ztitle)
	{
	const string path = histoPath(hname);
	Histo2DPtr hist = make_shared<Histo2D>(nxbins, xlower, xupper, nybins, ylower, yupper, path, title);
	addAnalysisObject(hist);
	MSG_TRACE("Made 2D histogram " << hname << " for " << name());
	hist->setAnnotation("XLabel", xtitle);
	hist->setAnnotation("YLabel", ytitle);
	hist->setAnnotation("ZLabel", ztitle);
	return hist;
	}


	Histo2DPtr Analysis::bookHisto2D(const string& hname,
	const vector<double>& xbinedges,
	const vector<double>& ybinedges,
	const string& title,
	const string& xtitle,
	const string& ytitle,
	const string& ztitle)
	{
	const string path = histoPath(hname);
	Histo2DPtr hist = make_shared<Histo2D>(xbinedges, ybinedges, path, title);
	addAnalysisObject(hist);
	MSG_TRACE("Made 2D histogram " << hname << " for " << name());
	hist->setAnnotation("XLabel", xtitle);
	hist->setAnnotation("YLabel", ytitle);
	hist->setAnnotation("ZLabel", ztitle);
	return hist;
	}


	// Histo2DPtr Analysis::bookHisto2D(const string& hname,
	// const Scatter3D& refscatter,
	// const string& title="",
	// const string& xtitle="",
	// const string& ytitle="",
	// const string& ztitle="") {
	// const string path = histoPath(hname);
	// Histo2DPtr hist( new Histo2D(refscatter, path) );
	// addAnalysisObject(hist);
	// MSG_TRACE("Made 2D histogram " << hname << " for " << name());
	// hist->setTitle(title);
	// hist->setAnnotation("XLabel", xtitle);
	// hist->setAnnotation("YLabel", ytitle);
	// hist->setAnnotation("ZLabel", ztitle);
	// return hist;
	// }


	// Histo2DPtr Analysis::bookHisto2D(const string& hname,
	// const string& title,
	// const string& xtitle,
	// const string& ytitle,
	// const string& ztitle) {
	// const Scatter3D& refdata = refData(hname);
	// return bookHisto2D(hname, refdata, title, xtitle, ytitle, ztitle);
	// }


	// Histo2DPtr Analysis::bookHisto2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	// const string& title,
	// const string& xtitle,
	// const string& ytitle,
	// const string& ztitle) {
	// const string axisCode = makeAxisCode(datasetId, xAxisId, yAxisId);
	// return bookHisto2D(axisCode, title, xtitle, ytitle, ztitle);
	// }


	/////////////////


	Profile1DPtr Analysis::bookProfile1D(const string& hname,
	size_t nbins, double lower, double upper,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string path = histoPath(hname);
	Profile1DPtr prof = make_shared<Profile1D>(nbins, lower, upper, path, title);
	addAnalysisObject(prof);
	MSG_TRACE("Made profile histogram " << hname << " for " << name());
	prof->setAnnotation("XLabel", xtitle);
	prof->setAnnotation("YLabel", ytitle);
	return prof;
	}


	Profile1DPtr Analysis::bookProfile1D(const string& hname,
	const vector<double>& binedges,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string path = histoPath(hname);
	Profile1DPtr prof = make_shared<Profile1D>(binedges, path, title);
	addAnalysisObject(prof);
	MSG_TRACE("Made profile histogram " << hname << " for " << name());
	prof->setAnnotation("XLabel", xtitle);
	prof->setAnnotation("YLabel", ytitle);
	return prof;
	}


	Profile1DPtr Analysis::bookProfile1D(const string& hname,
	const Scatter2D& refscatter,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string path = histoPath(hname);
	Profile1DPtr prof = make_shared<Profile1D>(refscatter, path);
	addAnalysisObject(prof);
	MSG_TRACE("Made profile histogram " << hname << " for " << name());
	prof->setTitle(title);
	prof->setAnnotation("XLabel", xtitle);
	prof->setAnnotation("YLabel", ytitle);
	return prof;
	}


	Profile1DPtr Analysis::bookProfile1D(const string& hname,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const Scatter2D& refdata = refData(hname);
	return bookProfile1D(hname, refdata, title, xtitle, ytitle);
	}


	Profile1DPtr Analysis::bookProfile1D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string axisCode = makeAxisCode(datasetId, xAxisId, yAxisId);
	return bookProfile1D(axisCode, title, xtitle, ytitle);
	}


	///////////////////



	Profile2DPtr Analysis::bookProfile2D(const string& hname,
	size_t nxbins, double xlower, double xupper,
	size_t nybins, double ylower, double yupper,
	const string& title,
	const string& xtitle,
	const string& ytitle,
	const string& ztitle)
	{
	const string path = histoPath(hname);
	Profile2DPtr prof = make_shared<Profile2D>(nxbins, xlower, xupper, nybins, ylower, yupper, path, title);
	addAnalysisObject(prof);
	MSG_TRACE("Made 2D profile histogram " << hname << " for " << name());
	prof->setAnnotation("XLabel", xtitle);
	prof->setAnnotation("YLabel", ytitle);
	prof->setAnnotation("ZLabel", ztitle);
	return prof;
	}


	Profile2DPtr Analysis::bookProfile2D(const string& hname,
	const vector<double>& xbinedges,
	const vector<double>& ybinedges,
	const string& title,
	const string& xtitle,
	const string& ytitle,
	const string& ztitle)
	{
	const string path = histoPath(hname);
	Profile2DPtr prof = make_shared<Profile2D>(xbinedges, ybinedges, path, title);
	addAnalysisObject(prof);
	MSG_TRACE("Made 2D profile histogram " << hname << " for " << name());
	prof->setAnnotation("XLabel", xtitle);
	prof->setAnnotation("YLabel", ytitle);
	prof->setAnnotation("ZLabel", ztitle);
	return prof;
	}


	// Profile2DPtr Analysis::bookProfile2D(const string& hname,
	// const Scatter3D& refscatter,
	// const string& title="",
	// const string& xtitle="",
	// const string& ytitle="",
	// const string& ztitle="") {
	// const string path = histoPath(hname);
	// Profile2DPtr prof( new Profile2D(refscatter, path) );
	// addAnalysisObject(prof);
	// MSG_TRACE("Made 2D profile histogram " << hname << " for " << name());
	// prof->setTitle(title);
	// prof->setAnnotation("XLabel", xtitle);
	// prof->setAnnotation("YLabel", ytitle);
	// prof->setAnnotation("ZLabel", ztitle);
	// return prof;
	// }


	// Profile2DPtr Analysis::bookProfile2D(const string& hname,
	// const string& title,
	// const string& xtitle,
	// const string& ytitle,
	// const string& ztitle) {
	// const Scatter3D& refdata = refData(hname);
	// return bookProfile2D(hname, refdata, title, xtitle, ytitle, ztitle);
	// }


	// Profile2DPtr Analysis::bookProfile2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	// const string& title,
	// const string& xtitle,
	// const string& ytitle,
	// const string& ztitle) {
	// const string axisCode = makeAxisCode(datasetId, xAxisId, yAxisId);
	// return bookProfile2D(axisCode, title, xtitle, ytitle, ztitle);
	// }


	/////////////////


	Scatter2DPtr Analysis::bookScatter2D(unsigned int datasetId, unsigned int xAxisId, unsigned int yAxisId,
	bool copy_pts,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string axisCode = makeAxisCode(datasetId, xAxisId, yAxisId);
	return bookScatter2D(axisCode, copy_pts, title, xtitle, ytitle);
	}


	Scatter2DPtr Analysis::bookScatter2D(const string& hname,
	bool copy_pts,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	Scatter2DPtr s;
	const string path = histoPath(hname);
	if (copy_pts) {
	const Scatter2D& refdata = refData(hname);
	s = make_shared<Scatter2D>(refdata, path);
	foreach (Point2D& p, s->points()) p.setY(0, 0);
	} else {
	s = make_shared<Scatter2D>(path);
	}
	addAnalysisObject(s);
	MSG_TRACE("Made scatter " << hname << " for " << name());
	s->setTitle(title);
	s->setAnnotation("XLabel", xtitle);
	s->setAnnotation("YLabel", ytitle);
	return s;
	}


	Scatter2DPtr Analysis::bookScatter2D(const string& hname,
	size_t npts, double lower, double upper,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string path = histoPath(hname);
	Scatter2DPtr s = make_shared<Scatter2D>(path);
	const double binwidth = (upper-lower)/npts;
	for (size_t pt = 0; pt < npts; ++pt) {
	const double bincentre = lower + (pt + 0.5) * binwidth;
	s->addPoint(bincentre, 0, binwidth/2.0, 0);
	}
	addAnalysisObject(s);
	MSG_TRACE("Made scatter " << hname << " for " << name());
	s->setTitle(title);
	s->setAnnotation("XLabel", xtitle);
	s->setAnnotation("YLabel", ytitle);
	return s;
	}


	Scatter2DPtr Analysis::bookScatter2D(const string& hname,
	const vector<double>& binedges,
	const string& title,
	const string& xtitle,
	const string& ytitle) {
	const string path = histoPath(hname);
	Scatter2DPtr s = make_shared<Scatter2D>(path);
	for (size_t pt = 0; pt < binedges.size()-1; ++pt) {
	const double bincentre = (binedges[pt] + binedges[pt+1]) / 2.0;
	const double binwidth = binedges[pt+1] - binedges[pt];
	s->addPoint(bincentre, 0, binwidth/2.0, 0);
	}
	addAnalysisObject(s);
	MSG_TRACE("Made scatter " << hname << " for " << name());
	s->setTitle(title);
	s->setAnnotation("XLabel", xtitle);
	s->setAnnotation("YLabel", ytitle);
	return s;
	}


	/////////////////////


	+ void Analysis::divide(CounterPtr c1, CounterPtr c2, Scatter1DPtr s) const {
	+ const string path = s->path();
	+ s = c1 / *c2;
	+ s->setPath(path);
	+ }
	+
	+ void Analysis::divide(const Counter& c1, const Counter& c2, Scatter1DPtr s) const {
	+ const string path = s->path();
	+ *s = c1 / c2;
	+ s->setPath(path);
	+ }
	+
	+
	void Analysis::divide(Histo1DPtr h1, Histo1DPtr h2, Scatter2DPtr s) const {
	const string path = s->path();
	s = h1 / *h2;
	s->setPath(path);
	}

	void Analysis::divide(const Histo1D& h1, const Histo1D& h2, Scatter2DPtr s) const {
	const string path = s->path();
	*s = h1 / h2;
	s->setPath(path);
	}


	void Analysis::divide(Profile1DPtr p1, Profile1DPtr p2, Scatter2DPtr s) const {
	const string path = s->path();
	s = p1 / *p2;
	s->setPath(path);
	}

	void Analysis::divide(const Profile1D& p1, const Profile1D& p2, Scatter2DPtr s) const {
	const string path = s->path();
	*s = p1 / p2;
	s->setPath(path);
	}


	void Analysis::divide(Histo2DPtr h1, Histo2DPtr h2, Scatter3DPtr s) const {
	const string path = s->path();
	s = h1 / *h2;
	s->setPath(path);
	}

	void Analysis::divide(const Histo2D& h1, const Histo2D& h2, Scatter3DPtr s) const {
	const string path = s->path();
	*s = h1 / h2;
	s->setPath(path);
	}


	void Analysis::divide(Profile2DPtr p1, Profile2DPtr p2, Scatter3DPtr s) const {
	const string path = s->path();
	s = p1 / *p2;
	s->setPath(path);
	}

	void Analysis::divide(const Profile2D& p1, const Profile2D& p2, Scatter3DPtr s) const {
	const string path = s->path();
	*s = p1 / p2;
	s->setPath(path);
	}


	+ /// @todo Counter and Histo2D efficiencies and asymms
	+
	+
	void Analysis::efficiency(Histo1DPtr h1, Histo1DPtr h2, Scatter2DPtr s) const {
	const string path = s->path();
	s = YODA::efficiency(h1, *h2);
	s->setPath(path);
	}

	void Analysis::efficiency(const Histo1D& h1, const Histo1D& h2, Scatter2DPtr s) const {
	const string path = s->path();
	*s = YODA::efficiency(h1, h2);
	s->setPath(path);
	}


	void Analysis::asymm(Histo1DPtr h1, Histo1DPtr h2, Scatter2DPtr s) const {
	const string path = s->path();
	s = YODA::asymm(h1, *h2);
	s->setPath(path);
	}

	void Analysis::asymm(const Histo1D& h1, const Histo1D& h2, Scatter2DPtr s) const {
	const string path = s->path();
	*s = YODA::asymm(h1, h2);
	s->setPath(path);
	}


	+ void Analysis::scale(CounterPtr cnt, double factor) {
	+ if (!cnt) {
	+ MSG_WARNING("Failed to scale counter=NULL in analysis " << name() << " (scale=" << factor << ")");
	+ return;
	+ }
	+ if (std::isnan(factor) \|\| std::isinf(factor)) {
	+ MSG_WARNING("Failed to scale counter=" << cnt->path() << " in analysis: " << name() << " (invalid scale factor = " << factor << ")");
	+ factor = 0;
	+ }
	+ MSG_TRACE("Scaling counter " << cnt->path() << " by factor " << factor);
	+ try {
	+ cnt->scaleW(factor);
	+ } catch (YODA::Exception& we) {
	+ MSG_WARNING("Could not scale counter " << cnt->path());
	+ return;
	+ }
	+ }
	+
	+
	void Analysis::normalize(Histo1DPtr histo, double norm, bool includeoverflows) {
	if (!histo) {
	- MSG_ERROR("Failed to normalize histo=NULL in analysis " << name() << " (norm=" << norm << ")");
	+ MSG_WARNING("Failed to normalize histo=NULL in analysis " << name() << " (norm=" << norm << ")");
	return;
	}
	MSG_TRACE("Normalizing histo " << histo->path() << " to " << norm);
	try {
	histo->normalize(norm, includeoverflows);
	} catch (YODA::Exception& we) {
	MSG_WARNING("Could not normalize histo " << histo->path());
	return;
	}
	}


	- void Analysis::scale(Histo1DPtr histo, double scale) {
	+ void Analysis::scale(Histo1DPtr histo, double factor) {
	if (!histo) {
	- MSG_ERROR("Failed to scale histo=NULL in analysis " << name() << " (scale=" << scale << ")");
	+ MSG_WARNING("Failed to scale histo=NULL in analysis " << name() << " (scale=" << factor << ")");
	return;
	}
	- if (std::isnan(scale) \|\| std::isinf(scale)) {
	- MSG_ERROR("Failed to scale histo=" << histo->path() << " in analysis: " << name() << " (invalid scale factor = " << scale << ")");
	- scale = 0;
	+ if (std::isnan(factor) \|\| std::isinf(factor)) {
	+ MSG_WARNING("Failed to scale histo=" << histo->path() << " in analysis: " << name() << " (invalid scale factor = " << factor << ")");
	+ factor = 0;
	}
	- MSG_TRACE("Scaling histo " << histo->path() << " by factor " << scale);
	+ MSG_TRACE("Scaling histo " << histo->path() << " by factor " << factor);
	try {
	- histo->scaleW(scale);
	+ histo->scaleW(factor);
	} catch (YODA::Exception& we) {
	MSG_WARNING("Could not scale histo " << histo->path());
	return;
	}
	- // // Transforming the histo into a scatter after scaling
	- // vector<double> x, y, ex, ey;
	- // for (size_t i = 0, N = histo->numBins(); i < N; ++i) {
	- // x.push_back( histo->bin(i).midpoint() );
	- // ex.push_back(histo->bin(i).width()*0.5);
	- // y.push_back(histo->bin(i).height()*scale);
	- // ey.push_back(histo->bin(i).heightErr()*scale);
	- // }
	- // string title = histo->title();
	- // Scatter2DPtr dps( new Scatter2D(x, y, ex, ey, hpath, title) );
	- // addAnalysisObject(dps);
	}


	void Analysis::normalize(Histo2DPtr histo, double norm, bool includeoverflows) {
	if (!histo) {
	MSG_ERROR("Failed to normalize histo=NULL in analysis " << name() << " (norm=" << norm << ")");
	return;
	}
	MSG_TRACE("Normalizing histo " << histo->path() << " to " << norm);
	try {
	histo->normalize(norm, includeoverflows);
	} catch (YODA::Exception& we) {
	MSG_WARNING("Could not normalize histo " << histo->path());
	return;
	}
	}


	- void Analysis::scale(Histo2DPtr histo, double scale) {
	+ void Analysis::scale(Histo2DPtr histo, double factor) {
	if (!histo) {
	- MSG_ERROR("Failed to scale histo=NULL in analysis " << name() << " (scale=" << scale << ")");
	+ MSG_ERROR("Failed to scale histo=NULL in analysis " << name() << " (scale=" << factor << ")");
	return;
	}
	- if (std::isnan(scale) \|\| std::isinf(scale)) {
	- MSG_ERROR("Failed to scale histo=" << histo->path() << " in analysis: " << name() << " (invalid scale factor = " << scale << ")");
	- scale = 0;
	+ if (std::isnan(factor) \|\| std::isinf(factor)) {
	+ MSG_ERROR("Failed to scale histo=" << histo->path() << " in analysis: " << name() << " (invalid scale factor = " << factor << ")");
	+ factor = 0;
	}
	- MSG_TRACE("Scaling histo " << histo->path() << " by factor " << scale);
	+ MSG_TRACE("Scaling histo " << histo->path() << " by factor " << factor);
	try {
	- histo->scaleW(scale);
	+ histo->scaleW(factor);
	} catch (YODA::Exception& we) {
	MSG_WARNING("Could not scale histo " << histo->path());
	return;
	}
	}


	void Analysis::integrate(Histo1DPtr h, Scatter2DPtr s) const {
	// preserve the path info
	const string path = s->path();
	s = toIntegralHisto(h);
	s->setPath(path);
	}

	void Analysis::integrate(const Histo1D& h, Scatter2DPtr s) const {
	// preserve the path info
	const string path = s->path();
	*s = toIntegralHisto(h);
	s->setPath(path);
	}


	/// @todo 2D versions of integrate... defined how, exactly?!?


	//////////////////////////////////


	void Analysis::addAnalysisObject(AnalysisObjectPtr ao) {
	_analysisobjects.push_back(ao);
	}

	void Analysis::removeAnalysisObject(const string& path) {
	for (vector<AnalysisObjectPtr>::iterator it = _analysisobjects.begin(); it != _analysisobjects.end(); ++it) {
	if ((*it)->path() == path) {
	_analysisobjects.erase(it);
	break;
	}
	}
	}

	void Analysis::removeAnalysisObject(AnalysisObjectPtr ao) {
	for (vector<AnalysisObjectPtr>::iterator it = _analysisobjects.begin(); it != _analysisobjects.end(); ++it) {
	if (*it == ao) {
	_analysisobjects.erase(it);
	break;
	}
	}
	}


	}
	diff --git a/src/Core/AnalysisHandler.cc b/src/Core/AnalysisHandler.cc
	--- a/src/Core/AnalysisHandler.cc
	+++ b/src/Core/AnalysisHandler.cc
	@@ -1,332 +1,333 @@
	// -- C++ --
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/AnalysisHandler.hh"
	#include "Rivet/Analysis.hh"
	-#include "Rivet/ParticleName.hh"
	-#include "Rivet/BeamConstraint.hh"
	+#include "Rivet/Tools/ParticleName.hh"
	+#include "Rivet/Tools/BeamConstraint.hh"
	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Projections/Beam.hh"
	#include "YODA/WriterYODA.h"

	namespace Rivet {

	+
	AnalysisHandler::AnalysisHandler(const string& runname)
	: _runname(runname), _numEvents(0),
	_sumOfWeights(0.0), _xs(NAN),
	_initialised(false), _ignoreBeams(false)
	{}


	AnalysisHandler::~AnalysisHandler()
	{}


	Log& AnalysisHandler::getLog() const {
	return Log::getLog("Rivet.Analysis.Handler");
	}


	void AnalysisHandler::init(const GenEvent& ge) {
	if (_initialised)
	throw UserError("AnalysisHandler::init has already been called: cannot re-initialize!");

	setRunBeams(Rivet::beams(ge));
	MSG_DEBUG("Initialising the analysis handler");
	_numEvents = 0;
	_sumOfWeights = 0.0;
	_sumOfWeightsSq = 0.0;

	// Check that analyses are beam-compatible, and remove those that aren't
	const size_t num_anas_requested = analysisNames().size();
	vector<string> anamestodelete;
	for (const AnaHandle a : _analyses) {
	if (!_ignoreBeams && !a->isCompatible(beams())) {
	//MSG_DEBUG(a->name() << " requires beams " << a->requiredBeams() << " @ " << a->requiredEnergies() << " GeV");
	anamestodelete.push_back(a->name());
	}
	}
	for (const string& aname : anamestodelete) {
	MSG_WARNING("Analysis '" << aname << "' is incompatible with the provided beams: removing");
	removeAnalysis(aname);
	}
	if (num_anas_requested > 0 && analysisNames().empty()) {
	cerr << "All analyses were incompatible with the first event's beams\n"
	<< "Exiting, since this probably wasn't intentional!" << endl;
	exit(1);
	}

	// Warn if any analysis' status is not unblemished
	for (const AnaHandle a : analyses()) {
	if (toUpper(a->status()) == "PRELIMINARY") {
	MSG_WARNING("Analysis '" << a->name() << "' is preliminary: be careful, it may change and/or be renamed!");
	} else if (toUpper(a->status()) == "OBSOLETE") {
	MSG_WARNING("Analysis '" << a->name() << "' is obsolete: please update!");
	} else if (toUpper(a->status()).find("UNVALIDATED") != string::npos) {
	MSG_WARNING("Analysis '" << a->name() << "' is unvalidated: be careful, it may be broken!");
	}
	}

	// Initialize the remaining analyses
	for (AnaHandle a : _analyses) {
	MSG_DEBUG("Initialising analysis: " << a->name());
	try {
	// Allow projection registration in the init phase onwards
	a->_allowProjReg = true;
	a->init();
	//MSG_DEBUG("Checking consistency of analysis: " << a->name());
	//a->checkConsistency();
	} catch (const Error& err) {
	cerr << "Error in " << a->name() << "::init method: " << err.what() << endl;
	exit(1);
	}
	MSG_DEBUG("Done initialising analysis: " << a->name());
	}
	_initialised = true;
	MSG_DEBUG("Analysis handler initialised");
	}


	void AnalysisHandler::analyze(const GenEvent& ge) {
	// Call init with event as template if not already initialised
	if (!_initialised) init(ge);
	assert(_initialised);

	// Ensure that beam details match those from the first event
	const PdgIdPair beams = Rivet::beamIds(ge);
	const double sqrts = Rivet::sqrtS(ge);
	if (!compatible(beams, _beams) \|\| !fuzzyEquals(sqrts, sqrtS())) {
	cerr << "Event beams mismatch: "
	<< PID::toBeamsString(beams) << " @ " << sqrts/GeV << " GeV" << " vs. first beams "
	<< this->beams() << " @ " << this->sqrtS()/GeV << " GeV" << endl;
	exit(1);
	}

	// Create the Rivet event wrapper
	/// @todo Filter/normalize the event here
	Event event(ge);

	// Weights
	/// @todo Drop this / just report first weight when we support multiweight events
	_numEvents += 1;
	_sumOfWeights += event.weight();
	_sumOfWeightsSq += sqr(event.weight());
	MSG_DEBUG("Event #" << _numEvents << " weight = " << event.weight());

	// Cross-section
	#ifdef HEPMC_HAS_CROSS_SECTION
	if (ge.cross_section()) {
	_xs = ge.cross_section()->cross_section();
	_xserr = ge.cross_section()->cross_section_error();
	}
	#endif

	// Run the analyses
	for (AnaHandle a : _analyses) {
	MSG_TRACE("About to run analysis " << a->name());
	try {
	a->analyze(event);
	} catch (const Error& err) {
	cerr << "Error in " << a->name() << "::analyze method: " << err.what() << endl;
	exit(1);
	}
	MSG_TRACE("Finished running analysis " << a->name());
	}
	}


	void AnalysisHandler::analyze(const GenEvent* ge) {
	if (ge == NULL) {
	MSG_ERROR("AnalysisHandler received null pointer to GenEvent");
	//throw Error("AnalysisHandler received null pointer to GenEvent");
	}
	analyze(*ge);
	}


	void AnalysisHandler::finalize() {
	if (!_initialised) return;
	MSG_INFO("Finalising analyses");
	for (AnaHandle a : _analyses) {
	a->setCrossSection(_xs);
	try {
	a->finalize();
	} catch (const Error& err) {
	cerr << "Error in " << a->name() << "::finalize method: " << err.what() << endl;
	exit(1);
	}
	}

	// Print out number of events processed
	MSG_INFO("Processed " << _numEvents << " event" << (_numEvents == 1 ? "" : "s"));

	// // Delete analyses
	// MSG_DEBUG("Deleting analyses");
	// _analyses.clear();

	// Print out MCnet boilerplate
	cout << endl;
	cout << "The MCnet usage guidelines apply to Rivet: see http://www.montecarlonet.org/GUIDELINES" << endl;
	cout << "Please acknowledge plots made with Rivet analyses, and cite arXiv:1003.0694 (http://arxiv.org/abs/1003.0694)" << endl;
	}


	AnalysisHandler& AnalysisHandler::addAnalysis(const string& analysisname) {
	// Check for a duplicate analysis
	/// @todo Might we want to be able to run an analysis twice, with different params?
	/// Requires avoiding histo tree clashes, i.e. storing the histos on the analysis objects.
	for (const AnaHandle& a : _analyses) {
	if (a->name() == analysisname) {
	MSG_WARNING("Analysis '" << analysisname << "' already registered: skipping duplicate");
	return *this;
	}
	}
	AnaHandle analysis( AnalysisLoader::getAnalysis(analysisname) );
	if (analysis.get() != 0) { // < Check for null analysis.
	MSG_DEBUG("Adding analysis '" << analysisname << "'");
	analysis->_analysishandler = this;
	_analyses.insert(analysis);
	} else {
	MSG_WARNING("Analysis '" << analysisname << "' not found.");
	}
	// MSG_WARNING(_analyses.size());
	// for (const AnaHandle& a : _analyses) MSG_WARNING(a->name());
	return *this;
	}


	AnalysisHandler& AnalysisHandler::removeAnalysis(const string& analysisname) {
	std::shared_ptr<Analysis> toremove;
	for (const AnaHandle a : _analyses) {
	if (a->name() == analysisname) {
	toremove = a;
	break;
	}
	}
	if (toremove.get() != 0) {
	MSG_DEBUG("Removing analysis '" << analysisname << "'");
	_analyses.erase(toremove);
	}
	return *this;
	}


	vector<AnalysisObjectPtr> AnalysisHandler::getData() const {
	vector<AnalysisObjectPtr> rtn;
	rtn.push_back( make_shared<Counter>(YODA::Dbn0D(_numEvents, _sumOfWeights, _sumOfWeightsSq), "/_EVTCOUNT") );
	YODA::Scatter1D::Points pts; pts.insert(YODA::Point1D(_xs, _xserr));
	rtn.push_back( make_shared<Scatter1D>(pts, "/_XSEC") );
	for (const AnaHandle a : analyses()) {
	vector<AnalysisObjectPtr> aos = a->analysisObjects();
	// MSG_WARNING(a->name() << " " << aos.size());
	for (const AnalysisObjectPtr ao : aos) {
	// Exclude paths starting with /TMP/ from final write-out
	/// @todo This needs to be much more nuanced for re-entrant histogramming
	if (ao->path().find("/TMP/") != string::npos) continue;
	rtn.push_back(ao);
	}
	}
	sort(rtn.begin(), rtn.end(),
	[](AnalysisObjectPtr a, AnalysisObjectPtr b) {
	return a->path() < b->path();
	}
	);
	return rtn;
	}


	void AnalysisHandler::writeData(const string& filename) const {
	const vector<AnalysisObjectPtr> aos = getData();
	try {
	YODA::WriterYODA::write(filename, aos.begin(), aos.end());
	} catch (...) { /// @todo Move to specific YODA::WriteError type when YODA >= 1.5.0 is well-established
	throw UserError("Unexpected error in writing file to: " + filename);
	}
	}


	string AnalysisHandler::runName() const { return _runname; }
	size_t AnalysisHandler::numEvents() const { return _numEvents; }
	double AnalysisHandler::sumOfWeights() const { return _sumOfWeights; }


	void AnalysisHandler::setSumOfWeights(const double& sum) {
	_sumOfWeights=sum;
	}


	std::vector<std::string> AnalysisHandler::analysisNames() const {
	std::vector<std::string> rtn;
	for (AnaHandle a : _analyses) {
	rtn.push_back(a->name());
	}
	return rtn;
	}


	const AnaHandle AnalysisHandler::analysis(const std::string& analysisname) const {
	for (const AnaHandle a : analyses())
	if (a->name() == analysisname) return a;
	throw Error("No analysis named '" + analysisname + "' registered in AnalysisHandler");
	}


	AnalysisHandler& AnalysisHandler::addAnalyses(const std::vector<std::string>& analysisnames) {
	for (const string& aname : analysisnames) {
	//MSG_DEBUG("Adding analysis '" << aname << "'");
	addAnalysis(aname);
	}
	return *this;
	}


	AnalysisHandler& AnalysisHandler::removeAnalyses(const std::vector<std::string>& analysisnames) {
	for (const string& aname : analysisnames) {
	removeAnalysis(aname);
	}
	return *this;
	}


	bool AnalysisHandler::needCrossSection() const {
	bool rtn = false;
	for (const AnaHandle a : _analyses) {
	if (!rtn) rtn = a->needsCrossSection();
	if (rtn) break;
	}
	return rtn;
	}


	AnalysisHandler& AnalysisHandler::setCrossSection(double xs) {
	_xs = xs;
	return *this;
	}


	bool AnalysisHandler::hasCrossSection() const {
	return (!std::isnan(crossSection()));
	}


	AnalysisHandler& AnalysisHandler::addAnalysis(Analysis* analysis) {
	analysis->_analysishandler = this;
	_analyses.insert(AnaHandle(analysis));
	return *this;
	}


	PdgIdPair AnalysisHandler::beamIds() const {
	return Rivet::beamIds(beams());
	}


	double AnalysisHandler::sqrtS() const {
	return Rivet::sqrtS(beams());
	}

	void AnalysisHandler::setIgnoreBeams(bool ignore) {
	_ignoreBeams=ignore;
	}


	}
	diff --git a/src/Core/AnalysisInfo.cc b/src/Core/AnalysisInfo.cc
	--- a/src/Core/AnalysisInfo.cc
	+++ b/src/Core/AnalysisInfo.cc
	@@ -1,246 +1,248 @@
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/AnalysisInfo.hh"
	#include "Rivet/Tools/RivetPaths.hh"
	#include "Rivet/Tools/Utils.hh"
	#include "Rivet/Tools/Logging.hh"
	#include "yaml-cpp/yaml.h"
	#include <iostream>
	#include <fstream>
	#include <unistd.h>

	#ifdef YAML_NAMESPACE
	#define YAML YAML_NAMESPACE
	#endif

	namespace Rivet {


	namespace {
	Log& getLog() {
	return Log::getLog("Rivet.AnalysisInfo");
	}
	}


	/// Static factory method
	unique_ptr<AnalysisInfo> AnalysisInfo::make(const std::string& ananame) {
	// Returned AI, in semi-null state
	unique_ptr<AnalysisInfo> ai( new AnalysisInfo );
	ai->_beams += make_pair(PID::ANY, PID::ANY);
	ai->_name = ananame;

	/// If no ana data file found, return null AI
	const string datapath = findAnalysisInfoFile(ananame + ".info");
	if (datapath.empty()) {
	MSG_DEBUG("No datafile " << ananame + ".info found");
	return ai;
	}

	// Read data from YAML document
	MSG_DEBUG("Reading analysis data from " << datapath);
	YAML::Node doc;
	try {
	#if YAMLCPP_API == 3
	std::ifstream file(datapath.c_str());
	YAML::Parser parser(file);
	parser.GetNextDocument(doc);
	#elif YAMLCPP_API == 5
	doc = YAML::LoadFile(datapath);
	#endif
	} catch (const YAML::ParserException& ex) {
	MSG_ERROR("Parse error when reading analysis data from " << datapath << " (" << ex.what() << ")");
	return ai;
	}

	#define THROW_INFOERR(KEY) throw InfoError("Problem in info parsing while accessing key " + string(KEY) + " in file " + datapath)

	// Simple scalars (test for nullness before casting)
	#if YAMLCPP_API == 3
	#define TRY_GETINFO(KEY, VAR) try { if (doc.FindValue(KEY)) { string val; doc[KEY] >> val; ai->_ ## VAR = val; } } catch (...) { THROW_INFOERR(KEY); }
	#elif YAMLCPP_API == 5
	#define TRY_GETINFO(KEY, VAR) try { if (doc[KEY] && !doc[KEY].IsNull()) ai->_ ## VAR = doc[KEY].as<string>(); } catch (...) { THROW_INFOERR(KEY); }
	#endif
	TRY_GETINFO("Name", name);
	TRY_GETINFO("Summary", summary);
	TRY_GETINFO("Status", status);
	TRY_GETINFO("RunInfo", runInfo);
	TRY_GETINFO("Description", description);
	TRY_GETINFO("Experiment", experiment);
	TRY_GETINFO("Collider", collider);
	TRY_GETINFO("Year", year);
	+ TRY_GETINFO("Luminosity_fb", luminosityfb);
	TRY_GETINFO("SpiresID", spiresId);
	TRY_GETINFO("InspireID", inspireId);
	TRY_GETINFO("BibKey", bibKey);
	TRY_GETINFO("BibTeX", bibTeX);
	#undef TRY_GETINFO

	// Sequences (test the seq and each entry for nullness before casting)
	#if YAMLCPP_API == 3
	#define TRY_GETINFO_SEQ(KEY, VAR) try { \
	if (const YAML::Node* VAR = doc.FindValue(KEY)) { \
	for (size_t i = 0; i < VAR->size(); ++i) { \
	string val; (*VAR)[i] >> val; ai->_ ## VAR += val; \
	} } } catch (...) { THROW_INFOERR(KEY); }
	#elif YAMLCPP_API == 5
	#define TRY_GETINFO_SEQ(KEY, VAR) try { \
	if (doc[KEY] && !doc[KEY].IsNull()) { \
	const YAML::Node& VAR = doc[KEY]; \
	for (size_t i = 0; i < VAR.size(); ++i) \
	if (!VAR[i].IsNull()) ai->_ ## VAR += VAR[i].as<string>(); \
	} } catch (...) { THROW_INFOERR(KEY); }
	#endif
	TRY_GETINFO_SEQ("Authors", authors);
	TRY_GETINFO_SEQ("References", references);
	TRY_GETINFO_SEQ("ToDo", todos);
	+ TRY_GETINFO_SEQ("Keywords", keywords);
	#undef TRY_GETINFO_SEQ


	// A boolean with some name flexibility
	try {
	#if YAMLCPP_API == 3
	bool val;
	if (const YAML::Node* n = doc.FindValue("NeedsCrossSection")) { *n >> val; ai->_needsCrossSection = val; }
	if (const YAML::Node* n = doc.FindValue("NeedCrossSection")) { *n >> val; ai->_needsCrossSection = val; }
	#elif YAMLCPP_API == 5
	if (doc["NeedsCrossSection"]) ai->_needsCrossSection = doc["NeedsCrossSection"].as<bool>();
	else if (doc["NeedCrossSection"]) ai->_needsCrossSection = doc["NeedCrossSection"].as<bool>();
	#endif
	} catch (...) {
	THROW_INFOERR("NeedsCrossSection\|NeedCrossSection");
	}


	// Beam particle identities
	try {
	#if YAMLCPP_API == 3

	if (const YAML::Node* pbeampairs = doc.FindValue("Beams")) {
	const YAML::Node& beampairs = *pbeampairs;
	vector<PdgIdPair> beam_pairs;
	if (beampairs.size() == 2 &&
	beampairs[0].Type() == YAML::NodeType::Scalar &&
	beampairs[1].Type() == YAML::NodeType::Scalar) {
	string bstr0, bstr1;
	beampairs[0] >> bstr0;
	beampairs[1] >> bstr1;
	beam_pairs += PID::make_pdgid_pair(bstr0, bstr1);
	} else {
	for (YAML::Iterator bpi = beampairs.begin(); bpi != beampairs.end(); ++bpi) {
	const YAML::Node& bp = *bpi;
	if (bp.size() == 2 &&
	bp[0].Type() == YAML::NodeType::Scalar &&
	bp[1].Type() == YAML::NodeType::Scalar) {
	string bstr0, bstr1;
	bp[0] >> bstr0;
	bp[1] >> bstr1;
	beam_pairs += PID::make_pdgid_pair(bstr0, bstr1);
	} else {
	throw InfoError("Beam ID pairs have to be either a 2-tuple or a list of 2-tuples of particle names");
	}
	}
	}
	ai->_beams = beam_pairs;
	}

	#elif YAMLCPP_API == 5

	if (doc["Beams"]) {
	const YAML::Node& beams = doc["Beams"];
	vector<PdgIdPair> beam_pairs;
	if (beams.size() == 2 && beams[0].IsScalar() && beams[0].IsScalar()) {
	beam_pairs += PID::make_pdgid_pair(beams[0].as<string>(), beams[1].as<string>());
	} else {
	for (size_t i = 0; i < beams.size(); ++i) {
	const YAML::Node& bp = beams[i];
	if (bp.size() != 2 \|\| !bp[0].IsScalar() \|\| !bp[0].IsScalar())
	throw InfoError("Beam ID pairs have to be either a 2-tuple or a list of 2-tuples of particle names");
	beam_pairs += PID::make_pdgid_pair(bp[0].as<string>(), bp[1].as<string>());
	}
	}
	ai->_beams = beam_pairs;
	}

	#endif
	} catch (...) { THROW_INFOERR("Beams"); }


	// Beam energies
	try {
	#if YAMLCPP_API == 3

	if (const YAML::Node* penergies = doc.FindValue("Energies")) {
	const YAML::Node& energies = *penergies;
	vector<pair<double,double> > beam_energy_pairs;
	for (YAML::Iterator be = energies.begin(); be != energies.end(); ++be) {
	if (be->Type() == YAML::NodeType::Scalar) {
	// If beam energy is a scalar, then assume symmetric beams each with half that energy
	double sqrts;
	*be >> sqrts;
	beam_energy_pairs += make_pair(sqrts/2.0, sqrts/2.0);
	} else if (be->Type() == YAML::NodeType::Sequence) {
	const YAML::Node& beseq = *be;
	// If the sub-sequence is of length 1, then it's another scalar sqrt(s)!
	if (beseq.size() == 1) {
	double sqrts;
	(*be)[0] >> sqrts;
	beam_energy_pairs += make_pair(sqrts/2.0, sqrts/2.0);
	} else if (beseq.size() == 2) {
	vector<double> beamenergies;
	double beamenergy0, beamenergy1;
	beseq[0] >> beamenergy0;
	beseq[1] >> beamenergy1;
	beam_energy_pairs += make_pair(beamenergy0, beamenergy1);
	} else {
	throw InfoError("Beam energies have to be a list of either numbers or pairs of numbers");
	}
	} else {
	throw InfoError("Beam energies have to be a list of either numbers or pairs of numbers");
	}
	}
	ai->_energies = beam_energy_pairs;
	}

	#elif YAMLCPP_API == 5

	if (doc["Energies"]) {
	vector< pair<double,double> > beam_energy_pairs;
	for (size_t i = 0; i < doc["Energies"].size(); ++i) {
	const YAML::Node& be = doc["Energies"][i];
	if (be.IsScalar()) {
	// If beam energy is a scalar, then assume symmetric beams each with half that energy
	beam_energy_pairs += make_pair(be.as<double>()/2.0, be.as<double>()/2.0);
	} else if (be.IsSequence()) {
	if (be.size() != 2)
	throw InfoError("Beam energies have to be a list of either numbers or pairs of numbers");
	beam_energy_pairs += make_pair(be[0].as<double>(), be[1].as<double>());
	} else {
	throw InfoError("Beam energies have to be a list of either numbers or pairs of numbers");
	}
	}
	ai->_energies = beam_energy_pairs;
	}

	#endif

	} catch (...) { THROW_INFOERR("Energies"); }

	#undef THROW_INFOERR


	MSG_TRACE("AnalysisInfo pointer = " << ai.get());
	return ai;
	}


	string toString(const AnalysisInfo& ai) {
	stringstream ss;
	ss << ai.name();
	ss << " - " << ai.summary();
	// ss << " - " << ai.beams();
	// ss << " - " << ai.energies();
	ss << " (" << ai.status() << ")";
	return ss.str();
	}


	}
	diff --git a/src/Core/Event.cc b/src/Core/Event.cc
	--- a/src/Core/Event.cc
	+++ b/src/Core/Event.cc
	@@ -1,97 +1,114 @@
	+// -- C++ --
	#include "Rivet/Event.hh"
	-#include "Rivet/Tools/Logging.hh"
	+#include "Rivet/Tools/BeamConstraint.hh"
	#include "Rivet/Projections/Beam.hh"
	-#include "Rivet/BeamConstraint.hh"
	#include "HepMC/GenEvent.h"

	namespace Rivet {


	- // ParticlePair Event::beams() const { return Rivet::beams(*this); }
	+ ParticlePair Event::beams() const { return Rivet::beams(*this); }

	- // double Event::sqrtS() const { return Rivet::sqrtS(*this); }
	+ // PdgIdPair Event::beamIds() const { return pids(beams()); }

	- // double Event::asqrtS() const { return Rivet::asqrtS(*this); }
	+ double Event::sqrtS() const { return Rivet::sqrtS(beams()); }
	+
	+ double Event::asqrtS() const { return Rivet::asqrtS(beams()); }

	// Vector3 Event::beamCMSBoost() const { return Rivet::beamCMSBoost(*this); }

	// LorentzTransform Event::beamCMSTransform() const { return Rivet::beamCMSTransform(*this); }



	void Event::_init(const GenEvent& ge) {
	// Use Rivet's preferred units if possible
	#ifdef HEPMC_HAS_UNITS
	- _genEvent.use_units(HepMC::Units::GEV, HepMC::Units::MM);
	+ _genevent.use_units(HepMC::Units::GEV, HepMC::Units::MM);
	#endif

	// Use the conventional alignment
	// _geNormAlignment();

	/// @todo Filter the event to remove generator-specific particles: optional
	/// behaviour? Maybe disableable in an inconvenient way, e.g. with an env
	/// var, to communicate the appropriate distaste for this sort of truth
	/// analysis ;-)

	// Debug printout to check that copying/mangling has worked
	/// @todo Enable this when HepMC has been fixed to allow printing to a stream like the Rivet logger.
	- //_genEvent.print();
	+ //_genevent.print();
	}


	// namespace { // unnamed namespace for hiding
	//
	// void _geRot180x(GenEvent& ge) {
	// /// @todo Use nicer iterators over HepMC particles
	// for (HepMC::GenEvent::particle_iterator ip = ge.particles_begin(); ip != ge.particles_end(); ++ip) {
	// const HepMC::FourVector& mom = (*ip)->momentum();
	// (*ip)->set_momentum(HepMC::FourVector(mom.px(), -mom.py(), -mom.pz(), mom.e()));
	// }
	// /// @todo Use nicer iterators over HepMC vertices
	// for (HepMC::GenEvent::vertex_iterator iv = ge.vertices_begin(); iv != ge.vertices_end(); ++iv) {
	// const HepMC::FourVector& pos = (*iv)->position();
	// (*iv)->set_position(HepMC::FourVector(pos.x(), -pos.y(), -pos.z(), pos.t()));
	// }
	// }
	//
	// }


	// void Event::_geNormAlignment() {
	- // if (!_genEvent.valid_beam_particles()) return;
	+ // if (!_genevent.valid_beam_particles()) return;
	// typedef pair<HepMC::GenParticle, HepMC::GenParticle> GPPair;
	- // GPPair bps = _genEvent.beam_particles();
	+ // GPPair bps = _genevent.beam_particles();
	//
	// // Rotate e+- p and ppbar to put p along +z
	// /// @todo Is there an e+ e- convention for longitudinal boosting, e.g. at B-factories? Different from LEP?
	// // if (compatible(beamids, make_pdgid_pair(ELECTRON, PROTON)) \|\|
	// // compatible(beamids, make_pdgid_pair(POSITRON, PROTON)) \|\|
	// // compatible(beamids, make_pdgid_pair(ANTIPROTON, PROTON)) ) {
	// // Log::getLog("Rivet.Event") << Log::TRACE << "May need to rotate event..." << endl;
	// bool rot = false;
	// const HepMC::GenParticle* plusgp = 0;
	// if (bps.first->pdg_id() != PID::PROTON \|\| bps.second->pdg_id() != PID::PROTON) {
	// if (bps.first->pdg_id() == PID::PROTON) {
	// plusgp = bps.first;
	// } else if (bps.second->pdg_id() == PID::PROTON) {
	// plusgp = bps.second;
	// }
	// if (plusgp && plusgp->momentum().pz() < 0) {
	// rot = true;
	// }
	// }
	//
	// // Do the rotation
	// if (rot) {
	// if (Log::getLog("Rivet.Event").isActive(Log::TRACE)) {
	// Log::getLog("Rivet.Event") << Log::TRACE << "Rotating event\n"
	// << "Before rotation: "
	// << bps.first->pdg_id() << "@pz=" << bps.first->momentum().pz()/GeV << ", "
	// << bps.second->pdg_id() << "@pz=" << bps.second->momentum().pz()/GeV << endl;
	// }
	- // _geRot180x(_genEvent);
	+ // _geRot180x(_genevent);
	// }
	// }


	+ const Particles& Event::allParticles() const {
	+ if (_particles.empty()) { //< assume that empty means no attempt yet made
	+ for (const GenParticle* gp : particles(genEvent())) {
	+ _particles += Particle(gp);
	+ }
	+ }
	+ return _particles;
	+ }
	+
	+
	+ double Event::weight() const {
	+ return (!_genevent.weights().empty()) ? _genevent.weights()[0] : 1.0;
	+ }
	+
	+
	}
	diff --git a/src/Core/Jet.cc b/src/Core/Jet.cc
	--- a/src/Core/Jet.cc
	+++ b/src/Core/Jet.cc
	@@ -1,210 +1,192 @@
	#include "Rivet/Jet.hh"
	-#include "Rivet/Cuts.hh"
	-#include "Rivet/ParticleName.hh"
	+#include "Rivet/Tools/Cuts.hh"
	+#include "Rivet/Tools/ParticleName.hh"
	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Tools/ParticleIdUtils.hh"

	namespace Rivet {


	Jet& Jet::clear() {
	_momentum = FourMomentum();
	_pseudojet.reset(0,0,0,0);
	_particles.clear();
	return *this;
	}


	Jet& Jet::setState(const FourMomentum& mom, const Particles& particles, const Particles& tags) {
	clear();
	_momentum = mom;
	_pseudojet = fastjet::PseudoJet(mom.px(), mom.py(), mom.pz(), mom.E());
	_particles = particles;
	_tags = tags;
	return *this;
	}


	- Jet& Jet::setState(const fastjet::PseudoJet& pj, const vector<Particle>& particles, const Particles& tags) {
	+ Jet& Jet::setState(const fastjet::PseudoJet& pj, const Particles& particles, const Particles& tags) {
	clear();
	_pseudojet = pj;
	_momentum = FourMomentum(pj.e(), pj.px(), pj.py(), pj.pz());
	_particles = particles;
	_tags = tags;
	// if (_particles.empty()) {
	// foreach (const fastjet::PseudoJet pjc, _pseudojet.constituents()) {
	// // If there is no attached user info, we can't create a meaningful particle, so skip
	// if (!pjc.has_user_info<RivetFJInfo>()) continue;
	// const RivetFJInfo& fjinfo = pjc.user_info<RivetFJInfo>();
	// // Don't add ghosts to the particles list
	// if (fjinfo.isGhost) continue;
	// // Otherwise construct a Particle from the PseudoJet, preferably from an associated GenParticle
	// ?if (fjinfo.genParticle != NULL) {
	// _particles.push_back(Particle(fjinfo.genParticle));
	// } else {
	// if (fjinfo.pid == 0) continue; // skip if there is a null PID entry in the FJ info
	// const FourMomentum pjcmom(pjc.e(), pjc.px(), pjc.py(), pjc.pz());
	// _particles.push_back(Particle(fjinfo.pid, pjcmom));
	// }
	// }
	// }
	return *this;
	}


	- Jet& Jet::setParticles(const vector<Particle>& particles) {
	+ Jet& Jet::setParticles(const Particles& particles) {
	_particles = particles;
	return *this;
	}


	bool Jet::containsParticle(const Particle& particle) const {
	const int barcode = particle.genParticle()->barcode();
	foreach (const Particle& p, particles()) {
	if (p.genParticle()->barcode() == barcode) return true;
	}
	return false;
	}


	bool Jet::containsParticleId(PdgId pid) const {
	foreach (const Particle& p, particles()) {
	if (p.pid() == pid) return true;
	}
	return false;
	}


	bool Jet::containsParticleId(const vector<PdgId>& pids) const {
	foreach (const Particle& p, particles()) {
	foreach (PdgId pid, pids) {
	if (p.pid() == pid) return true;
	}
	}
	return false;
	}


	/// @todo Jet::containsMatch(Matcher m) { ... if m(pid) return true; ... }


	+ Jet& Jet::transformBy(const LorentzTransform& lt) {
	+ _momentum = lt.transform(_momentum);
	+ for (Particle& p : _particles) p.transformBy(lt);
	+ for (Particle& t : _tags) t.transformBy(lt);
	+ _pseudojet.reset(_momentum.px(), _momentum.py(), _momentum.pz(), _momentum.E()); //< lose ClusterSeq etc.
	+ return *this;
	+ }
	+
	+
	double Jet::neutralEnergy() const {
	double e_neutral = 0.0;
	foreach (const Particle& p, particles()) {
	const PdgId pid = p.pid();
	if (PID::threeCharge(pid) == 0) {
	e_neutral += p.E();
	}
	}
	return e_neutral;
	}


	double Jet::hadronicEnergy() const {
	double e_hadr = 0.0;
	foreach (const Particle& p, particles()) {
	const PdgId pid = p.pid();
	if (PID::isHadron(pid)) {
	e_hadr += p.E();
	}
	}
	return e_hadr;
	}


	bool Jet::containsCharm(bool include_decay_products) const {
	foreach (const Particle& p, particles()) {
	const PdgId pid = p.pid();
	if (abs(pid) == PID::CQUARK) return true;
	if (PID::isHadron(pid) && PID::hasCharm(pid)) return true;
	if (include_decay_products) {
	const HepMC::GenVertex* gv = p.genParticle()->production_vertex();
	if (gv) {
	foreach (const GenParticle* pi, Rivet::particles(gv, HepMC::ancestors)) {
	const PdgId pid2 = pi->pdg_id();
	if (PID::isHadron(pid2) && PID::hasCharm(pid2)) return true;
	}
	}
	}
	}
	return false;
	}


	bool Jet::containsBottom(bool include_decay_products) const {
	foreach (const Particle& p, particles()) {
	const PdgId pid = p.pid();
	if (abs(pid) == PID::BQUARK) return true;
	if (PID::isHadron(pid) && PID::hasBottom(pid)) return true;
	if (include_decay_products) {
	const HepMC::GenVertex* gv = p.genParticle()->production_vertex();
	if (gv) {
	foreach (const GenParticle* pi, Rivet::particles(gv, HepMC::ancestors)) {
	const PdgId pid2 = pi->pdg_id();
	if (PID::isHadron(pid2) && PID::hasBottom(pid2)) return true;
	}
	}
	}
	}
	return false;
	}


	Particles Jet::tags(const Cut& c) const {
	- Particles rtn;
	- foreach (const Particle& p, tags()) {
	- if (c->accept(p)) rtn.push_back(p);
	- }
	- return rtn;
	+ return filter_select(tags(), c);
	}

	-
	Particles Jet::bTags(const Cut& c) const {
	Particles rtn;
	- foreach (const Particle& tp, tags()) {
	+ for (const Particle& tp : tags()) {
	if (hasBottom(tp) && c->accept(tp)) rtn.push_back(tp);
	}
	return rtn;
	}

	-
	Particles Jet::cTags(const Cut& c) const {
	Particles rtn;
	- foreach (const Particle& tp, tags()) {
	+ for (const Particle& tp : tags()) {
	/// @todo Is making b and c tags exclusive the right thing to do?
	if (hasCharm(tp) && !hasBottom(tp) && c->accept(tp)) rtn.push_back(tp);
	}
	return rtn;
	}

	-
	Particles Jet::tauTags(const Cut& c) const {
	Particles rtn;
	- foreach (const Particle& tp, tags()) {
	+ for (const Particle& tp : tags()) {
	if (isTau(tp) && c->accept(tp)) rtn.push_back(tp);
	}
	return rtn;
	}


	- /// Filter a jet collection in-place to the subset that passes the supplied Cut
	- Jets& filterBy(Jets& jets, const Cut& c) {
	- if (c != Cuts::OPEN) {
	- const auto newend = std::remove_if(jets.begin(), jets.end(), [&](const Jet& j){ return !c->accept(j); });
	- jets.erase(newend, jets.end());
	- }
	- return jets;
	- }
	-
	- /// Get a subset of the supplied jets that passes the supplied Cut
	- Jets filterBy(const Jets& jets, const Cut& c) {
	- // Just return a copy if the cut is open
	- if (c == Cuts::OPEN) return jets;
	- // But if there is a non-trivial cut...
	- Jets rtn;
	- std::copy_if(jets.begin(), jets.end(), back_inserter(rtn), [&](const Jet& j){ return c->accept(j); });
	- return rtn;
	- }
	-
	-
	}
	diff --git a/src/Core/Makefile.am b/src/Core/Makefile.am
	--- a/src/Core/Makefile.am
	+++ b/src/Core/Makefile.am
	@@ -1,13 +1,12 @@
	SUBDIRS = yamlcpp

	noinst_LTLIBRARIES = libRivetCore.la
	libRivetCore_la_LIBADD = $(builddir)/yamlcpp/librivet-yaml-cpp.la

	libRivetCore_la_SOURCES = \
	- Run.cc Event.cc Jet.cc Particle.cc ParticleName.cc \
	+ Run.cc Event.cc Jet.cc Particle.cc \
	ProjectionApplier.cc Projection.cc \
	Analysis.cc AnalysisLoader.cc AnalysisInfo.cc \
	- AnalysisHandler.cc ProjectionHandler.cc \
	- Cuts.cc
	+ AnalysisHandler.cc ProjectionHandler.cc

	libRivetCore_la_CPPFLAGS = -I$(srcdir)/yamlcpp -DYAMLCPP_API=3 -DYAML_NAMESPACE=RIVET_YAML $(AM_CPPFLAGS)
	diff --git a/src/Core/Particle.cc b/src/Core/Particle.cc
	--- a/src/Core/Particle.cc
	+++ b/src/Core/Particle.cc
	@@ -1,100 +1,266 @@
	#include "Rivet/Particle.hh"
	-#include "Rivet/Cuts.hh"
	+#include "Rivet/Tools/Cuts.hh"
	#include "Rivet/Tools/ParticleIdUtils.hh"

	namespace Rivet {


	- /// @todo Neaten this up with C++11, via one walker function and several uses with lamba tests
	+ Particle& Particle::transformBy(const LorentzTransform& lt) {
	+ _momentum = lt.transform(_momentum);
	+ return *this;
	+ }


	- bool Particle::hasAncestor(PdgId pdg_id) const {
	- const GenVertex* prodVtx = genParticle()->production_vertex();
	- if (prodVtx == NULL) return false;
	- foreach (const GenParticle* ancestor, particles(prodVtx, HepMC::ancestors)) {
	- if (ancestor->pdg_id() == pdg_id) return true;
	- }
	+ bool Particle::isVisible() const {
	+ // Charged particles are visible
	+ if ( PID::threeCharge(pid()) != 0 ) return true;
	+ // Neutral hadrons are visible
	+ if ( PID::isHadron(pid()) ) return true;
	+ // Photons are visible
	+ if ( pid() == PID::PHOTON ) return true;
	+ // Gluons are visible (for parton level analyses)
	+ if ( pid() == PID::GLUON ) return true;
	+ // Everything else is invisible
	return false;
	}


	- bool Particle::fromBottom() const {
	- const GenVertex* prodVtx = genParticle()->production_vertex();
	- if (prodVtx == NULL) return false;
	- foreach (const GenParticle* ancestor, particles(prodVtx, HepMC::ancestors)) {
	- const PdgId pid = ancestor->pdg_id();
	- if (ancestor->status() == 2 && (PID::isHadron(pid) && PID::hasBottom(pid))) return true;
	- }
	- return false;
	+ bool Particle::isStable() const {
	+ return genParticle() != NULL &&
	+ genParticle()->status() == 1 &&
	+ genParticle()->end_vertex() == NULL;
	}


	- bool Particle::fromCharm() const {
	- const GenVertex* prodVtx = genParticle()->production_vertex();
	- if (prodVtx == NULL) return false;
	- foreach (const GenParticle* ancestor, particles(prodVtx, HepMC::ancestors)) {
	- const PdgId pid = ancestor->pdg_id();
	- if (ancestor->status() == 2 && (PID::isHadron(pid) && PID::hasCharm(pid) && !PID::hasBottom(pid))) return true;
	+ vector<Particle> Particle::parents(const Cut& c) const {
	+ vector<Particle> rtn;
	+ /// @todo Remove this const mess crap when HepMC doesn't suck
	+ GenVertexPtr gv = const_cast<GenVertexPtr>( genParticle()->production_vertex() );
	+ if (gv == NULL) return rtn;
	+ /// @todo Would like to do this, but the range objects are broken
	+ // foreach (const GenParticlePtr gp, gv->particles(HepMC::children))
	+ // rtn += Particle(gp);
	+ for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::parents); it != gv->particles_end(HepMC::parents); ++it) {
	+ const Particle p(*it);
	+ if (c != Cuts::OPEN && !c->accept(p)) continue;
	+ rtn += p;
	}
	- return false;
	+ return rtn;
	}


	+ vector<Particle> Particle::children(const Cut& c) const {
	+ vector<Particle> rtn;
	+ if (isStable()) return rtn;
	+ /// @todo Remove this const mess crap when HepMC doesn't suck
	+ GenVertexPtr gv = const_cast<GenVertexPtr>( genParticle()->end_vertex() );
	+ if (gv == NULL) return rtn;
	+ /// @todo Would like to do this, but the range objects are broken
	+ // foreach (const GenParticlePtr gp, gv->particles(HepMC::children))
	+ // rtn += Particle(gp);
	+ for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::children); it != gv->particles_end(HepMC::children); ++it) {
	+ const Particle p(*it);
	+ if (c != Cuts::OPEN && !c->accept(p)) continue;
	+ rtn += p;
	+ }
	+ return rtn;
	+ }
	+
	+
	+ /// @todo Insist that the current particle is post-hadronization, otherwise throw an exception?
	+ /// @todo Use recursion through replica-avoiding functions to avoid bookkeeping duplicates
	+ vector<Particle> Particle::allDescendants(const Cut& c, bool remove_duplicates) const {
	+ vector<Particle> rtn;
	+ if (isStable()) return rtn;
	+ /// @todo Remove this const mess crap when HepMC doesn't suck
	+ GenVertexPtr gv = const_cast<GenVertexPtr>( genParticle()->end_vertex() );
	+ if (gv == NULL) return rtn;
	+ /// @todo Would like to do this, but the range objects are broken
	+ // foreach (const GenParticlePtr gp, gv->particles(HepMC::descendants))
	+ for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::descendants); it != gv->particles_end(HepMC::descendants); ++it) {
	+ const Particle p(*it);
	+ if (c != Cuts::OPEN && !c->accept(p)) continue;
	+ if (remove_duplicates && (*it)->end_vertex() != NULL) {
	+ // size_t n = 0; ///< @todo Only remove 1-to-1 duplicates?
	+ bool dup = false;
	+ /// @todo Yuck, HepMC
	+ for (GenVertex::particle_iterator it2 = (it)->end_vertex()->particles_begin(HepMC::children); it2 != (it)->end_vertex()->particles_end(HepMC::children); ++it2) {
	+ // n += 1; if (n > 1) break;
	+ if ((it)->pdg_id() == (it2)->pdg_id()) { dup = true; break; }
	+ }
	+ if (dup) continue;
	+ }
	+ rtn += p;
	+ }
	+ return rtn;
	+ }
	+
	+
	+ /// @todo Insist that the current particle is post-hadronization, otherwise throw an exception?
	+ vector<Particle> Particle::stableDescendants(const Cut& c) const {
	+ vector<Particle> rtn;
	+ if (isStable()) return rtn;
	+ /// @todo Remove this const mess crap when HepMC doesn't suck
	+ GenVertexPtr gv = const_cast<GenVertexPtr>( genParticle()->end_vertex() );
	+ if (gv == NULL) return rtn;
	+ /// @todo Would like to do this, but the range objects are broken
	+ // foreach (const GenParticlePtr gp, gv->particles(HepMC::descendants))
	+ for (GenVertex::particle_iterator it = gv->particles_begin(HepMC::descendants); it != gv->particles_end(HepMC::descendants); ++it) {
	+ // if ((it)->status() != 1 \|\| (it)->end_vertex() != NULL) continue;
	+ const Particle p(*it);
	+ if (!p.isStable()) continue;
	+ if (c != Cuts::OPEN && !c->accept(p)) continue;
	+ rtn += p;
	+ }
	+ return rtn;
	+ }
	+
	+
	+ double Particle::flightLength() const {
	+ if (isStable()) return -1;
	+ if (genParticle() == NULL) return 0;
	+ if (genParticle()->production_vertex() == NULL) return 0;
	+ const HepMC::FourVector v1 = genParticle()->production_vertex()->position();
	+ const HepMC::FourVector v2 = genParticle()->end_vertex()->position();
	+ return sqrt(sqr(v2.x()-v1.x()) + sqr(v2.y()-v1.y()) + sqr(v2.z()-v1.z()));
	+ }
	+
	+
	+ bool Particle::hasParent(PdgId pid) const {
	+ return _hasRelativeWith(HepMC::parents, hasPID(pid));
	+ }
	+
	+ bool Particle::hasParentWith(const Cut& c) const {
	+ return hasParentWith([&](const Particle& p){return c->accept(p);});
	+ }
	+
	+
	+ bool Particle::hasAncestor(PdgId pid) const {
	+ return _hasRelativeWith(HepMC::ancestors, hasPID(pid));
	+ }
	+
	+ bool Particle::hasAncestorWith(const Cut& c) const {
	+ return hasAncestorWith([&](const Particle& p){return c->accept(p);});
	+ }
	+
	+
	+ bool Particle::fromBottom() const {
	+ return _hasRelativeWith(HepMC::ancestors, [](const Particle& p){
	+ return p.genParticle()->status() == 2 && p.isHadron() && p.hasBottom();
	+ });
	+ // const GenVertexPtr prodVtx = genParticle()->production_vertex();
	+ // if (prodVtx == NULL) return false;
	+ // foreach (const GenParticlePtr ancestor, particles(prodVtx, HepMC::ancestors)) {
	+ // const PdgId pid = ancestor->pdg_id();
	+ // if (ancestor->status() == 2 && (PID::isHadron(pid) && PID::hasBottom(pid))) return true;
	+ // }
	+ // return false;
	+ }
	+
	+
	+ bool Particle::fromCharm() const {
	+ return _hasRelativeWith(HepMC::ancestors, [](const Particle& p){
	+ return p.genParticle()->status() == 2 && p.isHadron() && p.hasCharm();
	+ });
	+ // const GenVertexPtr prodVtx = genParticle()->production_vertex();
	+ // if (prodVtx == NULL) return false;
	+ // foreach (const GenParticlePtr ancestor, particles(prodVtx, HepMC::ancestors)) {
	+ // const PdgId pid = ancestor->pdg_id();
	+ // if (ancestor->status() == 2 && (PID::isHadron(pid) && PID::hasCharm(pid) && !PID::hasBottom(pid))) return true;
	+ // }
	+ // return false;
	+ }
	+

	bool Particle::fromHadron() const {
	- const GenVertex* prodVtx = genParticle()->production_vertex();
	- if (prodVtx == NULL) return false;
	- foreach (const GenParticle* ancestor, particles(prodVtx, HepMC::ancestors)) {
	- const PdgId pid = ancestor->pdg_id();
	- if (ancestor->status() == 2 && PID::isHadron(pid)) return true;
	- }
	- return false;
	+ return _hasRelativeWith(HepMC::ancestors, [](const Particle& p){
	+ return p.genParticle()->status() == 2 && p.isHadron();
	+ });
	+ // const GenVertexPtr prodVtx = genParticle()->production_vertex();
	+ // if (prodVtx == NULL) return false;
	+ // foreach (const GenParticlePtr ancestor, particles(prodVtx, HepMC::ancestors)) {
	+ // const PdgId pid = ancestor->pdg_id();
	+ // if (ancestor->status() == 2 && PID::isHadron(pid)) return true;
	+ // }
	+ // return false;
	}


	bool Particle::fromTau(bool prompt_taus_only) const {
	if (prompt_taus_only && fromHadron()) return false;
	- const GenVertex* prodVtx = genParticle()->production_vertex();
	- if (prodVtx == NULL) return false;
	- foreach (const GenParticle* ancestor, particles(prodVtx, HepMC::ancestors)) {
	- const PdgId pid = ancestor->pdg_id();
	- if (ancestor->status() == 2 && abs(pid) == PID::TAU) return true;
	- }
	- return false;
	+ return _hasRelativeWith(HepMC::ancestors, [](const Particle& p){
	+ return p.genParticle()->status() == 2 && isTau(p);
	+ });
	+ // const GenVertexPtr prodVtx = genParticle()->production_vertex();
	+ // if (prodVtx == NULL) return false;
	+ // foreach (const GenParticlePtr ancestor, particles(prodVtx, HepMC::ancestors)) {
	+ // const PdgId pid = ancestor->pdg_id();
	+ // if (ancestor->status() == 2 && abs(pid) == PID::TAU) return true;
	+ // }
	+ // return false;
	}


	// bool Particle::fromDecay() const {
	- // const GenVertex* prodVtx = genParticle()->production_vertex();
	+ // const GenVertexPtr prodVtx = genParticle()->production_vertex();
	// if (prodVtx == NULL) return false;
	- // foreach (const GenParticle* ancestor, particles(prodVtx, HepMC::ancestors)) {
	+ // foreach (const GenParticlePtr ancestor, particles(prodVtx, HepMC::ancestors)) {
	// const PdgId pid = ancestor->pdg_id();
	// if (ancestor->status() == 2 && (PID::isHadron(pid) \|\| abs(pid) == PID::TAU)) return true;
	// }
	// return false;
	// }


	- /////////////////////
	+ bool Particle::isPrompt(bool allow_from_prompt_tau, bool allow_from_prompt_mu) const {
	+ if (genParticle() == NULL) return false; // no HepMC connection, give up! Throw UserError exception?
	+ const GenVertexPtr prodVtx = genParticle()->production_vertex();
	+ if (prodVtx == NULL) return false; // orphaned particle, has to be assume false
	+ const pair<GenParticlePtr, GenParticlePtr> beams = prodVtx->parent_event()->beam_particles();

	-
	- Particles& filterBy(Particles& particles, const Cut& c) {
	- if (c != Cuts::OPEN) {
	- const auto newend = std::remove_if(particles.begin(), particles.end(), [&](const Particle& p){ return !c->accept(p); });
	- particles.erase(newend, particles.end());
	+ /// @todo Would be nicer to be able to write this recursively up the chain, exiting as soon as a parton or string/cluster is seen
	+ for (const GenParticlePtr ancestor : Rivet::particles(prodVtx, HepMC::ancestors)) {
	+ const PdgId pid = ancestor->pdg_id();
	+ if (ancestor->status() != 2) continue; // no non-standard statuses or beams to be used in decision making
	+ if (ancestor == beams.first \|\| ancestor == beams.second) continue; // PYTHIA6 uses status 2 for beams, I think... (sigh)
	+ if (PID::isParton(pid)) continue; // PYTHIA6 also uses status 2 for some partons, I think... (sigh)
	+ if (PID::isHadron(pid)) return false; // prompt particles can't be from hadron decays
	+ if (abs(pid) == PID::TAU && abspid() != PID::TAU && !allow_from_prompt_tau) return false; // allow or ban particles from tau decays (permitting tau copies)
	+ if (abs(pid) == PID::MUON && abspid() != PID::MUON && !allow_from_prompt_mu) return false; // allow or ban particles from muon decays (permitting muon copies)
	}
	- return particles;
	+ return true;
	}

	- /// Get a subset of the supplied particles that passes the supplied Cut
	- Particles filterBy(const Particles& particles, const Cut& c) {
	- // Just return a copy if the cut is open
	- if (c == Cuts::OPEN) return particles;
	- // But if there is a non-trivial cut...
	- Particles rtn;
	- std::copy_if(particles.begin(), particles.end(), rtn.begin(), [&](const Particle& p){ return c->accept(p); });
	- return rtn;
	+
	+
	+ ///////////////////////
	+
	+
	+
	+ string to_str(const Particle& p) {
	+ string pname;
	+ try {
	+ pname = PID::toParticleName(p.pid());
	+ } catch (...) {
	+ pname = "PID=" + to_str(p.pid());
	+ }
	+ stringstream out;
	+ out << pname << " @ " << p.momentum() << " GeV";
	+ return out.str();
	}


	+ string to_str(const ParticlePair& pair) {
	+ stringstream out;
	+ out << "[" << pair.first << ", " << pair.second << "]";
	+ // out << "["
	+ // << PID::toParticleName(pair.first.pid()) << " @ "
	+ // << pair.first.momentum().E()/GeV << " GeV, "
	+ // << PID::toParticleName(pair.second.pid()) << " @ "
	+ // << pair.second.momentum().E()/GeV << " GeV]";
	+ return out.str();
	+ }
	+
	+
	+
	}
	diff --git a/src/Core/Projection.cc b/src/Core/Projection.cc
	--- a/src/Core/Projection.cc
	+++ b/src/Core/Projection.cc
	@@ -1,59 +1,56 @@
	// -- C++ --
	+#include "Rivet/Event.hh"
	#include "Rivet/Projection.hh"
	#include "Rivet/Tools/Logging.hh"
	-#include "Rivet/BeamConstraint.hh"
	-#include "Rivet/Event.hh"
	-#include "Rivet/Cmp.hh"
	+#include "Rivet/Tools/BeamConstraint.hh"
	+#include "Rivet/Tools/Cmp.hh"

	namespace Rivet {


	Projection::Projection()
	: _name("BaseProjection")
	{
	addPdgIdPair(PID::ANY, PID::ANY);
	}


	Projection:: ~Projection() { }


	Projection& Projection::operator = (const Projection&) { return *this; }


	bool Projection::before(const Projection& p) const {
	const std::type_info& thisid = typeid(*this);
	const std::type_info& otherid = typeid(p);
	if (thisid == otherid) {
	return compare(p) < 0;
	} else {
	return thisid.before(otherid);
	}
	}


	const set<PdgIdPair> Projection::beamPairs() const {
	set<PdgIdPair> ret = _beamPairs;
	set<ConstProjectionPtr> projs = getProjections();
	for (set<ConstProjectionPtr>::const_iterator ip = projs.begin(); ip != projs.end(); ++ip) {
	ConstProjectionPtr p = *ip;
	getLog() << Log::TRACE << "Proj addr = " << p << endl;
	if (p) ret = intersection(ret, p->beamPairs());
	}
	return ret;
	}


	- Cmp<Projection> Projection::mkNamedPCmp(const Projection& otherparent,
	- const string& pname) const {
	+ Cmp<Projection> Projection::mkNamedPCmp(const Projection& otherparent, const string& pname) const {
	return pcmp(*this, otherparent, pname);
	}

	-
	- Cmp<Projection> Projection::mkPCmp(const Projection& otherparent,
	- const string& pname) const {
	+ Cmp<Projection> Projection::mkPCmp(const Projection& otherparent, const string& pname) const {
	return pcmp(*this, otherparent, pname);
	}


	}
	diff --git a/src/Core/ProjectionApplier.cc b/src/Core/ProjectionApplier.cc
	--- a/src/Core/ProjectionApplier.cc
	+++ b/src/Core/ProjectionApplier.cc
	@@ -1,46 +1,46 @@
	// -- C++ --
	#include "Rivet/ProjectionApplier.hh"
	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Event.hh"

	namespace Rivet {


	// NB. Allow proj registration in constructor by default -- explicitly disable for Analysis
	ProjectionApplier::ProjectionApplier()
	: _allowProjReg(true), _owned(false),
	_projhandler(ProjectionHandler::getInstance())
	{ }


	ProjectionApplier::~ProjectionApplier() {
	if ( ! _owned )
	getProjHandler().removeProjectionApplier(*this);
	}


	const Projection& ProjectionApplier::_applyProjection(const Event& evt,
	const string& name) const {
	return evt.applyProjection(getProjection(name));
	}


	const Projection& ProjectionApplier::_applyProjection(const Event& evt,
	const Projection& proj) const {
	return evt.applyProjection(proj);
	}


	- const Projection& ProjectionApplier::_addProjection(const Projection& proj,
	+ const Projection& ProjectionApplier::_declareProjection(const Projection& proj,
	const std::string& name) {
	if (!_allowProjReg) {
	cerr << "Trying to register projection '"
	<< proj.name() << "' before init phase in '" << this->name() << "'." << endl;
	exit(2);
	}
	const Projection& reg = getProjHandler().registerProjection(*this, proj, name);
	return reg;
	}


	}
	diff --git a/src/Core/ProjectionHandler.cc b/src/Core/ProjectionHandler.cc
	--- a/src/Core/ProjectionHandler.cc
	+++ b/src/Core/ProjectionHandler.cc
	@@ -1,258 +1,257 @@
	// -- C++ --
	#include "Rivet/Config/RivetCommon.hh"
	-#include "Rivet/Tools/Logging.hh"
	#include "Rivet/ProjectionHandler.hh"
	-#include "Rivet/Cmp.hh"
	+#include "Rivet/Tools/Cmp.hh"
	#include <algorithm>

	namespace {
	// Get a logger.
	Rivet::Log& getLog() {
	return Rivet::Log::getLog("Rivet.ProjectionHandler");
	}
	}

	namespace Rivet {


	// Take a Projection, compare it to the others on record, and return (by
	// reference) an equivalent Projection which is guaranteed to be the
	// (persistent) version that will be applied to an event.
	const Projection& ProjectionHandler::registerProjection(const ProjectionApplier& parent,
	const Projection& proj,
	const string& name)
	{
	getLog() << Log::TRACE << "Trying to register"
	<< " projection " << &proj << " (" << proj.name() << ")"
	<< " for parent " << &parent << " (" << parent.name() << ")"
	<< " with name '" << name << "'" << endl;

	// Check for duplicate use of "name" on "parent"
	const bool dupOk = _checkDuplicate(parent, proj, name);
	if (!dupOk) {
	cerr << "Duplicate name '" << name << "' in parent '" << parent.name() << "'." << endl;
	exit(1);
	}

	// Choose which version of the projection to register with this parent and name
	ProjHandle ph = _getEquiv(proj);
	if ( ph ) {
	const Projection & ret = _register(parent, ph, name);
	return ret;
	}
	else {
	unique_ptr<Projection> p = _clone(proj);
	const Projection & ret = _register(parent, move(p), name);
	// Return registered proj
	return ret;
	}
	}

	// Clone neatly
	unique_ptr<Projection> ProjectionHandler::_clone(const Projection& proj)
	{
	// Clone a new copy of the passed projection on the heap
	getLog() << Log::TRACE << "Cloning projection " << proj.name() << " from " << &proj << "..." << endl;
	unique_ptr<Projection> newproj = proj.clone();
	getLog() << Log::TRACE << "...cloned to " << proj.name() << " at " << newproj.get() << endl;

	// Copy all the child ProjHandles when cloning, since otherwise links to "stack parents"
	// will be generated by their children, without any connection to the cloned parent
	if (&proj != newproj.get()) {
	auto nps = _namedprojs.find(&proj);
	if (nps != _namedprojs.end()) {
	getLog() << Log::TRACE << "Cloning registered projections list: "
	<< &proj << " -> " << newproj.get() << endl;
	getLog() << Log::TRACE << "** creates " << newproj.get() << " -> (map from " << nps->first << ")\n";
	_namedprojs[newproj.get()] = nps->second;
	}
	}

	return newproj;
	}



	// Take a Projection, and register it in the registry.
	const Projection& ProjectionHandler::_register(const ProjectionApplier& parent,
	ProjHandle p,
	const string& name)
	{
	// here we take ownership of the projection
	- getLog() << Log::TRACE << "Registering new projection at " << p.get()
	+ getLog() << Log::TRACE << "Registering new projection at " << p.get()
	<< ". Starting refcount: " << p.use_count() << endl;

	// Add the passed Projection to _projs

	_projs.insert(p);
	- getLog() << Log::TRACE
	+ getLog() << Log::TRACE
	<< "** inserted " << p.get() << " to lookup. Refcount: " << p.use_count() << endl;


	// Add the ProjApplier* => name location to the associative container
	_namedprojs[&parent][name] = p;
	- getLog() << Log::TRACE
	+ getLog() << Log::TRACE
	<< "** created " << &parent << " -> (" << name << ',' <<
	p.get() << "). Refcount: " << p.use_count() << endl;

	p->markAsOwned();

	return *p;
	}




	// Try to find a equivalent projection in the system
	ProjHandle ProjectionHandler::_getEquiv(const Projection& proj) const
	{
	// Get class type using RTTI
	const std::type_info& newtype = typeid(proj);
	getLog() << Log::TRACE << "RTTI type of " << &proj << " is " << newtype.name() << endl;

	// Compare to ALL projections via _projs collection
	getLog() << Log::TRACE << "Comparing " << &proj
	<< " with " << _projs.size()
	<< " registered projection" << (_projs.size() == 1 ? "" : "s") << endl;
	foreach (const ProjHandle& ph, _projs) {
	// Make sure the concrete types match, using RTTI.
	const std::type_info& regtype = typeid(*ph);
	getLog() << Log::TRACE << " RTTI type comparison with " << ph << ": "
	<< newtype.name() << " vs. " << regtype.name() << endl;
	if (newtype != regtype) continue;
	getLog() << Log::TRACE << " RTTI type matches with " << ph << endl;

	// Test for semantic match
	if (pcmp(*ph, proj) != EQUIVALENT) {
	getLog() << Log::TRACE << " Projections at "
	<< &proj << " and " << ph << " are not equivalent" << endl;
	} else {
	getLog() << Log::TRACE << " MATCH! Projections at "
	<< &proj << " and " << ph << " are equivalent" << endl;
	return ph;
	}
	}
	getLog() << Log::TRACE << " Nothing matches." << endl;
	// If no match, just return a null pointer
	return nullptr;
	}



	string ProjectionHandler::_getStatus() const {
	ostringstream msg;
	msg << "Current projection hierarchy:" << endl;
	foreach (const NamedProjsMap::value_type& nps, _namedprojs) {
	//const string parentname = nps.first->name();
	msg << nps.first << endl; //"(" << parentname << ")" << endl;
	foreach (const NamedProjs::value_type& np, nps.second) {
	msg << " " << np.second << " (" << np.second->name()
	<< ", locally called '" << np.first << "')" << endl;
	}
	msg << endl;
	}
	return msg.str();
	}



	// Check that the same parent hasn't already used this name for something else
	bool ProjectionHandler::_checkDuplicate(const ProjectionApplier& parent,
	const Projection& proj,
	const string& name) const
	{
	auto listedParent = _namedprojs.find(&parent);
	if (listedParent != _namedprojs.end()) {
	const NamedProjs pnps = listedParent->second;
	const NamedProjs::const_iterator ipph = pnps.find(name);
	if (ipph != pnps.end()) {
	const ProjHandle pph = ipph->second;
	getLog() << Log::ERROR << "Projection clash! "
	<< parent.name() << " (" << &parent << ") "
	<< "is trying to overwrite its registered '" << name << "' "
	<< "projection (" << pph << "="
	<< pph->name() << ") with a non-equivalent projection "
	<< "(" << &proj << "=" << proj.name() << ")" << endl;
	getLog() << Log::ERROR << _getStatus();
	return false;
	}
	}
	return true;
	}




	void ProjectionHandler::removeProjectionApplier(ProjectionApplier& parent) {
	auto npi = _namedprojs.find(&parent);
	if (npi != _namedprojs.end()) {
	getLog() << Log::TRACE << "REMOVE Projection at "
	<< &parent << " from map" << endl;
	_namedprojs.erase(npi);
	}
	//
	auto pAsProj = dynamic_cast<Projection*>(&parent);
	if (pAsProj) {
	- auto pi = find_if(_projs.begin(), _projs.end(),
	+ auto pi = find_if(_projs.begin(), _projs.end(),
	[pAsProj](ProjHandle h)->bool { return h.get() == pAsProj; } );
	if (pi != _projs.end()) {
	getLog() << Log::TRACE << "REMOVE Projection at "
	<< pAsProj << " from lookup" << endl;
	_projs.erase(pi);

	}
	}
	}




	set<const Projection*> ProjectionHandler::getChildProjections(const ProjectionApplier& parent,
	ProjDepth depth) const
	{
	set<const Projection*> toplevel;
	NamedProjs nps = _namedprojs.find(&parent)->second;
	foreach (NamedProjs::value_type& np, nps) {
	toplevel.insert(np.second.get());
	}
	if (depth == SHALLOW) {
	// Only return the projections directly contained within the top level
	return toplevel;
	} else {
	// Return recursively built projection list
	set<const Projection*> alllevels = toplevel;
	foreach (const Projection* p, toplevel) {
	set<const Projection> allsublevels = getChildProjections(p, DEEP);
	alllevels.insert(allsublevels.begin(), allsublevels.end());
	}
	return alllevels;
	}
	}




	const Projection& ProjectionHandler::getProjection(const ProjectionApplier& parent,
	const string& name) const {
	//getLog() << Log::TRACE << "Searching for child projection '"
	// << name << "' of " << &parent << endl;
	NamedProjsMap::const_iterator nps = _namedprojs.find(&parent);
	if (nps == _namedprojs.end()) {
	ostringstream msg;
	msg << "No projections registered for parent " << &parent;
	throw Error(msg.str());
	}
	NamedProjs::const_iterator np = nps->second.find(name);
	if (np == nps->second.end()) {
	ostringstream msg;
	msg << "No projection '" << name << "' found for parent " << &parent;
	throw Error(msg.str());
	}
	// If it's registered with the projection handler, we must be able to safely
	// dereference the Projection pointer to a reference...
	return *(np->second);
	}



	}
	diff --git a/src/Core/Run.cc b/src/Core/Run.cc
	--- a/src/Core/Run.cc
	+++ b/src/Core/Run.cc
	@@ -1,146 +1,155 @@
	// -- C++ --
	#include "Rivet/Run.hh"
	#include "Rivet/AnalysisHandler.hh"
	#include "HepMC/IO_GenEvent.h"
	#include "Rivet/Math/MathUtils.hh"
	#include <limits>

	namespace Rivet {


	Run::Run(AnalysisHandler& ah)
	: _ah(ah), _fileweight(1.0), _xs(NAN)
	{ }


	Run::~Run() { }


	Run& Run::setCrossSection(const double xs) {
	_xs = xs;
	return *this;
	}


	double Run::crossSection() const {
	return _ah.crossSection();
	}


	Run& Run::setListAnalyses(const bool dolist) {
	_listAnalyses = dolist;
	return *this;
	}


	// Fill event and check for a bad read state
	bool Run::readEvent() {
	/// @todo Clear rather than new the GenEvent object per-event?
	_evt.reset(new GenEvent());
	if (_io->rdstate() != 0 \|\| !_io->fill_next_event(_evt.get()) ) {
	Log::getLog("Rivet.Run") << Log::DEBUG << "Read failed. End of file?" << endl;
	return false;
	}
	// Rescale event weights by file-level weight, if scaling is non-trivial
	if (!fuzzyEquals(_fileweight, 1.0)) {
	for (size_t i = 0; i < (size_t) _evt->weights().size(); ++i) {
	_evt->weights()[i] *= _fileweight;
	}
	}
	return true;
	}
	+
	+ // Fill event and check for a bad read state --- to skip, maybe HEPMC3 will have a better way
	+ bool Run::skipEvent() {
	+ if (_io->rdstate() != 0 \|\| !_io->fill_next_event(_evt.get()) ) {
	+ Log::getLog("Rivet.Run") << Log::DEBUG << "Read failed. End of file?" << endl;
	+ return false;
	+ }
	+ return true;
	+ }


	bool Run::openFile(const std::string& evtfile, double weight) {
	// Set current weight-scaling member
	_fileweight = weight;

	// Set up HepMC input reader objects
	if (evtfile == "-") {
	_io.reset(new HepMC::IO_GenEvent(std::cin));
	} else {
	// Ignore the HepMC::IO_GenEvent(filename, ios) constructor, since it's only available from HepMC 2.4
	_istr.reset(new std::fstream(evtfile.c_str(), std::ios::in));
	_io.reset(new HepMC::IO_GenEvent(*_istr));
	}
	if (_io->rdstate() != 0) {
	Log::getLog("Rivet.Run") << Log::ERROR << "Read error on file " << evtfile << endl;
	return false;
	}
	return true;
	}


	bool Run::init(const std::string& evtfile, double weight) {
	if (!openFile(evtfile, weight)) return false;

	// Read first event to define run conditions
	bool ok = readEvent();
	if (!ok) return false;
	if (_evt->particles_size() == 0) {
	Log::getLog("Rivet.Run") << Log::ERROR << "Empty first event." << endl;
	return false;
	}

	// Initialise AnalysisHandler with beam information from first event
	_ah.init(*_evt);

	// Set cross-section from command line
	- if (!isnan(_xs)) {
	+ if (!std::isnan(_xs)) {
	Log::getLog("Rivet.Run")
	<< Log::DEBUG << "Setting user cross-section = " << _xs << " pb" << endl;
	_ah.setCrossSection(_xs);
	}

	// List the chosen & compatible analyses if requested
	if (_listAnalyses) {
	foreach (const std::string& ana, _ah.analysisNames()) {
	cout << ana << endl;
	}
	}

	return true;
	}


	bool Run::processEvent() {
	// Set cross-section if found in event and not from command line
	#ifdef HEPMC_HAS_CROSS_SECTION
	if (std::isnan(_xs) && _evt->cross_section()) {
	const double xs = _evt->cross_section()->cross_section(); ///< in pb
	Log::getLog("Rivet.Run")
	<< Log::DEBUG << "Setting cross-section = " << xs << " pb" << endl;
	_ah.setCrossSection(xs);
	}
	#endif
	// Complain about absence of cross-section if required!
	if (_ah.needCrossSection() && !_ah.hasCrossSection()) {
	Log::getLog("Rivet.Run")
	<< Log::ERROR
	<< "Total cross-section needed for at least one of the analyses. "
	<< "Please set it (on the command line with '-x' if using the 'rivet' program)" << endl;
	return false;
	}

	// Analyze event
	_ah.analyze(*_evt);

	return true;
	}


	bool Run::finalize() {
	_evt.reset();
	_istr.reset();
	_io.reset();

	- if (!isnan(_xs)) _ah.setCrossSection(_xs);
	+ if (!std::isnan(_xs)) _ah.setCrossSection(_xs);
	_ah.finalize();

	return true;
	}




	}
	diff --git a/src/Projections/Beam.cc b/src/Projections/Beam.cc
	--- a/src/Projections/Beam.cc
	+++ b/src/Projections/Beam.cc
	@@ -1,78 +1,130 @@
	// -- C++ --
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Tools/Logging.hh"
	#include "Rivet/Projections/Beam.hh"

	namespace Rivet {


	ParticlePair beams(const Event& e) {
	assert(e.genEvent()->particles_size() >= 2);
	if (e.genEvent()->valid_beam_particles()) {
	pair<HepMC::GenParticle, HepMC::GenParticle> beams = e.genEvent()->beam_particles();
	assert(beams.first && beams.second);
	return ParticlePair{beams.first, beams.second};
	} else if (e.genEvent()->barcode_to_particle(1) && e.genEvent()->barcode_to_particle(2)) {
	return ParticlePair{e.genEvent()->barcode_to_particle(1), e.genEvent()->barcode_to_particle(2)};
	}
	return ParticlePair{Particle(PID::ANY, FourMomentum()), Particle(PID::ANY, FourMomentum())};
	}


	double sqrtS(const FourMomentum& pa, const FourMomentum& pb) {
	const double mom1 = pa.pz();
	const double e1 = pa.E();
	const double mom2 = pb.pz();
	const double e2 = pb.E();
	double sqrts = sqrt( sqr(e1+e2) - sqr(mom1+mom2) );
	return sqrts;
	}


	double asqrtS(const FourMomentum& pa, const FourMomentum& pb) {
	const static double MNUCLEON = 939*MeV; //< nominal nucleon mass
	- return sqrtS(pa, pb) / (pa.mass()/MNUCLEON + pb.mass()/MNUCLEON);
	+ return sqrtS(pa/(pa.mass()/MNUCLEON), pb/(pb.mass()/MNUCLEON));
	}

	double asqrtS(const ParticlePair& beams) {
	- return sqrtS(beams) / (nuclA(beams.first) + nuclA(beams.second));
	+ return sqrtS(beams.first.mom()/nuclA(beams.first), beams.second.mom()/nuclA(beams.second));
	}


	- Vector3 cmsBoost(const FourMomentum& pa, const FourMomentum& pb) {
	- Vector3 rtn = (pa.p3() + pb.p3()) / (pa.E() + pb.E());
	+ FourMomentum acmsBoostVec(const FourMomentum& pa, const FourMomentum& pb) {
	+ const static double MNUCLEON = 939*MeV; //< nominal nucleon mass
	+ const double na = pa.mass()/MNUCLEON, nb = pb.mass()/MNUCLEON;
	+ return cmsBoostVec(pa/na, pb/nb);
	+ }
	+
	+ FourMomentum acmsBoostVec(const ParticlePair& beams) {
	+ return cmsBoostVec(beams.first.mom()/nuclA(beams.first), beams.second.mom()/nuclA(beams.second));
	+ }
	+
	+
	+ Vector3 cmsBetaVec(const FourMomentum& pa, const FourMomentum& pb) {
	+ // const Vector3 rtn = (pa.p3() + pb.p3()) / (pa.E() + pb.E());
	+ const Vector3 rtn = (pa + pb).betaVec();
	return rtn;
	}

	+ Vector3 acmsBetaVec(const FourMomentum& pa, const FourMomentum& pb) {
	+ const static double MNUCLEON = 939*MeV; //< nominal nucleon mass
	+ const Vector3 rtn = cmsBetaVec(pa/(pa.mass()/MNUCLEON), pb/(pb.mass()/MNUCLEON));
	+ return rtn;
	+ }
	+
	+ Vector3 acmsBetaVec(const ParticlePair& beams) {
	+ const Vector3 rtn = cmsBetaVec(beams.first.mom()/nuclA(beams.first), beams.second.mom()/nuclA(beams.second));
	+ return rtn;
	+ }
	+
	+
	+ Vector3 cmsGammaVec(const FourMomentum& pa, const FourMomentum& pb) {
	+ // const Vector3 rtn = (pa + pb).gammaVec();
	+ const double gamma = (pa.E() + pb.E()) / sqrt( sqr(pa.mass()) + sqr(pb.mass()) + 2(pa.E()pb.E() - dot(pa.p3(), pb.p3())) );
	+ const Vector3 rtn = gamma * (pa.p3() + pb.p3()).unit();
	+ return rtn;
	+ }
	+
	+ Vector3 acmsGammaVec(const FourMomentum& pa, const FourMomentum& pb) {
	+ const static double MNUCLEON = 939*MeV; //< nominal nucleon mass
	+ Vector3 rtn = cmsGammaVec(pa/(pa.mass()/MNUCLEON), pb/(pb.mass()/MNUCLEON));
	+ return rtn;
	+ }
	+
	+ Vector3 acmsGammaVec(const ParticlePair& beams) {
	+ Vector3 rtn = cmsGammaVec(beams.first.mom()/nuclA(beams.first), beams.second.mom()/nuclA(beams.second));
	+ return rtn;
	+ }
	+

	LorentzTransform cmsTransform(const FourMomentum& pa, const FourMomentum& pb) {
	- return LorentzTransform(-cmsBoost(pa, pb));
	+ /// @todo Automatically choose to construct from beta or gamma according to which is more precise?
	+ return LorentzTransform::mkFrameTransformFromGamma(cmsGammaVec(pa, pb));
	+ }
	+
	+ LorentzTransform acmsTransform(const FourMomentum& pa, const FourMomentum& pb) {
	+ /// @todo Automatically choose to construct from beta or gamma according to which is more precise?
	+ return LorentzTransform::mkFrameTransformFromGamma(acmsGammaVec(pa, pb));
	+ }
	+
	+ LorentzTransform acmsTransform(const ParticlePair& beams) {
	+ return LorentzTransform::mkFrameTransformFromGamma(acmsGammaVec(beams));
	}



	/////////////////////////////////////////////



	void Beam::project(const Event& e) {
	_theBeams = Rivet::beams(e);
	MSG_DEBUG("Beam particles = " << _theBeams << " => sqrt(s) = " << sqrtS()/GeV << " GeV");
	}


	FourVector Beam::pv() const {
	HepMC::FourVector v1, v2;
	const ParticlePair bpair = beams();
	if (bpair.first.genParticle() && bpair.first.genParticle()->end_vertex())
	v1 = bpair.first.genParticle()->end_vertex()->position();
	if (bpair.second.genParticle() && bpair.second.genParticle()->end_vertex())
	v2 = bpair.second.genParticle()->end_vertex()->position();
	const FourVector rtn = (v1 == v2) ? FourVector(v1.t(), v1.x(), v1.y(), v1.z()) : FourVector();
	MSG_DEBUG("Beam PV 4-position = " << rtn);
	return rtn;
	}



	}
	diff --git a/src/Projections/ChargedLeptons.cc b/src/Projections/ChargedLeptons.cc
	--- a/src/Projections/ChargedLeptons.cc
	+++ b/src/Projections/ChargedLeptons.cc
	@@ -1,27 +1,27 @@
	// -- C++ --
	#include "Rivet/Projections/ChargedLeptons.hh"

	namespace Rivet {


	int ChargedLeptons::compare(const Projection& other) const {
	return mkNamedPCmp(other, "ChFS");
	}


	void ChargedLeptons::project(const Event& evt) {
	// Reset result
	_theParticles.clear();

	// Loop over charged particles and fill vector with leptons
	const FinalState& fs = applyProjection<FinalState>(evt, "ChFS");
	foreach (const Particle& p, fs.particles()) {
	- if (PID::isLepton(p.pid())) {
	+ if (PID::isChargedLepton(p.pid())) {
	_theParticles += Particle(p);
	}
	}
	std::sort(_theParticles.begin(), _theParticles.end(), cmpMomByPt);
	}


	}
	diff --git a/src/Projections/DISKinematics.cc b/src/Projections/DISKinematics.cc
	--- a/src/Projections/DISKinematics.cc
	+++ b/src/Projections/DISKinematics.cc
	@@ -1,75 +1,75 @@
	// -- C++ --
	#include "Rivet/Projections/DISKinematics.hh"
	#include "Rivet/Math/Constants.hh"

	namespace Rivet {


	void DISKinematics::project(const Event& e) {
	// Identify beam hadron
	const ParticlePair& inc = applyProjection<Beam>(e, "Beam").beams();
	bool firstIsHadron = PID::isHadron(inc.first.pid());
	bool secondIsHadron = PID::isHadron(inc.second.pid());
	if (firstIsHadron && !secondIsHadron) {
	_inHadron = inc.first;
	} else if (!firstIsHadron && secondIsHadron) {
	_inHadron = inc.second;
	} else {
	//help!
	throw Error("DISKinematics projector could not find the correct beam hadron");
	}

	// Get the DIS lepton and store some of its properties
	const DISLepton& dislep = applyProjection<DISLepton>(e, "Lepton");
	const FourMomentum pLepIn = dislep.in().momentum();
	const FourMomentum pLepOut = dislep.out().momentum();
	const FourMomentum pHad = _inHadron.momentum();
	const FourMomentum pGamma = pLepIn - pLepOut;
	const FourMomentum tothad = pGamma + pHad;
	_theQ2 = -pGamma.mass2();
	_theW2 = tothad.mass2();
	_theX = Q2()/(2.0 * pGamma * pHad);
	_theY = (pGamma * pHad) / (pLepIn * pHad);
	_theS = invariant(pLepIn + pHad);

	// Calculate boost vector for boost into HCM-system
	LorentzTransform tmp;
	- tmp.setBoost(-tothad.boostVector());
	+ tmp.setBetaVec(-tothad.boostVector());

	// Rotate so the photon is in x-z plane in HCM rest frame
	FourMomentum pGammaHCM = tmp.transform(pGamma);
	tmp.preMult(Matrix3(Vector3::mkZ(), -pGammaHCM.azimuthalAngle()));
	pGammaHCM = tmp.transform(pGamma);
	assert(isZero(dot(pGammaHCM.vector3(), Vector3::mkY())));

	// Rotate so the photon is along the positive z-axis
	const double rot_angle = pGammaHCM.polarAngle() * (pGammaHCM.px() >= 0 ? -1 : 1);
	tmp.preMult(Matrix3(Vector3::mkY(), rot_angle));
	// Check that final HCM photon lies along +ve z as expected
	pGammaHCM = tmp.transform(pGamma);
	assert(isZero(dot(pGammaHCM.vector3(), Vector3::mkX()), 1e-3));
	assert(isZero(dot(pGammaHCM.vector3(), Vector3::mkY()), 1e-3));
	assert(isZero(angle(pGammaHCM.vector3(), Vector3::mkZ()), 1e-3));

	// Finally rotate so outgoing lepton at phi = 0
	FourMomentum pLepOutHCM = tmp.transform(pLepOut);
	tmp.preMult(Matrix3(Vector3::mkZ(), -pLepOutHCM.azimuthalAngle()));
	assert(isZero(tmp.transform(pLepOut).azimuthalAngle()));
	_hcm = tmp;

	// Boost to Breit frame (use opposite convention for photon --- along minus z)
	tmp.preMult(Matrix3(Vector3::mkX(), PI));
	const double bz = 1 - 2*x();
	- _breit = LorentzTransform(Vector3::mkZ() * bz).combine(tmp);
	+ _breit = LorentzTransform::mkObjTransformFromBeta(Vector3::mkZ() * bz).combine(tmp);
	assert(isZero(angle(_breit.transform(pGamma).vector3(), -Vector3::mkZ()), 1e-3));
	assert(isZero(_breit.transform(pLepOut).azimuthalAngle(), 1e-3));
	}


	int DISKinematics::compare(const Projection & p) const {
	const DISKinematics& other = pcast<DISKinematics>(p);
	return mkNamedPCmp(other, "Lepton");
	}


	}
	diff --git a/src/Projections/DressedLeptons.cc b/src/Projections/DressedLeptons.cc
	--- a/src/Projections/DressedLeptons.cc
	+++ b/src/Projections/DressedLeptons.cc
	@@ -1,118 +1,89 @@
	// -- C++ --
	#include "Rivet/Projections/DressedLeptons.hh"

	namespace Rivet {


	- /// @todo Reduce the cut & paste duplication between the constructors. With C++11 constructors can chain...
	-
	-
	DressedLeptons::DressedLeptons(const FinalState& photons, const FinalState& bareleptons,
	double dRmax, const Cut& cut, bool cluster, bool useDecayPhotons)
	: FinalState(cut),
	_dRmax(dRmax), _cluster(cluster), _fromDecay(useDecayPhotons)
	{
	setName("DressedLeptons");
	- IdentifiedFinalState photonfs(photons);
	- photonfs.acceptId(PID::PHOTON);
	+
	+ IdentifiedFinalState photonfs(photons, PID::PHOTON);
	addProjection(photonfs, "Photons");
	- addProjection(bareleptons, "Leptons");
	+
	+ IdentifiedFinalState leptonfs(bareleptons);
	+ leptonfs.acceptIdPairs({PID::ELECTRON, PID::MUON, PID::TAU});
	+ addProjection(leptonfs, "Leptons");
	}


	- DressedLeptons::DressedLeptons(const FinalState& photons, const FinalState& bareleptons,
	- double dRmax, bool cluster, const Cut& cut,
	- bool useDecayPhotons)
	- : FinalState(cut),
	- _dRmax(dRmax), _cluster(cluster), _fromDecay(useDecayPhotons)
	- {
	- setName("DressedLeptons");
	- IdentifiedFinalState photonfs(photons);
	- photonfs.acceptId(PID::PHOTON);
	- addProjection(photonfs, "Photons");
	- addProjection(bareleptons, "Leptons");
	- }
	-
	-
	- DressedLeptons::DressedLeptons(const FinalState& photons, const FinalState& bareleptons,
	- double dRmax, bool cluster,
	- double etaMin, double etaMax,
	- double pTmin, bool useDecayPhotons)
	- : FinalState(etaMin, etaMax, pTmin),
	- _dRmax(dRmax), _cluster(cluster), _fromDecay(useDecayPhotons)
	- {
	- setName("DressedLeptons");
	- IdentifiedFinalState photonfs(photons);
	- photonfs.acceptId(PID::PHOTON);
	- addProjection(photonfs, "Photons");
	- addProjection(bareleptons, "Leptons");
	- }
	-
	-
	-
	int DressedLeptons::compare(const Projection& p) const {
	// Compare the two as final states (for pT and eta cuts)
	const DressedLeptons& other = dynamic_cast<const DressedLeptons&>(p);
	int fscmp = FinalState::compare(other);
	if (fscmp != EQUIVALENT) return fscmp;

	const PCmp phcmp = mkNamedPCmp(p, "Photons");
	if (phcmp != EQUIVALENT) return phcmp;

	const PCmp sigcmp = mkNamedPCmp(p, "Leptons");
	if (sigcmp != EQUIVALENT) return sigcmp;

	return (cmp(_dRmax, other._dRmax) \|\|
	cmp(_cluster, other._cluster) \|\|
	cmp(_fromDecay, other._fromDecay));
	}


	void DressedLeptons::project(const Event& e) {
	_theParticles.clear();
	_clusteredLeptons.clear();

	const FinalState& signal = applyProjection<FinalState>(e, "Leptons");
	Particles bareleptons = signal.particles();
	if (bareleptons.empty()) return;

	vector<DressedLepton> allClusteredLeptons;
	for (size_t i = 0; i < bareleptons.size(); ++i) {
	allClusteredLeptons.push_back(DressedLepton(bareleptons[i]));
	}

	// Match each photon to its closest charged lepton within the dR cone
	const FinalState& photons = applyProjection<FinalState>(e, "Photons");
	- foreach (const Particle& photon, photons.particles()) {
	+ for (const Particle& photon : photons.particles()) {
	// Ignore photon if it's from a hadron/tau decay and we're avoiding those
	if (!_fromDecay && photon.fromDecay()) continue;
	- const FourMomentum p_P = photon.momentum();
	+ const FourMomentum& p_P = photon.momentum();
	double dRmin = _dRmax;
	int idx = -1;
	for (size_t i = 0; i < bareleptons.size(); ++i) {
	// Only cluster photons around charged signal particles
	- if (PID::threeCharge(bareleptons[i].pid()) == 0) continue;
	+ if (bareleptons[i].charge3() == 0) continue;
	// Find the closest lepton
	const FourMomentum& p_l = bareleptons[i].momentum();
	double dR = deltaR(p_l, p_P);
	if (dR < dRmin) {
	dRmin = dR;
	idx = i;
	}
	}
	if (idx > -1) {
	if (_cluster) allClusteredLeptons[idx].addPhoton(photon, _cluster);
	}
	}

	- foreach (const DressedLepton& lepton, allClusteredLeptons) {
	+ for (const DressedLepton& lepton : allClusteredLeptons) {
	if (accept(lepton)) {
	_clusteredLeptons.push_back(lepton);
	_theParticles.push_back(lepton.constituentLepton());
	- _theParticles.insert(_theParticles.end(),
	- lepton.constituentPhotons().begin(),
	- lepton.constituentPhotons().end());
	+ _theParticles += lepton.constituentPhotons();
	}
	}
	+
	}
	+
	+
	}
	diff --git a/src/Projections/FinalState.cc b/src/Projections/FinalState.cc
	--- a/src/Projections/FinalState.cc
	+++ b/src/Projections/FinalState.cc
	@@ -1,84 +1,82 @@
	// -- C++ --
	#include "Rivet/Projections/FinalState.hh"

	namespace Rivet {


	FinalState::FinalState(const Cut & c)
	: ParticleFinder(c)
	{
	setName("FinalState");
	- const bool open = ( c == Cuts::open() );
	+ const bool open = (c == Cuts::open());
	MSG_TRACE("Check for open FS conditions: " << std::boolalpha << open);
	if (!open) addProjection(FinalState(), "OpenFS");
	}


	/// @deprecated, keep for backwards compatibility for now.
	- FinalState::FinalState(double mineta, double maxeta, double minpt)
	- {
	- using namespace Cuts;
	+ FinalState::FinalState(double mineta, double maxeta, double minpt) {
	setName("FinalState");
	const bool openpt = isZero(minpt);
	const bool openeta = (mineta <= -MAXDOUBLE && maxeta >= MAXDOUBLE);
	MSG_TRACE("Check for open FS conditions:" << std::boolalpha << " eta=" << openeta << ", pt=" << openpt);
	- if ( openpt && openeta ) {
	- _cuts = open();
	+ if (openpt && openeta) {
	+ _cuts = Cuts::open();
	}
	else {
	addProjection(FinalState(), "OpenFS");
	- if ( openeta )
	- _cuts = pT >= minpt;
	+ if (openeta)
	+ _cuts = (Cuts::pT >= minpt);
	else if ( openpt )
	- _cuts = etaIn(mineta,maxeta);
	+ _cuts = Cuts::etaIn(mineta, maxeta);
	else
	- _cuts = etaIn(mineta,maxeta) & (pT >= minpt);
	+ _cuts = (Cuts::etaIn(mineta, maxeta) && Cuts::pT >= minpt);
	}
	}


	int FinalState::compare(const Projection& p) const {
	const FinalState& other = dynamic_cast<const FinalState&>(p);
	return _cuts == other._cuts ? EQUIVALENT : UNDEFINED;
	}


	void FinalState::project(const Event& e) {
	_theParticles.clear();

	// Handle "open FS" special case
	if (_cuts == Cuts::OPEN) {
	MSG_TRACE("Open FS processing: should only see this once per event (" << e.genEvent()->event_number() << ")");
	for (const GenParticle* p : Rivet::particles(e.genEvent())) {
	if (p->status() == 1) {
	MSG_TRACE("FS GV = " << p->production_vertex());
	_theParticles.push_back(Particle(*p));
	}
	}
	return;
	}

	// If this is not itself the "open" FS, base the calculations on the open FS' results
	/// @todo In general, we'd like to calculate a restrictive FS based on the most restricted superset FS.
	const Particles allstable = applyProjection<FinalState>(e, "OpenFS").particles();
	for (const Particle& p : allstable) {
	const bool passed = accept(p);
	MSG_TRACE("Choosing: ID = " << p.pid()
	<< ", pT = " << p.pT()/GeV << " GeV"
	<< ", eta = " << p.eta()
	<< ": result = " << std::boolalpha << passed);
	if (passed) _theParticles.push_back(p);
	}
	MSG_TRACE("Number of final-state particles = " << _theParticles.size());
	}


	/// Decide if a particle is to be accepted or not.
	bool FinalState::accept(const Particle& p) const {
	// Not having status == 1 should never happen!
	assert(p.genParticle() == NULL \|\| p.genParticle()->status() == 1);
	return _cuts->accept(p);
	}


	}
	diff --git a/src/Projections/IdentifiedFinalState.cc b/src/Projections/IdentifiedFinalState.cc
	--- a/src/Projections/IdentifiedFinalState.cc
	+++ b/src/Projections/IdentifiedFinalState.cc
	@@ -1,94 +1,86 @@
	// -- C++ --
	#include "Rivet/Projections/IdentifiedFinalState.hh"

	namespace Rivet {


	IdentifiedFinalState::IdentifiedFinalState(const FinalState& fsp, const vector<PdgId>& pids) {
	setName("IdentifiedFinalState");
	addProjection(fsp, "FS");
	acceptIds(pids);
	}

	IdentifiedFinalState::IdentifiedFinalState(const vector<PdgId>& pids, const FinalState& fsp) {
	setName("IdentifiedFinalState");
	addProjection(fsp, "FS");
	acceptIds(pids);
	}

	IdentifiedFinalState::IdentifiedFinalState(const FinalState& fsp, PdgId pid) {
	setName("IdentifiedFinalState");
	addProjection(fsp, "FS");
	acceptId(pid);
	}

	IdentifiedFinalState::IdentifiedFinalState(PdgId pid, const FinalState& fsp) {
	setName("IdentifiedFinalState");
	addProjection(fsp, "FS");
	acceptId(pid);
	}


	IdentifiedFinalState::IdentifiedFinalState(const Cut& c, const vector<PdgId>& pids) {
	setName("IdentifiedFinalState");
	addProjection(FinalState(c), "FS");
	acceptIds(pids);
	}

	IdentifiedFinalState::IdentifiedFinalState(const vector<PdgId>& pids, const Cut& c) {
	setName("IdentifiedFinalState");
	addProjection(FinalState(c), "FS");
	acceptIds(pids);
	}

	IdentifiedFinalState::IdentifiedFinalState(const Cut& c, PdgId pid) {
	setName("IdentifiedFinalState");
	addProjection(FinalState(c), "FS");
	acceptId(pid);
	}

	IdentifiedFinalState::IdentifiedFinalState(PdgId pid, const Cut& c) {
	setName("IdentifiedFinalState");
	addProjection(FinalState(c), "FS");
	acceptId(pid);
	}


	- IdentifiedFinalState::IdentifiedFinalState(double etamin, double etamax, double ptMin)
	- // : FinalState(etamin, etamax, ptMin)
	- {
	- setName("IdentifiedFinalState");
	- addProjection(FinalState(etamin, etamax, ptMin), "FS");
	- }
	-
	-

	int IdentifiedFinalState::compare(const Projection& p) const {
	const PCmp fscmp = mkNamedPCmp(p, "FS");
	if (fscmp != EQUIVALENT) return fscmp;

	const IdentifiedFinalState& other = dynamic_cast<const IdentifiedFinalState&>(p);
	int pidssize = cmp(_pids.size(), other._pids.size());
	if (pidssize != EQUIVALENT) return pidssize;
	return cmp(_pids, other._pids);
	}


	void IdentifiedFinalState::project(const Event& e) {
	const FinalState& fs = applyProjection<FinalState>(e, "FS");
	_theParticles.clear();
	_theParticles.reserve(fs.particles().size());
	_remainingParticles.clear();
	_remainingParticles.reserve(fs.particles().size());
	foreach (const Particle& p, fs.particles()) {
	if (acceptedIds().find(p.pid()) != acceptedIds().end()) {
	_theParticles.push_back(p); // Identified
	}
	else {
	_remainingParticles.push_back(p); // Remaining
	}
	}
	}


	}
	diff --git a/src/Projections/Makefile.am b/src/Projections/Makefile.am
	--- a/src/Projections/Makefile.am
	+++ b/src/Projections/Makefile.am
	@@ -1,45 +1,46 @@
	noinst_LTLIBRARIES = libRivetProjections.la
	libRivetProjections_la_SOURCES = \
	Beam.cc \
	BeamThrust.cc \
	ChargedFinalState.cc \
	ChargedLeptons.cc \
	CentralEtHCM.cc \
	DISFinalState.cc \
	DISKinematics.cc \
	DISLepton.cc \
	DressedLeptons.cc \
	FastJets.cc \
	FinalPartons.cc \
	FinalState.cc \
	FoxWolframMoments.cc \
	FParameter.cc \
	HadronicFinalState.cc \
	HeavyHadrons.cc \
	Hemispheres.cc \
	IdentifiedFinalState.cc \
	InitialQuarks.cc \
	InvMassFinalState.cc \
	JetAlg.cc \
	JetShape.cc \
	LeadingParticlesFinalState.cc \
	MergedFinalState.cc \
	MissingMomentum.cc \
	NeutralFinalState.cc \
	NonHadronicFinalState.cc \
	+ NonPromptFinalState.cc \
	ParisiTensor.cc \
	ParticleFinder.cc \
	PrimaryHadrons.cc \
	PromptFinalState.cc \
	Sphericity.cc \
	Spherocity.cc \
	TauFinder.cc \
	Thrust.cc \
	TriggerCDFRun0Run1.cc \
	TriggerCDFRun2.cc \
	TriggerUA5.cc \
	UnstableFinalState.cc \
	VetoedFinalState.cc \
	VisibleFinalState.cc \
	WFinder.cc \
	ZFinder.cc
	diff --git a/src/Projections/MissingMomentum.cc b/src/Projections/MissingMomentum.cc
	--- a/src/Projections/MissingMomentum.cc
	+++ b/src/Projections/MissingMomentum.cc
	@@ -1,43 +1,46 @@
	// -- C++ --
	#include "Rivet/Projections/MissingMomentum.hh"

	namespace Rivet {


	int MissingMomentum::compare(const Projection& p) const {
	return mkNamedPCmp(p, "VisibleFS");
	}


	void MissingMomentum::clear() {
	_momentum = FourMomentum();
	_set = 0.0;
	_vet = Vector3();
	}


	void MissingMomentum::project(const Event& e) {
	clear();

	// Project into final state
	const FinalState& vfs = applyProjection<FinalState>(e, "VisibleFS");
	- foreach (const Particle& p, vfs.particles()) {
	+ for (const Particle& p : vfs.particles()) {
	const FourMomentum& mom = p.momentum();
	+ const Vector3 ptunit = mom.vector3().setZ(0.0).unit();
	_momentum += mom;
	_set += mom.Et();
	- _vet += mom.Et() * mom.vector3().setZ(0.0).unit();
	+ _spt += mom.pT();
	+ _vet += mom.Et() * ptunit;
	+ _vpt += mom.pT() * ptunit;
	}
	}


	const FourMomentum MissingMomentum::visibleMomentum(double mass) const {
	/// @todo Couldn't we just reset the internal _momentum's mass and return by value? Would require mutable, though
	FourMomentum p4 = _momentum;
	const double pmod2 = p4.p3().mod2();
	const double new_energy = sqrt(pmod2 + sqr(mass));
	p4.setE(new_energy);
	return p4;
	}


	}
	diff --git a/src/Projections/NeutralFinalState.cc b/src/Projections/NeutralFinalState.cc
	--- a/src/Projections/NeutralFinalState.cc
	+++ b/src/Projections/NeutralFinalState.cc
	@@ -1,29 +1,29 @@
	// -- C++ --
	#include "Rivet/Projections/NeutralFinalState.hh"

	namespace Rivet {


	int NeutralFinalState::compare(const Projection& p) const {
	const NeutralFinalState& other = dynamic_cast<const NeutralFinalState&>(p);
	return mkNamedPCmp(other, "FS") \|\| cmp(_Etmin, other._Etmin);
	}


	void NeutralFinalState::project(const Event& e) {
	const FinalState& fs = applyProjection<FinalState>(e, "FS");
	_theParticles.clear();
	- foreach (const Particle& p, fs.particles()){
	- if ((PID::threeCharge(p.pid()) == 0) && (p.Et() > _Etmin)) {
	+ for (const Particle& p : fs.particles()) {
	+ if (p.charge3() == 0 && p.Et() > _Etmin) {
	_theParticles.push_back(p);
	MSG_TRACE("Selected: ID = " << p.pid()
	<< ", Et = " << p.Et()
	<< ", eta = " << p.eta()
	<< ", charge = " << p.charge());
	}
	}
	MSG_DEBUG("Number of neutral final-state particles = " << _theParticles.size());
	}


	}
	diff --git a/src/Projections/NonPromptFinalState.cc b/src/Projections/NonPromptFinalState.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Projections/NonPromptFinalState.cc
	@@ -0,0 +1,46 @@
	+// -- C++ --
	+#include "Rivet/Projections/NonPromptFinalState.hh"
	+
	+namespace Rivet {
	+
	+
	+ NonPromptFinalState::NonPromptFinalState(const FinalState& fsp, bool accepttaudecays, bool acceptmudecays)
	+ : _acceptMuDecays(acceptmudecays), _acceptTauDecays(accepttaudecays)
	+ {
	+ setName("NonPromptFinalState");
	+ addProjection(fsp, "FS");
	+ }
	+
	+
	+ NonPromptFinalState::NonPromptFinalState(const Cut& c, bool accepttaudecays, bool acceptmudecays)
	+ : _acceptMuDecays(acceptmudecays), _acceptTauDecays(accepttaudecays)
	+ {
	+ setName("NonPromptFinalState");
	+ addProjection(FinalState(c), "FS");
	+ }
	+
	+
	+ int NonPromptFinalState::compare(const Projection& p) const {
	+ const PCmp fscmp = mkNamedPCmp(p, "FS");
	+ if (fscmp != EQUIVALENT) return fscmp;
	+ const NonPromptFinalState& other = dynamic_cast<const NonPromptFinalState&>(p);
	+ return cmp(_acceptMuDecays, other._acceptMuDecays) \|\| cmp(_acceptTauDecays, other._acceptTauDecays);
	+ }
	+
	+
	+ void NonPromptFinalState::project(const Event& e) {
	+ _theParticles.clear();
	+
	+ const Particles& particles = applyProjection<FinalState>(e, "FS").particles();
	+ foreach (const Particle& p, particles)
	+ if (!isPrompt(p, !_acceptTauDecays, !_acceptMuDecays)) _theParticles.push_back(p);
	+ MSG_DEBUG("Number of final state particles from hadron decays = " << _theParticles.size());
	+
	+ if (getLog().isActive(Log::TRACE)) {
	+ foreach (const Particle& p, _theParticles)
	+ MSG_TRACE("Selected: " << p.pid() << ", charge = " << p.charge());
	+ }
	+ }
	+
	+
	+}
	diff --git a/src/Projections/PromptFinalState.cc b/src/Projections/PromptFinalState.cc
	--- a/src/Projections/PromptFinalState.cc
	+++ b/src/Projections/PromptFinalState.cc
	@@ -1,65 +1,46 @@
	// -- C++ --
	#include "Rivet/Projections/PromptFinalState.hh"

	namespace Rivet {


	- PromptFinalState::PromptFinalState(const FinalState& fsp)
	- : _acceptMuDecays(false), _acceptTauDecays(false)
	+ PromptFinalState::PromptFinalState(const FinalState& fsp, bool accepttaudecays, bool acceptmudecays)
	+ : _acceptMuDecays(acceptmudecays), _acceptTauDecays(accepttaudecays)
	{
	setName("PromptFinalState");
	addProjection(fsp, "FS");
	}


	- PromptFinalState::PromptFinalState(const Cut & c)
	- : _acceptMuDecays(false), _acceptTauDecays(false)
	+ PromptFinalState::PromptFinalState(const Cut& c, bool accepttaudecays, bool acceptmudecays)
	+ : _acceptMuDecays(acceptmudecays), _acceptTauDecays(accepttaudecays)
	{
	setName("PromptFinalState");
	addProjection(FinalState(c), "FS");
	}

	+
	int PromptFinalState::compare(const Projection& p) const {
	const PCmp fscmp = mkNamedPCmp(p, "FS");
	if (fscmp != EQUIVALENT) return fscmp;
	const PromptFinalState& other = dynamic_cast<const PromptFinalState&>(p);
	return cmp(_acceptMuDecays, other._acceptMuDecays) \|\| cmp(_acceptTauDecays, other._acceptTauDecays);
	}


	- bool PromptFinalState::isPrompt(const Particle& p) const {
	- if (p.genParticle() == NULL) return false; // no HepMC connection, give up! Throw UserError exception?
	- const GenVertex* prodVtx = p.genParticle()->production_vertex();
	- if (prodVtx == NULL) return false; // orphaned particle, has to be assume false
	- const pair<GenParticle, GenParticle> beams = prodVtx->parent_event()->beam_particles();
	-
	- /// @todo Would be nicer to be able to write this recursively up the chain, exiting as soon as a parton or string/cluster is seen
	- foreach (const GenParticle* ancestor, Rivet::particles(prodVtx, HepMC::ancestors)) {
	- const PdgId pid = ancestor->pdg_id();
	- if (ancestor->status() != 2) continue; // no non-standard statuses or beams to be used in decision making
	- if (ancestor == beams.first \|\| ancestor == beams.second) continue; // PYTHIA6 uses status 2 for beams, I think... (sigh)
	- if (PID::isParton(pid)) continue; // PYTHIA6 also uses status 2 for some partons, I think... (sigh)
	- if (PID::isHadron(pid)) return false; // prompt particles can't be from hadron decays
	- if (abs(pid) == PID::TAU && p.abspid() != PID::TAU && !_acceptTauDecays) return false; // allow or ban particles from tau decays (permitting tau copies)
	- if (abs(pid) == PID::MUON && p.abspid() != PID::MUON && !_acceptMuDecays) return false; // allow or ban particles from muon decays (permitting muon copies)
	- }
	- return true;
	- }
	-
	-
	void PromptFinalState::project(const Event& e) {
	_theParticles.clear();

	const Particles& particles = applyProjection<FinalState>(e, "FS").particles();
	- foreach (const Particle& p, particles)
	- if (isPrompt(p)) _theParticles.push_back(p);
	+ for (const Particle& p : particles)
	+ if (isPrompt(p, _acceptTauDecays, _acceptMuDecays)) _theParticles.push_back(p);
	MSG_DEBUG("Number of final state particles not from hadron decays = " << _theParticles.size());

	if (getLog().isActive(Log::TRACE)) {
	- foreach (const Particle& p, _theParticles)
	+ for (const Particle& p : _theParticles)
	MSG_TRACE("Selected: " << p.pid() << ", charge = " << p.charge());
	}
	}


	}
	diff --git a/src/Projections/Sphericity.cc b/src/Projections/Sphericity.cc
	--- a/src/Projections/Sphericity.cc
	+++ b/src/Projections/Sphericity.cc
	@@ -1,137 +1,137 @@
	// -- C++ --
	#include "Rivet/Projections/Sphericity.hh"
	+#include "Rivet/Jet.hh"

	namespace Rivet {


	Sphericity::Sphericity(const FinalState& fsp, double rparam)
	: _regparam(rparam)
	{
	setName("Sphericity");
	addProjection(fsp, "FS");
	clear();
	}


	void Sphericity::clear() {
	_lambdas = vector<double>(3, 0);
	_sphAxes = vector<Vector3>(3, Vector3());
	}


	int Sphericity::compare(const Projection& p) const {
	PCmp fscmp = mkNamedPCmp(p, "FS");
	if (fscmp != EQUIVALENT) return fscmp;
	const Sphericity& other = dynamic_cast<const Sphericity&>(p);
	if (fuzzyEquals(_regparam, other._regparam)) return 0;
	return cmp(_regparam, other._regparam);
	}


	void Sphericity::project(const Event& e) {
	const Particles prts = applyProjection<FinalState>(e, "FS").particles();
	calc(prts);
	}


	void Sphericity::calc(const FinalState& fs) {
	calc(fs.particles());
	}

	- void Sphericity::calc(const vector<Particle>& fsparticles) {
	+
	+ void Sphericity::calc(const Particles& particles) {
	vector<Vector3> threeMomenta;
	- threeMomenta.reserve(fsparticles.size());
	- foreach (const Particle& p, fsparticles) {
	- threeMomenta.push_back( p.momentum().vector3() );
	- }
	- _calcSphericity(threeMomenta);
	+ transform(particles, threeMomenta, p3);
	+ calc(threeMomenta);
	}

	- void Sphericity::calc(const vector<FourMomentum>& fsmomenta) {
	+
	+ void Sphericity::calc(const Jets& jets) {
	vector<Vector3> threeMomenta;
	- threeMomenta.reserve(fsmomenta.size());
	- foreach (const FourMomentum& v, fsmomenta) {
	- threeMomenta.push_back(v.vector3());
	- }
	- _calcSphericity(threeMomenta);
	+ transform(jets, threeMomenta, p3);
	+ calc(threeMomenta);
	}

	- void Sphericity::calc(const vector<Vector3>& fsmomenta) {
	- _calcSphericity(fsmomenta);
	+
	+ void Sphericity::calc(const vector<FourMomentum>& momenta) {
	+ vector<Vector3> threeMomenta;
	+ transform(momenta, threeMomenta, [](const FourMomentum& p4){return p4.vector3();});
	+ calc(threeMomenta);
	}


	- // Actually do the calculation
	- void Sphericity::_calcSphericity(const vector<Vector3>& fsmomenta) {
	+ void Sphericity::calc(const vector<Vector3>& momenta) {
	MSG_DEBUG("Calculating sphericity with r = " << _regparam);

	- // Return (with "safe nonsense" sphericity params) if there are no final state particles.
	- if (fsmomenta.empty()) {
	- MSG_DEBUG("No particles in final state...");
	+ // Return (with "safe nonsense" sphericity params) if there are no final state particles
	+ if (momenta.empty()) {
	+ MSG_DEBUG("No momenta given...");
	clear();
	return;
	}

	// Iterate over all the final state particles.
	Matrix3 mMom;
	double totalMomentum = 0.0;
	- MSG_DEBUG("Number of particles = " << fsmomenta.size());
	- foreach (const Vector3& p3, fsmomenta) {
	+ MSG_DEBUG("Number of particles = " << momenta.size());
	+ for (const Vector3& p3 : momenta) {
	// Build the (regulated) normalising factor.
	totalMomentum += pow(p3.mod(), _regparam);

	// Build (regulated) quadratic momentum components.
	const double regfactor = pow(p3.mod(), _regparam-2);
	if (!fuzzyEquals(regfactor, 1.0)) {
	MSG_TRACE("Regfactor (r=" << _regparam << ") = " << regfactor);
	}

	Matrix3 mMomPart;
	for (size_t i = 0; i < 3; ++i) {
	for (size_t j = 0; j < 3; ++j) {
	mMomPart.set(i,j, p3[i]*p3[j]);
	}
	}
	mMom += regfactor * mMomPart;
	}

	// Normalise to total (regulated) momentum.
	mMom /= totalMomentum;
	MSG_DEBUG("Momentum tensor = " << "\n" << mMom);

	// Check that the matrix is symmetric.
	const bool isSymm = mMom.isSymm();
	if (!isSymm) {
	MSG_ERROR("Error: momentum tensor not symmetric (r=" << _regparam << ")");
	MSG_ERROR("[0,1] vs. [1,0]: " << mMom.get(0,1) << ", " << mMom.get(1,0));
	MSG_ERROR("[0,2] vs. [2,0]: " << mMom.get(0,2) << ", " << mMom.get(2,0));
	MSG_ERROR("[1,2] vs. [2,1]: " << mMom.get(1,2) << ", " << mMom.get(2,1));
	}
	// If not symmetric, something's wrong (we made sure the error msg appeared first).
	assert(isSymm);

	// Diagonalize momentum matrix.
	const EigenSystem<3> eigen3 = diagonalize(mMom);
	MSG_DEBUG("Diag momentum tensor = " << "\n" << eigen3.getDiagMatrix());

	// Reset and set eigenvalue/vector parameters.
	_lambdas.clear();
	_sphAxes.clear();
	const EigenSystem<3>::EigenPairs epairs = eigen3.getEigenPairs();
	assert(epairs.size() == 3);
	for (size_t i = 0; i < 3; ++i) {
	_lambdas.push_back(epairs[i].first);
	_sphAxes.push_back(Vector3(epairs[i].second));
	}

	// Debug output.
	MSG_DEBUG("Lambdas = ("
	<< lambda1() << ", " << lambda2() << ", " << lambda3() << ")");
	MSG_DEBUG("Sum of lambdas = " << lambda1() + lambda2() + lambda3());
	MSG_DEBUG("Vectors = "
	<< sphericityAxis() << ", "
	<< sphericityMajorAxis() << ", "
	<< sphericityMinorAxis() << ")");
	}

	+
	}
	diff --git a/src/Tools/CentralityHistogram.cc b/src/Tools/CentralityHistogram.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Tools/CentralityHistogram.cc
	@@ -0,0 +1,173 @@
	+// -- C++ --
	+#include "Rivet/Tools/CentralityHistogram.hh"
	+#include "Rivet/Tools/RivetYODA.hh"
	+#include "Rivet/Analysis.hh"
	+
	+namespace Rivet {
	+
	+void CentralityHistogram::add(Histo1DPtr hist, double cmin, double cmax,
	+ double cestmin, double cestmax) {
	+ if ( cestmax < 0.0 )
	+ _unfilled.push_back(HistBin(hist, cmin/100.0, cmax/100.0));
	+ else
	+ _ready[hist] = HistBin(hist, cmin/100.0, cmax/100.0, cestmin, cestmax);
	+ _percentiles.insert(cmin/100.0);
	+ _percentiles.insert(cmax/100.0);
	+}
	+
	+
	+CentralityHistogram::FlexiBinSet::iterator
	+CentralityHistogram::_findBin(double cest) const {
	+ FlexiBinSet::iterator it = _flexiBins.upper_bound(FlexiBin(cest));
	+ if ( it != _flexiBins.end() && it != _flexiBins.begin() ) {
	+ --it;
	+ if ( it->_cestLo == cest \|\|
	+ ( it->_cestLo < cest && cest < it->_cestHi ) )
	+ return it;
	+ }
	+ return _flexiBins.end();
	+}
	+
	+void CentralityHistogram::setup(const Event & ev, double centin) {
	+
	+ // Get the estimator value from the associated projection.
	+ _currentCEst = centin >= 0.0? centin:
	+ applyProjection<CentralityEstimator>(ev, _estimator).estimate();
	+ _weightsum += ev.weight();
	+ for ( auto h : _ready )
	+ if ( h.second.inRange(_currentCEst) )
	+ h.second._weightsum += ev.weight();
	+
	+ // If estimator is negative, something has gone wrong.
	+ if ( _currentCEst < 0.0 ) {
	+ _currentHist = Histo1DPtr();
	+ return;
	+ }
	+
	+ // If the current value of the centrality estimator is already in
	+ // use, just return the corresponding histogram.
	+ FlexiBinSet::iterator sit = _findBin(_currentCEst);
	+ if ( sit != _flexiBins.end() ) {
	+ sit->_weightsum += ev.weight();
	+ return;
	+ }
	+
	+ if ( _flexiBins.size() >= _unfilled.size()*_overSamplingFactor )
	+ _currentHist = _purgeSamplers(); // Purge the histogram furthest
	+ // away from a centrality limit.
	+ else
	+ _currentHist = _newSamplerHist(); // Create a new sampler
	+ // histogram
	+
	+ _flexiBins.insert(FlexiBin(_currentHist, _currentCEst, ev.weight()));
	+
	+}
	+
	+Histo1DPtr CentralityHistogram::_newSamplerHist() {
	+ // This is an error;
	+ if ( _unfilled.empty() ) return Histo1DPtr();
	+
	+ Histo1DPtr hist(_unfilled.begin()->_hist->newclone());
	+ hist->reset();
	+ return hist;
	+
	+}
	+
	+Histo1DPtr CentralityHistogram::_purgeSamplers() {
	+
	+ set<double>::iterator citn = _percentiles.begin();
	+ set<double>::iterator cit0 = citn++;
	+
	+ FlexiBinSet::iterator selectit = _flexiBins.begin();
	+ int selectdist = 0;
	+ int counter = 0;
	+
	+ FlexiBinSet::iterator midit = selectit;
	+ int idist = 0;
	+ double totweight = _weightsum;
	+ double accweight = 0.0;
	+
	+ for ( auto curr = _flexiBins.begin(); curr != _flexiBins.end(); ++curr ) {
	+ accweight += curr->_weightsum;
	+ if ( accweight > (citn)totweight ) {
	+ if ( idist > selectdist ) {
	+ selectdist = idist;
	+ selectit = midit;
	+ }
	+ idist = 0;
	+ midit = curr;
	+ cit0 = citn++;
	+ counter = 0;
	+ } else {
	+ ++counter;
	+ // Note that for the first centrality bin we always merge the
	+ // bin closest to 0, and for the last bin always the one closest
	+ // to 100%, for all the rest we choose the middle bin.
	+ if ( cit0 == 0.0 \|\| citn == 1.0 \|\| counter%2 ) ++idist;
	+ if ( *citn == 1.0 \|\| counter%2 ) ++midit;
	+ }
	+ }
	+
	+ FlexiBinSet::iterator mergeit = selectit;
	+ if ( selectit == _flexiBins.begin() ) ++selectit;
	+ else --mergeit;
	+
	+ FlexiBin merged = *mergeit;
	+ FlexiBin selected = *selectit;
	+ merged.merge(*selectit);
	+ _flexiBins.erase(mergeit);
	+ _flexiBins.erase(selectit);
	+ _flexiBins.insert(merged);
	+
	+ return selected._hist;
	+
	+}
	+
	+void CentralityHistogram::finalize() {
	+
	+ // Take the contents of the dynamical binning and fill the original
	+ // histograms.
	+
	+ double clo = 0.0;
	+ for ( const FlexiBin & fb : _flexiBins ) {
	+ double chi = clo + fb._weightsum/_weightsum;
	+ for ( HistBin & hbin : _unfilled ) {
	+ double olo = hbin._centLo;
	+ double ohi = hbin._centHi;
	+ if ( clo > ohi \|\| chi <= olo ) continue;
	+ // If we only have partial overlap we need to scale
	+ double lo = max(olo, clo);
	+ double hi = min(ohi, chi);
	+ Histo1D h = fb._hist->clone();
	+ h.scaleW((hi - lo)/(chi - clo));
	+ *(hbin._hist) += h;
	+ hbin._weightsum += fb._weightsum*(hi - lo)/(chi - clo);
	+ if ( clo <= olo )
	+ hbin._cestLo =
	+ fb._cestLo + (fb._cestHi - fb._cestHi)*(olo - clo)/(chi - clo);
	+ if ( chi > ohi )
	+ hbin._cestHi =
	+ fb._cestLo + (fb._cestHi - fb._cestHi)*(ohi - clo)/(chi - clo);
	+ }
	+ }
	+ _flexiBins.clear();
	+ for ( HistBin & hbin : _unfilled ) _ready[hbin._hist] = hbin;
	+ _unfilled.clear();
	+
	+}
	+
	+void CentralityHistogram::normalizePerEvent() {
	+ for ( auto h : _ready ) h.second.normalizePerEvent();
	+}
	+
	+map<double,double> CentralityHistogram::edges() const {
	+ map<double,double> ret;
	+ for ( auto hbin : _ready ) {
	+ ret[hbin.second._centLo] = hbin.second._cestLo;
	+ ret[hbin.second._centHi] = hbin.second._cestHi;
	+ }
	+ return ret;
	+}
	+
	+
	+}
	diff --git a/src/Core/Cuts.cc b/src/Tools/Cuts.cc
	rename from src/Core/Cuts.cc
	rename to src/Tools/Cuts.cc
	--- a/src/Core/Cuts.cc
	+++ b/src/Tools/Cuts.cc
	@@ -1,399 +1,449 @@
	-#include <Rivet/Cuts.hh>
	+#include "Rivet/Tools/Cuts.hh"
	+#include "Rivet/Particle.hh"
	+#include "Rivet/Jet.hh"
	+#include "Rivet/Math/Vectors.hh"
	+#include "fastjet/PseudoJet.hh"
	+#include "HepMC/SimpleVector.h"

	-// Headers for converters
	-#include <Rivet/Particle.hh>
	-#include <Rivet/Jet.hh>
	-#include <Rivet/Math/Vectors.hh>
	-#include <fastjet/PseudoJet.hh>
	-#include <HepMC/SimpleVector.h>
	-
	-/// @todo Sort out what can go into anonymous namespace
	+/// @todo Identify what can go into anonymous namespace

	namespace Rivet {


	// Base for all wrapper classes that translate ClassToCheck to Cuttable
	class CuttableBase {
	public:
	virtual double getValue(Cuts::Quantity) const = 0;
	virtual ~CuttableBase() {}
	};


	// Cuttables can be directly passed to @ref _accept
	template <>
	- bool CutBase::accept<CuttableBase>(const CuttableBase & t) const {
	+ bool CutBase::accept<CuttableBase>(const CuttableBase& t) const {
	return _accept(t);
	}

	- // bool operator==(const Cut & a, const Cut & b) {
	- // return *a == b;
	- // }
	-

	// Open Cut singleton
	class Open_Cut : public CutBase {
	public:
	- bool operator==(const Cut & c) const {
	+ bool operator==(const Cut& c) const {
	std::shared_ptr<Open_Cut> cc = dynamic_pointer_cast<Open_Cut>(c);
	return bool(cc);
	}
	protected:
	// open cut accepts everything
	- bool _accept(const CuttableBase &) const { return true; }
	+ bool _accept(const CuttableBase&) const { return true; }
	};


	const Cut& Cuts::open() {
	// Only ever need one static open cut object
	static const Cut open = std::make_shared<Open_Cut>();
	return open;
	}

	// Constants for convenient access
	const Cut& Cuts::OPEN = Cuts::open();
	const Cut& Cuts::NOCUT = Cuts::open();


	+ // Cut constructor for ==
	+ class Cut_Eq : public CutBase {
	+ public:
	+ Cut_Eq(const Cuts::Quantity qty, double val) : _qty(qty), _val(val) {}
	+ bool operator==(const Cut& c) const {
	+ std::shared_ptr<Cut_Eq> cc = dynamic_pointer_cast<Cut_Eq>(c);
	+ return cc && _qty == cc->_qty && _val == cc->_val;
	+ }
	+ protected:
	+ bool _accept(const CuttableBase& o) const { return o.getValue(_qty) == _val; }
	+ private:
	+ Cuts::Quantity _qty;
	+ int _val;
	+ };
	+
	+
	+ // Cut constructor for !=
	+ class Cut_NEq : public CutBase {
	+ public:
	+ Cut_NEq(const Cuts::Quantity qty, double val) : _qty(qty), _val(val) {}
	+ bool operator==(const Cut& c) const {
	+ std::shared_ptr<Cut_NEq> cc = dynamic_pointer_cast<Cut_NEq>(c);
	+ return cc && _qty == cc->_qty && _val == cc->_val;
	+ }
	+ protected:
	+ bool _accept(const CuttableBase& o) const { return o.getValue(_qty) != _val; }
	+ private:
	+ Cuts::Quantity _qty;
	+ int _val;
	+ };
	+

	// Cut constructor for >=
	class Cut_GtrEq : public CutBase {
	public:
	- Cut_GtrEq(const Cuts::Quantity qty, const double low) : qty_(qty), low_(low) {}
	- bool operator==(const Cut & c) const {
	+ Cut_GtrEq(const Cuts::Quantity qty, double val) : _qty(qty), _val(val) {}
	+ bool operator==(const Cut& c) const {
	std::shared_ptr<Cut_GtrEq> cc = dynamic_pointer_cast<Cut_GtrEq>(c);
	- return cc && qty_ == cc->qty_ && low_ == cc->low_;
	+ return cc && _qty == cc->_qty && _val == cc->_val;
	}
	protected:
	- bool _accept(const CuttableBase & o) const { return o.getValue(qty_) >= low_; }
	+ bool _accept(const CuttableBase& o) const { return o.getValue(_qty) >= _val; }
	private:
	- Cuts::Quantity qty_;
	- double low_;
	+ Cuts::Quantity _qty;
	+ double _val;
	};


	// Cut constructor for <
	class Cut_Less : public CutBase {
	public:
	- Cut_Less(const Cuts::Quantity qty, const double high) : qty_(qty), high_(high) {}
	- bool operator==(const Cut & c) const {
	+ Cut_Less(const Cuts::Quantity qty, const double val) : _qty(qty), _val(val) {}
	+ bool operator==(const Cut& c) const {
	std::shared_ptr<Cut_Less> cc = dynamic_pointer_cast<Cut_Less>(c);
	- return cc && qty_ == cc->qty_ && high_ == cc->high_;
	+ return cc && _qty == cc->_qty && _val == cc->_val;
	}
	protected:
	- bool _accept(const CuttableBase & o) const { return o.getValue(qty_) < high_; }
	+ bool _accept(const CuttableBase& o) const { return o.getValue(_qty) < _val; }
	private:
	- Cuts::Quantity qty_;
	- double high_;
	+ Cuts::Quantity _qty;
	+ double _val;
	};


	- // Cut constructor for >=
	+ // Cut constructor for >
	class Cut_Gtr : public CutBase {
	public:
	- Cut_Gtr(const Cuts::Quantity qty, const double low) : qty_(qty), low_(low) {}
	- bool operator==(const Cut & c) const {
	+ Cut_Gtr(const Cuts::Quantity qty, const double val) : _qty(qty), _val(val) {}
	+ bool operator==(const Cut& c) const {
	std::shared_ptr<Cut_Gtr> cc = dynamic_pointer_cast<Cut_Gtr>(c);
	- return cc && qty_ == cc->qty_ && low_ == cc->low_;
	+ return cc && _qty == cc->_qty && _val == cc->_val;
	}
	protected:
	- bool _accept(const CuttableBase & o) const { return o.getValue(qty_) > low_; }
	+ bool _accept(const CuttableBase& o) const { return o.getValue(_qty) > _val; }
	private:
	- Cuts::Quantity qty_;
	- double low_;
	+ Cuts::Quantity _qty;
	+ double _val;
	};


	- // Cut constructor for <
	+ // Cut constructor for <=
	class Cut_LessEq : public CutBase {
	public:
	- Cut_LessEq(const Cuts::Quantity qty, const double high) : qty_(qty), high_(high) {}
	- bool operator==(const Cut & c) const {
	+ Cut_LessEq(const Cuts::Quantity qty, const double val) : _qty(qty), _val(val) {}
	+ bool operator==(const Cut& c) const {
	std::shared_ptr<Cut_LessEq> cc = dynamic_pointer_cast<Cut_LessEq>(c);
	- return cc && qty_ == cc->qty_ && high_ == cc->high_;
	+ return cc && _qty == cc->_qty && _val == cc->_val;
	}
	protected:
	- bool _accept(const CuttableBase & o) const { return o.getValue(qty_) <= high_; }
	+ bool _accept(const CuttableBase& o) const { return o.getValue(_qty) <= _val; }
	private:
	- Cuts::Quantity qty_;
	- double high_;
	+ Cuts::Quantity _qty;
	+ double _val;
	};


	template <typename T>
	inline Cut make_cut(T t) {
	return std::make_shared<T>(t);
	}

	+ Cut operator == (Cuts::Quantity qty, double n) {
	+ return make_cut(Cut_Eq(qty, n));
	+ }
	+
	+ Cut operator != (Cuts::Quantity qty, double n) {
	+ return make_cut(Cut_NEq(qty, n));
	+ }
	+
	Cut operator < (Cuts::Quantity qty, double n) {
	return make_cut(Cut_Less(qty, n));
	}

	Cut operator >= (Cuts::Quantity qty, double n) {
	return make_cut(Cut_GtrEq(qty, n));
	}

	Cut operator <= (Cuts::Quantity qty, double n) {
	return make_cut(Cut_LessEq(qty, n));
	}

	Cut operator > (Cuts::Quantity qty, double n) {
	return make_cut(Cut_Gtr(qty, n));
	}

	Cut Cuts::range(Cuts::Quantity qty, double m, double n) {
	if (m > n) std::swap(m,n);
	- return (qty >= m) & (qty < n);
	+ return (qty >= m) && (qty < n);
	}


	//////////////
	/// Combiners

	/// AND, OR, NOT, and XOR objects for combining cuts

	class CutsOr : public CutBase {
	public:
	- CutsOr(const Cut & c1, const Cut & c2) : cut1(c1), cut2(c2) {}
	- bool operator==(const Cut & c) const {
	+ CutsOr(const Cut& c1, const Cut& c2) : cut1(c1), cut2(c2) {}
	+ bool operator==(const Cut& c) const {
	std::shared_ptr<CutsOr> cc = dynamic_pointer_cast<CutsOr>(c);
	return cc && ( ( cut1 == cc->cut1 && cut2 == cc->cut2 )
	\|\| ( cut1 == cc->cut2 && cut2 == cc->cut1 ));
	}
	protected:
	- bool _accept(const CuttableBase & o) const {
	+ bool _accept(const CuttableBase& o) const {
	return cut1->accept(o) \|\| cut2->accept(o);
	}
	private:
	const Cut cut1;
	const Cut cut2;
	};


	class CutsAnd : public CutBase {
	public:
	- CutsAnd(const Cut & c1, const Cut & c2) : cut1(c1), cut2(c2) {}
	- bool operator==(const Cut & c) const {
	+ CutsAnd(const Cut& c1, const Cut& c2) : cut1(c1), cut2(c2) {}
	+ bool operator==(const Cut& c) const {
	std::shared_ptr<CutsAnd> cc = dynamic_pointer_cast<CutsAnd>(c);
	return cc && ( ( cut1 == cc->cut1 && cut2 == cc->cut2 )
	\|\| ( cut1 == cc->cut2 && cut2 == cc->cut1 ));
	}
	protected:
	- bool _accept(const CuttableBase & o) const {
	+ bool _accept(const CuttableBase& o) const {
	return cut1->accept(o) && cut2->accept(o);
	}
	private:
	const Cut cut1;
	const Cut cut2;
	};


	class CutInvert : public CutBase {
	public:
	- CutInvert(const Cut & c1) : cut(c1) {}
	- bool operator==(const Cut & c) const {
	+ CutInvert(const Cut& c1) : cut(c1) {}
	+ bool operator==(const Cut& c) const {
	std::shared_ptr<CutInvert> cc = dynamic_pointer_cast<CutInvert>(c);
	return cc && cut == cc->cut;
	}
	protected:
	- bool _accept(const CuttableBase & o) const {
	+ bool _accept(const CuttableBase& o) const {
	return !cut->accept(o);
	}
	private:
	const Cut cut;
	};


	class CutsXor : public CutBase {
	public:
	- CutsXor(const Cut & c1, const Cut & c2) : cut1(c1), cut2(c2) {}
	- bool operator==(const Cut & c) const {
	+ CutsXor(const Cut& c1, const Cut& c2) : cut1(c1), cut2(c2) {}
	+ bool operator==(const Cut& c) const {
	std::shared_ptr<CutsXor> cc = dynamic_pointer_cast<CutsXor>(c);
	return cc && ( ( cut1 == cc->cut1 && cut2 == cc->cut2 )
	\|\| ( cut1 == cc->cut2 && cut2 == cc->cut1 ));
	}
	protected:
	- bool _accept(const CuttableBase & o) const {
	+ bool _accept(const CuttableBase& o) const {
	bool A_and_B = cut1->accept(o) && cut2->accept(o);
	bool A_or_B = cut1->accept(o) \|\| cut2->accept(o);
	return A_or_B && (! A_and_B);
	}
	private:
	const Cut cut1;
	const Cut cut2;
	};


	////////////
	///Operators

	- Cut operator && (const Cut & aptr, const Cut & bptr) {
	+ Cut operator && (const Cut& aptr, const Cut& bptr) {
	return make_cut(CutsAnd(aptr, bptr));
	}

	- Cut operator \|\| (const Cut & aptr, const Cut & bptr) {
	+ Cut operator \|\| (const Cut& aptr, const Cut& bptr) {
	return make_cut(CutsOr(aptr, bptr));
	}

	- Cut operator ! (const Cut & cptr) {
	+ Cut operator ! (const Cut& cptr) {
	return make_cut(CutInvert(cptr));
	}


	- Cut operator & (const Cut & aptr, const Cut & bptr) {
	+ Cut operator & (const Cut& aptr, const Cut& bptr) {
	return make_cut(CutsAnd(aptr, bptr));
	}

	- Cut operator \| (const Cut & aptr, const Cut & bptr) {
	+ Cut operator \| (const Cut& aptr, const Cut& bptr) {
	return make_cut(CutsOr(aptr, bptr));
	}

	- Cut operator ~ (const Cut & cptr) {
	+ Cut operator ~ (const Cut& cptr) {
	return make_cut(CutInvert(cptr));
	}

	- Cut operator ^ (const Cut & aptr, const Cut & bptr) {
	+ Cut operator ^ (const Cut& aptr, const Cut& bptr) {
	return make_cut(CutsXor(aptr, bptr));
	}


	///////////////////////
	/// Cuts

	// Non-functional Cuttable template class. Must be specialized below.
	- template <typename T> class Cuttable;
	+ template <typename T>
	+ class Cuttable;

	// Non-cuttables need to be wrapped into a Cuttable first
	#define SPECIALISE_ACCEPT(TYPENAME) \
	template <> \
	- bool CutBase::accept<TYPENAME>(const TYPENAME & t) const { \
	+ bool CutBase::accept<TYPENAME>(const TYPENAME& t) const { \
	return _accept(Cuttable<TYPENAME>(t)); \
	} \


	- void qty_not_found() {
	+ inline void qty_not_found() {
	throw Exception("Missing implementation for a Cuts::Quantity.");
	}


	template<>
	class Cuttable<Particle> : public CuttableBase {
	public:
	Cuttable(const Particle& p) : p_(p) {}
	double getValue(Cuts::Quantity qty) const {
	switch ( qty ) {
	- case Cuts::pT: return p_.momentum().pT();
	- case Cuts::Et: return p_.momentum().Et();
	- case Cuts::mass: return p_.momentum().mass();
	- case Cuts::rap: return p_.momentum().rapidity();
	- case Cuts::absrap: return std::abs(p_.momentum().rapidity());
	- case Cuts::eta: return p_.momentum().pseudorapidity();
	- case Cuts::abseta: return std::abs(p_.momentum().pseudorapidity());
	- case Cuts::phi: return p_.momentum().phi();
	+ case Cuts::pT: return p_.pT();
	+ case Cuts::Et: return p_.Et();
	+ case Cuts::mass: return p_.mass();
	+ case Cuts::rap: return p_.rap();
	+ case Cuts::absrap: return p_.absrap();
	+ case Cuts::eta: return p_.eta();
	+ case Cuts::abseta: return p_.abseta();
	+ case Cuts::phi: return p_.phi();
	+ case Cuts::pid: return p_.pid();
	+ case Cuts::abspid: return p_.abspid();
	+ case Cuts::charge: return p_.charge();
	+ case Cuts::abscharge: return p_.abscharge();
	+ case Cuts::charge3: return p_.charge3();
	+ case Cuts::abscharge3: return p_.abscharge3();
	default: qty_not_found();
	}
	return -999.;
	}
	+
	private:
	- const Particle & p_;
	+ const Particle& p_;
	};
	+
	SPECIALISE_ACCEPT(Particle)


	template<>
	class Cuttable<FourMomentum> : public CuttableBase {
	public:
	Cuttable(const FourMomentum& fm) : fm_(fm) {}
	double getValue(Cuts::Quantity qty) const {
	switch ( qty ) {
	case Cuts::pT: return fm_.pT();
	case Cuts::Et: return fm_.Et();
	case Cuts::mass: return fm_.mass();
	- case Cuts::rap: return fm_.rapidity();
	- case Cuts::absrap: return std::abs(fm_.rapidity());
	- case Cuts::eta: return fm_.pseudorapidity();
	- case Cuts::abseta: return std::abs(fm_.pseudorapidity());
	+ case Cuts::rap: return fm_.rap();
	+ case Cuts::absrap: return fm_.absrap();
	+ case Cuts::eta: return fm_.eta();
	+ case Cuts::abseta: return fm_.abseta();
	case Cuts::phi: return fm_.phi();
	default: qty_not_found();
	}
	return -999.;
	}
	+
	private:
	- const FourMomentum & fm_;
	+ const FourMomentum& fm_;
	};
	+
	SPECIALISE_ACCEPT(FourMomentum)


	template<>
	class Cuttable<Jet> : public CuttableBase {
	public:
	Cuttable(const Jet& jet) : jet_(jet) {}
	double getValue(Cuts::Quantity qty) const {
	switch ( qty ) {
	case Cuts::pT: return jet_.momentum().pT();
	case Cuts::Et: return jet_.momentum().Et();
	case Cuts::mass: return jet_.momentum().mass();
	case Cuts::rap: return jet_.momentum().rapidity();
	case Cuts::absrap: return std::abs(jet_.momentum().rapidity());
	case Cuts::eta: return jet_.momentum().pseudorapidity();
	case Cuts::abseta: return std::abs(jet_.momentum().pseudorapidity());
	case Cuts::phi: return jet_.momentum().phi();
	default: qty_not_found();
	}
	return -999.;
	}
	+
	private:
	- const Jet & jet_;
	+ const Jet& jet_;
	};
	+
	SPECIALISE_ACCEPT(Jet)


	template<>
	class Cuttable<fastjet::PseudoJet> : public CuttableBase {
	public:
	Cuttable(const fastjet::PseudoJet& pjet) : pjet_(pjet) {}
	double getValue(Cuts::Quantity qty) const {
	switch ( qty ) {
	case Cuts::pT: return pjet_.perp();
	case Cuts::Et: return pjet_.Et();
	case Cuts::mass: return pjet_.m();
	case Cuts::rap: return pjet_.rap();
	case Cuts::absrap: return std::abs(pjet_.rap());
	case Cuts::eta: return pjet_.eta();
	case Cuts::abseta: return std::abs(pjet_.eta());
	case Cuts::phi: return pjet_.phi();
	default: qty_not_found();
	}
	return -999.;
	}
	+
	private:
	- const fastjet::PseudoJet & pjet_;
	+ const fastjet::PseudoJet& pjet_;
	};
	+
	SPECIALISE_ACCEPT(fastjet::PseudoJet)


	template<>
	class Cuttable<HepMC::FourVector> : public CuttableBase {
	public:
	- Cuttable(const HepMC::FourVector & vec) : vec_(vec) {}
	+ Cuttable(const HepMC::FourVector& vec) : vec_(vec) {}
	double getValue(Cuts::Quantity qty) const {
	switch ( qty ) {
	case Cuts::pT: return vec_.perp();
	/// @todo case Cuts::Et: return vec_.perp();
	case Cuts::mass: return vec_.m();
	case Cuts::rap: return 0.5*std::log((vec_.t()+vec_.z())/(vec_.t()-vec_.z()));
	case Cuts::absrap: return std::abs(getValue(Cuts::rap));
	case Cuts::eta: return vec_.pseudoRapidity();
	case Cuts::abseta: return std::abs(vec_.pseudoRapidity());
	case Cuts::phi: return vec_.phi();
	default: qty_not_found();
	}
	return -999.;
	}
	+
	private:
	- const HepMC::FourVector & vec_;
	+ const HepMC::FourVector& vec_;
	};
	+
	SPECIALISE_ACCEPT(HepMC::FourVector)


	}
	diff --git a/src/Tools/JetUtils.cc b/src/Tools/JetUtils.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Tools/JetUtils.cc
	@@ -0,0 +1,21 @@
	+#include "Rivet/Tools/JetUtils.hh"
	+#include "Rivet/Tools/Cuts.hh"
	+
	+namespace Rivet {
	+
	+
	+ Jets& ifilter_select(Jets& jets, const Cut& c) {
	+ if (c == Cuts::OPEN) return jets;
	+ // return ifilter_select(jets, *c);
	+ return ifilter_select(jets, [&](const Jet& j){return c->accept(j);});
	+ }
	+
	+
	+ Jets& ifilter_discard(Jets& jets, const Cut& c) {
	+ if (c == Cuts::OPEN) { jets.clear(); return jets; }
	+ // return ifilter_discard(jets, *c);
	+ return ifilter_discard(jets, [&](const Jet& j){return c->accept(j);});
	+ }
	+
	+
	+}
	diff --git a/src/Tools/Makefile.am b/src/Tools/Makefile.am
	--- a/src/Tools/Makefile.am
	+++ b/src/Tools/Makefile.am
	@@ -1,15 +1,20 @@
	noinst_LTLIBRARIES = libRivetTools.la

	libRivetTools_la_SOURCES = \
	+ BinnedHistogram.cc \
	+ CentralityHistogram.cc \
	+ Cuts.cc \
	+ JetUtils.cc \
	Logging.cc \
	+ ParticleUtils.cc \
	+ ParticleName.cc \
	RivetYODA.cc \
	+ RivetMT2.cc \
	RivetPaths.cc \
	+ Utils.cc \
	binreloc.c \
	- Utils.cc \
	- mt2_bisect.cc \
	- RivetMT2.cc \
	- BinnedHistogram.cc
	+ mt2_bisect.cc

	dist_noinst_HEADERS = binreloc.h mt2_bisect.hh

	libRivetTools_la_CPPFLAGS = $(AM_CPPFLAGS) -DENABLE_BINRELOC -DDEFAULTDATADIR=\"$(datadir)\" -DDEFAULTLIBDIR=\"$(libdir)\"
	diff --git a/src/Core/ParticleName.cc b/src/Tools/ParticleName.cc
	rename from src/Core/ParticleName.cc
	rename to src/Tools/ParticleName.cc
	--- a/src/Core/ParticleName.cc
	+++ b/src/Tools/ParticleName.cc
	@@ -1,42 +1,42 @@
	-#include "Rivet/ParticleName.hh"
	+#include "Rivet/Tools/ParticleName.hh"
	#include "Rivet/Tools/Utils.hh"

	namespace Rivet {

	namespace PID {


	// Initialise ParticleNames singleton pointer
	unique_ptr<ParticleNames> ParticleNames::_instance = nullptr;


	const std::string& ParticleNames::_particleName(PdgId pid) {
	if (_ids_names.find(pid) == _ids_names.end()) {
	throw PidError("Particle ID '" + lexical_cast<string>(pid) + "' not known.");
	}
	return _ids_names[pid];
	}


	PdgId ParticleNames::_particleId(const std::string& pname) {
	if (_names_ids.find(pname) == _names_ids.end()) {
	if (toUpper(pname) == "P+" \|\| toUpper(pname) == "P") return PROTON;
	if (toUpper(pname) == "P-" \|\| toUpper(pname) == "PBAR") return ANTIPROTON;
	if (toUpper(pname) == "E-") return ELECTRON;
	if (toUpper(pname) == "E+") return POSITRON;
	if (toUpper(pname) == "GAMMA") return PHOTON;
	if (toUpper(pname) == "N") return NEUTRON;
	try {
	PdgId rtn = lexical_cast<PdgId>(pname);
	return rtn;
	} catch (const bad_lexical_cast& blc) {
	throw PidError("Particle name '" + pname + "' not known and could not be directly cast to a PDG ID.");
	}
	}
	return _names_ids[pname];
	}


	}

	}
	diff --git a/src/Tools/ParticleUtils.cc b/src/Tools/ParticleUtils.cc
	new file mode 100644
	--- /dev/null
	+++ b/src/Tools/ParticleUtils.cc
	@@ -0,0 +1,58 @@
	+#include "Rivet/Tools/ParticleUtils.hh"
	+#include "Rivet/Tools/Cuts.hh"
	+
	+namespace Rivet {
	+
	+
	+ FirstParticleWith::FirstParticleWith(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ FirstParticleWithout::FirstParticleWithout(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ LastParticleWith::LastParticleWith(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ LastParticleWithout::LastParticleWithout(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+
	+ HasParticleAncestorWith::HasParticleAncestorWith(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ HasParticleAncestorWithout::HasParticleAncestorWithout(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ HasParticleParentWith::HasParticleParentWith(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ HasParticleParentWithout::HasParticleParentWithout(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ HasParticleChildWith::HasParticleChildWith(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ HasParticleChildWithout::HasParticleChildWithout(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ HasParticleDescendantWith::HasParticleDescendantWith(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+ HasParticleDescendantWithout::HasParticleDescendantWithout(const Cut& c)
	+ : fn([&](const Particle& p){ return c->accept(p); }) { }
	+
	+
	+ Particles& ifilter_select(Particles& particles, const Cut& c) {
	+ if (c == Cuts::OPEN) return particles;
	+ // return ifilter_select(particles, *c);
	+ return ifilter_select(particles, [&](const Particle& p){return c->accept(p);});
	+ }
	+
	+ Particles& ifilter_discard(Particles& particles, const Cut& c) {
	+ if (c == Cuts::OPEN) { particles.clear(); return particles; }
	+ // return ifilter_discard(particles, *c);
	+ return ifilter_discard(particles, [&](const Particle& p){return c->accept(p);});
	+ }
	+
	+
	+}
	diff --git a/src/Tools/RivetPaths.cc b/src/Tools/RivetPaths.cc
	--- a/src/Tools/RivetPaths.cc
	+++ b/src/Tools/RivetPaths.cc
	@@ -1,146 +1,158 @@
	#include "Rivet/Config/RivetCommon.hh"
	#include "Rivet/Tools/RivetPaths.hh"
	#include "Rivet/Tools/Utils.hh"
	#include "binreloc.h"
	#include <cstring>

	namespace Rivet {


	inline string _findFile(const string& filename, const vector<string>& paths) {
	for (const string& dir : paths) {
	const string path = dir + "/" + filename;
	if (fileexists(path)) return path;
	}
	return "";
	}


	string getLibPath() {
	BrInitError error;
	br_init_lib(&error);
	char* temp = br_find_lib_dir(DEFAULTLIBDIR);
	const string libdir(temp);
	free (temp);
	return libdir;
	}

	string getDataPath() {
	BrInitError error;
	br_init_lib(&error);
	char* temp = br_find_data_dir(DEFAULTDATADIR);
	const string sharedir(temp);
	free (temp);
	return sharedir;
	}

	string getRivetDataPath() {
	return getDataPath() + "/Rivet";
	}



	void setAnalysisLibPaths(const vector<string>& paths) {
	const string pathstr = pathjoin(paths);
	setenv("RIVET_ANALYSIS_PATH", pathstr.c_str(), 1);
	}

	void addAnalysisLibPath(const string& extrapath) {
	vector<string> paths = getAnalysisLibPaths();
	paths.push_back(extrapath);
	setAnalysisLibPaths(paths);
	}

	vector<string> getAnalysisLibPaths() {
	vector<string> dirs;
	// Use the Rivet analysis path variable if set...
	const char* env = getenv("RIVET_ANALYSIS_PATH");
	if (env) dirs += pathsplit(env);
	// ... otherwise fall back to the Rivet library install path unless the path ends in ::
	if (!env \|\| strlen(env) < 2 \|\| string(env).substr(strlen(env)-2) != "::")
	dirs += getLibPath();
	return dirs;
	}

	string findAnalysisLibFile(const string& filename) {
	return _findFile(filename, getAnalysisLibPaths());
	}


	+
	+ void setAnalysisDataPaths(const vector<string>& paths) {
	+ const string pathstr = pathjoin(paths);
	+ setenv("RIVET_DATA_PATH", pathstr.c_str(), 1);
	+ }
	+
	+ void addAnalysisDataPath(const string& extrapath) {
	+ vector<string> paths = getAnalysisDataPaths();
	+ paths.push_back(extrapath);
	+ setAnalysisDataPaths(paths);
	+ }
	+
	vector<string> getAnalysisDataPaths() {
	vector<string> dirs;
	// Use the Rivet data path variable if set...
	const char* env = getenv("RIVET_DATA_PATH");
	if (env) dirs += pathsplit(env);
	// ... then, unless the path ends in :: ...
	if (!env \|\| strlen(env) < 2 \|\| string(env).substr(strlen(env)-2) != "::") {
	// ... fall back to the Rivet data install path...
	dirs += getRivetDataPath();
	// ... and also add any analysis plugin search dirs for convenience
	dirs += getAnalysisLibPaths();
	}
	return dirs;
	}

	string findAnalysisDataFile(const string& filename,
	const vector<string>& pathprepend, const vector<string>& pathappend) {
	const vector<string> paths = pathprepend + getAnalysisDataPaths() + pathappend;
	return _findFile(filename, paths);
	}


	vector<string> getAnalysisRefPaths() {
	vector<string> dirs;
	// Use the Rivet ref path variable if set...
	const char* env = getenv("RIVET_REF_PATH");
	if (env) dirs += pathsplit(env);
	// ... and append the universal Rivet data paths, unless the env path ends in ::
	if (!env \|\| strlen(env) < 2 \|\| string(env).substr(strlen(env)-2) != "::")
	dirs += getAnalysisDataPaths();
	return dirs;
	}

	string findAnalysisRefFile(const string& filename,
	const vector<string>& pathprepend, const vector<string>& pathappend) {
	const vector<string> paths = pathprepend + getAnalysisRefPaths() + pathappend;
	return _findFile(filename, paths);
	}


	vector<string> getAnalysisInfoPaths() {
	vector<string> dirs;
	// Use the Rivet info path variable if set...
	const char* env = getenv("RIVET_INFO_PATH");
	if (env) dirs += pathsplit(env);
	// ... and append the universal Rivet data paths, unless the env path ends in ::
	if (!env \|\| strlen(env) < 2 \|\| string(env).substr(strlen(env)-2) != "::")
	dirs += getAnalysisDataPaths();
	return dirs;
	}

	string findAnalysisInfoFile(const string& filename,
	const vector<string>& pathprepend, const vector<string>& pathappend) {
	const vector<string> paths = pathprepend + getAnalysisInfoPaths() + pathappend;
	return _findFile(filename, paths);
	}


	vector<string> getAnalysisPlotPaths() {
	vector<string> dirs;
	// Use the Rivet plot path variable if set...
	const char* env = getenv("RIVET_PLOT_PATH");
	if (env) dirs += pathsplit(env);
	// ... and append the universal Rivet data paths, unless the env path ends in ::
	if (!env \|\| strlen(env) < 2 \|\| string(env).substr(strlen(env)-2) != "::")
	dirs += getAnalysisDataPaths();
	return dirs;
	}

	string findAnalysisPlotFile(const string& filename,
	const vector<string>& pathprepend, const vector<string>& pathappend) {
	const vector<string> paths = pathprepend + getAnalysisPlotPaths() + pathappend;
	return _findFile(filename, paths);
	}


	}
	diff --git a/test/Makefile.am b/test/Makefile.am
	--- a/test/Makefile.am
	+++ b/test/Makefile.am
	@@ -1,33 +1,38 @@
	-check_PROGRAMS = testMath testMatVec testCmp testApi testNaN
	+check_PROGRAMS = testMath testMatVec testCmp testApi testNaN testBeams

	AM_LDFLAGS = -L$(top_srcdir)/src -L$(prefix)/lib $(YAMLCPP_LDFLAGS) -L$(YODALIBPATH)
	LIBS = -lm $(GSL_LDFLAGS) -lYODA

	+TEST_LDADD = $(top_builddir)/src/libRivet.la $(HEPMCLDFLAGS) $(YODALDFLAGS) $(HEPMCLDLIBS) $(YODALDLIBS)
	+
	testMath_SOURCES = testMath.cc
	+testMath_LDADD = $(TEST_LDADD)
	testMatVec_SOURCES = testMatVec.cc
	-
	+testMatVec_LDADD = $(TEST_LDADD)
	testCmp_SOURCES = testCmp.cc
	-testCmp_LDADD = $(top_builddir)/src/libRivet.la $(HEPMCLDFLAGS) $(YODALDFLAGS) $(HEPMCLDLIBS) $(YODALDLIBS)
	+testCmp_LDADD = $(TEST_LDADD)
	testApi_SOURCES = testApi.cc
	-testApi_LDADD = $(top_builddir)/src/libRivet.la $(HEPMCLDFLAGS) $(YODALDFLAGS) $(HEPMCLDLIBS) $(YODALDLIBS)
	+testApi_LDADD = $(TEST_LDADD)
	testNaN_SOURCES = testNaN.cc
	-testNaN_LDADD = $(top_builddir)/src/libRivet.la $(HEPMCLDFLAGS) $(YODALDFLAGS) $(HEPMCLDLIBS) $(YODALDLIBS)
	+testNaN_LDADD = $(TEST_LDADD)
	+testBeams_SOURCES = testBeams.cc
	+testBeams_LDADD = $(TEST_LDADD)

	TESTS_ENVIRONMENT = \
	RIVET_REF_PATH=$(top_srcdir)/data/refdata \
	RIVET_INFO_PATH=$(top_srcdir)/data/anainfo \
	RIVET_ANALYSIS_PATH=$(top_builddir)/src/Analyses/.libs \
	LD_LIBRARY_PATH=$(top_builddir)/src:$(top_builddir)/src/.libs:$(HEPMCLIBPATH):$(YODALIBPATH):$(FASTJETLIBPATH):$(YAML_CPPLIBPATH):$(LD_LIBRARY_PATH) \
	DYLD_LIBRARY_PATH=$(top_builddir)/src:$(top_builddir)/src/.libs:$(HEPMCLIBPATH):$(YODALIBPATH):$(FASTJETLIBPATH):$(YAML_CPPLIBPATH):$(DYLD_LIBRARY_PATH) \
	PYTHON_BUILD_DIR=$(top_builddir)/pyext/build \
	PATH=$(top_builddir)/bin:$(top_srcdir)/bin:$(PATH) \
	RIVET_TESTS_SRC=$(srcdir)

	-TESTS = testMath testMatVec testCmp testApi testNaN
	+TESTS = testMath testMatVec testCmp testApi testNaN testBeams
	if ENABLE_ANALYSES
	TESTS += testCmdLine.sh
	endif

	EXTRA_DIST = testApi.hepmc testCmdLine.sh

	CLEANFILES = out.aida log a.out fifo.hepmc file2.hepmc out.yoda NaN.aida Rivet.yoda
	diff --git a/test/testBeams.cc b/test/testBeams.cc
	new file mode 100644
	--- /dev/null
	+++ b/test/testBeams.cc
	@@ -0,0 +1,63 @@
	+#include "Rivet/Particle.hh"
	+#include "Rivet/Projections/Beam.hh"
	+
	+int main() {
	+ using namespace Rivet;
	+ using namespace std;
	+
	+ const FourMomentum pbeam1a(sqrt(1E6 + 1)GeV, 0, 0, 1TeV), pbeam1b(sqrt(1E6 + 1)GeV, 0, 0, -1TeV);
	+ const Particle beam1a(PID::PROTON, pbeam1a), beam1b(PID::PROTON, pbeam1b);
	+ //
	+ const Vector3 beta1a = cmsBetaVec(pbeam1a, pbeam1b);
	+ const Vector3 beta1b = cmsBetaVec(beam1a, beam1b);
	+ cout << "Beta_symm = " << beta1a << " or " << beta1b << endl;
	+ //
	+ const Vector3 gamma1a = cmsGammaVec(pbeam1a, pbeam1b);
	+ const Vector3 gamma1b = cmsGammaVec(beam1a, beam1b);
	+ cout << "Gamma_symm = " << gamma1a << " or " << gamma1b << endl;
	+ //
	+ const LorentzTransform trfb1 = LorentzTransform::mkFrameTransformFromBeta(cmsBetaVec(pbeam1a, pbeam1b));
	+ cout << "Beta trf matrix = " << trfb1 << endl;
	+ const FourMomentum pbeam1c = trfb1.transform(pbeam1a);
	+ const FourMomentum pbeam1d = trfb1.transform(pbeam1b);
	+ cout << "Beta-boosted_symm = " << pbeam1c << " + " << pbeam1d << " = " << (pbeam1c + pbeam1d) << endl;
	+ //
	+ //const LorentzTransform trfy1 = LorentzTransform::mkFrameTransformFromGamma(cmsGammaVec(pbeam1a, pbeam1b));
	+ const LorentzTransform trfy1 = cmsTransform(pbeam1a, pbeam1b);
	+ cout << "Gamma trf matrix = " << trfy1 << endl;
	+ const FourMomentum pbeam1e = trfy1.transform(pbeam1a);
	+ const FourMomentum pbeam1f = trfy1.transform(pbeam1b);
	+ cout << "Gamma-boosted_symm = " << pbeam1e << " + " << pbeam1f << " = " << (pbeam1e + pbeam1f) << endl;
	+
	+
	+ cout << endl;
	+
	+
	+ const FourMomentum pbeam2a(sqrt(101)GeV, 0, 0, 10GeV), pbeam2b(2*GeV, 0, 0, 0);
	+ // const Particle beam2a(, pbeam1), beam2b(, pbeam1);
	+ cout << "Original_asymm = " << pbeam2a << " + " << pbeam2b << " = " << (pbeam2a + pbeam2b) << endl;
	+ //
	+ const Vector3 beta2a = cmsBetaVec(pbeam2a, pbeam2b);
	+ //const Vector3 beta2b = cmsBetaVec(beam2a, beam2b);
	+ cout << "Beta_asymm = " << beta2a << endl; // << " or " << beta2b << endl;
	+ //
	+ const Vector3 gamma2a = cmsGammaVec(pbeam2a, pbeam2b);
	+ //const Vector3 gamma2b = cmsGammaVec(beam2a, beam2b);
	+ cout << "Gamma_asymm = " << gamma2a << endl; // << " or " << gamma2b << endl;
	+ cout << "Gamma_asymm2 = " << (pbeam2a+pbeam2b).gammaVec() << endl; // << " or " << gamma2b << endl;
	+ //
	+ const LorentzTransform trfb2 = LorentzTransform::mkFrameTransformFromBeta(cmsBetaVec(pbeam2a, pbeam2b));
	+ cout << "Beta trf matrix = " << trfb2 << endl;
	+ const FourMomentum pbeam2c = trfb2.transform(pbeam2a);
	+ const FourMomentum pbeam2d = trfb2.transform(pbeam2b);
	+ cout << "Beta-boosted_asymm = " << pbeam2c << " + " << pbeam2d << " = " << (pbeam2c + pbeam2d) << endl;
	+ //
	+ //const LorentzTransform trfy2 = LorentzTransform::mkFrameTransformFromGamma(cmsGammaVec(pbeam2a, pbeam2b));
	+ const LorentzTransform trfy2 = cmsTransform(pbeam2a, pbeam2b);
	+ cout << "Gamma trf matrix = " << trfy2 << endl;
	+ const FourMomentum pbeam2e = trfy2.transform(pbeam2a);
	+ const FourMomentum pbeam2f = trfy2.transform(pbeam2b);
	+ cout << "Gamma-boosted_asymm = " << pbeam2e << " + " << pbeam2f << " = " << (pbeam2e + pbeam2f) << endl;
	+
	+ return 0;
	+}
	diff --git a/test/testCmp.cc b/test/testCmp.cc
	--- a/test/testCmp.cc
	+++ b/test/testCmp.cc
	@@ -1,26 +1,26 @@
	#include <iostream>
	#include <limits>

	-#include "Rivet/Cmp.hh"
	+#include "Rivet/Tools/Cmp.hh"

	using namespace std;

	int main() {
	using namespace Rivet;

	CmpState cs = UNDEFINED;

	cs = cmp(0.5, 0.6);
	cout << "cmp(0.5, 0.6) = " << cs << endl;
	assert(cs == ORDERED);

	cs = cmp(0.5, 0.5);
	cout << "cmp(0.5, 0.5) = " << cs << endl;
	assert(cs == EQUIVALENT);

	cs = cmp(0.6, 0.5);
	cout << "cmp(0.6, 0.5) = " << cs << endl;
	assert(cs == UNORDERED);

	return EXIT_SUCCESS;
	}
	diff --git a/test/testMatVec.cc b/test/testMatVec.cc
	--- a/test/testMatVec.cc
	+++ b/test/testMatVec.cc
	@@ -1,155 +1,154 @@
	+#include "Rivet/Math/MathUtils.hh"
	+#include "Rivet/Math/Vectors.hh"
	+#include "Rivet/Math/Matrices.hh"
	+using namespace Rivet;
	+
	#include <iostream>
	#include <limits>
	#include <cassert>
	-
	-#include "Rivet/Math/MathUtils.hh"
	-#include "Rivet/Math/Vectors.hh"
	-#include "Rivet/Math/Matrices.hh"
	-
	using namespace std;
	-using namespace Rivet;

	int main() {

	FourVector a(1,0,0,0);
	cout << a << ": interval = " << a.invariant() << endl;
	assert(fuzzyEquals(a.invariant(), 1));
	a.setZ(1);
	assert(isZero(a.invariant()));
	cout << a << ": interval = " << a.invariant() << endl;
	a.setY(2).setZ(3);
	cout << a << ": interval = " << a.invariant() << endl;
	assert(fuzzyEquals(a.invariant(), -12));
	cout << a << ": vector = " << a.vector3() << endl << endl;

	FourMomentum b(1,0,0,0);
	cout << b << ": mass = " << b.mass() << endl;
	assert(fuzzyEquals(b.mass2(), 1));
	b.setPz(1);
	cout << b << ": mass = " << b.mass() << endl;
	assert(isZero(b.mass2()));
	b.setPy(2).setPz(3).setE(6);
	cout << b << ": mass = " << b.mass2() << endl;
	assert(fuzzyEquals(b.mass2(), 23));
	cout << b << ": vector = " << b.vector3() << endl << endl;

	Matrix3 m;
	m.set(0, 0, 7/4.0);
	m.set(0, 1, 3 * sqrt(3)/4.0);
	m.set(1, 0, 3 * sqrt(3)/4.0);
	m.set(1, 1, 13/4.0);
	m.set(2, 2, 9);
	cout << m << endl << endl;
	EigenSystem<3> es = diagonalize(m);

	cout << "Matrices:" << endl;
	cout << Matrix3() << endl;
	cout << Matrix3::mkIdentity() << endl;
	const Matrix3 I3 = Matrix3::mkIdentity();
	cout << Matrix3::mkIdentity() * m * I3 << endl;
	cout << "tr(0) & det(0): " << Matrix3().trace() << ", " << Matrix3().det() << endl;
	cout << "tr(I3) & det(I3): " << I3.trace() << ", " << I3.det() << endl;
	Matrix3 m1 = Matrix3::mkIdentity();
	Matrix3 m2 = m1;
	m1.setRow(1, Vector3(1,2,3));
	m2.setColumn(1, Vector3(3,2,1));
	Matrix3 m3 = Matrix3::mkZero();
	cout << m1 << " + " << m2 << " = " << m1 + m2 << endl;
	m3.setRow(0, Vector3(2,3,0)).setRow(1, Vector3(1,4,3)).setRow(2, Vector3(0,1,2));
	cout << m1+m2 << " == " << m3 << ": " << (m1+m2 == m3 ? "true" : "false") << endl;
	cout << endl;


	Vector3 v3(1,2,3);
	cout << "Vector: " << v3 << endl;
	cout << "Invert: " << v3 << " --> " << -v3 << endl;
	const Matrix3 rot90(Vector3(0,0,1), PI/2.0);
	const Matrix3 rot90m(Vector3(0,0,1), -PI/2.0);
	const Matrix3 rot180(Vector3(0,0,1), PI);
	const Matrix3 rot180m(Vector3(0,0,1), -PI);
	const Vector3 v3_90 = rot90*v3;
	cout << "Rot 90: " << v3 << " ---> " << v3_90 << endl;
	const Vector3 v3_90m = rot90m*v3;
	cout << "Rot -90: " << v3 << " ---> " << v3_90m << endl;
	const Vector3 v3_180 = rot180*v3;
	cout << "Rot 180: " << v3 << " ---> " << v3_180 << endl;
	const Vector3 v3_180m = rot180m*v3;
	cout << "Rot -180: " << v3 << " ---> " << v3_180m << endl;
	assert(fuzzyEquals(v3_180, v3_180m));

	const Vector3 v3_9090 = rot90rot90v3;
	cout << "Rot 2 x 90: " << v3 << " ---> " << v3_9090 << endl;
	assert(fuzzyEquals(v3_180, v3_9090));

	const Vector3 v3_90m90m = rot90mrot90mv3;
	cout << "Rot 2 x -90: " << v3 << " ---> " << v3_90m90m << endl;
	assert(fuzzyEquals(v3_180, v3_90m90m));

	const Vector3 v3_9090m = rot90rot90mv3;
	const Vector3 v3_90m90 = rot90mrot90v3;
	cout << "Rot 90*-90: "<< v3 << " ---> " << v3_9090m << endl;
	cout << "Rot -90*90: "<< v3 << " ---> " << v3_90m90 << endl;
	assert(fuzzyEquals(v3, v3_9090m));
	assert(fuzzyEquals(v3, v3_90m90));

	const Vector3 v3_90i = rot90.inverse()*v3;
	cout << "Rot (90)^-1: "<< v3 << " ---> " << v3_90i << endl;
	assert(fuzzyEquals(v3_90i, v3_90m));

	const Vector3 v3_9090i = rot90rot90.inverse()v3;
	const Vector3 v3_90i90 = rot90.inverse()rot90v3;
	cout << "Rot 90*(90)^-1: "<< v3 << " ---> " << v3_9090i << endl;
	cout << "Rot (90)^-1*90: "<< v3 << " ---> " << v3_90i90 << endl;
	assert(fuzzyEquals(v3, v3_9090i));
	assert(fuzzyEquals(v3, v3_90i90));

	const Matrix3 rot1(Vector3(0,1,0), PI/180.0);
	cout << "Rot 0 x 45 x 1: " << v3 << endl;
	for (size_t i = 0; i < 8; ++i) {
	for (size_t j = 0; j < 45; ++j) {
	v3 = rot1*v3;
	}
	cout << "Rot " << i+1 << " x 45 x 1: " << v3 << endl;
	}
	assert(fuzzyEquals(v3, Vector3(1,2,3)));
	cout << endl;

	cout << "Boosts:" << endl;
	- LorentzTransform ltX(0.5,0,0);
	+ LorentzTransform ltX = LorentzTransform::mkObjTransformFromBeta(Vector3(0.5, 0, 0));
	cout << "LTx: " << ltX << endl;
	cout << "I on LTx: " << ltX.rotate(Matrix3::mkIdentity()) << endl;
	cout << "Rot90 on LTx: " << ltX.rotate(rot90) << endl;
	cout << endl;

	cout << "X-boosts:" << endl;
	- const FourMomentum p1 = FourMomentum(10,0,0,1);
	+ const FourMomentum p1 = FourMomentum(10, 0, 0, 1);
	const FourMomentum p2 = ltX.transform(p1);
	cout << p1 << " -> " << p2 << endl;
	cout << p2 << " -> " << ltX.inverse().transform(p2) << endl;
	//cout << p1.boostVector() << endl;
	- const FourMomentum p3 = LorentzTransform(-p1.boostVector()).transform(p1);
	+ const FourMomentum p3 = LorentzTransform::mkFrameTransformFromBeta(p1.boostVector()).transform(p1);
	cout << p1 << " -> " << p3 << endl;
	cout << endl;

	- LorentzTransform ltY(0,0.4,0);
	+ LorentzTransform ltY = LorentzTransform::mkObjTransformFromGamma(Vector3(0, 1.2, 0));
	cout << FourMomentum(1,0,0,1) << " -> " //<< "\n "
	<< (ltX * ltY).transform(FourMomentum(1,0,0,1)) << endl;
	cout << FourMomentum(1,0,0,1) << " -> " //<< "\n "
	<< (ltY * ltX).transform(FourMomentum(1,0,0,1)) << endl;
	- cout << (ltX * ltY).boost() << endl;
	- cout << (ltY * ltX).boost() << endl;
	- cout << (ltX * ltX.inverse()).boost() << endl;
	+ cout << (ltX * ltY).betaVec() << endl;
	+ cout << (ltY * ltX).betaVec() << endl;
	+ cout << (ltX * ltX.inverse()).betaVec() << endl;

	// If we are already in the rest frame and there is no boost, then LT is trivial/identity
	- LorentzTransform noBoost(0.0,0.0,0.0);
	+ LorentzTransform noBoost;
	cout << "Element 0,0 should be 1 and is " << noBoost.toMatrix().get(0,0) << endl;
	assert(noBoost.toMatrix().get(0,0)==1);
	cout << "Element 0,1 should be 0 and is " << noBoost.toMatrix().get(0,1) << endl;
	assert(noBoost.toMatrix().get(0,1)==0);
	cout << "Element 1,0 should be 0 and is " << noBoost.toMatrix().get(1,0) << endl;
	assert(noBoost.toMatrix().get(1,0)==0);
	cout << "Element 1,1 should be 1 and is " << noBoost.toMatrix().get(1,1) << endl;
	assert(noBoost.toMatrix().get(1,1)==1);

	return EXIT_SUCCESS;
	}

File Metadata

Mime Type: application/octet-stream
Expires: Mon, May 20, 6:49 PM (1 d, 23 h)
Storage Engine: chunks
Storage Format: Chunks
Storage Handle: qt6iS0kaqs2i
Default Alt Text: (6 MB)

Offset	End	Complete
0	4194304	Yes
4194304	6607450	Yes

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions