pytopo3d


Namepytopo3d JSON
Version 0.1.0 PyPI version JSON
download
home_pagehttps://github.com/jihoonkim888/PyTopo3D
Summary3D SIMP Topology Optimization Framework for Python
upload_time2025-04-09 02:08:18
maintainerNone
docs_urlNone
authorJihoon Kim, Namwoo Kang
requires_python>=3.10
licenseMIT
keywords topology optimization simp structural optimization 3d finite element
VCS
bugtrack_url
requirements No requirements were recorded.
Travis-CI No Travis.
coveralls test coverage No coveralls.
            # PyTopo3D: 3D SIMP Topology Optimization Framework for Python

![Design optimization with boundary conditions](assets/optimization_animation.gif)

A comprehensive Python implementation of 3D Topology Optimization based on SIMP (Solid Isotropic Material with Penalization) method. Unlike traditional MATLAB implementations, PyTopo3D brings the power of 3D SIMP-based optimization to the Python ecosystem with support for obstacle regions.

## Table of Contents
- [PyTopo3D: 3D SIMP Topology Optimization Framework for Python](#pytopo3d-3d-simp-topology-optimization-framework-for-python)
  - [Table of Contents](#table-of-contents)
  - [Overview](#overview)
  - [Installation](#installation)
  - [Basic Usage](#basic-usage)
    - [Configuration Parameters](#configuration-parameters)
    - [Command-line Interface](#command-line-interface)
    - [Python Package API](#python-package-api)
  - [Advanced Features](#advanced-features)
    - [Obstacle Configuration](#obstacle-configuration)
      - [Command Line Usage](#command-line-usage)
      - [Python API Usage](#python-api-usage)
      - [Obstacle Configuration Format](#obstacle-configuration-format)
    - [Design Space Customization](#design-space-customization)
      - [Command Line Usage](#command-line-usage-1)
      - [Python API Usage](#python-api-usage-1)
      - [Understanding Pitch and Resolution](#understanding-pitch-and-resolution)
    - [Exporting Results](#exporting-results)
      - [Command Line Usage](#command-line-usage-2)
    - [Animation Generation](#animation-generation)
    - [Experiment Management](#experiment-management)
      - [Command Line Options](#command-line-options)
  - [Acknowledgements](#acknowledgements)
  - [Citation](#citation)

## Overview

This code performs 3D structural topology optimization using the SIMP (Solid Isotropic Material with Penalization) method. It is designed to be efficient by utilizing:

- Parallel solver (PyPardiso if available, otherwise SciPy's spsolve)
- Precomputed assembly mapping for fast matrix assembly
- Support for obstacle regions where no material can be placed
- Flexible obstacle configuration via JSON files
- Advanced visualization capabilities including animation generation

## Installation

1. Clone this repository:
```bash
git clone https://github.com/jihoonkim888/PyTopo3D.git
cd PyTopo3D
```

2. Create and activate the conda environment:
```bash
# Create the environment from the environment.yml file
conda env create -f environment.yml

# Activate the environment
conda activate pytopo3d
```

## Basic Usage

### Configuration Parameters

The main optimization parameters are:

- `nelx`, `nely`, `nelz`: Number of elements in x, y, z directions (default: 60, 30, 20)
- `volfrac`: Volume fraction constraint (0.0-1.0) (default: 0.3)
- `penal`: Penalization power for SIMP method (default: 3.0)
- `rmin`: Filter radius for sensitivity filtering (default: 3.0)
- `disp_thres`: Display threshold for 3D visualization (elements with density > disp_thres are shown) (default: 0.5)
- `tolx`: Convergence tolerance on design change (default: 0.01)
- `maxloop`: Maximum number of iterations (default: 2000)

### Command-line Interface

To run a basic optimization:

```bash
python main.py --nelx 32 --nely 16 --nelz 16 --volfrac 0.3 --penal 3.0 --rmin 3.0
```

For full options:

```bash
python main.py --help
```

### Python Package API

```python
import numpy as np
from pytopo3d.core.optimizer import top3d

# Define parameters
nelx, nely, nelz = 32, 16, 16
volfrac = 0.3
penal = 3.0
rmin = 3.0
disp_thres = 0.5

# Run optimization
result = top3d(nelx, nely, nelz, volfrac, penal, rmin, disp_thres)

# Save result
np.save("optimized_design.npy", result)
```

## Advanced Features

### Obstacle Configuration

PyTopo3D supports defining regions where material should not be placed during optimization.

#### Command Line Usage

```bash
python main.py --obstacle-config examples/obstacles_config_cylinder.json
```

#### Python API Usage

```python
# Create a custom obstacle mask
obstacle_mask = np.zeros((nely, nelx, nelz), dtype=bool)
obstacle_mask[5:15, 3:7, 3:7] = True  # Example obstacle

# Or load obstacles from config file
from pytopo3d.preprocessing.geometry import load_geometry_data

design_space_mask, obstacle_mask, combined_obstacle_mask = load_geometry_data(
    nelx=nelx, 
    nely=nely, 
    nelz=nelz, 
    obstacle_config="path/to/config.json"
)

# Use the mask in optimization
result = top3d(nelx, nely, nelz, volfrac, penal, rmin, disp_thres, 
               obstacle_mask=combined_obstacle_mask)
```

#### Obstacle Configuration Format

The obstacle configuration file is a JSON file with the following structure:

```json
{
  "obstacles": [
    {
      "type": "cube",
      "center": [0.5, 0.5, 0.2],  // x, y, z as fractions [0-1]
      "size": 0.15                // single value for a cube
    },
    {
      "type": "sphere",
      "center": [0.25, 0.25, 0.6],
      "radius": 0.1
    },
    {
      "type": "cylinder",
      "center": [0.75, 0.5, 0.5],
      "radius": 0.08,
      "height": 0.7,
      "axis": 2                  // 0=x, 1=y, 2=z
    },
    {
      "type": "cube",
      "center": [0.25, 0.75, 0.5],
      "size": [0.15, 0.05, 0.3]  // [x, y, z] for a cuboid
    }
  ]
}
```

Supported obstacle types:
- `cube`: A cube or cuboid. Use `size` as a single value for a cube, or as `[x, y, z]` for a cuboid.
- `sphere`: A sphere. Use `radius` to set the size.
- `cylinder`: A cylinder. Use `radius`, `height`, and `axis` (0=x, 1=y, 2=z) to configure.

All positions are specified as fractions [0-1] of the domain size, making it easy to reuse configurations across different mesh resolutions.

### Design Space Customization

PyTopo3D allows using STL files to define the design space geometry, enabling complex shapes beyond the standard rectangular domain.

#### Command Line Usage

```bash
python main.py --design-space-stl path/to/design_space.stl --pitch 0.5
```

Command line options:
- `--design-space-stl`: Path to an STL file defining the design space geometry
- `--pitch`: Distance between voxel centers when voxelizing STL (default: 1.0, smaller values create finer detail)
- `--invert-design-space`: Flag to invert the design space (treat STL as void space rather than design space)

#### Python API Usage

```python
from pytopo3d.preprocessing.geometry import load_geometry_data
import numpy as np

# Load design space from STL
design_space_mask, obstacle_mask, combined_obstacle_mask = load_geometry_data(
    nelx=60, 
    nely=30, 
    nelz=20,
    design_space_stl="path/to/design_space.stl",
    pitch=0.5,
    invert_design_space=False
)

# The shape of the mask is determined by the STL geometry and pitch
nely, nelx, nelz = design_space_mask.shape
print(f"Resolution from voxelization: {nely}x{nelx}x{nelz}")

# Use the mask in optimization
from pytopo3d.core.optimizer import top3d

result = top3d(
    nelx=nelx, 
    nely=nely, 
    nelz=nelz, 
    volfrac=0.3, 
    penal=3.0, 
    rmin=3.0,
    disp_thres=0.5,
    obstacle_mask=combined_obstacle_mask
)
```

#### Understanding Pitch and Resolution

The `pitch` parameter directly controls the resolution of the voxelized model:

- Smaller pitch values create higher resolution voxelizations
- The number of voxels along any dimension = physical length รท pitch
- Choose pitch value based on the level of detail needed and computational resources available

### Exporting Results

You can export the final optimization result as an STL file for 3D printing or further analysis in CAD software.

#### Command Line Usage

```bash
python main.py --nelx 32 --nely 16 --nelz 16 \
               --volfrac 0.3 --penal 3.0 --rmin 3.0 \
               --export-stl \
               [--stl-level 0.5] \
               [--smooth-stl] \
               [--smooth-iterations 5]
```

Options:
- `--export-stl`: Flag to enable STL export of the final optimization result
- `--stl-level`: Contour level for the marching cubes algorithm (default: 0.5)
- `--smooth-stl`: Flag to apply Laplacian smoothing to the mesh (default: True)
- `--smooth-iterations`: Number of iterations for mesh smoothing (default: 5)

### Animation Generation

PyTopo3D can generate animations of the optimization process.

```bash
python main.py --nelx 32 --nely 16 --nelz 16 \
               --create-animation \
               --animation-frequency 10 \
               --animation-frames 50 \
               --animation-fps 5
```

Options:
- `--create-animation`: Flag to enable animation generation
- `--animation-frequency`: Store every N iterations for the animation (default: 10)
- `--animation-frames`: Target number of frames in the final animation (default: 50)
- `--animation-fps`: Frames per second in the generated animation (default: 5)

### Experiment Management

PyTopo3D includes a robust experiment management system that automatically:

- Creates a uniquely named directory for each optimization run
- Saves all relevant parameters, inputs, and outputs
- Generates detailed logs of the optimization process
- Records performance metrics and convergence data

#### Command Line Options

```bash
python main.py --experiment-name custom_name \
               --description "Detailed description of this experiment" \
               --log-level DEBUG \
               --log-file custom_log.log \
               --verbose
```

Options:
- `--experiment-name`: Custom name for the experiment (optional, auto-generated if not provided)
- `--description`: Description of the experiment stored in the results metadata
- `--log-level`: Set logging detail level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
- `--log-file`: Path to a custom log file
- `--verbose`: Enable more detailed output (sets log level to DEBUG)
- `--quiet`: Reduce output verbosity (sets log level to WARNING)

## Acknowledgements

This code is adapted from [Liu & Tovar's MATLAB code](https://www.top3d.app/) for 3D topology optimization.

> K. Liu and A. Tovar, "An efficient 3D topology optimization code written in Matlab", Struct Multidisc Optim, 50(6): 1175-1196, 2014, doi:10.1007/s00158-014-1107-x

## Citation

If you use PyTopo3D in your research or work, please cite our paper on ArXiv: [PyTopo3D: A Python Framework for 3D SIMP-based Topology Optimization](https://arxiv.org/abs/2504.05604)

> Kim, J. & Kang, N. (2024). PyTopo3D: A Python Framework for 3D SIMP-based Topology Optimization. arXiv preprint arXiv:2504.05604.

```bibtex
@article{kim2025pytopo3d
      title={PyTopo3D: A Python Framework for 3D SIMP-based Topology Optimization}, 
      author={Jihoon Kim and Namwoo Kang},
      journal={arXiv preprint arXiv:2504.05604},
      year={2025}
}
```

This paper provides a detailed explanation of the implementation, theoretical foundations, and optimizations used in PyTopo3D. Proper citation helps support the continued development of open-source scientific software.

            

Raw data

            {
    "_id": null,
    "home_page": "https://github.com/jihoonkim888/PyTopo3D",
    "name": "pytopo3d",
    "maintainer": null,
    "docs_url": null,
    "requires_python": ">=3.10",
    "maintainer_email": null,
    "keywords": "topology optimization, SIMP, structural optimization, 3D, finite element",
    "author": "Jihoon Kim, Namwoo Kang",
    "author_email": "Jihoon Kim <jihoonkim888@example.com>, Namwoo Kang <example@example.com>",
    "download_url": "https://files.pythonhosted.org/packages/96/fe/99996aaa7eadbb825e0094167b5b0c3e21b8a8f01bfff5711003d3c0b57d/pytopo3d-0.1.0.tar.gz",
    "platform": null,
    "description": "# PyTopo3D: 3D SIMP Topology Optimization Framework for Python\r\n\r\n![Design optimization with boundary conditions](assets/optimization_animation.gif)\r\n\r\nA comprehensive Python implementation of 3D Topology Optimization based on SIMP (Solid Isotropic Material with Penalization) method. Unlike traditional MATLAB implementations, PyTopo3D brings the power of 3D SIMP-based optimization to the Python ecosystem with support for obstacle regions.\r\n\r\n## Table of Contents\r\n- [PyTopo3D: 3D SIMP Topology Optimization Framework for Python](#pytopo3d-3d-simp-topology-optimization-framework-for-python)\r\n  - [Table of Contents](#table-of-contents)\r\n  - [Overview](#overview)\r\n  - [Installation](#installation)\r\n  - [Basic Usage](#basic-usage)\r\n    - [Configuration Parameters](#configuration-parameters)\r\n    - [Command-line Interface](#command-line-interface)\r\n    - [Python Package API](#python-package-api)\r\n  - [Advanced Features](#advanced-features)\r\n    - [Obstacle Configuration](#obstacle-configuration)\r\n      - [Command Line Usage](#command-line-usage)\r\n      - [Python API Usage](#python-api-usage)\r\n      - [Obstacle Configuration Format](#obstacle-configuration-format)\r\n    - [Design Space Customization](#design-space-customization)\r\n      - [Command Line Usage](#command-line-usage-1)\r\n      - [Python API Usage](#python-api-usage-1)\r\n      - [Understanding Pitch and Resolution](#understanding-pitch-and-resolution)\r\n    - [Exporting Results](#exporting-results)\r\n      - [Command Line Usage](#command-line-usage-2)\r\n    - [Animation Generation](#animation-generation)\r\n    - [Experiment Management](#experiment-management)\r\n      - [Command Line Options](#command-line-options)\r\n  - [Acknowledgements](#acknowledgements)\r\n  - [Citation](#citation)\r\n\r\n## Overview\r\n\r\nThis code performs 3D structural topology optimization using the SIMP (Solid Isotropic Material with Penalization) method. It is designed to be efficient by utilizing:\r\n\r\n- Parallel solver (PyPardiso if available, otherwise SciPy's spsolve)\r\n- Precomputed assembly mapping for fast matrix assembly\r\n- Support for obstacle regions where no material can be placed\r\n- Flexible obstacle configuration via JSON files\r\n- Advanced visualization capabilities including animation generation\r\n\r\n## Installation\r\n\r\n1. Clone this repository:\r\n```bash\r\ngit clone https://github.com/jihoonkim888/PyTopo3D.git\r\ncd PyTopo3D\r\n```\r\n\r\n2. Create and activate the conda environment:\r\n```bash\r\n# Create the environment from the environment.yml file\r\nconda env create -f environment.yml\r\n\r\n# Activate the environment\r\nconda activate pytopo3d\r\n```\r\n\r\n## Basic Usage\r\n\r\n### Configuration Parameters\r\n\r\nThe main optimization parameters are:\r\n\r\n- `nelx`, `nely`, `nelz`: Number of elements in x, y, z directions (default: 60, 30, 20)\r\n- `volfrac`: Volume fraction constraint (0.0-1.0) (default: 0.3)\r\n- `penal`: Penalization power for SIMP method (default: 3.0)\r\n- `rmin`: Filter radius for sensitivity filtering (default: 3.0)\r\n- `disp_thres`: Display threshold for 3D visualization (elements with density > disp_thres are shown) (default: 0.5)\r\n- `tolx`: Convergence tolerance on design change (default: 0.01)\r\n- `maxloop`: Maximum number of iterations (default: 2000)\r\n\r\n### Command-line Interface\r\n\r\nTo run a basic optimization:\r\n\r\n```bash\r\npython main.py --nelx 32 --nely 16 --nelz 16 --volfrac 0.3 --penal 3.0 --rmin 3.0\r\n```\r\n\r\nFor full options:\r\n\r\n```bash\r\npython main.py --help\r\n```\r\n\r\n### Python Package API\r\n\r\n```python\r\nimport numpy as np\r\nfrom pytopo3d.core.optimizer import top3d\r\n\r\n# Define parameters\r\nnelx, nely, nelz = 32, 16, 16\r\nvolfrac = 0.3\r\npenal = 3.0\r\nrmin = 3.0\r\ndisp_thres = 0.5\r\n\r\n# Run optimization\r\nresult = top3d(nelx, nely, nelz, volfrac, penal, rmin, disp_thres)\r\n\r\n# Save result\r\nnp.save(\"optimized_design.npy\", result)\r\n```\r\n\r\n## Advanced Features\r\n\r\n### Obstacle Configuration\r\n\r\nPyTopo3D supports defining regions where material should not be placed during optimization.\r\n\r\n#### Command Line Usage\r\n\r\n```bash\r\npython main.py --obstacle-config examples/obstacles_config_cylinder.json\r\n```\r\n\r\n#### Python API Usage\r\n\r\n```python\r\n# Create a custom obstacle mask\r\nobstacle_mask = np.zeros((nely, nelx, nelz), dtype=bool)\r\nobstacle_mask[5:15, 3:7, 3:7] = True  # Example obstacle\r\n\r\n# Or load obstacles from config file\r\nfrom pytopo3d.preprocessing.geometry import load_geometry_data\r\n\r\ndesign_space_mask, obstacle_mask, combined_obstacle_mask = load_geometry_data(\r\n    nelx=nelx, \r\n    nely=nely, \r\n    nelz=nelz, \r\n    obstacle_config=\"path/to/config.json\"\r\n)\r\n\r\n# Use the mask in optimization\r\nresult = top3d(nelx, nely, nelz, volfrac, penal, rmin, disp_thres, \r\n               obstacle_mask=combined_obstacle_mask)\r\n```\r\n\r\n#### Obstacle Configuration Format\r\n\r\nThe obstacle configuration file is a JSON file with the following structure:\r\n\r\n```json\r\n{\r\n  \"obstacles\": [\r\n    {\r\n      \"type\": \"cube\",\r\n      \"center\": [0.5, 0.5, 0.2],  // x, y, z as fractions [0-1]\r\n      \"size\": 0.15                // single value for a cube\r\n    },\r\n    {\r\n      \"type\": \"sphere\",\r\n      \"center\": [0.25, 0.25, 0.6],\r\n      \"radius\": 0.1\r\n    },\r\n    {\r\n      \"type\": \"cylinder\",\r\n      \"center\": [0.75, 0.5, 0.5],\r\n      \"radius\": 0.08,\r\n      \"height\": 0.7,\r\n      \"axis\": 2                  // 0=x, 1=y, 2=z\r\n    },\r\n    {\r\n      \"type\": \"cube\",\r\n      \"center\": [0.25, 0.75, 0.5],\r\n      \"size\": [0.15, 0.05, 0.3]  // [x, y, z] for a cuboid\r\n    }\r\n  ]\r\n}\r\n```\r\n\r\nSupported obstacle types:\r\n- `cube`: A cube or cuboid. Use `size` as a single value for a cube, or as `[x, y, z]` for a cuboid.\r\n- `sphere`: A sphere. Use `radius` to set the size.\r\n- `cylinder`: A cylinder. Use `radius`, `height`, and `axis` (0=x, 1=y, 2=z) to configure.\r\n\r\nAll positions are specified as fractions [0-1] of the domain size, making it easy to reuse configurations across different mesh resolutions.\r\n\r\n### Design Space Customization\r\n\r\nPyTopo3D allows using STL files to define the design space geometry, enabling complex shapes beyond the standard rectangular domain.\r\n\r\n#### Command Line Usage\r\n\r\n```bash\r\npython main.py --design-space-stl path/to/design_space.stl --pitch 0.5\r\n```\r\n\r\nCommand line options:\r\n- `--design-space-stl`: Path to an STL file defining the design space geometry\r\n- `--pitch`: Distance between voxel centers when voxelizing STL (default: 1.0, smaller values create finer detail)\r\n- `--invert-design-space`: Flag to invert the design space (treat STL as void space rather than design space)\r\n\r\n#### Python API Usage\r\n\r\n```python\r\nfrom pytopo3d.preprocessing.geometry import load_geometry_data\r\nimport numpy as np\r\n\r\n# Load design space from STL\r\ndesign_space_mask, obstacle_mask, combined_obstacle_mask = load_geometry_data(\r\n    nelx=60, \r\n    nely=30, \r\n    nelz=20,\r\n    design_space_stl=\"path/to/design_space.stl\",\r\n    pitch=0.5,\r\n    invert_design_space=False\r\n)\r\n\r\n# The shape of the mask is determined by the STL geometry and pitch\r\nnely, nelx, nelz = design_space_mask.shape\r\nprint(f\"Resolution from voxelization: {nely}x{nelx}x{nelz}\")\r\n\r\n# Use the mask in optimization\r\nfrom pytopo3d.core.optimizer import top3d\r\n\r\nresult = top3d(\r\n    nelx=nelx, \r\n    nely=nely, \r\n    nelz=nelz, \r\n    volfrac=0.3, \r\n    penal=3.0, \r\n    rmin=3.0,\r\n    disp_thres=0.5,\r\n    obstacle_mask=combined_obstacle_mask\r\n)\r\n```\r\n\r\n#### Understanding Pitch and Resolution\r\n\r\nThe `pitch` parameter directly controls the resolution of the voxelized model:\r\n\r\n- Smaller pitch values create higher resolution voxelizations\r\n- The number of voxels along any dimension = physical length \u00f7 pitch\r\n- Choose pitch value based on the level of detail needed and computational resources available\r\n\r\n### Exporting Results\r\n\r\nYou can export the final optimization result as an STL file for 3D printing or further analysis in CAD software.\r\n\r\n#### Command Line Usage\r\n\r\n```bash\r\npython main.py --nelx 32 --nely 16 --nelz 16 \\\r\n               --volfrac 0.3 --penal 3.0 --rmin 3.0 \\\r\n               --export-stl \\\r\n               [--stl-level 0.5] \\\r\n               [--smooth-stl] \\\r\n               [--smooth-iterations 5]\r\n```\r\n\r\nOptions:\r\n- `--export-stl`: Flag to enable STL export of the final optimization result\r\n- `--stl-level`: Contour level for the marching cubes algorithm (default: 0.5)\r\n- `--smooth-stl`: Flag to apply Laplacian smoothing to the mesh (default: True)\r\n- `--smooth-iterations`: Number of iterations for mesh smoothing (default: 5)\r\n\r\n### Animation Generation\r\n\r\nPyTopo3D can generate animations of the optimization process.\r\n\r\n```bash\r\npython main.py --nelx 32 --nely 16 --nelz 16 \\\r\n               --create-animation \\\r\n               --animation-frequency 10 \\\r\n               --animation-frames 50 \\\r\n               --animation-fps 5\r\n```\r\n\r\nOptions:\r\n- `--create-animation`: Flag to enable animation generation\r\n- `--animation-frequency`: Store every N iterations for the animation (default: 10)\r\n- `--animation-frames`: Target number of frames in the final animation (default: 50)\r\n- `--animation-fps`: Frames per second in the generated animation (default: 5)\r\n\r\n### Experiment Management\r\n\r\nPyTopo3D includes a robust experiment management system that automatically:\r\n\r\n- Creates a uniquely named directory for each optimization run\r\n- Saves all relevant parameters, inputs, and outputs\r\n- Generates detailed logs of the optimization process\r\n- Records performance metrics and convergence data\r\n\r\n#### Command Line Options\r\n\r\n```bash\r\npython main.py --experiment-name custom_name \\\r\n               --description \"Detailed description of this experiment\" \\\r\n               --log-level DEBUG \\\r\n               --log-file custom_log.log \\\r\n               --verbose\r\n```\r\n\r\nOptions:\r\n- `--experiment-name`: Custom name for the experiment (optional, auto-generated if not provided)\r\n- `--description`: Description of the experiment stored in the results metadata\r\n- `--log-level`: Set logging detail level (DEBUG, INFO, WARNING, ERROR, CRITICAL)\r\n- `--log-file`: Path to a custom log file\r\n- `--verbose`: Enable more detailed output (sets log level to DEBUG)\r\n- `--quiet`: Reduce output verbosity (sets log level to WARNING)\r\n\r\n## Acknowledgements\r\n\r\nThis code is adapted from [Liu & Tovar's MATLAB code](https://www.top3d.app/) for 3D topology optimization.\r\n\r\n> K. Liu and A. Tovar, \"An efficient 3D topology optimization code written in Matlab\", Struct Multidisc Optim, 50(6): 1175-1196, 2014, doi:10.1007/s00158-014-1107-x\r\n\r\n## Citation\r\n\r\nIf you use PyTopo3D in your research or work, please cite our paper on ArXiv: [PyTopo3D: A Python Framework for 3D SIMP-based Topology Optimization](https://arxiv.org/abs/2504.05604)\r\n\r\n> Kim, J. & Kang, N. (2024). PyTopo3D: A Python Framework for 3D SIMP-based Topology Optimization. arXiv preprint arXiv:2504.05604.\r\n\r\n```bibtex\r\n@article{kim2025pytopo3d\r\n      title={PyTopo3D: A Python Framework for 3D SIMP-based Topology Optimization}, \r\n      author={Jihoon Kim and Namwoo Kang},\r\n      journal={arXiv preprint arXiv:2504.05604},\r\n      year={2025}\r\n}\r\n```\r\n\r\nThis paper provides a detailed explanation of the implementation, theoretical foundations, and optimizations used in PyTopo3D. Proper citation helps support the continued development of open-source scientific software.\r\n",
    "bugtrack_url": null,
    "license": "MIT",
    "summary": "3D SIMP Topology Optimization Framework for Python",
    "version": "0.1.0",
    "project_urls": {
        "Bug Tracker": "https://github.com/jihoonkim888/PyTopo3D/issues",
        "Documentation": "https://github.com/jihoonkim888/PyTopo3D",
        "Homepage": "https://github.com/jihoonkim888/PyTopo3D",
        "Source Code": "https://github.com/jihoonkim888/PyTopo3D"
    },
    "split_keywords": [
        "topology optimization",
        " simp",
        " structural optimization",
        " 3d",
        " finite element"
    ],
    "urls": [
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "454e2bcfccec54ba7e182f5b096f4d5e9eb8897ccfa3be494158fe4996db09d0",
                "md5": "5b0b12e83a6ceac67a9e50e8d544f9f0",
                "sha256": "a77d36b829e47e306a9c916b130846e9035149aeb3c4d570336bba39dc6eaf64"
            },
            "downloads": -1,
            "filename": "pytopo3d-0.1.0-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "5b0b12e83a6ceac67a9e50e8d544f9f0",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": ">=3.10",
            "size": 50867,
            "upload_time": "2025-04-09T02:08:16",
            "upload_time_iso_8601": "2025-04-09T02:08:16.397280Z",
            "url": "https://files.pythonhosted.org/packages/45/4e/2bcfccec54ba7e182f5b096f4d5e9eb8897ccfa3be494158fe4996db09d0/pytopo3d-0.1.0-py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "96fe99996aaa7eadbb825e0094167b5b0c3e21b8a8f01bfff5711003d3c0b57d",
                "md5": "49922fa6eb04933af96f0a843416486e",
                "sha256": "70727519e05ade8d5167ed6fd8e1cdd99882a793948505e04212492547c7c0d2"
            },
            "downloads": -1,
            "filename": "pytopo3d-0.1.0.tar.gz",
            "has_sig": false,
            "md5_digest": "49922fa6eb04933af96f0a843416486e",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": ">=3.10",
            "size": 41121,
            "upload_time": "2025-04-09T02:08:18",
            "upload_time_iso_8601": "2025-04-09T02:08:18.125771Z",
            "url": "https://files.pythonhosted.org/packages/96/fe/99996aaa7eadbb825e0094167b5b0c3e21b8a8f01bfff5711003d3c0b57d/pytopo3d-0.1.0.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2025-04-09 02:08:18",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "codeberg": false,
    "github_user": "jihoonkim888",
    "github_project": "PyTopo3D",
    "travis_ci": false,
    "coveralls": false,
    "github_actions": false,
    "lcname": "pytopo3d"
}
        
Elapsed time: 0.55248s