Inheritance diagram for ContactRelationshipManagerTest:

[legend]

Protected Types
enum	GhostWholeInterfaceInput { GhostWholeInterfaceInput::Default, GhostWholeInterfaceInput::False, GhostWholeInterfaceInput::True }

Protected Member Functions
void	SetUp () override

void	buildMooseMesh ()

std::shared_ptr< ContactAction >	buildContactAction (const GhostWholeInterfaceInput ghost_whole_interface=GhostWholeInterfaceInput::Default, const std::string &formulation="kinematic")

void	testContactActionRelationshipManager (const bool enabled)

void	testMortarContactActionRejectsGhostWholeInterface (const std::string &formulation)

Protected Attributes
std::shared_ptr< MooseApp >	_app

Factory *	_factory

Detailed Description

Definition at line 22 of file ContactRelationshipManagerTest.C.

Member Enumeration Documentation

◆ GhostWholeInterfaceInput

enum ContactRelationshipManagerTest::GhostWholeInterfaceInput

strongprotected

Enumerator
Default
False
True

Definition at line 25 of file ContactRelationshipManagerTest.C.

   {
     Default,
     False,
     True
   };

Member Function Documentation

◆ buildContactAction()

std::shared_ptr<ContactAction> ContactRelationshipManagerTest::buildContactAction	(	const GhostWholeInterfaceInput	ghost_whole_interface = `GhostWholeInterfaceInput::Default`,
		const std::string &	formulation = `"kinematic"`
	)

inlineprotected

Definition at line 50 of file ContactRelationshipManagerTest.C.

Referenced by testContactActionRelationshipManager(), and testMortarContactActionRejectsGhostWholeInterface().

   {
     auto params = _app->getActionFactory().getValidParams("ContactAction");
     params.set<std::string>("task") = "add_constraint";
     params.set<std::string>("registered_identifier") = "Contact/*";
     params.set<std::vector<BoundaryName>>("primary") = {"primary"};
     params.set<std::vector<BoundaryName>>("secondary") = {"secondary"};
     // Mark this programmatic assignment as user-set so the action sees the
     // same parameter metadata it would get from parsed input.
     params.set_attributes("formulation", false);
     params.set<MooseEnum>("formulation") = formulation;
     // The mortar validation specifically checks isParamSetByUser(), so only
     // explicit test inputs should be marked as user-set.
     switch (ghost_whole_interface)
     {
       case GhostWholeInterfaceInput::Default:
         break;
       case GhostWholeInterfaceInput::False:
         params.set_attributes("ghost_whole_interface", false);
         params.set<bool>("ghost_whole_interface") = false;
         break;
       case GhostWholeInterfaceInput::True:
         params.set_attributes("ghost_whole_interface", false);
         params.set<bool>("ghost_whole_interface") = true;
         break;
     }
 
     auto action = _app->getActionFactory().create("ContactAction", "Contact/test", params);
     return std::dynamic_pointer_cast<ContactAction>(action);
   }

◆ buildMooseMesh()

void ContactRelationshipManagerTest::buildMooseMesh ( )

inlineprotected

Definition at line 40 of file ContactRelationshipManagerTest.C.

Referenced by SetUp().

   {
     auto params = _factory->getValidParams("MeshGeneratorMesh");
     auto moose_mesh =
         _factory->create<MeshGeneratorMesh>("MeshGeneratorMesh", "moose_mesh", params);
     moose_mesh->setMeshBase(moose_mesh->buildMeshBaseObject(2));
     moose_mesh->buildMesh();
     _app->actionWarehouse().mesh() = moose_mesh;
   }

◆ SetUp()

void ContactRelationshipManagerTest::SetUp ( )

inlineoverrideprotected

Definition at line 32 of file ContactRelationshipManagerTest.C.

   {
     const char * argv[2] = {"foo", "\0"};
     _app = Moose::createMooseApp("ContactApp", 1, (char **)argv);
     _factory = &_app->getFactory();
     buildMooseMesh();
   }

◆ testContactActionRelationshipManager()

void ContactRelationshipManagerTest::testContactActionRelationshipManager ( const bool enabled )

inlineprotected

Definition at line 83 of file ContactRelationshipManagerTest.C.

   {
     const auto action = buildContactAction(enabled ? GhostWholeInterfaceInput::True
                                                    : GhostWholeInterfaceInput::Default);
     ASSERT_TRUE(action);
 
     action->addRelationshipManagers(Moose::RelationshipManagerType::GEOMETRIC);
 
     const auto & relationship_managers = _app->relationshipManagers();
     ASSERT_EQ(relationship_managers.size(), 1);
 
     auto & rm = **relationship_managers.begin();
     EXPECT_EQ(rm.type(), "GhostPrimaryFace");
     EXPECT_TRUE(rm.isType(Moose::RelationshipManagerType::GEOMETRIC));
     EXPECT_TRUE(rm.isType(Moose::RelationshipManagerType::ALGEBRAIC));
     EXPECT_EQ(rm.attachGeometricEarly(), !enabled);
     EXPECT_EQ(rm.getInfo(), enabled ? "GhostPrimaryFace" : "GhostPrimaryFace (disabled)");
   }

◆ testMortarContactActionRejectsGhostWholeInterface()

void ContactRelationshipManagerTest::testMortarContactActionRejectsGhostWholeInterface ( const std::string & formulation )

inlineprotected

Definition at line 102 of file ContactRelationshipManagerTest.C.

   {
     const std::string error =
         "Mortar contact always geometrically and algebraically ghosts the interface.";
     EXPECT_THROW_MSG_CONTAINS(
         buildContactAction(GhostWholeInterfaceInput::True, formulation), std::runtime_error, error);
     EXPECT_THROW_MSG_CONTAINS(buildContactAction(GhostWholeInterfaceInput::False, formulation),
                               std::runtime_error,
                               error);
   }