https://mooseframework.inl.gov: Assembly Class Reference

VariablePhiGradient _grad_phi

Definition: Assembly.h:2664

◆ gradPhi() [2/6]

const VariablePhiGradient& Assembly::gradPhi ( const MooseVariableField< Real > & ) const

inline

Definition at line 1288 of file Assembly.h.

1288 { return _grad_phi; }

VariablePhiGradient _grad_phi

Definition: Assembly.h:2664

◆ gradPhi() [3/6]

const VectorVariablePhiGradient& Assembly::gradPhi ( const MooseVariableField< RealVectorValue > & ) const

inline

Definition at line 1337 of file Assembly.h.

   {
     return _vector_grad_phi;
   }

◆ gradPhi() [4/6]

VariablePhiGradient& Assembly::gradPhi ( const MooseVariableField< Real > & )

inline

Definition at line 1426 of file Assembly.h.

1426 { return _grad_phi; }

VariablePhiGradient _grad_phi

Definition: Assembly.h:2664

◆ gradPhi() [5/6]

VectorVariablePhiGradient& Assembly::gradPhi ( const MooseVariableField< RealVectorValue > & )

inline

Definition at line 1458 of file Assembly.h.

   {
     return _vector_grad_phi;
   }

◆ gradPhi() [6/6]

VariablePhiGradient& Assembly::gradPhi ( const MooseVariableField< RealEigenVector > & )

inline

Definition at line 1539 of file Assembly.h.

1539 { return _grad_phi; }

Assembly::_current_JxW_face

VariablePhiGradient _grad_phi

Definition: Assembly.h:2664

◆ gradPhiFace() [1/6]

const VariablePhiGradient& Assembly::gradPhiFace ( ) const

inline

Definition at line 1297 of file Assembly.h.

Referenced by copyFaceShapes().

1297 { return _grad_phi_face; }

Assembly::_grad_phi_face

VariablePhiGradient _grad_phi_face

Definition: Assembly.h:2668

◆ gradPhiFace() [2/6]

const VariablePhiGradient& Assembly::gradPhiFace ( const MooseVariableField< Real > & ) const

inline

Definition at line 1298 of file Assembly.h.

   {
     return _grad_phi_face;
   }

◆ gradPhiFace() [3/6]

const VectorVariablePhiGradient& Assembly::gradPhiFace ( const MooseVariableField< RealVectorValue > & ) const

inline

Definition at line 1358 of file Assembly.h.

   {
     return _vector_grad_phi_face;
   }

◆ gradPhiFace() [4/6]

VariablePhiGradient& Assembly::gradPhiFace ( const MooseVariableField< Real > & )

inline

Definition at line 1430 of file Assembly.h.

1430 { return _grad_phi_face; }

Assembly::_grad_phi_face

VariablePhiGradient _grad_phi_face

Definition: Assembly.h:2668

◆ gradPhiFace() [5/6]

VectorVariablePhiGradient& Assembly::gradPhiFace ( const MooseVariableField< RealVectorValue > & )

inline

Definition at line 1479 of file Assembly.h.

   {
     return _vector_grad_phi_face;
   }

◆ gradPhiFace() [6/6]

VariablePhiGradient& Assembly::gradPhiFace ( const MooseVariableField< RealEigenVector > & )

inline

Definition at line 1543 of file Assembly.h.

   {
     return _grad_phi_face;
   }

◆ gradPhiFaceNeighbor() [1/5]

const VariablePhiGradient& Assembly::gradPhiFaceNeighbor ( const MooseVariableField< Real > & ) const

inline

Definition at line 1324 of file Assembly.h.

Referenced by copyNeighborShapes().

   {
     return _grad_phi_face_neighbor;
   }

◆ gradPhiFaceNeighbor() [2/5]

const VectorVariablePhiGradient& Assembly::gradPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > & ) const

inline

Definition at line 1404 of file Assembly.h.

   {
     return _vector_grad_phi_face_neighbor;
   }

◆ gradPhiFaceNeighbor() [3/5]

VariablePhiGradient& Assembly::gradPhiFaceNeighbor ( const MooseVariableField< Real > & )

inline

Definition at line 1447 of file Assembly.h.

   {
     return _grad_phi_face_neighbor;
   }

◆ gradPhiFaceNeighbor() [4/5]

VectorVariablePhiGradient& Assembly::gradPhiFaceNeighbor ( const MooseVariableField< RealVectorValue > & )

inline

Definition at line 1520 of file Assembly.h.

   {
     return _vector_grad_phi_face_neighbor;
   }

◆ gradPhiFaceNeighbor() [5/5]

VariablePhiGradient& Assembly::gradPhiFaceNeighbor ( const MooseVariableField< RealEigenVector > & )

inline

Definition at line 1569 of file Assembly.h.

   {
     return _grad_phi_face_neighbor;
   }

◆ gradPhiNeighbor() [1/5]

const VariablePhiGradient& Assembly::gradPhiNeighbor ( const MooseVariableField< Real > & ) const

inline

Definition at line 1311 of file Assembly.h.

Referenced by copyNeighborShapes().

   {
     return _grad_phi_neighbor;
   }

◆ gradPhiNeighbor() [2/5]

const VectorVariablePhiGradient& Assembly::gradPhiNeighbor ( const MooseVariableField< RealVectorValue > & ) const

inline

Definition at line 1380 of file Assembly.h.

   {
     return _vector_grad_phi_neighbor;
   }

◆ gradPhiNeighbor() [3/5]

VariablePhiGradient& Assembly::gradPhiNeighbor ( const MooseVariableField< Real > & )

inline

Definition at line 1434 of file Assembly.h.

   {
     return _grad_phi_neighbor;
   }

◆ gradPhiNeighbor() [4/5]

VectorVariablePhiGradient& Assembly::gradPhiNeighbor ( const MooseVariableField< RealVectorValue > & )

inline

Definition at line 1500 of file Assembly.h.

   {
     return _vector_grad_phi_neighbor;
   }

◆ gradPhiNeighbor() [5/5]

VariablePhiGradient& Assembly::gradPhiNeighbor ( const MooseVariableField< RealEigenVector > & )

inline

Definition at line 1556 of file Assembly.h.

   {
     return _grad_phi_neighbor;
   }

◆ hasScalingVector()

void Assembly::hasScalingVector ( )

signals this object that a vector containing variable scaling factors should be used when doing residual and matrix assembly

Definition at line 4574 of file Assembly.C.

Referenced by SubProblem::hasScalingVector().

 {
   _scaling_vector = &_sys.getVector("scaling_factors");
 }

◆ havePRefinement()

void Assembly::havePRefinement ( const std::unordered_set< FEFamily > & disable_p_refinement_for_families )

Indicate that we have p-refinement.

This method will perform the following tasks:

Disable p-refinement as requested by the user with disable_p_refinement_for_families -.Disable p-refinement of Lagrange helper types that we use for getting things like the physical locations of quadrature points and JxW. (Don't worry, we still use the element p-level when initializing the quadrature rule attached to the Lagrange helper so the number of quadrature points reflects the element p-level)
Parameters

disable_p_refinement_for_families Families that we should disable p-refinement for

Definition at line 4859 of file Assembly.C.

Referenced by SubProblem::preparePRefinement().

 {
   if (_have_p_refinement)
     // Already performed tasks for p-refinement
     return;
 
   const Order helper_order = _mesh.hasSecondOrderElements() ? SECOND : FIRST;
   const FEType helper_type(helper_order, LAGRANGE);
   auto process_fe =
       [&disable_families](const unsigned int num_dimensionalities, auto & fe_container)
   {
     if (!disable_families.empty())
       for (const auto dim : make_range(num_dimensionalities))
       {
         auto fe_container_it = fe_container.find(dim);
         if (fe_container_it != fe_container.end())
           for (auto & [fe_type, fe_ptr] : fe_container_it->second)
             if (disable_families.count(fe_type.family))
               fe_ptr->add_p_level_in_reinit(false);
       }
   };
   auto process_fe_and_helpers = [process_fe, &helper_type](auto & unique_helper_container,
                                                            auto & helper_container,
                                                            const unsigned int num_dimensionalities,
                                                            const bool user_added_helper_type,
                                                            auto & fe_container)
   {
     unique_helper_container.resize(num_dimensionalities);
     for (const auto dim : make_range(num_dimensionalities))
     {
       auto & unique_helper = unique_helper_container[dim];
       unique_helper = FEGenericBase<Real>::build(dim, helper_type);
       // don't participate in p-refinement
       unique_helper->add_p_level_in_reinit(false);
       helper_container[dim] = unique_helper.get();
 
       // If the user did not request the helper type then we should erase it from our FE container
       // so that they're not penalized (in the "we should be able to do p-refinement sense") for
       // our perhaps silly helpers
       if (!user_added_helper_type)
       {
         auto & fe_container_dim = libmesh_map_find(fe_container, dim);
         auto fe_it = fe_container_dim.find(helper_type);
         mooseAssert(fe_it != fe_container_dim.end(), "We should have the helper type");
         delete fe_it->second;
         fe_container_dim.erase(fe_it);
       }
     }
 
     process_fe(num_dimensionalities, fe_container);
   };
 
   // Handle scalar field families
   process_fe_and_helpers(_unique_fe_helper,
                          _holder_fe_helper,
                          _mesh_dimension + 1,
                          _user_added_fe_of_helper_type,
                          _fe);
   process_fe_and_helpers(_unique_fe_face_helper,
                          _holder_fe_face_helper,
                          _mesh_dimension + 1,
                          _user_added_fe_face_of_helper_type,
                          _fe_face);
   process_fe_and_helpers(_unique_fe_face_neighbor_helper,
                          _holder_fe_face_neighbor_helper,
                          _mesh_dimension + 1,
                          _user_added_fe_face_neighbor_of_helper_type,
                          _fe_face_neighbor);
   process_fe_and_helpers(_unique_fe_neighbor_helper,
                          _holder_fe_neighbor_helper,
                          _mesh_dimension + 1,
                          _user_added_fe_neighbor_of_helper_type,
                          _fe_neighbor);
   process_fe_and_helpers(_unique_fe_lower_helper,
                          _holder_fe_lower_helper,
                          _mesh_dimension,
                          _user_added_fe_lower_of_helper_type,
                          _fe_lower);
   // Handle vector field families
   process_fe(_mesh_dimension + 1, _vector_fe);
   process_fe(_mesh_dimension + 1, _vector_fe_face);
   process_fe(_mesh_dimension + 1, _vector_fe_neighbor);
   process_fe(_mesh_dimension + 1, _vector_fe_face_neighbor);
   process_fe(_mesh_dimension, _vector_fe_lower);
 
   helpersRequestData();
 
   _have_p_refinement = true;
 }

◆ helpersRequestData()

void Assembly::helpersRequestData ( )

private

request phi, dphi, xyz, JxW, etc.

data through the FE helper functions

Definition at line 4826 of file Assembly.C.

Referenced by Assembly(), and havePRefinement().

 {
   for (unsigned int dim = 0; dim <= _mesh_dimension; dim++)
   {
     _holder_fe_helper[dim]->get_phi();
     _holder_fe_helper[dim]->get_dphi();
     _holder_fe_helper[dim]->get_xyz();
     _holder_fe_helper[dim]->get_JxW();
 
     _holder_fe_face_helper[dim]->get_phi();
     _holder_fe_face_helper[dim]->get_dphi();
     _holder_fe_face_helper[dim]->get_xyz();
     _holder_fe_face_helper[dim]->get_JxW();
     _holder_fe_face_helper[dim]->get_normals();
 
     _holder_fe_face_neighbor_helper[dim]->get_xyz();
     _holder_fe_face_neighbor_helper[dim]->get_JxW();
     _holder_fe_face_neighbor_helper[dim]->get_normals();
 
     _holder_fe_neighbor_helper[dim]->get_xyz();
     _holder_fe_neighbor_helper[dim]->get_JxW();
   }
 
   for (unsigned int dim = 0; dim < _mesh_dimension; dim++)
   {
     // We need these computations in order to compute correct lower-d element volumes in
     // curvilinear coordinates
     _holder_fe_lower_helper[dim]->get_xyz();
     _holder_fe_lower_helper[dim]->get_JxW();
   }
 }

◆ init()

void Assembly::init ( const libMesh::CouplingMatrix * cm )

Initialize the Assembly object and set the CouplingMatrix for use throughout.

Definition at line 2465 of file Assembly.C.

 {
   _cm = cm;
 
   unsigned int n_vars = _sys.nVariables();
 
   _cm_ss_entry.clear();
   _cm_sf_entry.clear();
   _cm_fs_entry.clear();
   _cm_ff_entry.clear();
 
   auto & vars = _sys.getVariables(_tid);
 
   _block_diagonal_matrix = true;
   for (auto & ivar : vars)
   {
     auto i = ivar->number();
     if (i >= _component_block_diagonal.size())
       _component_block_diagonal.resize(i + 1, true);
 
     auto ivar_start = _cm_ff_entry.size();
     for (unsigned int k = 0; k < ivar->count(); ++k)
     {
       unsigned int iv = i + k;
       for (const auto & j : ConstCouplingRow(iv, *_cm))
       {
         if (_sys.isScalarVariable(j))
         {
           auto & jvar = _sys.getScalarVariable(_tid, j);
           _cm_fs_entry.push_back(std::make_pair(ivar, &jvar));
           _block_diagonal_matrix = false;
         }
         else
         {
           auto & jvar = _sys.getVariable(_tid, j);
           auto pair = std::make_pair(ivar, &jvar);
           auto c = ivar_start;
           // check if the pair has been pushed or not
           bool has_pair = false;
           for (; c < _cm_ff_entry.size(); ++c)
             if (_cm_ff_entry[c] == pair)
             {
               has_pair = true;
               break;
             }
           if (!has_pair)
             _cm_ff_entry.push_back(pair);
           // only set having diagonal matrix to false when ivar and jvar numbers are different
           // Note: for array variables, since we save the entire local Jacobian of all components,
           //       even there are couplings among components of the same array variable, we still
           //       do not set the flag to false.
           if (i != jvar.number())
             _block_diagonal_matrix = false;
           else if (iv != j)
             _component_block_diagonal[i] = false;
         }
       }
     }
   }
 
   auto & scalar_vars = _sys.getScalarVariables(_tid);
 
   for (auto & ivar : scalar_vars)
   {
     auto i = ivar->number();
     if (i >= _component_block_diagonal.size())
       _component_block_diagonal.resize(i + 1, true);
 
     for (const auto & j : ConstCouplingRow(i, *_cm))
       if (_sys.isScalarVariable(j))
       {
         auto & jvar = _sys.getScalarVariable(_tid, j);
         _cm_ss_entry.push_back(std::make_pair(ivar, &jvar));
       }
       else
       {
         auto & jvar = _sys.getVariable(_tid, j);
         _cm_sf_entry.push_back(std::make_pair(ivar, &jvar));
       }
   }
 
   if (_block_diagonal_matrix && scalar_vars.size() != 0)
     _block_diagonal_matrix = false;
 
   auto num_vector_tags = _residual_vector_tags.size();
 
   _sub_Re.resize(num_vector_tags);
   _sub_Rn.resize(num_vector_tags);
   _sub_Rl.resize(num_vector_tags);
   for (MooseIndex(_sub_Re) i = 0; i < _sub_Re.size(); i++)
   {
     _sub_Re[i].resize(n_vars);
     _sub_Rn[i].resize(n_vars);
     _sub_Rl[i].resize(n_vars);
   }
 
   _cached_residual_values.resize(num_vector_tags);
   _cached_residual_rows.resize(num_vector_tags);
 
   auto num_matrix_tags = _subproblem.numMatrixTags();
 
   _cached_jacobian_values.resize(num_matrix_tags);
   _cached_jacobian_rows.resize(num_matrix_tags);
   _cached_jacobian_cols.resize(num_matrix_tags);
 
   // Element matrices
   _sub_Kee.resize(num_matrix_tags);
   _sub_Keg.resize(num_matrix_tags);
   _sub_Ken.resize(num_matrix_tags);
   _sub_Kne.resize(num_matrix_tags);
   _sub_Knn.resize(num_matrix_tags);
   _sub_Kll.resize(num_matrix_tags);
   _sub_Kle.resize(num_matrix_tags);
   _sub_Kln.resize(num_matrix_tags);
   _sub_Kel.resize(num_matrix_tags);
   _sub_Knl.resize(num_matrix_tags);
 
   _jacobian_block_used.resize(num_matrix_tags);
   _jacobian_block_neighbor_used.resize(num_matrix_tags);
   _jacobian_block_lower_used.resize(num_matrix_tags);
   _jacobian_block_nonlocal_used.resize(num_matrix_tags);
 
   for (MooseIndex(num_matrix_tags) tag = 0; tag < num_matrix_tags; tag++)
   {
     _sub_Keg[tag].resize(n_vars);
     _sub_Ken[tag].resize(n_vars);
     _sub_Kne[tag].resize(n_vars);
     _sub_Knn[tag].resize(n_vars);
     _sub_Kee[tag].resize(n_vars);
     _sub_Kll[tag].resize(n_vars);
     _sub_Kle[tag].resize(n_vars);
     _sub_Kln[tag].resize(n_vars);
     _sub_Kel[tag].resize(n_vars);
     _sub_Knl[tag].resize(n_vars);
 
     _jacobian_block_used[tag].resize(n_vars);
     _jacobian_block_neighbor_used[tag].resize(n_vars);
     _jacobian_block_lower_used[tag].resize(n_vars);
     _jacobian_block_nonlocal_used[tag].resize(n_vars);
     for (MooseIndex(n_vars) i = 0; i < n_vars; ++i)
     {
       if (!_block_diagonal_matrix)
       {
         _sub_Kee[tag][i].resize(n_vars);
         _sub_Keg[tag][i].resize(n_vars);
         _sub_Ken[tag][i].resize(n_vars);
         _sub_Kne[tag][i].resize(n_vars);
         _sub_Knn[tag][i].resize(n_vars);
         _sub_Kll[tag][i].resize(n_vars);
         _sub_Kle[tag][i].resize(n_vars);
         _sub_Kln[tag][i].resize(n_vars);
         _sub_Kel[tag][i].resize(n_vars);
         _sub_Knl[tag][i].resize(n_vars);
 
         _jacobian_block_used[tag][i].resize(n_vars);
         _jacobian_block_neighbor_used[tag][i].resize(n_vars);
         _jacobian_block_lower_used[tag][i].resize(n_vars);
         _jacobian_block_nonlocal_used[tag][i].resize(n_vars);
       }
       else
       {
         _sub_Kee[tag][i].resize(1);
         _sub_Keg[tag][i].resize(1);
         _sub_Ken[tag][i].resize(1);
         _sub_Kne[tag][i].resize(1);
         _sub_Knn[tag][i].resize(1);
         _sub_Kll[tag][i].resize(1);
         _sub_Kle[tag][i].resize(1);
         _sub_Kln[tag][i].resize(1);
         _sub_Kel[tag][i].resize(1);
         _sub_Knl[tag][i].resize(1);
 
         _jacobian_block_used[tag][i].resize(1);
         _jacobian_block_neighbor_used[tag][i].resize(1);
         _jacobian_block_lower_used[tag][i].resize(1);
         _jacobian_block_nonlocal_used[tag][i].resize(1);
       }
     }
   }
 }

◆ initNonlocalCoupling()

void Assembly::initNonlocalCoupling ( )

Create pair of variables requiring nonlocal jacobian contributions.

Definition at line 2647 of file Assembly.C.

Referenced by FEProblemBase::initialSetup().

 {
   _cm_nonlocal_entry.clear();
 
   auto & vars = _sys.getVariables(_tid);
 
   for (auto & ivar : vars)
   {
     auto i = ivar->number();
     auto ivar_start = _cm_nonlocal_entry.size();
     for (unsigned int k = 0; k < ivar->count(); ++k)
     {
       unsigned int iv = i + k;
       for (const auto & j : ConstCouplingRow(iv, _nonlocal_cm))
         if (!_sys.isScalarVariable(j))
         {
           auto & jvar = _sys.getVariable(_tid, j);
           auto pair = std::make_pair(ivar, &jvar);
           auto c = ivar_start;
           // check if the pair has been pushed or not
           bool has_pair = false;
           for (; c < _cm_nonlocal_entry.size(); ++c)
             if (_cm_nonlocal_entry[c] == pair)
             {
               has_pair = true;
               break;
             }
           if (!has_pair)
             _cm_nonlocal_entry.push_back(pair);
         }
     }
   }
 }

◆ jacobianBlock()

DenseMatrix<Number>& Assembly::jacobianBlock	(	unsigned int	ivar,
		unsigned int	jvar,
		LocalDataKey	,
		TagID	tag
	)

inline

Get local Jacobian block for a pair of variables and a tag.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 1103 of file Assembly.h.

Referenced by TaggingInterface::accumulateTaggedLocalMatrix(), addJacobianCoupledVarPair(), cacheJacobianCoupledVarPair(), prepareBlock(), prepareJacobianBlock(), TaggingInterface::prepareMatrixTag(), prepareOffDiagScalar(), prepareScalar(), and prepareVariable().

   {
     jacobianBlockUsed(tag, ivar, jvar, true);
     return _sub_Kee[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
   }

◆ jacobianBlockLowerUsed() [1/2]

void Assembly::jacobianBlockLowerUsed	(	TagID	tag,
		unsigned int	ivar,
		unsigned int	jvar,
		bool	used
	)

inlineprivate

Sets whether or not lower Jacobian coupling between ivar and jvar is used to the value used.

Definition at line 2235 of file Assembly.h.

Referenced by addJacobianLowerD(), addJacobianNeighborLowerD(), cacheJacobianMortar(), jacobianBlockMortar(), and prepareLowerD().

   {
     _jacobian_block_lower_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar] = used;
   }

◆ jacobianBlockLowerUsed() [2/2]

char Assembly::jacobianBlockLowerUsed	(	TagID	tag,
		unsigned int	ivar,
		unsigned int	jvar
	)		const

inlineprivate

Return a flag to indicate if a particular coupling lower Jacobian block between ivar and jvar is used.

Definition at line 2244 of file Assembly.h.

   {
     return _jacobian_block_lower_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
   }

◆ jacobianBlockMortar()

DenseMatrix< Number > & Assembly::jacobianBlockMortar	(	Moose::ConstraintJacobianType	type,
		unsigned int	ivar,
		unsigned int	jvar,
		LocalDataKey	,
		TagID	tag
	)

Returns the jacobian block for the given mortar Jacobian type.

This jacobian block can involve degrees of freedom from the secondary side interior parent, the primary side interior parent, or the lower-dimensional element (located on the secondary side). Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 3153 of file Assembly.C.

Referenced by addJacobianLowerD(), addJacobianNeighborLowerD(), cacheJacobianMortar(), prepareLowerD(), and TaggingInterface::prepareMatrixTagLower().

 {
   jacobianBlockLowerUsed(tag, ivar, jvar, true);
   if (_block_diagonal_matrix)
   {
     switch (type)
     {
       default:
       case Moose::LowerLower:
         return _sub_Kll[tag][ivar][0];
       case Moose::LowerSecondary:
         return _sub_Kle[tag][ivar][0];
       case Moose::LowerPrimary:
         return _sub_Kln[tag][ivar][0];
       case Moose::SecondaryLower:
         return _sub_Kel[tag][ivar][0];
       case Moose::SecondarySecondary:
         return _sub_Kee[tag][ivar][0];
       case Moose::SecondaryPrimary:
         return _sub_Ken[tag][ivar][0];
       case Moose::PrimaryLower:
         return _sub_Knl[tag][ivar][0];
       case Moose::PrimarySecondary:
         return _sub_Kne[tag][ivar][0];
       case Moose::PrimaryPrimary:
         return _sub_Knn[tag][ivar][0];
     }
   }
   else
   {
     switch (type)
     {
       default:
       case Moose::LowerLower:
         return _sub_Kll[tag][ivar][jvar];
       case Moose::LowerSecondary:
         return _sub_Kle[tag][ivar][jvar];
       case Moose::LowerPrimary:
         return _sub_Kln[tag][ivar][jvar];
       case Moose::SecondaryLower:
         return _sub_Kel[tag][ivar][jvar];
       case Moose::SecondarySecondary:
         return _sub_Kee[tag][ivar][jvar];
       case Moose::SecondaryPrimary:
         return _sub_Ken[tag][ivar][jvar];
       case Moose::PrimaryLower:
         return _sub_Knl[tag][ivar][jvar];
       case Moose::PrimarySecondary:
         return _sub_Kne[tag][ivar][jvar];
       case Moose::PrimaryPrimary:
         return _sub_Knn[tag][ivar][jvar];
     }
   }
 }

◆ jacobianBlockNeighbor()

DenseMatrix< Number > & Assembly::jacobianBlockNeighbor	(	Moose::DGJacobianType	type,
		unsigned int	ivar,
		unsigned int	jvar,
		LocalDataKey	,
		TagID	tag
	)

Get local Jacobian block of a DG Jacobian type for a pair of variables and a tag.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 3112 of file Assembly.C.

Referenced by TaggingInterface::accumulateTaggedLocalMatrix(), addJacobianNeighbor(), addJacobianNeighborLowerD(), cacheJacobianNeighbor(), TaggingInterface::prepareMatrixTagNeighbor(), and prepareNeighbor().

 {
   if (type == Moose::ElementElement)
     jacobianBlockUsed(tag, ivar, jvar, true);
   else
     jacobianBlockNeighborUsed(tag, ivar, jvar, true);
 
   if (_block_diagonal_matrix)
   {
     switch (type)
     {
       default:
       case Moose::ElementElement:
         return _sub_Kee[tag][ivar][0];
       case Moose::ElementNeighbor:
         return _sub_Ken[tag][ivar][0];
       case Moose::NeighborElement:
         return _sub_Kne[tag][ivar][0];
       case Moose::NeighborNeighbor:
         return _sub_Knn[tag][ivar][0];
     }
   }
   else
   {
     switch (type)
     {
       default:
       case Moose::ElementElement:
         return _sub_Kee[tag][ivar][jvar];
       case Moose::ElementNeighbor:
         return _sub_Ken[tag][ivar][jvar];
       case Moose::NeighborElement:
         return _sub_Kne[tag][ivar][jvar];
       case Moose::NeighborNeighbor:
         return _sub_Knn[tag][ivar][jvar];
     }
   }
 }

◆ jacobianBlockNeighborUsed() [1/2]

void Assembly::jacobianBlockNeighborUsed	(	TagID	tag,
		unsigned int	ivar,
		unsigned int	jvar,
		bool	used
	)

inlineprivate

Sets whether or not neighbor Jacobian coupling between ivar and jvar is used to the value used.

Definition at line 2217 of file Assembly.h.

Referenced by addJacobianNeighbor(), addJacobianNeighborLowerD(), cacheJacobianNeighbor(), jacobianBlockNeighbor(), and prepareNeighbor().

   {
     _jacobian_block_neighbor_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar] = used;
   }

◆ jacobianBlockNeighborUsed() [2/2]

char Assembly::jacobianBlockNeighborUsed	(	TagID	tag,
		unsigned int	ivar,
		unsigned int	jvar
	)		const

inlineprivate

Return a flag to indicate if a particular coupling neighbor Jacobian block between ivar and jvar is used.

Definition at line 2226 of file Assembly.h.

   {
     return _jacobian_block_neighbor_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
   }

◆ jacobianBlockNonlocal()

DenseMatrix<Number>& Assembly::jacobianBlockNonlocal	(	unsigned int	ivar,
		unsigned int	jvar,
		LocalDataKey	,
		TagID	tag
	)

inline

Get local Jacobian block from non-local contribution for a pair of variables and a tag.

Only blessed framework classes may call this API by creating the requisiste LocalDataKey class

Definition at line 1114 of file Assembly.h.

Referenced by addJacobianBlockNonlocal(), addJacobianNonlocal(), cacheJacobianNonlocal(), prepareBlockNonlocal(), TaggingInterface::prepareMatrixTagNonlocal(), prepareNonlocal(), and prepareVariableNonlocal().

   {
     jacobianBlockNonlocalUsed(tag, ivar, jvar, true);
     return _sub_Keg[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
   }

◆ jacobianBlockNonlocalUsed() [1/2]

void Assembly::jacobianBlockNonlocalUsed	(	TagID	tag,
		unsigned int	ivar,
		unsigned int	jvar,
		bool	used
	)

inlineprivate

Sets whether or not nonlocal Jacobian coupling between ivar and jvar is used to the value used.

Definition at line 2253 of file Assembly.h.

Referenced by addJacobianNonlocal(), cacheJacobianNonlocal(), jacobianBlockNonlocal(), prepareBlockNonlocal(), prepareNonlocal(), and prepareVariableNonlocal().

   {
     _jacobian_block_nonlocal_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar] = used;
   }

◆ jacobianBlockNonlocalUsed() [2/2]

char Assembly::jacobianBlockNonlocalUsed	(	TagID	tag,
		unsigned int	ivar,
		unsigned int	jvar
	)		const

inlineprivate

Return a flag to indicate if a particular coupling nonlocal Jacobian block between ivar and jvar is used.

Definition at line 2262 of file Assembly.h.

   {
     return _jacobian_block_nonlocal_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
   }

◆ jacobianBlockUsed() [1/2]

void Assembly::jacobianBlockUsed	(	TagID	tag,
		unsigned int	ivar,
		unsigned int	jvar,
		bool	used
	)

inlineprivate

Sets whether or not Jacobian coupling between ivar and jvar is used to the value used.

Definition at line 2199 of file Assembly.h.

Referenced by addJacobianCoupledVarPair(), cacheJacobianCoupledVarPair(), jacobianBlock(), jacobianBlockNeighbor(), prepareBlock(), prepareJacobianBlock(), prepareOffDiagScalar(), prepareScalar(), and prepareVariable().

   {
     _jacobian_block_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar] = used;
   }

◆ jacobianBlockUsed() [2/2]

char Assembly::jacobianBlockUsed	(	TagID	tag,
		unsigned int	ivar,
		unsigned int	jvar
	)		const

inlineprivate

Return a flag to indicate if a particular coupling Jacobian block between ivar and jvar is used.

Definition at line 2208 of file Assembly.h.

   {
     return _jacobian_block_used[tag][ivar][_block_diagonal_matrix ? 0 : jvar];
   }

◆ JxW()

const MooseArray<Real>& Assembly::JxW ( ) const

inline

Returns the reference to the transformed jacobian weights.

Returns: A reference. Make sure to store this as a reference!

Definition at line 248 of file Assembly.h.

Referenced by elementVolume(), reinitDual(), reinitLowerDElem(), and reinitNeighbor().

248 { return _current_JxW; }

Assembly::_current_JxW

MooseArray< Real > _current_JxW

The current list of transformed jacobian weights.

Definition: Assembly.h:2380

◆ JxWFace()

const MooseArray<Real>& Assembly::JxWFace ( ) const

inline

Returns the reference to the transformed jacobian weights on a current face.

Returns: A reference. Make sure to store this as a reference!

Definition at line 312 of file Assembly.h.

312 { return _current_JxW_face; }

MooseArray< Real > _current_JxW_face

The current transformed jacobian weights on a face.

Definition: Assembly.h:2488

◆ jxWMortar()

const std::vector<Real>& Assembly::jxWMortar ( ) const

inline

Returns a reference to JxW for mortar segment elements.

Definition at line 668 of file Assembly.h.

Referenced by Moose::Mortar::loopOverMortarSegments().

668 { return *_JxW_msm; }

Assembly::_JxW_msm

const std::vector< Real > * _JxW_msm

A JxW for working on mortar segement elements.

Definition: Assembly.h:2539

◆ JxWNeighbor()

const MooseArray< Real > & Assembly::JxWNeighbor ( ) const

Returns the reference to the transformed jacobian weights on a current face.

Returns: A reference. Make sure to store this as a reference!

Definition at line 259 of file Assembly.C.

 {
   _need_JxW_neighbor = true;
   return _current_JxW_neighbor;
 }

◆ lowerDElem()

const Elem* const& Assembly::lowerDElem ( ) const

inline

Return the lower dimensional element.

Returns: A reference. Make sure to store this as a reference!

Definition at line 437 of file Assembly.h.

Referenced by Moose::globalDofIndexToDerivative(), and MooseVariableFE< Real >::MooseVariableFE().

437 { return _current_lower_d_elem; }

Assembly::_current_lower_d_elem

const Elem * _current_lower_d_elem

The current lower dimensional element.

Definition: Assembly.h:2591

◆ lowerDElemVolume()

const Real & Assembly::lowerDElemVolume ( ) const

inline

Definition at line 3166 of file Assembly.h.

 {
   _need_lower_d_elem_volume = true;
   return _current_lower_d_elem_volume;
 }

◆ mappedNormals()

const std::vector<Eigen::Map<RealDIMValue> >& Assembly::mappedNormals ( ) const

inline

Definition at line 323 of file Assembly.h.

323 { return _mapped_normals; }

Assembly::_mapped_normals

std::vector< Eigen::Map< RealDIMValue > > _mapped_normals

Mapped normals.

Definition: Assembly.h:2492

◆ modifyArbitraryWeights()

void Assembly::modifyArbitraryWeights ( const std::vector< Real > & weights )

Modify the weights when using the arbitrary quadrature rule.

The intention is to use this when you wish to supply your own quadrature after calling reinit at physical points.

You should only use this if the arbitrary quadrature is the current quadrature rule!

Parameters

weights The weights to fill into _current_JxW

Definition at line 4580 of file Assembly.C.

 {
   mooseAssert(_current_qrule == _current_qrule_arbitrary, "Rule should be arbitrary");
   mooseAssert(weights.size() == _current_physical_points.size(), "Size mismatch");
 
   for (MooseIndex(weights.size()) i = 0; i < weights.size(); ++i)
     _current_JxW[i] = weights[i];
 }

◆ modifyFaceWeightsDueToXFEM()

void Assembly::modifyFaceWeightsDueToXFEM	(	const Elem *	elem,
		unsigned int	side = `0`
	)

private

Update the face integration weights for XFEM partial elements.

This only affects the weights if XFEM is used and if the element is cut.

Parameters

elem	The element for which the weights are adjusted
side	The side of element for which the weights are adjusted

Definition at line 4553 of file Assembly.C.

Referenced by reinitFEFace().

 {
   mooseAssert(_xfem != nullptr, "This function should not be called if xfem is inactive");
 
   if (_current_qrule_face == _current_qrule_arbitrary)
     return;
 
   MooseArray<Real> xfem_face_weight_multipliers;
   if (_xfem->getXFEMFaceWeights(
           xfem_face_weight_multipliers, elem, _current_qrule_face, _current_q_points_face, side))
   {
     mooseAssert(xfem_face_weight_multipliers.size() == _current_JxW_face.size(),
                 "Size of weight multipliers in xfem doesn't match number of quadrature points");
     for (unsigned i = 0; i < xfem_face_weight_multipliers.size(); i++)
       _current_JxW_face[i] = _current_JxW_face[i] * xfem_face_weight_multipliers[i];
 
     xfem_face_weight_multipliers.release();
   }
 }

◆ modifyWeightsDueToXFEM()

void Assembly::modifyWeightsDueToXFEM ( const Elem * elem )

private

Update the integration weights for XFEM partial elements.

This only affects the weights if XFEM is used and if the element is cut.

Parameters

elem	The element for which the weights are adjusted

Definition at line 4533 of file Assembly.C.

Referenced by reinitFE().

 {
   mooseAssert(_xfem != nullptr, "This function should not be called if xfem is inactive");
 
   if (_current_qrule == _current_qrule_arbitrary)
     return;
 
   MooseArray<Real> xfem_weight_multipliers;
   if (_xfem->getXFEMWeights(xfem_weight_multipliers, elem, _current_qrule, _current_q_points))
   {
     mooseAssert(xfem_weight_multipliers.size() == _current_JxW.size(),
                 "Size of weight multipliers in xfem doesn't match number of quadrature points");
     for (unsigned i = 0; i < xfem_weight_multipliers.size(); i++)
       _current_JxW[i] = _current_JxW[i] * xfem_weight_multipliers[i];
 
     xfem_weight_multipliers.release();
   }
 }

◆ mortarCoordTransformation()

const MooseArray<Real>& Assembly::mortarCoordTransformation ( ) const

inline

Returns the reference to the coordinate transformation coefficients on the mortar segment mesh.

Returns: A reference. Make sure to store this as a reference!

Definition at line 266 of file Assembly.h.

266 { return _coord_msm; }

Assembly::_coord_msm

MooseArray< Real > _coord_msm

The coordinate transformation coefficients evaluated on the quadrature points of the mortar segment m...

Definition: Assembly.h:2534

◆ msmElem()

const Elem* const& Assembly::msmElem ( ) const

inline

Returns: The current mortar segment element

Definition at line 1916 of file Assembly.h.

1916 { return _msm_elem; }

Assembly::_msm_elem

const Elem * _msm_elem

Definition: Assembly.h:2843

◆ needDual()

bool Assembly::needDual ( ) const

inline

Indicates whether dual shape functions are used (computation is now repeated on each element so expense of computing dual shape functions is no longer trivial)

Definition at line 584 of file Assembly.h.

Referenced by Moose::Mortar::loopOverMortarSegments().

584 { return _need_dual; }

Assembly::_need_dual

bool _need_dual

Whether dual shape functions need to be computed for mortar constraints.

Definition: Assembly.h:2603

◆ neighbor()

const Elem* const& Assembly::neighbor ( ) const

inline

Return the neighbor element.

Returns: A reference. Make sure to store this as a reference!

Definition at line 431 of file Assembly.h.

Referenced by Moose::globalDofIndexToDerivative(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseVariableFE< Real >::MooseVariableFE(), MooseVariableFV< Real >::MooseVariableFV(), qruleFaceHelper(), reinitElemAndNeighbor(), reinitFEFaceNeighbor(), reinitFENeighbor(), reinitFVFace(), reinitNeighbor(), and reinitNeighborFaceRef().

431 { return _current_neighbor_elem; }

Assembly::_current_neighbor_elem

const Elem * _current_neighbor_elem

The current neighbor "element".

Definition: Assembly.h:2570

◆ neighborLowerDElem()

const Elem* const& Assembly::neighborLowerDElem ( ) const

inline

Return the neighboring lower dimensional element.

Returns: A reference. Make sure to store this as a reference!

Definition at line 443 of file Assembly.h.

443 { return _current_neighbor_lower_d_elem; }

Assembly::_current_neighbor_lower_d_elem

const Elem * _current_neighbor_lower_d_elem

The current neighboring lower dimensional element.

Definition: Assembly.h:2593

◆ neighborLowerDElemVolume()

const Real & Assembly::neighborLowerDElemVolume ( ) const

inline

Definition at line 3173 of file Assembly.h.

 {
   _need_neighbor_lower_d_elem_volume = true;
   return _current_neighbor_lower_d_elem_volume;
 }

◆ neighborSide()

const unsigned int& Assembly::neighborSide ( ) const

inline

Returns the current neighboring side.

Returns: A reference. Make sure to store this as a reference!

Definition at line 413 of file Assembly.h.

413 { return _current_neighbor_side; }

Assembly::_current_neighbor_side

unsigned int _current_neighbor_side

The current side of the selected neighboring element (valid only when working with sides) ...

Definition: Assembly.h:2574

◆ neighborVolume()

const Real& Assembly::neighborVolume ( )

inline

Returns the reference to the current neighbor volume.

Returns: A reference. Make sure to store this as a reference!

Definition at line 469 of file Assembly.h.

Referenced by InterfaceKernelBase::getNeighborElemVolume(), InternalSideUserObject::getNeighborElemVolume(), and DGKernelBase::getNeighborElemVolume().

   {
     _need_neighbor_elem_volume = true;
     return _current_neighbor_volume;
   }

◆ node()

const Node* const& Assembly::node ( ) const

inline

Returns the reference to the node.

Returns: A reference. Make sure to store this as a reference!

Definition at line 506 of file Assembly.h.

Referenced by computeFaceMap(), computeSinglePointMapAD(), and MooseVariableFE< Real >::MooseVariableFE().

506 { return _current_node; }

Assembly::_current_node

const Node * _current_node

The current node we are working with.

Definition: Assembly.h:2582

◆ nodeNeighbor()

const Node* const& Assembly::nodeNeighbor ( ) const

inline

Returns the reference to the neighboring node.

Returns: A reference. Make sure to store this as a reference!

Definition at line 512 of file Assembly.h.

Referenced by MooseVariableFE< Real >::MooseVariableFE().

512 { return _current_neighbor_node; }

Assembly::_current_neighbor_node

const Node * _current_neighbor_node

The current neighboring node we are working with.

Definition: Assembly.h:2584

◆ nonlocalCouplingEntries()

std::vector<std::pair<MooseVariableFieldBase *, MooseVariableFieldBase *> >& Assembly::nonlocalCouplingEntries ( )

inline

Definition at line 1264 of file Assembly.h.

   {
     return _cm_nonlocal_entry;
   }

◆ normals()

const MooseArray<Point>& Assembly::normals ( ) const

inline

Returns the array of normals for quadrature points on a current side.

Returns: A reference. Make sure to store this as a reference!

Definition at line 318 of file Assembly.h.

318 { return _current_normals; }

Assembly::_current_normals

MooseArray< Point > _current_normals

The current Normal vectors at the quadrature points.

Definition: Assembly.h:2490

◆ numExtraElemIntegers()

unsigned int Assembly::numExtraElemIntegers ( ) const

inline

Number of extra element integers Assembly tracked.

Definition at line 334 of file Assembly.h.

Referenced by reinitFE(), reinitFEFace(), and reinitNeighbor().

334 { return _extra_elem_ids.size() - 1; }

Assembly::_extra_elem_ids

std::vector< dof_id_type > _extra_elem_ids

Extra element IDs.

Definition: Assembly.h:2497

◆ phi() [1/6]

const VariablePhiValue& Assembly::phi ( ) const

inline

Definition at line 1280 of file Assembly.h.

Referenced by copyShapes().

1280 { return _phi; }

VariablePhiValue _phi

Definition: Assembly.h:2663

◆ phi() [2/6]

const VariablePhiValue& Assembly::phi ( const MooseVariableField< Real > & ) const

inline

Definition at line 1286 of file Assembly.h.

1286 { return _phi; }

VariablePhiValue _phi

Definition: Assembly.h:2663

◆ phi() [3/6]

const VectorVariablePhiValue& Assembly::phi ( const MooseVariableField< RealVectorValue > & ) const

inline

Definition at line 1333 of file Assembly.h.

   {
     return _vector_phi;
   }

◆ phi() [4/6]

VariablePhiValue& Assembly::phi ( const MooseVariableField< Real > & )

inline

Definition at line 1425 of file Assembly.h.

1425 { return _phi; }

VariablePhiValue _phi

Definition: Assembly.h:2663

◆ phi() [5/6]

VectorVariablePhiValue& Assembly::phi ( const MooseVariableField< RealVectorValue > & )

inline

Definition at line 1457 of file Assembly.h.

1457 { return _vector_phi; }

Assembly::_vector_phi

VectorVariablePhiValue _vector_phi

Definition: Assembly.h:2680

◆ phi() [6/6]

VariablePhiValue& Assembly::phi ( const MooseVariableField< RealEigenVector > & )

inline

Definition at line 1538 of file Assembly.h.

1538 { return _phi; }

VariablePhiValue _phi

Definition: Assembly.h:2663

◆ phiFace() [1/6]

const VariablePhiValue& Assembly::phiFace ( ) const

inline

Definition at line 1295 of file Assembly.h.

Referenced by copyFaceShapes().

1295 { return _phi_face; }

VariablePhiValue _phi_face

Definition: Assembly.h:2667

◆ phiFace() [2/6]

const VariablePhiValue& Assembly::phiFace ( const MooseVariableField< Real > & ) const

inline

Definition at line 1296 of file Assembly.h.

1296 { return _phi_face; }

VariablePhiValue _phi_face

Definition: Assembly.h:2667

◆ phiFace() [3/6]

const VectorVariablePhiValue& Assembly::phiFace ( const MooseVariableField< RealVectorValue > & ) const

inline

Definition at line 1354 of file Assembly.h.

   {
     return _vector_phi_face;
   }

◆ phiFace() [4/6]

VariablePhiValue& Assembly::phiFace ( const MooseVariableField< Real > & )

inline

Definition at line 1429 of file Assembly.h.

1429 { return _phi_face; }

VariablePhiValue _phi_face

Definition: Assembly.h:2667

◆ phiFace() [5/6]

VectorVariablePhiValue& Assembly::phiFace ( const MooseVariableField< RealVectorValue > & )

inline

Definition at line 1475 of file Assembly.h.

   {
     return _vector_phi_face;
   }

◆ phiFace() [6/6]

VariablePhiValue& Assembly::phiFace ( const MooseVariableField< RealEigenVector > & )

inline

Definition at line 1542 of file Assembly.h.

1542 { return _phi_face; }