Inheritance diagram for ContactRelationshipManagerTest:

[legend]

Protected Types
enum class	GhostWholeInterfaceInput { Default , False , 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 class 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.

  {
    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);
  }

Referenced by testContactActionRelationshipManager(), and testMortarContactActionRejectsGhostWholeInterface().

◆ buildMooseMesh()

void ContactRelationshipManagerTest::buildMooseMesh ( )

inlineprotected

Definition at line 40 of file ContactRelationshipManagerTest.C.

  {
    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;
  }

Referenced by SetUp().

◆ 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);
  }