holobench 1.41.0__py3-none-any.whl → 1.43.0__py3-none-any.whl

bencher/example/inputs_2_float/example_2_float_3_cat_in_2_out.py

@@ -0,0 +1,138 @@
+"""Demonstration of benchmarking with 2 float and 3 categorical inputs producing visually distinct patterns.
+
+Each categorical input has 2 conditions that create distinctly different surface shapes.
+"""
+
+import random
+import math
+import bencher as bch
+
+random.seed(0)
+
+
+class PatternBenchmark(bch.ParametrizedSweep):
+    """Benchmark demonstrating patterns with distinctive shapes based on categorical settings."""
+
+    # Float input parameters
+    x_value = bch.FloatSweep(default=100, bounds=[1, 100], doc="X value parameter")
+    y_value = bch.FloatSweep(default=10, bounds=[1, 100], doc="Y value parameter")
+
+    # Categorical input parameters - each with 2 conditions
+    pattern_type = bch.StringSweep(["linear", "exponential"], doc="Pattern relationship")
+    symmetry_type = bch.StringSweep(["symmetric", "asymmetric"], doc="Pattern symmetry")
+    feature_type = bch.StringSweep(["smooth", "ridged"], doc="Surface features")
+
+    # Output metrics
+    response_a = bch.ResultVar(units="units", doc="Response variable A")
+    response_b = bch.ResultVar(units="units", doc="Response variable B")
+
+    def __call__(self, **kwargs) -> dict:
+        """Generate responses with distinctly different patterns based on categorical inputs."""
+        self.update_params_from_kwargs(**kwargs)
+
+        # Normalize inputs to [0,1]
+        x = self.x_value / 100
+        y = self.y_value / 100
+
+        # Set base patterns based on pattern_type
+        if self.pattern_type == "linear":
+            base_a = 2 * x + 3 * y
+            base_b = 3 * x - y
+        else:  # exponential
+            base_a = math.exp(2 * x) * math.exp(y) / math.exp(3)
+            base_b = math.exp(x) * math.exp(2 * y) / math.exp(3)
+
+        # Apply symmetry effect
+        if self.symmetry_type == "symmetric":
+            sym_a = (x + y) ** 2
+            sym_b = (x + y) * abs(x - y)
+        else:  # asymmetric
+            sym_a = x**2 * y
+            sym_b = x * y**2
+
+        # Apply surface features
+        if self.feature_type == "smooth":
+            feat_a = math.sin(3 * math.pi * x) * math.sin(3 * math.pi * y)
+            feat_b = math.cos(3 * math.pi * x) * math.cos(3 * math.pi * y)
+        else:  # ridged
+            feat_a = math.sin(8 * math.pi * x) ** 2 * math.sin(8 * math.pi * y) ** 2
+            feat_b = abs(math.sin(10 * math.pi * x * y))
+
+        # Combine patterns with weights that vary by condition combination
+        # Each combination produces a visually distinct surface shape
+        weights = {
+            "linear": {
+                "symmetric": {
+                    "smooth": ([1, 2, 0.5], [1, 1.5, 0.3]),  # Valley pattern
+                    "ridged": ([1, 1.5, 1.8], [1, 1, 2]),  # Diagonal ridges
+                },
+                "asymmetric": {
+                    "smooth": ([1, 1.8, 0.7], [1, 1.2, 0.9]),  # Tilted plane with waves
+                    "ridged": ([1, 1, 2.2], [1, 0.8, 2.5]),  # Grid pattern
+                },
+            },
+            "exponential": {
+                "symmetric": {
+                    "smooth": ([1, 1, 0.3], [1, 0.8, 0.4]),  # Corner peak with ripples
+                    "ridged": ([1, 0.7, 1.5], [1, 0.5, 1.8]),  # Corner peak with ridges
+                },
+                "asymmetric": {
+                    "smooth": ([1, 1.5, 0.4], [1, 1.8, 0.2]),  # Curved gradient
+                    "ridged": ([1, 1.2, 1.2], [1, 1.4, 1.4]),  # Extreme corner peak
+                },
+            },
+        }
+
+        # Get the weights for the current combination
+        w_a, w_b = weights[self.pattern_type][self.symmetry_type][self.feature_type]
+
+        # Calculate final responses with weights
+        if self.pattern_type == "linear":
+            self.response_a = w_a[0] * base_a + w_a[1] * sym_a + w_a[2] * feat_a
+            self.response_b = w_b[0] * base_b + w_b[1] * sym_b + w_b[2] * feat_b
+        else:  # exponential - multiplicative relationship
+            self.response_a = base_a * (1 + w_a[1] * sym_a) * (1 + w_a[2] * feat_a)
+            self.response_b = base_b * (1 + w_b[1] * sym_b) * (1 + w_b[2] * feat_b)
+
+        # Add minimal randomness (to maintain pattern visibility)
+        random_factor = random.uniform(0.98, 1.02)
+        self.response_a *= random_factor
+        self.response_b *= random_factor
+
+        return super().__call__(**kwargs)
+
+
+def example_2_float_3_cat_in_2_out(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    """Benchmark demonstrating visually distinct patterns based on categorical settings.
+
+    Args:
+        run_cfg: Configuration for the benchmark run
+        report: Report to append the results to
+
+    Returns:
+        bch.Bench: The benchmark object
+    """
+    if run_cfg is None:
+        run_cfg = bch.BenchRunCfg()
+    run_cfg.repeats = 3  # Fewer repeats for a quicker benchmark
+
+    bench = PatternBenchmark().to_bench(run_cfg, report)
+    bench.plot_sweep(
+        title="Pattern Visualization (2 Float, 3 Categorical Variables)",
+        description="Response patterns with distinctive shapes based on categorical settings",
+        post_description="""
+        Pattern Type: Linear (diagonal gradients) vs Exponential (corner-concentrated)
+        Symmetry Type: Symmetric (x/y similarity) vs Asymmetric (x/y difference)
+        Feature Type: Smooth (gradual transitions) vs Ridged (sharp features)
+        
+        Each combination produces a unique pattern shape that remains visually distinctive
+        even with auto-scaling of the color maps.
+        """,
+    )
+    return bench
+
+
+if __name__ == "__main__":
+    example_2_float_3_cat_in_2_out().report.show()

bencher/example/inputs_3_float/example_3_float_0_cat_in_2_out.py

@@ -0,0 +1,111 @@
+"""Demonstration of benchmarking with 3 float inputs and no categorical inputs.
+
+This example shows a 3D parameter space with consistent mathematical pattern generation.
+"""
+
+import random
+import math
+import bencher as bch
+import holoviews as hv
+
+random.seed(0)
+
+
+class Pattern3DModel0Cat(bch.ParametrizedSweep):
+    """Benchmark demonstrating 3D patterns without categorical settings."""
+
+    # Float input parameters
+    x_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="X value parameter")
+    y_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="Y value parameter")
+    z_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="Z value parameter")
+
+    # No categorical inputs - all parameters are fixed
+
+    # Output metrics
+    contrast = bch.ResultVar(units="ratio", doc="Secondary contrast measure")
+    intensity = bch.ResultVar(units="units", doc="Primary response intensity")
+
+    def __call__(self, **kwargs) -> dict:
+        """Generate 3D responses with consistent pattern generation."""
+        self.update_params_from_kwargs(**kwargs)
+
+        # Normalize inputs to [0,1]
+        x = self.x_value / 100
+        y = self.y_value / 100
+        z = self.z_value / 100
+
+        # Fixed to spherical geometry
+        # Spherical geometry creates radial patterns from center
+        r = math.sqrt(x**2 + y**2 + z**2) / math.sqrt(3)
+        theta = math.atan2(y, x) / (2 * math.pi) + 0.5  # normalized [0,1]
+        phi = math.acos(z / max(0.001, math.sqrt(x**2 + y**2 + z**2))) / math.pi
+
+        # Fixed to linear scaling
+        # Linear scaling creates more uniform patterns
+        scale_factor = 1.5 * r + 0.8 * phi + 0.5 * theta
+        scale_factor2 = 0.7 * r + 1.2 * phi + 0.9 * theta
+
+        # Create wave patterns
+        wave1 = math.sin(5 * math.pi * r) * math.cos(4 * math.pi * theta)
+        wave2 = math.sin(3 * math.pi * phi) * math.sin(6 * math.pi * r * theta)
+
+        # Create interference patterns
+        pattern1 = math.sin(7 * math.pi * (x + y + z) / 3)
+        pattern2 = math.cos(9 * math.pi * x * y * z)
+
+        # Fixed to additive composition
+        # Additive creates smoother transitions
+        self.intensity = 0.6 * scale_factor + 0.3 * wave1 + 0.2 * pattern1 + 0.5
+        self.contrast = 0.4 * scale_factor2 + 0.5 * wave2 + 0.3 * pattern2 + 0.3
+
+        # Add minimal randomness (to maintain pattern visibility)
+        random_factor = random.uniform(0.98, 1.02)
+        self.intensity *= random_factor
+        self.contrast *= random_factor
+
+        # Keep values in a reasonable range
+        self.intensity = max(0.1, min(3.0, self.intensity))
+        self.contrast = max(0.1, min(3.0, self.contrast))
+
+        return super().__call__(**kwargs)
+
+
+def example_3_float_0_cat_in_2_out(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    """Benchmark demonstrating 3D visual patterns with no categorical settings.
+
+    Args:
+        run_cfg: Configuration for the benchmark run
+        report: Report to append the results to
+
+    Returns:
+        bch.Bench: The benchmark object
+    """
+    if run_cfg is None:
+        run_cfg = bch.BenchRunCfg()
+        run_cfg.level = 5
+    run_cfg.repeats = 1  # Fewer repeats for a quicker benchmark
+
+    hv.opts.defaults(hv.opts.HeatMap(cmap="plasma", width=300, height=300, colorbar=True))
+
+    bench = Pattern3DModel0Cat().to_bench(run_cfg, report)
+    bench.plot_sweep(
+        title="3D Pattern Visualization (3 Float Variables, No Categorical Variables)",
+        description="Response patterns based purely on 3D coordinates with no categorical settings",
+        post_description="""
+        This example uses fixed parameters for all categorical settings:
+        - Spherical geometry (radial patterns from center)
+        - Linear scaling (uniform effects)
+        - Additive composition (smooth transitions)
+        
+        2D slices of the 3D space show how the input coordinates affect the pattern generation.
+        The intensity and contrast measures reveal different aspects of the underlying mathematical model.
+        """,
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_3_float_0_cat_in_2_out().report.show()

bencher/example/inputs_3_float/example_3_float_1_cat_in_2_out.py

@@ -0,0 +1,117 @@
+"""Demonstration of benchmarking with 3 float and 1 categorical input producing visually distinct patterns.
+
+The categorical input has 2 conditions that create distinctly different surface shapes in 3D space.
+"""
+
+import random
+import math
+import bencher as bch
+import holoviews as hv
+
+random.seed(0)
+
+
+class Pattern3DModel1Cat(bch.ParametrizedSweep):
+    """Benchmark demonstrating 3D patterns with distinctive shapes based on 1 categorical setting."""
+
+    # Float input parameters
+    x_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="X value parameter")
+    y_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="Y value parameter")
+    z_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="Z value parameter")
+
+    # Categorical input parameter - with 2 conditions
+    geometry_type = bch.StringSweep(["spherical", "cylindrical"], doc="Geometry model")
+    # Removed scaling_type and composition_type categoricals
+
+    # Output metrics
+    contrast = bch.ResultVar(units="ratio", doc="Secondary contrast measure")
+    intensity = bch.ResultVar(units="units", doc="Primary response intensity")
+
+    def __call__(self, **kwargs) -> dict:
+        """Generate 3D responses with distinctly different patterns based on the geometry categorical input."""
+        self.update_params_from_kwargs(**kwargs)
+
+        # Normalize inputs to [0,1]
+        x = self.x_value / 100
+        y = self.y_value / 100
+        z = self.z_value / 100
+
+        # Calculate radial components based on geometry_type
+        if self.geometry_type == "spherical":
+            # Spherical geometry creates radial patterns from center
+            r = math.sqrt(x**2 + y**2 + z**2) / math.sqrt(3)
+            theta = math.atan2(y, x) / (2 * math.pi) + 0.5  # normalized [0,1]
+            phi = math.acos(z / max(0.001, math.sqrt(x**2 + y**2 + z**2))) / math.pi
+        else:  # cylindrical
+            # Cylindrical geometry creates patterns based on distance from z-axis
+            r = math.sqrt(x**2 + y**2) / math.sqrt(2)
+            theta = math.atan2(y, x) / (2 * math.pi) + 0.5
+            phi = z  # z directly affects the height
+
+        # Fixed to linear scaling (removed scaling_type categorical)
+        # Linear scaling creates more uniform patterns
+        scale_factor = 1.5 * r + 0.8 * phi + 0.5 * theta
+        scale_factor2 = 0.7 * r + 1.2 * phi + 0.9 * theta
+
+        # Create wave patterns
+        wave1 = math.sin(5 * math.pi * r) * math.cos(4 * math.pi * theta)
+        wave2 = math.sin(3 * math.pi * phi) * math.sin(6 * math.pi * r * theta)
+
+        # Create interference patterns
+        pattern1 = math.sin(7 * math.pi * (x + y + z) / 3)
+        pattern2 = math.cos(9 * math.pi * x * y * z)
+
+        # Fixed to additive composition (removed composition_type categorical)
+        # Additive creates smoother transitions
+        self.intensity = 0.6 * scale_factor + 0.3 * wave1 + 0.2 * pattern1 + 0.5
+        self.contrast = 0.4 * scale_factor2 + 0.5 * wave2 + 0.3 * pattern2 + 0.3
+
+        # Add minimal randomness (to maintain pattern visibility)
+        random_factor = random.uniform(0.98, 1.02)
+        self.intensity *= random_factor
+        self.contrast *= random_factor
+
+        # Keep values in a reasonable range
+        self.intensity = max(0.1, min(3.0, self.intensity))
+        self.contrast = max(0.1, min(3.0, self.contrast))
+
+        return super().__call__(**kwargs)
+
+
+def example_3_float_1_cat_in_2_out(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    """Benchmark demonstrating 3D visual patterns based on 1 categorical setting.
+
+    Args:
+        run_cfg: Configuration for the benchmark run
+        report: Report to append the results to
+
+    Returns:
+        bch.Bench: The benchmark object
+    """
+    if run_cfg is None:
+        run_cfg = bch.BenchRunCfg()
+        run_cfg.level = 5
+    run_cfg.repeats = 1  # Fewer repeats for a quicker benchmark
+
+    hv.opts.defaults(hv.opts.HeatMap(cmap="plasma", width=300, height=300, colorbar=True))
+
+    bench = Pattern3DModel1Cat().to_bench(run_cfg, report)
+    bench.plot_sweep(
+        title="3D Pattern Visualization (3 Float, 1 Categorical Variable)",
+        description="Response patterns with distinctive shapes based on 3D coordinates and 1 categorical setting",
+        post_description="""
+        Geometry Type: Spherical (radial from center) vs Cylindrical (distance from z-axis)
+        
+        This example uses linear scaling and additive composition for pattern generation (fixed parameters).
+        2D slices of the 3D space show visually distinctive patterns that vary based on the geometry setting.
+        The intensity and contrast measures reveal different aspects of the underlying mathematical model.
+        """,
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_3_float_1_cat_in_2_out().report.show()

bencher/example/inputs_3_float/example_3_float_2_cat_in_2_out.py

@@ -0,0 +1,124 @@
+"""Demonstration of benchmarking with 3 float and 2 categorical inputs producing visually distinct patterns.
+
+Each categorical input has 2 conditions that create distinctly different surface shapes in 3D space.
+"""
+
+import random
+import math
+import bencher as bch
+import holoviews as hv
+
+random.seed(0)
+
+
+class Pattern3DModel2Cat(bch.ParametrizedSweep):
+    """Benchmark demonstrating 3D patterns with distinctive shapes based on 2 categorical settings."""
+
+    # Float input parameters
+    x_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="X value parameter")
+    y_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="Y value parameter")
+    z_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="Z value parameter")
+
+    # Categorical input parameters - each with 2 conditions
+    geometry_type = bch.StringSweep(["spherical", "cylindrical"], doc="Geometry model")
+    scaling_type = bch.StringSweep(["linear", "quadratic"], doc="Scaling behavior")
+    # Removed composition_type categorical
+
+    # Output metrics
+    contrast = bch.ResultVar(units="ratio", doc="Secondary contrast measure")
+    intensity = bch.ResultVar(units="units", doc="Primary response intensity")
+
+    def __call__(self, **kwargs) -> dict:
+        """Generate 3D responses with distinctly different patterns based on categorical inputs."""
+        self.update_params_from_kwargs(**kwargs)
+
+        # Normalize inputs to [0,1]
+        x = self.x_value / 100
+        y = self.y_value / 100
+        z = self.z_value / 100
+
+        # Calculate radial components based on geometry_type
+        if self.geometry_type == "spherical":
+            # Spherical geometry creates radial patterns from center
+            r = math.sqrt(x**2 + y**2 + z**2) / math.sqrt(3)
+            theta = math.atan2(y, x) / (2 * math.pi) + 0.5  # normalized [0,1]
+            phi = math.acos(z / max(0.001, math.sqrt(x**2 + y**2 + z**2))) / math.pi
+        else:  # cylindrical
+            # Cylindrical geometry creates patterns based on distance from z-axis
+            r = math.sqrt(x**2 + y**2) / math.sqrt(2)
+            theta = math.atan2(y, x) / (2 * math.pi) + 0.5
+            phi = z  # z directly affects the height
+
+        # Apply scaling function
+        if self.scaling_type == "linear":
+            # Linear scaling creates more uniform patterns
+            scale_factor = 1.5 * r + 0.8 * phi + 0.5 * theta
+            scale_factor2 = 0.7 * r + 1.2 * phi + 0.9 * theta
+        else:  # quadratic
+            # Quadratic scaling creates more concentrated effects
+            scale_factor = 1.5 * r**2 + 0.8 * phi**2 + 0.5 * theta
+            scale_factor2 = 0.7 * r**2 + 1.2 * phi**2 + 0.9 * theta
+
+        # Create wave patterns
+        wave1 = math.sin(5 * math.pi * r) * math.cos(4 * math.pi * theta)
+        wave2 = math.sin(3 * math.pi * phi) * math.sin(6 * math.pi * r * theta)
+
+        # Create interference patterns
+        pattern1 = math.sin(7 * math.pi * (x + y + z) / 3)
+        pattern2 = math.cos(9 * math.pi * x * y * z)
+
+        # Fixed to additive composition (removed composition_type categorical)
+        # Additive creates smoother transitions
+        self.intensity = 0.6 * scale_factor + 0.3 * wave1 + 0.2 * pattern1 + 0.5
+        self.contrast = 0.4 * scale_factor2 + 0.5 * wave2 + 0.3 * pattern2 + 0.3
+
+        # Add minimal randomness (to maintain pattern visibility)
+        random_factor = random.uniform(0.98, 1.02)
+        self.intensity *= random_factor
+        self.contrast *= random_factor
+
+        # Keep values in a reasonable range
+        self.intensity = max(0.1, min(3.0, self.intensity))
+        self.contrast = max(0.1, min(3.0, self.contrast))
+
+        return super().__call__(**kwargs)
+
+
+def example_3_float_2_cat_in_2_out(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    """Benchmark demonstrating 3D visual patterns based on 2 categorical settings.
+
+    Args:
+        run_cfg: Configuration for the benchmark run
+        report: Report to append the results to
+
+    Returns:
+        bch.Bench: The benchmark object
+    """
+    if run_cfg is None:
+        run_cfg = bch.BenchRunCfg()
+        run_cfg.level = 5
+    run_cfg.repeats = 1  # Fewer repeats for a quicker benchmark
+
+    hv.opts.defaults(hv.opts.HeatMap(cmap="plasma", width=300, height=300, colorbar=True))
+
+    bench = Pattern3DModel2Cat().to_bench(run_cfg, report)
+    bench.plot_sweep(
+        title="3D Pattern Visualization (3 Float, 2 Categorical Variables)",
+        description="Response patterns with distinctive shapes based on 3D coordinates and 2 categorical settings",
+        post_description="""
+        Geometry Type: Spherical (radial from center) vs Cylindrical (distance from z-axis)
+        Scaling Type: Linear (uniform effects) vs Quadratic (concentrated effects)
+        
+        This example uses additive composition for pattern generation (fixed parameter).
+        2D slices of the 3D space show visually distinctive patterns that vary based on categorical settings.
+        The intensity and contrast measures reveal different aspects of the underlying mathematical model.
+        """,
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_3_float_2_cat_in_2_out().report.show()

bencher/example/inputs_3_float/example_3_float_3_cat_in_2_out.py

@@ -0,0 +1,129 @@
+"""Demonstration of benchmarking with 3 float and 3 categorical inputs producing visually distinct patterns.
+
+Each categorical input has 2 conditions that create distinctly different surface shapes in 3D space.
+"""
+
+import random
+import math
+import bencher as bch
+import holoviews as hv
+
+random.seed(0)
+
+
+class Pattern3DModel(bch.ParametrizedSweep):
+    """Benchmark demonstrating 3D patterns with distinctive shapes based on categorical settings."""
+
+    # Float input parameters
+    x_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="X value parameter")
+    y_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="Y value parameter")
+    z_value = bch.FloatSweep(default=50, bounds=[0, 100], doc="Z value parameter")
+
+    # Categorical input parameters - each with 2 conditions
+    geometry_type = bch.StringSweep(["spherical", "cylindrical"], doc="Geometry model")
+    scaling_type = bch.StringSweep(["linear", "quadratic"], doc="Scaling behavior")
+    composition_type = bch.StringSweep(["additive", "multiplicative"], doc="How components combine")
+
+    # Output metrics
+    contrast = bch.ResultVar(units="ratio", doc="Secondary contrast measure")
+    intensity = bch.ResultVar(units="units", doc="Primary response intensity")
+
+    def __call__(self, **kwargs) -> dict:
+        """Generate 3D responses with distinctly different patterns based on categorical inputs."""
+        self.update_params_from_kwargs(**kwargs)
+
+        # Normalize inputs to [0,1]
+        x = self.x_value / 100
+        y = self.y_value / 100
+        z = self.z_value / 100
+
+        # Calculate radial components based on geometry_type
+        if self.geometry_type == "spherical":
+            # Spherical geometry creates radial patterns from center
+            r = math.sqrt(x**2 + y**2 + z**2) / math.sqrt(3)
+            theta = math.atan2(y, x) / (2 * math.pi) + 0.5  # normalized [0,1]
+            phi = math.acos(z / max(0.001, math.sqrt(x**2 + y**2 + z**2))) / math.pi
+        else:  # cylindrical
+            # Cylindrical geometry creates patterns based on distance from z-axis
+            r = math.sqrt(x**2 + y**2) / math.sqrt(2)
+            theta = math.atan2(y, x) / (2 * math.pi) + 0.5
+            phi = z  # z directly affects the height
+
+        # Apply scaling function
+        if self.scaling_type == "linear":
+            # Linear scaling creates more uniform patterns
+            scale_factor = 1.5 * r + 0.8 * phi + 0.5 * theta
+            scale_factor2 = 0.7 * r + 1.2 * phi + 0.9 * theta
+        else:  # quadratic
+            # Quadratic scaling creates more concentrated effects
+            scale_factor = 1.5 * r**2 + 0.8 * phi**2 + 0.5 * theta
+            scale_factor2 = 0.7 * r**2 + 1.2 * phi**2 + 0.9 * theta
+
+        # Create wave patterns
+        wave1 = math.sin(5 * math.pi * r) * math.cos(4 * math.pi * theta)
+        wave2 = math.sin(3 * math.pi * phi) * math.sin(6 * math.pi * r * theta)
+
+        # Create interference patterns
+        pattern1 = math.sin(7 * math.pi * (x + y + z) / 3)
+        pattern2 = math.cos(9 * math.pi * x * y * z)
+
+        # Combine components based on composition_type
+        if self.composition_type == "additive":
+            # Additive creates smoother transitions
+            self.intensity = 0.6 * scale_factor + 0.3 * wave1 + 0.2 * pattern1 + 0.5
+            self.contrast = 0.4 * scale_factor2 + 0.5 * wave2 + 0.3 * pattern2 + 0.3
+        else:  # multiplicative
+            # Multiplicative creates sharper boundaries
+            self.intensity = 0.6 * scale_factor * (1 + 0.6 * wave1) * (1 + 0.4 * pattern1)
+            self.contrast = 0.4 * scale_factor2 * (1 + 0.8 * wave2) * (1 + 0.5 * pattern2)
+
+        # Add minimal randomness (to maintain pattern visibility)
+        random_factor = random.uniform(0.98, 1.02)
+        self.intensity *= random_factor
+        self.contrast *= random_factor
+
+        # Keep values in a reasonable range
+        self.intensity = max(0.1, min(3.0, self.intensity))
+        self.contrast = max(0.1, min(3.0, self.contrast))
+
+        return super().__call__(**kwargs)
+
+
+def example_3_float_3_cat_in_2_out(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    """Benchmark demonstrating 3D visual patterns based on categorical settings.
+
+    Args:
+        run_cfg: Configuration for the benchmark run
+        report: Report to append the results to
+
+    Returns:
+        bch.Bench: The benchmark object
+    """
+    if run_cfg is None:
+        run_cfg = bch.BenchRunCfg()
+        run_cfg.level = 5
+    run_cfg.repeats = 1  # Fewer repeats for a quicker benchmark
+
+    hv.opts.defaults(hv.opts.HeatMap(cmap="plasma", width=300, height=300, colorbar=True))
+
+    bench = Pattern3DModel().to_bench(run_cfg, report)
+    bench.plot_sweep(
+        title="3D Pattern Visualization (3 Float, 3 Categorical Variables)",
+        description="Response patterns with distinctive shapes based on 3D coordinates and categorical settings",
+        post_description="""
+        Geometry Type: Spherical (radial from center) vs Cylindrical (distance from z-axis)
+        Scaling Type: Linear (uniform effects) vs Quadratic (concentrated effects)
+        Composition Type: Additive (smooth transitions) vs Multiplicative (sharp boundaries)
+        
+        2D slices of the 3D space show visually distinctive patterns that vary based on categorical settings.
+        The intensity and contrast measures reveal different aspects of the underlying mathematical model.
+        """,
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_3_float_3_cat_in_2_out().report.show()