Index: contrib/contribs/LundPlane/trunk/RecursiveLundEEGenerator.hh
===================================================================
--- contrib/contribs/LundPlane/trunk/RecursiveLundEEGenerator.hh	(revision 1326)
+++ contrib/contribs/LundPlane/trunk/RecursiveLundEEGenerator.hh	(revision 1327)
@@ -1,296 +1,296 @@
 // $Id$
 //
 // Copyright (c) 2018-, Frederic A. Dreyer, Keith Hamilton, Alexander Karlberg,
 // Gavin P. Salam, Ludovic Scyboz, Gregory Soyez, Rob Verheyen
 //
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 //
 // It 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 2 of the License, or (at
 // your option) any later version.
 //
 // It 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 code. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 
 #ifndef __FASTJET_CONTRIB_RECURSIVELUNDEEGENERATOR_HH__
 #define __FASTJET_CONTRIB_RECURSIVELUNDEEGENERATOR_HH__
 
-#include "EEHelpers.hh"
+#include "LundEEHelpers.hh"
 
 #include <fastjet/internal/base.hh>
 #include "fastjet/tools/Recluster.hh"
 #include "fastjet/JetDefinition.hh"
 #include "fastjet/PseudoJet.hh"
 #include <string>
 #include <vector>
 #include <utility>
 #include <queue>
 
 using namespace std;
 
 FASTJET_BEGIN_NAMESPACE
 
 namespace contrib{
 
 //----------------------------------------------------------------------
 /// \class LundEEDeclustering
 /// Contains the declustering variables associated with a single qnode
 /// on the LundEE plane
 class LundEEDeclustering {
 public:
 
   /// return the pair PseudoJet, i.e. sum of the two subjets
   const PseudoJet & pair()  const {return pair_;}
   /// returns the subjet with larger transverse momentum
   const PseudoJet & harder() const {return harder_;}
   /// returns the subjet with smaller transverse momentum
   const PseudoJet & softer() const {return softer_;}
 
 
   /// returns pair().m() [cached]
   double m()         const {return m_;}
 
   /// returns the effective pseudorapidity of the emission [cached]
   double eta()       const {return eta_;}
 
   /// returns sin(theta) of the branching [cached]
   double sin_theta() const {return sin_theta_;}
 
   /// returns softer().modp() / (softer().modp() + harder().modp()) [cached]
   double z()         const {return z_;}
 
   /// returns softer().modp() * sin(theta()) [cached]
   double kt()        const {return kt_;}
 
   /// returns ln(softer().modp() * sin(theta())) [cached]
   double lnkt()      const {return lnkt_;}
 
   /// returns z() * Delta() [cached]
   double kappa()     const {return kappa_;}
 
   /// returns the index of the plane to which this branching belongs
   int iplane() const {return iplane_;}
 
   /// returns the depth of the plane on which this declustering
   /// occurred. 0 is the primary plane, 1 is the first set of leaves, etc. 
   int depth() const {return depth_;}
   
   /// returns iplane (plane index) of the leaf associated with the
   /// potential further declustering of the softer of the objects in
   /// this splitting
   int leaf_iplane() const {return leaf_iplane_;}
 
   /// Returns sign_s, indicating the initial parent jet index of this splitting
   int sign_s() const {return sign_s_;}
   
   /// (DEPRECATED)
   /// returns an azimuthal type angle between this declustering plane and the previous one
   /// Note: one should use psibar() instead, since we found that this definition of psi is
   /// not invariant under rotations of the event
   double psi()       const {return psi_;}
 
   /// update the azimuthal angle (deprecated)
   void set_psi(double psi) {psi_ = psi;}
 
   /// returns the azimuthal angle psibar between this declustering plane and the previous one
   double psibar()    const {return psibar_;}
 
   
   /// returns the coordinates in the Lund plane
   std::pair<double,double> const lund_coordinates() const {
     return std::pair<double,double>(eta_,lnkt_);
   }
 
   virtual ~LundEEDeclustering() {}
 
 private:
   int iplane_;
   double psi_, psibar_, lnkt_, eta_;
   double m_, z_, kt_, kappa_, sin_theta_;
   PseudoJet pair_, harder_, softer_;
   int  depth_ = -1, leaf_iplane_ = -1;
   int sign_s_;
 
 protected:
   /// the constructor is private, because users will not generally be
   /// constructing a LundEEDeclustering element themselves.
   LundEEDeclustering(const PseudoJet& pair,
 		     const PseudoJet& j1, const PseudoJet& j2,
 		     int iplane = -1, double psi = 0.0, double psibar = 0.0, int depth = -1, int leaf_iplane = -1, int sign_s = 1);
 
   friend class RecursiveLundEEGenerator;
 
 };
 
 
 /// Default comparison operator for LundEEDeclustering, using kt as the ordering.
 /// Useful when including declusterings in structures like priority queues
 inline bool operator<(const LundEEDeclustering& d1, const LundEEDeclustering& d2) {
   return d1.kt() < d2.kt();
 }
 
 //----------------------------------------------------------------------  
 /// Class to carry out Lund declustering to get anything from the
 /// primary Lund plane declusterings to the full Lund diagram with all
 /// its leaves, etc.
 class RecursiveLundEEGenerator {
  public:
   /// constructs a RecursiveLundEEGenerator with the specified depth.
   /// - depth = 0 means only primary declusterings are registered
   /// - depth = 1 means the first set of leaves are declustered
   /// - ...
   /// - depth < 0 means no limit, i.e. recurse through all leaves
   RecursiveLundEEGenerator(int max_depth = 0, bool dynamical_psi_ref = false) :
     max_depth_(max_depth), nx_(1,0,0,0), ny_(0,1,0,0), dynamical_psi_ref_(dynamical_psi_ref)
   {}
 
   /// destructor
   virtual ~RecursiveLundEEGenerator() {}
 
   /// This takes a cluster sequence with an e+e- C/A style algorithm, e.g.
   /// EECambridgePlugin(ycut=1.0).
   ///
   /// The output is a vector of LundEEDeclustering objects, ordered
   /// according to kt
   virtual std::vector<LundEEDeclustering> result(const ClusterSequence & cs) const {
     std::vector<PseudoJet> exclusive_jets = cs.exclusive_jets(2);
     assert(exclusive_jets.size() == 2);
     
     // order the two jets according to momentum along z axis
     if (exclusive_jets[0].pz() < exclusive_jets[1].pz()) {
       std::swap(exclusive_jets[0],exclusive_jets[1]);
     }
 
     PseudoJet d_ev = exclusive_jets[0] - exclusive_jets[1];
-    Matrix3 rotmat = Matrix3::from_direction(d_ev);
+    lund_plane::Matrix3 rotmat = lund_plane::Matrix3::from_direction(d_ev);
     
     std::vector<LundEEDeclustering> declusterings;
     int depth = 0;
     int max_iplane_sofar = 1;
     for (unsigned ijet = 0; ijet < exclusive_jets.size(); ijet++) {
 
       // reference direction for psibar calculation
       PseudoJet axis = d_ev/sqrt(d_ev.modp2());
       PseudoJet ref_plane = axis;
 
       int sign_s = ijet == 0? +1 : -1;
       // We can pass a vector normal to a plane of reference for phi definitions
       append_to_vector(declusterings, exclusive_jets[ijet], depth, ijet, max_iplane_sofar,
                        rotmat, sign_s, exclusive_jets[0], exclusive_jets[1], ref_plane, 0., true);
     }
     
     // a typedef to save typing below
     typedef LundEEDeclustering LD;
     // sort so that declusterings are returned in order of decreasing
     // kt (if result of the lambda is true, then first object appears
     // before the second one in the final sorted list)
     sort(declusterings.begin(), declusterings.end(),
          [](const LD & d1, LD & d2){return d1.kt() > d2.kt();});
 
     return declusterings;
   }
   
  private:
 
   /// internal routine to recursively carry out the declusterings,
   /// adding each one to the declusterings vector; the primary
   /// ones are dealt with first (from large to small angle),
   /// and then secondary ones take place.
   void append_to_vector(std::vector<LundEEDeclustering> & declusterings,
                         const PseudoJet & jet, int depth,
                         int iplane, int & max_iplane_sofar,
-                        const Matrix3 & rotmat, int sign_s,
+                        const lund_plane::Matrix3 & rotmat, int sign_s,
                         const PseudoJet & harder,
                         const PseudoJet & softer,
                         const PseudoJet & psibar_ref_plane,
                         const double & last_psibar, bool first_time) const {
     PseudoJet j1, j2;
     if (!jet.has_parents(j1, j2)) return;
     if (j1.modp2() < j2.modp2()) std::swap(j1,j2);
 
     // calculation of azimuth psi
-    Matrix3 new_rotmat;
+    lund_plane::Matrix3 new_rotmat;
     if (dynamical_psi_ref_) {
-      new_rotmat = Matrix3::from_direction(rotmat.transpose()*(sign_s*jet)) * rotmat;
+      new_rotmat = lund_plane::Matrix3::from_direction(rotmat.transpose()*(sign_s*jet)) * rotmat;
     } else {
       new_rotmat = rotmat;
     }
     PseudoJet rx = new_rotmat * nx_;
     PseudoJet ry = new_rotmat * ny_;
     PseudoJet u1 = j1/j1.modp(), u2 = j2/j2.modp();
     PseudoJet du = u2 - u1;
     double x = du.px() * rx.px() + du.py() * rx.py() + du.pz() * rx.pz();
     double y = du.px() * ry.px() + du.py() * ry.py() + du.pz() * ry.pz();
     double psi = atan2(y,x);
 
     // calculation of psibar
     double psibar = 0.;
     PseudoJet n1, n2;
 
     // First psibar for this jet
     if (first_time) {
 
       // Compute the angle between the planes spanned by (some axis,j1) and by (j1,j2)
-      n1 = cross_product(psibar_ref_plane,j1);
-      n2 = cross_product(j1,j2);
+      n1 = lund_plane::cross_product(psibar_ref_plane,j1);
+      n2 = lund_plane::cross_product(j1,j2);
 
       double signed_angle = 0.;
       n2 /= n2.modp();
       if (n1.modp() != 0) {
         n1 /= n1.modp();
-        signed_angle = signed_angle_between_planes(n1,n2,j1);
+        signed_angle = lund_plane::signed_angle_between_planes(n1,n2,j1);
       }
 
-      psibar = map_to_pi(j1.phi() + signed_angle);
+      psibar = lund_plane::map_to_pi(j1.phi() + signed_angle);
     }
     // Else take the value of psibar_i and the plane from the last splitting to define psibar_{i+1}
     else {
-      n2 = cross_product(j1,j2);
+      n2 = lund_plane::cross_product(j1,j2);
       n2 /= n2.modp();
-      psibar = map_to_pi(last_psibar + signed_angle_between_planes(psibar_ref_plane, n2, j1));
+      psibar = lund_plane::map_to_pi(last_psibar + lund_plane::signed_angle_between_planes(psibar_ref_plane, n2, j1));
     }
 
     int leaf_iplane = -1;
     // we will recurse into the softer "parent" only if the depth is
     // not yet at its limit or if there is no limit on the depth (max_depth<0)
     bool recurse_into_softer = (depth < max_depth_ || max_depth_ < 0);
     if (recurse_into_softer) {
       max_iplane_sofar += 1;
       leaf_iplane = max_iplane_sofar;
     }
     
     LundEEDeclustering declust(jet, j1, j2, iplane, psi, psibar, depth, leaf_iplane, sign_s);
     declusterings.push_back(declust);
 
     // now recurse
     // for the definition of psibar, we recursively pass the last splitting plane (normal to n2) and the last value
     // of psibar
     append_to_vector(declusterings, j1, depth, iplane, max_iplane_sofar, new_rotmat, sign_s, u1, u2, n2, psibar, false);
     if (recurse_into_softer) {
       append_to_vector(declusterings, j2, depth+1, leaf_iplane, max_iplane_sofar, new_rotmat, sign_s, u1, u2, n2, psibar, false);
     }
   }
   
   int max_depth_ = 0;
   /// vectors used to help define psi
   PseudoJet nx_;
   PseudoJet ny_;
   bool dynamical_psi_ref_;
 };
   
 } // namespace contrib
 
 FASTJET_END_NAMESPACE
 
 /// for output of declustering information
 std::ostream & operator<<(std::ostream & ostr, const fastjet::contrib::LundEEDeclustering & d);
 
 #endif  // __FASTJET_CONTRIB_RECURSIVELUNDEEGENERATOR_HH__
Index: contrib/contribs/LundPlane/trunk/example_dpsi_slice.cc
===================================================================
--- contrib/contribs/LundPlane/trunk/example_dpsi_slice.cc	(revision 1326)
+++ contrib/contribs/LundPlane/trunk/example_dpsi_slice.cc	(revision 1327)
@@ -1,173 +1,173 @@
 //----------------------------------------------------------------------
 /// \file example_dpsi_slice.cc
 ///
 /// This example program is meant to illustrate how the
 /// fastjet::contrib::RecursiveLundEEGenerator class is used.
 ///
 /// Run this example with
 ///
 /// \verbatim
 ///     ./example_dpsi_slice < ../data/single-ee-event.dat
 /// \endverbatim
 
 //----------------------------------------------------------------------
 // $Id$
 //
 // Copyright (c) 2018-, Frederic A. Dreyer, Keith Hamilton, Alexander Karlberg,
 // Gavin P. Salam, Ludovic Scyboz, Gregory Soyez, Rob Verheyen
 //
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 //
 // It 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 2 of the License, or (at
 // your option) any later version.
 //
 // It 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 code. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 
 #include <iostream>
 #include <fstream>
 #include <sstream>
 
 #include "fastjet/PseudoJet.hh"
 #include "fastjet/EECambridgePlugin.hh"
 #include <string>
 #include "RecursiveLundEEGenerator.hh" // In external code, this should be fastjet/contrib/RecursiveLundEEGenerator.hh
 using namespace std;
 using namespace fastjet;
 
 // Definitions for the slice observable (ymax = 1, zcut = 0.1)
 double abs_rap_slice = 1;
 double z2_cut = 0.1;
 
 // forward declaration to make things clearer
 void read_event(vector<PseudoJet> &event);
 
 // returns true if PseudoJet p is in the central slice of half-width abs_rap_slice
 // w.r.t. the event axis pref
 bool in_slice(const PseudoJet & p, const PseudoJet & pref) {
   
   // Rotate p, and use the rapidity to determine if p is in the slice
-  contrib::Matrix3 rotmat = contrib::Matrix3::from_direction(pref).transpose();
+  contrib::lund_plane::Matrix3 rotmat = contrib::lund_plane::Matrix3::from_direction(pref).transpose();
   const PseudoJet p_rot = rotmat*p;
 
   return fabs(p_rot.rap()) < abs_rap_slice;
 }
 
 //----------------------------------------------------------------------
 int main(){
 
   //----------------------------------------------------------
   // read in input particles
   vector<PseudoJet> event;
   read_event(event);
 
   cout << "# read an event with " << event.size() << " particles" << endl;
   //----------------------------------------------------------
   // create an instance of RecursiveLundEEGenerator, with default options
   int depth = -1;
   bool dynamic_psi_reference = true;
   fastjet::contrib::RecursiveLundEEGenerator lund(depth, dynamic_psi_reference);
   
   // first get some C/A jets
   double y3_cut = 1.0;
   JetDefinition::Plugin* ee_plugin = new EECambridgePlugin(y3_cut);
   JetDefinition jet_def(ee_plugin);
   ClusterSequence cs(event, jet_def);
 
   // Get the event axis (to be used for the slice)
   std::vector<PseudoJet> excl = cs.exclusive_jets(2);
   assert(excl.size() == 2);
   // order the two jets according to momentum along z axis
   if (excl[0].pz() < excl[1].pz()) {
     std::swap(excl[0],excl[1]);
   }
   const PseudoJet ev_axis = excl[0]-excl[1];
 
   // Get the list of primary declusterings
   const vector<contrib::LundEEDeclustering> declusts = lund.result(cs);
 
   // find the declustering that throws something into a fixed slice
   // (from a parent that was not in the slice) and that throws the
   // largest pt (relative to the z axis) into that slice
 
   int index_of_max_pt_in_slice = -1;
   double max_pt_in_slice = 0.0;
   double psi_1;
   for (unsigned i = 0; i < declusts.size(); i++) {
     const auto & decl = declusts[i];
     if (!in_slice(decl.harder(), ev_axis) && in_slice(decl.softer(), ev_axis)) {
       if (decl.softer().pt() > max_pt_in_slice) {
         index_of_max_pt_in_slice = i;
         max_pt_in_slice = decl.softer().pt();
         psi_1 = decl.psibar();
       }
     }
   }
   if (index_of_max_pt_in_slice < 0) return 0;
 
   // establish what we need to follow and the reference psi_1
   int iplane_to_follow = declusts[index_of_max_pt_in_slice].leaf_iplane();
   
   vector<const contrib::LundEEDeclustering *> secondaries;
   for (const auto & declust: declusts){
     if (declust.iplane() == iplane_to_follow) secondaries.push_back(&declust);
   }
 
   int index_of_max_kt_secondary = -1;
   double dpsi;
   for (uint i_secondary=0; i_secondary<secondaries.size(); i_secondary++) {
     if (secondaries[i_secondary]->z() > z2_cut) {
 
       index_of_max_kt_secondary = i_secondary;
       double psi_2 = secondaries[i_secondary]->psibar();
-      dpsi = contrib::map_to_pi(psi_2 - psi_1);
+      dpsi = contrib::lund_plane::map_to_pi(psi_2 - psi_1);
 
       break;
     }
   }
   if (index_of_max_kt_secondary < 0) return 0;
 
   cout << "Primary in the central slice, with Lund coordinates ( ln 1/Delta, ln kt, psibar ):" << endl;
   pair<double,double> coords = declusts[index_of_max_pt_in_slice].lund_coordinates();
   cout << "index [" << index_of_max_pt_in_slice << "](" << coords.first << ", " << coords.second << ", "
        << declusts[index_of_max_pt_in_slice].psibar() << ")" << endl;
   cout << endl << "with Lund coordinates for the (highest-kT) secondary plane that passes the zcut of "
        << z2_cut << endl;
   coords = secondaries[index_of_max_kt_secondary]->lund_coordinates();
   cout << "index [" << index_of_max_kt_secondary << "](" << coords.first << ", " << coords.second << ", "
        << secondaries[index_of_max_kt_secondary]->psibar() << ")";
 
   cout << " --> delta_psi,slice = " << dpsi << endl;
 
   // Delete the EECambridge plugin
   delete ee_plugin;
 
   return 0;
 }
 
 // read in input particles
 void read_event(vector<PseudoJet> &event){  
   string line;
   while (getline(cin, line)) {
     istringstream linestream(line);
     // take substrings to avoid problems when there is extra "pollution"
     // characters (e.g. line-feed).
     if (line.substr(0,4) == "#END") {return;}
     if (line.substr(0,1) == "#") {continue;}
     double px,py,pz,E;
     linestream >> px >> py >> pz >> E;
     PseudoJet particle(px,py,pz,E);
 
     // push event onto back of full_event vector
     event.push_back(particle);
   }
 }
Index: contrib/contribs/LundPlane/trunk/Makefile
===================================================================
--- contrib/contribs/LundPlane/trunk/Makefile	(revision 1326)
+++ contrib/contribs/LundPlane/trunk/Makefile	(revision 1327)
@@ -1,91 +1,91 @@
 # If you are using this Makefile standalone and fastjet-config is not
 # in your path, edit this line to specify the full path
 FASTJETCONFIG=fastjet-config
 PREFIX=`$(FASTJETCONFIG) --prefix`
 CXX=g++
 CXXFLAGS= -O3 -Wall -g
 install_script = $(SHELL) ../utils/install-sh
 check_script = ../utils/check.sh
 
 # global contrib-wide Makefile include may override some of the above
 # variables (leading "-" means don't give an error if you can't find
 # the file)
 -include ../.Makefile.inc
 
 #------------------------------------------------------------------------
 # things that are specific to this contrib
 NAME=LundPlane
 SRCS=LundGenerator.cc LundWithSecondary.cc SecondaryLund.cc RecursiveLundEEGenerator.cc
 EXAMPLES=example example_secondary example_dpsi_collinear example_dpsi_slice
-INSTALLED_HEADERS=LundGenerator.hh LundWithSecondary.hh SecondaryLund.hh RecursiveLundEEGenerator.hh LundJSON.hh
+INSTALLED_HEADERS=LundGenerator.hh LundWithSecondary.hh SecondaryLund.hh RecursiveLundEEGenerator.hh LundJSON.hh LundEEHelpers.hh
 #------------------------------------------------------------------------
 
 CXXFLAGS+= $(shell $(FASTJETCONFIG) --cxxflags)
 LDFLAGS += -lm $(shell $(FASTJETCONFIG) --libs) -lfastjetplugins
 
 OBJS  = $(SRCS:.cc=.o)
 EXAMPLES_SRCS  = $(EXAMPLES:=.cc)
 
 install_HEADER  = $(install_script) -c -m 644
 install_LIB     = $(install_script) -c -m 644
 install_DIR     = $(install_script) -d
 install_DATA    = $(install_script) -c -m 644
 install_PROGRAM = $(install_script) -c -s
 install_SCRIPT  = $(install_script) -c
 
 .PHONY: clean distclean examples check install
 
 # compilation of the code (default target)
 all: lib$(NAME).a
 
 lib$(NAME).a: $(OBJS) 
 	ar cru lib$(NAME).a $(OBJS)
 	ranlib lib$(NAME).a
 
 # building the examples
 examples: $(EXAMPLES)
 
 # the following construct makes it possible to automatically build
 # each of the examples listed in $EXAMPLES
 $(EXAMPLES): % : %.o all
 	$(CXX) $(CXXFLAGS) -o $@ $< -L. -l$(NAME) $(LDFLAGS)
 
 # check that everything went fine
 check: examples
 	@for prog in $(EXAMPLES); do\
 	  if [ "$${prog}" = "example_dpsi_collinear" ] || [ "$${prog}" = "example_dpsi_slice" ]; then \
 	    $(check_script) $${prog} ../data/single-ee-event.dat || exit 1; \
 	  else \
 	    $(check_script) $${prog} ../data/single-event.dat || exit 1; \
 	  fi; \
 	done
 	@echo "All tests successful"
 
 # cleaning the directory
 clean:
 	rm -f *~ *.o
 
 distclean: clean
 	rm -f lib$(NAME).a $(EXAMPLES)
 
 # install things in PREFIX/...
 install: all
 	$(install_DIR) $(PREFIX)/include/fastjet/contrib
 	for header in $(INSTALLED_HEADERS); do\
 	  $(install_HEADER) $$header $(PREFIX)/include/fastjet/contrib/;\
 	done
 	$(install_DIR) $(PREFIX)/lib
 	$(install_LIB) lib$(NAME).a $(PREFIX)/lib
 
 depend:
 	makedepend -Y --   -- $(SRCS) $(EXAMPLES_SRCS)
 # DO NOT DELETE
 
 LundGenerator.o: LundGenerator.hh
 LundWithSecondary.o: LundWithSecondary.hh LundGenerator.hh SecondaryLund.hh
 SecondaryLund.o: SecondaryLund.hh LundGenerator.hh
-RecursiveLundEEGenerator.o: RecursiveLundEEGenerator.hh EEHelpers.hh
+RecursiveLundEEGenerator.o: RecursiveLundEEGenerator.hh LundEEHelpers.hh
 example.o: LundGenerator.hh LundJSON.hh
 example_secondary.o: LundWithSecondary.hh LundGenerator.hh SecondaryLund.hh
-example_dpsi_collinear.o: RecursiveLundEEGenerator.hh EEHelpers.hh
-example_dpsi_slice.o: RecursiveLundEEGenerator.hh EEHelpers.hh
+example_dpsi_collinear.o: RecursiveLundEEGenerator.hh LundEEHelpers.hh
+example_dpsi_slice.o: RecursiveLundEEGenerator.hh LundEEHelpers.hh
Index: contrib/contribs/LundPlane/trunk/example_dpsi_collinear.cc
===================================================================
--- contrib/contribs/LundPlane/trunk/example_dpsi_collinear.cc	(revision 1326)
+++ contrib/contribs/LundPlane/trunk/example_dpsi_collinear.cc	(revision 1327)
@@ -1,145 +1,145 @@
 //----------------------------------------------------------------------
 /// \file example_dpsi_collinear.cc
 ///
 /// This example program is meant to illustrate how the
 /// fastjet::contrib::RecursiveLundEEGenerator class is used.
 ///
 /// Run this example with
 ///
 /// \verbatim
 ///     ./example_dpsi_collinear < ../data/single-ee-event.dat
 /// \endverbatim
 
 //----------------------------------------------------------------------
 // $Id$
 //
 // Copyright (c) 2018-, Frederic A. Dreyer, Keith Hamilton, Alexander Karlberg,
 // Gavin P. Salam, Ludovic Scyboz, Gregory Soyez, Rob Verheyen
 //
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 //
 // It 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 2 of the License, or (at
 // your option) any later version.
 //
 // It 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 code. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 
 #include <iostream>
 #include <fstream>
 #include <sstream>
 
 #include "fastjet/PseudoJet.hh"
 #include "fastjet/EECambridgePlugin.hh"
 #include <string>
 #include "RecursiveLundEEGenerator.hh" // In external code, this should be fastjet/contrib/RecursiveLundEEGenerator.hh
 using namespace std;
 using namespace fastjet;
 
 // Definitions for the collinear observable
 double z1_cut = 0.1;
 double z2_cut = 0.1;
 
 // forward declaration to make things clearer
 void read_event(vector<PseudoJet> &event);
 
 //----------------------------------------------------------------------
 int main(){
 
   //----------------------------------------------------------
   // read in input particles
   vector<PseudoJet> event;
   read_event(event);
 
   cout << "# read an event with " << event.size() << " particles" << endl;
   //----------------------------------------------------------
   // create an instance of RecursiveLundEEGenerator, with default options
   int depth = -1;
   bool dynamic_psi_reference = true;
   fastjet::contrib::RecursiveLundEEGenerator lund(depth, dynamic_psi_reference);
   
   // first get some C/A jets
   double y3_cut = 1.0;
   JetDefinition::Plugin* ee_plugin = new EECambridgePlugin(y3_cut);
   JetDefinition jet_def(ee_plugin);
   ClusterSequence cs(event, jet_def);
 
   // Get the list of primary declusterings
   const vector<contrib::LundEEDeclustering> declusts = lund.result(cs);
   
   // Find the highest-kt primary declustering (ordered in kt by default)
   int i_primary = -1;
   double psi_1;
   for (int i=0; i<declusts.size(); i++) {
     if (declusts[i].depth() == 0 && declusts[i].z() > z1_cut) {
         i_primary = i;
         psi_1 = declusts[i].psibar();
         break;
     }
   }
   if (i_primary < 0) return 0;
 
   // Find the highest-kt secondary associated to that Lund leaf
   int iplane_to_follow = declusts[i_primary].leaf_iplane();
   vector<const contrib::LundEEDeclustering *> secondaries;
   for (const auto & declust: declusts){
       if (declust.iplane() == iplane_to_follow) secondaries.push_back(&declust);
   }
   if(secondaries.size() < 1) return 0;
 
   int i_secondary = -1;
   double dpsi;
   for (int i=0; i<secondaries.size(); i++) {
       if (secondaries[i]->z() > z2_cut) {
           i_secondary = i;
           double psi_2 = secondaries[i]->psibar();
-          dpsi = contrib::map_to_pi(psi_2-psi_1);
+          dpsi = contrib::lund_plane::map_to_pi(psi_2-psi_1);
           break;
       }
   }
   if (i_secondary < 0) return 0;
 
   cout << "Primary that passes the zcut of "
        << z1_cut << ", with Lund coordinates  ( ln 1/Delta, ln kt, psibar ):" << endl;
   pair<double,double> coords = declusts[i_primary].lund_coordinates();
   cout << "index [" << i_primary << "](" << coords.first << ", " << coords.second << ", "
        << declusts[i_primary].psibar() << ")" << endl;
   cout << endl << "with Lund coordinates for the secondary plane that passes the zcut of "
        << z2_cut << endl;
   coords = secondaries[i_secondary]->lund_coordinates();
   cout << "index [" << i_secondary << "](" << coords.first << ", " << coords.second << ", "
        << secondaries[i_secondary]->psibar() << ")";
 
   cout << " --> delta_psi = " << dpsi << endl;
 
   // Delete the EECambridge plugin
   delete ee_plugin;
 
   return 0;
 }
 
 // read in input particles
 void read_event(vector<PseudoJet> &event){  
   string line;
   while (getline(cin, line)) {
     istringstream linestream(line);
     // take substrings to avoid problems when there is extra "pollution"
     // characters (e.g. line-feed).
     if (line.substr(0,4) == "#END") {return;}
     if (line.substr(0,1) == "#") {continue;}
     double px,py,pz,E;
     linestream >> px >> py >> pz >> E;
     PseudoJet particle(px,py,pz,E);
 
     // push event onto back of full_event vector
     event.push_back(particle);
   }
 }
Index: contrib/contribs/LundPlane/trunk/ChangeLog
===================================================================
--- contrib/contribs/LundPlane/trunk/ChangeLog	(revision 1326)
+++ contrib/contribs/LundPlane/trunk/ChangeLog	(revision 1327)
@@ -1,87 +1,106 @@
+2022-10-04 Tue  <gavin.salam@physics.ox.ac.uk> + Ludo Scyboz
+
+	* EEHelpers.hh ->  LundEEHelpers.hh:
+    EEHelpers.hh was not being installed; given that it's a potentially 
+	common name, renamed it before including among the installation 
+	targets. 
+
+	Also placed whole contents in a new contrib::lund_plane namespace,
+	because of certain potentially common names like cross_product
+
+	* Makefile:
+	replaced EEHelpers.hh ->  LundEEHelpers.hh and made sure that
+	LundEEHelpers.hh gets installed (without which RecursiveLundEEGenerator.hh
+	cannot be used)
+
+	* example_dpsi_collinear.cc:
+	* example_dpsi_slice.cc:
+	use of things from LundEEHelpers.hh updated to use of new namespace
+
 2022-08-20  Gavin Salam  <gavin.salam@physics.ox.ac.uk>
 
 	* VERSION:
 	* NEWS:
 	prepared for release 2.0.2
 
 	* Makefile:
 	updated some dependencies
 
 	* EEHelpers.hh:
 	added #include <limits>, as per request from Andy Buckley
 	for compilation with g++-12 on some systems
 
 2021-12-06  Gavin Salam  <gavin.salam@physics.ox.ac.uk>
 
 	* NEWS:
         * VERSION:
 	prepared for release 2.0.1
 
 	* AUTHORS:
 	fixed missing names and publication info
 
 2021-12-06  Gregory Soyez  <soyez@fastjet.fr>
 
 	* SecondaryLund.cc:
 	fixed int v. unsigned int in loop over vector indices
 
 2021-12-06  Gavin Salam  <gavin.salam@physics.ox.ac.uk>
 
 	* example.py:
 	fixed name of executable in comments about how to execute
 	this (thanks to Matteo Cacciari)
 
 2021-11-09  Ludovic Scyboz <ludovic.scyboz@physics.ox.ac.uk>
 
 	* VERSION:
 	preparing for release of 2.0.0
 
 	* RecursiveLundEEGenerator.hh:
 	* RecursiveLundEEGenerator.cc:
 	class for recursive Lund declustering in e+e-
 	* example_dpsi_collinear.cc:
 	spin-sensitive collinear observable from 2103.16526
 	* example_dpsi_slice.cc:
 	spin-sensitive non-global observable from 2111.01161
 
 2020-02-23  Gavin Salam  <gavin.salam@cern.ch>
 
 	* NEWS:
 	* VERSION:
 	preparing for release of 1.0.3
 
 	* example.cc:
 	changed outfile open(filename) to outfile.open(filename.c_str());
 	to attempt to solve issue reported by Steven Schramm.
 
 2018-10-26  Gavin Salam <gavin.salam@cern.ch>
 
 	* read_lund_json.py:
 	removed extraneous normalisation of zeroth bin in
 	the LundImage class.
 	Added documentation.
 
 
 2018-08-30  Gavin Salam  <gavin.salam@cern.ch>
 
 	* VERSION: 
 	* NEWS:
 
 	Release of version 1.0.1
 
 2018-08-23  Gavin Salam  <gavin.salam@cern.ch>
 
 	* LundWithSecondary.hh:
 	* LundWithSecondary.cc:
 	added secondary_index(...), removed virtual qualifier from various
 	functions
 
 	* example_secondary.cc:
 	* example_secondary.ref:
 	example now prints out index of the primary declustering being
 	used for the secondary. Referemce file updated accordingly.
 
 2018-08-09  Frédéric Dreyer  <fdreyer@mit.edu>
 
 	First version of LundPlane.
 
Index: contrib/contribs/LundPlane/trunk/RecursiveLundEEGenerator.cc
===================================================================
--- contrib/contribs/LundPlane/trunk/RecursiveLundEEGenerator.cc	(revision 1326)
+++ contrib/contribs/LundPlane/trunk/RecursiveLundEEGenerator.cc	(revision 1327)
@@ -1,86 +1,88 @@
 // $Id$
 //
 // Copyright (c) 2018-, Frederic A. Dreyer, Keith Hamilton, Alexander Karlberg,
 // Gavin P. Salam, Ludovic Scyboz, Gregory Soyez, Rob Verheyen
 //
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 //
 // It 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 2 of the License, or (at
 // your option) any later version.
 //
 // It 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 code. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 
 #include <sstream>
 #include "RecursiveLundEEGenerator.hh"
 
 using namespace std;
 
 FASTJET_BEGIN_NAMESPACE
 
 namespace contrib{
+
+using namespace lund_plane;  
   
 LundEEDeclustering::LundEEDeclustering(const PseudoJet& pair,
 		const PseudoJet& j1, const PseudoJet& j2,
 		int iplane, double psi, double psibar,
 		int depth, int leaf_iplane, int sign_s)
   : iplane_(iplane), psi_(psi), psibar_(psibar), m_(pair.m()), pair_(pair), depth_(depth), leaf_iplane_(leaf_iplane), sign_s_(sign_s) {
 
   double omc = one_minus_costheta(j1,j2);
   
   if (omc > sqrt(numeric_limits<double>::epsilon())) {
     double cos_theta = 1.0 - omc;
     double theta     = acos(cos_theta);
     sin_theta_ = sin(theta);
     eta_       = -log(tan(theta/2.0));
   } else {
     // we are at small angles, so use small-angle formulas
     double theta = sqrt(2. * omc);
     sin_theta_ = theta;
     eta_       = -log(theta/2);
   }
 
   // establish which of j1 and j2 is softer
   if (j1.modp2() > j2.modp2()) {
     harder_ = j1;
     softer_ = j2;
   } else {
     harder_ = j2;
     softer_ = j1;
   }
 
   // now work out the various LundEE declustering variables
   double softer_modp = softer_.modp();
   z_   = softer_modp / (softer_modp + harder_.modp());
   kt_  = softer_modp * sin_theta_;
   lnkt_ = log(kt_);
   kappa_ = z_ * sin_theta_;
 }
 
 } // namespace contrib
 
 
 FASTJET_END_NAMESPACE
 
 std::ostream & operator<<(std::ostream & ostr, const fastjet::contrib::LundEEDeclustering & d) {
   ostr << "kt = "   << d.kt()
        << " z = "   << d.z()
        << " eta = " << d.eta()
        << " psi = " << d.psi()
        << " psibar = " << d.psibar()
        << " m = "   << d.m()
        << " iplane = " << d.iplane()
        << " depth = " << d.depth()
        << " leaf_iplane = " << d.leaf_iplane();
   return ostr;
 }
 
Index: contrib/contribs/LundPlane/trunk
===================================================================
--- contrib/contribs/LundPlane/trunk	(revision 1326)
+++ contrib/contribs/LundPlane/trunk	(revision 1327)

Property changes on: contrib/contribs/LundPlane/trunk
___________________________________________________________________
Modified: svn:ignore
## -1,3 +1,18 ##
 # Added by svn-ignore on 2018-08-23
 example
 example_secondary
+
+# Added by svn-ignore on 2022-10-04
+example_dpsi_slice
+
+# Added by svn-ignore on 2022-10-04
+example_dpsi_collinear
+
+# Added by svn-ignore on 2022-10-04
+example_dpsi_slice.diff
+example_secondary.diff
+example_dpsi_collinear.diff
+Makefile.bak
+
+# Added by svn-ignore on 2022-10-04
+example.diff