pytopo3d 0.1.0__py3-none-any.whl

pytopo3d/cli/__init__.py

@@ -0,0 +1,3 @@
+"""
+Command-line interface utilities for the 3D topology optimization package.
+""" 

pytopo3d/cli/command.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""
+Command-line entry point for the pytopo3d package.
+This module provides the main entry point when installed as a package.
+"""
+
+import sys
+from typing import List, Optional
+
+# Import the main function from the main module
+from pytopo3d.cli.parser import parse_args
+from pytopo3d.preprocessing.geometry import load_geometry_data
+from pytopo3d.runners.experiment import (
+    execute_optimization,
+    export_result_to_stl,
+    setup_experiment,
+)
+from pytopo3d.utils.metrics import collect_metrics
+from pytopo3d.visualization.visualizer import (
+    create_optimization_animation,
+    visualize_final_result,
+    visualize_initial_setup,
+)
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """
+    Main function to run the optimization from command-line arguments.
+
+    Args:
+        args: Command line arguments (sys.argv[1:] by default)
+
+    Returns:
+        Exit code (0 for success, non-zero for errors)
+    """
+    # Parse command-line arguments
+    if args is None:
+        args = sys.argv[1:]
+
+    parsed_args = parse_args(args)
+
+    try:
+        # Setup experiment, logging and results manager
+        logger, results_mgr = setup_experiment(
+            verbose=parsed_args.verbose,
+            quiet=parsed_args.quiet,
+            log_level=parsed_args.log_level,
+            log_file=parsed_args.log_file,
+            experiment_name=getattr(parsed_args, "experiment_name", None),
+            description=parsed_args.description,
+            nelx=parsed_args.nelx,
+            nely=parsed_args.nely,
+            nelz=parsed_args.nelz,
+            volfrac=parsed_args.volfrac,
+            penal=parsed_args.penal,
+            rmin=parsed_args.rmin,
+        )
+
+        # Update args.experiment_name if it was generated in setup_experiment
+        if (
+            not hasattr(parsed_args, "experiment_name")
+            or not parsed_args.experiment_name
+        ):
+            parsed_args.experiment_name = results_mgr.experiment_name
+
+        # Load design space and obstacle data
+        design_space_mask, obstacle_mask, combined_obstacle_mask = load_geometry_data(
+            nelx=parsed_args.nelx,
+            nely=parsed_args.nely,
+            nelz=parsed_args.nelz,
+            design_space_stl=getattr(parsed_args, "design_space_stl", None),
+            pitch=getattr(parsed_args, "pitch", 1.0),
+            invert_design_space=getattr(parsed_args, "invert_design_space", False),
+            obstacle_config=getattr(parsed_args, "obstacle_config", None),
+            experiment_name=parsed_args.experiment_name,
+            logger=logger,
+            results_mgr=results_mgr,
+        )
+
+        # Create and save initial visualization
+        loads_array, constraints_array, _ = visualize_initial_setup(
+            nelx=parsed_args.nelx,
+            nely=parsed_args.nely,
+            nelz=parsed_args.nelz,
+            experiment_name=parsed_args.experiment_name,
+            logger=logger,
+            results_mgr=results_mgr,
+            combined_obstacle_mask=combined_obstacle_mask,
+        )
+
+        # Run the optimization
+        xPhys, history, run_time = execute_optimization(
+            nelx=parsed_args.nelx,
+            nely=parsed_args.nely,
+            nelz=parsed_args.nelz,
+            volfrac=parsed_args.volfrac,
+            penal=parsed_args.penal,
+            rmin=parsed_args.rmin,
+            disp_thres=parsed_args.disp_thres,
+            tolx=getattr(parsed_args, "tolx", 0.01),
+            maxloop=getattr(parsed_args, "maxloop", 2000),
+            create_animation=getattr(parsed_args, "create_animation", False),
+            animation_frequency=getattr(parsed_args, "animation_frequency", 10),
+            logger=logger,
+            combined_obstacle_mask=combined_obstacle_mask,
+        )
+
+        # Save the result to the experiment directory
+        result_path = results_mgr.save_result(xPhys, "optimized_design.npy")
+        logger.debug(f"Optimization result saved to {result_path}")
+
+        # Create visualization of the final result
+        visualize_final_result(
+            nelx=parsed_args.nelx,
+            nely=parsed_args.nely,
+            nelz=parsed_args.nelz,
+            experiment_name=parsed_args.experiment_name,
+            disp_thres=parsed_args.disp_thres,
+            logger=logger,
+            results_mgr=results_mgr,
+            xPhys=xPhys,
+            combined_obstacle_mask=combined_obstacle_mask,
+            loads_array=loads_array,
+            constraints_array=constraints_array,
+        )
+
+        # Create animation if history was captured
+        gif_path = None
+        if history:
+            gif_path = create_optimization_animation(
+                nelx=parsed_args.nelx,
+                nely=parsed_args.nely,
+                nelz=parsed_args.nelz,
+                experiment_name=parsed_args.experiment_name,
+                disp_thres=parsed_args.disp_thres,
+                animation_frames=getattr(parsed_args, "animation_frames", 50),
+                animation_fps=getattr(parsed_args, "animation_fps", 5),
+                logger=logger,
+                results_mgr=results_mgr,
+                history=history,
+                combined_obstacle_mask=combined_obstacle_mask,
+                loads_array=loads_array,
+                constraints_array=constraints_array,
+            )
+
+        # Export result as STL if requested
+        stl_exported = export_result_to_stl(
+            export_stl=getattr(parsed_args, "export_stl", False),
+            stl_level=getattr(parsed_args, "stl_level", 0.5),
+            smooth_stl=getattr(parsed_args, "smooth_stl", False),
+            smooth_iterations=getattr(parsed_args, "smooth_iterations", 3),
+            logger=logger,
+            results_mgr=results_mgr,
+            result_path=result_path,
+        )
+
+        # Collect and save metrics
+        metrics = collect_metrics(
+            nelx=parsed_args.nelx,
+            nely=parsed_args.nely,
+            nelz=parsed_args.nelz,
+            volfrac=parsed_args.volfrac,
+            penal=parsed_args.penal,
+            rmin=parsed_args.rmin,
+            disp_thres=parsed_args.disp_thres,
+            tolx=getattr(parsed_args, "tolx", 0.01),
+            maxloop=getattr(parsed_args, "maxloop", 2000),
+            design_space_stl=getattr(parsed_args, "design_space_stl", None),
+            pitch=getattr(parsed_args, "pitch", 1.0),
+            obstacle_config=getattr(parsed_args, "obstacle_config", None),
+            animation_fps=getattr(parsed_args, "animation_fps", 5),
+            stl_level=getattr(parsed_args, "stl_level", 0.5),
+            smooth_stl=getattr(parsed_args, "smooth_stl", False),
+            smooth_iterations=getattr(parsed_args, "smooth_iterations", 3),
+            xPhys=xPhys,
+            design_space_mask=design_space_mask,
+            obstacle_mask=obstacle_mask,
+            combined_obstacle_mask=combined_obstacle_mask,
+            run_time=run_time,
+            gif_path=gif_path,
+            stl_exported=stl_exported,
+        )
+        results_mgr.update_metrics(metrics)
+        logger.debug("Metrics updated")
+
+        logger.info(f"Optimization complete in {run_time:.2f} seconds.")
+        logger.info(f"Result saved to {result_path}")
+        logger.info(f"All experiment files are in {results_mgr.experiment_dir}")
+
+    except Exception as e:
+        if "logger" in locals():
+            logger.error(f"Error in main function: {e}")
+            import traceback
+
+            logger.debug(f"Error details: {traceback.format_exc()}")
+        else:
+            print(f"Error during initialization: {e}", file=sys.stderr)
+            import traceback
+
+            print(f"Error details: {traceback.format_exc()}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pytopo3d/cli/parser.py

@@ -0,0 +1,235 @@
+"""
+Command-line argument parsing for the 3D topology optimization package.
+"""
+
+import argparse
+import os
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+def parse_args(args: Optional[List[str]] = None) -> argparse.Namespace:
+    """
+    Parse command-line arguments for the topology optimization.
+
+    Parameters
+    ----------
+    args : Optional[List[str]], optional
+        Command line arguments, by default None (uses sys.argv[1:])
+
+    Returns
+    -------
+    argparse.Namespace
+        Parsed command-line arguments.
+    """
+    parser = argparse.ArgumentParser(
+        description="3D Topology Optimization",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    # Basic parameters
+    basic_group = parser.add_argument_group("Basic parameters")
+    basic_group.add_argument(
+        "--nelx", type=int, default=60, help="Number of elements in x direction"
+    )
+    basic_group.add_argument(
+        "--nely", type=int, default=30, help="Number of elements in y direction"
+    )
+    basic_group.add_argument(
+        "--nelz", type=int, default=20, help="Number of elements in z direction"
+    )
+    basic_group.add_argument(
+        "--volfrac", type=float, default=0.3, help="Volume fraction constraint"
+    )
+    basic_group.add_argument(
+        "--penal", type=float, default=3.0, help="Penalty parameter"
+    )
+    basic_group.add_argument("--rmin", type=float, default=3.0, help="Filter radius")
+    basic_group.add_argument(
+        "--disp_thres",
+        type=float,
+        default=0.5,
+        help="Threshold for displaying elements in visualization",
+    )
+    basic_group.add_argument(
+        "--tolx",
+        type=float,
+        default=0.01,
+        help="Convergence tolerance on design change",
+    )
+    basic_group.add_argument(
+        "--maxloop",
+        type=int,
+        default=2000,
+        help="Maximum number of iterations",
+    )
+
+    # Output parameters
+    output_group = parser.add_argument_group("Output parameters")
+    output_group.add_argument(
+        "--output",
+        type=str,
+        default="optimized_design.npy",
+        help="Output filename for the optimized design",
+    )
+    output_group.add_argument(
+        "--export-stl",
+        action="store_true",
+        help="Export the final optimization result as an STL file",
+    )
+    output_group.add_argument(
+        "--stl-level",
+        type=float,
+        default=0.5,
+        help="Contour level for STL export (default: 0.5)",
+    )
+    output_group.add_argument(
+        "--smooth-stl",
+        action="store_true",
+        default=True,
+        help="Apply smoothing to the exported STL (default: True)",
+    )
+    output_group.add_argument(
+        "--smooth-iterations",
+        type=int,
+        default=5,
+        help="Number of smoothing iterations for STL export (default: 5)",
+    )
+    output_group.add_argument(
+        "--experiment-name",
+        type=str,
+        default=None,
+        help="Custom name for the experiment (optional)",
+    )
+    output_group.add_argument(
+        "--description",
+        type=str,
+        default=None,
+        help="Description of the experiment (optional)",
+    )
+
+    # Animation parameters
+    animation_group = parser.add_argument_group("Animation parameters")
+    animation_group.add_argument(
+        "--create-animation",
+        action="store_true",
+        help="Create a GIF animation of the optimization process",
+    )
+    animation_group.add_argument(
+        "--animation-frequency",
+        type=int,
+        default=10,
+        help="Store every N iterations for the animation (default: 10)",
+    )
+    animation_group.add_argument(
+        "--animation-frames",
+        type=int,
+        default=50,
+        help="Target number of frames to include in the animation (default: 50)",
+    )
+    animation_group.add_argument(
+        "--animation-fps",
+        type=int,
+        default=5,
+        help="Frames per second in the animation (default: 5)",
+    )
+
+    # Design space parameters
+    design_space_group = parser.add_argument_group("Design space parameters")
+    design_space_group.add_argument(
+        "--design-space-stl",
+        type=str,
+        help="Path to an STL file defining the design space geometry",
+    )
+    design_space_group.add_argument(
+        "--pitch",
+        type=float,
+        default=1.0,
+        help="Distance between voxel centers when voxelizing STL (smaller values create finer detail)",
+    )
+    design_space_group.add_argument(
+        "--invert-design-space",
+        action="store_true",
+        help="Invert the design space (treat STL as void space rather than design space)",
+    )
+
+    # Obstacle related arguments
+    obstacle_group = parser.add_argument_group("Obstacle parameters")
+    obstacle_group.add_argument(
+        "--obstacle-config", type=str, help="Path to a JSON file defining obstacles"
+    )
+
+    # Logging parameters
+    log_group = parser.add_argument_group("Logging parameters")
+    log_group.add_argument(
+        "--log-level",
+        type=str,
+        default="INFO",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        help="Logging level",
+    )
+    log_group.add_argument("--log-file", type=str, default=None, help="Log file path")
+    log_group.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Enable verbose output (DEBUG level)",
+    )
+    log_group.add_argument(
+        "--quiet", "-q", action="store_true", help="Suppress output (WARNING level)"
+    )
+
+    return parser.parse_args(args)
+
+
+def generate_experiment_name(args: argparse.Namespace) -> str:
+    """
+    Generate an experiment name from command-line arguments.
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Command-line arguments.
+
+    Returns
+    -------
+    str
+        Generated experiment name.
+    """
+    if args.experiment_name:
+        return args.experiment_name
+
+    dims = f"{args.nelx}x{args.nely}x{args.nelz}"
+
+    # Include obstacle info in experiment name
+    obstacle_type = "no_obstacle"
+    if args.obstacle_config:
+        obstacle_type = os.path.basename(args.obstacle_config).replace(".json", "")
+
+    # Include design space STL info in experiment name if provided
+    design_space = ""
+    if hasattr(args, "design_space_stl") and args.design_space_stl:
+        stl_name = os.path.basename(args.design_space_stl).replace(".stl", "")
+        pitch_info = f"_p{args.pitch}".replace(".", "p")
+        design_space = f"_ds_{stl_name}{pitch_info}"
+
+    return f"{dims}_{obstacle_type}{design_space}"
+
+
+def create_config_dict(args: argparse.Namespace) -> Dict[str, Any]:
+    """
+    Create a configuration dictionary from command-line arguments.
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Command-line arguments.
+
+    Returns
+    -------
+    Dict[str, Any]
+        Configuration dictionary.
+    """
+    config = vars(args)
+    config["timestamp"] = datetime.now().isoformat()
+    return config

pytopo3d/core/compliance.py

@@ -0,0 +1,32 @@
+"""
+Element compliance calculation for 3D topology optimization.
+
+This module contains functions for computing element-wise compliance.
+"""
+
+import numpy as np
+
+def element_compliance(U, edofMat, KE):
+    """
+    Compute element-wise compliance:
+      ce[e] = Ue @ KE @ Ue^T  for each element e.
+    
+    Parameters
+    ----------
+    U : ndarray
+        Global displacement vector.
+    edofMat : ndarray
+        Element DOF mapping matrix.
+    KE : ndarray
+        Element stiffness matrix.
+        
+    Returns
+    -------
+    ndarray
+        A 1D array of length nele with element compliance values.
+    """
+    nele = edofMat.shape[0]
+    # edofMat is 1-based indexing, so subtract 1 for 0-based U
+    Ue = U[edofMat.astype(int) - 1]  # shape (nele, 24)
+    ce = np.sum((Ue @ KE) * Ue, axis=1)
+    return ce