How To: Boundary Conditions¶

Boundary Conditions¶

Restraints¶

Fixed Boundary¶

A “Fixed Boundary” restraint fixes the selected geometry in all directions.

The fixed boundary only has one input:

the boundary surface to be fixed

auto fixed = std::make_shared<Intact::FixedBoundaryDescriptor>();

// Set the geometry "restraint.ply" to be fixed
fixed->boundary = Intact::MeshModel("restraint.ply");

Fixed Vector¶

A “Fixed Vector” restraint allows for each direction to be optionally set to a specified displacement value, 0 being fixed and ‘None’ being un-restrained. Note that a structural problem must have all three directions restrained somewhere to be valid.

A fixed vector has five inputs:

the boundary surface to be fixed
the x_value to set the displacement for the x-axis direction (optional)
the y_value to set the displacement for the y-axis direction (optional)
the z_value to set the displacement for the z-axis direction (optional)
the units that apply to the displacement values

auto fixed_vector = std::make_shared<Intact::FixedVectorDescriptor>();

// Set the geometry "restraint.stl" to be restrained
fixed_vector->boundary = Intact::MeshModel("restraint.stl");

// Set the displacements in each direction
fixed_vector->x_value = 0.2;  // X-direction displacement of 0.2 ft
fixed_vector->y_value = std::nullopt; // un-restrained in the Y-direction at this surface
fixed_vector->z_value = 0.0;  // fixed Z-direction
fixed_vector->units = Intact::UnitSystem::FootPoundSecond;

Sliding Restraint¶

A “Sliding Restraint” allows for motion tangential to a specified surface, but fixes motion normal to the specified surface.

A sliding restraint only has one input:

the boundary surface for the sliding restraint condition

auto sliding_boundary = std::make_shared<Intact::SlidingBoundaryDescriptor>();

// Set the geometry "restraint.stl" for the sliding restraint condition
sliding_boundary->boundary = Intact::MeshModel("restraint.stl");

Structural Loads¶

Vector Force¶

“Vector Force” load is a surface load applied to a face in a specified direction. An example of this load is pressing on the top of a book to push it across a table.

A vector load requires four inputs:

the boundary surfaces where the load is applied
the direction vector of the force
the magnitude of the force
the units that apply to the magnitude

auto load = std::make_shared<Intact::VectorForceDescriptor>();

// Set the geometry "load.stl" the vector load is applied to
load->boundary = Intact::MeshModel("load.stl");

// Set the vector load direction to be in the -Z direction with a magnitude of 100 lbf
load->direction = {0, 0, -1};
load->units = Intact::UnitSystem::InchPoundSecond;
load->magnitude = 100; // lbf

Torque¶

“Torque” load is a surface load that applies a twisting force around an axis. The direction of the torque is determined using the right-hand rule: using your right hand, point your thumb in the direction of the axis. A positive torque value applies a torque acting in the direction the fingers of your right hand would wrap around the axis. The torque load is applied among the load faces with a distribution that varies linearly from zero at the axis.

A torque load requires five inputs:

the boundary surfaces where the load is applied
the origin for the axis of rotation
the axis vector defining the axis of rotation
the magnitude of the torque
the units that apply to the magnitude

auto torque_load = std::make_shared<Intact::TorqueForceDescriptor>();

// Set the geometry "load.stl" the torque load is applied to
torque_load->boundary = Intact::MeshModel("load.stl");

// Set the axis of the torque axis
torque_load->origin = {10, 1, 1};
torque_load->axis = {1, 0, 0}; // Set the torque to be about the +X (right-hand rule)
torque_load->units = Intact::UnitSystem::MeterKilogramSecond;
torque_load->magnitude = 10; // Set the torque magnitude to 10 N*m

Pressure¶

A “Pressure” load is a surface load specified in terms of force per unit area. Positive pressures ‘push’ into the surface, and negative pressures ‘pull’.

A pressure load requires three inputs:

the boundary surfaces where the load is applied
the units that apply to the magnitude
the magnitude of the pressure.

auto pressure_load = std::make_shared<Intact::PressureForceDescriptor>();

// Set the geometry "load.stl" the pressure load is applied to
pressure_load->boundary = Intact::MeshModel("load.stl");

// Set the pressure magnitude to 10 Pa
pressure_load->units = Intact::UnitSystem::MeterKilogramSecond;
pressure_load->magnitude = 10;

Bearing Force¶

A “Bearing Force” is a surface load applied to a (typically) cylindrical face to approximate the effects of a shaft pressing against the side of a hole. The applied force gets converted to a varying pressure distribution on the portion of the face experiencing compressive pressure. The pressure distribution is computed automatically to achieve the specified overall bearing force.

A bearing force requires four inputs:

the boundary surfaces where the load is applied
the direction vector of the bearing force
the units that apply to the magnitude
the magnitude of the force

auto bearing_load = std::make_shared<Intact::BearingForceDescriptor>();

// Set the geometry "load.stl" the bearing load is applied to
bearing_load->boundary = Intact::MeshModel("load.stl");

// Set the loading direction to be in the -Z
bearing_load->direction = {0, 0, -1};

// Set the magnitude of the load to 100 N
bearing_load->units = Intact::UnitSystem::MeterKilogramSecond;
bearing_load->magnitude = 100;

Flexible Remote Load¶

A “Flexible Remote Load” allows specifying the force and moment at a remote location that is then applied to a surface. It can be used in a similar manner to NASTRAN’s RBE3 load or Abaqus coupling elements.

A flexible remote load requires seven inputs:

the boundary surfaces where the load is applied
the direction vector of the remote force
the force of the remote force
the axis of rotation about which the moment acts
the moment magnitude of the remote moment
the remote_point where the force and moment are applied
the units that apply to the magnitude and moment

The direction and axis vectors should be unit vectors to describe the direction. They will be normalized if they are not unit vectors.

auto load = std::make_shared<Intact::FlexibleRemoteLoadDescriptor>();

// Set the geometry "load.stl" the load is applied to
load->boundary = Intact::MeshModel("load.stl");

// Set the loading direction to be in the -Y
load->direction = {0, -1, 0};

// Set the magnitude of the load to 100 N
load->units = Intact::UnitSystem::MeterKilogramSecond;
load->magnitude = 100;

// Set the moment axis in the X direction
load->axis = {1, 0, 0};

// Set the magnitude of the moment to 200 N-m
load->moment = 200;

// The remote load acts at the point (1, 1, 1)
load->remote_point = {1, 1, 1};

Thermal Loads¶

Fixed Boundary (Fixed Temperature)¶

A “Fixed Boundary” load fixes the selected boundary to a specified temperature when the value is specified and non-zero.

The fixed temperature boundary condition has three inputs:

the boundary surface to be fixed
the value of the temperature to fix at the boundary surface
the units that apply to the temperature

auto fixed = std::make_shared<Intact::FixedBoundaryDescriptor>();

// Set the geometry "fixed_temp.ply" to set a fixed temperaure of 320 K
fixed_boundary->boundary = Intact::MeshModel("fixed_temp.ply");
fixed_boundary->value = 320;  // Kelvin

// Set the geometry "fixed_temp.ply" to set a fixed temperaure of 500 Rankine
fixed_boundary->boundary = Intact::MeshModel("fixed_temp.ply");
fixed_boundary->units = Intact::UnitSystem::InchPoundSecond;
fixed_boundary->value = 500;  // Rankine

Convection¶

A “Convection” load specifies the transfer of heat from a surrounding medium.

A thermal convection boundary condition requires four inputs:

the boundary surface where the convection is applied
the heat transfer coefficient
the environment_temperature of the surrounding medium
the units that apply to the coefficient and environment temperature

// Create an instance of ConvectionDescriptor
auto convection = std::make_shared<Intact::ConvectionDescriptor>();
convection->units = Intact::UnitSystem::MeterKilogramSecond;

// Set the geometry "face.ply" the convection is applied to
convection->boundary = Intact::MeshModel("face.ply");

// Set the heat transfer coefficient to 25 W/m^2K and environment temperature
convection->coefficient = 25;  // W/m^2K
convection->environment_temperature = 300;  // Kelvin

Surface Flux¶

Surface “Thermal or Heat Flux” specifies the heat flow per unit of surface area.

A surface thermal flux requires three inputs:

the boundary surface where the flux is applied.
the magnitude of the heat flux
the units that apply to the magnitude

// Create an instance of ConstantFluxDescriptor
auto flux = std::make_shared<Intact::ConstantFluxDescriptor>();
flux->units = Intact::UnitSystem::MeterKilogramSecond;

// Set the geometry "face.ply" the constant flux is applied to
flux->boundary = Intact::MeshModel("face.ply");

// Set the flux magnitude to 500 W/m^2
flux->magnitude = 500;  // W/m^2

Body Loads/Internal Conditions¶

Add body load to the scenario as shown below. (see Scenario Setup section for more details)

scenario.internal_conditions = {rotational_load, gravity_load};

Linear Acceleration Load or Gravity¶

A linear acceleration load can be used to simulate the effect of gravity. The material in the body will tend to be pulled in the direction of the acceleration vector. A linear acceleration body load is configured by specifying the direction of the acceleration and its magnitude.

The inputs to the linear acceleration body load are:

the direction vector of the acceleration field
the units that apply to the magnitude
the magnitude of acceleration

// Example for a "gravity load"
auto body_load = std::make_shared<Intact::BodyLoadDescriptor>();

// Set the direction vector to be downward (-Z)
body_load->direction = {0, 0, -1};

// Set the magnitude to 9.80655 m/s^2
body_load->units = Intact::UnitSystem::MeterKilogramSecond;
body_load->magnitude = 9.80665;

Rotational Load¶

Rotational body loads simulate the effect of a body rotating around an axis. Two contributions are considered in a rotational body load: angular velocity and angular acceleration. The angular velocity term simulates the centrifugal effects that tend to throw a body’s material away from the axis of rotation. The angular acceleration term simulates the effect of a rotational acceleration field around the axis of rotation. A positive angular acceleration tends to drag the body’s material in the positive rotational direction according to the right-hand rule.

A rotational body load has 4 inputs:

origin point for the axis of rotation
vector defining the axis of rotation
angular_velocity (in radians/sec)
angular_acceleration (in radians/sec²)

auto rotational_load = std::make_shared<Intact::RotationalLoadDescriptor>();

// Set the origin at the coordinate system origin
rotational_load->origin = {0, 0, 0};

// Set the axis of rotation about the y-axis
rotational_load->axis = {0, 1, 0};

// Set angular velocity to 10 rad/s and angular acceleration to 0.5 rad/s^2
rotational_load->angular_velocity = 10;
rotational_load->angular_acceleration = 0.5;

Thermal Body Loads¶

Constant Heat¶

A “Constant Heat” or body heat flux load applies uniform heat generation over a specified volume.

Constant heat flux has three inputs

the instance_id of the components which are producing heat flux
the magnitude of the body heat flux
the units (default MKS)

auto constant_heat = std::make_shared<Intact::ConstantHeatDescriptor>();
constant_heat->units = Intact::UnitSystem::MeterKilogramSecond;

// Set the heat generation to -200,000 W for a beam component
constant_heat->instance_id = "beam";
constant_heat->magnitude = -200000.0;  // W