diff --git a/src/materials/material_linear_elastic_generic1.hh b/src/materials/material_linear_elastic_generic1.hh
index 0680233..eb779f6 100644
--- a/src/materials/material_linear_elastic_generic1.hh
+++ b/src/materials/material_linear_elastic_generic1.hh
@@ -1,185 +1,185 @@
 /**
  * @file   material_linear_elastic_generic1.hh
  *
  * @author Till Junge <till.junge@altermail.ch>
  *
  * @date   21 Sep 2018
  *
  * @brief Implementation fo a generic linear elastic material that
  *        stores the full elastic stiffness tensor. Convenient but not the
  *        most efficient
  *
  * Copyright © 2018 Till Junge
  *
  * µSpectre is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation, either version 3, or (at
  * your option) any later version.
  *
  * µSpectre is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with µSpectre; see the file COPYING. If not, write to the
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * * Boston, MA 02111-1307, USA.
  *
  * Additional permission under GNU GPL version 3 section 7
  *
  * If you modify this Program, or any covered work, by linking or combining it
  * with proprietary FFT implementations or numerical libraries, containing parts
  * covered by the terms of those libraries' licenses, the licensors of this
  * Program grant you additional permission to convey the resulting work.
  */
 
 #ifndef SRC_MATERIALS_MATERIAL_LINEAR_ELASTIC_GENERIC1_HH_
 #define SRC_MATERIALS_MATERIAL_LINEAR_ELASTIC_GENERIC1_HH_
 
 #include "common/common.hh"
 #include "common/T4_map_proxy.hh"
 #include "materials/material_muSpectre_base.hh"
 #include "common/tensor_algebra.hh"
 
 namespace muSpectre {
 
   /**
    * forward declaration
    */
   template <Dim_t DimS, Dim_t DimM>
   class MaterialLinearElasticGeneric1;
 
   /**
    * traits for use by MaterialMuSpectre for crtp
    */
   template <Dim_t DimS, Dim_t DimM>
   struct MaterialMuSpectre_traits<MaterialLinearElasticGeneric1<DimS, DimM>> {
     //! global field collection
     using GFieldCollection_t =
         typename MaterialBase<DimS, DimM>::GFieldCollection_t;
 
     //! expected map type for strain fields
     using StrainMap_t =
         MatrixFieldMap<GFieldCollection_t, Real, DimM, DimM, true>;
     //! expected map type for stress fields
     using StressMap_t = MatrixFieldMap<GFieldCollection_t, Real, DimM, DimM>;
     //! expected map type for tangent stiffness fields
     using TangentMap_t = T4MatrixFieldMap<GFieldCollection_t, Real, DimM>;
 
     //! declare what type of strain measure your law takes as input
     constexpr static auto strain_measure{StrainMeasure::GreenLagrange};
     //! declare what type of stress measure your law yields as output
     constexpr static auto stress_measure{StressMeasure::PK2};
 
     //! elasticity without internal variables
     using InternalVariables = std::tuple<>;
   };
 
   /**
    * Linear elastic law defined by a full stiffness tensor. Very
    * generic, but not most efficient
    */
   template <Dim_t DimS, Dim_t DimM>
   class MaterialLinearElasticGeneric1
       : public MaterialMuSpectre<MaterialLinearElasticGeneric1<DimS, DimM>,
                                  DimS, DimM> {
    public:
     //! parent type
     using Parent = MaterialMuSpectre<MaterialLinearElasticGeneric1<DimS, DimM>,
                                      DimS, DimM>;
     //! generic input tolerant to python input
     using CInput_t =
         Eigen::Ref<Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic>, 0,
                    Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>>;
     //! Default constructor
     MaterialLinearElasticGeneric1() = delete;
 
     /**
      * Constructor by name and stiffness tensor.
      *
      * @param name unique material name
      * @param C_voigt elastic tensor in Voigt notation
      */
     MaterialLinearElasticGeneric1(const std::string & name,
                                   const CInput_t & C_voigt);
 
     //! Copy constructor
     MaterialLinearElasticGeneric1(const MaterialLinearElasticGeneric1 & other) =
         delete;
 
     //! Move constructor
     MaterialLinearElasticGeneric1(MaterialLinearElasticGeneric1 && other) =
         delete;
 
     //! Destructor
     virtual ~MaterialLinearElasticGeneric1() = default;
 
     //! Copy assignment operator
     MaterialLinearElasticGeneric1 &
     operator=(const MaterialLinearElasticGeneric1 & other) = delete;
 
     //! Move assignment operator
     MaterialLinearElasticGeneric1 &
     operator=(MaterialLinearElasticGeneric1 && other) = delete;
 
     //! see
     //! http://eigen.tuxfamily.org/dox/group__TopicStructHavingEigenMembers.html
     EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
 
     /**
      * evaluates second Piola-Kirchhoff stress given the Green-Lagrange
      * strain (or Cauchy stress if called with a small strain tensor)
      */
     template <class Derived>
     inline decltype(auto) evaluate_stress(const Eigen::MatrixBase<Derived> & E);
 
     /**
      * evaluates both second Piola-Kirchhoff stress and stiffness given
      * the Green-Lagrange strain (or Cauchy stress and stiffness if
      * called with a small strain tensor)
      */
     template <class Derived>
     inline decltype(auto)
     evaluate_stress_tangent(const Eigen::MatrixBase<Derived> & E);
 
     /**
      * return the empty internals tuple
      */
     std::tuple<> & get_internals() { return this->internal_variables; }
 
     /**
      * return a reference to the stiffness tensor
      */
     const T4Mat<Real, DimM> & get_C() const { return this->C; }
 
    protected:
-    T4Mat<Real, DimM> C{}; //! stiffness tensor
+    T4Mat<Real, DimM> C{};  //! stiffness tensor
     //! empty tuple
     std::tuple<> internal_variables{};
   };
 
   /* ---------------------------------------------------------------------- */
   template <Dim_t DimS, Dim_t DimM>
   template <class Derived>
   auto MaterialLinearElasticGeneric1<DimS, DimM>::evaluate_stress(
       const Eigen::MatrixBase<Derived> & E) -> decltype(auto) {
     static_assert(Derived::ColsAtCompileTime == DimM, "wrong input size");
     static_assert(Derived::RowsAtCompileTime == DimM, "wrong input size");
     return Matrices::tensmult(this->C, E);
   }
 
   /* ---------------------------------------------------------------------- */
   template <Dim_t DimS, Dim_t DimM>
   template <class Derived>
   auto MaterialLinearElasticGeneric1<DimS, DimM>::evaluate_stress_tangent(
       const Eigen::MatrixBase<Derived> & E) -> decltype(auto) {
     using Stress_t = decltype(this->evaluate_stress(E));
     using Stiffness_t = Eigen::Map<T4Mat<Real, DimM>>;
     using Ret_t = std::tuple<Stress_t, Stiffness_t>;
     return Ret_t{this->evaluate_stress(E),
                  Stiffness_t(this->C.data())};
   }
 }  // namespace muSpectre
 
 #endif  // SRC_MATERIALS_MATERIAL_LINEAR_ELASTIC_GENERIC1_HH_
diff --git a/src/materials/material_linear_elastic_generic2.hh b/src/materials/material_linear_elastic_generic2.hh
index 74efca4..6690d08 100644
--- a/src/materials/material_linear_elastic_generic2.hh
+++ b/src/materials/material_linear_elastic_generic2.hh
@@ -1,202 +1,202 @@
 /**
  * @file   material_linear_elastic_generic2.hh
  *
  * @author Till Junge <till.junge@epfl.ch>
  *
  * @date   20 Dec 2018
  *
  * @brief  implementation of a generic linear elastic law with eigenstrains
  *
  * Copyright © 2018 Till Junge
  *
  * µSpectre is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation, either version 3, or (at
  * your option) any later version.
  *
  * µSpectre is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with µSpectre; see the file COPYING. If not, write to the
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  *
  * Additional permission under GNU GPL version 3 section 7
  *
  * If you modify this Program, or any covered work, by linking or combining it
  * with proprietary FFT implementations or numerical libraries, containing parts
  * covered by the terms of those libraries' licenses, the licensors of this
  * Program grant you additional permission to convey the resulting work.
  */
 
 #ifndef SRC_MATERIALS_MATERIAL_LINEAR_ELASTIC_GENERIC2_HH_
 #define SRC_MATERIALS_MATERIAL_LINEAR_ELASTIC_GENERIC2_HH_
 
 #include "material_linear_elastic_generic1.hh"
 
 namespace muSpectre {
 
   /**
    * forward declaration
    */
   template <Dim_t DimS, Dim_t DimM>
   class MaterialLinearElasticGeneric2;
 
   /**
    * traits for use by MaterialMuSpectre for crtp
    */
 
   template <Dim_t DimS, Dim_t DimM>
   struct MaterialMuSpectre_traits<MaterialLinearElasticGeneric2<DimS, DimM>> {
     //! global field collection
     using GFieldCollection_t =
         typename MaterialBase<DimS, DimM>::GFieldCollection_t;
 
     //! expected map type for strain fields
     using StrainMap_t =
         MatrixFieldMap<GFieldCollection_t, Real, DimM, DimM, true>;
     //! expected map type for stress fields
     using StressMap_t = MatrixFieldMap<GFieldCollection_t, Real, DimM, DimM>;
     //! expected map type for tangent stiffness fields
     using TangentMap_t = T4MatrixFieldMap<GFieldCollection_t, Real, DimM>;
 
     //! declare what type of strain measure your law takes as input
     constexpr static auto strain_measure{StrainMeasure::GreenLagrange};
     //! declare what type of stress measure your law yields as output
     constexpr static auto stress_measure{StressMeasure::PK2};
 
     //! local field_collections used for internals
     using LFieldColl_t = LocalFieldCollection<DimS>;
     //! local strain type
     using LStrainMap_t = MatrixFieldMap<LFieldColl_t, Real, DimM, DimM, true>;
     //! elasticity with eigenstrain
     using InternalVariables = std::tuple<LStrainMap_t>;
   };
 
   /**
    * Implementation proper of the class
    */
   template <Dim_t DimS, Dim_t DimM>
   class MaterialLinearElasticGeneric2
       : public MaterialMuSpectre<MaterialLinearElasticGeneric2<DimS, DimM>,
                                  DimS, DimM> {
     //! parent type
     using Parent = MaterialMuSpectre<MaterialLinearElasticGeneric2<DimS, DimM>,
                                      DimS, DimM>;
     //! underlying worker class
     using Law_t = MaterialLinearElasticGeneric1<DimS, DimM>;
 
     //! generic input tolerant to python input
     using CInput_t = typename Law_t::CInput_t;
 
     //! reference to any type that casts to a matrix
     using StrainTensor = Eigen::Ref<Eigen::Matrix<Real, DimM, DimM>>;
 
     //! traits of this material
     using traits = MaterialMuSpectre_traits<MaterialLinearElasticGeneric2>;
 
     //! Type of container used for storing eigenstrain
     using InternalVariables_t = typename traits::InternalVariables;
 
    public:
     //! Default constructor
     MaterialLinearElasticGeneric2() = delete;
 
     //! Construct by name and elastic stiffness tensor
     MaterialLinearElasticGeneric2(const std::string & name,
                                   const CInput_t & C_voigt);
 
     //! Copy constructor
     MaterialLinearElasticGeneric2(const MaterialLinearElasticGeneric2 & other) =
         delete;
 
     //! Move constructor
     MaterialLinearElasticGeneric2(MaterialLinearElasticGeneric2 && other) =
         default;
 
     //! Destructor
     virtual ~MaterialLinearElasticGeneric2() = default;
 
     //! Copy assignment operator
     MaterialLinearElasticGeneric2 &
     operator=(const MaterialLinearElasticGeneric2 & other) = delete;
 
     //! Move assignment operator
     MaterialLinearElasticGeneric2 &
     operator=(MaterialLinearElasticGeneric2 && other) = default;
 
     //! see
     //! http://eigen.tuxfamily.org/dox/group__TopicStructHavingEigenMembers.html
     EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
 
     /**
      * evaluates second Piola-Kirchhoff stress given the Green-Lagrange
      * strain (or Cauchy stress if called with a small strain tensor)
      */
     template <class DerivedA, class DerivedB>
     inline decltype(auto)
     evaluate_stress(const Eigen::MatrixBase<DerivedA> & E,
                     const Eigen::MatrixBase<DerivedB> & E_eig);
     /**
      * evaluates both second Piola-Kirchhoff stress and stiffness given
      * the Green-Lagrange strain (or Cauchy stress and stiffness if
      * called with a small strain tensor)
      */
     template <class DerivedA, class DerivedB>
     inline decltype(auto)
     evaluate_stress_tangent(const Eigen::MatrixBase<DerivedA> & E,
                             const Eigen::MatrixBase<DerivedB> & E_eig);
 
     /**
      * returns tuple with only the eigenstrain field
      */
     InternalVariables_t & get_internals() { return this->internal_variables; }
 
     /**
      * return a reference to the stiffness tensor
      */
     const T4Mat<Real, DimM> & get_C() const { return this->worker.get_C(); }
 
     /**
      * overload add_pixel to write into eigenstrain
      */
     void add_pixel(const Ccoord_t<DimS> & pixel) final;
 
     /**
      * overload add_pixel to write into eigenstrain
      */
     void add_pixel(const Ccoord_t<DimS> & pixel, const StrainTensor & E_eig);
 
    protected:
     Law_t worker;  //! underlying law to be evaluated
     //! storage for eigenstrain
     using Field_t =
         TensorField<LocalFieldCollection<DimS>, Real, secondOrder, DimM>;
     Field_t & eigen_field;  //!< field holding the eigen strain per pixel
     InternalVariables_t internal_variables;
   };
 
   /* ---------------------------------------------------------------------- */
   template <Dim_t DimS, Dim_t DimM>
   template <class DerivedA, class DerivedB>
   auto MaterialLinearElasticGeneric2<DimS, DimM>::evaluate_stress(
       const Eigen::MatrixBase<DerivedA> & E,
       const Eigen::MatrixBase<DerivedB> & E_eig) -> decltype(auto) {
     return this->worker.evaluate_stress(E - E_eig);
   }
 
   /* ---------------------------------------------------------------------- */
   template <Dim_t DimS, Dim_t DimM>
   template <class DerivedA, class DerivedB>
   auto MaterialLinearElasticGeneric2<DimS, DimM>::evaluate_stress_tangent(
       const Eigen::MatrixBase<DerivedA> & E,
       const Eigen::MatrixBase<DerivedB> & E_eig) -> decltype(auto) {
     return this->worker.evaluate_stress_tangent(E - E_eig);
   }
 
 }  // namespace muSpectre
 
-#endif /* SRC_MATERIALS_MATERIAL_LINEAR_ELASTIC_GENERIC2_HH_ */
+#endif  // SRC_MATERIALS_MATERIAL_LINEAR_ELASTIC_GENERIC2_HH_