ToPy

https://github.com/williamhunter/topy
Admin
ToPy is a lightweight topology optimization framework for Python that can solve compliance...
Tokens:7,093
Snippets:40
Trust Score:6.8
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install ToPy using setup.py (Bash)

Source: https://github.com/williamhunter/topy/blob/master/README.md

Installs the ToPy library by navigating to its directory and running the setup script. This is part of the manual installation process after downloading dependencies and the stable release.

```bash
cd topy/topy
python setup.py install
```

--------------------------------

### Pip Package Installation (Windows)

Source: https://github.com/williamhunter/topy/blob/master/INSTALL.md

Example command for installing Python packages using pip on Windows. Ensure pip is added to your PATH and run the command prompt as Administrator.

```shell
pip install <package>
```

--------------------------------

### Install ToPy Project

Source: https://github.com/williamhunter/topy/blob/master/INSTALL.md

Commands to install the ToPy project from its source directory. It supports both system-wide and user-local installations.

```shell
python setup.py install

```

```shell
python setup.py install --user
```

--------------------------------

### Run ToPy Optimise Script

Source: https://github.com/williamhunter/topy/blob/master/examples/README.md

Execute the 'optimise.py' script from the 'scripts' directory by providing a TPD filename as an argument. Ensure the script is in the same directory as the TPD file or accessible via your system's PATH.

```shell
python optimise.py <filename>.tpd
```

--------------------------------

### Create GIF Animation from PNGs using ImageMagick

Source: https://github.com/williamhunter/topy/blob/master/examples/README.md

Convert a sequence of PNG images into an animated GIF using the 'convert' command from ImageMagick. The '-delay' option controls the time between frames. Ensure all PNG files are in the current directory.

```shell
convert -delay 35 *.png anim.gif
```

--------------------------------

### Run Optimization from Command Line (Bash)

Source: https://github.com/williamhunter/topy/blob/master/README.md

Executes the ToPy optimization process using a specified .tpd file directly from the command line. This is a convenient way to start the optimization without writing a separate Python script.

```bash
python topy/scripts/optimise.py <filename>.tpd
```

--------------------------------

### Define Problem with Config Dictionary (Python)

Source: https://github.com/williamhunter/topy/blob/master/README.md

Creates a ToPy Topology object initialized with a Python dictionary that defines the optimization problem parameters. This method allows for dynamic problem setup within Python scripts.

```python
config = {
     'DOF_PN': 2,
     'ELEM_K': 'Q4',
     'ETA': '0.5',
     'FILT_RAD': 1.5,
     'FXTR_NODE_X': range(1, 22),
     'FXTR_NODE_Y': 1281,
     'LOAD_NODE_Y': 1,
     'LOAD_VALU_Y': -1,
     'NUM_ELEM_X': 60,
     'NUM_ELEM_Y': 20,
     'NUM_ELEM_Z': 0,
     'NUM_ITER': 94,
     'PROB_NAME': 'beam_2d_reci',
     'PROB_TYPE': 'comp',
     'P_FAC': 3.0,
     'VOL_FRAC': 0.5
}
topology = Topology(config=config)
```

--------------------------------

### ToPy Problem Definition (TPD) File Parsing

Source: https://github.com/williamhunter/topy/wiki/Tutorials

This output details the successful parsing of a ToPy problem definition (TPD) file. It shows the configuration parameters used for the optimization, such as domain discretization, element type, filter radius, number of iterations, and problem type. This information is crucial for understanding the setup of the optimization problem.

```text
===============================================================================
ToPy problem definition (TPD) file successfully parsed.
TPD file name: tut1_2d.tpd (v2007)
-------------------------------------------------------------------------------
Domain discretisation (NUM_ELEM_X x NUM_ELEM_Y) = 30 x 30
Element type (ELEM_K) = Q4
Filter radius (FILT_RAD) = 1.5
Number of iterations (NUM_ITER) = 30
Problem type (PROB_TYPE) = comp
Problem name (PROB_NAME) = tut1_2d
Continuation of penalisation factor (P_FAC) not specified
GSF active
Damping factor (ETA) = 0.50
No passive elements (PASV_ELEM) specified
No active elements (ACTV_ELEM) specified
===============================================================================
```

--------------------------------

### Check Python Architecture

Source: https://github.com/williamhunter/topy/blob/master/INSTALL.md

This Python snippet helps determine the architecture of the installed Python version. It's useful for verifying compatibility with dependencies.

```python
import platform
platform.architecture()
```

--------------------------------

### TDP Penalty Factor (p) Parameters

Source: https://github.com/williamhunter/topy/wiki/Help

Shows the configuration of penalty factor 'p' parameters, including starting value (P_FAC), maximum value (P_MAX), increment (P_INCR), and constancy period (P_CON).

```tpd
P_FAC : 3
P_MAX : 3.5
P_INCR: 0.02
P_CON : 25
```

--------------------------------

### Define 2D MBB Beam with GSF (TPD File)

Source: https://github.com/williamhunter/topy/wiki/Examples-of-ToPy-results

This TPD file configures a 2D MBB beam compliance problem incorporating Grey-Scale Filtering (GSF). It includes standard problem definitions along with parameters specific to GSF, such as P_HOLD, P_INCR, P_CON, P_MAX, Q_HOLD, Q_INCR, Q_CON, and Q_MAX, to refine the solution quality.

```topy
[ToPy Problem Definition File v2007]

# Author: William Hunter
# The 'classic' 60x20 2d mbb beam, as per Ole Sigmund's 99 line code, but with
# grey-scale filtering.

PROB_TYPE  : comp
PROB_NAME  : beam_2d_reci_gsf
ETA        : 0.5  # reciprocal approx.
DOF_PN     : 2
VOL_FRAC   : 0.5
FILT_RAD   : 1.5
ELEM_K     : Q4
NUM_ELEM_X : 60
NUM_ELEM_Y : 20
NUM_ELEM_Z : 0
FXTR_NODE_X: 1|21
FXTR_NODE_Y: 1281
LOAD_NODE_Y: 1
LOAD_VALU_Y: -1

NUM_ITER   : 100

# Grey-scale filter (GSF)
P_FAC      : 1
P_HOLD     : 25  # num of iters to hold p constant from start
P_INCR     : 0.2  # increment by this amount
P_CON      : 1  # increment every 'P_CON' iters
P_MAX      : 3  # max value of 'P_CON'

Q_FAC      : 1
Q_HOLD     : 25  # num of iters to hold q constant from start
Q_INCR     : 0.05  # increment by this amount
Q_CON      : 1  # increment every 'Q_CON' iters
Q_MAX      : 5  # max value of 'Q_CON'

```

--------------------------------

### Define 2D MBB Beam Problem (TPD File)

Source: https://github.com/williamhunter/topy/wiki/Examples-of-ToPy-results

This TPD file defines a standard 2D MBB beam compliance problem. It specifies problem type, dimensions, material properties, boundary conditions (fixed nodes), and loading. Key parameters include volume fraction, filter radius, and number of iterations.

```topy
[ToPy Problem Definition File v2007]

# Author: William Hunter
# The 'classic' 60x20 2d MBB beam, as per Ole Sigmund's 99 line code.

PROB_TYPE  : comp         # compliance (stiffness) problem
PROB_NAME  : beam_2d_reci # output files will have this name
ETA        : 0.5          # reciprocal approximation
DOF_PN     : 2            # degrees of freedom per node
VOL_FRAC   : 0.5          # volume fraction, so we want only 50% of the area to be used for structure
FILT_RAD   : 1.5          # how 'thick' we want regions
ELEM_K     : Q4           # element type, for 2d almost always a linear 4 node element
NUM_ELEM_X : 60           # number of elements in the x direction, which is equal to your dimension in x
NUM_ELEM_Y : 20           # number of elements in the y direction, which is equal to your dimension in y
NUM_ELEM_Z : 0            # because it's a 2d problem
FXTR_NODE_X: 1|21         # fix translation of these node numbers in x direction
FXTR_NODE_Y: 1281         # fix translation of this node number in y direction
LOAD_NODE_Y: 1            # load this node number in y direction
LOAD_VALU_Y: -1           # the sign and size of the load in the y direction, for this problem it won't make a difference

NUM_ITER   : 94           # number of iterations to run, generally around 50 is enough, depending on the problem

P_FAC      : 3            # penalty factor; sort of how aggressive to get rid of elements (material)

```

--------------------------------

### TDP Grey-Scale Filtering (GSF) Penalty Factor (q) Parameters

Source: https://github.com/williamhunter/topy/wiki/Help

Demonstrates the configuration of the extra penalty factor 'q' for Grey-Scale Filtering (GSF), including its starting value (Q_FAC), maximum value (Q_MAX), increment (Q_INCR), and constancy period (Q_CON).

```tpd
Q_FAC : 1
Q_MAX : 5
Q_INCR: 0.08
Q_CON : 20
```

--------------------------------

### Load TPD file with ToPy (Python)

Source: https://github.com/williamhunter/topy/blob/master/README.md

Initializes the ToPy Topology class and loads problem definitions from a specified .tpd file. This is the standard method for setting up an optimization problem using a text-based definition file.

```python
from topy import Topology

topology = Topology()
topology.load_tpd_file('file.tpd')
```

--------------------------------

### Running ToPy Optimization Script

Source: https://github.com/williamhunter/topy/wiki/Tutorials

Command to execute the ToPy optimization script. This command takes the TPD file as an argument and runs the optimization process. Ensure you are in the directory containing both the script and the TPD file.

```bash
python optimise.py tut1_2d.tpd
```

--------------------------------

### Create Animation from PNGs using ImageMagick

Source: https://github.com/williamhunter/topy/wiki/Tutorials

This command uses ImageMagick's 'convert' tool to create a GIF animation from a series of PNG images. The '-delay' option sets the time between frames, and '*.png' selects all PNG files in the current directory. The output is a single GIF file named 'tut1_2d.gif'.

```bash
convert -delay 30 *.png tut1_2d.gif
```

--------------------------------

### Configure Heat Conduction Specific Settings

Source: https://github.com/williamhunter/topy/wiki/Help

Sets parameters specific to heat conduction analysis. Emphasizes using only *_X keywords as heat problems are one-dimensional in terms of degrees of freedom. Includes settings for element type and degrees of freedom per node.

```text
NUM_ELEM_Z : 0

DOF_PN  : 1
ELEM_K  : Q4T
```

--------------------------------

### ToPy TPD File Structure and Parameters

Source: https://github.com/williamhunter/topy/wiki/Tutorials

Defines the structure and parameters for a ToPy Problem Definition File (.tpd). This file specifies all settings for a structural optimization problem, including mesh, loads, constraints, and solver parameters. Comments can be added after a hash symbol.

```plaintext
[ToPy Problem Definition File v2007]

PROB_NAME: tut1_2d

PROB_TYPE: comp # you can add comments after a hash

NUM_ELEM_X: 30
NUM_ELEM_Y: 30
NUM_ELEM_Z: 0 # set to zero for 2d problems

VOL_FRAC: 0.444 # 20*20/30*30

LOAD_NODE_X: 1 # load node number 1 ... 
LOAD_VALU_X: 1 # in the positive X-direction
LOAD_NODE_Y: 951 # load node number 951...
LOAD_VALU_Y: -1 # in the negative Y-direction

FXTR_NODE_X: 651 # this is the only node that is fixed in the X-direction
FXTR_NODE_Y: 31; 651 # these nodes are fixed in the Y-direction

ELEM_K: Q4 # element type (stiffness matrix) for 2d compliance problems
DOF_PN: 2 # degrees of freedom per node, 2 for 2d compliance problems

# Optimisation parameters:
# If you just want a quick answer, use the below values
ETA: 0.5 # 0.4 for 3d
FILT_RAD: 1.5 # 1.8 for 3d
P_FAC: 3 # up to 3.5
Q_FAC: 2.5 # extra penalty factor (grey-scale filter)
NUM_ITER: 30 # stop after 30 iterations
```

--------------------------------

### TDP Problem Name and Basic Parameters

Source: https://github.com/williamhunter/topy/wiki/Help

Demonstrates the usage of PROB_NAME for output file naming and basic parameters like VOL_FRAC (volume fraction) and FILT_RAD (filter radius).

```tpd
PROB_NAME: really_cool_problem
VOL_FRAC: 0.5
FILT_RAD: 1.5
```

--------------------------------

### ToPy Optimization Iteration Log

Source: https://github.com/williamhunter/topy/wiki/Tutorials

This log displays the progress of the ToPy optimization process over several iterations. It includes key metrics such as the iteration number, objective function value, volume, change in objective function, penalization factor, and solid-void fraction. This data is used to monitor the convergence of the optimization.

```text
Iter | Obj. func.   | Vol.  | Change     | P_FAC | Q_FAC | Ave ETA | S-V frac.
-------------------------------------------------------------------------------
   1  | 8.358387e+02 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.000
   2  | 3.697232e+02 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.000
   3  | 1.879175e+02 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.454
   4  | 1.241993e+02 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.620
   5  | 1.067986e+02 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.780
   6  | 1.006967e+02 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.853
   7  | 9.836660e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.900
   8  | 9.711562e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.933
   9  | 9.653572e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.959
  10  | 9.628151e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.968
  11  | 9.612210e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.974
  12  | 9.596980e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.980
  13  | 9.584600e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.981
  14  | 9.577452e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.981
  15  | 9.573832e+01 | 0.444 | 6.1204e-02 | 3.000 | 2.500 |  0.500  |  0.989
  16  | 9.572545e+01 | 0.444 | 9.3079e-02 | 3.000 | 2.500 |  0.500  |  0.989
  17  | 9.572103e+01 | 0.444 | 1.4164e-01 | 3.000 | 2.500 |  0.500  |  0.990
  18  | 9.572643e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.992
  19  | 9.574836e+01 | 0.444 | 2.0000e-01 | 3.000 | 2.500 |  0.500  |  0.991
  20  | 9.578061e+01 | 0.444 | 5.0250e-02 | 3.000 | 2.500 |  0.500  |  0.994
  21  | 9.579138e+01 | 0.444 | 5.3160e-02 | 3.000 | 2.500 |  0.500  |  0.997
  22  | 9.579561e+01 | 0.444 | 5.9350e-02 | 3.000 | 2.500 |  0.500  |  0.997
  23  | 9.580103e+01 | 0.444 | 7.5427e-02 | 3.000 | 2.500 |  0.500  |  0.997
  24  | 9.580654e+01 | 0.444 | 7.7182e-02 | 3.000 | 2.500 |  0.500  |  0.998
  25  | 9.580686e+01 | 0.444 | 8.9910e-02 | 3.000 | 2.500 |  0.500  |  0.998
  26  | 9.580255e+01 | 0.444 | 9.1640e-02 | 3.000 | 2.500 |  0.500  |  0.998
  27  | 9.579435e+01 | 0.444 | 5.3421e-02 | 3.000 | 2.500 |  0.500  |  0.999
  28  | 9.578835e+01 | 0.444 | 8.7270e-10 | 3.000 | 2.500 |  0.500  |  0.999
  29  | 9.578835e+01 | 0.444 | 1.6454e-09 | 3.000 | 2.500 |  0.500  |  0.999
  30  | 9.578835e+01 | 0.444 | 6.6716e-10 | 3.000 | 2.500 |  0.500  |  0.999
```

--------------------------------

### Run Optimization using Python Script (Python)

Source: https://github.com/williamhunter/topy/blob/master/README.md

Performs the ToPy optimization within a Python script. It involves creating a Topology object (either from a config or TPD file), setting parameters, and calling the optimize function.

```python
import topy

config = {...}
t = topy.Topology(config)
t.set_top_params()
topy.optimise(t)
```

--------------------------------

### TDP Iteration Control Parameters

Source: https://github.com/williamhunter/topy/wiki/Help

Illustrates how to control the number of iterations using NUM_ITER or the convergence criteria using CHG_STOP.

```tpd
NUM_ITER: 100
CHG_STOP: 0.01
```

--------------------------------

### TDP File Format Header and Comments

Source: https://github.com/williamhunter/topy/wiki/Help

Illustrates the required header for a ToPy Input File and demonstrates how to include comments within the TDP file. Comments can be placed after a hash symbol.

```tpd
[ToPy Input File v2007]

# This is a full line comment
PROB_NAME: my_problem # This is an in-line comment
```

--------------------------------

### TDP Approximation Type and Damping Factor

Source: https://github.com/williamhunter/topy/wiki/Help

Shows how to specify the approximation type (ETA, APPROX) and its associated damping factor. Different ETA values are used for different approximation types.

```tpd
ETA   : 0.5     # Use for reciprocal approximation.
APPROX: reciprocal

ETA   : exp     # Use for exponential approximation.
APPROX: exp

ETA   : 0.1     # Must be specified for diagonal quadratic approximation.
APPROX: dquad
```

--------------------------------

### TDP Element Constraints: Passive and Active Elements

Source: https://github.com/williamhunter/topy/wiki/Help

Demonstrates how to enforce elements to be passive (void) or active (solid) using PASV_ELEM and ACTV_ELEM keywords, respectively. Multiple element numbers can be specified.

```tpd
PASV_ELEM: 10 20 30
ACTV_ELEM: 5 15
```

--------------------------------

### Create 2D Mesh with ToPy

Source: https://github.com/williamhunter/topy/wiki/Tutorials

Generates a 2D mesh file (.msh) for use with Gmsh. This function defines the dimensions of the domain and the output filename. The created mesh is essential for defining loads and boundary conditions in subsequent topology optimization steps.

```python
create_2d_msh(30, 30, 'tut1')
```

--------------------------------

### TDP Boundary Condition: Fixed Nodes

Source: https://github.com/williamhunter/topy/wiki/Help

Illustrates how to specify nodes where translation is fixed in X, Y, or Z directions using FXTR_NODE_X, FXTR_NODE_Y, and FXTR_NODE_Z keywords. Multiple node numbers can be provided.

```tpd
FXTR_NODE_X: 1 5 10
FXTR_NODE_Y: 2 6
FXTR_NODE_Z: 3
```

--------------------------------

### Topy Problem Definition File (TPD) Structure

Source: https://github.com/williamhunter/topy/wiki/Tutorials

Defines the parameters for a 2D compliance optimization problem. This includes mesh dimensions, volume fraction, load conditions, fixed nodes, element type, and optimization parameters for grey-scale filtering.

```ini
[ToPy Problem Definition File v2007]

PROB_NAME: tut3_2d

PROB_TYPE: comp # you can add comments after a hash

NUM_ELEM_X: 120
NUM_ELEM_Y: 120
NUM_ELEM_Z: 0 # set to zero for 2d problems

VOL_FRAC: 0.444 # 4/9

LOAD_NODE_X: 1 # load node number 1 ...
LOAD_VALU_X: 1 # in the positive X-direction
LOAD_NODE_Y: 14601 # load node number 14601...
LOAD_VALU_Y: -1 # in the negative Y-direction

FXTR_NODE_X: 121; 9801 # these nodes are fixed in the X-direction
FXTR_NODE_Y: 121; 9801 # these nodes are fixed in the Y-direction

ELEM_K: Q4 # element type (stiffness matrix) for 2d compliance problems
DOF_PN: 2 # degrees of freedom per node, 2 for 2d compliance problems

# Optimisation parameters:
# If you just want a quick answer, use the below values
ETA: 0.5 # 0.4 for 3d
FILT_RAD: 6 # 1.8 for 3d
CHG_STOP: 0.001 # stop when objective function changes less than this

# Grey-scale filter (GSF)
P_FAC      : 1
P_HOLD     : 5  # num of iters to hold p constant from start
P_INCR     : 0.25  # increment by this amount
P_CON      : 1  # increment every 'P_CON' iters
P_MAX      : 3  # max value of 'P_CON'

Q_FAC      : 1
Q_HOLD     : 10  # num of iters to hold q constant from start
Q_INCR     : 0.5  # increment by this amount
Q_CON      : 5  # increment every 'Q_CON' iters
Q_MAX      : 5  # max value of 'Q_CON'
```

--------------------------------

### Define Loads on Nodes

Source: https://github.com/williamhunter/topy/wiki/Help

Specifies loads to be applied to nodes, including the node selection, load value, and direction. Supports node ranges and multiple nodes separated by semicolons. Load values can be specified directly or using '@' for replication.

```text
LOAD_NODE_X: 1; 4; 9 # Load nodes 1, 4 and 9 in X direction.
LOAD_NODE_Y: 1       # Upper left corner -- node number = 1 (always), Y direction.
LOAD_NODE_Z: 20|32|3 # Load node 20 to 32 in steps of 3, in Z direction.
LOAD_VALU_X: 0.75    # Simply omit a line if not necessary for your problem.
LOAD_VALU_Y: -1      # Value of the load = 1, direction negative Y.
LOAD_VALU_Z: 1@10    # Value of the load = 1 at 10 nodes in Z direction.
```

--------------------------------

### Define Output Requirements for Mechanism Design

Source: https://github.com/williamhunter/topy/wiki/Help

Specifies the node(s) and the corresponding load value required for output during mechanism design (synthesis). This is used to extract specific performance metrics.

```text
LOAD_NODE_X_OUT: 841 # Node number(s) at which you require the output
LOAD_VALU_X_OUT: -1 # Value of output at specified OUT node.
```

--------------------------------

### Modify ToPy Problem Parameters for Tutorial 2

Source: https://github.com/williamhunter/topy/wiki/Tutorials

This snippet shows how to modify parameters in a ToPy problem definition file to run Tutorial 2. It involves changing the problem name and fixing nodes in the X-direction. It also demonstrates replacing the fixed iteration count with a change-based stopping condition.

```text
PROB_NAME: tut2_2d
FXTR_NODE_X: 31; 651 # these nodes are fixed in the X-direction

# Delete
NUM_ITER: 30 # stop after 30 iterations

# Replace with
CHG_STOP: 0.001 # stop when objective function changes less than this
```

--------------------------------

### Define 2D and 3D Finite Element Types

Source: https://github.com/williamhunter/topy/wiki/Help

Specifies the types of finite elements supported for 2D and 3D analyses. Includes common element notations like Q4 for 2D and H8 for 3D, along with variations.

```text
2D: Y             3D: Y
    |                 |
  4-|-3             4-|-3
  | +-|---X        /| +-|---X
  1---2           / 1/--2
                 8--/7 /
                 | / |/
                 5/--6
                 /
                Z

ELEM_K: Q4 # Other 2D: Q5B, Q4a5B, Q4T.   3D: H8, H18B, H8T.
```

--------------------------------

### Discretize Design Domain for 2D and 3D

Source: https://github.com/williamhunter/topy/wiki/Help

Defines the discretization of the design domain in 2D and 3D space by specifying the number of elements along each axis. The numbering scheme for nodes and elements is also illustrated.

```text
2D: Y             3D: Y
    |                 |
    +---X             +---X
                     /
                    Z

 1---5---9
 | 1 | 5 |
 2---6---10
 | 2 | 6 |
 3---7---11
 | 3 | 7 |
 4---8---12

NUM_ELEM_X: 60 # Number (quantity) of elements in the X-direction.
NUM_ELEM_Y: 20 # Number of elements in the (negative) Y-direction.

Set the following keyword to 0 if not necessary for your problem, i.e., 2D:
NUM_ELEM_Z: 10
```

--------------------------------

### TDP Boundary Condition: Applied Loads

Source: https://github.com/williamhunter/topy/wiki/Help

Shows how to define applied loads at specific nodes. This involves specifying the node numbers (LOAD_NODE_X/Y/Z) and their corresponding values (LOAD_VALU_X/Y/Z).

```tpd
LOAD_NODE_X: 10
LOAD_VALU_X: -1.0

LOAD_NODE_Y: 5 15
LOAD_VALU_Y: [0.5, 0.8]
```

--------------------------------

### TDP Mechanism Synthesis Output Definitions

Source: https://github.com/williamhunter/topy/wiki/Help

Defines keywords for specifying output requirements in mechanism synthesis problems. This includes nodes for output (LOAD_NODE_X/Y/Z_OUT) and the corresponding output values (LOAD_VALU_X/Y/Z_OUT).

```tpd
LOAD_NODE_X_OUT: 50
LOAD_VALU_X_OUT: 1.0

LOAD_NODE_Y_OUT: 60 70
LOAD_VALU_Y_OUT: [0.2, -0.3]
```

--------------------------------

### TDP Problem Type Specification

Source: https://github.com/williamhunter/topy/wiki/Help

Shows how to specify the type of problem to be solved using the PROB_TYPE keyword. The case of the keyword and its value is ignored.

```tpd
PROB_TYPE: comp # Solve a minimum compliance problem.

# Other options are 'heat' or 'mech'.
```

--------------------------------

### Create 2D Mesh using Topy

Source: https://github.com/williamhunter/topy/wiki/Tutorials

Generates a 2D mesh file for use with Gmsh. This function allows for the creation of meshes with specified dimensions, which is useful for visualizing element and node numbers in complex analyses.

```python
import topy
topy.create_2d_msh(120, 120, 'tut3_2d')
```

--------------------------------

### Apply Translational Constraints to Nodes

Source: https://github.com/williamhunter/topy/wiki/Help

Sets translational constraints (fixed degrees of freedom) for nodes. Supports node number ranges using 'start|stop|step' notation and multiple ranges separated by semicolons. Constraints can be applied in X, Y, or Z directions.

```text
FXTR_NODE_X = FiX TRanslation of NODE in the X direction

    FXTR_NODE_X: 1|21               # Node 1 to 21, step size 1 is implied.
    FXTR_NODE_Y: 1281               # Lower right corner for 60x20 problem
    FXTR_NODE_Z: 1; 4|13|3; 18|22|2 # Nodes 1, 4, 7, 10, 13, 18, 20, 22.
```

--------------------------------

### Specify Passive and Active Elements

Source: https://github.com/williamhunter/topy/wiki/Help

Defines which elements are considered passive (void) or active (solid) within the design domain. Element numbers can be specified as ranges or individual numbers, separated by semicolons.

```text
PASV_ELEM: 10|19; 30|39; 50|59; 70|79; 90|99 # No elements will appear at these locations (void)
ACTV_ELEM: 1|1181|20; 1181|1200 # These elements will remain (solid)
```
Tokens:
Raw