Struct cellular_raza_building_blocks::CartesianCuboid3New

pub struct CartesianCuboid3New {
    pub min: [f64; 3],
    pub max: [f64; 3],
    pub n_voxels: [i64; 3],
    pub dx_voxels: [f64; 3],
    pub rng_seed: u64,
}

Cartesian cuboid in 3D with float type f64

Fields

min: [f64; 3]

Lower boundary of domain

max: [f64; 3]

Upper boundary of domain

n_voxels: [i64; 3]

Number of voxels in domain along axes

dx_voxels: [f64; 3]

Length of individual voxels in domain

rng_seed: u64

Initial seed from which to generate seeds for voxels

Implementations

impl CartesianCuboid3New

pub fn from_boundaries_and_interaction_ranges( min: [f64; 3], max: [f64; 3], interaction_ranges: [f64; 3] ) -> Result<CartesianCuboid3New, CalcError>

Construct the domain from given lower/upper boundaries and maximum length of interaction ranges along axes.

pub fn from_boundaries_and_n_voxels( min: [f64; 3], max: [f64; 3], n_vox: [usize; 3] ) -> Result<CartesianCuboid3New, CalcError>

Construct the domain from given lower/upper boundaries and number of voxels along axes.

Trait Implementations

impl Clone for CartesianCuboid3New

fn clone(&self) -> CartesianCuboid3New

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CartesianCuboid3New

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CartesianCuboid3New

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 HasPyGilRef for CartesianCuboid3New

type AsRefTarget = PyCell<CartesianCuboid3New>

Utility type to make Py::as_ref work.

impl IntoPy<Py<PyAny>> for CartesianCuboid3New

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

Performs the conversion.

impl PyClass for CartesianCuboid3New

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for CartesianCuboid3New

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<CartesianCuboid3New>

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> for &'a CartesianCuboid3New

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

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

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut CartesianCuboid3New

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

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

impl PyTypeInfo for CartesianCuboid3New

const NAME: &'static str = "CartesianCuboid3New"

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<'_>) -> &PyType

👎Deprecated since 0.21.0: PyTypeInfo::type_object will be replaced by PyTypeInfo::type_object_bound in a future PyO3 version

Returns the safe abstraction over the type object.

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

Returns the safe abstraction over the type object.

fn is_type_of(object: &PyAny) -> bool

👎Deprecated since 0.21.0: PyTypeInfo::is_type_of will be replaced by PyTypeInfo::is_type_of_bound in a future PyO3 version

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

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

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

fn is_exact_type_of(object: &PyAny) -> bool

👎Deprecated since 0.21.0: PyTypeInfo::is_exact_type_of will be replaced by PyTypeInfo::is_exact_type_of_bound in a future PyO3 version

Checks if object is an instance of this type.

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

Checks if object is an instance of this type.

impl Serialize for CartesianCuboid3New

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl DerefToPyAny for CartesianCuboid3New