Builder patern

src/builder.rs

@@ -0,0 +1,22 @@
+//! builder utility
+
+use std::num::NonZeroUsize;
+
+#[cfg(feature = "serde-serialize")]
+use serde::{Deserialize, Serialize};
+
+/// Type of generation
+#[non_exhaustive]
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub enum GenType<'rng, Rng: rand::Rng + ?Sized> {
+    /// Cold generation all elements are set to the default
+    Cold,
+    /// Random determinist
+    #[cfg_attr(feature = "serde-serialize", serde(skip_deserializing))]
+    HotDeterminist(&'rng mut Rng),
+    /// Random determinist but own the RNG (for instance the result of `clone`)
+    HotDeterministOwned(Box<Rng>),
+    /// Random threaded (non determinist)
+    HotThreaded(NonZeroUsize),
+}

src/field.rs

@@ -21,6 +21,11 @@ use super::{
     CMatrix3, Complex, Real, Vector8, I,
 };
 
+mod link_matrix_builder;
+pub use link_matrix_builder::*;
+mod e_field_builder;
+pub use e_field_builder::*;
+
 /// Adjoint representation of SU(3), it is su(3) (i.e. the lie algebra).
 /// See [`su3::GENERATORS`] to view the order of generators.
 /// Note that the generators are normalize such that `Tr[T^a T^b] = \delta^{ab} / 2`

src/field/e_field_builder.rs

@@ -0,0 +1,75 @@
+use std::borrow::Cow;
+use std::fmt::Debug;
+use std::num::NonZeroUsize;
+
+use rand::distributions::Distribution;
+use rand_distr::Normal;
+#[cfg(feature = "serde-serialize")]
+use serde::Serialize;
+
+use super::EField;
+use crate::builder::GenType;
+use crate::lattice::LatticeCyclic;
+use crate::{CMatrix3, Real};
+
+#[derive(Debug, Clone)]
+enum DistributionForBuilder<'dis, Dis: Distribution<Real> + ?Sized> {
+    Default(Normal<Real>),
+    Given(&'dis Dis), // TODO box dyn
+}
+
+impl<'d, Dis: Distribution<Real> + ?Sized> Default for DistributionForBuilder<'d, Dis> {
+    fn default() -> Self {
+        Self::Default(Normal::new(0_f64, 0.5_f64).unwrap())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct EFieldProceduralBuilder<
+    'rng,
+    'lat,
+    'dis,
+    Rng: rand::Rng + ?Sized,
+    Dis: Distribution<Real> + ToOwned + ?Sized,
+    const D: usize,
+> {
+    gen_type: GenType<'rng, Rng>,
+    lattice: Cow<'lat, LatticeCyclic<D>>,
+    distribution: DistributionForBuilder<'dis, Dis>,
+}
+
+/*
+impl<'r, 'l, 'd, Rng: rand::Rng + ?Sized, Dis, const D: usize> Debug
+    for EFieldProceduralBuilder<'r, 'l, 'd, Rng, Dis, D>
+where
+    Dis: Distribution<Real> + ?Sized + ToOwned + Debug,
+    Rng: Debug,
+    Dis::Owned: Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EFieldProceduralBuilder")
+            .field("gen_type", &self.gen_type)
+            .field("lattice", &self.lattice)
+            .field("distribution", &self.distribution)
+            .finish()
+    }
+}
+*/
+
+impl<
+        'rng,
+        'lat,
+        'dis,
+        Rng: rand::Rng + ?Sized,
+        Dis: Distribution<Real> + ToOwned + ?Sized,
+        const D: usize,
+    > EFieldProceduralBuilder<'rng, 'lat, 'dis, Rng, Dis, D>
+{
+    pub fn new(lattice: impl Into<Cow<'lat, LatticeCyclic<D>>>) -> Self {
+        Self {
+            gen_type: GenType::Cold,
+            lattice: lattice.into(),
+            distribution: DistributionForBuilder::default(),
+        }
+    }
+}