diff --git a/src/common/aka_config.hh.in b/src/common/aka_config.hh.in
index 321a236e4..3d71748a6 100644
--- a/src/common/aka_config.hh.in
+++ b/src/common/aka_config.hh.in
@@ -1,94 +1,95 @@
 /**
  * @file   aka_config.hh.in
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Sun Sep 26 2010
  * @date last modification: Thu Jan 25 2018
  *
  * @brief  Compilation time configuration of Akantu
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu 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 of the License, or (at your option) any later version.
  *
  * Akantu 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  Lesser General  Public License  for more details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_AKA_CONFIG_HH__
 #define __AKANTU_AKA_CONFIG_HH__
 
 #define AKANTU_VERSION_MAJOR @AKANTU_MAJOR_VERSION@
 #define AKANTU_VERSION_MINOR @AKANTU_MINOR_VERSION@
 #define AKANTU_VERSION_PATCH @AKANTU_PATCH_VERSION@
 #define AKANTU_VERSION (AKANTU_VERSION_MAJOR * 10000 \
                         + AKANTU_VERSION_MINOR * 100 \
                         + AKANTU_VERSION_PATCH)
 
 @AKANTU_TYPES_EXTRA_INCLUDES@
 namespace akantu {
 using Real = @AKANTU_FLOAT_TYPE@;
 using Int = @AKANTU_SIGNED_INTEGER_TYPE@;
 using UInt = @AKANTU_UNSIGNED_INTEGER_TYPE@;
 } // akantu
 
 #define AKANTU_INTEGER_SIZE @AKANTU_INTEGER_SIZE@
 #define AKANTU_FLOAT_SIZE @AKANTU_FLOAT_SIZE@
 
 #cmakedefine AKANTU_HAS_STRDUP
 
 #cmakedefine AKANTU_USE_BLAS
 #cmakedefine AKANTU_USE_LAPACK
 
 #cmakedefine AKANTU_PARALLEL
 #cmakedefine AKANTU_USE_MPI
 
 #cmakedefine AKANTU_USE_SCOTCH
 #cmakedefine AKANTU_USE_PTSCOTCH
 #cmakedefine AKANTU_SCOTCH_NO_EXTERN
 
 #cmakedefine AKANTU_IMPLICIT
 #cmakedefine AKANTU_USE_MUMPS
 #cmakedefine AKANTU_USE_PETSC
 
 #cmakedefine AKANTU_USE_IOHELPER
 #cmakedefine AKANTU_USE_QVIEW
 #cmakedefine AKANTU_USE_BLACKDYNAMITE
 
 #cmakedefine AKANTU_USE_PYBIND11
 
 #cmakedefine AKANTU_USE_OBSOLETE_GETTIMEOFDAY
 
 #cmakedefine AKANTU_EXTRA_MATERIALS
 #cmakedefine AKANTU_STUDENTS_EXTRA_PACKAGE
 #cmakedefine AKANTU_DAMAGE_NON_LOCAL
 
 #cmakedefine AKANTU_SOLID_MECHANICS
 #cmakedefine AKANTU_STRUCTURAL_MECHANICS
 #cmakedefine AKANTU_HEAT_TRANSFER
+#cmakedefine AKANTU_PHASE_FIELD
 #cmakedefine AKANTU_PYTHON_INTERFACE
 
 #cmakedefine AKANTU_COHESIVE_ELEMENT
 #cmakedefine AKANTU_PARALLEL_COHESIVE_ELEMENT
 
 #cmakedefine AKANTU_IGFEM
 
 #cmakedefine AKANTU_USE_CGAL
 #cmakedefine AKANTU_EMBEDDED
 
 // Debug tools
 //#cmakedefine AKANTU_NDEBUG
 #cmakedefine AKANTU_DEBUG_TOOLS
 #cmakedefine READLINK_COMMAND @READLINK_COMMAND@
 #cmakedefine ADDR2LINE_COMMAND @ADDR2LINE_COMMAND@
 
 #define __aka_inline__ inline
 
 #endif /* __AKANTU_AKA_CONFIG_HH__ */
diff --git a/src/io/parser/parser.hh b/src/io/parser/parser.hh
index ea07a640b..daa9ab208 100644
--- a/src/io/parser/parser.hh
+++ b/src/io/parser/parser.hh
@@ -1,509 +1,510 @@
 /**
  * @file   parser.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Wed Nov 13 2013
  * @date last modification: Fri Dec 08 2017
  *
  * @brief  File parser interface
  *
  * @section LICENSE
  *
  * Copyright (©) 2014-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu 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 of the License, or (at your option) any
  * later version.
  *
  * Akantu 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  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_random_generator.hh"
 /* -------------------------------------------------------------------------- */
 #include <map>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PARSER_HH__
 #define __AKANTU_PARSER_HH__
 
 namespace akantu {
 
 #ifndef SWIG
 // clang-format off
 #define AKANTU_SECTION_TYPES                                            \
   (cohesive_inserter)                                                   \
   (contact)                                                             \
   (embedded_interface)                                                  \
   (friction)                                                            \
   (global)                                                              \
   (heat)                                                                \
+  (phase)								\
   (integration_scheme)                                                  \
   (material)                                                            \
   (mesh)                                                                \
   (model)                                                               \
   (model_solver)                                                        \
   (neighborhood)                                                        \
   (neighborhoods)                                                       \
   (non_linear_solver)                                                   \
   (non_local)                                                           \
   (rules)                                                               \
   (solver)                                                              \
   (time_step_solver)                                                    \
   (user)                                                                \
   (weight_function)                                                     \
   (not_defined)
 // clang-format on
 
 /// Defines the possible section types
 AKANTU_ENUM_DECLARE(ParserType, AKANTU_SECTION_TYPES)
 AKANTU_ENUM_OUTPUT_STREAM(ParserType, AKANTU_SECTION_TYPES)
 AKANTU_ENUM_INPUT_STREAM(ParserType, AKANTU_SECTION_TYPES)
 
 /// Defines the possible search contexts/scopes (for parameter search)
 enum ParserParameterSearchCxt {
   _ppsc_current_scope = 0x1,
   _ppsc_parent_scope = 0x2,
   _ppsc_current_and_parent_scope = 0x3
 };
 #endif
 /* ------------------------------------------------------------------------ */
 /* Parameters Class                                                         */
 /* ------------------------------------------------------------------------ */
 class ParserSection;
 
 /// @brief The ParserParameter objects represent the end of tree branches as
 /// they
 /// are the different informations contained in the input file.
 class ParserParameter {
 public:
   ParserParameter()
       : name(std::string()), value(std::string()), dbg_filename(std::string()) {
   }
 
   ParserParameter(const std::string & name, const std::string & value,
                   const ParserSection & parent_section)
       : parent_section(&parent_section), name(name), value(value),
         dbg_filename(std::string()) {}
 
   ParserParameter(const ParserParameter & param) = default;
 
   virtual ~ParserParameter() = default;
 
   /// Get parameter name
   const std::string & getName() const { return name; }
   /// Get parameter value
   const std::string & getValue() const { return value; }
 
   /// Set info for debug output
   void setDebugInfo(const std::string & filename, UInt line, UInt column) {
     dbg_filename = filename;
     dbg_line = line;
     dbg_column = column;
   }
 
   template <typename T> inline operator T() const;
 
   // template <typename T> inline operator Vector<T>() const;
   // template <typename T> inline operator Matrix<T>() const;
 
   /// Print parameter info in stream
   void printself(std::ostream & stream,
                  __attribute__((unused)) unsigned int indent = 0) const {
     stream << name << ": " << value << " (" << dbg_filename << ":" << dbg_line
            << ":" << dbg_column << ")";
   }
 
 private:
   void setParent(const ParserSection & sect) { parent_section = &sect; }
 
   friend class ParserSection;
 
 private:
   /// Pointer to the parent section
   const ParserSection * parent_section{nullptr};
   /// Name of the parameter
   std::string name;
   /// Value of the parameter
   std::string value;
   /// File for debug output
   std::string dbg_filename;
   /// Position of parameter in parsed file
   UInt dbg_line, dbg_column;
 };
 
 /* ------------------------------------------------------------------------ */
 /* Sections Class                                                           */
 /* ------------------------------------------------------------------------ */
 /// ParserSection represents a branch of the parsing tree.
 class ParserSection {
 public:
   using SubSections = std::multimap<ParserType, ParserSection>;
   using Parameters = std::map<std::string, ParserParameter>;
 
 private:
   using const_section_iterator_ = SubSections::const_iterator;
 
 public:
   /* ------------------------------------------------------------------------ */
   /* SubSection iterator                                                      */
   /* ------------------------------------------------------------------------ */
   /// Iterator on sections
   class const_section_iterator {
   public:
     using iterator_category = std::forward_iterator_tag;
     using value_type = ParserSection;
     using pointer = ParserSection *;
     using reference = ParserSection &;
 
     const_section_iterator() = default;
     const_section_iterator(const const_section_iterator_ & it) : it(it) {}
     const_section_iterator(const const_section_iterator & other) = default;
     const_section_iterator &
     operator=(const const_section_iterator & other) = default;
 
     const ParserSection & operator*() const { return it->second; }
     const ParserSection * operator->() const { return &(it->second); }
 
     bool operator==(const const_section_iterator & other) const {
       return it == other.it;
     }
 
     bool operator!=(const const_section_iterator & other) const {
       return it != other.it;
     }
 
     const_section_iterator & operator++() {
       ++it;
       return *this;
     }
 
     const_section_iterator operator++(int) {
       const_section_iterator tmp = *this;
       operator++();
       return tmp;
     }
 
   private:
     const_section_iterator_ it;
   };
 
   /* ------------------------------------------------------------------------ */
   /* Parameters iterator                                                      */
   /* ------------------------------------------------------------------------ */
   /// Iterator on parameters
   class const_parameter_iterator {
   public:
     const_parameter_iterator(const const_parameter_iterator & other) = default;
     const_parameter_iterator(const Parameters::const_iterator & it) : it(it) {}
 
     const_parameter_iterator &
     operator=(const const_parameter_iterator & other) {
       if (this != &other) {
         it = other.it;
       }
       return *this;
     }
     const ParserParameter & operator*() const { return it->second; }
     const ParserParameter * operator->() { return &(it->second); };
     bool operator==(const const_parameter_iterator & other) const {
       return it == other.it;
     }
     bool operator!=(const const_parameter_iterator & other) const {
       return it != other.it;
     }
     const_parameter_iterator & operator++() {
       ++it;
       return *this;
     }
     const_parameter_iterator operator++(int) {
       const_parameter_iterator tmp = *this;
       operator++();
       return tmp;
     }
 
   private:
     Parameters::const_iterator it;
   };
 
   /* ---------------------------------------------------------------------- */
   ParserSection() : name(std::string()) {}
 
   ParserSection(const std::string & name, ParserType type)
       : parent_section(nullptr), name(name), type(type) {}
 
   ParserSection(const std::string & name, ParserType type,
                 const std::string & option,
                 const ParserSection & parent_section)
       : parent_section(&parent_section), name(name), type(type),
         option(option) {}
 
   ParserSection(const ParserSection & section)
       : parent_section(section.parent_section), name(section.name),
         type(section.type), option(section.option),
         parameters(section.parameters),
         sub_sections_by_type(section.sub_sections_by_type) {
     setChldrenPointers();
   }
 
   ParserSection & operator=(const ParserSection & other) {
     if (&other != this) {
       parent_section = other.parent_section;
       name = other.name;
       type = other.type;
       option = other.option;
       parameters = other.parameters;
       sub_sections_by_type = other.sub_sections_by_type;
       setChldrenPointers();
     }
     return *this;
   }
 
   virtual ~ParserSection();
 
   virtual void printself(std::ostream & stream, unsigned int indent = 0) const;
 
   /* ---------------------------------------------------------------------- */
   /* Creation functions                                                     */
   /* ---------------------------------------------------------------------- */
 public:
   ParserParameter & addParameter(const ParserParameter & param);
   ParserSection & addSubSection(const ParserSection & section);
 
 protected:
   /// Clean ParserSection content
   void clean() {
     parameters.clear();
     sub_sections_by_type.clear();
   }
 
 private:
   void setChldrenPointers() {
     for (auto && param_pair : this->parameters)
       param_pair.second.setParent(*this);
 
     for (auto && sub_sect_pair : this->sub_sections_by_type)
       sub_sect_pair.second.setParent(*this);
   }
 
   /* ---------------------------------------------------------------------- */
   /* Accessors                                                              */
   /* ---------------------------------------------------------------------- */
 public:
 #ifndef SWIG
   class SubSectionsRange
       : public std::pair<const_section_iterator, const_section_iterator> {
   public:
     SubSectionsRange(const const_section_iterator & first,
                      const const_section_iterator & second)
         : std::pair<const_section_iterator, const_section_iterator>(first,
                                                                     second) {}
     auto begin() { return this->first; }
     auto end() { return this->second; }
   };
 
   /// Get begin and end iterators on subsections of certain type
   auto getSubSections(ParserType type = ParserType::_not_defined) const {
     if (type != ParserType::_not_defined) {
       auto range = sub_sections_by_type.equal_range(type);
       return SubSectionsRange(range.first, range.second);
     } else {
       return SubSectionsRange(sub_sections_by_type.begin(),
                               sub_sections_by_type.end());
     }
   }
 
   /// Get number of subsections of certain type
   UInt getNbSubSections(ParserType type = ParserType::_not_defined) const {
     if (type != ParserType::_not_defined) {
       return this->sub_sections_by_type.count(type);
     } else {
       return this->sub_sections_by_type.size();
     }
   }
 
   /// Get begin and end iterators on parameters
   auto getParameters() const {
     return std::pair<const_parameter_iterator, const_parameter_iterator>(
         parameters.begin(), parameters.end());
   }
 #endif
   /* ---------------------------------------------------------------------- */
   /// Get parameter within specified context
   const ParserParameter & getParameter(
       const std::string & name,
       ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const {
     Parameters::const_iterator it;
     if (search_ctx & _ppsc_current_scope)
       it = parameters.find(name);
 
     if (it == parameters.end()) {
       if ((search_ctx & _ppsc_parent_scope) && parent_section)
         return parent_section->getParameter(name, search_ctx);
       else {
         AKANTU_SILENT_EXCEPTION(
             "The parameter " << name
                              << " has not been found in the specified context");
       }
     }
     return it->second;
   }
 
   /* ------------------------------------------------------------------------ */
   /// Get parameter within specified context, with a default value in case the
   /// parameter does not exists
   template <class T>
   const T getParameter(
       const std::string & name, const T & default_value,
       ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const {
     try {
       T tmp = this->getParameter(name, search_ctx);
       return tmp;
     } catch (debug::Exception &) {
       return default_value;
     }
   }
 
   /* ------------------------------------------------------------------------ */
   /// Check if parameter exists within specified context
   bool hasParameter(
       const std::string & name,
       ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const {
 
     Parameters::const_iterator it;
     if (search_ctx & _ppsc_current_scope)
       it = parameters.find(name);
 
     if (it == parameters.end()) {
       if ((search_ctx & _ppsc_parent_scope) && parent_section)
         return parent_section->hasParameter(name, search_ctx);
       else {
         return false;
       }
     }
     return true;
   }
 
   /* --------------------------------------------------------------------------
    */
   /// Get value of given parameter in context
   template <class T>
   T getParameterValue(
       const std::string & name,
       ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const {
     const ParserParameter & tmp_param = getParameter(name, search_ctx);
     T t = tmp_param;
     return t;
   }
 
   /* --------------------------------------------------------------------------
    */
   /// Get section name
   const std::string getName() const { return name; }
   /// Get section type
   ParserType getType() const { return type; }
   /// Get section option
   const std::string getOption(const std::string & def = "") const {
     return option != "" ? option : def;
   }
 
 protected:
   void setParent(const ParserSection & sect) { parent_section = &sect; }
 
   /* ---------------------------------------------------------------------- */
   /* Members                                                                */
   /* ---------------------------------------------------------------------- */
 private:
   /// Pointer to the parent section
   const ParserSection * parent_section{nullptr};
   /// Name of section
   std::string name;
   /// Type of section, see AKANTU_SECTION_TYPES
   ParserType type{ParserType::_not_defined};
   /// Section option
   std::string option;
   /// Map of parameters in section
   Parameters parameters;
   /// Multi-map of subsections
   SubSections sub_sections_by_type;
 };
 
 /* ------------------------------------------------------------------------ */
 /* Parser Class                                                             */
 /* ------------------------------------------------------------------------ */
 /// Root of parsing tree, represents the global ParserSection
 class Parser : public ParserSection {
 public:
   Parser() : ParserSection("global", ParserType::_global) {}
 
   void parse(const std::string & filename);
 
   std::string getLastParsedFile() const;
 
   static bool isPermissive() { return permissive_parser; }
 
 public:
   /// Parse real scalar
   static Real parseReal(const std::string & value,
                         const ParserSection & section);
   /// Parse real vector
   static Vector<Real> parseVector(const std::string & value,
                                   const ParserSection & section);
   /// Parse real matrix
   static Matrix<Real> parseMatrix(const std::string & value,
                                   const ParserSection & section);
 #ifndef SWIG
   /// Parse real random parameter
   static RandomParameter<Real>
   parseRandomParameter(const std::string & value,
                        const ParserSection & section);
 #endif
 protected:
   /// General parse function
   template <class T, class Grammar>
   static T parseType(const std::string & value, Grammar & grammar);
 
 protected:
   //  friend class Parsable;
   static bool permissive_parser;
   std::string last_parsed_file;
 };
 
 inline std::ostream & operator<<(std::ostream & stream,
                                  const ParserParameter & _this) {
   _this.printself(stream);
   return stream;
 }
 
 inline std::ostream & operator<<(std::ostream & stream,
                                  const ParserSection & section) {
   section.printself(stream);
   return stream;
 }
 
 } // akantu
 
 namespace std {
 template <> struct iterator_traits<::akantu::Parser::const_section_iterator> {
   using iterator_category = input_iterator_tag;
   using value_type = ::akantu::ParserParameter;
   using difference_type = ptrdiff_t;
   using pointer = const ::akantu::ParserParameter *;
   using reference = const ::akantu::ParserParameter &;
 };
 }
 
 #include "parser_tmpl.hh"
 
 #endif /* __AKANTU_PARSER_HH__ */
diff --git a/src/model/model_options.hh b/src/model/model_options.hh
index a027c281a..24dc278fb 100644
--- a/src/model/model_options.hh
+++ b/src/model/model_options.hh
@@ -1,139 +1,154 @@
 /**
  * @file   model_options.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Mon Dec 04 2017
  * @date last modification: Wed Jan 31 2018
  *
  * @brief  A Documented file.
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu 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 of the License, or (at your option) any
  * later version.
  *
  * Akantu 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  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_common.hh"
 #include "aka_named_argument.hh"
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_MODEL_OPTIONS_HH__
 #define __AKANTU_MODEL_OPTIONS_HH__
 
 namespace akantu {
 
 namespace {
   DECLARE_NAMED_ARGUMENT(analysis_method);
 }
 
 struct ModelOptions {
   explicit ModelOptions(AnalysisMethod analysis_method = _static)
       : analysis_method(analysis_method) {}
 
   template <typename... pack>
   ModelOptions(use_named_args_t, pack &&... _pack)
       : ModelOptions(OPTIONAL_NAMED_ARG(analysis_method, _static)) {}
 
   virtual ~ModelOptions() = default;
 
   AnalysisMethod analysis_method;
 };
 
 #ifdef AKANTU_SOLID_MECHANICS
 /* -------------------------------------------------------------------------- */
 struct SolidMechanicsModelOptions : public ModelOptions {
   explicit SolidMechanicsModelOptions(
       AnalysisMethod analysis_method = _explicit_lumped_mass)
       : ModelOptions(analysis_method) {}
 
   template <typename... pack>
   SolidMechanicsModelOptions(use_named_args_t, pack &&... _pack)
       : SolidMechanicsModelOptions(
             OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass)) {}
 };
 #endif
 
 /* -------------------------------------------------------------------------- */
 #ifdef AKANTU_COHESIVE_ELEMENT
 namespace {
   DECLARE_NAMED_ARGUMENT(is_extrinsic);
 }
 /* -------------------------------------------------------------------------- */
 struct SolidMechanicsModelCohesiveOptions : public SolidMechanicsModelOptions {
   SolidMechanicsModelCohesiveOptions(
       AnalysisMethod analysis_method = _explicit_lumped_mass,
       bool extrinsic = false)
       : SolidMechanicsModelOptions(analysis_method), is_extrinsic(extrinsic) {}
 
   template <typename... pack>
   SolidMechanicsModelCohesiveOptions(use_named_args_t, pack &&... _pack)
       : SolidMechanicsModelCohesiveOptions(
             OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass),
             OPTIONAL_NAMED_ARG(is_extrinsic, false)) {}
 
   bool is_extrinsic{false};
 };
 #endif
 
 #ifdef AKANTU_HEAT_TRANSFER
 /* -------------------------------------------------------------------------- */
 struct HeatTransferModelOptions : public ModelOptions {
   explicit HeatTransferModelOptions(
       AnalysisMethod analysis_method = _explicit_lumped_mass)
       : ModelOptions(analysis_method) {}
 
   template <typename... pack>
   HeatTransferModelOptions(use_named_args_t, pack &&... _pack)
       : HeatTransferModelOptions(
             OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass)) {}
 };
 #endif
 
+#ifdef AKANTU_PHASE_FIELD
+/* -------------------------------------------------------------------------- */
+struct PhaseFieldModelOptions : public ModelOptions {
+  explicit PhaseFieldModelOptions(
+      AnalysisMethod analysis_method = _explicit_lumped_mass)
+      : ModelOptions(analysis_method) {}
+
+  template <typename... pack>
+  PhaseFieldModelOptions(use_named_args_t, pack &&... _pack)
+      : PhaseFieldModelOptions(
+            OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass)) {}
+};
+#endif
+
+/* -------------------------------------------------------------------------- */
 #ifdef AKANTU_EMBEDDED
 
 namespace {
   DECLARE_NAMED_ARGUMENT(init_intersections);
 }
 /* -------------------------------------------------------------------------- */
 struct EmbeddedInterfaceModelOptions : SolidMechanicsModelOptions {
   /**
    * @brief Constructor for EmbeddedInterfaceModelOptions
    * @param analysis_method see SolidMechanicsModelOptions
    * @param init_intersections compute intersections
    */
   EmbeddedInterfaceModelOptions(
       AnalysisMethod analysis_method = _explicit_lumped_mass,
       bool init_intersections = true)
       : SolidMechanicsModelOptions(analysis_method),
         has_intersections(init_intersections) {}
 
   template <typename... pack>
   EmbeddedInterfaceModelOptions(use_named_args_t, pack &&... _pack)
       : EmbeddedInterfaceModelOptions(
             OPTIONAL_NAMED_ARG(analysis_method, _explicit_lumped_mass),
             OPTIONAL_NAMED_ARG(init_intersections, true)) {}
 
   /// Should consider reinforcements
   bool has_intersections;
 };
 #endif
 
 } // akantu
 
 #endif /* __AKANTU_MODEL_OPTIONS_HH__ */
diff --git a/src/model/phase_field/phase_field_model.hh b/src/model/phase_field/phase_field_model.hh
index e67b8e996..890ecf3c5 100644
--- a/src/model/phase_field/phase_field_model.hh
+++ b/src/model/phase_field/phase_field_model.hh
@@ -1,228 +1,233 @@
 /**
  * @file   phase_field_model.hh
  *
  * @author Mohit Pundir <mohit.pundir@epfl.ch>
  * 
  * @date creation: Sun Jul 30 2018
  * @date last modification: Mon Feb 05 2018
  *
  * @brief  Model of Phase Field
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu 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 of the License, or (at your option) any
  * later version.
  *
  * Akantu 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  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "data_accessor.hh"
 #include "fe_engine.hh"
 #include "model.hh"
 /* -------------------------------------------------------------------------- */
 #include <array>
 /* -------------------------------------------------------------------------- */
 
 #ifndef __AKANTU_PHASE_FIELD_MODEL_HH__
 #define __AKANTU_PHASE_FIELD_MODEL_HH__
 
 namespace akantu {
 template <ElementKind kind, class IntegrationOrderFuntor>
 class IntegratorGauss;
 template <ElementKind kind> class Shapelagrange;  
 } // namespace akantu
 
 namespace akantu {
 
 class PhaseFieldModel : public Model,
 			public DataAccessor<Element>,
 			public DataAccessor<UInt> {
 
   /* ------------------------------------------------------------------------ */
   /* Constructors/Destructors                                                 */
   /* ------------------------------------------------------------------------ */
 public:
   using FEEngineType = FEEngineTemplate<IntegratorGauss, Shapelagrange>;
 
   PhaseFieldModel(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
 		  const ID & id = "phase_field_model",
 		  const MemoryID & memory_id = 0);
 
   virtual ~PhaseFieldModel();
 
   /* ------------------------------------------------------------------------ */
   /* Methods                                                                  */
   /* ------------------------------------------------------------------------ */
 protected:
   /// generic function to initialize everything ready for explicit dynamics
   void initFullImpl(const ModelOptions & options) override;
 
   /// read one material file to instantiate all the materials
   void readMaterials();
 
   /// allocate all vectors
   void initSolver(TimeStepSolverType, NonLinearSolverType) override;
 
   /// initialize the model
   void initModel() override;
 
   void predictor() override;
 
   /// compute the heat flux
   void assembleResidual() override;
 
   /// get the type of matrix needed
   MatrixType getMatrixType(const ID &) override;
 
   /// callback to assemble a Matrix
   void assembleMatrix(const ID &) override;
 
   std::tuple<ID, TimeStepSolverType>
   getDefaultSolverID(const AnalysisMethod & method) override;
 
   ModelSolverOptions
   getDefaultSolverOptions(const TimeStepSolverType & type) const;
   
   /// compute the internal forces 
   void assembleInternalForces();
 
   
   /* ------------------------------------------------------------------------ */
   /* Methods for static                                                       */
   /* ------------------------------------------------------------------------ */
 public:
   /// assemble damage matrix
   void assembleDamageMatrix();
 
   /// assemble damage gradient matrix
   void assembleDamageGradMatrix();
   
   /// compute the damage on quadrature points
   void computeDamage(Array<Real> & damage, ElementType type, GhostType ghost_type);
 
 private:
   /// assemble the damage matrix (w/ ghost type)
   template<UInt dim>
   void assembleDamageMatrix(const GhostType & ghost_type);
 
    /// assemble the damage grad matrix (w/ ghost type)
   template<UInt dim>
   void assembleDamageGradMatrix(const GhostType & ghost_type);
 
   /// compute vector strain history field for each quadrature point
   void computeStrainHistoryOnQuadPoints(const GhostType & ghost_type);
 
   /// compute the fracture energy
   Real computeFractureEnergyByNode();
 
   /* ------------------------------------------------------------------------ */
   /* Data Accessor inherited members                                          */
   /* ------------------------------------------------------------------------ */
 public:
   UInt getNbData(const Array<Element> & elements,
 		 const SynchronizationTag & tag) const override;
 
   void packData(CommunicationBuffer & buffer, const Array<Element> & elements,
 		const SynchronizationTag & tag) const override;
 
   void unpackData(CommunicationBuffer & buffer, const Array<Element> & elements,
 		  const SynchronizationTag & tag) override;
 
   UInt getNbData(const Array<UInt> & dofs,
 		 const SynchronizationTag & tag) const override;
 
   void packData(CommunicationBuffer & buffer, const Array<UInt> & dofs,
 		const SynchronizationTag & tag) const override;
 
   void unpackData(CommunicationBuffer & buffer, const Array<UInt> & dofs,
 		  const SynchronizationTag & tag) override;
 
   /* ------------------------------------------------------------------------ */
   /* Dumpable Interface                                                       */
   /* ------------------------------------------------------------------------ */
 public:
   dumper::Field * createNodalFieldReal(const std::string & field_name,
 				       const std::string & group_name,
 				       bool padding_flag) override;
 
   dumper::Field * createNodalFieldBool(const std::string & field_name,
 				       const std::string & group_name,
 				       bool padding_flag) override;
   
   dumper::Field * createElementalField(const std::string & field_name,
 				       const std::string & group_name,
 				       bool padding_flag) override;
 
   virtual void dump(const std::string & dumper_name);
 
   virtual void dump(const std::string & dumper_name, UInt step);
 
   virtual void dump(const std::string & dumper_name, Real time, UInt step);
 
   void dump() override;
 
   virtual void dump(UInt step);
 
   virtual void dump(Real time, UInt step);
   
   /* ------------------------------------------------------------------------ */
   /* Class Members                                                            */
   /* ------------------------------------------------------------------------ */
 private:
   ///number of iterations
   UInt n_iter;
 
   /// damage array
   Array<Real> * damage{nullptr};
 
   /// damage field on quadrature points
   ElementTypeMapArray<Real> damage_on_qpoints;
 
   /// critical local fracture energy density on quadrature points
   ElementTypeMapArray<Real> gc_on_qpoints;
 
   /// vector \phi plus on quadrature points
   ElementTypeMapArray<Real> strain_history_on_qpoints;
 
   /// displacement on quadrature points
   ElementTypeMapArray<Real> displacement_on_qpoints;
 
   /// boundary vector
   Array<bool> * blocked_dofs{nullptr};
 
   /// external force vector
   Array<Real> * external_force{nullptr};
 
   /// residuals array
   Array<Real> * internal_force{nullptr};
 
   /// lengthscale parameter
   Real l_0;
 
   /// critical energy release rate
   Real g_c;
 
   /// Lame's parameter
   Real lame_lambda;
 
   /// Lame's paramter
   Real lame_mu;
 
 };
 
-}
+} // akantu
+
+/* ------------------------------------------------------------------------ */
+/* inline functions                                                         */
+/* ------------------------------------------------------------------------ */
+#include "phase_field_model_inline_impl.cc"
 
 #endif