pyFracAggregate 0.1.0__py3-none-any.whl

pyFracAggregate/__init__.py

@@ -0,0 +1,105 @@
+import numpy as np
+from pyFracAggregate.core.aggregate import Aggregate
+from pyFracAggregate.generators.factory import get_generator
+from pyFracAggregate.core.distributions import Monodisperse, LognormalDistribution
+from pyFracAggregate.analysis.morphology import radius_of_gyration, center_of_mass
+from pyFracAggregate.analysis.correlation import (
+    pair_correlation_function,
+    estimate_fractal_dimension,
+    plot_pair_correlation
+)
+from pyFracAggregate.io.vtk import export_vtm, export_vtk
+from pyFracAggregate.io.data import export_yaml
+from pyFracAggregate.io.visualization import export_render, export_rotation_video
+from pyFracAggregate.generators.pca import PCAGenerator
+from pyFracAggregate.generators.cca import CCAGenerator
+from pyFracAggregate.generators.fracval import FracVALGenerator
+from pyFracAggregate.generators.tdcca import ThouyJullienGenerator
+from pyFracAggregate.generators.placement.algebraic import AlgebraicPlacement
+from pyFracAggregate.generators.placement.random_ import RandomPlacement
+
+__version__ = "0.1.0"
+__author__ = "Fan Zhang"
+
+def generate(
+    n_particles: int,
+    df: float,
+    kf: float,
+    method: str = 'pca',
+    particle_dist = None,
+    overlap_tolerance: float = 1e-5,
+    placement: str = 'algebraic',
+    **kwargs
+) -> Aggregate:
+    """
+    High-level API to generate a fractal aggregate.
+
+    Args:
+        n_particles (int): Target number of particles.
+        df (float): Fractal dimension (typically 1.5 - 2.5).
+        kf (float): Fractal prefactor (typically 1.0 - 2.0).
+        method (str): Algorithm to use ('pca', 'cca', 'fracval', 'tdcca').
+        particle_dist: Particle radius distribution (defaults to Monodisperse(1.0)).
+        overlap_tolerance (float): Allowed overlap between spheres.
+        placement (str): Placement strategy ('algebraic' or 'random').
+
+    Returns:
+        Aggregate: The generated fractal aggregate.
+    """
+    if particle_dist is None:
+        particle_dist = Monodisperse(1.0)
+
+    generator = get_generator(
+        method=method,
+        n_particles=n_particles,
+        df=df,
+        kf=kf,
+        particle_dist=particle_dist,
+        overlap_tolerance=overlap_tolerance,
+        placement=placement,
+        **kwargs
+    )
+
+    return generator.generate()
+
+def analyze(aggregate: Aggregate):
+    """
+    Compute core morphological properties.
+    """
+    rg = radius_of_gyration(aggregate)
+    r_centers, c_r = pair_correlation_function(aggregate)
+    df_est, r2, _ = estimate_fractal_dimension(r_centers, c_r,
+                                               r_min=np.mean(aggregate.radii),
+                                               r_max=rg)
+
+    return {
+        "Rg": rg,
+        "CoM": center_of_mass(aggregate),
+        "N": aggregate.current_size,
+        "Df_estimated": df_est,
+        "R2": r2
+    }
+
+__all__ = [
+    "generate",
+    "analyze",
+    "Aggregate",
+    "Monodisperse",
+    "LognormalDistribution",
+    "radius_of_gyration",
+    "center_of_mass",
+    "pair_correlation_function",
+    "estimate_fractal_dimension",
+    "plot_pair_correlation",
+    "export_yaml",
+    "export_render",
+    "export_rotation_video",
+    "export_vtm",
+    "export_vtk",
+    "PCAGenerator",
+    "CCAGenerator",
+    "FracVALGenerator",
+    "ThouyJullienGenerator",
+    "AlgebraicPlacement",
+    "RandomPlacement",
+]

pyFracAggregate/analysis/__init__.py

@@ -0,0 +1 @@
+"""Analysis tools for fractal aggregates."""

pyFracAggregate/analysis/correlation.py

@@ -0,0 +1,207 @@
+import numpy as np
+from scipy.spatial import cKDTree
+from pyFracAggregate.core.aggregate import Aggregate
+
+def pair_correlation_function(
+    aggregate: Aggregate, 
+    bins: int = 50, 
+    r_max: float = None
+) -> tuple[np.ndarray, np.ndarray]:
+    """Calculates the two-point density correlation function C(r).
+
+    Efficient calculation based on scipy.spatial.cKDTree.
+    
+    C(r) = n(r) / (4 * pi * r^2 * h * N)
+    where n(r) is the number of particle pairs between distance r and r+h,
+    N is the total number of particles, and h is the step size (bin width).
+    
+    Args:
+        aggregate (Aggregate): Cluster object.
+        bins (int): Number of bins for r.
+        r_max (float, optional): Maximum distance for calculating the correlation function.
+            If None, the maximum distance between particles is used.
+        
+    Returns:
+        tuple[np.ndarray, np.ndarray]: (r_centers, C_r) where r_centers are the bin 
+            center distances and C_r are the corresponding correlation values.
+    """
+    if aggregate.current_size < 2:
+        return np.array([]), np.array([])
+        
+    positions = aggregate.positions
+    N = aggregate.current_size
+    
+    # Build KDTree for accelerated queries
+    tree = cKDTree(positions)
+    
+    if r_max is None:
+        # Estimate maximum distance (upper bound of the furthest pair)
+        # Use 2x the maximum distance from center as a safe upper bound
+        com = np.mean(positions, axis=0)
+        max_dist_to_center = np.max(np.linalg.norm(positions - com, axis=1))
+        r_max = 2.0 * max_dist_to_center
+        if r_max == 0:
+            return np.array([]), np.array([])
+            
+    # Calculate distance statistics (upper triangle only to avoid double counting, 
+    # though tree.count_neighbors handles pair counting).
+    # tree.count_neighbors returns cumulative counts (<= r), so we differentiate.
+    r_edges = np.linspace(0, r_max, bins + 1)
+    
+    # count_neighbors can take multiple radii at once
+    # cumulative_counts[i] contains number of pairs with distance <= r_edges[i]
+    cumulative_counts = tree.count_neighbors(tree, r_edges)
+    
+    # Subtract self-matches (N) at r=0 to avoid interference with real pair statistics.
+    # (Coincident points are not expected due to collision detection).
+    cumulative_counts = np.array(cumulative_counts, dtype=np.float64)
+    # Subtract N self-matches for all r >= 0 counts
+    cumulative_counts -= N
+    # Ensure no negative values (preventing anomalies due to precision)
+    cumulative_counts = np.maximum(cumulative_counts, 0)
+    
+    # Differentiate to get counts in each bin: n(r)
+    n_r = np.diff(cumulative_counts)
+    
+    # r_centers are the interval midpoints
+    r_centers = (r_edges[:-1] + r_edges[1:]) / 2.0
+    h = r_edges[1] - r_edges[0]
+    
+    # Avoid division by zero at r=0, although r_centers > 0
+    with np.errstate(divide='ignore', invalid='ignore'):
+        c_r = n_r / (4.0 * np.pi * (r_centers ** 2) * h * N)
+        
+    # Assign 0 for r=0 or cases where distance is too small (causing div by 0)
+    c_r = np.nan_to_num(c_r, posinf=0.0)
+    
+    return r_centers, c_r
+
+def estimate_fractal_dimension(
+    r_centers: np.ndarray, 
+    c_r: np.ndarray, 
+    r_min: float = None, 
+    r_max: float = None
+) -> tuple[float, float, dict]:
+    """Estimates the fractal dimension Df from the pair correlation function C(r).
+
+    Performs log-log linear regression on the fractal regime (a < r < Rg).
+    Df is calculated as: Df = slope + 3.
+
+    Args:
+        r_centers (np.ndarray): Bin center distances.
+        c_r (np.ndarray): Correlation function values.
+        r_min (float, optional): Lower bound for regression.
+        r_max (float, optional): Upper bound for regression.
+
+    Returns:
+        tuple[float, float, dict]: (Df, R_squared, fit_results)
+            - Df: Estimated fractal dimension.
+            - R_squared: Coefficient of determination.
+            - fit_results: Dictionary containing 'slope', 'intercept', 'x_fit', 'y_fit'.
+    """
+    # Filter valid data (C(r) > 0 for log)
+    mask = c_r > 0
+    if r_min is not None:
+        mask &= (r_centers >= r_min)
+    if r_max is not None:
+        mask &= (r_centers <= r_max)
+    
+    x = r_centers[mask]
+    y = c_r[mask]
+    
+    if len(x) < 2:
+        return 0.0, 0.0, {}
+
+    log_x = np.log10(x)
+    log_y = np.log10(y)
+    
+    # Linear regression: log10(C(r)) = slope * log10(r) + intercept
+    slope, intercept = np.polyfit(log_x, log_y, 1)
+    
+    # Calculate R-squared
+    y_pred = slope * log_x + intercept
+    ss_res = np.sum((log_y - y_pred) ** 2)
+    ss_tot = np.sum((log_y - np.mean(log_y)) ** 2)
+    r_squared = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0.0
+    
+    df = slope + 3.0
+    
+    fit_results = {
+        'slope': slope,
+        'intercept': intercept,
+        'r_min': np.min(x),
+        'r_max': np.max(x),
+        'x_fit': x,
+        'y_fit': 10 ** y_pred
+    }
+    
+    return df, r_squared, fit_results
+
+def plot_pair_correlation(
+    aggregate: Aggregate, 
+    bins: int = 50, 
+    show_fit: bool = True, 
+    reference_df: float = None, 
+    save_path: str = None
+) -> None:
+    """Plots the pair correlation function and optionally its fractal fit.
+
+    Args:
+        aggregate (Aggregate): Cluster object.
+        bins (int): Number of bins for PCF.
+        show_fit (bool): Whether to show the fractal dimension fit.
+        reference_df (float, optional): Reference Df to show in plot.
+        save_path (str, optional): Path to save the figure.
+    """
+    try:
+        import matplotlib.pyplot as plt
+    except ImportError:
+        print("Error: matplotlib is required for plotting. Install it with 'pip install matplotlib'.")
+        return
+
+    from pyFracAggregate.analysis.morphology import radius_of_gyration
+    
+    r_centers, c_r = pair_correlation_function(aggregate, bins=bins)
+    
+    if len(r_centers) == 0:
+        print("Warning: Aggregate has too few particles for correlation analysis.")
+        return
+
+    plt.figure(figsize=(8, 6))
+    plt.loglog(r_centers, c_r, 'o', label='Data', markersize=4, alpha=0.7)
+    
+    if show_fit:
+        # Use r_min = mean radius, r_max = Rg as default bounds for fractal regime
+        r_min = np.mean(aggregate.radii)
+        r_max = radius_of_gyration(aggregate)
+        
+        df, r2, fit = estimate_fractal_dimension(r_centers, c_r, r_min=r_min, r_max=r_max)
+        
+        if fit:
+            plt.loglog(fit['x_fit'], fit['y_fit'], 'r-', linewidth=2, 
+                       label=f'Fit: $D_f$={df:.2f}, $R^2$={r2:.3f}')
+            
+            # Draw vertical lines for fitting range
+            plt.axvline(r_min, color='gray', linestyle='--', alpha=0.5, label='Min Fit Bound')
+            plt.axvline(r_max, color='gray', linestyle=':', alpha=0.5, label='Max Fit Bound ($R_g$)')
+
+    if reference_df is not None:
+        # Show a reference slope (slope = reference_df - 3)
+        mid_idx = len(r_centers) // 2
+        ref_x = r_centers
+        # Arbitrary intercept to place it near the data
+        ref_intercept = np.log10(c_r[mid_idx]) - (reference_df - 3.0) * np.log10(r_centers[mid_idx])
+        ref_y = 10 ** ((reference_df - 3.0) * np.log10(ref_x) + ref_intercept)
+        plt.loglog(ref_x, ref_y, 'g--', alpha=0.5, label=f'Ref: $D_f$={reference_df}')
+
+    plt.xlabel(f'Distance $r$ [{aggregate.length_unit}]')
+    plt.ylabel('Correlation function $C(r)$')
+    plt.title('Pair Correlation Function Analysis')
+    plt.grid(True, which="both", ls="-", alpha=0.2)
+    plt.legend()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"Plot saved to {save_path}")
+    else:
+        plt.show()

pyFracAggregate/analysis/morphology.py

@@ -0,0 +1,72 @@
+import numpy as np
+from pyFracAggregate.core.aggregate import Aggregate
+
+def center_of_mass(aggregate: Aggregate) -> np.ndarray:
+    """
+    Calculate the center of mass of the aggregate.
+    
+    Args:
+        aggregate (Aggregate): The aggregate object.
+        
+    Returns:
+        np.ndarray: A 1D array of shape (3,) representing the (x, y, z) coordinates of the center of mass.
+    """
+    if aggregate.current_size == 0:
+        return np.zeros(3)
+        
+    masses = aggregate.masses
+    positions = aggregate.positions
+    
+    total_mass = np.sum(masses)
+    if total_mass == 0:
+        return np.mean(positions, axis=0)
+        
+    # sum(m_i * r_i) / sum(m_i)
+    com = np.sum(positions * masses[:, np.newaxis], axis=0) / total_mass
+    return com
+
+def radius_of_gyration(aggregate: Aggregate) -> float:
+    """
+    Calculate the radius of gyration (Rg) of the aggregate.
+    Uses the parallel axis theorem to account for the finite size of the primary particles.
+    For a solid sphere, the radius of gyration about its own center is sqrt(3/5) * r.
+    
+    Args:
+        aggregate (Aggregate): The aggregate object.
+        
+    Returns:
+        float: The radius of gyration.
+    """
+    if aggregate.current_size == 0:
+        return 0.0
+        
+    if aggregate.current_size == 1:
+        # For a single sphere, Rg = sphere radius according to Filippov 2000 definition eq [4]
+        # Or more accurately based on eq [4]: Rg^2 = a^2 for N=1. 
+        # But for polydisperse spheres with parallel axis theorem: Rg^2 = 3/5 * r^2.
+        # Wait, the Filippov paper uses: Rg^2 = 1/N sum((ri - r0)^2 + a^2).
+        # Let's check the Moran 2019 FracVAL equation for polydisperse:
+        # Rg^2 = 1/m_a sum(m_i * [(R_i - R_c)^2 + r_{g,i}^2]) where r_{g,i}^2 = 3/5 * r_{p,i}^2
+        # Let's implement the standard physical Rg (with 3/5 factor).
+        return np.sqrt(3.0 / 5.0) * aggregate.radii[0]
+
+    masses = aggregate.masses
+    positions = aggregate.positions
+    radii = aggregate.radii
+    
+    total_mass = np.sum(masses)
+    if total_mass == 0:
+        return 0.0
+        
+    com = center_of_mass(aggregate)
+    
+    # Distance squared from CoM to each particle center
+    dist_sq = np.sum((positions - com) ** 2, axis=1)
+    
+    # Intrinsic Rg squared of each solid sphere: 3/5 * r^2
+    intrinsic_rg_sq = (3.0 / 5.0) * (radii ** 2)
+    
+    # sum(m_i * (dist_sq + intrinsic_rg_sq)) / M
+    rg_sq = np.sum(masses * (dist_sq + intrinsic_rg_sq)) / total_mass
+    
+    return float(np.sqrt(rg_sq))

pyFracAggregate/core/__init__.py

@@ -0,0 +1 @@
+"""Core data structures and math utils."""

pyFracAggregate/core/aggregate.py

@@ -0,0 +1,93 @@
+import numpy as np
+
+class Aggregate:
+    """Core physical entity representing a fractal cluster.
+
+    Uses pre-allocated contiguous memory via NumPy for high data locality 
+    and access performance.
+    """
+    def __init__(self, max_particles: int, length_unit: str = 'nm', mass_unit: str = 'g', density: float = 1.0):
+        """Initializes the Aggregate object.
+
+        Args:
+            max_particles (int): Maximum number of particles the cluster can hold.
+            length_unit (str, optional): Unit for length measurements (e.g., 'nm'). Defaults to 'nm'.
+            mass_unit (str, optional): Unit for mass measurements (e.g., 'g'). Defaults to 'g'.
+            density (float, optional): Density of particle material. Defaults to 1.0.
+
+        Raises:
+            ValueError: If max_particles <= 0.
+        """
+        if max_particles <= 0:
+            raise ValueError("max_particles must be positive")
+        
+        # Data structure: [x, y, z, radius, mass] with pre-allocated memory
+        self._data = np.zeros((max_particles, 5), dtype=np.float64)
+        self._current_size = 0  
+        self.length_unit = length_unit
+        self.mass_unit = mass_unit
+        self.density = density
+
+    @property
+    def positions(self) -> np.ndarray:
+        """Gets particle coordinates.
+
+        Returns:
+            np.ndarray: A zero-copy view with shape (N, 3).
+        """
+        return self._data[:self._current_size, :3]
+    
+    @property
+    def radii(self) -> np.ndarray:
+        """Gets particle radii.
+
+        Returns:
+            np.ndarray: A zero-copy view with shape (N,).
+        """
+        return self._data[:self._current_size, 3]
+
+    @property
+    def masses(self) -> np.ndarray:
+        """Gets particle masses.
+
+        Returns:
+            np.ndarray: A zero-copy view with shape (N,).
+        """
+        return self._data[:self._current_size, 4]
+        
+    @property
+    def current_size(self) -> int:
+        """Gets the current total number of particles."""
+        return self._current_size
+        
+    @property
+    def max_size(self) -> int:
+        """Gets the maximum allowed number of particles."""
+        return len(self._data)
+
+    def add_particle(self, x: float, y: float, z: float, r: float, m: float) -> None:
+        """Adds a new particle. O(1) complexity.
+
+        Args:
+            x (float): X coordinate
+            y (float): Y coordinate
+            z (float): Z coordinate
+            r (float): Radius
+            m (float): Mass
+
+        Raises:
+            RuntimeError: If cluster reaches maximum capacity.
+        """
+        if self._current_size >= len(self._data):
+            raise RuntimeError("Aggregate capacity exceeded")
+        i = self._current_size
+        self._data[i] = [x, y, z, r, m]
+        self._current_size += 1
+        
+    def to_numpy(self) -> np.ndarray:
+        """Exports a copy of valid particles.
+
+        Returns:
+            np.ndarray: A copy of the data with shape (N, 5).
+        """
+        return self._data[:self._current_size].copy()

pyFracAggregate/core/distributions.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+import numpy as np
+
+class ParticleDistribution(ABC):
+    """Abstract base class for particle size distributions."""
+    @abstractmethod
+    def sample(self, n: int) -> np.ndarray:
+        """Samples n particle sizes.
+        
+        Args:
+            n (int): Number of particle sizes to generate.
+            
+        Returns:
+            np.ndarray: An array of particle sizes with shape (n,).
+        """
+        pass
+
+class Monodisperse(ParticleDistribution):
+    """Monodisperse distribution (all particles have the same radius)."""
+    def __init__(self, radius: float):
+        """Initializes the distribution.
+
+        Args:
+            radius (float): Particle radius.
+        Raises:
+            ValueError: If radius <= 0.
+        """
+        if radius <= 0:
+            raise ValueError("Radius must be positive")
+        self.radius = radius
+        
+    def sample(self, n: int) -> np.ndarray:
+        return np.full(n, self.radius, dtype=np.float64)
+
+class LognormalDistribution(ParticleDistribution):
+    """Lognormal distribution."""
+    def __init__(self, mean: float, std: float):
+        """Initializes the distribution.
+
+        Args:
+            mean (float): Geometric mean.
+            std (float): Geometric standard deviation (should be >= 1.0).
+            
+        Raises:
+            ValueError: If mean or std is invalid.
+        """
+        if mean <= 0:
+            raise ValueError("Mean must be positive")
+        if std <= 0:
+            raise ValueError("Standard deviation must be positive")
+            
+        self.mean = mean
+        self.std = std
+        
+        # Calculate mean and standard deviation of the underlying normal distribution
+        self.normal_mean = np.log(self.mean)
+        self.normal_std = np.log(self.std) if self.std > 1.0 else 0.0
+        
+    def sample(self, n: int) -> np.ndarray:
+        if self.normal_std == 0.0:
+            return np.full(n, self.mean, dtype=np.float64)
+        return np.random.lognormal(self.normal_mean, self.normal_std, n)

pyFracAggregate/core/math_utils.py

@@ -0,0 +1,124 @@
+import numpy as np
+from typing import Tuple, Optional
+
+import mathutils
+
+def rotate_points(points: np.ndarray, euler_angles: Tuple[float, float, float]) -> np.ndarray:
+    """
+    Rotate points using given euler angles (in radians).
+    
+    Args:
+        points (np.ndarray): Shape (N, 3) points to rotate.
+        euler_angles (Tuple[float, float, float]): Rotation angles (x, y, z) in radians.
+        
+    Returns:
+        np.ndarray: Rotated points of shape (N, 3).
+    """
+    if points.size == 0:
+        return points.copy()
+        
+    euler = mathutils.Euler(euler_angles, 'XYZ')
+    rot_matrix = np.array(euler.to_matrix())
+    return points @ rot_matrix.T
+
+def rotate_points_quaternion(points: np.ndarray, quaternion: Tuple[float, float, float, float]) -> np.ndarray:
+    """
+    Rotate points using given quaternion (w, x, y, z).
+    
+    Args:
+        points (np.ndarray): Shape (N, 3) points to rotate.
+        quaternion (Tuple[float, float, float, float]): Quaternion parameters (w, x, y, z).
+        
+    Returns:
+        np.ndarray: Rotated points.
+    """
+    if points.size == 0:
+        return points.copy()
+        
+    q = mathutils.Quaternion(quaternion)
+    rot_matrix = np.array(q.to_matrix())
+    return points @ rot_matrix.T
+
+def euler_rodrigues_rotation(points: np.ndarray, axis: np.ndarray, angle: float) -> np.ndarray:
+    """Rotate points around an arbitrary axis by a given angle using Euler-Rodrigues formula.
+
+    Args:
+        points (np.ndarray): Shape (N, 3) points to rotate.
+        axis (np.ndarray): Rotation axis (3,), must be non-zero.
+        angle (float): Rotation angle in radians.
+
+    Returns:
+        np.ndarray: Rotated points of shape (N, 3).
+    """
+    if points.size == 0:
+        return points.copy()
+    axis = axis / np.linalg.norm(axis)
+    K = np.array([
+        [0, -axis[2], axis[1]],
+        [axis[2], 0, -axis[0]],
+        [-axis[1], axis[0], 0]
+    ])
+    R = np.eye(3) + np.sin(angle) * K + (1 - np.cos(angle)) * (K @ K)
+    return points @ R.T
+
+
+def sphere_sphere_intersection(
+    c1: np.ndarray, r1: float, c2: np.ndarray, r2: float
+) -> Optional[Tuple[np.ndarray, float]]:
+    """Compute the intersection circle of two spheres.
+
+    Args:
+        c1: Center of sphere 1, shape (3,).
+        r1: Radius of sphere 1.
+        c2: Center of sphere 2, shape (3,).
+        r2: Radius of sphere 2.
+
+    Returns:
+        (circle_center, circle_radius) if intersection exists, None otherwise.
+        For tangent spheres, circle_radius is 0.0.
+    """
+    d_vec = c2 - c1
+    d = np.linalg.norm(d_vec)
+
+    if d > r1 + r2 + 1e-12:
+        return None
+    if d < abs(r1 - r2) - 1e-12:
+        return None
+    if d < 1e-12:
+        return None
+
+    a = (r1**2 - r2**2 + d**2) / (2 * d)
+    h_sq = r1**2 - a**2
+    if h_sq < -1e-12:
+        return None
+    h = np.sqrt(max(h_sq, 0.0))
+
+    circle_center = c1 + (a / d) * d_vec
+    return circle_center, h
+
+
+def random_point_on_circle(
+    center: np.ndarray,
+    radius: float,
+    normal: np.ndarray,
+) -> np.ndarray:
+    """Sample a random point on a circle in 3D.
+
+    Args:
+        center: Circle center, shape (3,).
+        radius: Circle radius.
+        normal: Normal vector to the circle plane, shape (3,).
+
+    Returns:
+        A single point on the circle, shape (3,).
+    """
+    normal = normal / np.linalg.norm(normal)
+    temp = np.array([1.0, 0.0, 0.0])
+    if np.abs(np.dot(normal, temp)) > 0.9:
+        temp = np.array([0.0, 1.0, 0.0])
+    u = np.cross(normal, temp)
+    u /= np.linalg.norm(u)
+    v = np.cross(normal, u)
+
+    theta = np.random.uniform(0, 2 * np.pi)
+    return center + radius * (np.cos(theta) * u + np.sin(theta) * v)

pyFracAggregate/generators/__init__.py

@@ -0,0 +1,21 @@
+"""Generators for fractal aggregates."""
+
+from pyFracAggregate.generators.base import BaseGenerator
+from pyFracAggregate.generators.pca import PCAGenerator
+from pyFracAggregate.generators.cca import CCAGenerator
+from pyFracAggregate.generators.fracval import FracVALGenerator
+from pyFracAggregate.generators.tdcca import ThouyJullienGenerator
+from pyFracAggregate.generators.placement.base import PlacementStrategy
+from pyFracAggregate.generators.placement.algebraic import AlgebraicPlacement
+from pyFracAggregate.generators.placement.random_ import RandomPlacement
+
+__all__ = [
+    "BaseGenerator",
+    "PCAGenerator",
+    "CCAGenerator",
+    "FracVALGenerator",
+    "ThouyJullienGenerator",
+    "PlacementStrategy",
+    "AlgebraicPlacement",
+    "RandomPlacement",
+]