diff --git a/src/common/component_libmultiscale.hh b/src/common/component_libmultiscale.hh
index ed696cd..f0fe83f 100644
--- a/src/common/component_libmultiscale.hh
+++ b/src/common/component_libmultiscale.hh
@@ -1,469 +1,444 @@
 /**
  * @file   component_libmultiscale.hh
  *
  * @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
  *
  * @date   Mon Sep 08 23:40:22 2014
  *
  * @brief  This describe the root objects to be combined into valid LM
  * components
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * LibMultiScale 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.
  *
  * LibMultiScale 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 LibMultiScale. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef __LIBMULTISCALE_COMPONENT_LIBMULTISCALE_HH__
 #define __LIBMULTISCALE_COMPONENT_LIBMULTISCALE_HH__
 /* -------------------------------------------------------------------------- */
 #include "lm_common.hh"
 #include <map>
 #include <memory>
 #include <typeindex>
 #include <typeinfo>
 
 #undef LM_FATAL
 #define LM_FATAL(x)                                                            \
   {                                                                            \
     std::stringstream sstr;                                                    \
     sstr << x;                                                                 \
     throw std::runtime_error(sstr.str());                                      \
   }
 
 /* -------------------------------------------------------------------------- */
 __BEGIN_LIBMULTISCALE__
 /* -------------------------------------------------------------------------- */
 
-// enum ArgumentNature { _container_array, _vector, _scalar };
-
-// enum ArgumentType { _bool, _int, _uint, _real };
-
-// template <typename T> struct make_type {};
-// template <> struct make_type<int> {
-//   const ArgumentType value = _int;
-// };
-
-// template <template <typename> class _class> struct make_nature {};
-
-// template <> struct make_nature<ContainerArray> {
-//   const ArgumentNature value = _container_array;
-// };
-
-/* -------------------------------------------------------------------------- */
-
-// template <typename T> struct make_argument {
-// };
-
-// template <template <typename> class _class, typename T>
-// struct make_argument<_class<T>> {
-//   const ArgumentType type = make_type<T>::value;
-//   const ArgumentNature nature = make_nature<_class>::value;
-// };
-
-// template <typename T> struct Argument {
-
-//   const ArgumentNature nature = make_argument<T>::nature;
-//   const ArgumentType type = make_argument<T>::type;
-// };
-
-/* -------------------------------------------------------------------------- */
+template<typename T> struct PossibleTypes {
+  using types = std::tuple<Real, UInt, int, bool>;
+};
 
 struct ArgumentInterface {
 
   virtual ~ArgumentInterface(){};
 
   virtual std::type_index get_type_index() = 0;
   virtual std::string get_type_info() = 0;
 
   template <typename T> operator T();
+
 };
 
 template <typename T> struct Argument : public ArgumentInterface {
   const std::type_index type_index = typeid(T);
 
   std::type_index get_type_index() override { return type_index; };
 
   std::string get_type_info() override { return typeid(T).name(); };
 
   virtual T &get() = 0;
 };
 
 template <typename T> ArgumentInterface::operator T() {
   return dynamic_cast<Argument<T> &>(*this).get();
 }
 
 template <typename T> struct Output : public Argument<T> {
 
   T &get() { return value; }
 
   T value;
 };
 
 template <typename T> struct Input : public Argument<T> {
 
   Input(T &val) : value(val) {}
 
   T &get() { return value; }
 
   T &value;
 };
 
 class ComponentInterface {
 
 public:
   ComponentInterface(){};
 
   virtual ~ComponentInterface(){};
 
   template <typename T> void connect(const std::string &input, T &a) {
     auto search = inputs.find(input);
     if (search == inputs.end()) {
       LM_FATAL(input + ": input not existing");
     }
     inputs[input] = std::make_shared<Input<T>>(a);
   };
 
   virtual void compute() = 0;
 
 protected:
   std::map<std::string, std::shared_ptr<ArgumentInterface>> inputs;
   std::map<std::string, std::shared_ptr<ArgumentInterface>> outputs;
 };
 
 /* --------------------------------------------------------------------- */
 
 template <typename Functor, typename Tuple, size_t... Is>
 void unstack_tuple(Functor f, Tuple &tuple, std::index_sequence<Is...>) {
   f(std::get<Is>(tuple)...);
 };
 
 template <typename Obj, int n, typename tuple_type,
           typename tuple_type_formatted, typename Arg, typename _type,
           typename... possible_types>
 inline void cpp_dynamic_cast(Obj &obj, tuple_type args,
                              tuple_type_formatted args_formatted, Arg &arg);
 
 /* --------------------------------------------------------------------- */
 
 template <typename Obj, int n, typename tuple_type,
           typename tuple_type_formatted>
 struct CallCast {
   static void call_compute(Obj &obj, tuple_type args,
                            tuple_type_formatted args_formatted) {
+
     auto &&argn = std::get<n>(args);
-    // cpp_dynamic_cast<Obj, n, tuple_type, tuple_type_formatted, decltype(argn),
-    //                  int, Real, bool>(obj, args, args_formatted, argn);
+    auto possible_types = typename PossibleTypes<decltype(*argn.get())>::types{};
 
-    auto possible_types = std::tuple<int, Real, bool>{};
+    constexpr size_t N = std::tuple_size<decltype(possible_types)>::value;
     unstack_tuple(
         [&](auto... possible_types) {
           cpp_dynamic_cast<Obj, n, tuple_type, tuple_type_formatted,
-                           decltype(argn), decltype(possible_types)...>(obj, args, args_formatted, argn);
+                           decltype(argn), decltype(possible_types)...>(
+              obj, args, args_formatted, argn);
         },
-        possible_types, std::make_index_sequence<3>{});
+        possible_types, std::make_index_sequence<N>{});
   }
 };
 
 template <typename Obj, typename tuple_type, typename tuple_type_formatted>
 struct CallCast<Obj, -1, tuple_type, tuple_type_formatted> {
   static void call_compute(Obj &obj, tuple_type args,
                            tuple_type_formatted args_formatted) {
 
     constexpr size_t N = std::tuple_size<tuple_type_formatted>::value;
     unstack_tuple([&](auto... args) { obj.compute(args...); }, args_formatted,
                   std::make_index_sequence<N>{});
   }
 };
 
 /* --------------------------------------------------------------------- */
 
 template <typename Obj, int n, typename tuple_type,
           typename tuple_type_formatted, typename Arg>
 void cpp_dynamic_cast(Obj &obj, tuple_type args,
                       tuple_type_formatted args_formatted, Arg &arg) {
 
   LM_FATAL("type unknown : " << arg->get_type_info());
 }
 
 template <typename Obj, int n, typename tuple_type,
           typename tuple_type_formatted, typename Arg, typename _type,
           typename... possible_types>
 void cpp_dynamic_cast(Obj &obj, tuple_type args,
                       tuple_type_formatted args_formatted, Arg &arg) {
 
+  std::cout << "testing type " << typeid(_type).name() << " " << n << std::endl;
   if (auto *ref = dynamic_cast<Input<_type> *>(arg.get())) {
     auto new_args_formatted =
         std::tuple_cat(std::make_tuple(ref->get()), args_formatted);
     CallCast<Obj, n - 1, decltype(args),
              decltype(new_args_formatted)>::call_compute(obj, args,
                                                          new_args_formatted);
     return;
   }
   cpp_dynamic_cast<Obj, n, tuple_type, tuple_type_formatted, Arg,
                    possible_types...>(obj, args, args_formatted, arg);
 }
 
+/* --------------------------------------------------------------------- */
+
 template <typename Obj, typename... Args>
 void call_compute(Obj obj, Args... args) {
   auto tup = std::make_tuple(args...);
   CallCast<Obj, std::tuple_size<decltype(tup)>::value - 1, decltype(tup),
            std::tuple<>>::call_compute(obj, tup, std::make_tuple());
 }
 
 /* --------------------------------------------------------------------- */
 
 template <typename _Daughter> class Component : public ComponentInterface {
 
 public:
   using Daughter = _Daughter;
 
   Component(){};
 
   virtual ~Component(){};
 
   template <typename... Inputs> void compute(Inputs...);
 };
 
 // /*
 // --------------------------------------------------------------------------
 // */
 
 // struct ComponentNull {};
 
 // /*
 // --------------------------------------------------------------------------
 // */
 
 // class ComponentLMInterface {
 
 // public:
 //   ComponentLMInterface() : input(NULL){};
 
 //   ComponentLMInterface(ComponentLMInterface &input)
 //       : input(&input), dim(input.getDim()){};
 //   ComponentLMInterface(UInt dim) : input(NULL), dim(dim){};
 
 //   virtual ~ComponentLMInterface(){};
 
 //   UInt getDim() {
 //     LM_ASSERT(dim, "dimension was not set by the visitable object");
 //     return dim;
 //   };
 //   void setDim(UInt d) { dim = d; };
 
 //   virtual void accept(ComponentLMInterface &visitor) { LM_TOIMPLEMENT; };
 
 //   ComponentLMInterface *getInput() { return input; };
 
 // protected:
 //   ComponentLMInterface *input;
 
 //   UInt dim;
 // };
 
 // /*
 // --------------------------------------------------------------------------
 // */
 // template <typename _Output> class ComponentLMOut;
 
 // template <typename _Input>
 // class ComponentLMIn : public virtual ComponentLMInterface {
 
 // public:
 //   ComponentLMIn(UInt dim) { this->dim = dim; };
 //   ComponentLMIn(ComponentLMInterface &input) {
 //     this->input = &input;
 //     this->dim = input.getDim();
 //   };
 //   ComponentLMIn(ComponentLMInterface &input, UInt dim) {
 //     this->input = &input;
 //     this->dim = dim;
 //   };
 
 //   virtual void visit(ComponentLMOut<_Input> &obj) = 0;
 
 //   typedef _Input Input;
 // };
 
 // /*
 // --------------------------------------------------------------------------
 // */
 
 // template <typename _Output>
 // class ComponentLMOut : public virtual ComponentLMInterface {
 
 // public:
 //   ComponentLMOut(UInt dim) { this->dim = dim; };
 //   ComponentLMOut(ComponentLMInterface &input) { this->input = &input; };
 //   ComponentLMOut(ComponentLMInterface &input, UInt dim) {
 //     this->input = &input;
 //     this->dim = dim;
 //   };
 
 //   virtual void accept(ComponentLMInterface &visitor) {
 //     // test the input of the visitor
 //     if (ComponentLMIn<_Output> *ptr =
 //             dynamic_cast<ComponentLMIn<_Output> *>(&visitor)) {
 //       // if good, first build myself
 //       this->build();
 //       // then allow the visitor to visit me
 //       ptr->visit(*this);
 //     }
 //   };
 
 //   typedef _Output Output;
 
 //   virtual void build() = 0;
 
 //   virtual _Output &getOutput() { return *output; };
 
 //   operator _Output &() { return getOutput(); };
 
 //   void setOutput(_Output &_output) { output = &_output; };
 
 // private:
 //   _Output *output;
 // };
 
 // /*
 // --------------------------------------------------------------------------
 // */
 
 // template <typename _Output, COutputType _type>// class
 // ComponentLMOutTyped : public ComponentLMOut<_Output> {
 
 // public:
 //   ComponentLMOutTyped(UInt dim) : ComponentLMOut<_Output>(dim){};
 
 //   ComponentLMOutTyped(ComponentLMInterface &input)
 //       : ComponentLMOut<_Output>(input){};
 
 //   ComponentLMOutTyped(ComponentLMInterface &input, UInt dim)
 //       : ComponentLMOut<_Output>(input, dim){};
 
 //   static const COutputType output_type = _type;
 // };
 
 // /*
 // --------------------------------------------------------------------------
 // */
 
 // template <typename _Output, COutputType type>
 // class ComponentLMOutContainer : public ComponentLMOutTyped<_Output,
 // type>,
 //                                 public _Output {
 
 // public:
 //   ComponentLMOutContainer(UInt dim) : ComponentLMOutTyped<_Output,
 //   type>(dim){};
 
 //   ComponentLMOutContainer(ComponentLMInterface &input)
 //       : ComponentLMOutTyped<_Output, type>(input){};
 
 //   ComponentLMOutContainer(ComponentLMInterface &input, UInt dim)
 //       : ComponentLMOutTyped<_Output, type>(input, dim){};
 
 //   virtual _Output &getOutput() { return *this; };
 // };
 // /*
 // --------------------------------------------------------------------------
 // */
 
 // template <typename Comp_Input, typename Comp_Output>
 // class ComponentLMTemplate : public Comp_Input, public Comp_Output {
 
 // public:
 //   ComponentLMTemplate(UInt dim)
 //       : ComponentLMInterface(dim), Comp_Input(dim), Comp_Output(dim){};
 
 //   ComponentLMTemplate(ComponentLMInterface &input)
 //       : ComponentLMInterface(input), Comp_Input(input),
 //       Comp_Output(input){};
 
 //   ComponentLMTemplate(ComponentLMInterface &input, UInt dim)
 //       : ComponentLMInterface(input), Comp_Input(input, dim),
 //         Comp_Output(input, dim){};
 
 //   virtual ~ComponentLMTemplate(){};
 // };
 
 // /*
 // --------------------------------------------------------------------------
 // */
 
 // template <typename _Input, typename _Output, COutputType type>
 // class ComponentLM
 //     : public ComponentLMTemplate<ComponentLMIn<_Input>,
 //                                  ComponentLMOutTyped<_Output, type>> {
 
 // public:
 //   ComponentLM(ComponentLMInterface &input)
 //       : ComponentLMTemplate<ComponentLMIn<_Input>,
 //                             ComponentLMOutTyped<_Output, type>>(input){};
 
 //   ComponentLM(ComponentLMInterface &input, UInt dim)
 //       : ComponentLMTemplate<ComponentLMIn<_Input>,
 //                             ComponentLMOutTyped<_Output, type>>(input,
 //                             dim){};
 
 //   ComponentLM(UInt dim)
 //       : ComponentLMTemplate<ComponentLMIn<_Input>,
 //                             ComponentLMOutTyped<_Output, type>>(dim){};
 
 //   virtual ~ComponentLM(){};
 // };
 
 // /*
 // --------------------------------------------------------------------------
 // */
 
 // template <typename _Input, typename _Output, COutputType type>
 // class ComponentLMContainer
 //     : public ComponentLMTemplate<ComponentLMIn<_Input>,
 //                                  ComponentLMOutContainer<_Output, type>>
 //                                  {
 
 // public:
 //   ComponentLMContainer(ComponentLMInterface &input)
 //       : ComponentLMTemplate<ComponentLMIn<_Input>,
 //                             ComponentLMOutContainer<_Output,
 //                             type>>(input){};
 
 //   ComponentLMContainer(ComponentLMInterface &input, UInt dim)
 //       : ComponentLMTemplate<ComponentLMIn<_Input>,
 //                             ComponentLMOutContainer<_Output,
 //                             type>>(input,
 //                                                                     dim){};
 
 //   ComponentLMContainer(UInt dim)
 //       : ComponentLMTemplate<ComponentLMIn<_Input>,
 //                             ComponentLMOutContainer<_Output,
 //                             type>>(dim){};
 
 //   virtual ~ComponentLMContainer(){};
 // };
 
 // /*
 // --------------------------------------------------------------------------
 // */
 
 __END_LIBMULTISCALE__
 
 #endif /* __LIBMULTISCALE_COMPONENT_LIBMULTISCALE_HH__ */