PyIntact API¶

class PyIntact.Geometry(self: PyIntact.Geometry, value: int)

Members:

VDB

Mesh

property name

class PyIntact.Model

property instance_id

The instance ID of the model. We enforce that this must be unique per run.

mass(self: PyIntact.Model) -> float

Returns the mass of the model

property model_name

This is used for debugging purposes. It need not be filled out in general.

projectField(self: PyIntact.Model, field: Callable[[Annotated[list[float], FixedSize(3)]], Intact::Tensor]) -> None

Sets tensors according to a user-provided callback

Parameter field:
The field

setDensities(self: PyIntact.Model, densities: list[float]) -> None

Sets tensors as 1x1-dimensional data, AKA densities. This is a convenience wrapper around setTensors.

Parameter densities:
The densities

setTensors(self: PyIntact.Model, tensors: list[Intact::Tensor]) -> None

Set the tensors for all voxels.

Parameter tensors:
The tensors for all voxels.

tensor(self: PyIntact.Model, id: int) -> Intact::Tensor

Returns the tensor at the given index

Parameter id:
The id (typically point ID) for the tensor

class PyIntact.MeshModel(*args, **kwargs)

Bases: Model

Overloaded function.

__init__(self: PyIntact.MeshModel) -> None

Construct an empty MeshModel.

__init__(self: PyIntact.MeshModel, other: PyIntact.MeshModel) -> None

Construct a MeshModel from an existing MeshModel.

Parameter other:
A MeshModel.

__init__(self: PyIntact.MeshModel, filename: str) -> None

Load MeshModel from file.

Parameter filename:
File must be a VTU, PLY, or STL file.

addFacet(self: PyIntact.MeshModel, vertex_1: int, vertex_2: int, vertex_3: int) -> int

Add a new facet to the MeshModel.

Parameter vertex_1:
Index of the first vertex in the facet.

Parameter vertex_2:
Index of the second vertex in the facet.

Parameter vertex_3:
Index of the third vertex in the facet.

Returns:

The index of the new facet.

addVertex(self: PyIntact.MeshModel, vertex: Annotated[list[float], FixedSize(3)]) -> int

Add new vertex to the MeshModel.

Parameter vertex:
The position of the vertex.

Returns:

The index of the new vertex for use with facets.

facet(self: PyIntact.MeshModel, facet_index: int) -> Annotated[list[int], FixedSize(3)]

Get a specific facet.

Parameter facet_index:
The facet identifier.

Returns:

The facet.

facetCount(self: PyIntact.MeshModel) -> int

Get the number of facets in the MeshModel.

refine(*args, **kwargs)

Overloaded function.

refine(self: PyIntact.MeshModel, threshold: float) -> None

Refine the input mesh, by splitting every facet edge that is larger than (threshold) * (bounding box size of mesh). Refining the input mesh increases sampling density.

Parameter threshold:
The fraction of the bounding box size of the mesh.

refine(self: PyIntact.MeshModel) -> None

Refine the input mesh, by splitting every facet edge that is larger than 2% of bounding box size of mesh.

vertex(self: PyIntact.MeshModel, vertex_index: int) -> Annotated[list[float], FixedSize(3)]

Get a specific vertex.

Parameter vertex_index:
The vertex identifier.

Returns:

The vertex.

vertexCount(self: PyIntact.MeshModel) -> int

Get the number of vertices in the MeshModel.

writePLY(self: PyIntact.MeshModel, output_filename: str) -> None

Write the MeshModel to file in PLY format.

Parameter output_filename:
The output filename.

writeVTU(self: PyIntact.MeshModel, output_filename: str) -> None

Write the MeshModel to file in VTU (VTK unstructured grid) format.

Parameter output_filename:
The output filename.

class PyIntact.Tensor(self: PyIntact.Tensor, arg0: list[float], arg1: int, arg2: int)

cols(self: PyIntact.Tensor) -> int

raw_data(self: PyIntact.Tensor) -> list[float]

rows(self: PyIntact.Tensor) -> int

class PyIntact.VDBModel(*args, **kwargs)

Bases: Model

Represents a model based on an openVDB volume.

Overloaded function.

__init__(self: PyIntact.VDBModel, filename: str) -> None

Load a VDBModel from a file.

Parameter filename:
The VDB file.

__init__(self: PyIntact.VDBModel, grid: openvdb::v9_1::Grid<openvdb::v9_1::tree::Tree<openvdb::v9_1::tree::RootNode<openvdb::v9_1::tree::InternalNode<openvdb::v9_1::tree::InternalNode<openvdb::v9_1::tree::LeafNode<double, 3u>, 4u>, 5u> > > >) -> None

Construct a VDBModel an existing DoubleGrid.

Parameter grid:
The existing DoubleGrid.

tessellate(self: PyIntact.VDBModel) -> `PyIntact.MeshModel <#PyIntact.MeshModel>`_

Create a mesh from the VDBModel, using the OpenVDB volumeToMesh method.

Returns:

A MeshModel.

class PyIntact.MaterialDomain(self: PyIntact.MaterialDomain, model: PyIntact.Model, material_name: str, scenario_descriptor: Intact::AbstractScenarioDescriptor)

Construct a MaterialDomain from a model, material name, and scenario descriptor. This constructor ensures the material units are consistent with scenario units and should be used.

Parameter model:
The model

Parameter material_name:
The material name

Parameter scenario_descriptor:
The scenario descriptor

class PyIntact.Field(self: PyIntact.Field, value: int)

Members:

Displacement

Strain

Stress

TopologicalSensitivity

StrainEnergyDensity

VonMisesStress

Temperature

HeatFlux

BoundaryVelocity

BoundarySensitivity

property name

class PyIntact.Query

class PyIntact.FieldQuery(*args, **kwargs)

Bases: Query

This class describes a query over a field. This query can be for a specific field component, or the norm of the field.

Overloaded function.

__init__(self: PyIntact.FieldQuery, *, f: PyIntact.Field, norm: bool = False) -> None

Parameter f:
The field to sample

Parameter norm:
Whether to compute the norm of the field.

__init__(self: PyIntact.FieldQuery, *, f: PyIntact.Field, scheme: Intact::IndexScheme, norm: bool = False) -> None

Parameter f:
The field to sample

Parameter scheme:
The indexing scheme for the field

Parameter norm:
Whether to compute the norm of the field.

__init__(self: PyIntact.FieldQuery, *, f: PyIntact.Field, component: int) -> None

Parameter f:
The field to sample

Parameter component:
The field component to sample

__init__(self: PyIntact.FieldQuery, *, f: PyIntact.Field, component: int, scheme: Intact::IndexScheme) -> None

Parameter f:
The field to sample

Parameter component:
The field component to sample

Parameter scheme:
The indexing scheme for the field

class PyIntact.StatisticalQuery(*args, **kwargs)

Bases: Query

This class describes a query for a statistic over a field. This query can be for the minimum, maximum or mean value of the field.

Overloaded function.

__init__(self: PyIntact.StatisticalQuery, *, f: PyIntact.Field, s: PyIntact.StatisticalQueryType, norm: bool = False) -> None

Parameter f:
The field to sample.

Parameter s:
The statistic to query for.

Parameter norm:
Whether to compute the norm of the field.

__init__(self: PyIntact.StatisticalQuery, *, f: PyIntact.Field, component: int, s: PyIntact.StatisticalQueryType) -> None

Parameter f:
The field to sample.

Parameter component:
The field component to sample.

Parameter s:
The statistic to query for.

__init__(self: PyIntact.StatisticalQuery, *, f: PyIntact.Field, s: PyIntact.StatisticalQueryType, scheme: Intact::IndexScheme, norm: bool) -> None

Parameter f:
The field to sample.

Parameter s:
The statistic to query for.

Parameter scheme:
The indexing scheme for the field

Parameter norm:
Whether to compute the norm of the field.

__init__(self: PyIntact.StatisticalQuery, *, f: PyIntact.Field, component: int, s: PyIntact.StatisticalQueryType, scheme: Intact::IndexScheme) -> None

Parameter f:
The field to sample.

Parameter component:
The field component to sample.

Parameter s:
The statistic to query for.

Parameter scheme:
The indexing scheme for the field

class PyIntact.IndexScheme

class PyIntact.DiscreteIndex(self: PyIntact.DiscreteIndex, i: int)

Bases: IndexScheme

An index into a collection of solutions.

A DiscreteIndex may represent indexing into a solution that has multiple results. For example, a modal simulation that solved for five eigenvalues will have five sets of results where each result is an eigenvalue, representing the frequency, and an eigenmode, representing displacement characteristic of that vibration mode. A DiscreteIndex would be used to separately access the first such result, the second, etc.

Parameter i:
The index.

class PyIntact.NullIndex

Bases: IndexScheme

class PyIntact.VectorArray(*args, **kwargs)

This class represents an array of constant-sized vector data. It wraps a flat std::vector<double> for cache performance, but structures the queries so that indexing errors are unlikely.

Overloaded function.

__init__(self: PyIntact.VectorArray) -> None

__init__(self: PyIntact.VectorArray, arg0: int, arg1: int) -> None

__init__(self: PyIntact.VectorArray, arg0: list[float], arg1: int) -> None

dimension(self: PyIntact.VectorArray) -> int

get(self: PyIntact.VectorArray, index: int, component: int) -> float

Get the component at the given index.

Parameter index:
The index

Parameter component:
The component

Returns:

Returns the component at the given index value.

n_tuples(self: PyIntact.VectorArray) -> int

Gives the number of tuples stored in this vector array.

Returns:

The full size of the raw data divided by the vector m_dimension.

raw_data(self: PyIntact.VectorArray) -> list[float]

class PyIntact.QueryResult(*args, **kwargs)

This class describes a query result. The buffer contains a list of scalar values, however the amount of data depends on the query type that produced it.

Overloaded function.

__init__(self: PyIntact.QueryResult, model: PyIntact.MaterialDomain) -> None

Constructs a new query result over the given material domain. Note that if the underlying model is a VoxelModel, the data will be sampled at the centroids of each voxel, and the data will be persisted in the same order as the voxels themselves. Otherwise, the data will be sampled at the points of the model and persisted in the same order as the points.

__init__(self: PyIntact.QueryResult, assembly: list[PyIntact.MaterialDomain]) -> None

Constructs a new query result over the given assembly. Note that if the underlying model is a VoxelModel, the data will be sampled at the centroids of each voxel, and the data will be persisted in the same order as the voxels themselves. Otherwise, the data will be sampled at the points of the model and persisted in the same order as the points.

addData(self: PyIntact.QueryResult, query: PyIntact.Query, data: PyIntact.VectorArray) -> None

Adds the result of computing query to this object.

Parameter query:
The query being computed.

Parameter data:
The data result of the query.

getData(self: PyIntact.QueryResult, query: PyIntact.Query) -> `PyIntact.VectorArray <#PyIntact.VectorArray>`_

Returns the vector-valued data indexed by the given query. Note that this method can throw an error if the query data has not been precomputed. Use hasData to ensure that such data has been computed.

Parameter query:
The query whose results are to be returned

Returns:

The vector-valued output of the query.

hasData(self: PyIntact.QueryResult, query: PyIntact.Query) -> bool

Determines if data exists for a given query.

Parameter query:
The query whose results we are checking on.

Returns:

True if data has been computed, False otherwise.

writeVTK(self: PyIntact.QueryResult, filename: str, unit_system: Intact::UnitSystemType) -> None

Writes a vtk file containing the results that have been stored on this object.

Parameter filename:
The filename to write to. If it does not end in “.vtu”, the “.vtu” will be appended to the filename.

Parameter unit_system:
The Unitsystem to use when attaching units to the sampled data.

class PyIntact.UnitSystem(self: PyIntact.UnitSystem, value: int)

Members:

MeterKilogramSecond

CentimeterGramSecond

MillimeterMegagramSecond

FootPoundSecond

InchPoundSecond

property name

class PyIntact.Metadata

property basis_order

The order of basis function approximation to use. We support linear (= 1) and quadratic (= 2).

property cell_size

The exact simulation cell size to use.

Warning: Setting the cell_size overrides the resolution.

property integrator_override

For some physics types, there may be multiple integrator implementations available. This field allows you to override the default solver.

property max_iterations_multiplier

max_iterations_multiplier is used to control the maximum number of iterations of a solver from the AMG family of solvers. Use a value less than 1 to reduce the maximum number of iterations and reduce the solver runtime.

property moment_order

moment_order is the order of moments computed for integration. Use lower for faster runtime, at an accuracy cost. This number must be at least 2 and can be as high as 6-7. The default is 3.

property resolution

resolution is the number of finite elements to compute over. Note that Intact will only approximate the target number of cells. Either this member or the cell_size must be set, or else Intact will throw an error.

property solver_override

For some integrator types, there are multiple sparse linear solvers available. Please see the user’s manual for information about the available options. The default is AMGCL_amg.

property tolerance

The tolerance of the linear solver. Use a smaller tolerance for more accurate simulations and longer runtime. Use a larger tolerance for less accurate simulations and shorter runtime. Default is 1e-8.

class PyIntact.ThermalMetadata

property environment_temperature

The temperature of the environment.

class PyIntact.ModalMetadata

property desired_eigenvalues

The number of eigenvalues or natural frequencies to calculate.

class PyIntact.BucklingMetadata

property desired_eigenvalues

The number of eigenvalues or critical load factors to calculate.

class PyIntact.LevelOptMetadata

property enable_fixed_interfaces

Make interfaces between components a fixed part of the design domain when true, or allow these interfaces to be optimized away when false.

property fix_thickness

The thickness of material that must be retained around a boundary condition or interface between components.

property move_limit

Move limit for level set.

property num_load_cases

The number of load cases that apply to this topology optimization scenario.

property opt_max_iter

Maximum number of iterations.

property smooth_iter

Smooth output after this number of iterations.

property vol_frac_cons

Target volume fraction.

property voxelSize

Cell size for topology optimization level set.

class PyIntact.Solver(self: PyIntact.Solver, value: int)

Members:

AMGCL_cg : Iterative conjugate gradient solver without preconditioner.

AMGCL_ilu0_cg : Iterative conjugate gradient solver with ilu0 preconditioner.

AMGCL_damped_jacobi_cg : Iterative conjugate gradient solver with damped jacobi preconditioner.

AMGCL_amg : Iterative AMG based solver with smoothed aggregation. This is the default solver for thermal scenarios.

AMGCL_amg_rigid_body : Iterative AMG based solver with rigid body modes based coarsening. This is the default solver for linear elasticity. This solver cannot be used with thermal scenarios.

Eigen_SparseLU : Direct solver that uses LU decomposition.

MKL_PardisoLDLT : PardisoLDLT is proprietary direct solver provided by Intel through MKL. Use Intact::mklPresent() to check whether this feature is available.

MKL_PardisoLLT : PardisoLLT is proprietary direct solver provided by Intel through MKL. Use Intact::mklPresent() to check whether this feature is available.

MKL_PardisoLU : PardisoLU is proprietary direct solver provided by Intel through MKL. Use Intact::mklPresent() to check whether this feature is available.

property name

class PyIntact.Integrator(self: PyIntact.Integrator, value: int)

Members:

IntactModal

IntactLinearElasticity

MPCLinearElasticity

MPCStaticThermal

LinearBuckling

property name

class PyIntact.AbstractBoundaryConditionDescriptor

property boundary

The boundary where the boundary condition is applied.

property load_case_id

The load case to which this boundary condition belongs.

property units

The unit system. If not set, then the default value is MeterKilogramSecond.

class PyIntact.TractionDescriptor

Bases: AbstractBoundaryConditionDescriptor

class PyIntact.VectorForceDescriptor(self: PyIntact.VectorForceDescriptor)

Bases: TractionDescriptor

Describes a vector force applied uniformly over the specified boundary.

property direction

The direction of the force.

property magnitude

The magnitude of the force.

class PyIntact.HydrostaticForceDescriptor(self: PyIntact.HydrostaticForceDescriptor)

Bases: TractionDescriptor

Simulates a body submerged in liquid.

property density

The density of the liquid in which the body is submerged.

property height

The height the liquid rises above the z=0 plane.

class PyIntact.PressureForceDescriptor(self: PyIntact.PressureForceDescriptor)

Bases: TractionDescriptor

Describes a pressure load (force per unit area) applied normal to the boundary.

property magnitude

The magnitude of the pressure load.

class PyIntact.TorqueForceDescriptor(self: PyIntact.TorqueForceDescriptor)

Bases: TractionDescriptor

Describes a torque load applied to the boundary.

property axis

The axis of rotation of the torque load.

property magnitude

The magnitude of the torque load.

property origin

The origin of the axis of rotation of the torque.

class PyIntact.BearingForceDescriptor(self: PyIntact.BearingForceDescriptor)

Bases: TractionDescriptor

Describes a load at the contact between two curved surfaces. The contact pressure is not uniform. It is scaled by the angle of the contact relative to the angle of the force.

property direction

The direction of the force.

property magnitude

The magnitude is the total force applied over the entire surface.

class PyIntact.FixedBoundaryDescriptor(self: PyIntact.FixedBoundaryDescriptor)

Bases: AbstractBoundaryConditionDescriptor

This class describes a fixed solution quantity (also known as a Dirichlet boundary condition). In order to set the value to fix the solution, set the value member. Note that not all scenarios support inhomogeneous Dirichlet conditions.

property value

The value of the boundary condition.

class PyIntact.FixedVectorDescriptor(self: PyIntact.FixedVectorDescriptor)

Bases: AbstractBoundaryConditionDescriptor

Describes a fixed vector quantity.

A fixed vector boundary condition can represent fixing displacement at some non-zero value, or it can represent partial restraints, also known as axis-aligned sliding restraints.

Displacement is a three dimensional field, and each displacement component can optionally be specified. Any axis not specified will not be restrained.

property x_value

The value of the boundary condition in the x-direction.

property y_value

The value of the boundary condition in the y-direction.

property z_value

The value of the boundary condition in the z-direction.

class PyIntact.SlidingBoundaryDescriptor(self: PyIntact.SlidingBoundaryDescriptor)

Bases: AbstractBoundaryConditionDescriptor

Describes a sliding boundary condition, which prevents displacement in the direction normal to the specified surface, and permits displacement tangential to the surface.

class PyIntact.ConvectionDescriptor(self: PyIntact.ConvectionDescriptor)

Bases: AbstractBoundaryConditionDescriptor

Describes the convective transfer of heat from a surrounding medium.

property coefficient

The coefficient of convection.

property environment_temperature

The temperature of the surrounding medium.

class PyIntact.ConstantFluxDescriptor(self: PyIntact.ConstantFluxDescriptor)

Bases: AbstractBoundaryConditionDescriptor

Describes a constant flux per unit surface area.

property magnitude

The magnitude of the flux.

class PyIntact.AbstractInternalConditionDescriptor

property instance_id

The instance id of the Model that this internal condition is applied to. If not set, then this internal condition is applied to every instance.

property units

The unit system. If not set, then the default value is MeterKilogramSecond.

class PyIntact.BodyLoadDescriptor(self: PyIntact.BodyLoadDescriptor)

Bases: AbstractInternalConditionDescriptor

Describes body load caused by linear acceleration.

property direction

The direction of the acceleration.

property magnitude

The magnitude of the acceleration.

class PyIntact.RotationalLoadDescriptor(self: PyIntact.RotationalLoadDescriptor)

Bases: AbstractInternalConditionDescriptor

Describes a rotational load on a body.

property angular_acceleration

The angular acceleration.

property angular_velocity

The angular velocity.

property axis

The axis of rotation of the rotational load.

property origin

The origin of the axis of rotation of the rotational load.

class PyIntact.ConstantHeatDescriptor(self: PyIntact.ConstantHeatDescriptor)

Bases: AbstractInternalConditionDescriptor

Describes the uniform generation of heat within a body.

property magnitude

The magnitude of the body heat flux.

class PyIntact.AbstractMaterialDescriptor

An abstract description of a material.

property density

The material density.

property units

The unit system. If not set, then the default value is MeterKilogramSecond.

class PyIntact.IsotropicMaterialDescriptor(self: PyIntact.IsotropicMaterialDescriptor)

Bases: AbstractMaterialDescriptor

Describes an isotropic material, which has the same behavior no matter the direction of the forces applied.

property compressive_strength

The ultimate strength in compression of the material.

property poisson_ratio

The Poisson ratio of the material.

property tensile_strength

The ultimate strength in tension of the material.

property yield_strength

The yield strength of the material.

property youngs_modulus

The Young’s modulus of the material.

class PyIntact.OrthotropicMaterialDescriptor(self: PyIntact.OrthotropicMaterialDescriptor)

Bases: AbstractMaterialDescriptor

property Ex

The elastic modulus in the x-direction

property Ey

The elastic modulus in the y-direction

property Ez

The elastic modulus in the z-direction

property Gxy

The shear modulus in the xy plane.

property Gxz

The shear modulus in the xz plane.

property Gyz

The shear modulus in the yz plane.

property transform

A transformation matrix to change the material orientation.

property vxy

The poisson ratio in the xy plane.

property vxz

The poisson ratio in the xz plane.

property vyz

The poisson ratio in the yz plane.

class PyIntact.ThermalMaterialDescriptor(self: PyIntact.ThermalMaterialDescriptor)

Bases: AbstractMaterialDescriptor

Describes the thermal properties of an isotropic material.

property conductivity

The thermal conductivity.

property expansion_coefficient

The coefficient of thermal expansion (optional).

property specific_heat

The specific heat of the material.

class PyIntact.AbstractScenarioDescriptor

property boundary_conditions

The collection of boundary conditions to be applied.

property materials

The mapping of a material identifier, usually the material name, to the material.

property metadata

Metadata about the simulation to be performed.

class PyIntact.LinearElasticScenarioDescriptor(self: PyIntact.LinearElasticScenarioDescriptor)

Bases: AbstractScenarioDescriptor

Describes a linear elastic scenario to be simulated.

property internal_conditions

The collection of the internal conditions, such as a gravity load, to be applied.

class PyIntact.ModalScenarioDescriptor(self: PyIntact.ModalScenarioDescriptor)

Bases: AbstractScenarioDescriptor

class PyIntact.LinearBucklingScenarioDescriptor(self: PyIntact.LinearBucklingScenarioDescriptor)

Bases: AbstractScenarioDescriptor

Describes a linear buckling scenario to be simulated.

property internal_conditions

The collection of the internal conditions, such as a gravity load, to be applied.

class PyIntact.StaticThermalScenarioDescriptor(self: PyIntact.StaticThermalScenarioDescriptor)

Bases: AbstractScenarioDescriptor

class PyIntact.LevelOptScenarioDescriptor(self: PyIntact.LevelOptScenarioDescriptor)

Bases: AbstractScenarioDescriptor

Describes a level set optimization.

property internal_conditions

The collection of the internal conditions, such as a gravity load, to be applied.

class PyIntact.Simulator

Generic Simulation Manager

cellComplex(self: PyIntact.Simulator) -> list[tuple[Annotated[list[float], FixedSize(3)], Annotated[list[float], FixedSize(3)]]]

Get the simulation grid.

Returns:

A vector of pairs of points that represent the minimum and maximum of the bounding box of each cell in the simulation grid.

cellCount(self: PyIntact.Simulator) -> int

Get the number of cells in the simulation grid.

cellSize(self: PyIntact.Simulator) -> float

Get the size of each cell in the simulation grid.

sample(*args, **kwargs)

Overloaded function.

sample(self: PyIntact.Simulator, query: PyIntact.Query, result: PyIntact.QueryResult) -> PyIntact.VectorArray

Sample the given query over the domain provided.

Parameter query:
The result to query for.

Parameter result:
The query result.

Returns:

The values of the query.

sample(self: PyIntact.Simulator, sample_points: list[Annotated[list[float], FixedSize(3)]], material_name: str, field_queries: list[PyIntact.FieldQuery]) -> list[PyIntact.VectorArray]

Sample at the given points, producing results for each query

Parameter sample_points:
The sample points

Parameter material_name:
Name of the material associated with points

Parameter field_queries:
The field queries to be answered

Returns:

The values of the field queries at the query points, in order

solve(self: PyIntact.Simulator) -> PyIntact.SolutionStats

Solve the simulation that has been constructed.

Returns:

The number of iterations performed by the solver and the error.

class PyIntact.StressSimulator(*args, **kwargs)

Bases: Simulator

Simulation Manager for Stress Scenarios

Overloaded function.

__init__(self: PyIntact.StressSimulator, assembly: list[PyIntact.MaterialDomain], descriptor: PyIntact.LinearElasticScenarioDescriptor) -> None

__init__(self: PyIntact.StressSimulator, assembly: list[PyIntact.MaterialDomain], descriptor: PyIntact.LinearElasticScenarioDescriptor, thermal_simulator: Intact::StaticThermalSimulator) -> None

Construct a linear elastic scenario

Parameter assembly:
A collection of MaterialDomains.

Parameter descriptor:
A LinearElasticScenarioDescriptor that describes the simulation.

Parameter solution_paths:
A collection of paths of existing solution files.

class PyIntact.ModalSimulator(self: PyIntact.ModalSimulator, assembly: list[PyIntact.MaterialDomain], descriptor: PyIntact.ModalScenarioDescriptor)

Bases: Simulator

Simulation Manager for Modal Scenarios

Construct a modal elastic scenario.

Parameter assembly:
A collection of MaterialDomains.

Parameter descriptor:
A ModalScenarioDescriptor that describes the simulation.

class PyIntact.LinearBucklingSimulator(self: PyIntact.LinearBucklingSimulator, assembly: list[PyIntact.MaterialDomain], descriptor: PyIntact.LinearBucklingScenarioDescriptor)

Bases: Simulator

Simulation Manager for linear buckling scenarios

Construct a linear buckling scenario.

Parameter assembly:
A collection of MaterialDomains.

Parameter descriptor:
A LinearBucklingScenarioDescriptor that describes the simulation.

class PyIntact.StaticThermalSimulator(self: PyIntact.StaticThermalSimulator, assembly: list[PyIntact.MaterialDomain], descriptor: PyIntact.StaticThermalScenarioDescriptor)

Bases: Simulator

Simulation Manager for Static Thermal Scenarios

Construct a static thermal scenario

Parameter assembly:
A collection of MaterialDomains.

Parameter descriptor:
A StaticThermalScenarioDescriptor that describes the simulation.

class PyIntact.LevelOpt(self: PyIntact.LevelOpt, design_domain: PyIntact.MaterialDomain, assembly: list[PyIntact.MaterialDomain], descriptor: PyIntact.LevelOptScenarioDescriptor, initial_design: PyIntact.MeshModel)

Construct a level set-based topology optimization scenario

Parameter design_domain:
The design domain.

Parameter assembly:
A collection of MaterialDomains.

Parameter descriptor:
A LevelOptScenarioDescriptor that describes the simulation and optimization.

Parameter initial_design:
An initial design.

getDesigns(self: PyIntact.LevelOpt) -> list[`PyIntact.MeshModel <#PyIntact.MeshModel>`_]

Get the designs from this LevelOpt.

Returns:

A vector of MeshModel, one each representing a design.

optimize(self: PyIntact.LevelOpt) -> PyIntact.SolutionStats

Perform the level set optimization.

sample(self: PyIntact.LevelOpt, arg0: PyIntact.Query) -> `PyIntact.VectorArray <#PyIntact.VectorArray>`_

Sample the available fields on the design domain boundary.

A LevelOpt allows sampling the design domain for the boundary velocities and sensitivities, to allow user control of modification of the design domain. The sampling points cannot be specified by the user.

Parameter query:
The query to query for.

Returns:

The values of the query.

PyIntact.setupLogging(log_level: int, catch_sig: bool = True) -> None

Initialize logging

Parameter log_level:
The max log level: 0 is info, -1 is warning, -2 is errors

Parameter catch_sig:
Whether Intact should gracefully handle signals. For testing purposes where exit code of the program is important, set to false.