FrictionProjectionTest.C File Reference

Go to the source code of this file.

Classes
class	FrictionProjectionTest< T >

Typedefs
using	FrictionProjectionTypes = ::testing::Types< Real, ADReal >

Functions
	TYPED_TEST_SUITE (FrictionProjectionTest, FrictionProjectionTypes)
	TYPED_TEST (FrictionProjectionTest, StickAndSlipRoots)
	TYPED_TEST (FrictionProjectionTest, SeparationAndAugmentedNormalSign)
	TYPED_TEST (FrictionProjectionTest, ThreeDimensionalProjection)
	TYPED_TEST (FrictionProjectionTest, Homogeneity)
	TYPED_TEST (FrictionProjectionTest, PositiveWeightRelationship)
	TYPED_TEST (FrictionProjectionTest, DegreeTwoDegenerateState)

Typedef Documentation

FrictionProjectionTypes

using FrictionProjectionTypes = ::testing::Types<Real, ADReal>

Definition at line 29 of file FrictionProjectionTest.C.

Function Documentation

TYPED_TEST() [1/6]

TYPED_TEST	(	FrictionProjectionTest	,
		DegreeTwoDegenerateState
	)

Definition at line 128 of file FrictionProjectionTest.C.

{
  using T = TypeParam;
 
  const std::array<T, 2> pressure = {2.0, -3.0};
  const std::array<T, 2> augmented_pressure = {0.0, 0.0};
  const auto ac = ContactUtils::alartCurnierFrictionResidual(pressure, augmented_pressure, T(0.0));
  const auto hsw =
      ContactUtils::hueberStadlerWohlmuthFrictionResidual(pressure, augmented_pressure, T(0.0));
 
  for (const auto i : index_range(pressure))
  {
    EXPECT_DOUBLE_EQ(raw_value(ac[i]), raw_value(pressure[i]));
    EXPECT_DOUBLE_EQ(raw_value(hsw[i]), raw_value(pressure[i]));
  }
}

TYPED_TEST() [2/6]

TYPED_TEST	(	FrictionProjectionTest	,
		Homogeneity
	)

Definition at line 84 of file FrictionProjectionTest.C.

{
  using T = TypeParam;
 
  const std::array<T, 2> pressure = {0.7, -0.2};
  const std::array<T, 2> augmented_pressure = {2.0, -1.0};
  const T radius = 0.8;
  const T alpha = 3.0;
  const std::array<T, 2> scaled_pressure = {alpha * pressure[0], alpha * pressure[1]};
  const std::array<T, 2> scaled_augmented = {alpha * augmented_pressure[0],
                                             alpha * augmented_pressure[1]};
 
  const auto ac = ContactUtils::alartCurnierFrictionResidual(pressure, augmented_pressure, radius);
  const auto ac_scaled =
      ContactUtils::alartCurnierFrictionResidual(scaled_pressure, scaled_augmented, alpha * radius);
  const auto hsw =
      ContactUtils::hueberStadlerWohlmuthFrictionResidual(pressure, augmented_pressure, radius);
  const auto hsw_scaled = ContactUtils::hueberStadlerWohlmuthFrictionResidual(
      scaled_pressure, scaled_augmented, alpha * radius);
 
  for (const auto i : index_range(pressure))
  {
    EXPECT_NEAR(raw_value(ac_scaled[i]), raw_value(alpha * ac[i]), 1e-14);
    EXPECT_NEAR(raw_value(hsw_scaled[i]), raw_value(alpha * alpha * hsw[i]), 1e-14);
  }
}

TYPED_TEST() [3/6]

TYPED_TEST	(	FrictionProjectionTest	,
		PositiveWeightRelationship
	)

Definition at line 111 of file FrictionProjectionTest.C.

{
  using T = TypeParam;
 
  const std::array<T, 2> pressure = {0.6, -0.1};
  const std::array<T, 2> augmented_pressure = {1.5, -0.5};
  const T radius = 0.9;
  const T weight = std::max(radius, MathUtils::norm(augmented_pressure));
  ASSERT_GT(raw_value(weight), 0.0);
 
  const auto ac = ContactUtils::alartCurnierFrictionResidual(pressure, augmented_pressure, radius);
  const auto hsw =
      ContactUtils::hueberStadlerWohlmuthFrictionResidual(pressure, augmented_pressure, radius);
  for (const auto i : index_range(pressure))
    EXPECT_NEAR(raw_value(hsw[i]), raw_value(weight * ac[i]), 1e-14);
}

TYPED_TEST() [4/6]

TYPED_TEST	(	FrictionProjectionTest	,
		SeparationAndAugmentedNormalSign
	)

Definition at line 55 of file FrictionProjectionTest.C.

{
  using T = TypeParam;
 
  const T open_augmented_pressure = ContactUtils::augmentedNormalPressure(T(1.0), T(2.0));
  EXPECT_DOUBLE_EQ(raw_value(open_augmented_pressure), -1.0);
  EXPECT_DOUBLE_EQ(raw_value(ContactUtils::coulombFrictionRadius(T(0.5), open_augmented_pressure)),
                   0.0);
 
  const std::array<T, 1> pressure = {0.0};
  const std::array<T, 1> augmented_pressure = {3.0};
  const auto ac = ContactUtils::alartCurnierFrictionResidual(pressure, augmented_pressure, T(0.0));
  const auto hsw =
      ContactUtils::hueberStadlerWohlmuthFrictionResidual(pressure, augmented_pressure, T(0.0));
  EXPECT_DOUBLE_EQ(raw_value(ac[0]), 0.0);
  EXPECT_DOUBLE_EQ(raw_value(hsw[0]), 0.0);
}

TYPED_TEST() [5/6]

TYPED_TEST	(	FrictionProjectionTest	,
		StickAndSlipRoots
	)

Definition at line 32 of file FrictionProjectionTest.C.

{
  using T = TypeParam;
 
  const std::array<T, 1> stick_pressure = {1.0};
  const std::array<T, 1> stick_augmented = {1.0};
  const auto ac_stick =
      ContactUtils::alartCurnierFrictionResidual(stick_pressure, stick_augmented, T(2.0));
  const auto hsw_stick =
      ContactUtils::hueberStadlerWohlmuthFrictionResidual(stick_pressure, stick_augmented, T(2.0));
  EXPECT_DOUBLE_EQ(raw_value(ac_stick[0]), 0.0);
  EXPECT_DOUBLE_EQ(raw_value(hsw_stick[0]), 0.0);
 
  const std::array<T, 1> slip_pressure = {2.0};
  const std::array<T, 1> slip_augmented = {4.0};
  const auto ac_slip =
      ContactUtils::alartCurnierFrictionResidual(slip_pressure, slip_augmented, T(2.0));
  const auto hsw_slip =
      ContactUtils::hueberStadlerWohlmuthFrictionResidual(slip_pressure, slip_augmented, T(2.0));
  EXPECT_DOUBLE_EQ(raw_value(ac_slip[0]), 0.0);
  EXPECT_DOUBLE_EQ(raw_value(hsw_slip[0]), 0.0);
}

TYPED_TEST() [6/6]

TYPED_TEST	(	FrictionProjectionTest	,
		ThreeDimensionalProjection
	)

Definition at line 73 of file FrictionProjectionTest.C.

{
  using T = TypeParam;
 
  const std::array<T, 2> augmented_pressure = {3.0, 4.0};
  const auto projection = ContactUtils::projectToClosedSphere(augmented_pressure, T(2.0));
  EXPECT_DOUBLE_EQ(raw_value(projection[0]), 1.2);
  EXPECT_DOUBLE_EQ(raw_value(projection[1]), 1.6);
  EXPECT_DOUBLE_EQ(raw_value(MathUtils::norm(projection)), 2.0);
}

TYPED_TEST_SUITE()

TYPED_TEST_SUITE	(	FrictionProjectionTest	,
		FrictionProjectionTypes
	)