m_fstr_contact_elem_alag Module Reference

Alag method implementations for contact element calculations. More...

Functions/Subroutines
subroutine, public	getcontactstiffness_alag (cstate, tSurf, ele, mu, mut, fcoeff, symm, stiff, force, smoothing_type, edisp, iter, slvpos)
subroutine, public	get_unique_map (sSurf, maplist, master_idxs, unique_count)
subroutine, public	getintgap (slave_surf, master, coord, disp, ddisp, unique_count, maplist, master_idxs, Snode, Nsnode, gapwnode)
	Compute the per-node mortar constraint quantities of one slave segment. More...
subroutine, public	build_group_tangent_basis (n_hat, t1, t2)
	Build an orthonormal tangent basis (t1,t2) as the orthogonal complement of a group-representative slave inward normal n_hat (Householder / I - n(x)n). The master geometry is NOT used. More...
subroutine, public	gettangentslip (slave_surf, master, coord, disp, ddisp, unique_count, maplist, master_idxs, Sigma_node, nacc_node)
	Aggregate, per master group g and slave-surf node a of one mortar slave segment, the mortar-weighted 3D relative displacement and the slave-normal accumulator. More...
subroutine, public	group_return_mapping (lam_t_in, rho_t, Dxi, fcoeff, lam_n, eps_fric_band, lam_t_out, fric_state, alpha, that, update_state)
	Group-level Coulomb return mapping for the tangent multiplier (metric = I). More...
subroutine, public	resolve_lambda_cur (surf, master_idxs, unique_count, nnode_s, sorted_idx, lambda_node, lam_t_cur, fric_state_cur)
	Mortar: resolve the current per-node lambda of each active group of one slave surf. master_idxs is sorted ascending and merged against the ascending begin/working buffers with the rule: working hit -> working / else begin hit -> begin / else 0. More...
subroutine, public	getcontactstiffness_alag_surfsurf (slave_surf, master, coord, disp, ddisp, mu, mut, fcoeff, symm, eps_fric_band, unique_count, maplist, master_idxs, stiff_n, active_n, stiff_t, active_t)
	Mortar (SURF-SURF) ALag: contact stiffness of one slave segment. More...
subroutine, public	getcontactnodalforce_alag_surfsurf (purpose, slave_surf, master, coord, disp, ddisp, mu, mut, fcoeff, symm, eps_fric_band, unique_count, maplist, master_idxs, ctNForce, active_n, ctTForce, active_t)
	Mortar (SURF-SURF) ALag: contact nodal force of one slave segment. More...
subroutine, public	getcontactnodalforce_alag (ctState, tSurf, ndCoord, ndDu, mu, mut, fcoeff, symm, lagrange, ctNForce, ctTForce, cflag, smoothing_type)
subroutine, public	updatecontactmultiplier_alag (ctState, ndLocal, coord, disp, ddisp, mu, mut, fcoeff, tSurf, lgnt, ctchanged, ctNForce, ctTForce, jump_ratio, smoothing_type)
subroutine, public	gettiedstiffness_alag (cstate, tSurf, mu, stiff, force)
subroutine, public	gettiednodalforce_alag (ctState, tSurf, ndu, mu, ctNForce, ctTForce)

Detailed Description

Alag method implementations for contact element calculations.

Function/Subroutine Documentation

build_group_tangent_basis()

subroutine, public m_fstr_contact_elem_alag::build_group_tangent_basis	(	real(kind=kreal), dimension(3), intent(in)	n_hat,
		real(kind=kreal), dimension(3), intent(out)	t1,
		real(kind=kreal), dimension(3), intent(out)	t2
	)

Build an orthonormal tangent basis (t1,t2) as the orthogonal complement of a group-representative slave inward normal n_hat (Householder / I - n(x)n). The master geometry is NOT used.

Picks the smallest-magnitude Cartesian axis e_k, removes its normal part to form a seed, normalizes to t1, then t2 = n_hat x t1. The result is orthonormal so the tangent metric is the identity (no metric inverse machinery needed).

Parameters

[in]

n_hat

unit slave inward normal (already normalized)

Definition at line 308 of file fstr_contact_elem_alag.f90.

Here is the caller graph for this function:

get_unique_map()

subroutine, public m_fstr_contact_elem_alag::get_unique_map	(	type(tcontactsurf)	sSurf,
		integer(kind=kint), dimension(:), intent(out)	maplist,
		integer(kind=kint), dimension(:), intent(out)	master_idxs,
		integer(kind=kint), intent(out)	unique_count
	)

Parameters

	ssurf	surface element structure
[out]	master_idxs	IP->group / group->masterID, sized by the caller

Definition at line 175 of file fstr_contact_elem_alag.f90.

Here is the caller graph for this function:

getcontactnodalforce_alag()

subroutine, public m_fstr_contact_elem_alag::getcontactnodalforce_alag	(	type(tcontactstate)	ctState,
		type(tsurfelement)	tSurf,
		real(kind=kreal), dimension(:)	ndCoord,
		real(kind=kreal), dimension(:)	ndDu,
		real(kind=kreal), intent(in)	mu,
		real(kind=kreal), intent(in)	mut,
		real(kind=kreal)	fcoeff,
		logical, intent(in)	symm,
		real(kind=kreal)	lagrange,
		real(kind=kreal), dimension(:)	ctNForce,
		real(kind=kreal), dimension(:)	ctTForce,
		logical	cflag,
		integer(kind=kint), intent(in), optional	smoothing_type
	)

Parameters

	ctstate	type tContactState
	tsurf	surface element structure
[in]	mut	penalty parameters
	fcoeff	friction coefficient
[in]	symm	freeze the friction cone radius at the multiplier
	lagrange	not used for ALagrange (kept for interface compatibility)
	nddu	nodal coordinates (coord+disp+ddisp); nodal displacement increment (ddisp)
	ctnforce	contact normal force vector
	cttforce	contact tangential force vector
	cflag	not used for ALagrange (kept for interface compatibility)
[in]	smoothing_type	kcsNONE or kcsNAGATA

Definition at line 886 of file fstr_contact_elem_alag.f90.

Here is the call graph for this function:

Here is the caller graph for this function:

getcontactnodalforce_alag_surfsurf()

subroutine, public m_fstr_contact_elem_alag::getcontactnodalforce_alag_surfsurf	(	integer(kind=kint), intent(in)	purpose,
		type(tcontactsurf), intent(in)	slave_surf,
		type(tsurfelement), dimension(:), intent(in)	master,
		real(kind=kreal), dimension(:), intent(in)	coord,
		real(kind=kreal), dimension(:), intent(in)	disp,
		real(kind=kreal), dimension(:), intent(in)	ddisp,
		real(kind=kreal), intent(in)	mu,
		real(kind=kreal), intent(in)	mut,
		real(kind=kreal), intent(in)	fcoeff,
		logical, intent(in)	symm,
		real(kind=kreal), intent(in)	eps_fric_band,
		integer(kind=kint), intent(in)	unique_count,
		integer(kind=kint), dimension(:), intent(in)	maplist,
		integer(kind=kint), dimension(:), intent(in)	master_idxs,
		real(kind=kreal), dimension(:,:,:), intent(out)	ctNForce,
		logical, dimension(:,:), intent(out)	active_n,
		real(kind=kreal), dimension(:,:,:), intent(out), optional	ctTForce,
		logical, dimension(:,:), intent(out), optional	active_t
	)

Mortar (SURF-SURF) ALag: contact nodal force of one slave segment.

Builds the element force of every (slave-surf node a, master group g) constraint of one slave segment, in the same (a,g) layout as getContactStiffness_Alag_SurfSurf: ctNForce(:,a,g) : normal, -(lambda_node + mu*gapwnode) * Nsnode(g,a) for the residual, -lambda_node * Nsnode(g,a) for the output ctTForce(:,a,g) : friction, the traction of the per-node return mapping distributed through the per-node mortar weight Wbar(a,j) = Nsnode(g,a,j).nhat_a (kctForOutput keeps the frozen multiplier instead of the live trial) The force is signed as the residual contribution, so the caller only adds it up. active_n / active_t, the block ordering and the sizing of the outputs are as in getContactStiffness_Alag_SurfSurf.

Parameters

[in]	purpose	kctForResidual or kctForOutput
[in]	slave_surf	slave segment
[in]	master	master surface elements
[in]	coord	mesh coordinate
[in]	disp	disp till current step
[in]	ddisp	disp till current substep
[in]	mut	penalty parameters
[in]	fcoeff	friction coefficient
[in]	symm	symmetricalize (cone radius frozen at the multiplier)
[in]	eps_fric_band	hysteresis half-band of the return mapping
[in]	unique_count	number of master groups of this segment
[in]	maplist	integration point -> group
[in]	master_idxs	group -> master surface index
[out]	ctnforce	(24,node,group) normal force vector
[out]	active_n	(node,group) vector to assemble
[out]	cttforce	(24,node,group) friction force vector
[out]	active_t	(node,group) vector to assemble

Definition at line 754 of file fstr_contact_elem_alag.f90.

Here is the call graph for this function:

Here is the caller graph for this function:

getcontactstiffness_alag()

subroutine, public m_fstr_contact_elem_alag::getcontactstiffness_alag	(	type(tcontactstate), intent(inout)	cstate,
		type(tsurfelement), intent(in)	tSurf,
		real(kind=kreal), dimension(:,:), intent(in)	ele,
		real(kind=kreal), intent(in)	mu,
		real(kind=kreal), intent(in)	mut,
		real(kind=kreal), intent(in)	fcoeff,
		logical, intent(in)	symm,
		real(kind=kreal), dimension(:,:), intent(out)	stiff,
		real(kind=kreal), dimension(:), intent(out)	force,
		integer(kind=kint), intent(in), optional	smoothing_type,
		real(kind=kreal), dimension(:), intent(in), optional	edisp,
		integer(kind=kint), intent(in)	iter,
		real(kind=kreal), dimension(3), intent(in)	slvpos
	)

Parameters

[in,out]	cstate	contact state (inout for projection info)
[in]	tsurf	surface element structure
[in]	ele	coord of surface element
[in]	mut	penalty parameters
[in]	fcoeff	friction coefficient
[in]	symm	freeze the friction cone radius at the multiplier
[out]	stiff	contact stiffness
[out]	force	contact force direction
[in]	smoothing_type	kcsNONE or kcsNAGATA
[in]	edisp	displacement increment for friction evaluation
[in]	iter	NR iteration number (for tangent switching)
[in]	slvpos	slave node position (coord+disp)

Definition at line 32 of file fstr_contact_elem_alag.f90.

Here is the call graph for this function:

Here is the caller graph for this function:

getcontactstiffness_alag_surfsurf()

subroutine, public m_fstr_contact_elem_alag::getcontactstiffness_alag_surfsurf	(	type(tcontactsurf), intent(in)	slave_surf,
		type(tsurfelement), dimension(:), intent(in)	master,
		real(kind=kreal), dimension(:), intent(in)	coord,
		real(kind=kreal), dimension(:), intent(in)	disp,
		real(kind=kreal), dimension(:), intent(in)	ddisp,
		real(kind=kreal), intent(in)	mu,
		real(kind=kreal), intent(in)	mut,
		real(kind=kreal), intent(in)	fcoeff,
		logical, intent(in)	symm,
		real(kind=kreal), intent(in)	eps_fric_band,
		integer(kind=kint), intent(in)	unique_count,
		integer(kind=kint), dimension(:), intent(in)	maplist,
		integer(kind=kint), dimension(:), intent(in)	master_idxs,
		real(kind=kreal), dimension(:,:,:,:), intent(out)	stiff_n,
		logical, dimension(:,:), intent(out)	active_n,
		real(kind=kreal), dimension(:,:,:,:), intent(out), optional	stiff_t,
		logical, dimension(:,:), intent(out), optional	active_t
	)

Mortar (SURF-SURF) ALag: contact stiffness of one slave segment.

Builds the element stiffness of every (slave-surf node a, master group g) constraint of one slave segment and hands the blocks to the caller: stiff_n(:,:,a,g) : normal, mu * Snode(g,a) * Nsnode(g,a) (x) Nsnode(g,a) stiff_t(:,:,a,g) : friction, the consistent tangent of the per-node return mapping (plus the coupling block of a cone radius following the normal force) active_n / active_t mark the blocks that take part; an inactive block is not computed and stays zero. A block is ordered like the element vector [slave-surf nodes | master nodes of group g], so the caller builds ndLocal from master_idxs(g) and assembles the block as it stands. Normal and friction are kept apart because the caller assembles them in two passes. The caller sizes the blocks with the unique_count of get_unique_map and passes the friction pair only when fcoeff /= 0.

Parameters

[in]	slave_surf	slave segment
[in]	master	master surface elements
[in]	coord	mesh coordinate
[in]	disp	disp till current step
[in]	ddisp	disp till current substep
[in]	mut	penalty parameters
[in]	fcoeff	friction coefficient
[in]	symm	symmetricalize (cone radius frozen at the multiplier)
[in]	eps_fric_band	hysteresis half-band of the return mapping
[in]	unique_count	number of master groups of this segment
[in]	maplist	integration point -> group
[in]	master_idxs	group -> master surface index
[out]	stiff_n	(24,24,node,group) normal stiffness
[out]	active_n	(node,group) block to assemble
[out]	stiff_t	(24,24,node,group) friction stiffness
[out]	active_t	(node,group) block to assemble

Definition at line 577 of file fstr_contact_elem_alag.f90.

Here is the call graph for this function:

Here is the caller graph for this function:

getintgap()

subroutine, public m_fstr_contact_elem_alag::getintgap	(	type(tcontactsurf)	slave_surf,
		type(tsurfelement), dimension(:)	master,
		real(kind=kreal), dimension(:), intent(in)	coord,
		real(kind=kreal), dimension(:), intent(in)	disp,
		real(kind=kreal), dimension(:), intent(in)	ddisp,
		integer(kind=kint), intent(in)	unique_count,
		integer(kind=kint), dimension(:), intent(in)	maplist,
		integer(kind=kint), dimension(:), intent(in)	master_idxs,
		real(kind=kreal), dimension(:,:), intent(out)	Snode,
		real(kind=kreal), dimension(:,:,:), intent(out)	Nsnode,
		real(kind=kreal), dimension(:,:), intent(out)	gapwnode
	)

Compute the per-node mortar constraint quantities of one slave segment.

The caller passes the unique_count/maplist/master_idxs of get_unique_map and sizes the outputs with them. For each group g and each slave-surf node a, it returns the decomposition that drives the residual/stiffness/augmentation: Snode(g,a) = sum_{IP in g} N_s(a) * weight (node tributary area) ANnode(g,a,:) = sum_{IP in g} N_s(a) * [N_s(b)|-N_m(k)] * weight*dir (per-node constraint accumulator) Nsnode(g,a,:) = ANnode(g,a,:) / Snode(g,a) (per-node averaged constraint grad) gapwnode(g,a) = ANnode(g,a,:) . curr_pos (per-node weighted gap) Summing over a re-collapses the group totals on a flat, uniform contact; on curved geometry they differ (one constraint per slave node).

Parameters

[out]

gapwnode

(g,a) / (g,a,24) per node in group

Definition at line 222 of file fstr_contact_elem_alag.f90.

Here is the call graph for this function:

Here is the caller graph for this function:

gettangentslip()

subroutine, public m_fstr_contact_elem_alag::gettangentslip	(	type(tcontactsurf)	slave_surf,
		type(tsurfelement), dimension(:)	master,
		real(kind=kreal), dimension(:), intent(in)	coord,
		real(kind=kreal), dimension(:), intent(in)	disp,
		real(kind=kreal), dimension(:), intent(in)	ddisp,
		integer(kind=kint), intent(in)	unique_count,
		integer(kind=kint), dimension(:), intent(in)	maplist,
		integer(kind=kint), dimension(:), intent(in)	master_idxs,
		real(kind=kreal), dimension(:,:,:), intent(out)	Sigma_node,
		real(kind=kreal), dimension(:,:,:), intent(out)	nacc_node
	)

Aggregate, per master group g and slave-surf node a of one mortar slave segment, the mortar-weighted 3D relative displacement and the slave-normal accumulator.

Mirrors getIntGap's per-IP loop (same weights, shape functions and direction field) but accumulates the mortar relative displacement du_rel(IP) = N_s . (slave ddisp) - N_m . (master ddisp). The caller passes the maplist/master_idxs/unique_count from getIntGap so the group->IP mapping matches. Each IP slip/normal is distributed to slave node a via shapefunc_s(a), so the caller can build a per-node frame, Dxi and cone radius. Outputs per group g and node a: Sigma_node(g,a,:) = sum_IP N_s(a) * weight * du_rel(IP) (per-node mortar slip) nacc_node(g,a,:) = sum_IP N_s(a) * weight * direction (per-node slave normal)

Parameters

[out]	sigma_node	(unique_count,nnode_s,3) per-node weighted 3D relative disp
[out]	nacc_node	(unique_count,nnode_s,3) per-node weighted slave normal

Definition at line 344 of file fstr_contact_elem_alag.f90.

Here is the call graph for this function:

Here is the caller graph for this function:

gettiednodalforce_alag()

subroutine, public m_fstr_contact_elem_alag::gettiednodalforce_alag	(	type(tcontactstate)	ctState,
		type(tsurfelement)	tSurf,
		real(kind=kreal), dimension(:)	ndu,
		real(kind=kreal), intent(in)	mu,
		real(kind=kreal), dimension(:)	ctNForce,
		real(kind=kreal), dimension(:)	ctTForce
	)

Parameters

	ctstate	type tContactState
	tsurf	surface element structure
	ndu	nodal total displacement (disp+ddisp)
[in]	mu	penalty parameter
	ctnforce	contact force vector
	cttforce	contact force vector (not used for tied)

Definition at line 1083 of file fstr_contact_elem_alag.f90.

Here is the call graph for this function:

Here is the caller graph for this function:

gettiedstiffness_alag()

subroutine, public m_fstr_contact_elem_alag::gettiedstiffness_alag	(	type(tcontactstate), intent(in)	cstate,
		type(tsurfelement), intent(in)	tSurf,
		real(kind=kreal), intent(in)	mu,
		real(kind=kreal), dimension(:,:), intent(out)	stiff,
		real(kind=kreal), dimension(:), intent(out)	force
	)

Parameters

[in]	cstate	contact state
[in]	tsurf	surface element structure
[in]	mu	penalty parameter
[out]	stiff	contact stiffness
[out]	force	contact force direction

Definition at line 1053 of file fstr_contact_elem_alag.f90.

Here is the call graph for this function:

Here is the caller graph for this function:

group_return_mapping()

subroutine, public m_fstr_contact_elem_alag::group_return_mapping	(	real(kind=kreal), dimension(2), intent(in)	lam_t_in,
		real(kind=kreal), intent(in)	rho_t,
		real(kind=kreal), dimension(2), intent(in)	Dxi,
		real(kind=kreal), intent(in)	fcoeff,
		real(kind=kreal), intent(in)	lam_n,
		real(kind=kreal), intent(in)	eps_fric_band,
		real(kind=kreal), dimension(2), intent(out)	lam_t_out,
		integer(kind=kint), intent(inout)	fric_state,
		real(kind=kreal), intent(out)	alpha,
		real(kind=kreal), dimension(2), intent(out)	that,
		logical, intent(in), optional	update_state
	)

Group-level Coulomb return mapping for the tangent multiplier (metric = I).

Same 2D return mapping as computeFrictionForce_ALag, on the orthonormal basis (metric = I): trial = lam_t_in + rho_t*Dxi, radius = fcoeff*lam_n ||trial|| <= radius -> STICK (lam_t_out = trial), else SLIP (projected onto the cone). lam_n <= 0 gives lam_t_out = 0 with the state kept. that(2) (= trial/||trial||) is returned for the slip-tangent stiffness.

Parameters

[in]	lam_t_in	incoming (warm-start) tangent multiplier, group frame
[in]	rho_t	tangential penalty rho_t = tPenalty*refStiff
[in]	dxi	group-frame slip increment (area-integrated)
[in]	fcoeff	friction coefficient
[in]	lam_n	group normal multiplier (area-integrated)
[in]	eps_fric_band	hysteresis half-band (0 = no band = legacy behavior)
[out]	lam_t_out	updated tangent multiplier, group frame
[in,out]	fric_state	CONTACTSTICK/CONTACTSLIP (updated only when update_state)
[out]	alpha	projection ratio (for the tangent stiffness)
[out]	that	trial/||trial|| (for the tangent stiffness)
[in]	update_state	.true. at the augmentation commits the state; .false. (default) reads it

Definition at line 413 of file fstr_contact_elem_alag.f90.

Here is the caller graph for this function:

resolve_lambda_cur()

subroutine, public m_fstr_contact_elem_alag::resolve_lambda_cur	(	type(tcontactsurf), intent(in)	surf,
		integer(kind=kint), dimension(:), intent(in)	master_idxs,
		integer(kind=kint), intent(in)	unique_count,
		integer(kind=kint), intent(in)	nnode_s,
		integer(kind=kint), dimension(:), intent(out)	sorted_idx,
		real(kind=kreal), dimension(:,:), intent(out)	lambda_node,
		real(kind=kreal), dimension(:,:,:), intent(out), optional	lam_t_cur,
		integer(kind=kint), dimension(:,:), intent(out), optional	fric_state_cur
	)

Mortar: resolve the current per-node lambda of each active group of one slave surf. master_idxs is sorted ascending and merged against the ascending begin/working buffers with the rule: working hit -> working / else begin hit -> begin / else 0.

Parameters

[in]	master_idxs	group->masterID (get_unique_map output, unsorted)
[in]	nnode_s	number of slave-surf nodes
[out]	sorted_idx	ascending rank r -> original group g
[out]	lambda_node	(nnode_s, unique_count) per-node current lambda_n
[out]	lam_t_cur	(2, nnode_s, unique_count) per-node tangent multiplier
[out]	fric_state_cur	(nnode_s, unique_count) per-node friction state

Definition at line 503 of file fstr_contact_elem_alag.f90.

Here is the caller graph for this function:

updatecontactmultiplier_alag()

subroutine, public m_fstr_contact_elem_alag::updatecontactmultiplier_alag	(	type(tcontactstate), intent(inout)	ctState,
		integer(kind=kint), dimension(:), intent(in)	ndLocal,
		real(kind=kreal), dimension(:), intent(in)	coord,
		real(kind=kreal), dimension(:), intent(in)	disp,
		real(kind=kreal), dimension(:), intent(in)	ddisp,
		real(kind=kreal), intent(in)	mu,
		real(kind=kreal), intent(in)	mut,
		real(kind=kreal), intent(in)	fcoeff,
		type(tsurfelement), intent(in)	tSurf,
		real(kind=kreal), dimension(2), intent(inout)	lgnt,
		logical, intent(inout)	ctchanged,
		real(kind=kreal), dimension(:), intent(out)	ctNForce,
		real(kind=kreal), dimension(:), intent(out)	ctTForce,
		real(kind=kreal), intent(out)	jump_ratio,
		integer(kind=kint), intent(in), optional	smoothing_type
	)

Parameters

[in,out]	ctstate	contact state
[in]	ndlocal	global node numbers (slave + master)
[in]	coord	mesh coordinate
[in]	disp	disp till current step
[in]	ddisp	disp till current substep
[in]	mut	penalty parameters
[in]	fcoeff	friction coefficient
[in]	tsurf	surface element structure (with vertex_normals for Nagata)
[in,out]	lgnt	convergence metrics
[in,out]	ctchanged	contact state changed flag
[out]	ctnforce	contact normal force vector
[out]	cttforce	contact tangential force vector
[out]	jump_ratio	stick trial / slip limit force ratio
[in]	smoothing_type	kcsNONE or kcsNAGATA

Definition at line 970 of file fstr_contact_elem_alag.f90.

Here is the call graph for this function:

Here is the caller graph for this function: