o.b.o. John Chapman: add namespaces to use newer CLHEP version (AtlasSealCLHEP-00-01-08)

Database/AtlasSealCLHEP/AtlasSealCLHEP/AtlasSealCLHEPDict.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/***************************************************************************
+ Temporary package for CLHEP SEAL dictionary
+ -------------------------------------------
+ Copyright (C) 2004 by ATLAS Collaboration
+ ***************************************************************************/
+
+//<doc><file>	$Id: AtlasSealCLHEPDict.h,v 1.3 2006-03-10 22:22:20 mnowak Exp $
+//<version>	$Name: not supported by cvs2svn $
+
+#ifndef ATLASSEALCLHEP_ATLASSEALCLHEPDICT_H
+# define ATLASSEALCLHEP_ATLASSEALCLHEPDICT_H
+
+//<<<<<< INCLUDES                                                       >>>>>>
+#include "AtlasSealCLHEP/CLHEP_Vector.h"
+#include "AtlasSealCLHEP/CLHEP_Random.h"
+#include "AtlasSealCLHEP/CLHEP_Geometry.h"
+#include "AtlasSealCLHEP/CLHEP_Matrix.h"
+// #include " AtlasSealCLHEP/CLHEP_Vector.h "
+// #include " AtlasSealCLHEP/CLHEP_Random.h "
+// #include " AtlasSealCLHEP/CLHEP_Geometry.h "
+// #include " AtlasSealCLHEP/CLHEP_Matrix.h "
+// #include " AtlasSealCLHEPDict/CLHEP_Vector.h "
+// #include " AtlasSealCLHEPDict/CLHEP_Random.h "
+// #include " AtlasSealCLHEPDict/CLHEP_Geometry.h "
+// #include " AtlasSealCLHEPDict/CLHEP_Matrix.h "
+// #include " AtlasSealCLHEPDict/CLHEP_HepMC.h "
+// #include " AtlasSealCLHEPDict/CLHEP_HepPDT.h "
+// #include " AtlasSealCLHEPDict/CLHEP_GenericFunctions.h "
+
+#include "AtlasSealCLHEP/OldCLHEP.h"
+#include "AtlasSealCLHEP/OldCLHEPStreamers.h"
+
+
+//<<<<<< CLASS DECLARATIONS                                             >>>>>>
+
+
+
+//<<<<<< INLINE PUBLIC FUNCTIONS                                        >>>>>>
+//<<<<<< INLINE MEMBER FUNCTIONS                                        >>>>>>
+
+#endif // ATLASSEALCLHEP_ATLASSEALCLHEPDICT_H

Database/AtlasSealCLHEP/AtlasSealCLHEP/CLHEP_GenericFunctions.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#include "CLHEP/GenericFunctions/ACos.hh"
+#include "CLHEP/GenericFunctions/ASin.hh"
+#include "CLHEP/GenericFunctions/ATan.hh"
+#include "CLHEP/GenericFunctions/Abs.hh"
+#include "CLHEP/GenericFunctions/AbsFunction.hh"
+#include "CLHEP/GenericFunctions/AbsFunctional.hh"
+#include "CLHEP/GenericFunctions/AbsParameter.hh"
+#include "CLHEP/GenericFunctions/AnalyticConvolution.hh"
+#include "CLHEP/GenericFunctions/Argument.hh"
+#include "CLHEP/GenericFunctions/ArrayFunction.hh"
+#include "CLHEP/GenericFunctions/AssociatedLaguerre.hh"
+#include "CLHEP/GenericFunctions/BivariateGaussian.hh"
+#include "CLHEP/GenericFunctions/ConstMinusFunction.hh"
+#include "CLHEP/GenericFunctions/ConstMinusParameter.hh"
+#include "CLHEP/GenericFunctions/ConstOverFunction.hh"
+#include "CLHEP/GenericFunctions/ConstOverParameter.hh"
+#include "CLHEP/GenericFunctions/ConstPlusFunction.hh"
+#include "CLHEP/GenericFunctions/ConstPlusParameter.hh"
+#include "CLHEP/GenericFunctions/ConstTimesFunction.hh"
+#include "CLHEP/GenericFunctions/ConstTimesParameter.hh"
+#include "CLHEP/GenericFunctions/Cos.hh"
+#include "CLHEP/GenericFunctions/CumulativeChiSquare.hh"
+#include "CLHEP/GenericFunctions/DefiniteIntegral.hh"
+#include "CLHEP/GenericFunctions/Erf.hh"
+#include "CLHEP/GenericFunctions/Exp.hh"
+#include "CLHEP/GenericFunctions/Exponential.hh"
+#include "CLHEP/GenericFunctions/FixedConstant.hh"
+#include "CLHEP/GenericFunctions/FloatingConstant.hh"
+#include "CLHEP/GenericFunctions/FunctionComposition.hh"
+#include "CLHEP/GenericFunctions/FunctionConvolution.hh"
+#include "CLHEP/GenericFunctions/FunctionDifference.hh"
+#include "CLHEP/GenericFunctions/FunctionDirectProduct.hh"
+#include "CLHEP/GenericFunctions/FunctionNegation.hh"
+#include "CLHEP/GenericFunctions/FunctionNoop.hh"
+#include "CLHEP/GenericFunctions/FunctionNumDeriv.hh"
+#include "CLHEP/GenericFunctions/FunctionPlusParameter.hh"
+#include "CLHEP/GenericFunctions/FunctionProduct.hh"
+#include "CLHEP/GenericFunctions/FunctionQuotient.hh"
+#include "CLHEP/GenericFunctions/FunctionSum.hh"
+#include "CLHEP/GenericFunctions/FunctionTimesParameter.hh"
+#include "CLHEP/GenericFunctions/Gaussian.hh"
+#include "CLHEP/GenericFunctions/IncompleteGamma.hh"
+#include "CLHEP/GenericFunctions/Landau.hh"
+#include "CLHEP/GenericFunctions/LikelihoodFunctional.hh"
+#include "CLHEP/GenericFunctions/Ln.hh"
+#include "CLHEP/GenericFunctions/LogGamma.hh"
+#include "CLHEP/GenericFunctions/LogisticFunction.hh"
+#include "CLHEP/GenericFunctions/Mod.hh"
+#include "CLHEP/GenericFunctions/Parameter.hh"
+#include "CLHEP/GenericFunctions/ParameterDifference.hh"
+#include "CLHEP/GenericFunctions/ParameterNegation.hh"
+#include "CLHEP/GenericFunctions/ParameterProduct.hh"
+#include "CLHEP/GenericFunctions/ParameterQuotient.hh"
+#include "CLHEP/GenericFunctions/ParameterSum.hh"
+#include "CLHEP/GenericFunctions/PeriodicRectangular.hh"
+#include "CLHEP/GenericFunctions/Power.hh"
+#include "CLHEP/GenericFunctions/Psi2Hydrogen.hh"
+#include "CLHEP/GenericFunctions/PtRelFcn.hh"
+#include "CLHEP/GenericFunctions/RCBase.hh"
+#include "CLHEP/GenericFunctions/RKIntegrator.hh"
+#include "CLHEP/GenericFunctions/Rectangular.hh"
+#include "CLHEP/GenericFunctions/ReverseExponential.hh"
+#include "CLHEP/GenericFunctions/Sigma.hh"
+#include "CLHEP/GenericFunctions/Sin.hh"
+#include "CLHEP/GenericFunctions/Sqrt.hh"
+#include "CLHEP/GenericFunctions/Square.hh"
+#include "CLHEP/GenericFunctions/Tan.hh"
+#include "CLHEP/GenericFunctions/TrivariateGaussian.hh"
+#include "CLHEP/GenericFunctions/Variable.hh"
+#include "CLHEP/GenericFunctions/X.hh"
+
+/* excluded because of multipe defined symbols
+   problem with *.icc files defining non inline functions
+#include "CLHEP/GenericFunctions/Bessel.hh"
+#include "CLHEP/GenericFunctions/EllipticIntegral.hh"
+#include "CLHEP/GenericFunctions/SphericalBessel.hh"
+#include "CLHEP/GenericFunctions/SphericalNeumann.hh"
+*/
+
+// not implemented functions in clhep 1.8.1.0
+inline Genfun::Parameter& Genfun::LogGamma::sigma() { return *(new Parameter("dummy",1.0)); };

Database/AtlasSealCLHEP/AtlasSealCLHEP/CLHEP_Geometry.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "CLHEP/Geometry/BasicVector3D.h"
+#include "CLHEP/Geometry/Normal3D.h"
+#include "CLHEP/Geometry/Plane3D.h"
+#include "CLHEP/Geometry/Point3D.h"
+#include "CLHEP/Geometry/Transform3D.h"
+#include "CLHEP/Geometry/Vector3D.h"
+
+namespace AtlasSealCLHEP 
+{
+//    HepGeom::Plane3D<double> m_pld;
+//    HepGeom::Plane3D<float>  m_plf;
+}
+
+    

Database/AtlasSealCLHEP/AtlasSealCLHEP/CLHEP_HepMC.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "CLHEP/HepMC/Flow.h"
+#include "CLHEP/HepMC/GenEvent.h"
+#include "CLHEP/HepMC/GenEventConvert.h"
+#include "CLHEP/HepMC/GenParticle.h"
+#include "CLHEP/HepMC/GenVertex.h"
+#include "CLHEP/HepMC/Polarization.h"
+#include "CLHEP/HepMC/WeightContainer.h"
+
+// functions declared but not defined in 1.8.1.0
+inline void HepMC::GenParticle::setParticleID(HepPDT::ParticleID pid) { int i = pid.pid(); ++i; }

Database/AtlasSealCLHEP/AtlasSealCLHEP/CLHEP_HepPDT.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "CLHEP/HepPDT/CommonParticleData.hh"
+#include "CLHEP/HepPDT/Constituent.hh"
+#include "CLHEP/HepPDT/DefTable.hh"
+#include "CLHEP/HepPDT/Measurement.hh"
+#include "CLHEP/HepPDT/PDGtoQQTable.hh"
+#include "CLHEP/HepPDT/ParticleID.hh"
+#include "CLHEP/HepPDT/QQChannel.hh"
+#include "CLHEP/HepPDT/QQDecay.hh"
+#include "CLHEP/HepPDT/QQDecayTable.hh"
+#include "CLHEP/HepPDT/ResonanceStructure.hh"
+#include "CLHEP/HepPDT/SimpleDecayModel.hh"
+#include "CLHEP/HepPDT/SimpleParticle.hh"
+#include "CLHEP/HepPDT/SpinState.hh"
+
+// functions declared in HepPDT but not defined
+inline void HepPDT::QQDecayTable::writeTable(std::ostream& os) const { os << "1"; }
+inline void HepPDT::QQChannel::write(std::ostream & os) const { os << "1"; }
+inline void HepPDT::QQDecay::write(std::ostream & os) const { os << "1"; }

Database/AtlasSealCLHEP/AtlasSealCLHEP/CLHEP_Matrix.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "CLHEP/Matrix/DiagMatrix.h"
+#include "CLHEP/Matrix/GenMatrix.h"
+#include "CLHEP/Matrix/Matrix.h"
+#include "CLHEP/Matrix/Pile.h"
+#include "CLHEP/Matrix/SymMatrix.h"
+#include "CLHEP/Matrix/Vector.h"
+
+// not implemented functions in CLHEP 1.8.1.0
+inline void CLHEP::HepSymMatrix::invertHaywood4(int& ) {}
+inline void CLHEP::HepMatrix::invertHaywood4(int& ) {}
+inline void CLHEP::HepMatrix::invertHaywood5(int& ) {}
+inline void CLHEP::HepMatrix::invertHaywood6(int& ) {}
+inline CLHEP::HepMatrix& CLHEP::HepMatrix::operator=(const CLHEP::HepRotation &) {return *(new CLHEP::HepMatrix()); }
+
+// must instatiate some templates
+
+namespace AtlasSealCLHEP {
+//    CLHEP::HepGenMatrix::Alloc<double,25>                        m_alloc;
+//    CLHEP::HepGenMatrix::Alloc<double,25> m_all;
+//    CLHEP::GenMatrix::Alloc<double,25>                        m_alloc;
+//    CLHEP::HepMatrix  m_matrix;
+//    std::vector<double, CLHEP::HepGenMatrix::Alloc<double,25> >  m_allocVec;
+}

Database/AtlasSealCLHEP/AtlasSealCLHEP/CLHEP_Random.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "CLHEP/Random/Randomize.h"
+
+//----Functions missing in the implementation and required by the dictionary
+//    [ Bug #1806 ] Missing method implementations
+
+inline void CLHEP::RandPoissonT::shootArray(class CLHEP::HepRandomEngine *,int,long *,double) {}
+inline void CLHEP::RandPoissonT::fireArray(int,long *) {}
+inline void CLHEP::RandPoissonQ::shootArray(class CLHEP::HepRandomEngine *,int,long *,double){}
+inline void CLHEP::RandPoissonQ::fireArray(int,long *) {}
+//// DRQ: The following function was removed in CLHEP 1.9.2.1
+////inline void HepRandomEngine::getTableSeeds(long *,int)const  {}
+

Database/AtlasSealCLHEP/AtlasSealCLHEP/CLHEP_Vector.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "CLHEP/Vector/Rotation.h"
+#include "CLHEP/Vector/EulerAngles.h"
+#include "CLHEP/Vector/LorentzRotation.h"
+#include "CLHEP/Vector/ThreeVector.h"
+#include "CLHEP/Vector/TwoVector.h"
+

Database/AtlasSealCLHEP/AtlasSealCLHEP/OldCLHEP.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef OLDHepVector3D_H
+#define OLDHepVector3D_H
+
+/*
+  2006 CERN  Marcin Nowak
+
+  Set of classes identical (hopefully) to CLHEP v.1.8.2 classes, but with different names.
+  Only persistent data members are important, inheritance and the presence of virtual table.
+  Methods are not needed.
+
+*/
+
+class OldHep3Vector {
+public:
+  OldHep3Vector() : dx(0), dy(0), dz(0) {}
+  
+  inline double	x() const { return dx; } 
+  inline double	y() const { return dy; }
+  inline double	z() const { return dz; }
+
+  double dx, dy, dz;
+};
+
+
+class OldHepTransform3D {
+ public:
+  double m1, m2, m3, m4,
+         m5, m6, m7, m8,
+         m9, m10, m11, m12;
+
+  OldHepTransform3D() :
+        m1(0), m2(0), m3(0), m4(0),
+        m5(0), m6(0), m7(0), m8(0),
+        m9(0), m10(0), m11(0), m12(0) {} 
+  virtual ~OldHepTransform3D() {}
+};
+
+  
+class OldHepRotation {
+public:
+  OldHepRotation() :
+        rxx(0), rxy(0), rxz(0),   ryx(0), ryy(0), ryz(0),   rzx(0), rzy(0), rzz(0) {}
+  
+  double rxx, rxy, rxz,   ryx, ryy, ryz,   rzx, rzy, rzz;
+};
+
+
+#include "CLHEP/Vector/ThreeVector.h"
+class OldBasicVector3D {
+public:
+  OldBasicVector3D() {}
+  virtual ~OldBasicVector3D() {}
+
+  inline double	x() const { return vec.x(); } 
+  inline double	y() const { return vec.y(); }
+  inline double	z() const { return vec.z(); }
+
+  CLHEP::Hep3Vector	vec;
+};
+
+
+
+
+
+class OldHepVector3D : public OldBasicVector3D {
+public:
+  OldHepVector3D() {}
+  virtual ~OldHepVector3D() {}
+};
+
+
+
+#include "CLHEP/Geometry/BasicVector3D.h"
+typedef HepGeom::BasicVector3D<double> MyBasicVector3D;
+class OldHepPoint3D
+   : public MyBasicVector3D
+{
+public:
+  OldHepPoint3D() {}
+  virtual ~OldHepPoint3D() {}
+
+  inline double	x() const { return MyBasicVector3D::x(); } 
+  inline double	y() const { return MyBasicVector3D::y(); }
+  inline double	z() const { return MyBasicVector3D::z(); }
+};
+
+
+
+
+
+class OldHepLorentzVector
+{
+public:
+  OldHepLorentzVector() : ee(0) {}
+
+  inline double	x() const { return pp.x(); } 
+  inline double	y() const { return pp.y(); }
+  inline double	z() const { return pp.z(); }
+  inline double	t() const { return ee; }
+
+  double  	ee; 
+  CLHEP::Hep3Vector pp;
+};
+
+
+
+
+#include "CLHEP/Matrix/GenMatrix.h"
+
+class OldHepGenMatrix {
+public :
+  OldHepGenMatrix() {};
+  virtual ~OldHepGenMatrix() {}
+};
+
+
+class OldHepMatrix : public CLHEP::HepGenMatrix
+{
+public:
+  OldHepMatrix() : nrow(0), ncol(0), size(0) {}
+  virtual ~OldHepMatrix() {}
+
+  virtual int  num_row() const { return nrow; }
+  virtual int  num_col() const { return ncol; }
+  virtual int  num_size() const { return size; }
+
+  virtual void invert(int&) {}
+  virtual const double& operator()(int x, int y) const { return m[x*ncol+y]; }    // <- FIXME hack
+  virtual double& operator()(int x, int y) {  return m[x*ncol+y]; }    // <- FIXME hack
+  
+//  std::vector<double,Alloc<double,25> > m;
+  std::vector<double> m;
+  int nrow, ncol;
+  int size;
+};
+
+
+
+
+
+
+#endif
+
+
+
+
+
+
+

Database/AtlasSealCLHEP/AtlasSealCLHEP/OldCLHEPStreamers.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef OLD_CLHEP_STREAMERS_H_
+#define OLD_CLHEP_STREAMERS_H_
+
+/*
+  2006 CERN  Marcin Nowak
+
+  Athena/ROOT custom streamers for CLHEP v.1.8.2 classes
+  
+*/
+
+#include "AthenaPoolServices/T_AthenaRootConverter.h"
+#include "CLHEP/Geometry/Vector3D.h"
+#include "CLHEP/Geometry/Point3D.h"
+#include "CLHEP/Vector/LorentzVector.h"
+#include "OldCLHEP.h"
+
+
+class CLHEPVec3dStreamer  : public T_AthenaRootConverter<HepGeom::Vector3D<double>, OldHepVector3D > {  
+public:
+  CLHEPVec3dStreamer() {
+     SetClassNameAndChecksum("HepVector3D", 358881035U);
+  }          
+  void CopyOldToNew(const OldHepVector3D &old_vec, HepGeom::Vector3D<double> &new_vec )
+  {
+     HepGeom::Vector3D<double>	vec( old_vec.x(), old_vec.y(), old_vec.z() );
+     new_vec = vec;
+   } 
+};
+
+
+
+class CLHEPPoint3dStreamer  : public T_AthenaRootConverter<HepGeom::Point3D<double>, OldHepPoint3D > {  
+public:
+  CLHEPPoint3dStreamer() {
+     SetClassNameAndChecksum("HepPoint3D", 1634550480U);
+  }          
+  void CopyOldToNew(const OldHepPoint3D &old_point, HepGeom::Point3D<double> &new_point );
+};
+
+
+
+class CLHEPRotationStreamer  : public T_AthenaRootConverter<CLHEP::HepRotation, OldHepRotation >
+{
+public:
+  CLHEPRotationStreamer() {
+     SetClassNameAndChecksum("HepRotation", 4141898558U);
+  }
+};
+
+
+template<>
+void
+T_AthenaRootConverter<CLHEP::HepGenMatrix, OldHepGenMatrix >
+::CopyOldToNew(const OldHepGenMatrix &, CLHEP::HepGenMatrix & ) {}
+
+class CLHEPGenMatrixStreamer  : public T_AthenaRootConverter<CLHEP::HepGenMatrix, OldHepGenMatrix >
+{
+public:
+  CLHEPGenMatrixStreamer() {  SetClassNameAndChecksum("HepGenMatrix", 21721098U);  }
+};
+
+
+
+class CLHEPMatrixStreamer  : public T_AthenaRootConverter<CLHEP::HepMatrix, OldHepMatrix >
+{
+public:
+  CLHEPMatrixStreamer() {
+     SetClassNameAndChecksum("HepMatrix", 3811046672U);
+  }
+  void CopyOldToNew(const OldHepMatrix &old_matx, CLHEP::HepMatrix &new_matx );
+};
+
+
+class CLHEPLorVecStreamer  : public T_AthenaRootConverter<CLHEP::HepLorentzVector, OldHepLorentzVector >
+{
+public:
+  CLHEPLorVecStreamer() {
+     SetClassNameAndChecksum("HepLorentzVector", 3077056266U);
+  }
+  void CopyOldToNew(const OldHepLorentzVector &old_vec, CLHEP::HepLorentzVector &new_vec );
+};
+
+
+class CLHEP3VectorStreamer  : public T_AthenaRootConverter<CLHEP::Hep3Vector, OldHep3Vector >
+{
+public:
+  CLHEP3VectorStreamer() {
+     SetClassNameAndChecksum("Hep3Vector", 760000369U);
+  }
+  void CopyOldToNew(const OldHep3Vector &old_vec, CLHEP::Hep3Vector &new_vec );
+};
+
+
+
+class CLHEPBasicVectorStreamer  : public T_AthenaRootConverter<HepGeom::BasicVector3D<double>, OldBasicVector3D >
+{
+public:
+  CLHEPBasicVectorStreamer() {
+     SetClassNameAndChecksum("BasicVector3D", 2681080162U);
+  }
+  void CopyOldToNew(const OldBasicVector3D &old_vec, HepGeom::BasicVector3D<double> &new_vec );
+};
+
+
+
+
+namespace HepGeom { class Transform3D; }
+class CLHEPTransform3DStreamer  : public T_AthenaRootConverter<HepGeom::Transform3D, OldHepTransform3D >
+{
+public:
+  CLHEPTransform3DStreamer() {
+     SetClassNameAndChecksum("HepTransform3D", 520750269U);
+  }
+  void CopyOldToNew(const OldHepTransform3D &old_, HepGeom::Transform3D &new_);
+};
+
+#endif

Database/AtlasSealCLHEP/AtlasSealCLHEP/selection.xml

+<lcgdict>
+
+  <!-- Vector -->
+  <class name="CLHEP::Hep2Vector"/>
+  <!-- rotation interface do not compile with reflex/gcc344 RDS 2006/03
+  <class name="CLHEP::Hep3RotationInterface"/>
+  <class name="CLHEP::Hep4RotationInterface"/>
+  -->
+  <class name="CLHEP::HepBoostZ"/>
+  <class name="CLHEP::HepBoostY"/>
+  <class name="CLHEP::HepBoostX"/>
+  <class name="CLHEP::HepBoost"/>
+  <class name="CLHEP::HepRotationZ"/>
+  <class name="CLHEP::HepRotationY"/>
+  <class name="CLHEP::HepRotationX"/>
+  <class name="CLHEP::HepRep4x4Symmetric"/>
+  <class name="CLHEP::HepRep4x4"/>
+  <class name="CLHEP::HepRep3x3"/>
+  <class name="CLHEP::HepLorentzVector"/>
+  <class name="CLHEP::HepLorentzRotation"/>
+  <class name="CLHEP::Hep3Vector"/>
+  <class name="CLHEP::HepAxisAngle"/>
+  <class name="CLHEP::HepEulerAngles"/>
+  <class name="CLHEP::HepRotation"/>
+
+  <!-- Random` -->
+  <class name="CLHEP::RandStudentT"/>
+  <class name="CLHEP::RandPoissonT"/>
+  <class name="CLHEP::RandPoissonQ"/>
+  <class name="CLHEP::RandPoisson"/>
+  <class name="CLHEP::RandLandau"/>
+  <class name="CLHEP::RandGeneral"/>
+  <class name="CLHEP::RandGaussT"/>
+  <class name="CLHEP::HepStat"/>
+  <class name="CLHEP::RandGaussQ"/>
+  <class name="CLHEP::RandGauss"/>
+  <class name="CLHEP::RandGamma"/>
+  <class name="CLHEP::RandBit"/>
+  <class name="CLHEP::RandExponential"/>
+  <class name="CLHEP::RandChiSquare"/>
+  <class name="CLHEP::RandBreitWigner"/>
+  <class name="CLHEP::RandFlat"/>
+  <class name="CLHEP::RandBinomial"/>
+  <class name="CLHEP::HepRandom"/>
+  <class name="CLHEP::RandEngine"/>
+  <class name="CLHEP::HepJamesRandom"/>
+  <class name="CLHEP::HepRandomEngine"/>
+
+  <!-- Geometry -->
+  <class name="HepGeom::BasicVector3D<double>"/>
+  <class name="HepGeom::BasicVector3D<float>"/>
+  <class name="HepGeom::Normal3D<double>"/>
+  <class name="HepGeom::Normal3D<float>"/>
+  <class name="HepGeom::Point3D<double>"/>
+  <class name="HepGeom::Point3D<float>"/>
+  <class name="HepGeom::Transform3D"/>
+<!--  <class name="HepTransform3D"/> -->
+  <class name="HepGeom::Rotate3D"/>
+  <class name="HepGeom::RotateX3D"/>
+  <class name="HepGeom::RotateY3D"/>
+  <class name="HepGeom::RotateZ3D"/>
+  <class name="HepGeom::Translate3D"/>
+  <class name="HepGeom::TranslateX3D"/>
+  <class name="HepGeom::TranslateY3D"/>
+  <class name="HepGeom::TranslateZ3D"/>
+  <class name="HepGeom::Reflect3D"/>
+  <class name="HepGeom::ReflectX3D"/>
+  <class name="HepGeom::ReflectY3D"/>
+  <class name="HepGeom::ReflectZ3D"/>
+  <class name="HepGeom::Scale3D"/>
+  <class name="HepGeom::ScaleX3D"/>
+  <class name="HepGeom::ScaleY3D"/>
+  <class name="HepGeom::ScaleZ3D"/>
+  <class name="HepGeom::Vector3D<double>"/>
+  <class name="HepGeom::Vector3D<float>"/>
+
+  <!-- Matrix  -->
+  <class name="CLHEP::HepDiagMatrix"/>
+  <class name="CLHEP::HepGenMatrix" />
+  <class name="CLHEP::HepMatrix"/>
+  <class name="CLHEP::HepSymMatrix"/>
+  <class name="CLHEP::HepVector"/>
+
+  <!-- GenericFunctions -->
+
+
+  <!-- OLD CLHEP -->
+
+  <class name="OldHepPoint3D" />
+  <class name="OldHepVector3D" />
+  <class name="OldBasicVector3D" />
+  <class name="OldHep3Vector" />
+  <class name="OldHepMatrix" />
+  <class name="OldHepGenMatrix" />
+  <class name="OldHepLorentzVector" />
+  <class name="OldHepTransform3D" />
+
+  <!-- OLD CLHEP Streamers -->
+
+  <class name="CLHEPVec3dStreamer" />
+  <class name="CLHEPPoint3dStreamer" />
+  <class name="CLHEPGenMatrixStreamer" />
+  <class name="CLHEPMatrixStreamer" />
+  <class name="CLHEPRotationStreamer" />
+  <class name="CLHEPLorVecStreamer" />
+  <class name="CLHEP3VectorStreamer" />
+  <class name="CLHEPBasicVectorStreamer" />
+  <class name="CLHEPTransform3DStreamer" />
+
+</lcgdict>

Database/AtlasSealCLHEP/cmt/requirements

+package AtlasSealCLHEP
+
+author RD Schaffer <R.D.Schaffer@cern.ch>
+
+use AtlasPolicy AtlasPolicy-01-*
+use AtlasCLHEP  AtlasCLHEP-00-* External
+use AthenaPoolServices  AthenaPoolServices-00-*   Database/AthenaPOOL
+
+
+private
+use AtlasReflex   AtlasReflex-00-*   External -no_auto_imports
+
+
+apply_pattern installed_library
+library  AtlasSealCLHEP     OldCLHEPStreamers.cxx
+
+# Pattern to build the dict lib. User should create a single header
+# file: <package>Dict.h which includes all other .h files. See MissingETDict
+# A selection file must be created by hand. This file lists the
+# classes to be added to the dictionary, and which fields are
+# transient. It should be put in ../<package> dir and is conventionally called
+# selection.xml.
+
+macro_append lcgdict_options  ' -I.. '
+macro_append AtlasSealCLHEPDict_shlibflags "  -lAtlasSealCLHEP "
+apply_pattern lcgdict dict=AtlasSealCLHEP  selectionfile=selection.xml headerfiles="../AtlasSealCLHEP/AtlasSealCLHEPDict.h" 
+
+
+#apply_tag no_extra_dict_deps
+#macro QUICK "1"
+
+# Now build a special (hand-written) library to build a dictionary for HepTransform3D
+#apply_pattern lcgdictfix libname=AtlasSealCLHEP  dictfiles="AtlasSealCLHEPDict_dict_fixes.cxx"
+
+apply_pattern declare_joboptions files="*.py"
+apply_pattern declare_python_modules files="*.py"
+
+

Database/AtlasSealCLHEP/doc/mainpage.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+@mainpage AtlasSealCLHEP Package
+
+This package contains Reflex dictionary definitions for some CLHEP classes used within ATLAS.
+
+@author R.D.Schaffer@cern.ch, Marcin.Nowak@cern.ch
+
+@section IntroductionAtlasSealCLHEP Introduction
+
+CLHEP classes used in ATLAS are defined in this package. This package
+was originally needed when CLHEP classes were being written out
+directly. This has mostly changed with the transient/persistent
+separation so that this dictionary is only needed for python
+interaction with CLHEP classes.
+
+There is also some ROOT streamers classes which allow reading old data
+with schema evolved CLHEP classes in the data. This is no longer
+needed with data written with from release 13 and beyond.
+
+*/
+
+/**
+@page UsedAtlasSealCLHEP Used Packages
+@htmlinclude used_packages.html
+*/
+
+/**
+@page RequirementsAtlasSealCLHEP Requirements
+@include requirements
+*/
+

Database/AtlasSealCLHEP/python/OldCLHEPStreamers.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+
+def loadOldCLHEPStreamers():
+    """
+    Helper method to load and configure the AthenaRootStreamerSvc to be able
+    to read Old CLHEP classes (v1.8)
+    """
+    from AthenaCommon.Logging import logging
+    from AthenaCommon.AppMgr import ServiceMgr as svcMgr
+    from AthenaCommon import CfgMgr
+    
+    msg = logging.getLogger( 'loadOldCLHEPStreamers' )
+    msg.debug( "Loading Old CLHEP streamers..." )
+    
+    # Seal services: for loading dictionaries
+    if not hasattr (svcMgr, 'AthenaSealSvc'):
+        svcMgr += CfgMgr.AthenaSealSvc()
+
+    # Reguest loading CLHEP dictionary
+    svcMgr.AthenaSealSvc.DictNames += [ "AtlasSealCLHEPDict" ]
+
+
+    # ROOT streaming service
+    if not hasattr (svcMgr, 'AthenaRootStreamerSvc'):
+        svcMgr += CfgMgr.AthenaRootStreamerSvc()
+    streamerSvc = svcMgr.AthenaRootStreamerSvc
+    
+    # active ROOT streamers list
+    streamerSvc.Streamers  += [ "CLHEPVec3dStreamer" ]      
+    streamerSvc.Streamers  += [ "CLHEPPoint3dStreamer" ]      
+    streamerSvc.Streamers  += [ "CLHEPRotationStreamer" ]      
+    streamerSvc.Streamers  += [ "CLHEPGenMatrixStreamer" ]      
+    streamerSvc.Streamers  += [ "CLHEPMatrixStreamer" ]      
+    streamerSvc.Streamers  += [ "CLHEPLorVecStreamer" ]      
+    streamerSvc.Streamers  += [ "CLHEPTransform3DStreamer" ]      
+    streamerSvc.Streamers  += [ "CLHEP3VectorStreamer" ]      
+    streamerSvc.Streamers  += [ "CLHEPBasicVectorStreamer" ]      
+
+    msg.debug( "Loading Old CLHEP streamers... [DONE]" )
+    return
+
+## load streamer configuration at module import
+loadOldCLHEPStreamers()
+
+## clean-up: avoid running multiple times this method
+del loadOldCLHEPStreamers

Database/AtlasSealCLHEP/python/__init__.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+

Database/AtlasSealCLHEP/share/OldCLHEPStreamers_jobOptions.py

+## load the Old CLHEP streamers by importing the appropriate py-module
+## It configures the AthenaRootStreamerSvc
+import AtlasSealCLHEP.OldCLHEPStreamers

Database/AtlasSealCLHEP/src/AtlasSealCLHEPDict_dict_fixes.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// Generated at Mon Jul 11 17:45:44 2005. Do not modify it
+
+#ifdef _WIN32
+#pragma warning ( disable : 4786 )
+#ifndef LCGDICT_STRING 
+#include <string> // Included here since it is sensitive to private->public trick
+#endif
+#endif
+#define private public
+#define protected public
+#include "../AtlasSealCLHEP/AtlasSealCLHEPDict.h"
+#undef private
+#undef protected
+#include "ReflectionBuilder/ReflectionBuilder.h"
+#include "ReflectionBuilder/CollectionProxy.h"
+#include <typeinfo>
+using namespace seal::reflect;
+
+//------Dictionary for class Transform3D -------------------------------
+class HepTransform3D_dict { 
+  public:
+  HepTransform3D_dict();
+  static void* constructor_2212( void* );
+  static void  destructor( void* o ) { ((HepGeom::Transform3D*)o)->~Transform3D(); }
+};
+HepTransform3D_dict::HepTransform3D_dict() {
+  ClassBuilder _c_("HepTransform3D", "", typeid(HepGeom::Transform3D), sizeof(HepGeom::Transform3D),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
+  _c_.addField("xx", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->xx_)-64, PROTECTED );
+  _c_.addField("xy", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->xy_)-64, PROTECTED );
+  _c_.addField("xz", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->xz_)-64, PROTECTED );
+  _c_.addField("dx", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->dx_)-64, PROTECTED );
+  _c_.addField("yx", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->yx_)-64, PROTECTED );
+  _c_.addField("yy", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->yy_)-64, PROTECTED );
+  _c_.addField("yz", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->yz_)-64, PROTECTED );
+  _c_.addField("dy", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->dy_)-64, PROTECTED );
+  _c_.addField("zx", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->zx_)-64, PROTECTED );
+  _c_.addField("zy", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->zy_)-64, PROTECTED );
+  _c_.addField("zz", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->zz_)-64, PROTECTED );
+  _c_.addField("dz", "double", "", (size_t)(&((HepGeom::Transform3D*)64)->dz_)-64, PROTECTED );
+  _c_.addMethod("HepTransform3D", "", "HepTransform3D", constructor_2212, PUBLIC);
+  _c_.addMethod("~HepTransform3D", "", destructor, PUBLIC);
+  _c_.build();
+}
+
+//------Stub functions for class Transform3D -------------------------------
+void* HepTransform3D_dict::constructor_2212( void* mem) {
+  return ::new(mem) HepGeom::Transform3D();
+}
+
+//------Dictionary for class HepLorentzVector -------------------------------
+class HepLorentzVector_dict { 
+  public:
+  HepLorentzVector_dict();
+  static void* constructor_7008( void* );
+  static void  destructor( void* o ) { ((CLHEP::HepLorentzVector*)o)->~HepLorentzVector(); }
+};
+HepLorentzVector_dict::HepLorentzVector_dict() {
+  ClassBuilder _c_("HepLorentzVector", "", typeid(CLHEP::HepLorentzVector), sizeof(CLHEP::HepLorentzVector),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
+  _c_.addField("pp", "Hep3Vector", "", (size_t)(&((CLHEP::HepLorentzVector*)64)->pp)-64, PRIVATE );
+  _c_.addField("ee", "double", "", (size_t)(&((CLHEP::HepLorentzVector*)64)->ee)-64, PRIVATE );
+  _c_.addMethod("HepLorentzVector", "", "HepLorentzVector", constructor_7008, PUBLIC);
+  _c_.addMethod("~HepLorentzVector", "", destructor, PUBLIC);
+  _c_.build();
+}
+
+//------Stub functions for class HepLorentzVector -------------------------------
+void* HepLorentzVector_dict::constructor_7008( void* mem) {
+  return ::new(mem) CLHEP::HepLorentzVector();
+}
+
+
+//------Dictionary for class Hep3Vector -------------------------------
+class Hep3Vector_dict { 
+  public:
+  Hep3Vector_dict();
+  static void* constructor_x46( void* );
+  static void  destructor( void* o ) { ((CLHEP::Hep3Vector*)o)->~Hep3Vector(); }
+};
+Hep3Vector_dict::Hep3Vector_dict() {
+  ClassBuilder _c_("Hep3Vector", "", typeid(CLHEP::Hep3Vector), sizeof(CLHEP::Hep3Vector),std::vector<const std::type_info*>(), false, NOCONTAINER, 0, PUBLIC);
+  _c_.addField("dx", "double", "", (size_t)(&((CLHEP::Hep3Vector*)64)->dx)-64, PROTECTED );
+  _c_.addField("dy", "double", "", (size_t)(&((CLHEP::Hep3Vector*)64)->dy)-64, PROTECTED );
+  _c_.addField("dz", "double", "", (size_t)(&((CLHEP::Hep3Vector*)64)->dz)-64, PROTECTED );
+  _c_.addMethod("Hep3Vector", "", "CLHEP::Hep3Vector", constructor_x46, PUBLIC);
+  _c_.addMethod("~Hep3Vector", "", destructor, PUBLIC);
+  _c_.build();
+}
+
+//------Stub functions for class Hep3Vector -------------------------------
+
+void* Hep3Vector_dict::constructor_x46( void* mem) {
+  return ::new(mem) CLHEP::Hep3Vector();
+}
+
+//---------  Bootstrap for building classes ------
+
+namespace {
+  struct Dictionaries {
+    Dictionaries() {
+      HepTransform3D_dict();
+      HepLorentzVector_dict();
+      Hep3Vector_dict();
+      Class::resolvePending();
+    }
+  };
+  static Dictionaries instance;
+}
+
+
+//---------  Capabilities specification ------
+
+
+// This file has been generated by lcgdict with the --capabilities option
+static  const char* clnames[] = {
+//--Begin AtlasSealCLHEPDictFix
+    "LCGDict/HepTransform3D",
+    "LCGDict/HepLorentzVector",
+    "LCGDict/Hep3Vector"
+//--End   AtlasSealCLHEPDict
+//--Final End
+};
+
+extern "C" void SEAL_CAPABILITIES (const char**& names, int& n )
+{ 
+  names = clnames;
+  n = sizeof(clnames)/sizeof(char*);
+}
+

Database/AtlasSealCLHEP/src/OldCLHEPStreamers.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#define private public
+#define protected public
+#include "CLHEP/Matrix/Matrix.h"
+#include "CLHEP/Geometry/Transform3D.h"
+#undef private
+#undef protected
+
+#include "AtlasSealCLHEP/OldCLHEPStreamers.h"
+
+#include <iostream>
+
+
+void
+CLHEPMatrixStreamer::CopyOldToNew(const OldHepMatrix &old_matx, CLHEP::HepMatrix &new_matx )
+{
+//      std::cout << "  ****  CLHEPMatrixStreamer::CopyOldToNew() " << std::endl;
+//      std::cout << "  matrix size="<< old_matx.size  << std::endl;
+//      std::cout << "  matrix nrow="<< old_matx.nrow  << std::endl;
+//      std::cout << "  matrix ncol="<< old_matx.ncol  << std::endl;
+//      std::cout << "  matrix m-size="<< old_matx.m.size()  << std::endl;
+     new_matx.m = old_matx.m;    //   ----   FIXME
+     new_matx.size_ = old_matx.size;
+     // intentional swap!   somehow necessary for reading root3 data 
+     new_matx.nrow = old_matx.ncol;
+     new_matx.ncol = old_matx.nrow;
+} 
+
+
+
+void
+CLHEPPoint3dStreamer::CopyOldToNew(const OldHepPoint3D &old_point, HepGeom::Point3D<double> &new_point )
+{
+//    std::cout << "  ****  CLHEPPoint3dStreamer::CopyOldToNew() " << std::endl;
+//    std::cout << "  Point(x,y,z) = "  << old_point.x() << "," << old_point.y() << "," <<  old_point.z() << std::endl;
+   HepGeom::Point3D<double>	point( old_point.x(), old_point.y(), old_point.z() );
+   new_point = point;
+} 
+
+
+
+void
+CLHEPLorVecStreamer::CopyOldToNew(const OldHepLorentzVector &old_vec, CLHEP::HepLorentzVector &new_vec )
+{
+//    std::cout << "  ****  CLHEPLorVecStreamer::CopyOldToNew() " << std::endl;
+//    std::cout << "  LVec(x,y,z,t) = "  << old_vec.x() << "," << old_vec.y() << "," << old_vec.z() << "," << old_vec.t() << std::endl;
+   CLHEP::HepLorentzVector	vector( old_vec.x(),  old_vec.y(),  old_vec.z(),  old_vec.t() );
+   new_vec = vector;
+}
+
+
+void
+CLHEP3VectorStreamer::CopyOldToNew(const OldHep3Vector &old_vec, CLHEP::Hep3Vector &new_vec )
+{
+//    std::cout << "  ****  CLHEP3VectorStreamer::CopyOldToNew() " << std::endl;
+//    std::cout << "  Vec(x,y,z) = "  << old_vec.x() << "," << old_vec.y() << "," << old_vec.z()  << std::endl;
+   CLHEP::Hep3Vector	vector( old_vec.x(),  old_vec.y(),  old_vec.z() );
+   new_vec = vector;
+}
+
+
+void
+CLHEPBasicVectorStreamer::CopyOldToNew(const OldBasicVector3D &old_vec, HepGeom::BasicVector3D<double> &new_vec )
+{
+//   std::cout << "  ****  CLHEPBasicVectorStreamer::CopyOldToNew() " << std::endl;
+//   std::cout << "  Vec(x,y,z) = "  << old_vec.x() << "," << old_vec.y() << "," << old_vec.z()  << std::endl;
+   HepGeom::BasicVector3D<double>	vector( old_vec.x(),  old_vec.y(),  old_vec.z() );
+   new_vec = vector;
+}
+
+
+
+  
+
+
+#define TRANSF_DBGL 0
+void
+CLHEPTransform3DStreamer::CopyOldToNew(const OldHepTransform3D &old_tr, HepGeom::Transform3D &new_tr )
+{
+#if( TRANSF_DBGL > 0 ) 
+  std::cout << "  ****  CLHEPTransform3DStreamer::CopyOldToNew() " << std::endl;
+#endif
+#if( TRANSF_DBGL > 1 )   
+  std::cout << "  TRFM= " << old_tr.m1 <<"," << old_tr.m2 <<"," << old_tr.m3 <<"," << old_tr.m4 << std::endl;
+  std::cout << "  TRFM= " << old_tr.m5 <<"," << old_tr.m6 <<"," << old_tr.m7 <<"," << old_tr.m8 << std::endl;
+  std::cout << "  TRFM= " << old_tr.m9 <<"," << old_tr.m10<<"," << old_tr.m11<<"," << old_tr.m12<< std::endl;
+#endif
+  new_tr.xx_ = old_tr.m4;
+  new_tr.xy_ = old_tr.m5;
+  new_tr.xz_ = old_tr.m6;
+  new_tr.dx_ = old_tr.m1;
+
+  new_tr.yx_ = old_tr.m7;
+  new_tr.yy_ = old_tr.m8;
+  new_tr.yz_ = old_tr.m9;
+  new_tr.dy_ = old_tr.m2;
+  
+  new_tr.zx_ = old_tr.m10;
+  new_tr.zy_ = old_tr.m11;
+  new_tr.zz_ = old_tr.m12;
+  new_tr.dz_ = old_tr.m3;
+#if( TRANSF_DBGL > 1 ) 
+  std::cout << "  TRFM new= " << new_tr.xx() <<"," << new_tr.xy() <<"," << new_tr.xz() <<"," << new_tr.dx() << std::endl;
+  std::cout << "  TRFM new= " << new_tr.yx() <<"," << new_tr.yy() <<"," << new_tr.yz() <<"," << new_tr.dy() << std::endl;
+  std::cout << "  TRFM new= " << new_tr.zx() <<"," << new_tr.zy() <<"," << new_tr.zz() <<"," << new_tr.dz() << std::endl;
+#endif
+}