diff --git a/src/algorithm/joint-configuration.hxx b/src/algorithm/joint-configuration.hxx
index a1b164c6a939a150ec3bc4bdecd26ae28742757e..1a8b81d45ea4aefcbf3a3a656a793f904d09e665 100644
--- a/src/algorithm/joint-configuration.hxx
+++ b/src/algorithm/joint-configuration.hxx
@@ -35,7 +35,7 @@ namespace se3
             const Eigen::VectorXd & q,
             const Eigen::VectorXd & v)
   {
-    return integrate<LieGroupTpl>(model, q, v);
+    return integrate<LieGroupMap>(model, q, v);
   }
 
   template<typename LieGroup_t>
@@ -59,7 +59,7 @@ namespace se3
                const Eigen::VectorXd & q1,
                const double u)
   {
-    return interpolate<LieGroupTpl>(model, q0, q1, u);
+    return interpolate<LieGroupMap>(model, q0, q1, u);
   }
 
   template<typename LieGroup_t>
@@ -98,7 +98,7 @@ namespace se3
                      const Eigen::VectorXd & q0,
                      const Eigen::VectorXd & q1)
   {
-    return differentiate<LieGroupTpl>(model, q0, q1);
+    return differentiate<LieGroupMap>(model, q0, q1);
   }
 
   template<typename LieGroup_t>
@@ -121,7 +121,7 @@ namespace se3
                   const Eigen::VectorXd & q0,
                   const Eigen::VectorXd & q1)
   {
-    return squaredDistance<LieGroupTpl>(model, q0, q1);
+    return squaredDistance<LieGroupMap>(model, q0, q1);
   }
   
   template<typename LieGroup_t>
@@ -138,7 +138,7 @@ namespace se3
            const Eigen::VectorXd & q0,
            const Eigen::VectorXd & q1)
   {
-    return std::sqrt(squaredDistance<LieGroupTpl>(model, q0, q1).sum());
+    return std::sqrt(squaredDistance<LieGroupMap>(model, q0, q1).sum());
   }
 
   template<typename LieGroup_t>
@@ -157,7 +157,7 @@ namespace se3
   inline Eigen::VectorXd
   randomConfiguration(const Model & model, const Eigen::VectorXd & lowerLimits, const Eigen::VectorXd & upperLimits)
   {
-    return randomConfiguration<LieGroupTpl>(model, lowerLimits, upperLimits);
+    return randomConfiguration<LieGroupMap>(model, lowerLimits, upperLimits);
   }
 
   template<typename LieGroup_t>
@@ -170,7 +170,7 @@ namespace se3
   inline Eigen::VectorXd
   randomConfiguration(const Model & model)
   {
-    return randomConfiguration<LieGroupTpl>(model);
+    return randomConfiguration<LieGroupMap>(model);
   }
 
   template<typename LieGroup_t>
@@ -185,7 +185,7 @@ namespace se3
   
   inline void normalize(const Model & model, Eigen::VectorXd & qout)
   {
-    return normalize<LieGroupTpl>(model,qout);
+    return normalize<LieGroupMap>(model,qout);
   }
 
   template<typename LieGroup_t>
@@ -212,7 +212,7 @@ namespace se3
                       const Eigen::VectorXd & q2,
                       const double& prec = Eigen::NumTraits<double>::dummy_precision())
   {
-    return isSameConfiguration<LieGroupTpl>(model, q1, q2, prec);
+    return isSameConfiguration<LieGroupMap>(model, q1, q2, prec);
   }
   
 
@@ -232,7 +232,7 @@ namespace se3
   
   inline Eigen::VectorXd neutral(const Model & model)
   {
-    return neutral<LieGroupTpl>(model);
+    return neutral<LieGroupMap>(model);
   }
 
 
diff --git a/src/multibody/liegroup/liegroup.hpp b/src/multibody/liegroup/liegroup.hpp
index ec41f852c6fafa44e2947473ab9c6b08fc37c0e3..6b545129e1d2ee4e0d6222a8c0b7f70355aeb11a 100644
--- a/src/multibody/liegroup/liegroup.hpp
+++ b/src/multibody/liegroup/liegroup.hpp
@@ -27,28 +27,28 @@
 #include "pinocchio/multibody/joint/fwd.hpp"
 
 namespace se3 {
-  struct LieGroupTpl {
+  struct LieGroupMap {
     template<typename JointModel> struct operation {
       typedef VectorSpaceOperation<JointModel::NQ> type;
     };
   };
   template<typename JointModel>
   struct LieGroup {
-    typedef typename LieGroupTpl::operation<JointModel>::type type;
+    typedef typename LieGroupMap::operation<JointModel>::type type;
   };
 
-  template<> struct LieGroupTpl::operation <JointModelComposite> {};
-  template<> struct LieGroupTpl::operation <JointModelSpherical> {
+  template<> struct LieGroupMap::operation <JointModelComposite> {};
+  template<> struct LieGroupMap::operation <JointModelSpherical> {
     typedef SpecialOrthogonalOperation<3> type;
   };
-  template<> struct LieGroupTpl::operation <JointModelFreeFlyer> {
+  template<> struct LieGroupMap::operation <JointModelFreeFlyer> {
     typedef SpecialEuclideanOperation<3> type;
   };
-  template<> struct LieGroupTpl::operation <JointModelPlanar> {
+  template<> struct LieGroupMap::operation <JointModelPlanar> {
     typedef SpecialEuclideanOperation<2> type;
   };
   template<typename Scalar, int Options, int axis>
-  struct LieGroupTpl::operation <JointModelRevoluteUnboundedTpl<Scalar,Options,axis> > {
+  struct LieGroupMap::operation <JointModelRevoluteUnboundedTpl<Scalar,Options,axis> > {
     typedef SpecialOrthogonalOperation<2> type;
   };
 }
diff --git a/src/multibody/model.hxx b/src/multibody/model.hxx
index 31d3430e60ae2744cd162883a94144136e5aa5c8..45efdb299d7829ffdc300bdd2edd4fba6c62ef57 100644
--- a/src/multibody/model.hxx
+++ b/src/multibody/model.hxx
@@ -99,7 +99,7 @@ namespace se3
     jmodel.jointConfigSelector(upperPositionLimit) = max_config;
     
     neutralConfiguration.conservativeResize(nq);
-    NeutralStepAlgo<LieGroupTpl,JointModelDerived>::run(jmodel,neutralConfiguration);
+    NeutralStepAlgo<LieGroupMap,JointModelDerived>::run(jmodel,neutralConfiguration);
 
     rotorInertia.conservativeResize(nv);
     jmodel.jointVelocitySelector(rotorInertia).setZero();
diff --git a/unittest/joint-composite.cpp b/unittest/joint-composite.cpp
index 7161dc8e5f3876e98e015f8e7bdae8daa060b0ed..9fe9b865f10e632ba76a01ba4167909589d73e1d 100644
--- a/unittest/joint-composite.cpp
+++ b/unittest/joint-composite.cpp
@@ -117,8 +117,8 @@ void test_joint_methods(const JointModelBase<JointModel> & jmodel, JointModelCom
   Eigen::VectorXd qq = q;
   Eigen::VectorXd vv = v;
   Eigen::VectorXd res(jmodel_composite.nq());
-  typename se3::IntegrateStep<se3::LieGroupTpl>::ArgsType args(qq, vv, res);
-  se3::IntegrateStep<se3::LieGroupTpl>::run(jmodel_composite, args);
+  typename se3::IntegrateStep<se3::LieGroupMap>::ArgsType args(qq, vv, res);
+  se3::IntegrateStep<se3::LieGroupMap>::run(jmodel_composite, args);
 }
 
 struct TestJointComposite{