Struct CartesianSubDomain3

pub struct CartesianSubDomain3 {
    pub voxels: Vec<CartesianVoxel3>,
    /* private fields */
}

Subdomain of CartesianCuboid3New

The subdomain contains voxels

Fields

voxels: Vec<CartesianVoxel3>

All voxels contained in this subdomain

Trait Implementations

impl Clone for CartesianSubDomain3

fn clone(&self) -> CartesianSubDomain3

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CartesianSubDomain3

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CartesianSubDomain3

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C, I: IntoIterator<Item = C>> Domain<C, CartesianSubDomain3, I> for CartesianCuboid3New

where C: Position<SVector<f64, 3>>,

fn decompose( self, n_subdomains: NonZeroUsize, cells: I, ) -> Result<DecomposedDomain<Self::SubDomainIndex, CartesianSubDomain3, C>, DecomposeError>

Much more research must be done to effectively write this function. We should be using more sophisticated functionality based on common known facts for minimizing surface area and number of neighbors. For more information also see

• Wikipedia
• Math StackExchange

type SubDomainIndex = usize

Subdomains can be identified by their unique SubDomainIndex. The backend uses this property to construct a mapping (graph) between subdomains.

type VoxelIndex = [i64; 3]

Similarly to the SubDomainIndex, voxels can be accessed by their unique index. The backend will use this information to construct a mapping (graph) between voxels inside their respective subdomains.

impl IntoPy<Py<PyAny>> for CartesianSubDomain3

fn into_py(self, py: Python<'_>) -> PyObject

👎Deprecated since 0.23.0: IntoPy is going to be replaced by IntoPyObject. See the migration guide (https://pyo3.rs/v0.23.0/migration) for more information.

Performs the conversion.

impl<'py> IntoPyObject<'py> for CartesianSubDomain3

type Target = CartesianSubDomain3

The Python output type

type Output = Bound<'py, <CartesianSubDomain3 as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for CartesianSubDomain3

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for CartesianSubDomain3

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<CartesianSubDomain3>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a CartesianSubDomain3

type Holder = Option<PyRef<'py, CartesianSubDomain3>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a mut CartesianSubDomain3

type Holder = Option<PyRefMut<'py, CartesianSubDomain3>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyTypeInfo for CartesianSubDomain3

const NAME: &'static str = "CartesianSubDomain3"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>

👎Deprecated since 0.23.0: renamed to PyTypeInfo::type_object

Deprecated name for [PyTypeInfo::type_object].

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_type_of

Deprecated name for [PyTypeInfo::is_type_of].

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_exact_type_of

Deprecated name for [PyTypeInfo::is_exact_type_of].

impl Serialize for CartesianSubDomain3

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C> SortCells<C> for CartesianSubDomain3

where C: Position<SVector<f64, 3>>,

type VoxelIndex = [i64; 3]

An index which determines to which next smaller unit the cell should be assigned.

fn get_voxel_index_of( &self, cell: &C, ) -> Result<Self::VoxelIndex, BoundaryError>

If given a cell, we can sort this cell into the corresponding sub unit.

impl SubDomain for CartesianSubDomain3

type VoxelIndex = [i64; 3]

Individual Voxels inside each subdomain can be accessed by this index.

fn get_neighbor_voxel_indices( &self, index: &Self::VoxelIndex, ) -> Vec<Self::VoxelIndex>

Obtains the neighbor voxels of the specified voxel index. This function behaves similarly to [SortCells::get_voxel_index_of] in that it also has to return indices which are in other SubDomains.

fn get_all_indices(&self) -> Vec<Self::VoxelIndex>

Get all voxel indices of this [SubDomain].

impl SubDomainMechanics<Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>> for CartesianSubDomain3

fn apply_boundary( &self, pos: &mut SVector<f64, 3>, velocity: &mut SVector<f64, 3>, ) -> Result<(), BoundaryError>

If the subdomain has boundary conditions, this function will enforce them onto the cells. For the future, we plan to replace this function to additionally obtain information about the previous and current location of the cell.

impl DerefToPyAny for CartesianSubDomain3