ConvertFromToCLHEP.h

Go to the documentation of this file.

#ifndef TrackPropagation_ConvertFromToCLHEP_h
#define TrackPropagation_ConvertFromToCLHEP_h

// CLHEP
#include <CLHEP/Geometry/Normal3D.h>
#include <CLHEP/Geometry/Point3D.h>
#include <CLHEP/Units/SystemOfUnits.h>
#include <CLHEP/Vector/Rotation.h>
#include <CLHEP/Vector/ThreeVector.h>

// CMS
#include "DataFormats/CLHEP/interface/AlgebraicObjects.h"
#include "DataFormats/GeometrySurface/interface/TkRotation.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"

// Geant4
#include "G4ErrorFreeTrajState.hh"

namespace TrackPropagation {
  using CLHEP::cm;
  inline HepGeom::Point3D<double> globalPointToHepPoint3D(const GlobalPoint &r) {
    return HepGeom::Point3D<double>(r.x() * cm, r.y() * cm, r.z() * cm);
  }

  inline GlobalPoint hepPoint3DToGlobalPoint(const HepGeom::Point3D<double> &r) {
    return GlobalPoint(r.x() / cm, r.y() / cm, r.z() / cm);
  }

  inline double g4doubleToCmsDouble(const G4double &d) { return d / cm; }

  inline HepGeom::Normal3D<double> globalVectorToHepNormal3D(const GlobalVector &p) {
    return HepGeom::Normal3D<double>(p.x(), p.y(), p.z());
  }

  inline GlobalVector hepNormal3DToGlobalVector(const HepGeom::Normal3D<double> &p) {
    return GlobalVector(p.x(), p.y(), p.z());
  }

  inline CLHEP::Hep3Vector globalVectorToHep3Vector(const GlobalVector &p) {
    return CLHEP::Hep3Vector(p.x(), p.y(), p.z());
  }

  inline GlobalVector hep3VectorToGlobalVector(const CLHEP::Hep3Vector &p) { return GlobalVector(p.x(), p.y(), p.z()); }

  inline CLHEP::Hep3Vector globalPointToHep3Vector(const GlobalPoint &r) {
    return CLHEP::Hep3Vector(r.x() * cm, r.y() * cm, r.z() * cm);
  }

  inline GlobalPoint hep3VectorToGlobalPoint(const CLHEP::Hep3Vector &v) {
    return GlobalPoint(v.x() / cm, v.y() / cm, v.z() / cm);
  }

  inline CLHEP::HepRotation tkRotationFToHepRotation(const TkRotation<float> &tkr) {
    return CLHEP::HepRotation(CLHEP::Hep3Vector(tkr.xx(), tkr.yx(), tkr.zx()),
                              CLHEP::Hep3Vector(tkr.xy(), tkr.yy(), tkr.zy()),
                              CLHEP::Hep3Vector(tkr.xz(), tkr.yz(), tkr.zz()));
  }

  inline TkRotation<float> hepRotationToTkRotationF(const CLHEP::HepRotation &r) {
    return TkRotation<float>(r.xx(), r.xy(), r.xz(), r.yx(), r.yy(), r.yz(), r.zx(), r.zy(), r.zz());
  }

  inline AlgebraicSymMatrix55 g4ErrorTrajErrToAlgebraicSymMatrix55(const G4ErrorTrajErr &e, const int q) {
    assert(q != 0);
    // From DataFormats/CLHEP/interface/Migration.h
    // typedef ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >
    // AlgebraicSymMatrix55;
    AlgebraicSymMatrix55 m55;
    for (unsigned int i = 0; i < 5; i++)
      for (unsigned int j = 0; j < 5; j++) {
        m55(i, j) = e(i + 1, j + 1);
        if (i == 0)
          m55(i, j) = double(q) * m55(i, j);
        if (j == 0)
          m55(i, j) = double(q) * m55(i, j);
      }
    return m55;
  }

  inline G4ErrorTrajErr algebraicSymMatrix55ToG4ErrorTrajErr(const AlgebraicSymMatrix55 &e, const int q) {
    assert(q != 0);
    G4ErrorTrajErr g4err(5, 1);
    for (unsigned int i = 0; i < 5; i++)
      for (unsigned int j = 0; j < 5; j++) {
        g4err(i + 1, j + 1) = e(i, j);

        if (i == 0)
          g4err(i + 1, j + 1) = g4err(i + 1, j + 1) * double(q);
        if (j == 0)
          g4err(i + 1, j + 1) = g4err(i + 1, j + 1) * double(q);
      }
    return g4err;
  }

}  // namespace TrackPropagation

#endif