diff --git a/Resample/Processed/Slicer.cpp b/Resample/Processed/Slicer.cpp
index dd062756509857727d5b5e5d15ce4dc78d88a4b1..3b82715ee8854b454c55d3e6a76a03a77dd6b411 100644
--- a/Resample/Processed/Slicer.cpp
+++ b/Resample/Processed/Slicer.cpp
@@ -60,8 +60,8 @@ SlicingEffects computeSlicingEffects(ZLimits limits, const R3& position, double
     return {new_position, dz_bottom, dz_top};
 }
 
-bool shapeIsContainedInLimits(const IFormFactor& formfactor, ZLimits limits,
-                              const IRotation* rotation, R3 translation)
+bool shapeIsContainedInLimits(const IFormFactor& formfactor, ZLimits limits, R3 translation,
+                              const IRotation* rotation)
 {
     double zbottom = formfactor.bottomZ(rotation) + translation.z();
     double ztop = formfactor.topZ(rotation) + translation.z();
@@ -69,8 +69,8 @@ bool shapeIsContainedInLimits(const IFormFactor& formfactor, ZLimits limits,
     return limits.zBottom() <= zbottom && ztop <= limits.zTop();
 }
 
-bool shapeOutsideLimits(const IFormFactor& formfactor, ZLimits limits, const IRotation* rotation,
-                        R3 translation)
+bool shapeOutsideLimits(const IFormFactor& formfactor, ZLimits limits, R3 translation,
+                        const IRotation* rotation)
 {
     double zbottom = formfactor.bottomZ(rotation) + translation.z();
     double ztop = formfactor.topZ(rotation) + translation.z();
@@ -78,22 +78,22 @@ bool shapeOutsideLimits(const IFormFactor& formfactor, ZLimits limits, const IRo
     return ztop <= limits.zBottom() || zbottom >= limits.zTop();
 }
 
-ReParticle* createTransformedFormFactor(const IFormFactor* formfactor, const IRotation* rot,
-                                        const R3& translation)
+ReParticle* createTransformedFormFactor(const IFormFactor* formfactor, const R3& translation,
+                                        const IRotation* rot)
 {
     return new ReParticle(*formfactor, new R3(translation),
                           rot && !rot->isIdentity() ? std::move(new RotMatrix(rot->rotMatrix()))
                                                     : nullptr);
 }
 
-ReParticle* createParticleSlice(const IFormFactor* ff, ZLimits limits, const IRotation* rot,
-                                R3 translation)
+ReParticle* createParticleSlice(const IFormFactor* ff, ZLimits limits, const R3& translation,
+                                const IRotation* rot)
 {
-    if (shapeOutsideLimits(*ff, limits, rot, translation))
+    if (shapeOutsideLimits(*ff, limits, translation, rot))
         return nullptr;
 
-    if (shapeIsContainedInLimits(*ff, limits, rot, translation))
-        return createTransformedFormFactor(ff, rot, translation);
+    if (shapeIsContainedInLimits(*ff, limits, translation, rot))
+        return createTransformedFormFactor(ff, translation, rot);
 
     if (!ff->canSliceAnalytically(rot))
         throw std::runtime_error("Slicing of " + ff->className()
@@ -104,27 +104,27 @@ ReParticle* createParticleSlice(const IFormFactor* ff, ZLimits limits, const IRo
         double dbase_edge = 2 * effects.dz_bottom * Math::cot(f->alpha());
         auto slicedff = new Pyramid2(f->length() - dbase_edge, f->width() - dbase_edge,
                                      f->height() - effects.dz_bottom - effects.dz_top, f->alpha());
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Box*>(ff)) {
         const SlicingEffects effects = computeSlicingEffects(limits, translation, f->height());
         auto slicedff =
             new Box(f->length(), f->width(), f->height() - effects.dz_bottom - effects.dz_top);
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Cone*>(ff)) {
         const SlicingEffects effects = computeSlicingEffects(limits, translation, f->height());
         double dradius = effects.dz_bottom * Math::cot(f->alpha());
         auto slicedff = new Cone(f->radius() - dradius,
                                  f->height() - effects.dz_bottom - effects.dz_top, f->alpha());
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Pyramid6*>(ff)) {
         const SlicingEffects effects = computeSlicingEffects(limits, translation, f->height());
         double dbase_edge = effects.dz_bottom * Math::cot(f->alpha());
         auto slicedff = new Pyramid6(f->baseEdge() - dbase_edge,
                                      f->height() - effects.dz_bottom - effects.dz_top, f->alpha());
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Bipyramid4*>(ff)) {
         const SlicingEffects effects =
@@ -135,7 +135,7 @@ ReParticle* createParticleSlice(const IFormFactor* ff, ZLimits limits, const IRo
                                          f->height() * (1 + f->heightRatio()) - effects.dz_bottom
                                              - effects.dz_top,
                                          f->alpha());
-            return createTransformedFormFactor(slicedff, rot, effects.position);
+            return createTransformedFormFactor(slicedff, effects.position, rot);
         }
         if (effects.dz_top > f->heightRatio() * f->height()) {
             double dbase_edge = 2 * (f->height() - effects.dz_bottom) * Math::cot(f->alpha());
@@ -143,29 +143,29 @@ ReParticle* createParticleSlice(const IFormFactor* ff, ZLimits limits, const IRo
                                          f->height() * (1 + f->heightRatio()) - effects.dz_bottom
                                              - effects.dz_top,
                                          M_PI - f->alpha());
-            return createTransformedFormFactor(slicedff, rot, effects.position);
+            return createTransformedFormFactor(slicedff, effects.position, rot);
         }
         auto slicedff = new Bipyramid4(f->length(), f->height() - effects.dz_bottom,
                                        f->heightRatio() * f->height() - effects.dz_top, f->alpha());
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Cylinder*>(ff)) {
         auto effects = computeSlicingEffects(limits, translation, f->height());
         auto slicedff = new Cylinder(f->radius(), f->height() - effects.dz_bottom - effects.dz_top);
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const EllipsoidalCylinder*>(ff)) {
         auto effects = computeSlicingEffects(limits, translation, f->height());
         auto slicedff = new EllipsoidalCylinder(f->radiusX(), f->radiusY(),
                                                 f->height() - effects.dz_bottom - effects.dz_top);
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const HorizontalCylinder*>(ff)) {
         auto effects = computeSlicingEffects(limits, translation, 2 * f->radius());
         auto slicedff =
             new HorizontalCylinder(f->radius(), f->length(), -f->radius() + effects.dz_bottom,
                                    f->radius() - effects.dz_top);
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Sphere*>(ff)) {
         R3 new_translation = translation;
@@ -176,57 +176,57 @@ ReParticle* createParticleSlice(const IFormFactor* ff, ZLimits limits, const IRo
         const double h = 2 * f->radius();
         auto effects = computeSlicingEffects(limits, translation, h);
         auto slicedff = new TruncatedSphere(f->radius(), h - effects.dz_bottom, effects.dz_top);
-        return createTransformedFormFactor(slicedff, nullptr, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, nullptr);
 
     } else if (const auto* f = dynamic_cast<const Spheroid*>(ff)) {
         double flattening = f->height() / (2.0 * f->radius());
         auto effects = computeSlicingEffects(limits, translation, f->height());
         auto slicedff = new TruncatedSpheroid(f->radius(), f->height() - effects.dz_bottom,
                                               flattening, effects.dz_top);
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const LongBoxGauss*>(ff)) {
         auto effects = computeSlicingEffects(limits, translation, f->height());
         auto slicedff = new LongBoxGauss(f->length(), f->width(),
                                          f->height() - effects.dz_bottom - effects.dz_top);
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const LongBoxLorentz*>(ff)) {
         auto effects = computeSlicingEffects(limits, translation, f->height());
         auto slicedff = new LongBoxLorentz(f->length(), f->width(),
                                            f->height() - effects.dz_bottom - effects.dz_top);
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Prism3*>(ff)) {
         auto effects = computeSlicingEffects(limits, translation, f->height());
         auto slicedff = new Prism3(f->baseEdge(), f->height() - effects.dz_bottom - effects.dz_top);
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Prism6*>(ff)) {
         auto effects = computeSlicingEffects(limits, translation, f->height());
         auto slicedff = new Prism6(f->baseEdge(), f->height() - effects.dz_bottom - effects.dz_top);
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Pyramid4*>(ff)) {
         auto effects = computeSlicingEffects(limits, translation, f->height());
         double dbaseEdge = 2 * effects.dz_bottom * Math::cot(f->alpha());
         auto slicedff = new Pyramid4(f->baseEdge() - dbaseEdge,
                                      f->height() - effects.dz_bottom - effects.dz_top, f->alpha());
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const Pyramid3*>(ff)) {
         auto effects = computeSlicingEffects(limits, translation, f->height());
         double dbaseEdge = 2 * sqrt(3) * effects.dz_bottom * Math::cot(f->alpha());
         auto slicedff = new Pyramid3(f->baseEdge() - dbaseEdge,
                                      f->height() - effects.dz_bottom - effects.dz_top, f->alpha());
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const TruncatedSphere*>(ff)) {
         double height = f->height() - f->removedTop();
         auto effects = computeSlicingEffects(limits, translation, height);
         auto slicedff = new TruncatedSphere(f->radius(), f->height() - effects.dz_bottom,
                                             effects.dz_top + f->removedTop());
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else if (const auto* f = dynamic_cast<const TruncatedSpheroid*>(ff)) {
         double height = f->height() - f->removedTop();
@@ -234,7 +234,7 @@ ReParticle* createParticleSlice(const IFormFactor* ff, ZLimits limits, const IRo
         auto slicedff =
             new TruncatedSpheroid(f->radius(), f->height() - effects.dz_bottom,
                                   f->heightFlattening(), effects.dz_top + f->removedTop());
-        return createTransformedFormFactor(slicedff, rot, effects.position);
+        return createTransformedFormFactor(slicedff, effects.position, rot);
 
     } else
         throw std::runtime_error("Slicing of " + ff->className() + " not supported");
@@ -269,7 +269,7 @@ OwningVector<IReParticle> Compute::Slicing::particlesInSlice(const IParticle* pa
     if (const auto* p = dynamic_cast<const Particle*>(particle)) {
         ASSERT(p->pFormfactor());
         std::unique_ptr<ReParticle> particleSlice(
-            createParticleSlice(p->pFormfactor(), limits, p->rotation(), p->particlePosition()));
+            createParticleSlice(p->pFormfactor(), limits, p->particlePosition(), p->rotation()));
         if (!particleSlice)
             return {};
         double volume = particleSlice->volume();
@@ -342,10 +342,10 @@ OwningVector<IReParticle> Compute::Slicing::particlesInSlice(const IParticle* pa
             return {};
 
         std::unique_ptr<ReParticle> new_shape(
-            createParticleSlice(meso_formfactor, limits, p->rotation(), p->particlePosition()));
+            createParticleSlice(meso_formfactor, limits, p->particlePosition(), p->rotation()));
 
         const std::unique_ptr<Crystal> new_crystal(
-            crystal->transformed(p->rotation(), p->particlePosition()));
+            crystal->transformed(p->particlePosition(), p->rotation()));
 
         const std::unique_ptr<IReParticle> new_basis(
             processBasis(new_crystal->basis(), ambientMat));
@@ -379,7 +379,7 @@ ZLimits Compute::Slicing::zSpan(const IParticle* particle)
     if (const auto* p = dynamic_cast<const Particle*>(particle)) {
         ASSERT(p->pFormfactor());
         std::unique_ptr<ReParticle> particleSlice(
-            createParticleSlice(p->pFormfactor(), ZLimits(), p->rotation(), p->particlePosition()));
+            createParticleSlice(p->pFormfactor(), ZLimits(), p->particlePosition(), p->rotation()));
         if (!particleSlice)
             return {};
         return particleSlice->Z_span();
@@ -407,7 +407,7 @@ ZLimits Compute::Slicing::zSpan(const IParticle* particle)
         const IFormFactor* meso_formfactor = p->outerShape();
         ASSERT(meso_formfactor);
         std::unique_ptr<ReParticle> new_shape(
-            createParticleSlice(meso_formfactor, ZLimits(), p->rotation(), p->particlePosition()));
+            createParticleSlice(meso_formfactor, ZLimits(), p->particlePosition(), p->rotation()));
 
         return {new_shape->bottom_Z(nullptr), new_shape->top_Z(nullptr)};
 
diff --git a/Sample/Particle/Crystal.cpp b/Sample/Particle/Crystal.cpp
index 1fe580fa92155e30bf5cd99f44e6547489fa3001..f4d3260dc41aeda2d3471e5fe762e6810dcbd27f 100644
--- a/Sample/Particle/Crystal.cpp
+++ b/Sample/Particle/Crystal.cpp
@@ -43,7 +43,7 @@ std::vector<const INode*> Crystal::nodeChildren() const
     return std::vector<const INode*>() << m_basis << m_lattice;
 }
 
-Crystal* Crystal::transformed(const IRotation* rotation, const R3& translation) const
+Crystal* Crystal::transformed(const R3& translation, const IRotation* rotation) const
 {
     const Lattice3D new_lattice = rotation ? m_lattice->rotated(rotation->rotMatrix()) : *m_lattice;
     IParticle* new_basis{m_basis->clone()};
diff --git a/Sample/Particle/Crystal.h b/Sample/Particle/Crystal.h
index 1d2ccff2273d66f24e26b2072dc381b661ef8fbb..ad706bfb1806381184665583ac7cbe3568988799 100644
--- a/Sample/Particle/Crystal.h
+++ b/Sample/Particle/Crystal.h
@@ -44,7 +44,7 @@ public:
     const Lattice3D* lattice() const { return m_lattice.get(); }
     double position_variance() const { return m_position_variance; }
 
-    Crystal* transformed(const IRotation* rotation, const R3& translation) const;
+    Crystal* transformed(const R3& translation, const IRotation* rotation) const;
 
     std::string validate() const override { return ""; }
 
diff --git a/auto/Wrap/libBornAgainSample.py b/auto/Wrap/libBornAgainSample.py
index 8d1981e1ac03c5fdd3d0d140099a54e0d49f6f3c..23bb1010c1e04fd22fdd99f7f4d7c9ded74637bc 100644
--- a/auto/Wrap/libBornAgainSample.py
+++ b/auto/Wrap/libBornAgainSample.py
@@ -2986,9 +2986,9 @@ class Crystal(ISampleNode):
         r"""position_variance(Crystal self) -> double"""
         return _libBornAgainSample.Crystal_position_variance(self)
 
-    def transformed(self, rotation, translation):
-        r"""transformed(Crystal self, IRotation rotation, R3 translation) -> Crystal"""
-        return _libBornAgainSample.Crystal_transformed(self, rotation, translation)
+    def transformed(self, translation, rotation):
+        r"""transformed(Crystal self, R3 translation, IRotation rotation) -> Crystal"""
+        return _libBornAgainSample.Crystal_transformed(self, translation, rotation)
 
     def validate(self):
         r"""validate(Crystal self) -> std::string"""
diff --git a/auto/Wrap/libBornAgainSample_wrap.cpp b/auto/Wrap/libBornAgainSample_wrap.cpp
index 7853a58a8f787ba82652f8529e506c9ccb55c7a7..bb23303eab41d8e07bc4621f904dbcc0eb18d35e 100644
--- a/auto/Wrap/libBornAgainSample_wrap.cpp
+++ b/auto/Wrap/libBornAgainSample_wrap.cpp
@@ -36240,8 +36240,8 @@ fail:
 SWIGINTERN PyObject *_wrap_Crystal_transformed(PyObject *self, PyObject *args) {
   PyObject *resultobj = 0;
   Crystal *arg1 = (Crystal *) 0 ;
-  IRotation *arg2 = (IRotation *) 0 ;
-  R3 *arg3 = 0 ;
+  R3 *arg2 = 0 ;
+  IRotation *arg3 = (IRotation *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -36257,20 +36257,20 @@ SWIGINTERN PyObject *_wrap_Crystal_transformed(PyObject *self, PyObject *args) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Crystal_transformed" "', argument " "1"" of type '" "Crystal const *""'"); 
   }
   arg1 = reinterpret_cast< Crystal * >(argp1);
-  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_IRotation, 0 |  0 );
+  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Vec3T_double_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Crystal_transformed" "', argument " "2"" of type '" "IRotation const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Crystal_transformed" "', argument " "2"" of type '" "R3 const &""'"); 
   }
-  arg2 = reinterpret_cast< IRotation * >(argp2);
-  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Vec3T_double_t,  0  | 0);
-  if (!SWIG_IsOK(res3)) {
-    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Crystal_transformed" "', argument " "3"" of type '" "R3 const &""'"); 
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Crystal_transformed" "', argument " "2"" of type '" "R3 const &""'"); 
   }
-  if (!argp3) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Crystal_transformed" "', argument " "3"" of type '" "R3 const &""'"); 
+  arg2 = reinterpret_cast< R3 * >(argp2);
+  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_IRotation, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Crystal_transformed" "', argument " "3"" of type '" "IRotation const *""'"); 
   }
-  arg3 = reinterpret_cast< R3 * >(argp3);
-  result = (Crystal *)((Crystal const *)arg1)->transformed((IRotation const *)arg2,(R3 const &)*arg3);
+  arg3 = reinterpret_cast< IRotation * >(argp3);
+  result = (Crystal *)((Crystal const *)arg1)->transformed((R3 const &)*arg2,(IRotation const *)arg3);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Crystal, 0 |  0 );
   return resultobj;
 fail:
@@ -62102,7 +62102,7 @@ static PyMethodDef SwigMethods[] = {
 	 { "Crystal_basis", _wrap_Crystal_basis, METH_O, "Crystal_basis(Crystal self) -> IParticle"},
 	 { "Crystal_lattice", _wrap_Crystal_lattice, METH_O, "Crystal_lattice(Crystal self) -> Lattice3D"},
 	 { "Crystal_position_variance", _wrap_Crystal_position_variance, METH_O, "Crystal_position_variance(Crystal self) -> double"},
-	 { "Crystal_transformed", _wrap_Crystal_transformed, METH_VARARGS, "Crystal_transformed(Crystal self, IRotation rotation, R3 translation) -> Crystal"},
+	 { "Crystal_transformed", _wrap_Crystal_transformed, METH_VARARGS, "Crystal_transformed(Crystal self, R3 translation, IRotation rotation) -> Crystal"},
 	 { "Crystal_validate", _wrap_Crystal_validate, METH_O, "Crystal_validate(Crystal self) -> std::string"},
 	 { "Crystal_swigregister", Crystal_swigregister, METH_O, NULL},
 	 { "Crystal_swiginit", Crystal_swiginit, METH_VARARGS, NULL},