pub fn new(obj: Bound<'_, PyAny>) -> PyResult<Self> {

let attr = obj.hasattr("ln_lambda3")?;

if !attr {

panic!(

"{}",

"Python Class has to have a method 'ln_lambda3' with signature:\n\tdef ln_lambda3(self, temperature: HD) -> HD\nwhere 'HD' has to be any (hyper-) dual number."

)

}

Ok(Self(obj.unbind()))

}

($($py_hd_id:ident, $hd_ty:ty);*) => {

impl IdealGas for PyIdealGas {

fn ideal_gas_model(&self) -> &'static str {

"Ideal gas (Python)"

}

fn ln_lambda3<D: DualNum<f64> + Copy>(&self, temperature: D) -> D {

let mut result = D::zero();

$(

if let Some(&t) = (&temperature as &dyn Any).downcast_ref::<$hd_ty>() {

let l3_any = (&mut result as &mut dyn Any).downcast_mut::<$hd_ty>().unwrap();

*l3_any = Python::attach(|py| {

let py_result = self

.0

.bind(py)

.call_method1("ln_lambda3", (<$py_hd_id>::from(t),))

.unwrap();

<$hd_ty>::from(py_result.extract::<$py_hd_id>().unwrap())

});

return result

}

)*

panic!("ln_lambda3: input data type not understood")

}

}

};

pub fn new(obj: Bound<'_, PyAny>) -> PyResult<Self> {

let attr = obj.hasattr("components")?;

if !attr {

panic!(

"Python Class has to have a method 'components' with signature:\n\tdef signature(self) -> int"

)

}

let attr = obj.hasattr("subset")?;

if !attr {

panic!(

"Python Class has to have a method 'subset' with signature:\n\tdef subset(self, component_list: List[int]) -> Self"

)

}

let attr = obj.hasattr("molar_weight")?;

if !attr {

panic!(

"Python Class has to have a method 'molar_weight' with signature:\n\tdef molar_weight(self) -> SIArray1\nwhere the size of the returned array has to be 'components'."

)

}

let attr = obj.hasattr("max_density")?;

if !attr {

panic!(

"Python Class has to have a method 'max_density' with signature:\n\tdef max_density(self, moles: numpy.ndarray[float]) -> float\nwhere the size of the input array has to be 'components'."

)

}

let attr = obj.hasattr("helmholtz_energy")?;

if !attr {

panic!(

"{}",

"Python Class has to have a method 'helmholtz_energy' with signature:\n\tdef helmholtz_energy(self, state: StateHD) -> HD\nwhere 'HD' has to be any of {{float, Dual64, HyperDual64, HyperDualDual64, Dual3Dual64, Dual3_64}}."

)

}

Ok(Self(obj.unbind()))

}

($($py_state_id:ident, $py_hd_id:ident, $hd_ty:ty);*) => {

impl ResidualDyn for PyResidual {

fn components(&self) -> usize {

Python::attach(|py| {

let py_result = self.0.bind(py).call_method0("components").unwrap();

py_result.extract().unwrap()

})

}

fn compute_max_density<D: DualNum<f64> + Copy>(&self, molefracs: &DVector<D>) -> D {

let mut rho = D::zero();

$(

if let Some(x) = (molefracs as &dyn Any).downcast_ref::<DVector<$hd_ty>>() {

let r = (&mut rho as &mut dyn Any).downcast_mut::<$hd_ty>().unwrap();

*r = Python::attach(|py| {

let py_result = self

.0

.bind(py)

.call_method1("max_density", (x.iter().copied().map(<$py_hd_id>::from).collect::<Vec<_>>(),))

.unwrap();

<$hd_ty>::from(py_result.extract::<$py_hd_id>().unwrap())

});

return rho

}

)*

panic!("compute_max_density: input data type not understood")

}

fn reduced_helmholtz_energy_density_contributions<D: DualNum<f64> + Copy + >(

&self,

state: &StateHD<D>,

) -> Vec<(&'static str, D)> {

// result to write to

let mut a = D::zero();

$(

if let Some(s) = (state as &dyn Any).downcast_ref::<StateHD<$hd_ty>>() {

let d = (&mut a as &mut dyn Any).downcast_mut::<$hd_ty>().unwrap();

*d = Python::attach(|py| {

let py_result = self

.0

.bind(py)

.call_method1("helmholtz_energy", (<$py_state_id>::from(s.clone()),))

.unwrap();

<$hd_ty>::from(py_result.extract::<$py_hd_id>().unwrap())

});

return vec![("Python", a)]

}

)*

panic!("helmholtz_energy: input data type not understood")

}

}

impl Molarweight for PyResidual {

fn molar_weight(&self) -> MolarWeight<DVector<f64>> {

Python::attach(|py| {

let py_result = self.0.bind(py).call_method0("molar_weight").unwrap();

py_result

.extract::<MolarWeight<DVector<f64>>>()

.unwrap()

})

}

}

impl Subset for PyResidual {

fn subset(&self, component_list: &[usize]) -> Self {

Python::attach(|py| {

let py_result = self

.0

.bind(py)

.call_method1("subset", (component_list.to_vec(),))

.unwrap();

Self::new(py_result.extract().unwrap()).unwrap()

})

}

}

}

($py_state_id:ident, $py_hd_id:ident, $hd_ty:ty) => {

#[pyclass(from_py_object)]

#[derive(Clone)]

struct $py_state_id(StateHD<$hd_ty>);

impl From<StateHD<$hd_ty>> for $py_state_id {

fn from(s: StateHD<$hd_ty>) -> Self {

Self(s)

}

}

#[pymethods]

impl $py_state_id {

#[new]

pub fn new(temperature: $py_hd_id, volume: $py_hd_id, moles: Vec<$py_hd_id>) -> Self {

let moles = moles.into_iter().map(<$hd_ty>::from).collect();

Self(StateHD::<$hd_ty>::new(

temperature.into(),

volume.into(),

&DVector::from_vec(moles),

))

}

#[getter]

pub fn get_temperature(&self) -> $py_hd_id {

<$py_hd_id>::from(self.0.temperature)

}

#[getter]

pub fn get_partial_density(&self) -> Vec<$py_hd_id> {

self.0

.partial_density

.iter()

.copied()

.map(<$py_hd_id>::from)

.collect()

}

#[getter]

pub fn get_molefracs(&self) -> Vec<$py_hd_id> {

self.0

.molefracs

.iter()

.copied()

.map(<$py_hd_id>::from)

.collect()

}

#[getter]

pub fn get_density(&self) -> $py_hd_id {

<$py_hd_id>::from(self.0.partial_density.sum())

}

}

};

($py_hd_id:ident, $hd_ty:ty, $py_field_ty:ty) => {

#[pyclass(from_py_object)]

#[derive(Clone)]

struct $py_hd_id($hd_ty);

impl_dual_num!($py_hd_id, $hd_ty, $py_field_ty);

};

($py_state_id:ident, $py_hd_id:ident, $hd_ty:ty, $py_field_ty:ty) => {

dual_number!($py_hd_id, $hd_ty, $py_field_ty);

state!($py_state_id, $py_hd_id, $hd_ty);

};