docs: creating a NACA airfoil example (#1167)

Co-authored-by: pyansys-ci-bot <pyansys.github.bot@ansys.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Kathy Pippert <84872299+PipKat@users.noreply.github.com>

Author: 4 people

doc/changelog.d/1167.miscellaneous.md

@@ -0,0 +1 @@
+docs: creating a NACA airfoil example

doc/source/_static/thumbnails/naca_airfoils.png

@@ -276,6 +276,7 @@ def intersphinx_pyansys_geometry(switcher_version: str):
     "examples/03_modeling/scale_map_mirror_bodies": "_static/thumbnails/scale_map_mirror_bodies.png",  # noqa: E501
     "examples/03_modeling/sweep_chain_profile": "_static/thumbnails/sweep_chain_profile.png",
     "examples/03_modeling/export_design": "_static/thumbnails/export_design.png",
+    "examples/04_applied/01_naca_airfoils": "_static/thumbnails/naca_airfoils.png",
 }
 nbsphinx_epilog = """
 ----

doc/source/conf.py

@@ -41,3 +41,13 @@ These examples demonstrate service-based modeling operations.
     examples/03_modeling/scale_map_mirror_bodies.mystnb
     examples/03_modeling/sweep_chain_profile.mystnb
     examples/03_modeling/export_design.mystnb
+
+Applied examples
+----------------
+
+These examples demonstrate the usage of PyAnsys Geometry for real-world
+applications.
+
+.. nbgallery::
+
+    examples/04_applied/01_naca_airfoils.mystnb

doc/source/examples.rst

@@ -74,6 +74,7 @@ material = Material(
 material.add_property(MaterialPropertyType.TENSILE_STRENGTH, "TensileProp", Quantity(45))
 design.add_material(material)
 ```
+
 ## Extrude sketch to create body
 
 Extrude the sketch to create the body and then assign a material to it.

doc/source/examples/03_modeling/add_design_material.mystnb

@@ -0,0 +1 @@
+*.fmd

doc/source/examples/04_applied/.gitignore

@@ -0,0 +1,252 @@
+---
+jupytext:
+  text_representation:
+    extension: .mystnb
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.14.1
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+# Applied: Create a NACA 4-digit airfoil
+
+NACA airfoils are a series of airfoil shapes for aircraft wings developed by
+the National Advisory Committee for Aeronautics (NACA). They are a standardized
+system of airfoil shapes that are defined by a series of digits. The digits,
+which indicate the shape of the airfoil, are used to create the airfoil shape.
+
+Each digit in the NACA airfoil number has a specific meaning:
+
+- The first digit defines the maximum camber as a percentage of the chord length.
+- The second digit defines the position of the maximum camber as a percentage of the chord length.
+- The last two digits define the maximum thickness of the airfoil as a percentage of the chord length.
+
+To fully understand the previous definitions, it is important to know that the chord length
+is the length of the airfoil from the leading edge to the trailing edge. The camber is the
+curvature of the airfoil, and the thickness is the distance between the upper and lower surfaces.
+
+Symmetric airfoils have a camber of 0% and consequently, the first two digits of the NACA number
+are 0. For example, the NACA 0012 airfoil is a symmetric airfoil with a maximum thickness of 12%.
+
+## Define the NACA 4-digit airfoil equation
+
+The following code uses the equation for a NACA 4-digit airfoil to create
+a set of points that define the airfoil shape. These points are ``Point2D`` objects
+in PyAnsys Geometry.
+
+```{code-cell} ipython3
+from typing import List, Union
+
+import numpy as np
+
+from ansys.geometry.core.math import Point2D
+
+def naca_airfoil_4digits(number: Union[int, str], n_points: int = 200) -> List[Point2D]:
+    """
+    Generate a NACA 4-digits airfoil.
+
+    Parameters
+    ----------
+    number : int or str
+        NACA 4-digit number.
+    n_points : int
+        Number of points to generate the airfoil. The default is ``200``.
+        Number of points in the upper side of the airfoil.
+        The total number of points is ``2 * n_points - 1``.
+
+    Returns
+    -------
+    List[Point2D]
+        List of points that define the airfoil.
+    """
+    # Check if the number is a string
+    if isinstance(number, str):
+        number = int(number)
+
+    # Calculate the NACA parameters
+    m = number // 1000 * 0.01
+    p = number // 100 % 10 * 0.1
+    t = number % 100 * 0.01
+
+    # Generate the airfoil
+    points = []
+    for i in range(n_points):
+
+        # Make it a exponential distribution so the points are more concentrated
+        # near the leading edge
+        x = (1 - np.cos(i / (n_points - 1) * np.pi)) / 2
+
+        # Check if it is a symmetric airfoil or not
+        if p == 0 and m == 0:
+            # Camber line is zero in this case
+            yc = 0
+            dyc_dx = 0
+        else:
+            # Compute the camber line
+            if x < p:
+                yc = m / p**2 * (2 * p * x - x**2)
+                dyc_dx = 2 * m / p**2 * (p - x)
+            else:
+                yc = m / (1 - p) ** 2 * ((1 - 2 * p) + 2 * p * x - x**2)
+                dyc_dx = 2 * m / (1 - p) ** 2 * (p - x)
+
+        # Compute the thickness
+        yt = 5 * t * (0.2969 * x**0.5
+                      - 0.1260 * x
+                      - 0.3516 * x**2
+                      + 0.2843 * x**3
+                      - 0.1015 * x**4)
+
+        # Compute the angle
+        theta = np.arctan(dyc_dx)
+
+        # Compute the points (upper and lower side of the airfoil)
+        xu = x - yt * np.sin(theta)
+        yu = yc + yt * np.cos(theta)
+        xl = x + yt * np.sin(theta)
+        yl = yc - yt * np.cos(theta)
+
+        # Append the points
+        points.append(Point2D([xu, yu]))
+        points.insert(0, Point2D([xl, yl]))
+
+        # Remove the first point since it is repeated
+        if i == 0:
+            points.pop(0)
+
+    return points
+
+```
+
+## Example of a symmetric airfoil: NACA 0012
+
+Now that the function for generating a NACA 4-digit airfoil is generated, this code creates a NACA 0012
+airfoil, which is symmetric. This airfoil has a maximum thickness of 12%. The NACA number is a constant.
+
+```{code-cell} ipython3
+NACA_AIRFOIL = "0012"
+```
+
+### Required imports
+
+Before you start creating the airfoil points, you must import the necessary modules to create the
+airfoil using PyAnsys Geometry.
+
+```{code-cell} ipython3
+from ansys.geometry.core import launch_modeler
+from ansys.geometry.core.sketch import Sketch
+```
+
+### Generate the airfoil points
+
+Using the function defined previously, you generate the points that define the NACA 0012 airfoil.
+Create a ``Sketch`` object and add the points to it. Then, approximate the airfoil using
+straight lines between the points.
+
+```{code-cell} ipython3
+# Create a sketch
+sketch = Sketch()
+
+# Generate the points of the airfoil
+points = naca_airfoil_4digits(NACA_AIRFOIL)
+
+# Create the segments of the airfoil
+for i in range(len(points) - 1):
+    sketch.segment(points[i], points[i + 1])
+
+# Close the airfoil
+sketch.segment(points[-1], points[0])
+
+# Plot the airfoil
+sketch.plot()
+```
+
+### Create the 3D airfoil
+
+Once the ``Sketch`` object is created, you create a 3D airfoil. For this operation, you must create
+a modeler object, create a design object, and extrude the sketch.
+
+```{code-cell} ipython3
+# Launch the modeler
+modeler = launch_modeler()
+
+# Create the design
+design = modeler.create_design(f"NACA_Airfoil_{NACA_AIRFOIL}")
+
+# Extrude the airfoil
+design.extrude_sketch("Airfoil", sketch, 1)
+
+# Plot the design
+design.plot()
+```
+
+### Save the design
+
+Finally, save the design to a file. This file can be used in other applications or imported
+into a simulation software. This code saves the design as an FMD file, which can then be imported
+into Ansys Fluent.
+
+```{code-cell} ipython3
+# Save the design
+file = design.export_to_fmd()
+print(f"Design saved to {file}")
+```
+
+## Example of a cambered airfoil: NACA 6412
+
+This code creates a NACA 6412 airfoil, which is cambered. This airfoil has a maximum
+camber of 6% and a maximum thickness of 12%. After overriding the NACA number, the code generates the
+airfoil points.
+
+```{code-cell} ipython3
+NACA_AIRFOIL = "6412"
+```
+
+### Generate the airfoil points
+
+As before, you generate the points that define the NACA 6412 airfoil. Create a
+``Sketch`` object and add the points to it. Then, approximate the airfoil using straight lines.
+
+```{code-cell} ipython3
+# Create a sketch
+sketch = Sketch()
+
+# Generate the points of the airfoil
+points = naca_airfoil_4digits(NACA_AIRFOIL)
+
+# Create the segments of the airfoil
+for i in range(len(points) - 1):
+    sketch.segment(points[i], points[i + 1])
+
+# Close the airfoil
+sketch.segment(points[-1], points[0])
+
+# Plot the airfoil
+sketch.plot()
+```
+
+### Create the 3D airfoil
+
+```{code-cell} ipython3
+# Launch the modeler
+modeler = launch_modeler()
+
+# Create the design
+design = modeler.create_design(f"NACA_Airfoil_{NACA_AIRFOIL}")
+
+# Extrude the airfoil
+design.extrude_sketch("Airfoil", sketch, 1)
+
+# Plot the design
+design.plot()
+```
+
+### Save the design
+
+```{code-cell} ipython3
+# Save the design
+file = design.export_to_fmd()
+print(f"Design saved to {file}")
+```