[PL] Tabs to whitespaces.

ProcessLib/CMakeLists.txt

@@ -18,8 +18,8 @@ target_link_libraries(ProcessLib
 ADD_VTK_DEPENDENCY(ProcessLib)
 
 if(TARGET Eigen)
-	add_dependencies(ProcessLib Eigen)
+    add_dependencies(ProcessLib Eigen)
 endif()
 if(TARGET Boost)
-	add_dependencies(ProcessLib Boost)
+    add_dependencies(ProcessLib Boost)
 endif()

ProcessLib/DirichletBc.h

@@ -22,8 +22,8 @@ namespace ProcessLib
 template <typename IndexType>
 struct DirichletBc final
 {
-	std::vector<IndexType> global_ids;
-	std::vector<double> values;
+    std::vector<IndexType> global_ids;
+    std::vector<double> values;
 };
 
 }  // namespace ProcessLib

ProcessLib/InitialCondition.cpp

@@ -23,13 +23,13 @@ namespace ProcessLib
 std::unique_ptr<InitialCondition> createUniformInitialCondition(
     BaseLib::ConfigTree const& config, int const /*n_components*/)
 {
-	config.checkConfParam("type", "Uniform");
+    config.checkConfParam("type", "Uniform");
 
-	auto value = config.getConfParam<double>("value");
-	DBUG("Using value %g", value);
+    auto value = config.getConfParam<double>("value");
+    DBUG("Using value %g", value);
 
-	return std::unique_ptr<InitialCondition>(
-	    new UniformInitialCondition(value));
+    return std::unique_ptr<InitialCondition>(
+        new UniformInitialCondition(value));
 }
 
 std::unique_ptr<InitialCondition> createMeshPropertyInitialCondition(
@@ -37,34 +37,34 @@ std::unique_ptr<InitialCondition> createMeshPropertyInitialCondition(
     MeshLib::Mesh const& mesh,
     int const n_components)
 {
-	auto field_name = config.getConfParam<std::string>("field_name");
-	DBUG("Using field_name %s", field_name.c_str());
+    auto field_name = config.getConfParam<std::string>("field_name");
+    DBUG("Using field_name %s", field_name.c_str());
 
-	if (!mesh.getProperties().hasPropertyVector(field_name))
-	{
-		ERR("The required property %s does not exists in the mesh.",
-		    field_name.c_str());
-		std::abort();
-	}
-	auto const& property =
-	    mesh.getProperties().template getPropertyVector<double>(field_name);
-	if (!property)
-	{
-		ERR("The required property %s is not of the requested type.",
-		    field_name.c_str());
-		std::abort();
-	}
+    if (!mesh.getProperties().hasPropertyVector(field_name))
+    {
+        ERR("The required property %s does not exists in the mesh.",
+            field_name.c_str());
+        std::abort();
+    }
+    auto const& property =
+        mesh.getProperties().template getPropertyVector<double>(field_name);
+    if (!property)
+    {
+        ERR("The required property %s is not of the requested type.",
+            field_name.c_str());
+        std::abort();
+    }
 
-	if (property->getNumberOfComponents() !=
-	    static_cast<std::size_t>(n_components))
-	{
-		ERR("The required property %s has different number of components %d, "
-		    "expected %d.",
-		    field_name.c_str(), property->getNumberOfComponents(), n_components);
-		std::abort();
-	}
-	return std::unique_ptr<InitialCondition>(
-	    new MeshPropertyInitialCondition(*property));
+    if (property->getNumberOfComponents() !=
+        static_cast<std::size_t>(n_components))
+    {
+        ERR("The required property %s has different number of components %d, "
+            "expected %d.",
+            field_name.c_str(), property->getNumberOfComponents(), n_components);
+        std::abort();
+    }
+    return std::unique_ptr<InitialCondition>(
+        new MeshPropertyInitialCondition(*property));
 }
 
 }  // namespace ProcessLib

ProcessLib/InitialCondition.h

@@ -34,27 +34,27 @@ namespace ProcessLib
 class InitialCondition
 {
 public:
-	virtual ~InitialCondition() = default;
-	virtual double getValue(MeshLib::Node const&, int const component_id) const = 0;
+    virtual ~InitialCondition() = default;
+    virtual double getValue(MeshLib::Node const&, int const component_id) const = 0;
 };
 
 /// Uniform value initial condition
 class UniformInitialCondition : public InitialCondition
 {
 public:
-	UniformInitialCondition(double const value) : _value(value)
-	{
-	}
-	/// Returns a value for given node and component.
-	/// \todo The component_id is to be implemented.
-	virtual double getValue(MeshLib::Node const&,
-	                        int const /* component_id */) const override
-	{
-		return _value;
-	}
+    UniformInitialCondition(double const value) : _value(value)
+    {
+    }
+    /// Returns a value for given node and component.
+    /// \todo The component_id is to be implemented.
+    virtual double getValue(MeshLib::Node const&,
+                            int const /* component_id */) const override
+    {
+        return _value;
+    }
 
 private:
-	double _value;
+    double _value;
 };
 
 /// Construct a UniformInitialCondition from configuration.
@@ -68,22 +68,22 @@ std::unique_ptr<InitialCondition> createUniformInitialCondition(
 class MeshPropertyInitialCondition : public InitialCondition
 {
 public:
-	MeshPropertyInitialCondition(
-	    MeshLib::PropertyVector<double> const& property)
-	    : _property(property)
-	{
-		assert(_property.getMeshItemType() == MeshLib::MeshItemType::Node);
-	}
+    MeshPropertyInitialCondition(
+        MeshLib::PropertyVector<double> const& property)
+        : _property(property)
+    {
+        assert(_property.getMeshItemType() == MeshLib::MeshItemType::Node);
+    }
 
-	virtual double getValue(MeshLib::Node const& n,
-	                        int const component_id) const override
-	{
-		return _property[n.getID() * _property.getNumberOfComponents() +
-		                 component_id];
-	}
+    virtual double getValue(MeshLib::Node const& n,
+                            int const component_id) const override
+    {
+        return _property[n.getID() * _property.getNumberOfComponents() +
+                         component_id];
+    }
 
 private:
-	MeshLib::PropertyVector<double> const& _property;
+    MeshLib::PropertyVector<double> const& _property;
 };
 
 /// Construct a MeshPropertyInitialCondition from configuration.

ProcessLib/Parameter.cpp

@@ -19,36 +19,36 @@ namespace ProcessLib
 std::unique_ptr<ParameterBase> createConstParameter(
     BaseLib::ConfigTree const& config)
 {
-	config.checkConfParam("type", "Constant");
-	auto value = config.getConfParam<double>("value");
-	DBUG("Using value %g", value);
+    config.checkConfParam("type", "Constant");
+    auto value = config.getConfParam<double>("value");
+    DBUG("Using value %g", value);
 
-	return std::unique_ptr<ParameterBase>(new ConstParameter<double>(value));
+    return std::unique_ptr<ParameterBase>(new ConstParameter<double>(value));
 }
 
 std::unique_ptr<ParameterBase> createMeshPropertyParameter(
     BaseLib::ConfigTree const& config, MeshLib::Mesh const& mesh)
 {
-	config.checkConfParam("type", "MeshProperty");
-	auto field_name = config.getConfParam<std::string>("field_name");
-	DBUG("Using field_name %s", field_name.c_str());
-
-	if (!mesh.getProperties().hasPropertyVector(field_name))
-	{
-		ERR("The required property %s does not exists in the mesh.",
-		    field_name.c_str());
-		std::abort();
-	}
-	auto const& property =
-	    mesh.getProperties().template getPropertyVector<double>(field_name);
-	if (!property)
-	{
-		ERR("The required property %s is not of the requested type.",
-		    field_name.c_str());
-		std::abort();
-	}
-
-	return std::unique_ptr<ParameterBase>(
-	    new MeshPropertyParameter<double>(*property));
+    config.checkConfParam("type", "MeshProperty");
+    auto field_name = config.getConfParam<std::string>("field_name");
+    DBUG("Using field_name %s", field_name.c_str());
+
+    if (!mesh.getProperties().hasPropertyVector(field_name))
+    {
+        ERR("The required property %s does not exists in the mesh.",
+            field_name.c_str());
+        std::abort();
+    }
+    auto const& property =
+        mesh.getProperties().template getPropertyVector<double>(field_name);
+    if (!property)
+    {
+        ERR("The required property %s is not of the requested type.",
+            field_name.c_str());
+        std::abort();
+    }
+
+    return std::unique_ptr<ParameterBase>(
+        new MeshPropertyParameter<double>(*property));
 }
 }  // namespace ProcessLib

ProcessLib/Parameter.h

@@ -31,9 +31,9 @@ namespace ProcessLib
 /// Its property name helps addressing the right parameter.
 struct ParameterBase
 {
-	virtual ~ParameterBase() = default;
+    virtual ~ParameterBase() = default;
 
-	std::string name;
+    std::string name;
 };
 
 /// A parameter is representing a value or function of any type.
@@ -43,9 +43,9 @@ struct ParameterBase
 template <typename ReturnType, typename... Args>
 struct Parameter : public ParameterBase
 {
-	virtual ~Parameter() = default;
+    virtual ~Parameter() = default;
 
-	virtual ReturnType operator()(Args&&... args) const = 0;
+    virtual ReturnType operator()(Args&&... args) const = 0;
 };
 
 /// Single, constant value parameter.
@@ -53,17 +53,17 @@ template <typename ReturnType>
 struct ConstParameter final
     : public Parameter<ReturnType, MeshLib::Element const&>
 {
-	ConstParameter(ReturnType value) : _value(value)
-	{
-	}
+    ConstParameter(ReturnType value) : _value(value)
+    {
+    }
 
-	ReturnType operator()(MeshLib::Element const&) const override
-	{
-		return _value;
-	}
+    ReturnType operator()(MeshLib::Element const&) const override
+    {
+        return _value;
+    }
 
 private:
-	ReturnType _value;
+    ReturnType _value;
 };
 
 std::unique_ptr<ParameterBase> createConstParameter(BaseLib::ConfigTree const& config);
@@ -73,18 +73,18 @@ template <typename ReturnType>
 struct MeshPropertyParameter final
     : public Parameter<ReturnType, MeshLib::Element const&>
 {
-	MeshPropertyParameter(MeshLib::PropertyVector<ReturnType> const& property)
-	    : _property(property)
-	{
-	}
+    MeshPropertyParameter(MeshLib::PropertyVector<ReturnType> const& property)
+        : _property(property)
+    {
+    }
 
-	ReturnType operator()(MeshLib::Element const& e) const override
-	{
-		return _property[e.getID()];
-	}
+    ReturnType operator()(MeshLib::Element const& e) const override
+    {
+        return _property[e.getID()];
+    }
 
 private:
-	MeshLib::PropertyVector<ReturnType> const& _property;
+    MeshLib::PropertyVector<ReturnType> const& _property;
 };
 
 std::unique_ptr<ParameterBase> createMeshPropertyParameter(BaseLib::ConfigTree const& config, MeshLib::Mesh const& mesh);

ProcessLib/Process.cpp

@@ -15,47 +15,47 @@ ProcessVariable& findProcessVariable(
     std::vector<ProcessVariable> const& variables,
     BaseLib::ConfigTree const& pv_config, std::string const& tag)
 {
-	// Find process variable name in process config.
-	std::string const name = pv_config.getConfParam<std::string>(tag);
+    // Find process variable name in process config.
+    std::string const name = pv_config.getConfParam<std::string>(tag);
 
         // Find corresponding variable by name.
-	auto variable = std::find_if(variables.cbegin(), variables.cend(),
-	                             [&name](ProcessVariable const& v)
-	                             {
-		                             return v.getName() == name;
-	                             });
-
-	if (variable == variables.end())
-	{
-		ERR(
-		    "Could not find process variable '%s' in the provided variables "
-		    "list for config tag <%s>.",
-		    name.c_str(), tag.c_str());
-		std::abort();
-	}
-	DBUG("Found process variable \'%s\' for config tag <%s>.",
-		 variable->getName().c_str(), tag.c_str());
-
-	// Const cast is needed because of variables argument constness.
-	return const_cast<ProcessVariable&>(*variable);
+    auto variable = std::find_if(variables.cbegin(), variables.cend(),
+                                 [&name](ProcessVariable const& v)
+                                 {
+                                     return v.getName() == name;
+                                 });
+
+    if (variable == variables.end())
+    {
+        ERR(
+            "Could not find process variable '%s' in the provided variables "
+            "list for config tag <%s>.",
+            name.c_str(), tag.c_str());
+        std::abort();
+    }
+    DBUG("Found process variable \'%s\' for config tag <%s>.",
+         variable->getName().c_str(), tag.c_str());
+
+    // Const cast is needed because of variables argument constness.
+    return const_cast<ProcessVariable&>(*variable);
 }
 
 std::vector<std::reference_wrapper<ProcessVariable>>
 findProcessVariables(
-		std::vector<ProcessVariable> const& variables,
-		BaseLib::ConfigTree const& process_config,
-		std::initializer_list<std::string> tag_names)
+        std::vector<ProcessVariable> const& variables,
+        BaseLib::ConfigTree const& process_config,
+        std::initializer_list<std::string> tag_names)
 {
-	std::vector<std::reference_wrapper<ProcessVariable>> vars;
-	vars.reserve(tag_names.size());
+    std::vector<std::reference_wrapper<ProcessVariable>> vars;
+    vars.reserve(tag_names.size());
 
-	auto const pv_conf = process_config.getConfSubtree("process_variables");
+    auto const pv_conf = process_config.getConfSubtree("process_variables");
 
-	for (auto const& tag : tag_names) {
-		vars.emplace_back(findProcessVariable(variables, pv_conf, tag));
-	}
+    for (auto const& tag : tag_names) {
+        vars.emplace_back(findProcessVariable(variables, pv_conf, tag));
+    }
 
-	return vars;
+    return vars;
 }
 
 }  // namespace ProcessLib

ProcessLib/Process.h

@@ -34,294 +34,294 @@ namespace ProcessLib
 
 template <typename GlobalSetup>
 class Process
-		: public NumLib::ODESystem<typename GlobalSetup::MatrixType,
-		                           typename GlobalSetup::VectorType,
-		                           // TODO: later on use a simpler ODE system
-		                           NumLib::ODESystemTag::FirstOrderImplicitQuasilinear,
-		                           NumLib::NonlinearSolverTag::Newton>
+        : public NumLib::ODESystem<typename GlobalSetup::MatrixType,
+                                   typename GlobalSetup::VectorType,
+                                   // TODO: later on use a simpler ODE system
+                                   NumLib::ODESystemTag::FirstOrderImplicitQuasilinear,
+                                   NumLib::NonlinearSolverTag::Newton>
 {
 public:
-	using GlobalVector = typename GlobalSetup::VectorType;
-	using GlobalMatrix = typename GlobalSetup::MatrixType;
-	using Index = typename GlobalMatrix::IndexType;
-	using NonlinearSolver = NumLib::NonlinearSolverBase<GlobalMatrix, GlobalVector>;
-	using TimeDiscretization = NumLib::TimeDiscretization<GlobalVector>;
-
-	Process(
-	    MeshLib::Mesh& mesh,
-	    NonlinearSolver& nonlinear_solver,
-	    std::unique_ptr<TimeDiscretization>&& time_discretization,
-	    std::vector<std::reference_wrapper<ProcessVariable>>&& process_variables,
-	    SecondaryVariableCollection<GlobalVector>&& secondary_variables,
-	    ProcessOutput<GlobalVector>&& process_output
-	    )
-	    : _mesh(mesh)
-	    , _nonlinear_solver(nonlinear_solver)
-	    , _time_discretization(std::move(time_discretization))
-	    , _process_variables(std::move(process_variables))
-	    , _process_output(std::move(process_output))
-	    , _secondary_variables(std::move(secondary_variables))
-	{}
-
-	/// Preprocessing before starting assembly for new timestep.
-	virtual void preTimestep(GlobalVector const& /*x*/,
-	                         const double /*t*/, const double /*delta_t*/) {}
-
-	/// Postprocessing after a complete timestep.
-	virtual void postTimestep(GlobalVector const& /*x*/) {}
-
-	/// Process output.
-	/// The file_name is indicating the name of possible output file.
-	void output(std::string const& file_name,
-	            const unsigned /*timestep*/,
-	            GlobalVector const& x) const
-	{
-		doProcessOutput(file_name, x, _mesh, *_local_to_global_index_map,
-		                _process_variables, _secondary_variables, _process_output);
-	}
-
-	void initialize()
-	{
-		DBUG("Initialize process.");
-
-		DBUG("Construct dof mappings.");
-		constructDofTable();
+    using GlobalVector = typename GlobalSetup::VectorType;
+    using GlobalMatrix = typename GlobalSetup::MatrixType;
+    using Index = typename GlobalMatrix::IndexType;
+    using NonlinearSolver = NumLib::NonlinearSolverBase<GlobalMatrix, GlobalVector>;
+    using TimeDiscretization = NumLib::TimeDiscretization<GlobalVector>;
+
+    Process(
+        MeshLib::Mesh& mesh,
+        NonlinearSolver& nonlinear_solver,
+        std::unique_ptr<TimeDiscretization>&& time_discretization,
+        std::vector<std::reference_wrapper<ProcessVariable>>&& process_variables,
+        SecondaryVariableCollection<GlobalVector>&& secondary_variables,
+        ProcessOutput<GlobalVector>&& process_output
+        )
+        : _mesh(mesh)
+        , _nonlinear_solver(nonlinear_solver)
+        , _time_discretization(std::move(time_discretization))
+        , _process_variables(std::move(process_variables))
+        , _process_output(std::move(process_output))
+        , _secondary_variables(std::move(secondary_variables))
+    {}
+
+    /// Preprocessing before starting assembly for new timestep.
+    virtual void preTimestep(GlobalVector const& /*x*/,
+                             const double /*t*/, const double /*delta_t*/) {}
+
+    /// Postprocessing after a complete timestep.
+    virtual void postTimestep(GlobalVector const& /*x*/) {}
+
+    /// Process output.
+    /// The file_name is indicating the name of possible output file.
+    void output(std::string const& file_name,
+                const unsigned /*timestep*/,
+                GlobalVector const& x) const
+    {
+        doProcessOutput(file_name, x, _mesh, *_local_to_global_index_map,
+                        _process_variables, _secondary_variables, _process_output);
+    }
+
+    void initialize()
+    {
+        DBUG("Initialize process.");
+
+        DBUG("Construct dof mappings.");
+        constructDofTable();
 
 #ifndef USE_PETSC
-		DBUG("Compute sparsity pattern");
-		computeSparsityPattern();
+        DBUG("Compute sparsity pattern");
+        computeSparsityPattern();
 #endif
 
-		initializeConcreteProcess(*_local_to_global_index_map, _mesh,
-								  _integration_order);
-
-		DBUG("Initialize boundary conditions.");
-		for (ProcessVariable& pv : _process_variables)
-		{
-			createDirichletBcs(pv, 0);  // 0 is the component id
-			createNeumannBcs(pv, 0);    // 0 is the component id
-		}
-
-		for (auto& bc : _neumann_bcs)
-			bc->initialize(_mesh.getDimension());
-	}
-
-	void setInitialConditions(GlobalVector& x)
-	{
-		DBUG("Set initial conditions.");
-		for (ProcessVariable& pv : _process_variables)
-		{
-			setInitialConditions(pv, 0, x);  // 0 is the component id
-		}
-	}
-
-	MathLib::MatrixSpecifications getMatrixSpecifications() const override final
-	{
-		return { 0u, 0u,
-		         &_sparsity_pattern,
-		         _local_to_global_index_map.get(),
-		         &_mesh };
-	}
-
-	void assemble(const double t, GlobalVector const& x,
-	              GlobalMatrix& M, GlobalMatrix& K, GlobalVector& b) override final
-	{
-		assembleConcreteProcess(t, x, M, K, b);
-
-		// Call global assembler for each Neumann boundary local assembler.
-		for (auto const& bc : _neumann_bcs)
-			bc->integrate(t, b);
-	}
-
-	void assembleJacobian(
-		const double t, GlobalVector const& x, GlobalVector const& xdot,
-		const double dxdot_dx, GlobalMatrix const& M,
-		const double dx_dx, GlobalMatrix const& K,
-		GlobalMatrix& Jac) override final
-	{
-		assembleJacobianConcreteProcess(t, x, xdot, dxdot_dx, M, dx_dx, K, Jac);
-
-		// TODO In this method one could check if the user wants to use an
-		//      analytical or a numerical Jacobian. Then the right
-		//      assembleJacobianConcreteProcess() method will be chosen.
-		//      Additionally in the default implementation of said method one
-		//      could provide a fallback to a numerical Jacobian. However, that
-		//      would be in a sense implicit behaviour and it might be better to
-		//      just abort, as is currently the case.
-		//      In order to implement the Jacobian assembly entirely, in addition
-		//      to the operator() in VectorMatrixAssembler there has to be a method
-		//      that dispatches the Jacobian assembly.
-		//      Similarly, then the NeumannBC specialization of VectorMatrixAssembler
-		//      probably can be merged into the main class s.t. one has only one
-		//      type of VectorMatrixAssembler (for each equation type) with the
-		//      three methods assemble(), assembleJacobian() and assembleNeumannBC().
-		//      That list can be extended, e.g. by methods for the assembly of
-		//      source terms.
-		//      UPDATE: Probably it is better to keep a separate NeumannBC version of the
-		//      VectoMatrixAssembler since that will work for all kinds of processes.
-	}
-
-	std::vector<DirichletBc<Index>> const* getKnownSolutions(
-	    double const /*t*/) const override final
-	{
-		return &_dirichlet_bcs;
-	}
-
-	NonlinearSolver& getNonlinearSolver() const
-	{
-		return _nonlinear_solver;
-	}
-
-	TimeDiscretization& getTimeDiscretization() const
-	{
-		return *_time_discretization;
-	}
+        initializeConcreteProcess(*_local_to_global_index_map, _mesh,
+                                  _integration_order);
+
+        DBUG("Initialize boundary conditions.");
+        for (ProcessVariable& pv : _process_variables)
+        {
+            createDirichletBcs(pv, 0);  // 0 is the component id
+            createNeumannBcs(pv, 0);    // 0 is the component id
+        }
+
+        for (auto& bc : _neumann_bcs)
+            bc->initialize(_mesh.getDimension());
+    }
+
+    void setInitialConditions(GlobalVector& x)
+    {
+        DBUG("Set initial conditions.");
+        for (ProcessVariable& pv : _process_variables)
+        {
+            setInitialConditions(pv, 0, x);  // 0 is the component id
+        }
+    }
+
+    MathLib::MatrixSpecifications getMatrixSpecifications() const override final
+    {
+        return { 0u, 0u,
+                 &_sparsity_pattern,
+                 _local_to_global_index_map.get(),
+                 &_mesh };
+    }
+
+    void assemble(const double t, GlobalVector const& x,
+                  GlobalMatrix& M, GlobalMatrix& K, GlobalVector& b) override final
+    {
+        assembleConcreteProcess(t, x, M, K, b);
+
+        // Call global assembler for each Neumann boundary local assembler.
+        for (auto const& bc : _neumann_bcs)
+            bc->integrate(t, b);
+    }
+
+    void assembleJacobian(
+        const double t, GlobalVector const& x, GlobalVector const& xdot,
+        const double dxdot_dx, GlobalMatrix const& M,
+        const double dx_dx, GlobalMatrix const& K,
+        GlobalMatrix& Jac) override final
+    {
+        assembleJacobianConcreteProcess(t, x, xdot, dxdot_dx, M, dx_dx, K, Jac);
+
+        // TODO In this method one could check if the user wants to use an
+        //      analytical or a numerical Jacobian. Then the right
+        //      assembleJacobianConcreteProcess() method will be chosen.
+        //      Additionally in the default implementation of said method one
+        //      could provide a fallback to a numerical Jacobian. However, that
+        //      would be in a sense implicit behaviour and it might be better to
+        //      just abort, as is currently the case.
+        //      In order to implement the Jacobian assembly entirely, in addition
+        //      to the operator() in VectorMatrixAssembler there has to be a method
+        //      that dispatches the Jacobian assembly.
+        //      Similarly, then the NeumannBC specialization of VectorMatrixAssembler
+        //      probably can be merged into the main class s.t. one has only one
+        //      type of VectorMatrixAssembler (for each equation type) with the
+        //      three methods assemble(), assembleJacobian() and assembleNeumannBC().
+        //      That list can be extended, e.g. by methods for the assembly of
+        //      source terms.
+        //      UPDATE: Probably it is better to keep a separate NeumannBC version of the
+        //      VectoMatrixAssembler since that will work for all kinds of processes.
+    }
+
+    std::vector<DirichletBc<Index>> const* getKnownSolutions(
+        double const /*t*/) const override final
+    {
+        return &_dirichlet_bcs;
+    }
+
+    NonlinearSolver& getNonlinearSolver() const
+    {
+        return _nonlinear_solver;
+    }
+
+    TimeDiscretization& getTimeDiscretization() const
+    {
+        return *_time_discretization;
+    }
 
 private:
-	/// Process specific initialization called by initialize().
-	virtual void initializeConcreteProcess(
-	    AssemblerLib::LocalToGlobalIndexMap const& dof_table,
-	    MeshLib::Mesh const& mesh,
-	    unsigned const integration_order) = 0;
-
-	virtual void assembleConcreteProcess(
-	    const double t, GlobalVector const& x,
-	    GlobalMatrix& M, GlobalMatrix& K, GlobalVector& b) = 0;
-
-	virtual void assembleJacobianConcreteProcess(
-		const double /*t*/, GlobalVector const& /*x*/, GlobalVector const& /*xdot*/,
-		const double /*dxdot_dx*/, GlobalMatrix const& /*M*/,
-		const double /*dx_dx*/, GlobalMatrix const& /*K*/,
-		GlobalMatrix& /*Jac*/)
-	{
-		ERR("The concrete implementation of this Process did not override the"
-			" assembleJacobianConcreteProcess() method."
-			" Hence, no analytical Jacobian is provided for this process"
-			" and the Newton-Raphson method cannot be used to solve it.");
-		std::abort();
-	}
-
-	void constructDofTable()
-	{
-		// Create single component dof in every of the mesh's nodes.
-		_mesh_subset_all_nodes.reset(
-		    new MeshLib::MeshSubset(_mesh, &_mesh.getNodes()));
-
-		// Collect the mesh subsets in a vector.
-		std::vector<std::unique_ptr<MeshLib::MeshSubsets>> all_mesh_subsets;
-		for (ProcessVariable const& pv : _process_variables)
-		{
-			std::generate_n(
-			    std::back_inserter(all_mesh_subsets),
-			    pv.getNumberOfComponents(),
-			    [&]()
-			    {
-				    return std::unique_ptr<MeshLib::MeshSubsets>{
-				        new MeshLib::MeshSubsets{_mesh_subset_all_nodes.get()}};
-				});
-		}
-
-		_local_to_global_index_map.reset(
-		    new AssemblerLib::LocalToGlobalIndexMap(
-		        std::move(all_mesh_subsets),
-		        AssemblerLib::ComponentOrder::BY_LOCATION));
-	}
-
-	/// Sets the initial condition values in the solution vector x for a given
-	/// process variable and component.
-	void setInitialConditions(ProcessVariable const& variable,
-	                          int const component_id,
-	                          GlobalVector& x)
-	{
-		std::size_t const n_nodes = _mesh.getNNodes();
-		for (std::size_t node_id = 0; node_id < n_nodes; ++node_id)
-		{
-			MeshLib::Location const l(_mesh.getID(),
-			                          MeshLib::MeshItemType::Node, node_id);
-			auto global_index = std::abs(
-			    _local_to_global_index_map->getGlobalIndex(l, component_id));
+    /// Process specific initialization called by initialize().
+    virtual void initializeConcreteProcess(
+        AssemblerLib::LocalToGlobalIndexMap const& dof_table,
+        MeshLib::Mesh const& mesh,
+        unsigned const integration_order) = 0;
+
+    virtual void assembleConcreteProcess(
+        const double t, GlobalVector const& x,
+        GlobalMatrix& M, GlobalMatrix& K, GlobalVector& b) = 0;
+
+    virtual void assembleJacobianConcreteProcess(
+        const double /*t*/, GlobalVector const& /*x*/, GlobalVector const& /*xdot*/,
+        const double /*dxdot_dx*/, GlobalMatrix const& /*M*/,
+        const double /*dx_dx*/, GlobalMatrix const& /*K*/,
+        GlobalMatrix& /*Jac*/)
+    {
+        ERR("The concrete implementation of this Process did not override the"
+            " assembleJacobianConcreteProcess() method."
+            " Hence, no analytical Jacobian is provided for this process"
+            " and the Newton-Raphson method cannot be used to solve it.");
+        std::abort();
+    }
+
+    void constructDofTable()
+    {
+        // Create single component dof in every of the mesh's nodes.
+        _mesh_subset_all_nodes.reset(
+            new MeshLib::MeshSubset(_mesh, &_mesh.getNodes()));
+
+        // Collect the mesh subsets in a vector.
+        std::vector<std::unique_ptr<MeshLib::MeshSubsets>> all_mesh_subsets;
+        for (ProcessVariable const& pv : _process_variables)
+        {
+            std::generate_n(
+                std::back_inserter(all_mesh_subsets),
+                pv.getNumberOfComponents(),
+                [&]()
+                {
+                    return std::unique_ptr<MeshLib::MeshSubsets>{
+                        new MeshLib::MeshSubsets{_mesh_subset_all_nodes.get()}};
+                });
+        }
+
+        _local_to_global_index_map.reset(
+            new AssemblerLib::LocalToGlobalIndexMap(
+                std::move(all_mesh_subsets),
+                AssemblerLib::ComponentOrder::BY_LOCATION));
+    }
+
+    /// Sets the initial condition values in the solution vector x for a given
+    /// process variable and component.
+    void setInitialConditions(ProcessVariable const& variable,
+                              int const component_id,
+                              GlobalVector& x)
+    {
+        std::size_t const n_nodes = _mesh.getNNodes();
+        for (std::size_t node_id = 0; node_id < n_nodes; ++node_id)
+        {
+            MeshLib::Location const l(_mesh.getID(),
+                                      MeshLib::MeshItemType::Node, node_id);
+            auto global_index = std::abs(
+                _local_to_global_index_map->getGlobalIndex(l, component_id));
 #ifdef USE_PETSC
-			// The global indices of the ghost entries of the global
-			// matrix or the global vectors need to be set as negative values
-			// for equation assembly, however the global indices start from zero.
-			// Therefore, any ghost entry with zero index is assigned an negative
-			// value of the vector size or the matrix dimension.
-			// To assign the initial value for the ghost entries,
-			// the negative indices of the ghost entries are restored to zero.
-			// checked hereby.
-			if ( global_index == x.size() )
-			    global_index = 0;
+            // The global indices of the ghost entries of the global
+            // matrix or the global vectors need to be set as negative values
+            // for equation assembly, however the global indices start from zero.
+            // Therefore, any ghost entry with zero index is assigned an negative
+            // value of the vector size or the matrix dimension.
+            // To assign the initial value for the ghost entries,
+            // the negative indices of the ghost entries are restored to zero.
+            // checked hereby.
+            if ( global_index == x.size() )
+                global_index = 0;
 #endif
-			x.set(global_index,
-			      variable.getInitialConditionValue(*_mesh.getNode(node_id),
-			                                        component_id));
-		}
-	}
-
-	void createDirichletBcs(ProcessVariable& variable, int const component_id)
-	{
-		MeshGeoToolsLib::MeshNodeSearcher& mesh_node_searcher =
-		    MeshGeoToolsLib::MeshNodeSearcher::getMeshNodeSearcher(
-		        variable.getMesh());
-
-		variable.initializeDirichletBCs(std::back_inserter(_dirichlet_bcs),
-		                                mesh_node_searcher,
-		                                *_local_to_global_index_map,
-		                                component_id);
-	}
-
-	void createNeumannBcs(ProcessVariable& variable, int const component_id)
-	{
-		// Find mesh nodes.
-		MeshGeoToolsLib::MeshNodeSearcher& mesh_node_searcher =
-		    MeshGeoToolsLib::MeshNodeSearcher::getMeshNodeSearcher(
-		        variable.getMesh());
-		MeshGeoToolsLib::BoundaryElementsSearcher mesh_element_searcher(
-		    variable.getMesh(), mesh_node_searcher);
-
-		// Create a neumann BC for the process variable storing them in the
-		// _neumann_bcs vector.
-		variable.createNeumannBcs<GlobalSetup>(
-		                          std::back_inserter(_neumann_bcs),
-		                          mesh_element_searcher,
-		                          _integration_order,
-		                          *_local_to_global_index_map,
-		                          0,  // 0 is the variable id TODO
-		                          component_id);
-	}
-
-	/// Computes and stores global matrix' sparsity pattern from given
-	/// DOF-table.
-	void computeSparsityPattern()
-	{
-		_sparsity_pattern = std::move(AssemblerLib::computeSparsityPattern(
-		    *_local_to_global_index_map, _mesh));
-	}
+            x.set(global_index,
+                  variable.getInitialConditionValue(*_mesh.getNode(node_id),
+                                                    component_id));
+        }
+    }
+
+    void createDirichletBcs(ProcessVariable& variable, int const component_id)
+    {
+        MeshGeoToolsLib::MeshNodeSearcher& mesh_node_searcher =
+            MeshGeoToolsLib::MeshNodeSearcher::getMeshNodeSearcher(
+                variable.getMesh());
+
+        variable.initializeDirichletBCs(std::back_inserter(_dirichlet_bcs),
+                                        mesh_node_searcher,
+                                        *_local_to_global_index_map,
+                                        component_id);
+    }
+
+    void createNeumannBcs(ProcessVariable& variable, int const component_id)
+    {
+        // Find mesh nodes.
+        MeshGeoToolsLib::MeshNodeSearcher& mesh_node_searcher =
+            MeshGeoToolsLib::MeshNodeSearcher::getMeshNodeSearcher(
+                variable.getMesh());
+        MeshGeoToolsLib::BoundaryElementsSearcher mesh_element_searcher(
+            variable.getMesh(), mesh_node_searcher);
+
+        // Create a neumann BC for the process variable storing them in the
+        // _neumann_bcs vector.
+        variable.createNeumannBcs<GlobalSetup>(
+                                  std::back_inserter(_neumann_bcs),
+                                  mesh_element_searcher,
+                                  _integration_order,
+                                  *_local_to_global_index_map,
+                                  0,  // 0 is the variable id TODO
+                                  component_id);
+    }
+
+    /// Computes and stores global matrix' sparsity pattern from given
+    /// DOF-table.
+    void computeSparsityPattern()
+    {
+        _sparsity_pattern = std::move(AssemblerLib::computeSparsityPattern(
+            *_local_to_global_index_map, _mesh));
+    }
 
 private:
-	unsigned const _integration_order = 2;
+    unsigned const _integration_order = 2;
 
-	MeshLib::Mesh& _mesh;
+    MeshLib::Mesh& _mesh;
 
-	std::unique_ptr<AssemblerLib::LocalToGlobalIndexMap>
-	    _local_to_global_index_map;
+    std::unique_ptr<AssemblerLib::LocalToGlobalIndexMap>
+        _local_to_global_index_map;
 
-	MathLib::SparsityPattern _sparsity_pattern;
+    MathLib::SparsityPattern _sparsity_pattern;
 
-	std::vector<DirichletBc<GlobalIndexType>> _dirichlet_bcs;
-	std::vector<std::unique_ptr<NeumannBc<GlobalSetup>>> _neumann_bcs;
+    std::vector<DirichletBc<GlobalIndexType>> _dirichlet_bcs;
+    std::vector<std::unique_ptr<NeumannBc<GlobalSetup>>> _neumann_bcs;
 
-	NonlinearSolver& _nonlinear_solver;
-	std::unique_ptr<TimeDiscretization> _time_discretization;
+    NonlinearSolver& _nonlinear_solver;
+    std::unique_ptr<TimeDiscretization> _time_discretization;
 
-	/// Variables used by this process.
-	std::vector<std::reference_wrapper<ProcessVariable>> _process_variables;
+    /// Variables used by this process.
+    std::vector<std::reference_wrapper<ProcessVariable>> _process_variables;
 
-	ProcessOutput<GlobalVector> _process_output;
+    ProcessOutput<GlobalVector> _process_output;
 
 protected:
-	std::unique_ptr<MeshLib::MeshSubset const> _mesh_subset_all_nodes;
-	SecondaryVariableCollection<GlobalVector> _secondary_variables;
+    std::unique_ptr<MeshLib::MeshSubset const> _mesh_subset_all_nodes;
+    SecondaryVariableCollection<GlobalVector> _secondary_variables;
 };
 
 /// Find process variables in \c variables whose names match the settings under
@@ -366,36 +366,36 @@ Parameter<ParameterArgs...>& findParameter(
     BaseLib::ConfigTree const& process_config, std::string const& tag,
     std::vector<std::unique_ptr<ParameterBase>> const& parameters)
 {
-	// Find parameter name in process config.
-	auto const name = process_config.getConfParam<std::string>(tag);
-
-	// Find corresponding parameter by name.
-	auto const parameter_it =
-	    std::find_if(parameters.cbegin(), parameters.cend(),
-	                 [&name](std::unique_ptr<ParameterBase> const& p)
-	                 {
-		                 return p->name == name;
-	                 });
-
-	if (parameter_it == parameters.end())
-	{
-		ERR(
-		    "Could not find parameter '%s' in the provided parameters list for "
-		    "config tag <%s>.",
-		    name.c_str(), tag.c_str());
-		std::abort();
-	}
-	DBUG("Found parameter \'%s\'.", (*parameter_it)->name.c_str());
-
-	// Check the type correctness of the found parameter.
-	auto* const parameter =
-	    dynamic_cast<Parameter<ParameterArgs...>*>(parameter_it->get());
-	if (!parameter)
-	{
-		ERR("The read parameter is of incompatible type.");
-		std::abort();
-	}
-	return *parameter;
+    // Find parameter name in process config.
+    auto const name = process_config.getConfParam<std::string>(tag);
+
+    // Find corresponding parameter by name.
+    auto const parameter_it =
+        std::find_if(parameters.cbegin(), parameters.cend(),
+                     [&name](std::unique_ptr<ParameterBase> const& p)
+                     {
+                         return p->name == name;
+                     });
+
+    if (parameter_it == parameters.end())
+    {
+        ERR(
+            "Could not find parameter '%s' in the provided parameters list for "
+            "config tag <%s>.",
+            name.c_str(), tag.c_str());
+        std::abort();
+    }
+    DBUG("Found parameter \'%s\'.", (*parameter_it)->name.c_str());
+
+    // Check the type correctness of the found parameter.
+    auto* const parameter =
+        dynamic_cast<Parameter<ParameterArgs...>*>(parameter_it->get());
+    if (!parameter)
+    {
+        ERR("The read parameter is of incompatible type.");
+        std::abort();
+    }
+    return *parameter;
 }
 
 }  // namespace ProcessLib

ProcessLib/ProcessVariable.cpp

@@ -25,74 +25,74 @@ ProcessVariable::ProcessVariable(BaseLib::ConfigTree const& config,
       _mesh(mesh),
       _n_components(config.getConfParam<int>("components"))
 {
-	DBUG("Constructing process variable %s", this->_name.c_str());
-
-	// Initial condition
-	if (auto ic_config = config.getConfSubtreeOptional("initial_condition"))
-	{
-		auto const type = ic_config->peekConfParam<std::string>("type");
-		if (type == "Uniform")
-		{
-			_initial_condition =
-			    createUniformInitialCondition(*ic_config, _n_components);
-		}
-		else if (type == "MeshProperty")
-		{
-			_initial_condition =
-			    createMeshPropertyInitialCondition(*ic_config, _mesh, _n_components);
-		}
-		else
-		{
-			ERR("Unknown type of the initial condition.");
-		}
-	}
-	else
-	{
-		INFO("No initial condition found.");
-	}
-
-	// Boundary conditions
-	if (auto bcs_config = config.getConfSubtreeOptional("boundary_conditions"))
-	{
-		for (auto bc_config
-			 : bcs_config->getConfSubtreeList("boundary_condition"))
-		{
-			auto const geometrical_set_name =
-					bc_config.getConfParam<std::string>("geometrical_set");
-			auto const geometry_name =
-					bc_config.getConfParam<std::string>("geometry");
-
-			GeoLib::GeoObject const* const geometry =
-			    geometries.getGeoObject(geometrical_set_name, geometry_name);
-			DBUG(
-			    "Found geometry type \"%s\"",
-			    GeoLib::convertGeoTypeToString(geometry->getGeoType()).c_str());
-
-			// Construct type dependent boundary condition
-			auto const type = bc_config.peekConfParam<std::string>("type");
-
-			if (type == "UniformDirichlet")
-			{
-				_dirichlet_bc_configs.emplace_back(
-				    new UniformDirichletBoundaryCondition(geometry, bc_config));
-			}
-			else if (type == "UniformNeumann")
-			{
-				_neumann_bc_configs.emplace_back(
-				    new NeumannBcConfig(geometry, bc_config));
-			}
-			else
-			{
-				ERR("Unknown type \'%s\' of the boundary condition.",
-				    type.c_str());
-			}
-		}
-	} else {
-		INFO("No boundary conditions found.");
-	}
-
-	// Source Terms
-	config.ignoreConfParam("source_terms");
+    DBUG("Constructing process variable %s", this->_name.c_str());
+
+    // Initial condition
+    if (auto ic_config = config.getConfSubtreeOptional("initial_condition"))
+    {
+        auto const type = ic_config->peekConfParam<std::string>("type");
+        if (type == "Uniform")
+        {
+            _initial_condition =
+                createUniformInitialCondition(*ic_config, _n_components);
+        }
+        else if (type == "MeshProperty")
+        {
+            _initial_condition =
+                createMeshPropertyInitialCondition(*ic_config, _mesh, _n_components);
+        }
+        else
+        {
+            ERR("Unknown type of the initial condition.");
+        }
+    }
+    else
+    {
+        INFO("No initial condition found.");
+    }
+
+    // Boundary conditions
+    if (auto bcs_config = config.getConfSubtreeOptional("boundary_conditions"))
+    {
+        for (auto bc_config
+             : bcs_config->getConfSubtreeList("boundary_condition"))
+        {
+            auto const geometrical_set_name =
+                    bc_config.getConfParam<std::string>("geometrical_set");
+            auto const geometry_name =
+                    bc_config.getConfParam<std::string>("geometry");
+
+            GeoLib::GeoObject const* const geometry =
+                geometries.getGeoObject(geometrical_set_name, geometry_name);
+            DBUG(
+                "Found geometry type \"%s\"",
+                GeoLib::convertGeoTypeToString(geometry->getGeoType()).c_str());
+
+            // Construct type dependent boundary condition
+            auto const type = bc_config.peekConfParam<std::string>("type");
+
+            if (type == "UniformDirichlet")
+            {
+                _dirichlet_bc_configs.emplace_back(
+                    new UniformDirichletBoundaryCondition(geometry, bc_config));
+            }
+            else if (type == "UniformNeumann")
+            {
+                _neumann_bc_configs.emplace_back(
+                    new NeumannBcConfig(geometry, bc_config));
+            }
+            else
+            {
+                ERR("Unknown type \'%s\' of the boundary condition.",
+                    type.c_str());
+            }
+        }
+    } else {
+        INFO("No boundary conditions found.");
+    }
+
+    // Source Terms
+    config.ignoreConfParam("source_terms");
 }
 
 ProcessVariable::ProcessVariable(ProcessVariable&& other)
@@ -107,32 +107,32 @@ ProcessVariable::ProcessVariable(ProcessVariable&& other)
 
 std::string const& ProcessVariable::getName() const
 {
-	return _name;
+    return _name;
 }
 
 MeshLib::Mesh const& ProcessVariable::getMesh() const
 {
-	return _mesh;
+    return _mesh;
 }
 
 MeshLib::PropertyVector<double>& ProcessVariable::getOrCreateMeshProperty()
 {
-	boost::optional<MeshLib::PropertyVector<double>&> result;
-	if (_mesh.getProperties().hasPropertyVector(_name))
-	{
-		result =
-		    _mesh.getProperties().template getPropertyVector<double>(_name);
-		assert(result);
-		assert(result->size() == _mesh.getNNodes() * _n_components);
-	}
-	else
-	{
-		result = _mesh.getProperties().template createNewPropertyVector<double>(
-		    _name, MeshLib::MeshItemType::Node);
-		assert(result);
-		result->resize(_mesh.getNNodes() * _n_components);
-	}
-	return *result;
+    boost::optional<MeshLib::PropertyVector<double>&> result;
+    if (_mesh.getProperties().hasPropertyVector(_name))
+    {
+        result =
+            _mesh.getProperties().template getPropertyVector<double>(_name);
+        assert(result);
+        assert(result->size() == _mesh.getNNodes() * _n_components);
+    }
+    else
+    {
+        result = _mesh.getProperties().template createNewPropertyVector<double>(
+            _name, MeshLib::MeshItemType::Node);
+        assert(result);
+        result->resize(_mesh.getNNodes() * _n_components);
+    }
+    return *result;
 }
 
 }  // namespace ProcessLib

ProcessLib/ProcessVariable.h

@@ -47,67 +47,67 @@ namespace ProcessLib
 class ProcessVariable
 {
 public:
-	ProcessVariable(BaseLib::ConfigTree const& config, MeshLib::Mesh& mesh,
-	                GeoLib::GEOObjects const& geometries);
-
-	ProcessVariable(ProcessVariable&&);
-
-	std::string const& getName() const;
-
-	/// Returns a mesh on which the process variable is defined.
-	MeshLib::Mesh const& getMesh() const;
-
-	/// Returns the number of components of the process variable.
-	int getNumberOfComponents() const { return _n_components; }
-
-	template <typename OutputIterator>
-	void initializeDirichletBCs(
-	    OutputIterator output_bcs,
-	    MeshGeoToolsLib::MeshNodeSearcher& searcher,
-	    const AssemblerLib::LocalToGlobalIndexMap& dof_table,
-	    const unsigned nodal_dof_idx)
-	{
-		for (auto& bc_config : _dirichlet_bc_configs)
-		{
-			DirichletBc<GlobalIndexType> bc;
-			bc_config->initialize(searcher, dof_table, nodal_dof_idx, bc);
-			output_bcs++ = bc;
-		}
-	}
-
-	template <typename GlobalSetup, typename OutputIterator, typename... Args>
-	void createNeumannBcs(OutputIterator bcs,
-	                      MeshGeoToolsLib::BoundaryElementsSearcher& searcher,
-	                      Args&&... args)
-	{
-		for (auto& config : _neumann_bc_configs)
-		{
-			config->initialize(searcher);
-			bcs++ = std::unique_ptr<NeumannBc<GlobalSetup>>{
-			    new NeumannBc<GlobalSetup>(*config,
-			                               std::forward<Args>(args)...)};
-		}
-	}
-
-	double getInitialConditionValue(MeshLib::Node const& n,
-	                                int const component_id) const
-	{
-		return _initial_condition->getValue(n, component_id);
-	}
-
-	// Get or create a property vector for results.
-	// The returned mesh property size is number of mesh nodes times number of
-	// components.
-	MeshLib::PropertyVector<double>& getOrCreateMeshProperty();
+    ProcessVariable(BaseLib::ConfigTree const& config, MeshLib::Mesh& mesh,
+                    GeoLib::GEOObjects const& geometries);
+
+    ProcessVariable(ProcessVariable&&);
+
+    std::string const& getName() const;
+
+    /// Returns a mesh on which the process variable is defined.
+    MeshLib::Mesh const& getMesh() const;
+
+    /// Returns the number of components of the process variable.
+    int getNumberOfComponents() const { return _n_components; }
+
+    template <typename OutputIterator>
+    void initializeDirichletBCs(
+        OutputIterator output_bcs,
+        MeshGeoToolsLib::MeshNodeSearcher& searcher,
+        const AssemblerLib::LocalToGlobalIndexMap& dof_table,
+        const unsigned nodal_dof_idx)
+    {
+        for (auto& bc_config : _dirichlet_bc_configs)
+        {
+            DirichletBc<GlobalIndexType> bc;
+            bc_config->initialize(searcher, dof_table, nodal_dof_idx, bc);
+            output_bcs++ = bc;
+        }
+    }
+
+    template <typename GlobalSetup, typename OutputIterator, typename... Args>
+    void createNeumannBcs(OutputIterator bcs,
+                          MeshGeoToolsLib::BoundaryElementsSearcher& searcher,
+                          Args&&... args)
+    {
+        for (auto& config : _neumann_bc_configs)
+        {
+            config->initialize(searcher);
+            bcs++ = std::unique_ptr<NeumannBc<GlobalSetup>>{
+                new NeumannBc<GlobalSetup>(*config,
+                                           std::forward<Args>(args)...)};
+        }
+    }
+
+    double getInitialConditionValue(MeshLib::Node const& n,
+                                    int const component_id) const
+    {
+        return _initial_condition->getValue(n, component_id);
+    }
+
+    // Get or create a property vector for results.
+    // The returned mesh property size is number of mesh nodes times number of
+    // components.
+    MeshLib::PropertyVector<double>& getOrCreateMeshProperty();
 
 private:
-	std::string const _name;
-	MeshLib::Mesh& _mesh;
-	const int _n_components;
-	std::unique_ptr<InitialCondition> _initial_condition;
-	std::vector<std::unique_ptr<UniformDirichletBoundaryCondition>>
-	    _dirichlet_bc_configs;
-	std::vector<std::unique_ptr<NeumannBcConfig>> _neumann_bc_configs;
+    std::string const _name;
+    MeshLib::Mesh& _mesh;
+    const int _n_components;
+    std::unique_ptr<InitialCondition> _initial_condition;
+    std::vector<std::unique_ptr<UniformDirichletBoundaryCondition>>
+        _dirichlet_bc_configs;
+    std::vector<std::unique_ptr<NeumannBcConfig>> _neumann_bc_configs;
 };
 
 }  // namespace ProcessLib