pointsource_pde: comparison src/dolfinx

-:a4137aedcb3a
+:c3a4f4bb87f7
 /*!
-Python and C++ wrapper for Dolfinx Function<f64>
+Python and C++ wrapper for Dolfinx `Function<f64>`.
 */
 use super::ffi;
 use super::ffi::Function_f64;
 use alg_tools::bounds::{Bounds, GlobalAnalysis, MinMaxMapping};
 owned: bool,
 /// C++ object pointer
 cxx: *mut Function_f64,
 }
+/// References to Python side helper routines
 struct Helpers {
+/// Dot product
 dot: Py<PyFunction>,
+/// Squared 2-norm
 norm2_squared: Py<PyFunction>,
+/// Squared distance
 dist2_squared: Py<PyFunction>,
 }
 use std::sync::OnceLock;
+/// A populated-once structure for referencing Python-side helper routines.
 static HELPERS: OnceLock<Helpers> = OnceLock::new();
+/// Gets [`Helpers`], populates [`HELPERS`] if needed.
 fn get_helpers(py: Python<'_>) -> PyResult<&Helpers> {
 HELPERS.get_or_try_init(|| {
 let extras = PyModule::import(py, "pointsource_pde.dolfinx_extras")?;
 let g = |s| -> PyResult<Py<PyFunction>> { Ok(extras.getattr(s)?.cast_into()?.unbind()) };
 Ok(Helpers {
 if let None = self.u {
 if self.cxx != std::ptr::null_mut() {
 unsafe { ffi::drop_Function_f64(self.cxx) };
 }
 }
+self.cxx = std::ptr::null_mut();
 }
 }
 impl<'py, const N: u32, const O: u32, const D: u32> Clone for DolfinxPyFunction_f64<'py, N, O, D> {
 fn clone(&self) -> Self {
 DolfinxPyFunction_f64 {
 u: None, // It's a different new function, so no Python instance
 function_space: self.function_space.clone(),
-owned: self.owned,
+owned: true,
 cxx: unsafe { ffi::clone_Function_f64(self.cxx) },
 }
 }
 }
 }
 }
 /// Returns a (possibly new) Python presentation, without consuming current object.
 ///
-/// Please use this functionality through [`pyo3::types::IntoPyObject`].
+/// Please use this functionality through [`pyo3::IntoPyObject`].
 pub(crate) fn _into_py_ref<'a>(
 &'a mut self,
 py: Python<'py>,
 ) -> PyResult<pyo3::Borrowed<'a, 'py, PyAny>> {
 self._make_py(py);
 }
 }
 /// Returns a (possibly new) Python presentation, consuming current object.
 ///
-/// Please use this functionality through [`pyo3::types::IntoPyObject`].
+/// Please use this functionality through [`pyo3::IntoPyObject`].
 pub(crate) fn _into_py(mut self, py: Python<'py>) -> PyResult<pyo3::Bound<'py, PyAny>> {
 self._make_py(py);
 self.cxx = std::ptr::null_mut();
 self.owned = false;
 match std::mem::replace(&mut self.u, None) {
 }
 new
 }
 }
+/// An extremely durty hack to create a Python-side Dolfinx `Function` referencing
+/// a C++-side Dolfinx `Function` that we already have. For some unfathomable reason,
+/// Dolfinx provies no way to do this cleanly.
 pub(crate) static CREATE_FUNCTION_HACK: &CStr = c_str!(
 "\
 from dolfinx.fem import Function
 from dolfinx.la import Vector
 x = Vector(cpp_object.x)
 wrapper._x = x
 wrapper.name = \"?\"
 "
 );
+/// Trait for points that can be expanded into Dolfinx' always-3D presentation
 trait ExpandCoordDolphinx {
+/// Convert to always-3D presentation
 fn to_dolphinx(self) -> [f64; 3];
 #[allow(dead_code)]
+/// Convert from always-3D presentation
 fn from_dolphinx(val: [f64; 3]) -> Self;
 }
 impl ExpandCoordDolphinx for Loc<1, f64> {
 #[inline]
 fn from_dolphinx([x1, x2, x3]: [f64; 3]) -> Self {
 [x1, x2, x3].into()
 }
 }
+/// Implements [`DifferentiableImpl`]
 macro_rules! impl_diff {
 ($n:literal ; $($o:literal)+) => { $(
 impl<'py> DifferentiableImpl<Loc<$n, f64>> for DolfinxPyFunction_f64<'py, $n, $o, 1> {
 type Derivative = Loc<$n, f64>;
 }
 }
 )+ };
 }
+/// Implements [`Mapping`]
 macro_rules! impl_mapping {
 ($($n:literal)+) => { $(
 impl<'py, const O: u32> Mapping<Loc<$n, f64>> for DolfinxPyFunction_f64<'py, $n, O, 1> {
 type Codomain = f64;
 }
 }
 */
 impl<'py, const N: u32, const O: u32, const D: u32> DolfinxPyFunction_f64<'py, N, O, D> {
+fn new_cxx(&mut self, new: *mut Function_f64) {
+if let None = self.u {
+if self.cxx != std::ptr::null_mut() {
+unsafe { ffi::drop_Function_f64(self.cxx) };
+}
+}
+self.cxx = new;
+self.u = None;
+self.owned = true;
+}
 /// If owned, call `f_valid` with mutable data.
 /// If not owned, create a new C++ fem.Function, uninitialised, and call `f_invalid` with its
 /// mutable data, as well as the original immutable data.
 #[inline]
 fn with_mut_data_and_orig<F, G, Z>(&mut self, f_valid: F, f_invalid: G) -> Z
 where
 F: Fn(&mut [f64]) -> Z,
 G: Fn(&mut [f64], &[f64]) -> Z,
 {
 if self.owned {
-return f_valid(unsafe { ffi::data_mut_Function_f64(self.cxx) });
+let res = f_valid(unsafe { ffi::data_mut_Function_f64(self.cxx) });
+unsafe { ffi::scatter_fwd_Function_f64(self.cxx) };
+return res;
 } else {
 // Create a completely new Function
 let old_data = unsafe { ffi::data_mut_Function_f64(self.cxx) };
 let new = unsafe { ffi::similar_Function_f64(self.cxx) };
 let new_data = unsafe { ffi::data_mut_Function_f64(new) };
 let res = f_invalid(new_data, old_data);
+unsafe { ffi::scatter_fwd_Function_f64(new) };
 // Invalidate Python reference; we're managing the object now
-self.cxx = new;
+self.new_cxx(new);
-self.u = None;
-self.owned = true;
 return res;
 }
 }
 /// If owned, call `f` with mutable data.
 fn with_mut_data<F, Z>(&mut self, f: F) -> Z
 where
 F: Fn(&mut [f64]) -> Z,
 {
 if self.owned {
-return f(unsafe { ffi::data_mut_Function_f64(self.cxx) });
+let res = f(unsafe { ffi::data_mut_Function_f64(self.cxx) });
+unsafe { ffi::scatter_fwd_Function_f64(self.cxx) };
+return res;
 } else {
 // Create a completely new Function
 let new = unsafe { ffi::similar_Function_f64(self.cxx) };
 let new_data = unsafe { ffi::data_mut_Function_f64(new) };
 let res = f(new_data);
+unsafe { ffi::scatter_fwd_Function_f64(new) };
 // Invalidate Python reference; we're managing the object now
-self.cxx = new;
+self.new_cxx(new);
-self.u = None;
-self.owned = true;
 return res;
 }
 }
 /// Create a similar new function, and call `f` with both the mutable (unininitialised)
 // Create a completely new Function
 let new = self.similar();
 let old_data = unsafe { ffi::data_Function_f64(self.cxx) };
 let new_data = unsafe { ffi::data_mut_Function_f64(new.cxx) };
 f(new_data, old_data);
+unsafe { ffi::scatter_fwd_Function_f64(new.cxx) };
 new
 }
-/// Similar to [`with_mut_data`], but check compatibility with `other` and also pass its
+/// Similar to [`Self::with_mut_data`], but check compatibility with `other` and also pass its
 /// immutable data slice as the final argument.
 #[inline]
 fn with_mut_data_and_orig_binop<F, G, Z>(
 &mut self,
 other: &DolfinxPyFunction_f64<'py, N, O, D>,
 {
 let data_other = unsafe {
 ffi::check_compat_Function_f64(self.cxx, other.cxx).unwrap();
 ffi::data_Function_f64(other.cxx)
 };
-self.with_mut_data_and_orig(
+let res = self.with_mut_data_and_orig(
 |data_self_valid| {
 assert_eq!(data_self_valid.len(), data_other.len());
 f_valid(data_self_valid, data_other)
 },
 |data_self_invalid, data_orig| {
 assert_eq!(data_self_invalid.len(), data_other.len());
 assert_eq!(data_orig.len(), data_other.len());
 f_invalid(data_self_invalid, data_orig, data_other)
 },
-)
+);
-}
+unsafe { ffi::scatter_fwd_Function_f64(self.cxx) };
+return res;
-/// Similar to [`with_new_data_and_orig`], but check compatibility with `other` and also
+}
+/// Similar to [`Self::with_new_data_and_orig`], but check compatibility with `other` and also
 /// pass its immutable data slice as the final argument.
 #[inline]
 fn with_new_data_and_orig_binop<F>(
 &self,
 other: &DolfinxPyFunction_f64<'py, N, O, D>,
 f(data, data_orig, data_other)
 })
 }
 }
+/// Implements unary operations
 macro_rules! impl_unop {
 ($trait:ident, $fn:ident) => {
 impl<'py, const N: u32, const O: u32, const D: u32> $trait
 for DolfinxPyFunction_f64<'py, N, O, D>
 {
 use std::ops::Neg;
 impl_unop!(Neg, neg);
+/// Implements scalar operations
 macro_rules! impl_scalarop {
 ($trait:ident, $fn:ident, $trait_assign:ident, $fn_assign:ident) => {
 impl<'py, const N: u32, const O: u32, const D: u32> $trait<f64>
 for DolfinxPyFunction_f64<'py, N, O, D>
 {
 use std::ops::{Div, DivAssign, Mul, MulAssign};
 impl_scalarop!(Mul, mul, MulAssign, mul_assign);
 impl_scalarop!(Div, div, DivAssign, div_assign);
+/// Implements consuming binary operations
 macro_rules! impl_binop_consume {
 ($trait:ident, $fn:ident, $trait_assign:ident, $fn_assign:ident) => {
 impl<'py, const N: u32, const O: u32, const D: u32> $trait<Self>
 for DolfinxPyFunction_f64<'py, N, O, D>
 {
 }
 }
 };
 }
+/// Implements binary operations on references
 macro_rules! impl_binop_ref {
 ($trait:ident, $fn:ident) => {
 impl<'py, 'b, const N: u32, const O: u32, const D: u32> $trait<Self>
 for &'b DolfinxPyFunction_f64<'py, N, O, D>
 {
 }
 }
 };
 }
+/// Implements binary operations, both consuming and on references
 macro_rules! impl_binop {
 ($trait:ident, $fn:ident, $trait_assign:ident, $fn_assign:ident) => {
 impl_binop_consume!($trait, $fn, $trait_assign, $fn_assign);
 impl_binop_ref!($trait, $fn);
 };
 use std::ops::{Add, AddAssign, Sub, SubAssign};
 impl_binop!(Add, add, AddAssign, add_assign);
 impl_binop!(Sub, sub, SubAssign, sub_assign);
-//use alg_tools::euclidean::Euclidean;
 use alg_tools::linops::{VectorSpace, AXPY};
-//use alg_tools::norms::{Dist, HasDual, Norm, Normed, L2};
 use alg_tools::self_ownable;
 self_ownable!(DolfinxPyFunction_f64<'py, N, O, D> where 'py, const N: u32, const O: u32, const D: u32);
 impl<'py, const N: u32, const O: u32, const D: u32> Dist<L2, f64>

comparison: src/dolfinx_access/function.rs

src/dolfinx_access/function.rs

Mercurial > repos > pointsource_pde / file comparison

comparison: src/dolfinx_access/function.rs

src/dolfinx_access/function.rs