/data/refman/pasoursint/CMSSW_5_3_0/src/TrackPropagation/Geant4e/interface/ConvertFromToCLHEP.h

Go to the documentation of this file.

#ifndef TrackPropagation_ConvertFromToCLHEP_h
#define TrackPropagation_ConvertFromToCLHEP_h

//CLHEP
#include "CLHEP/Geometry/Point3D.h"
#include "CLHEP/Geometry/Normal3D.h" 
#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Vector/Rotation.h"
#include "CLHEP/Units/GlobalSystemOfUnits.h"

//CMS

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

//Geant4
#include "G4ErrorFreeTrajState.hh"

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

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


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

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




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

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




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

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









  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()));
  }

  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());
  }

  AlgebraicSymMatrix55
   g4ErrorTrajErrToAlgebraicSymMatrix55(const G4ErrorTrajErr& e, const int q) {
    //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) = q*m55(i,j);
        if(j==0) m55(i,j) = q*m55(i,j);
      }
    return m55;
  }

  G4ErrorTrajErr
    algebraicSymMatrix55ToG4ErrorTrajErr(const AlgebraicSymMatrix55& e, const int q) {
    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) = q*g4err(i+1,j+1);
        if(j==0) g4err(i+1,j+1) = q*g4err(i+1,j+1);
      }
    return g4err;
  }

}



#endif