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 <#PyIntact.Model>`_ Overloaded function. 1. __init__(self: PyIntact.MeshModel) -> None Construct an empty MeshModel. 1. __init__(self: PyIntact.MeshModel, other: PyIntact.MeshModel) -> None Construct a MeshModel from an existing MeshModel. Parameter ``other``: A MeshModel. 1. __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. 1. 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. 1. 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 <#PyIntact.Model>`_ Represents a model based on an openVDB volume. Overloaded function. 1. __init__(self: PyIntact.VDBModel, filename: str) -> None Load a VDBModel from a file. Parameter ``filename``: The VDB file. 1. __init__(self: PyIntact.VDBModel, grid: openvdb::v9_1::Grid, 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 <#PyIntact.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. 1. __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. 1. __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. 1. __init__(self: PyIntact.FieldQuery, *, f: PyIntact.Field, component: int) -> None Parameter ``f``: The field to sample Parameter ``component``: The field component to sample 1. __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 <#PyIntact.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. 1. __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. 1. __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. 1. __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. 1. __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 <#PyIntact.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 <#PyIntact.IndexScheme>`_ **class PyIntact.VectorArray(*args, **kwargs)** This class represents an array of constant-sized vector data. It wraps a flat std::vector for cache performance, but structures the queries so that indexing errors are unlikely. Overloaded function. 1. __init__(self: PyIntact.VectorArray) -> None 2. __init__(self: PyIntact.VectorArray, arg0: int, arg1: int) -> None 3. __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. 1. __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. 1. __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 <#PyIntact.AbstractBoundaryConditionDescriptor>`_ **class PyIntact.VectorForceDescriptor(self: PyIntact.VectorForceDescriptor)** Bases: `TractionDescriptor <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.AbstractScenarioDescriptor>`_ **class PyIntact.LinearBucklingScenarioDescriptor(self: PyIntact.LinearBucklingScenarioDescriptor)** Bases: `AbstractScenarioDescriptor <#PyIntact.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 <#PyIntact.AbstractScenarioDescriptor>`_ **class PyIntact.LevelOptScenarioDescriptor(self: PyIntact.LevelOptScenarioDescriptor)** Bases: `AbstractScenarioDescriptor <#PyIntact.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. 1. 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. 1. 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 <#PyIntact.Simulator>`_ Simulation Manager for Stress Scenarios Overloaded function. 1. __init__(self: PyIntact.StressSimulator, assembly: list[PyIntact.MaterialDomain], descriptor: PyIntact.LinearElasticScenarioDescriptor) -> None 2. __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 <#PyIntact.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 <#PyIntact.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 <#PyIntact.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.