poisson_model.hh
ed0789ce666bmaster

poisson_model.hh
View Options

			/**
			* @file poisson_model.hh
			*
			* @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
			* @author Lucas Frerot <lucas.frerot@epfl.ch>
			* @author Srinivasa Babu Ramisetti <srinivasa.ramisetti@epfl.ch>
			* @author Nicolas Richart <nicolas.richart@epfl.ch>
			* @author Rui Wang <rui.wang@epfl.ch>
			*
			* @date creation: Sun May 01 2011
			* @date last modification: Mon Mar 15 2021
			*
			* @brief Model of Generic Poisson Equation
			*
			*
			* @section LICENSE
			*
			* Copyright (©) 2010-2021 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 "boundary_condition.hh"
			#include "data_accessor.hh"
			#include "fe_engine.hh"
			#include "model.hh"
			/* -------------------------------------------------------------------------- */

			#ifndef AKANTU_POISSON_MODEL_HH_
			#define AKANTU_POISSON_MODEL_HH_

			namespace akantu {
			class ConstitutiveLaw;
			class ConstitutiveLawSelector;
			template <ElementKind kind, class IntegrationOrderFunctor> class IntegratorGauss;
			template <ElementKind kind> class ShapeLagrange;
			} // namespace akantu

			namespace akantu {

			class PoissonModel : public Model,
			public DataAccessor<Element>,
			public DataAccessor<UInt>,
			public BoundaryCondition<PoissonModel> {
			/* ------------------------------------------------------------------------ */
			/* Constructors/Destructors */
			/* ------------------------------------------------------------------------ */
			public:
			using FEEngineType = FEEngineTemplate<IntegratorGauss, ShapeLagrange>;

			PoissonModel(Mesh & mesh, UInt dim = _all_dimensions,
			const ID & id = "poisson_model",
			std::shared_ptr<DOFManager> dof_manager = nullptr,
			ModelType model_type = ModelType::_poisson_model);

			~PoissonModel() override;

			/* ------------------------------------------------------------------------ */
			/* Methods */
			/* ------------------------------------------------------------------------ */
			protected:
			/// generic function to initialize everything ready for explicit dynamics
			void initFullImpl(const ModelOptions & options) override;

			public:
			/// read one material file to instantiate all the materials
			void initConstitutiveLaws();

			protected:
			/// allocate all vectors
			void initSolver(TimeStepSolverType time_step_solver_type,
			NonLinearSolverType non_linear_solver_type) override;

			/// initialize the model
			void initModel() override;

			void predictor() override;

			/// callback for the solver, this is called at end of solve
			void corrector() override;

			/// compute the heat flux
			void assembleResidual() override;

			/// get the type of matrix needed
			MatrixType getMatrixType(const ID & matrix_id) const override;

			/// callback to assemble a Matrix
			void assembleMatrix(const ID & matrix_id) override;

			/// callback to assemble a lumped Matrix
			void assembleLumpedMatrix(const ID & matrix_id) override;

			std::tuple<ID, TimeStepSolverType>
			getDefaultSolverID(const AnalysisMethod & method) override;

			ModelSolverOptions
			getDefaultSolverOptions(const TimeStepSolverType & type) const override;

			/// function to print the containt of the class
			void printself(std::ostream & stream, int indent = 0) const override;

			///
			TimeStepSolverType getDefaultSolverType() const override;

			/* ------------------------------------------------------------------------ */
			/* Constitutive laws */
			/* ------------------------------------------------------------------------ */
			public:
			/// register an empty constitutive law of a given type
			ConstitutiveLaw & registerNewConstitutiveLaw(const ID & phase_name,
			const ID & phase_type,
			const ID & opt_param);

			/// reassigns constitutive Laws depending on the constitutive law selector
			void reassignConstitutiveLaw();

			protected:
			/// register a constitutive law in the dynamic database
			ConstitutiveLaw & registerNewConstitutiveLaw(const ParserSection & phase_section);

			/// read the constitutive laws to instantiate all the constitutive_laws
			void instantiateConstitutiveLaws();

			/// set the element_id_by_constitutive_law and add the elements to the good
			/// constitutive law
			void assignConstitutiveLawToElements(
			const ElementTypeMapArray<UInt> * filter = nullptr);

			/* ------------------------------------------------------------------------ */
			/* Methods for explicit */
			/* ------------------------------------------------------------------------ */
			public:
			/// compute and get the stable time step
			Real getStableTimeStep();

			/// set the stable timestep
			void setTimeStep(Real time_step, const ID & solver_id = "") override;

			protected:
			/// callback for the solver, this is called at beginning of solve
			void beforeSolveStep() override;
			/// callback for the solver, this is called at end of solve
			void afterSolveStep(bool converged = true) override;

			/// compute the stable time step
			Real getStableTimeStep(GhostType ghost_type);


			public:
			/// compute the internal dof rate \todo Need code review: currently not
			/// public method
			void assembleInternalDofRate();

			/// assemble the stiffness matrix
			void assembleStiffnessMatrix(bool need_to_reassemble = false);


			public:
			/// calculate the lumped capacity vector for heat transfer problem
			void assembleCapacityLumped();

			/// assemble the capacity matrix
			void assembleCapacity();


			public:
			/// assemble the lumped capacity matrix for local and ghost elements
			void assembleCapacityLumped(GhostType ghost_type);

			/// assemble the capacity matrix for either _ghost or _not_ghost elements
			void assembleCapacity(GhostType ghost_type);

			/* ------------------------------------------------------------------------ */
			/* Data Accessor inherited members */
			/* ------------------------------------------------------------------------ */
			public:
			inline UInt getNbData(const Array<Element> & elements,
			const SynchronizationTag & tag) const override;
			inline void packData(CommunicationBuffer & buffer,
			const Array<Element> & elements,
			const SynchronizationTag & tag) const override;
			inline void unpackData(CommunicationBuffer & buffer,
			const Array<Element> & elements,
			const SynchronizationTag & tag) override;

			inline UInt getNbData(const Array<UInt> & indexes,
			const SynchronizationTag & tag) const override;
			inline void packData(CommunicationBuffer & buffer,
			const Array<UInt> & indexes,
			const SynchronizationTag & tag) const override;
			inline void unpackData(CommunicationBuffer & buffer,
			const Array<UInt> & indexes,
			const SynchronizationTag & tag) override;

			/* ------------------------------------------------------------------------ */
			/* Dumpable interface */
			/* ------------------------------------------------------------------------ */
			public:
			std::shared_ptr<dumpers::Field>
			createNodalFieldReal(const std::string & field_name,
			const std::string & group_name,
			bool padding_flag) override;

			std::shared_ptr<dumpers::Field>
			createNodalFieldBool(const std::string & field_name,
			const std::string & group_name,
			bool padding_flag) override;

			std::shared_ptr<dumpers::Field>
			createElementalField(const std::string & field_name,
			const std::string & group_name, bool padding_flag,
			UInt spatial_dimension, ElementKind kind) override;

			/* ------------------------------------------------------------------------ */
			/* Accessors */
			/* ------------------------------------------------------------------------ */
			public:
			/// get the current value of the time step
			AKANTU_GET_MACRO(TimeStep, time_step, Real);
			/// get the assembled heat flux
			AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(InternalDofRate, internal_dof_rate);
			/// get the assembled heat flux
			AKANTU_GET_MACRO_DEREF_PTR(InternalDofRate, internal_dof_rate);
			/// get the external dof rate vector
			AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(ExternalDofRate, external_dof_rate);
			/// get the external dof rate vector
			AKANTU_GET_MACRO_DEREF_PTR(ExternalDofRate, external_dof_rate);
			/// get the degree of freedom
			AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(Dof, dof);
			/// get the degree of freedom
			AKANTU_GET_MACRO_DEREF_PTR(Dof, dof);
			/// get the dof rate
			AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(DofRate, dof_rate);
			/// get the dof rate
			AKANTU_GET_MACRO_DEREF_PTR(DofRate, dof_rate);
			/// get the PoissonModel::blocked_dofs array
			AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(BlockedDOFs, blocked_dofs);
			/// get the blocked_dofs vector
			AKANTU_GET_MACRO_DEREF_PTR(BlockedDOFs, blocked_dofs);

			/// get an iterable on the constitutive_laws
			inline decltype(auto) getConstitutiveLaws();

			/// get an iterable on the constitutive_laws
			inline decltype(auto) getConstitutiveLaws() const;

			/// get a particular constitutive law (by constitutive law index)
			inline ConstitutiveLaw & getConstitutiveLaw(UInt mat_index);

			/// get a particular constitutive law (by constitutive law index)
			inline const ConstitutiveLaw & getConstitutiveLaw(UInt mat_index) const;

			/// get a particular constitutive law (by constitutive law name)
			inline ConstitutiveLaw & getConstitutiveLaw(const std::string & name);

			/// get a particular constitutive law (by constitutive law name)
			inline const ConstitutiveLaw & getConstitutiveLaw(const std::string & name) const;

			/// get a particular constitutive law id from is name
			inline UInt getConstitutiveLawIndex(const std::string & name) const;

			/// give the number of constitutive_laws
			inline UInt getNbConstitutiveLaws() const { return constitutive_laws.size(); }

			/// give the constitutive law internal index from its id
			Int getInternalIndexFromID(const ID & id) const;


			AKANTU_GET_MACRO(ConstitutiveLawByElement, constitutive_law_index,
			const ElementTypeMapArray<UInt> &);
			AKANTU_GET_MACRO(ConstitutiveLawLocalNumbering, constitutive_law_local_numbering,
			const ElementTypeMapArray<UInt> &);

			/// vectors containing local material element index for each global element
			/// index
			AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(ConstitutiveLawByElement, constitutive_law_index,
			UInt);
			AKANTU_GET_MACRO_BY_ELEMENT_TYPE(ConstitutiveLawByElement, constitutive_law_index, UInt);
			AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(ConstitutiveLawLocalNumbering,
			constitutive_law_local_numbering, UInt);
			AKANTU_GET_MACRO_BY_ELEMENT_TYPE(ConstitutiveLawLocalNumbering,
			constitutive_law_local_numbering, UInt);

			AKANTU_GET_MACRO_NOT_CONST(ConstitutiveLawSelector, *constitutive_law_selector,
			ConstitutiveLawSelector &);

			AKANTU_SET_MACRO(ConstitutiveLawSelector, constitutive_law_selector,
			std::shared_ptr<ConstitutiveLawSelector>);

			FEEngine & getFEEngineBoundary(const ID & name = "") override;


			/* ------------------------------------------------------------------------ */
			/* Class Members */
			/* ------------------------------------------------------------------------ */
			private:
			/// time step
			Real time_step;

			/// mapping between constitutive Law name and law internal id
			std::map<std::string, UInt> constitutive_laws_names_to_id;

			bool need_to_reassemble_capacity{true};

			bool need_to_reassemble_capacity_lumped{true};

			UInt dof_release{0};

			UInt conductivity_matrix_release{UInt(-1)};


			protected:
			/// temperatures array
			std::unique_ptr<Array<Real>> dof;

			/// temperatures derivatives array
			std::unique_ptr<Array<Real>> dof_rate;

			/// increment array (@f$\delta \dot T@f$ or @f$\delta T@f$)
			std::unique_ptr<Array<Real>> increment;

			/// external flux vector
			std::unique_ptr<Array<Real>> external_dof_rate;

			/// residuals array
			std::unique_ptr<Array<Real>> internal_dof_rate;

			/// boundary vector
			std::unique_ptr<Array<bool>> blocked_dofs;

			/// Arrays containing the constitutive law index for each element
			ElementTypeMapArray<UInt> constitutive_law_index;

			/// Arrays containing the position in the element filter of the constitutive law
			/// (constitutive law's local numbering)
			ElementTypeMapArray<UInt> constitutive_law_local_numbering;

			/// class defining of to choose a constitutive law
			std::shared_ptr<ConstitutiveLawSelector> constitutive_law_selector;

			/// list of used constitutive laws
			std::vector<std::unique_ptr<ConstitutiveLaw>> constitutive_laws;

			/// tells if the constitutive law are instantiated
			bool are_constitutive_laws_instantiated{false};


			friend class ConstitutiveLaw;


			};

			} // namespace akantu

			/* -------------------------------------------------------------------------- */
			/* inline functions */
			/* -------------------------------------------------------------------------- */
			#include "parser.hh"
			#include "constitutive_law.hh"

			#include "poisson_model_inline_impl.hh"

			#endif /* AKANTU_POISSON_MODEL_HH_ */

rAKA/src/model/heat_transfer/poisson_model.hhed0789ce666bmaster

poisson_model.hhView Options

rAKA/src/model/heat_transfer/poisson_model.hh
ed0789ce666bmaster

poisson_model.hh
View Options