MeltPoolDG Namespace Reference

Interface for a general preconditioner. More...

Namespaces
namespace	AMR
namespace	CharacteristicFunctions
namespace	CompressibleFlow
	This file contains various functions that can be used to set and evaluate boundary conditions for the compressible flow solver. The functions can be directly used with the BoundaryConditions class, which provides an interface to manage and evaluate the different boundary conditions in the solver.
namespace	Constraints
namespace	CutUtil
namespace	DoFTools
namespace	Evaporation
namespace	FiniteElementUtils
namespace	Flow
namespace	Functions
namespace	GridGenerator
namespace	Heat
namespace	internal
namespace	Journal
namespace	LevelSet
	This operation solves the reinitialization problem for a CG- or DG-FEM-based discrete level-set field by solving an elliptic problem.
namespace	MaterialUpdateFlags
namespace	MeltPool
namespace	Multiphase
	A collection of functions for the computation of the interface terms for compressible two-phase flows.
namespace	numbers
namespace	PhysicalConstants
namespace	PostProcessingTools
namespace	Profiling
namespace	RadiativeTransport
namespace	Restart
namespace	Simulation
namespace	SpeciesTransport
namespace	TimeIntegration
	Class providing different low storage explicit Runge-Kutta schemes. The schemes implemented in this class are presented in.
namespace	Utilities
namespace	Utility
namespace	UtilityFunctions
namespace	Utils
	Implementation of functions defined by C++23.
namespace	VectorTools

Classes
struct	AdaptiveMeshingData
struct	BaseData
class	BoundaryConditionManager
struct	BrinkmanObstacleForce
struct	BrinkmanPenalizationData
struct	BrinkmanPenalizationJacobianContribution
struct	BrinkmanPenalizationResidualContribution
struct	CellListParticleHandler
	Forward declaration of the CellListParticleHandler class template. More...
class	CellMonitor
class	ConditionalOStream
struct	CutStabilizationData
	Collection of parameters for the stabilization of cutFEM and cutDG applications. More...
class	DealiiPreconditionerWrapper
class	DEMParticleAccessor
class	DoFMonitor
struct	FiniteElementData
struct	FluidStructureInteractionData
class	GenericDataOut
	A generic utility for managing simulation output data in the MeltPoolDG context. More...
struct	GhostPenaltyData
	Collection of parameters for the ghost-penalty stabilization of cutFEM and cutDG applications. More...
class	IdentityPreconditioner
struct	is_dealii_tensor
struct	is_dealii_tensor< dealii::Tensor< rank, components, number > >
class	IterationMonitor
class	JacobiPreconditioner
class	LeastSquaresProjection
class	LevelAdjacentCellsCache
class	LevelCommunicationPattern
	Computes and stores the MPI communication pattern for a given level of a distributed triangulation. More...
class	LinearSolver
class	Material
struct	MaterialData
struct	MaterialParameterValues
struct	MaterialPhaseData
class	MatrixFreeCellBatchParticleCache
struct	MatrixFreeContext
struct	MatrixTypeObject
class	MeltFrontPropagation
class	MeltPoolApplication
class	MeltPoolCase
struct	MeltPoolCaseParameters
struct	NeighborListUpdateTracker
class	NewtonRaphsonSolver
struct	NonlinearSolverData
struct	ObstacleData
class	ObstacleField
struct	ObstacleGravitationalForce
	Computes the gravitational force acting on an obstacle. More...
struct	ObstacleLoad
	Interface class for loads acting on obstacles using type erasure. More...
class	OperatorBase
class	OperatorMatrixBased
	Operator handling matrix-based computations. More...
class	OperatorMatrixFree
	Operator handling matrix-free computations. More...
struct	OutputData
struct	ParametersBase
	Abstract base class for managing parameter files. More...
struct	ParaviewData
class	ParticleIterator
	STL-style bidirectional iterator over particles. More...
struct	ParticleOutputData
struct	PeriodicBoundaryConditions
class	Postprocessor
class	Preconditioner
class	Predictor
class	ScopedName
class	ScratchData
	Container for shared scratch data between operations/operators. More...
class	SimulationCaseBase
	Base class for managing a simulation case in a parallel computing environment. More...
class	SphericalParticle
	Class representing a finite-sized spherical particle, intended for use with the obstacle field class. More...
class	SphericalParticleCohesiveForce
struct	SphericalParticleCohesiveForceData
struct	SphericalParticleContactData
class	SphericalParticleContactForce
struct	StokesLawFluidForce
struct	StokesLawSphericalParticleForce

Concepts
concept	ParameterObject
	Concept to check if a type is derived from ParametersBase.
concept	PreconditionerTypeConcept
concept	JacobiPreconditionerOperatorType
concept	DealiipreconditionerWrapperOperatorType
concept	ArithmeticType
concept	HasJacobianQuadraturePointKernels

Typedefs
template<int dim, typename VectorType >
using	DoFHandlerAndVectorDataType = std::vector< std::pair< const dealii::DoFHandler< dim > *, std::function< void(std::vector< VectorType * > &)> > >
template<int dim, typename VectorType >
using	AttachDoFHandlerAndVectorsType = std::function< void(DoFHandlerAndVectorDataType< dim, VectorType > &)>
template<int dim, int n_components, typename number , typename VectorizedArrayType = dealii::VectorizedArray<number>>
using	FECellIntegrator = dealii::FEEvaluation< dim, -1, 0, n_components, number, VectorizedArrayType >
template<int dim, int n_components, typename number , typename VectorizedArrayType = dealii::VectorizedArray<number>>
using	FEFaceIntegrator = dealii::FEFaceEvaluation< dim, -1, 0, n_components, number, VectorizedArrayType >

Enumerations
enum class	MaterialTypes {   gas , liquid , gas_liquid , gas_liquid_consistent_with_evaporation ,   liquid_solid , gas_liquid_solid , gas_liquid_solid_consistent_with_evaporation }
enum	MatrixRepresentationType { DiagonalMatrix , SystemMatrix }
enum	TriangulationType { shared , parallel_distributed , parallel_fullydistributed , serial }

Functions
	DeclException1 (ExcBCAlreadyAssigned, std::string,<< "You try to attach a "<< arg1<< " boundary condition "<< "for a boundary_id for which a boundary condition is already "<< "specified. Check your input related to boundary conditions!")
	DeclException2 (ExcFieldNotAttached, std::string, std::string,<< "It seems that you have not called SimulationCaseBase::"<< arg1<< "() for the operator \""<< arg2<< "\". You can do that, e.g., "<< "in your simulation by overriding SimulationCaseBase::set_field_conditions().")
	DeclExceptionMsg (ExcZeroTimeIncrement, "It seems that the time increment is zero. Make sure that " "the time increment is larger than zero.")
	DeclExceptionMsg (ExcNewtonDidNotConverge, "The Newton-Raphson solver did not converge.")
	DeclExceptionMsg (ExcHeatTransferNoConvergence, "The heat transfer solver did not converge.")
	DeclException2 (ExcInvalidCSVInputColumns, unsigned int, unsigned int,<< "Expected "<< arg1<< " columns in each line of the CSV file, but got "<< arg2<< ". Please check your input file.")
	DeclException1 (ExcFailedToConvertStringToNumber, std::string,<< "Failed to convert the string \""<< arg1<< "\" to a number. Please ensure that the string is a valid representation of a number and "<< "does not contain any extraneous characters.")
MaterialTypes	determine_material_type (const bool do_two_phase, const bool do_solidification, const bool do_evaporation)
	BETTER_ENUM (MaterialTemplate, char, none, stainless_steel, Ti64, Ti64Benchmark) BETTER_ENUM(SolidLiquidPropertiesTransitionType
void	add_and_parse_parameters (const std::string &parameter_file, const std::function< void(dealii::ParameterHandler &)> &add_parameters, const bool &enable_print=false, const bool print_details=false, const bool skip_undefined=true, const std::string &subsection="")
	Adds parameters from a file to a ParameterHandler object.
template<typename ParametersType , template< int, typename > class CaseType, template< int, typename > class ApplicationType>
void	run_simulation (const std::string &parameter_file, const MPI_Comm mpi_communicator)
template<typename Parameters , template< int, typename > class Case, template< int, typename > class Application>
void	default_main (int argc, char *argv[], MPI_Comm mpi_comm)
	BETTER_ENUM (FSICouplingMethod, char, brinkman_penalization, stokes_law)
template<int dim, typename number , typename ObstacleType >
std::tuple< std::shared_ptr< CompressibleFlow::ExternalFlowForce< dim, number > >, std::shared_ptr< CompressibleFlow::ExternalFlowForceJacobian< dim, number > >, std::unique_ptr< ObstacleLoad< dim, number, ObstacleType > > >	setup_fluid_structure_interaction (const FluidStructureInteractionData< number > &fsi_data, ObstacleField< dim, number, ObstacleType > &obstacle_field, const CompressibleFlow::MaterialPhaseData< number > &flow_material, const dealii::LinearAlgebra::distributed::Vector< number > &flow_solution, const MatrixFreeContext< dim, number > flow_mf_context, const std::shared_ptr< MatrixFreeCellBatchParticleCache< dim, number, ObstacleType > > &cell_cache=nullptr)
	BETTER_ENUM (MaskFunctionType, char, discontinuous)
template<int dim, typename number , typename VectorizedArrayType >
VectorizedArrayType	discontinuous_mask_function (const dealii::Point< dim, VectorizedArrayType > &location, const DEMParticleAccessor< dim, number > &particle)
template<int dim, typename number , typename VectorizedArrayType >
VectorizedArrayType	mask_function (const MaskFunctionType mask_function_type, const dealii::Point< dim, VectorizedArrayType > &location, const DEMParticleAccessor< dim, number > &particle)
	BETTER_ENUM (PreconditionerType, char, Identity, AMG, ILU, Diagonal) BETTER_ENUM(LinearSolverType
GMRES	BETTER_ENUM (LinearSolverMonitorType, char, none, reduced, all) template< typename number
template<int dim, typename number , typename OperatorType , typename VectorType >
Preconditioner< dim, VectorType, number >	make_preconditioner (const PreconditionerType &preconditioner_type, const OperatorType *operator_in, const ScratchData< dim, dim, number > &scratch_data, const unsigned dof_idx, const bool do_matrix_free=true)
	BETTER_ENUM (PredictorType, char, none, zero, linear_extrapolation, least_squares_projection) struct PredictorData
template<typename VectorType , typename number >
void	compute_linear_predictor (const VectorType &old_vec, const VectorType &old_old_vec, VectorType &predictor, const number current_time_increment, const number old_time_increment)
template<int dim, typename number , typename ObstacleType , typename ContainerType > requires std::ranges::range<ContainerType>
and std::same_as< std::ranges::range_value_t< ContainerType >, DEMParticleAccessor< dim, number > > void	symplectic_euler_advance_time_step (const number time_step, ContainerType particle_range)
	Advances particle states by one time step using the symplectic Euler scheme.
template<int dim, typename number >
dealii::Tensor< 1, axial_dim< dim >, number >	compute_torque (const dealii::Tensor< 1, dim, number > &force, const dealii::Tensor< 1, dim, number > &lever_arm)
template<int dim, typename number >
number	compute_spherical_particle_volume (const number radius)
template<int dim, typename number >
number	compute_spherical_particle_moment_of_inertia (const number mass, const number radius)
template<int dim, typename number >
void	compute_and_set_spherical_particle_properties (DEMParticleAccessor< dim, number > accessor, const number radius, const number density)
template<int dim, typename number , typename VectorizedArrayType >
dealii::Tensor< 1, dim, VectorizedArrayType >	vector_to_center_of_gravity (const DEMParticleAccessor< dim, number > &particle, const dealii::Point< dim, VectorizedArrayType > &location)
template<int dim, typename number , typename VectorizedArrayType >
dealii::Tensor< 1, dim, VectorizedArrayType >	local_particle_velocity (const DEMParticleAccessor< dim, number > &particle, const dealii::Point< dim, VectorizedArrayType > &location)
template<int dim, typename number >
std::pair< std::vector< dealii::Point< dim, number > >, std::vector< std::vector< number > > >	read_particle_state_input_file (const std::string &filename, const MPI_Comm &mpi_communicator)
template<int dim>
constexpr std::tuple< dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id >	get_colorized_rectangle_boundary_ids ()
template<>
constexpr std::tuple< dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id >	get_colorized_rectangle_boundary_ids< 1 > ()
template<>
constexpr std::tuple< dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id >	get_colorized_rectangle_boundary_ids< 2 > ()
template<>
constexpr std::tuple< dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id >	get_colorized_rectangle_boundary_ids< 3 > ()
template<typename number , std::size_t N>
dealii::VectorizedArray< number, N >	scalar_product (const dealii::VectorizedArray< number, N > &scalar, const dealii::Tensor< 1, 1, dealii::VectorizedArray< number, N > > &vec)
template<typename number , std::size_t N>
dealii::VectorizedArray< number, N >	scalar_product (const dealii::Tensor< 1, 1, dealii::VectorizedArray< number, N > > &vec, const dealii::VectorizedArray< number, N > &scalar)
template<int n_rows, int n_columns, typename number >
dealii::Tensor< 1, n_rows, number >	matrix_vector_product (const dealii::Tensor< 1, n_rows, dealii::Tensor< 1, n_columns, number > > &matrix, const dealii::Tensor< 1, n_columns, number > &vector)
template<int a, int b, int c, typename number >
dealii::Tensor< 1, a, dealii::Tensor< 1, c, number > >	matrix_matrix_product (const dealii::Tensor< 1, a, dealii::Tensor< 1, b, number > > &matrix1, const dealii::Tensor< 1, b, dealii::Tensor< 1, c, number > > &matrix2)
template<int dim_1, int dim_2, typename number >
dealii::Tensor< 1, dim_1, dealii::VectorizedArray< number > >	contract_tensor_with_vector (const dealii::Tensor< 1, dim_1, dealii::Tensor< 1, dim_2, dealii::VectorizedArray< number > > > &tensor, const dealii::Tensor< 1, dim_2, dealii::VectorizedArray< number > > &vector)
template<int dim_1, int dim_2, typename number >
dealii::Tensor< 1, dim_1, number >	contract_average_tensor_with_vector (const dealii::Tensor< 1, dim_1, dealii::Tensor< 1, dim_2, number > > &tensor_1, const dealii::Tensor< 1, dim_1, dealii::Tensor< 1, dim_2, number > > &tensor_2, const dealii::Tensor< 1, dim_2, number > &vector)
template<int dim, typename number >
dealii::Tensor< 1, dim, dealii::VectorizedArray< number > >	normalize (const dealii::VectorizedArray< number > &in, const number zero=1e-16)
template<int dim, typename number >
dealii::Tensor< 1, dim, dealii::VectorizedArray< number > >	normalize (const dealii::Tensor< 1, dim, dealii::VectorizedArray< number > > &in, const number zero=1e-16)
template<int T1_dim, int T2_dim, typename number >
dealii::Tensor< 1, T1_dim, dealii::Tensor< 1, T2_dim, number > >	dyadic_product (const number *a_start, const number *b_start)
template<int T1_dim, int T2_dim, typename number >
dealii::Tensor< 1, T1_dim, dealii::Tensor< 1, T2_dim, number > >	dyadic_product (const dealii::Tensor< 1, T1_dim, number > &a, const dealii::Tensor< 1, T2_dim, number > &b)
template<int T1_dim, int T2_dim, typename number >
dealii::Tensor< 1, T2_dim, dealii::Tensor< 1, T1_dim, number > >	transpose (const dealii::Tensor< 1, T1_dim, dealii::Tensor< 1, T2_dim, number > > &in)
template<int dim, typename number >
number	trace (const dealii::Tensor< 1, dim, dealii::Tensor< 1, dim, number > > &in)
template<int dim, typename number >
number	trace (const dealii::Tensor< 2, dim, number > &in)
template<int dim, typename number >
dealii::Tensor< 1, dim, dealii::Tensor< 1, dim, number > >	identity ()
template<int dim1, int dim2, typename number >
dealii::Tensor< 1, dim1, dealii::Tensor< 1, dim2, number > >	jump (const dealii::Tensor< 1, dim1, number > &tensor_m, const dealii::Tensor< 1, dim1, number > &tensor_p, const dealii::Tensor< 1, dim2, number > &normal)
template<typename VectorType , typename Operator >
std::vector< std::complex< double > >	estimate_eigenvalues_gmres (const Operator &op, const VectorType &b, const unsigned max_eigenvalues=100)
template<typename VectorType , typename Operator >
std::vector< std::complex< double > >	estimate_eigenvalues_gmres (const Operator &op, const VectorType &b, const unsigned int max_eigenvalues)
template<typename FeEval >
dealii::Tensor< 1, FeEval::n_components, dealii::VectorizedArray< typename FeEval::number_type > >	fe_evaluation_tensor_value_at_q (const FeEval &fe_eval, const unsigned q_index)
template<int dim, typename number >
std::vector< dealii::TriaIterator< dealii::CellAccessor< dim > > >	cells_in_cell_batch (const dealii::MatrixFree< dim, number > &mf, const unsigned int cell_batch_id)
template<int dim, int n_components, typename number , HasJacobianQuadraturePointKernels< dim, number > OperatorType>
void	compute_jacobian_matrix_representation (const OperatorType &implicit_operator, std::variant< dealii::LinearAlgebra::distributed::Vector< number > *, dealii::TrilinosWrappers::SparseMatrix * > dst, const MatrixRepresentationType type, const dealii::LinearAlgebra::distributed::Vector< number > &current_solution, const dealii::MatrixFree< dim, number > &matrix_free, const unsigned int dof_idx, const unsigned int quad_idx)
template<int dim, typename number , int n_components>
std::vector< std::pair< dealii::Tensor< 1, n_components, number >, dealii::Tensor< 1, n_components, dealii::Tensor< 1, dim, number > > > >	compute_cell_average_quantities (const MatrixFreeContext< dim, number > &mf_context, const dealii::LinearAlgebra::distributed::Vector< number > &solution)
template<int dim, int spacedim = dim>
TriangulationType	get_triangulation_type (const dealii::Triangulation< dim, spacedim > &tria)
template void	compute_linear_predictor (const dealii::LinearAlgebra::distributed::Vector< double > &, const dealii::LinearAlgebra::distributed::Vector< double > &, dealii::LinearAlgebra::distributed::Vector< double > &, const double, const double)
template void	compute_linear_predictor (const dealii::LinearAlgebra::distributed::BlockVector< double > &, const dealii::LinearAlgebra::distributed::BlockVector< double > &, dealii::LinearAlgebra::distributed::BlockVector< double > &, const double, const double)
template TriangulationType	get_triangulation_type (const dealii::Triangulation< 1, 1 > &)
template TriangulationType	get_triangulation_type (const dealii::Triangulation< 2, 2 > &)
template TriangulationType	get_triangulation_type (const dealii::Triangulation< 3, 3 > &)

Variables
	char
	mushy_zone
	poly4_bell
	constant
	CG
template<int dim>
constexpr int	axial_dim

Detailed Description

Interface for a general preconditioner.

A wrapper for a deal.II like matrix type object. The purpose of this wrapper is to provide an object which has a member function vmult() that can be interpreted as a matrix vector product.

Wrapper class for deal.II matrix-based preconditioners.

Jacobi preconditioner for matrix-free operators.

Factory function for the preconditioner.

Typedef Documentation

AttachDoFHandlerAndVectorsType

template<int dim, typename VectorType >

using MeltPoolDG::AttachDoFHandlerAndVectorsType = typedef std::function<void(DoFHandlerAndVectorDataType<dim, VectorType> &)>

DoFHandlerAndVectorDataType

template<int dim, typename VectorType >

using MeltPoolDG::DoFHandlerAndVectorDataType = typedef std::vector< std::pair<const dealii::DoFHandler<dim> *, std::function<void(std::vector<VectorType *> &)> >>

Type alias definitions that are used to collect pointers to DoFHandlers and their respective DoF-Vectors.

FECellIntegrator

template<int dim, int n_components, typename number , typename VectorizedArrayType = dealii::VectorizedArray<number>>

using MeltPoolDG::FECellIntegrator = typedef dealii::FEEvaluation<dim, -1, 0, n_components, number, VectorizedArrayType>

FEFaceIntegrator

template<int dim, int n_components, typename number , typename VectorizedArrayType = dealii::VectorizedArray<number>>

using MeltPoolDG::FEFaceIntegrator = typedef dealii::FEFaceEvaluation<dim, -1, 0, n_components, number, VectorizedArrayType>

Enumeration Type Documentation

MaterialTypes

enum class MeltPoolDG::MaterialTypes

strong

Enumerator
gas
liquid
gas_liquid
gas_liquid_consistent_with_evaporation
liquid_solid
gas_liquid_solid
gas_liquid_solid_consistent_with_evaporation

MatrixRepresentationType

enum MeltPoolDG::MatrixRepresentationType

An enum of possible matrix representation types that can be computed from a matrix free object with the below defined functions.

Enumerator
DiagonalMatrix
SystemMatrix

TriangulationType

enum MeltPoolDG::TriangulationType

Enumerator
shared
parallel_distributed
parallel_fullydistributed
serial

Function Documentation

add_and_parse_parameters()

void MeltPoolDG::add_and_parse_parameters	(	const std::string &	parameter_file,
		const std::function< void(dealii::ParameterHandler &)> &	add_parameters,
		const bool &	enable_print = false,
		const bool	print_details = false,
		const bool	skip_undefined = true,
		const std::string &	subsection = ""
	)

Adds parameters from a file to a ParameterHandler object.

This free function reads user-defined parameters from a file (either JSON or PRM format), parses them, and applies them to the provided ParameterHandler object.

Parameters

parameter_file	Path to the parameter file.
add_parameters	Lambda function to define how problem-specific parameters are added.
pcout	ConditionalOStream to print the text.
enable_print	If true, parameters are printed to the console.

BETTER_ENUM() [1/6]

MeltPoolDG::BETTER_ENUM	(	FSICouplingMethod	,
		char	,
		brinkman_penalization	,
		stokes_law
	)

BETTER_ENUM() [2/6]

GMRES MeltPoolDG::BETTER_ENUM	(	LinearSolverMonitorType	,
		char	,
		none	,
		reduced	,
		all
	)

Parameters for the linear solver.

BETTER_ENUM() [3/6]

MeltPoolDG::BETTER_ENUM	(	MaskFunctionType	,
		char	,
		discontinuous
	)

BETTER_ENUM() [4/6]

MeltPoolDG::BETTER_ENUM	(	MaterialTemplate	,
		char	,
		none	,
		stainless_steel	,
		Ti64	,
		Ti64Benchmark
	)

BETTER_ENUM() [5/6]

MeltPoolDG::BETTER_ENUM	(	PreconditionerType	,
		char	,
		Identity	,
		AMG	,
		ILU	,
		Diagonal
	)

BETTER_ENUM() [6/6]

MeltPoolDG::BETTER_ENUM	(	PredictorType	,
		char	,
		none	,
		zero	,
		linear_extrapolation	,
		least_squares_projection
	)

cells_in_cell_batch()

template<int dim, typename number >

std::vector< dealii::TriaIterator< dealii::CellAccessor< dim > > > MeltPoolDG::cells_in_cell_batch	(	const dealii::MatrixFree< dim, number > &	mf,
		const unsigned int	cell_batch_id
	)

This function returns the cell iterators corresponding to the active SIMD lanes of the specified cell batch.

Parameters

mf	The matrix-free object defining the cell batch of interest.
cell_batch_id	Index of the cell batch.

compute_and_set_spherical_particle_properties()

template<int dim, typename number >

void MeltPoolDG::compute_and_set_spherical_particle_properties	(	DEMParticleAccessor< dim, number >	accessor,
		const number	radius,
		const number	density
	)

Compute and set the properties of a spherical particle based on its radius and density. The function computes the volume, mass, and moment of inertia of the particle using the provided radius and density and sets these properties in the particle accessor.

Parameters

accessor	The particle accessor for the spherical particle whose properties are to be computed and set.
radius	The radius of the spherical particle.
density	The density of the spherical particle.

compute_cell_average_quantities()

template<int dim, typename number , int n_components>

std::vector< std::pair< dealii::Tensor< 1, n_components, number >, dealii::Tensor< 1, n_components, dealii::Tensor< 1, dim, number > > > > MeltPoolDG::compute_cell_average_quantities	(	const MatrixFreeContext< dim, number > &	mf_context,
		const dealii::LinearAlgebra::distributed::Vector< number > &	solution
	)

This function computes the cell-average values for a given solution vector by integrating the solution at quadrature points across each cell and dividing by the cell volume. The resulting cell-average values are stored in a vector indexed by active cell indices, where each entry is a tensor containing the component-wise average values for that cell.

Template Parameters

n_components

The number of vector components in the solution quantity.

Parameters

mf_context	Context containing a reference to the matrix-free object and relevant indices for dofs and quadrature.
solution	Vector containing the solution values from which to compute the cell averages.

Returns

A vector indexed by active cell indices, where each entry is contains the component-wise average values for that cell.

compute_jacobian_matrix_representation()

template<int dim, int n_components, typename number , HasJacobianQuadraturePointKernels< dim, number > OperatorType>

void MeltPoolDG::compute_jacobian_matrix_representation	(	const OperatorType &	implicit_operator,
		std::variant< dealii::LinearAlgebra::distributed::Vector< number > *, dealii::TrilinosWrappers::SparseMatrix * >	dst,
		const MatrixRepresentationType	type,
		const dealii::LinearAlgebra::distributed::Vector< number > &	current_solution,
		const dealii::MatrixFree< dim, number > &	matrix_free,
		const unsigned int	dof_idx,
		const unsigned int	quad_idx
	)

Given a matrix-free object, computes the matrix based representation of a Jacobian.

Given a matrix free implementation of the jacobian matrix, this function computes the matrix based representation of the jacobian in various forms (diagonal matrix, sparse matrix).

Parameters

implicit_operator	Operator containing the kernel functions defining the operations at quadrature points.
dst	Destination in which the matrix representation is stored.
type	Type of the desired matrix representation.
current_solution	Solution of the primary variables.
matrix_free	Matrix free object to be worked on.
dof_idx	Relevant dof index in the matrix free object.
quad_idx	Relevant quadrature index in the matrix free object.

compute_linear_predictor() [1/3]

template void MeltPoolDG::compute_linear_predictor	(	const dealii::LinearAlgebra::distributed::BlockVector< double > &	,
		const dealii::LinearAlgebra::distributed::BlockVector< double > &	,
		dealii::LinearAlgebra::distributed::BlockVector< double > &	,
		const double	,
		const double
	)

compute_linear_predictor() [2/3]

template void MeltPoolDG::compute_linear_predictor	(	const dealii::LinearAlgebra::distributed::Vector< double > &	,
		const dealii::LinearAlgebra::distributed::Vector< double > &	,
		dealii::LinearAlgebra::distributed::Vector< double > &	,
		const double	,
		const double
	)

compute_linear_predictor() [3/3]

template<typename VectorType , typename number >

void MeltPoolDG::compute_linear_predictor	(	const VectorType &	old_vec,
		const VectorType &	old_old_vec,
		VectorType &	predictor,
		const number	current_time_increment,
		const number	old_time_increment
	)

Compute a linearly extrapolated initial guess value (predictor) for the Newton-Raphson solver at time "t_n+1" from the old solution

Parameters

old_vec	computed at time "t_n" and the old old solution
old_old_vec	computed at time "t_n-1". In addition the
current_time_increment	dt_n+1 = t_n+1 - t_n and the
old_time_incrementdt_n	= t_n-t_n-1 have to be provided.

The predictor is computed as follows

               dt_n+1

q_n+1^(0) = q_n + ---— * (q_n-q_n-1) dt_n

compute_spherical_particle_moment_of_inertia()

template<int dim, typename number >

number MeltPoolDG::compute_spherical_particle_moment_of_inertia ( const number  mass, const number  radius  )

inline

Compute the moment of inertia of a spherical particle based on its mass, radius, and the spatial dimension.

Parameters

mass	The mass of the spherical particle.
radius	The radius of the spherical particle.

Exceptions

If	the function is called with dimension other than 2 or 3, an exception is thrown indicating an invalid dimension.

compute_spherical_particle_volume()

template<int dim, typename number >

number MeltPoolDG::compute_spherical_particle_volume ( const number  radius )

inline

Compute the volume of a spherical particle based on its radius and the spatial dimension.

Parameters

radius

The radius of the spherical particle.

Exceptions

If	the function is called with dimension other than 2 or 3, an exception is thrown indicating an invalid dimension.

compute_torque()

template<int dim, typename number >

dealii::Tensor< 1, axial_dim< dim >, number > MeltPoolDG::compute_torque	(	const dealii::Tensor< 1, dim, number > &	force,
		const dealii::Tensor< 1, dim, number > &	lever_arm
	)

Computes the torque generated by a force applied at a given position. Given a force vector force and a position vector distance_to_center_of_gravity pointing from the center of gravity to the point of application, this function returns the resulting torque.

• In 3D, the torque is computed using the standard vector cross product: \( \mathbf{M} = \mathbf{r} \times \mathbf{F} \).
• In 2D, the torque reduces to its scalar z-component: \( M = r_x F_y - r_y F_x \).

The return type is a Tensor of dimension:

• 1D scalar torque (dim = 2 -> Tensor<1,1>)
• 3D torque vector (dim = 3 -> Tensor<1,3>)

Parameters

force	The applied force vector.
lever_arm	Vector from center of gravity to point of application.

Returns

The resulting torque as a Tensor.

contract_average_tensor_with_vector()

template<int dim_1, int dim_2, typename number >

dealii::Tensor< 1, dim_1, number > MeltPoolDG::contract_average_tensor_with_vector	(	const dealii::Tensor< 1, dim_1, dealii::Tensor< 1, dim_2, number > > &	tensor_1,
		const dealii::Tensor< 1, dim_1, dealii::Tensor< 1, dim_2, number > > &	tensor_2,
		const dealii::Tensor< 1, dim_2, number > &	vector
	)

Contracts the average of two given second order tensors with a vector, which results in a vector. Note that the second order tensors are provided as two nested first order tensors in this function.

Parameters

tensor_1	First second order tensor of type 'Tensor<1, dim_1, Tensor<1, dim_2, VectorizedArray<number>>>'
tensor_2	Second second order tensor of type 'Tensor<1, dim_1, Tensor<1, dim_2, VectorizedArray<number>>>'
vector	Vector of type 'Tensor<1, dim_2, VectorizedArray<number>>'

Returns

Result of the contraction, i.e. result_i = 0.5 * (tensor_1_ij + tensor_2_ij) * vector_j. The result has vector type 'Tensor<1, dim_1, VectorizedArray<number>>'.

@ note The dimensions of the provided tensors and the vector have to match, i.e. the second basis of the tensors and the vector must have the same dimension dim_2.

contract_tensor_with_vector()

template<int dim_1, int dim_2, typename number >

dealii::Tensor< 1, dim_1, dealii::VectorizedArray< number > > MeltPoolDG::contract_tensor_with_vector	(	const dealii::Tensor< 1, dim_1, dealii::Tensor< 1, dim_2, dealii::VectorizedArray< number > > > &	tensor,
		const dealii::Tensor< 1, dim_2, dealii::VectorizedArray< number > > &	vector
	)

Contracts the given second order tensor with a vector, which results in a vector. Note that the second order tensor is provided as two nested first order tensors in this function.

Parameters

tensor	Second order tensor of type 'Tensor<1, dim_1, Tensor<1, dim_2, VectorizedArray<number>>>'
vector	Vector of type 'Tensor<1, dim_2, VectorizedArray<number>>'

Returns

Result of the contraction, i.e. result_i = tensor_ij * vector_j. The result has vector type 'Tensor<1, dim_1, VectorizedArray<number>>'.

@ note The dimensions of the provided tensor and the vector have to match, i.e. the second basis of the tensor and the vector must have the same dimension dim_2.

DeclException1() [1/2]

MeltPoolDG::DeclException1	(	ExcBCAlreadyAssigned	,
		std::string	,
		<< "You try to attach a "<< arg1<< " boundary condition "<< "for a boundary_id for which a boundary condition is already "<< "specified. Check your input related to boundary conditions!"
	)

DeclException1() [2/2]

MeltPoolDG::DeclException1	(	ExcFailedToConvertStringToNumber	,
		std::string	,
		<< "Failed to convert the string \""<< arg1<< "\" to a number. Please ensure that the string is a valid representation of a number and "<< "does not contain any extraneous characters."
	)

DeclException2() [1/2]

MeltPoolDG::DeclException2	(	ExcFieldNotAttached	,
		std::string	,
		std::string	,
		<< "It seems that you have not called SimulationCaseBase::"<< arg1<< "() for the operator \""<< arg2<< "\". You can do	that,
		e.	g.,
		"<< "in your simulation by overriding SimulationCaseBase::set_field_conditions()."
	)

DeclException2() [2/2]

MeltPoolDG::DeclException2	(	ExcInvalidCSVInputColumns	,
		unsigned int	,
		unsigned int	,
		<< "Expected "<< arg1<< " columns in each line of the CSV	file,
		but got "<< arg2<< ". Please check your input file."
	)

DeclExceptionMsg() [1/3]

MeltPoolDG::DeclExceptionMsg	(	ExcHeatTransferNoConvergence	,
		"The heat transfer solver did not converge."
	)

DeclExceptionMsg() [2/3]

MeltPoolDG::DeclExceptionMsg	(	ExcNewtonDidNotConverge	,
		"The Newton-Raphson solver did not converge."
	)

DeclExceptionMsg() [3/3]

MeltPoolDG::DeclExceptionMsg	(	ExcZeroTimeIncrement	,
		"It seems that the time increment is zero. Make sure that " "the time increment is larger than zero."
	)

default_main()

template<typename Parameters , template< int, typename > class Case, template< int, typename > class Application>

void MeltPoolDG::default_main	(	int	argc,
		char *	argv[],
		MPI_Comm	mpi_comm
	)

determine_material_type()

MaterialTypes MeltPoolDG::determine_material_type	(	const bool	do_two_phase,
		const bool	do_solidification,
		const bool	do_evaporation
	)

discontinuous_mask_function()

template<int dim, typename number , typename VectorizedArrayType >

VectorizedArrayType MeltPoolDG::discontinuous_mask_function	(	const dealii::Point< dim, VectorizedArrayType > &	location,
		const DEMParticleAccessor< dim, number > &	particle
	)

Implementation of a discontinuous mask function, which returns one if a given coordinate is inside an obstacle and zero otherwise.

Parameters

location	Coordinates at which the mask function shall be computed.
property_pool	Property pool holding all required information about the obstacles at the given locations.
handle	Handle to identify relevant obstacles in the property pool.

Returns

Value of mask function at given coordinates.

dyadic_product() [1/2]

template<int T1_dim, int T2_dim, typename number >

dealii::Tensor< 1, T1_dim, dealii::Tensor< 1, T2_dim, number > > MeltPoolDG::dyadic_product	(	const dealii::Tensor< 1, T1_dim, number > &	a,
		const dealii::Tensor< 1, T2_dim, number > &	b
	)

Compute the dyadic product of two rank-1 tensors

dyadic_product() [2/2]

template<int T1_dim, int T2_dim, typename number >

dealii::Tensor< 1, T1_dim, dealii::Tensor< 1, T2_dim, number > > MeltPoolDG::dyadic_product	(	const number *	a_start,
		const number *	b_start
	)

Compute the dyadic product of two rank-1 tensors passing a pointer to the start of the values of the two tensors.

estimate_eigenvalues_gmres() [1/2]

template<typename VectorType , typename Operator >

std::vector< std::complex< double > > MeltPoolDG::estimate_eigenvalues_gmres	(	const Operator &	op,
		const VectorType &	b,
		const unsigned int	max_eigenvalues
	)

estimate_eigenvalues_gmres() [2/2]

template<typename VectorType , typename Operator >

std::vector< std::complex< double > > MeltPoolDG::estimate_eigenvalues_gmres	(	const Operator &	op,
		const VectorType &	b,
		const unsigned	max_eigenvalues = 100
	)

Estimate the eigenvalues of Operator op. Eigenvalues can be useful to estimate the condition number (largest eigenvalue divided by smallest eigenvalue) or the spectral radius (maximum absolute eigenvalue).

The estimation is done via a dummy solve of the linear system op*x = b with GMRES. The GMRES algorithm allows to estimate the eigenvalues after every iteration. Therefore, we perform a fixed number of iterations which may not even lead to convergence but allows us to get a good estimate for the eigenvalue range. The number of iterations is limited by max_eigenvalues.

Parameters

op	The linear operator of which you want to estimate the eigenvalues. It must support vmult.
b	A dummy right-hand side, which is used for the solve. This vector must be chosen, such that op*x=b is sufficiently hard to solve. For instance, a zero vector will not work. Instead, this should e.g. be the residual of a weak form, if op is the Jacobian of a weak form.
max_eigenvalues	The maximum number of eigenvalues that should be estimated. The GMRES solver will need to perform as many iterations as specified here (unless the system size is smaller), so choose this value rather small.

Returns

A vector of complex eigenvalues. This vector will have a maximum of max_eigenvalues or b.size() entries, whichever is smaller. If b is poorly chosen, the number of returned eigenvalues may be a lot smaller though, even zero, because we can only get as many eigenvalues as GRMES iterations are performed. It is therefore recommended to check the size of the returned vector before any other operations.

fe_evaluation_tensor_value_at_q()

template<typename FeEval >

dealii::Tensor< 1, FeEval::n_components, dealii::VectorizedArray< typename FeEval::number_type > > MeltPoolDG::fe_evaluation_tensor_value_at_q	(	const FeEval &	fe_eval,
		const unsigned	q_index
	)

Helper function that returns the values at a given quadrature point (specified by q_index) using the provided finite element evaluation object (fe_eval) and ensures that the result is always returned as a dealii::Tensor.

In deal.II, FEValues and similar objects return a VectorizedArray directly when there is only a single component. However, the algorithms in this codebase are written to operate on tensors for both 2D and 3D problems and for systems with multiple components. This function provides a uniform interface by converting single-component vectorized values into a Tensor<1,1,VectorizedArray> while leaving multi-component values as-is.

Parameters

fe_eval	The finite element evaluation object.
q_index	Index of the quadrature point.

Returns

Value at the specified quadrature point as a dealii::Tensor.

get_colorized_rectangle_boundary_ids()

template<int dim>

constexpr std::tuple< dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id > MeltPoolDG::get_colorized_rectangle_boundary_ids ( )

constexpr

face numbering according to the colorize flag of dealii::GridGenerator::hyper_rectangle

Parameters

lower_bc	and
upper_bc	boundaries perpendicular to the vertical axis i.e. faces in dim-1 direction the vertical axis in the z-axis in 3D and the y-axis in 2D
left_bc	and
right_bc	boundaries aligned with vertical axis, perpendicular to the x-axis
front_bc	and
back_bc	boundaries aligned with vertical axis, perpendicular to the y-axis, only in 3D

get_colorized_rectangle_boundary_ids< 1 >()

template<>

constexpr std::tuple< dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id > MeltPoolDG::get_colorized_rectangle_boundary_ids< 1 > ( )

constexpr

get_colorized_rectangle_boundary_ids< 2 >()

template<>

constexpr std::tuple< dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id > MeltPoolDG::get_colorized_rectangle_boundary_ids< 2 > ( )

constexpr

get_colorized_rectangle_boundary_ids< 3 >()

template<>

constexpr std::tuple< dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id, dealii::types::boundary_id > MeltPoolDG::get_colorized_rectangle_boundary_ids< 3 > ( )

constexpr

get_triangulation_type() [1/4]

template TriangulationType MeltPoolDG::get_triangulation_type

(

const dealii::Triangulation< 1, 1 > &

)

get_triangulation_type() [2/4]

template TriangulationType MeltPoolDG::get_triangulation_type

(

const dealii::Triangulation< 2, 2 > &

)

get_triangulation_type() [3/4]

template TriangulationType MeltPoolDG::get_triangulation_type

(

const dealii::Triangulation< 3, 3 > &

)

get_triangulation_type() [4/4]

template<int dim, int spacedim = dim>

TriangulationType MeltPoolDG::get_triangulation_type

(

const dealii::Triangulation< dim, spacedim > &

tria

)

identity()

template<int dim, typename number >

dealii::Tensor< 1, dim, dealii::Tensor< 1, dim, number > > MeltPoolDG::identity

(

)

Return identity matrix

jump()

template<int dim1, int dim2, typename number >

dealii::Tensor< 1, dim1, dealii::Tensor< 1, dim2, number > > MeltPoolDG::jump	(	const dealii::Tensor< 1, dim1, number > &	tensor_m,
		const dealii::Tensor< 1, dim1, number > &	tensor_p,
		const dealii::Tensor< 1, dim2, number > &	normal
	)

Compute the jump between two tensors.

local_particle_velocity()

template<int dim, typename number , typename VectorizedArrayType >

dealii::Tensor< 1, dim, VectorizedArrayType > MeltPoolDG::local_particle_velocity	(	const DEMParticleAccessor< dim, number > &	particle,
		const dealii::Point< dim, VectorizedArrayType > &	location
	)

make_preconditioner()

template<int dim, typename number , typename OperatorType , typename VectorType >

Preconditioner< dim, VectorType, number > MeltPoolDG::make_preconditioner	(	const PreconditionerType &	preconditioner_type,
		const OperatorType *	operator_in,
		const ScratchData< dim, dim, number > &	scratch_data,
		const unsigned	dof_idx,
		const bool	do_matrix_free = true
	)

A preconditioner factory function. This function creates a preconditioner based on the passed preconditioner type and the flag indicating whether the preconditioner is applied in a matrix-free or a matrix-based context.

Parameters

preconditioner_type	Type of the desired preconditioner.
operator_in	Operator that supports the required functions for the computations inside the preconditioner (see specific preconditioner classes for additional information).
scratch_data	Scratch data object to get relevant dof information for the preconditioner.
dof_idx	Relevant dof index in the scratch data object.
do_matrix_free	A flag indicating if the operator shall be used in a matrix-free or matrix-based way.

Returns

Preconditioner object using the passed preconditioner type.

Exceptions

Exception

if the preconditioner type is not supported.

mask_function()

template<int dim, typename number , typename VectorizedArrayType >

VectorizedArrayType MeltPoolDG::mask_function	(	const MaskFunctionType	mask_function_type,
		const dealii::Point< dim, VectorizedArrayType > &	location,
		const DEMParticleAccessor< dim, number > &	particle
	)

matrix_matrix_product()

template<int a, int b, int c, typename number >

dealii::Tensor< 1, a, dealii::Tensor< 1, c, number > > MeltPoolDG::matrix_matrix_product	(	const dealii::Tensor< 1, a, dealii::Tensor< 1, b, number > > &	matrix1,
		const dealii::Tensor< 1, b, dealii::Tensor< 1, c, number > > &	matrix2
	)

matrix_vector_product()

template<int n_rows, int n_columns, typename number >

dealii::Tensor< 1, n_rows, number > MeltPoolDG::matrix_vector_product	(	const dealii::Tensor< 1, n_rows, dealii::Tensor< 1, n_columns, number > > &	matrix,
		const dealii::Tensor< 1, n_columns, number > &	vector
	)

Helper functions for matrix-vector and matrix-matrix computations when both matrix and vector are implemented as Tensor.

normalize() [1/2]

template<int dim, typename number >

dealii::Tensor< 1, dim, dealii::VectorizedArray< number > > MeltPoolDG::normalize	(	const dealii::Tensor< 1, dim, dealii::VectorizedArray< number > > &	in,
		const number	zero = 1e-16
	)

normalize() [2/2]

template<int dim, typename number >

dealii::Tensor< 1, dim, dealii::VectorizedArray< number > > MeltPoolDG::normalize	(	const dealii::VectorizedArray< number > &	in,
		const number	zero = 1e-16
	)

read_particle_state_input_file()

template<int dim, typename number >

std::pair< std::vector< dealii::Point< dim, number > >, std::vector< std::vector< number > > > MeltPoolDG::read_particle_state_input_file	(	const std::string &	filename,
		const MPI_Comm &	mpi_communicator
	)

Reads particle initial conditions (position, density, radius) from a CSV file and computes the derived properties (volume, mass, moment of inertia) of each resulting spherical particle.

The file must contain one header line, followed by one line per particle with dim + 2 comma-separated values: the particle's position, density, and radius, in that order. Blank lines are skipped; any line with the wrong number of fields, or a field that cannot be parsed as a number, aborts execution with a message identifying the offending line.

Parameters

filename	Path to the particle data file. This must be an absolute path or a path relative to the current working directory of the process.
mpi_communicator	MPI communicator of the simulation.

Returns

The parsed particle locations and their property vectors.

Note

Only rank 0 reads and parses the file; other ranks receive empty vectors.

run_simulation()

template<typename ParametersType , template< int, typename > class CaseType, template< int, typename > class ApplicationType>

void MeltPoolDG::run_simulation	(	const std::string &	parameter_file,
		const MPI_Comm	mpi_communicator
	)

scalar_product() [1/2]

template<typename number , std::size_t N>

dealii::VectorizedArray< number, N > MeltPoolDG::scalar_product	(	const dealii::Tensor< 1, 1, dealii::VectorizedArray< number, N > > &	vec,
		const dealii::VectorizedArray< number, N > &	scalar
	)

scalar_product() [2/2]

template<typename number , std::size_t N>

dealii::VectorizedArray< number, N > MeltPoolDG::scalar_product	(	const dealii::VectorizedArray< number, N > &	scalar,
		const dealii::Tensor< 1, 1, dealii::VectorizedArray< number, N > > &	vec
	)

setup_fluid_structure_interaction()

template<int dim, typename number , typename ObstacleType >

std::tuple< std::shared_ptr< CompressibleFlow::ExternalFlowForce< dim, number > >, std::shared_ptr< CompressibleFlow::ExternalFlowForceJacobian< dim, number > >, std::unique_ptr< ObstacleLoad< dim, number, ObstacleType > > > MeltPoolDG::setup_fluid_structure_interaction	(	const FluidStructureInteractionData< number > &	fsi_data,
		ObstacleField< dim, number, ObstacleType > &	obstacle_field,
		const CompressibleFlow::MaterialPhaseData< number > &	flow_material,
		const dealii::LinearAlgebra::distributed::Vector< number > &	flow_solution,
		const MatrixFreeContext< dim, number >	flow_mf_context,
		const std::shared_ptr< MatrixFreeCellBatchParticleCache< dim, number, ObstacleType > > &	cell_cache = nullptr
	)

symplectic_euler_advance_time_step()

template<int dim, typename number , typename ObstacleType , typename ContainerType >
requires std::ranges::range<ContainerType>

and std::same_as< std::ranges::range_value_t< ContainerType >, DEMParticleAccessor< dim, number > > void MeltPoolDG::symplectic_euler_advance_time_step	(	const number	time_step,
		ContainerType	particle_range
	)

Advances particle states by one time step using the symplectic Euler scheme.

Updates translational and angular velocities and positions in place according to the symplectic (semi-implicit) Euler integration method:

\[ \mathbf{v}^{(n+1)} &= \mathbf{v}^{(n)} + \Delta t \mathbf{a}^{(n)},\\ \mathbf{x}^{(n+1)} &= \mathbf{x}^{(n)} + \Delta t \mathbf{v}^{(n+1)},\\ \boldsymbol{\omega}^{(n+1)} &= \boldsymbol{\omega}^{(n)} + \Delta t \boldsymbol{\alpha}^{(n)}. \]

where:

• \(\mathbf{x}\) is the particle position (location)
• \(\mathbf{v}\) is the translational velocity (translational_velocity)
• \(\mathbf{a}\) is the translational acceleration (translational_acceleration)
• \(\boldsymbol{\omega}\) is the angular velocity (angular_velocity)
• \(\boldsymbol{\alpha}\) is the angular acceleration (angular_acceleration)
• \(\Delta t\) is the time step size (time_step)
• superscripts \((n)\), \((n+1)\) denote the current and next points in time

At the end of the update, all particles in the provided particle range, i.e. location, translational_velocity, and so on have the value at the new time step. This includes the ghost values which are updated internally.

Parameters

time_step	Time step size.
particle_range	Range of particles to update.

trace() [1/2]

template<int dim, typename number >

number MeltPoolDG::trace

(

const dealii::Tensor< 1, dim, dealii::Tensor< 1, dim, number > > &

in

)

Return the trace of a dealii::Tensor<dealii::Tensor>

trace() [2/2]

template<int dim, typename number >

number MeltPoolDG::trace

(

const dealii::Tensor< 2, dim, number > &

in

)

transpose()

template<int T1_dim, int T2_dim, typename number >

dealii::Tensor< 1, T2_dim, dealii::Tensor< 1, T1_dim, number > > MeltPoolDG::transpose

(

const dealii::Tensor< 1, T1_dim, dealii::Tensor< 1, T2_dim, number > > &

in

)

Return the transpose of a dealii::Tensor<dealii::Tensor>

vector_to_center_of_gravity()

template<int dim, typename number , typename VectorizedArrayType >

dealii::Tensor< 1, dim, VectorizedArrayType > MeltPoolDG::vector_to_center_of_gravity	(	const DEMParticleAccessor< dim, number > &	particle,
		const dealii::Point< dim, VectorizedArrayType > &	location
	)

Variable Documentation

axial_dim

template<int dim>

constexpr int MeltPoolDG::axial_dim

inlineconstexpr

Initial value:

= [] {
    if constexpr (dim == 3)
      return 3;
    else
      return 1;
  }()

Spatial dimension of an axial quantity in a dim-dimensional space. This can be used, for example, as the size of torque, angular velocity, or other axial/pseudo-vector quantities.

Note

dim = 1 is allowed for compatibility or generic code, although from a physical perspective it does not make sense.

CG

MeltPoolDG::CG

char

MeltPoolDG::char

constant

MeltPoolDG::constant

Uniform latent heat distribution across the mushy zone.

mushy_zone

MeltPoolDG::mushy_zone

poly4_bell

MeltPoolDG::poly4_bell

Smooth quartic bell-shaped distribution with compact support and continuous first derivative at the interval boundaries.