Tutorial: Cubit+Sierra

Warning

Most WAVES tutorials are used as system tests in the regression test suite to ensure that the tutorial files are up-to-date and functional. The sierra local submission without sbatch is part of the regression suite, but the sbatch submission behavior is not. If you run into problems running this tutorial, please contact the WAVES development team.

Note

Depending on your Cubit installation and operating system, it may not be possible to import Cubit into arbitrary Python 3 environments. Instead, it may be necessary to execute Cubit Python scripts using the Python interpreter bundled with Cubit. An alternate Cubit tutorial using waves.scons_extensions.add_cubit_python() is provided as tutorial_cubit_alternate

$ pwd
/home/roppenheimer/waves-tutorials
$ waves fetch --destination tutorial_cubit_alternate tutorials/tutorial_cubit_alternate

References

• Cubit: Python Interface [57]

• Cubit: Importing Cubit into Python [57]

• Sierra: Sierra/SolidMechanics User’s Guide [59]

Environment

SCons and WAVES can be installed in a Conda environment with the Conda package manager. See the Conda installation and Conda environment management documentation for more details about using Conda.

Note

The SALib and numpy versions may not need to be this strict for most tutorials. However, Tutorial: Sensitivity Study uncovered some undocumented SALib version sensitivity to numpy surrounding the numpy v2 rollout.

1. Create the tutorials environment if it doesn’t exist

   $ conda create --name waves-tutorial-env --channel conda-forge waves 'scons>=4.6' matplotlib pandas pyyaml xarray seaborn 'numpy>=2' 'salib>=1.5.1' pytest
   

2. Activate the environment

   $ conda activate waves-tutorial-env
   

Some tutorials require additional third-party software that is not available for the Conda package manager. This software must be installed separately and either made available to SConstruct by modifying your system’s PATH or by modifying the SConstruct search paths provided to the waves.scons_extensions.add_program() method.

Directory Structure

3. Create and change to a new project root directory to house the tutorial files if you have not already done so. For example

$ mkdir -p ~/waves-tutorials
$ cd ~/waves-tutorials
$ pwd
/home/roppenheimer/waves-tutorials

4. Create a new tutorial_cubit directory with the waves fetch command below

$ pwd
/home/roppenheimer/waves-tutorials
$ waves fetch --destination tutorial_cubit tutorials/tutorial_cubit
$ ls tutorial_cubit
modsim_package/  abaqus  cubit  SConstruct  sierra fierro

5. Make the new tutorial_cubit directory the current working directory

$ pwd
/home/roppenheimer/waves-tutorials
$ cd tutorial_cubit
$ pwd
/home/roppenheimer/waves-tutorials/tutorial_cubit
$ ls
modsim_package/  abaqus  cubit  SConstruct  sierra fierro

SConscript

Note that the tutorial_cubit directory has four SConscript files: cubit, abaqus, sierra, and fierro. The cubit and sierra files are relevant to the current tutorial. The abaqus and fierro workflows are described in the complementary Tutorial: Cubit+Abaqus and Tutorial: Cubit+Fierro.

6. Review the cubit and sierra tutorials and compare them against the Tutorial 04: Simulation files.

The structure has changed enough that a diff view is not as useful. Instead the contents of the new SConscript files are duplicated below.

waves-tutorials/tutorial_cubit/cubit

#! /usr/bin/env python
"""Rectangle compression workflow: geometry, partition, mesh

Requires the following ``SConscript(..., exports={})``

* ``env`` - The SCons construction environment with the following required keys

  * ``unconditional_build`` - Boolean flag to force building of conditionally ignored targets
  * ``cubit`` - String path for the Cubit executable

* ``element_type`` - The Cubit 4 node quadrilateral element type
* ``solver`` - The target solver to use when writing a mesh file
"""

import pathlib

import waves

# Inherit the parent construction environment
Import("env", "element_type", "solver")

# Simulation variables
build_directory = pathlib.Path(Dir(".").abspath)
workflow_name = build_directory.name

# Collect the target nodes to build a concise alias for all targets
workflow = []

# Rectangle 2D
# Geometry
workflow.extend(
    env.PythonScript(
        target=["rectangle_geometry.cub"],
        source=["#/modsim_package/cubit/rectangle_geometry.py"],
        subcommand_options="",
    )
)

# Partition
workflow.extend(
    env.PythonScript(
        target=["rectangle_partition.cub"],
        source=["#/modsim_package/cubit/rectangle_partition.py", "rectangle_geometry.cub"],
        subcommand_options="",
    )
)

# Mesh
if solver.lower() == "abaqus":
    mesh_extension = "inp"
elif solver.lower() in ["sierra", "adagio"]:
    mesh_extension = "g"
else:
    raise RuntimeError(f"Unknown solver '{solver}'")
workflow.extend(
    env.PythonScript(
        target=[f"rectangle_mesh.{mesh_extension}", "rectangle_mesh.cub"],
        source=["#/modsim_package/cubit/rectangle_mesh.py", "rectangle_partition.cub"],
        subcommand_options="--element-type ${element_type} --solver ${solver}",
        element_type=element_type,
        solver=solver,
    )
)


# Cube 3D
# Geometry
workflow.extend(
    env.PythonScript(
        target=["cube_geometry.cub"],
        source=["#/modsim_package/cubit/cube_geometry.py"],
        subcommand_options="",
    )
)

# Partition
workflow.extend(
    env.PythonScript(
        target=["cube_partition.cub"],
        source=["#/modsim_package/cubit/cube_partition.py", "cube_geometry.cub"],
        subcommand_options="",
    )
)

# Mesh
if solver.lower() == "abaqus":
    mesh_extension = "inp"
elif solver.lower() in ["sierra", "adagio"]:
    mesh_extension = "g"
else:
    raise RuntimeError(f"Unknown solver '{solver}'")
workflow.extend(
    env.PythonScript(
        target=[f"cube_mesh.{mesh_extension}", "cube_mesh.cub"],
        source=["#/modsim_package/cubit/cube_mesh.py", "cube_partition.cub"],
        subcommand_options="--element-type ${element_type} --solver ${solver}",
        element_type=element_type,
        solver=solver,
    )
)

# Collector alias based on parent directory name
env.Alias(f"{workflow_name}_cubit", workflow)

if not env["unconditional_build"] and not env["CUBIT_PROGRAM"]:
    print(f"Program 'cubit' was not found in construction environment. Ignoring '{workflow_name}' target(s)")
    Ignore([".", workflow_name], workflow)

waves-tutorials/tutorial_cubit/sierra

#! /usr/bin/env python
"""Rectangle compression workflow: Sierra solve

Requires the following ``SConscript(..., exports={})``

* ``env`` - The SCons construction environment with the following required keys

  * ``unconditional_build`` - Boolean flag to force building of conditionally ignored targets
  * ``cubit`` - String path for the Cubit executable

* ``envSierra`` - The Sierra SCons construction environment with the following required keys

  * ``sierra`` - String path for the Sierra executable
"""

import pathlib

# Inherit the parent construction environment
Import("env", "envSierra")

# Simulation variables
build_directory = pathlib.Path(Dir(".").abspath)
workflow_name = build_directory.name

# Collect the target nodes to build a concise alias for all targets
workflow = []

element_type = "SHELL"
solver = "sierra"
SConscript(
    "cubit",
    exports={"env": env, "element_type": element_type, "solver": solver},
    duplicate=False,
)

# SolverPrep
sierra_source_list = ["#/modsim_package/sierra/rectangle_compression.i"]
sierra_source_list = [pathlib.Path(source_file) for source_file in sierra_source_list]
workflow.extend(env.CopySubstfile(sierra_source_list))

# Sierra Solve
solve_source_list = [source_file.name for source_file in sierra_source_list]
solve_source_list.append("rectangle_mesh.g")
workflow.extend(
    envSierra.Sierra(
        target=["rectangle_compression.e"],
        source=solve_source_list,
    )
)

# Collector alias based on parent directory name
env.Alias(workflow_name, workflow)

# Developer note: CI system configuration for Sierra is inconsistent. Do not force with ``unconditional build`` option.
if not envSierra["sierra"]:
    print(f"Program 'sierra' was not found in construction environment. Ignoring '{workflow_name}' target(s)")
    Ignore([".", workflow_name], workflow)

Cubit Journal Files

7. Review the following journal files in the waves-tutorials/modsim_package/cubit directory.

The Cubit journal files include the same CLI introduced in Tutorial 02: Partition and Mesh for the Abaqus journal files. Besides the differences in Abaqus and Cubit commands, the major difference between the Abaqus and Cubit journal files is the opportunity to use Python 3 with Cubit, where Abaqus journal files must use the Abaqus controlled installation of Python 2. The API and CLI built from the Cubit journal files’ docstrings may be found in the WAVES-TUTORIAL API for cubit and the WAVES-TUTORIAL CLI for cubit, respectively.

waves-tutorials/tutorial_cubit/modsim_package/cubit/rectangle_geometry.py

import sys
import pathlib
import argparse

import cubit


def main(output_file, width, height):
    """Create a simple rectangle geometry.

    This script creates a simple Cubit model with a single rectangle part.

    :param str output_file: The output file for the Cubit model. Will be stripped of the extension and ``.cub`` will be
        used.
    :param float width: The rectangle width
    :param float height: The rectangle height

    :returns: writes ``output_file``.cub
    """
    output_file = pathlib.Path(output_file).with_suffix(".cub")

    cubit.init(["cubit", "-noecho", "-nojournal", "-nographics", "-batch"])
    cubit.cmd("new")
    cubit.cmd("reset")

    cubit.cmd(f"create vertex 0 0 0")
    cubit.cmd(f"create vertex {width} 0 0")
    cubit.cmd(f"create vertex {width} {height} 0")
    cubit.cmd(f"create vertex 0 {height} 0")
    cubit.cmd(f"create surface vertex 1,2,3,4")

    cubit.cmd(f"save as '{output_file}' overwrite")


def get_parser():
    script_name = pathlib.Path(__file__)
    # Set default parameter values
    default_output_file = script_name.with_suffix(".cub").name
    default_width = 1.0
    default_height = 1.0

    prog = f"python {script_name.name} "
    cli_description = "Create a simple rectangle geometry and write an ``output_file``.cub Cubit model file."
    parser = argparse.ArgumentParser(description=cli_description, prog=prog)
    parser.add_argument(
        "--output-file",
        type=str,
        default=default_output_file,
        # fmt: off
        help="The output file for the Cubit model. "
             "Will be stripped of the extension and ``.cub`` will be used, e.g. ``output_file``.cub "
             "(default: %(default)s",
        # fmt: on
    )
    parser.add_argument(
        "--width",
        type=float,
        default=default_width,
        help="The rectangle width",
    )
    parser.add_argument(
        "--height",
        type=float,
        default=default_height,
        help="The rectangle height",
    )
    return parser


if __name__ == "__main__":
    parser = get_parser()
    args = parser.parse_args()
    sys.exit(
        main(
            output_file=args.output_file,
            width=args.width,
            height=args.height,
        )
    )

waves-tutorials/tutorial_cubit/modsim_package/cubit/rectangle_partition.py

import sys
import shutil
import pathlib
import argparse

import cubit


def main(input_file, output_file, width, height):
    """Partition the simple rectangle geometry created by ``rectangle_geometry.py``

    This script partitions a simple Cubit model with a single rectangle part.

    **Feature labels:**

    * ``bottom_left`` - bottom left vertex
    * ``bottom_right`` - bottom right vertex
    * ``top_right`` - top right vertex
    * ``top_left`` - top left vertex
    * ``left`` - left edge nodes
    * ``top`` - top edge nodes
    * ``right`` - right edge nodes
    * ``bottom`` - bottom edge nodes
    * ``elset_left`` - left edge elements
    * ``elset_top`` - top edge elements
    * ``elset_right`` - right edge elements
    * ``elset_bottom`` - bottom edge elements

    :param str input_file: The Cubit model file created by ``rectangle_geometry.py``. Will be stripped of the extension
        and ``.cub`` will be used.
    :param str output_file: The output file for the Cubit model. Will be stripped of the extension and ``.cub`` will be
        used.
    :param float width: The rectangle width
    :param float height: The rectangle height

    :returns: writes ``output_file``.cub
    """
    input_file = pathlib.Path(input_file).with_suffix(".cub")
    output_file = pathlib.Path(output_file).with_suffix(".cub")

    # Avoid modifying the contents or timestamp on the input file.
    # Required to get conditional re-builds with a build system such as GNU Make, CMake, or SCons
    if input_file != output_file:
        shutil.copyfile(input_file, output_file)

    cubit.init(["cubit", "-noecho", "-nojournal", "-nographics", "-batch"])
    cubit.cmd("new")
    cubit.cmd("reset")

    cubit.cmd(f"open '{output_file}'")

    cubit.cmd("nodeset 1 add vertex 1")
    cubit.cmd("nodeset 1 name 'bottom_left'")
    cubit.cmd("nodeset 2 add vertex 2")
    cubit.cmd("nodeset 2 name 'bottom_right'")
    cubit.cmd("nodeset 3 add vertex 3")
    cubit.cmd("nodeset 3 name 'top_right'")
    cubit.cmd("nodeset 4 add vertex 4")
    cubit.cmd("nodeset 4 name 'top_left'")

    cubit.cmd("nodeset 5 add curve 4")
    cubit.cmd("nodeset 5 name 'left'")
    cubit.cmd("nodeset 6 add curve 3")
    cubit.cmd("nodeset 6 name 'top'")
    cubit.cmd("nodeset 7 add curve 2")
    cubit.cmd("nodeset 7 name 'right'")
    cubit.cmd("nodeset 8 add curve 1")
    cubit.cmd("nodeset 8 name 'bottom'")

    cubit.cmd("sideset 1 add curve 4")
    cubit.cmd("sideset 1 name 'elset_left'")
    cubit.cmd("sideset 2 add curve 3")
    cubit.cmd("sideset 2 name 'elset_top'")
    cubit.cmd("sideset 3 add curve 2")
    cubit.cmd("sideset 3 name 'elset_right'")
    cubit.cmd("sideset 4 add curve 1")
    cubit.cmd("sideset 4 name 'elset_bottom'")

    cubit.cmd(f"save as '{output_file}' overwrite")


def get_parser():
    script_name = pathlib.Path(__file__)
    # Set default parameter values
    default_input_file = script_name.with_suffix(".cub").name.replace("_partition", "_geometry")
    default_output_file = script_name.with_suffix(".cub").name
    default_width = 1.0
    default_height = 1.0

    prog = f"python {script_name.name} "
    cli_description = (
        "Partition the simple rectangle geometry created by ``rectangle_geometry.py`` "
        "and write an ``output_file``.cub Cubit model file."
    )
    parser = argparse.ArgumentParser(description=cli_description, prog=prog)
    parser.add_argument(
        "--input-file",
        type=str,
        default=default_input_file,
        # fmt: off
        help="The Cubit model file created by ``rectangle_geometry.py``. "
             "Will be stripped of the extension and ``.cub`` will be used, e.g. ``input_file``.cub "
             "(default: %(default)s",
        # fmt: on
    )
    parser.add_argument(
        "--output-file",
        type=str,
        default=default_output_file,
        # fmt: off
        help="The output file for the Cubit model. "
             "Will be stripped of the extension and ``.cub`` will be used, e.g. ``output_file``.cub "
             "(default: %(default)s",
        # fmt: on
    )
    parser.add_argument(
        "--width",
        type=float,
        default=default_width,
        help="The rectangle width",
    )
    parser.add_argument(
        "--height",
        type=float,
        default=default_height,
        help="The rectangle height",
    )
    return parser


if __name__ == "__main__":
    parser = get_parser()
    args = parser.parse_args()
    sys.exit(
        main(
            input_file=args.input_file,
            output_file=args.output_file,
            width=args.width,
            height=args.height,
        )
    )

waves-tutorials/tutorial_cubit/modsim_package/cubit/rectangle_mesh.py

import sys
import shutil
import pathlib
import argparse

import cubit


def main(input_file, output_file, global_seed, element_type="QUAD", solver="abaqus"):
    """Mesh the simple rectangle geometry partitioned by ``rectangle_partition.py``

    This script meshes a simple Cubit model with a single rectangle part.

    **Feature labels:**

    * ``NODES`` - all part nodes
    * ``ELEMENTS`` - all part elements

    :param str input_file: The Cubit model file created by ``rectangle_partition.py``. Will be stripped of the extension
        and ``.cub`` will be used.
    :param str output_file: The output file for the Cubit model. Will be stripped of the extension and ``.cub`` and
        ``.inp`` will be used for the model and orphan mesh output files, respectively.
    :param float global_seed: The global mesh seed size
    :param str element_type: The model element type. Must be a supported Cubit 4 node element type.
    :param str solver: The solver type to use when exporting the mesh

    :returns: writes ``output_file``.cub and ``output_file``.inp

    :raises RuntimeError: If the solver is not supported
    """
    input_file = pathlib.Path(input_file).with_suffix(".cub")
    output_file = pathlib.Path(output_file).with_suffix(".cub")
    abaqus_mesh_file = output_file.with_suffix(".inp")
    sierra_mesh_file = output_file.with_suffix(".g")

    # Avoid modifying the contents or timestamp on the input file.
    # Required to get conditional re-builds with a build system such as GNU Make, CMake, or SCons
    if input_file != output_file:
        shutil.copyfile(input_file, output_file)

    cubit.init(["cubit", "-noecho", "-nojournal", "-nographics", "-batch"])
    cubit.cmd("new")
    cubit.cmd("reset")

    cubit.cmd(f"open '{output_file}'")

    cubit.cmd(f"surface 1 size {global_seed}")
    cubit.cmd("mesh surface 1")
    cubit.cmd("set duplicate block elements off")

    cubit.cmd("nodeset 9 add surface 1")
    cubit.cmd("nodeset 9 name 'NODES'")

    cubit.cmd("block 1 add surface 1")
    cubit.cmd(f"block 1 name 'ELEMENTS' Element type {element_type}")

    cubit.cmd(f"save as '{output_file}' overwrite")

    if solver.lower() == "abaqus":
        # Export Abaqus orphan mesh for Abaqus workflow
        cubit.cmd(f"export abaqus '{abaqus_mesh_file}' partial dimension 2 block 1 overwrite everything")
    elif solver.lower() in ["sierra", "adagio"]:
        # Export Genesis file for Sierra workflow
        cubit.cmd(f"export mesh '{sierra_mesh_file}' overwrite")
    else:
        raise RuntimeError(f"Uknown solver '{solver}'")


def get_parser():
    script_name = pathlib.Path(__file__)
    # Set default parameter values
    default_input_file = script_name.with_suffix(".cub").name.replace("_mesh", "_partition")
    default_output_file = script_name.with_suffix(".cub").name
    default_global_seed = 1.0
    default_element_type = "QUAD"
    default_solver = "abaqus"

    prog = f"python {script_name.name} "
    cli_description = (
        "Mesh the simple rectangle geometry partitioned by ``rectangle_partition.py`` "
        "and write an ``output_file``.cub Cubit model file and ``output_file``.inp orphan mesh file."
    )
    parser = argparse.ArgumentParser(description=cli_description, prog=prog)
    parser.add_argument(
        "--input-file",
        type=str,
        default=default_input_file,
        # fmt: off
        help="The Cubit model file created by ``rectangle_partition.py``. "
             "Will be stripped of the extension and ``.cub`` will be used, e.g. ``input_file``.cub "
             "(default: %(default)s",
        # fmt: on
    )
    parser.add_argument(
        "--output-file",
        type=str,
        default=default_output_file,
        # fmt: off
        help="The output file for the Cubit model. "
             "Will be stripped of the extension and ``.cub`` will be used, e.g. ``output_file``.cub",
        # fmt: on
    )
    parser.add_argument(
        "--global-seed",
        type=float,
        default=default_global_seed,
        help="The global mesh seed size (default: %(default)s)",
    )
    parser.add_argument(
        "--element-type",
        type=str,
        default=default_element_type,
        help="The model element type. Must be a supported Cubit 4 node element type. " "(default: %(default)s)",
    )
    parser.add_argument(
        "--solver",
        type=str,
        default=default_solver,
        choices=["abaqus", "sierra", "adagio"],
        help="The target solver for the mesh file. (default: %(default)s)",
    )

    return parser


if __name__ == "__main__":
    parser = get_parser()
    args = parser.parse_args()
    sys.exit(
        main(
            input_file=args.input_file,
            output_file=args.output_file,
            global_seed=args.global_seed,
            element_type=args.element_type,
            solver=args.solver,
        )
    )

Sierra Input File(s)

8. Create or review the Sierra input file from the contents below

waves-tutorials/tutorial_cubit/modsim_package/sierra/rectangle_compression.i

begin sierra

  begin function line
    type is analytic
    evaluate expression = "x"
  end function line

  begin property specification for material mock
    density = 0.27000e-08
    begin parameters for model elastic
      youngs modulus = 100
      poissons ratio = 0.3
    end
  end

  begin shell section planestress
    thickness = 0.1
  end shell section planestress

  begin finite element model rectangle_compression
    database name = rectangle_mesh.g
    database type = exodusII

    begin parameters for block ELEMENTS
      material mock
      solid mechanics use model elastic
      section = planestress
    end

  end finite element model rectangle_compression

  begin adagio procedure adagio

    begin time control
      begin time stepping block p0
        start time = 0
        begin parameters for adagio region adagio
            time increment = 0.5
        end
      end
      termination time = 1
    end

    begin adagio region adagio
      use finite element model rectangle_compression

      begin results output output_rectangle_compression
        database name = rectangle_compression.e
        database type = exodusII
        at time 0 interval = 0.1
        global variables = kinetic_energy
        global variables = internal_energy
        global variables = external_energy
        global variables = von_mises_max
        global variables = effective_strain_max
        nodal variables = displacement
        nodal variables = force_external
        nodal variables = force_internal
        element variables = strain
        element variables = unrotated_stress
        element variables = effective_strain
        element variables = von_mises
      end

      begin user output
        include all blocks
        compute global von_mises_max as max absolute value of element von_mises
        compute global effective_strain_max as max absolute value of element effective_strain
      end user output

      begin fixed displacement
        node set = bottom_left
        component = x
      end

      begin fixed displacement
        node set = bottom_left
        component = y
      end

      begin fixed rotation
        node set = bottom_left
        component = x
      end

      begin fixed rotation
        node set = bottom_left
        component = y
      end

      begin fixed rotation
        node set = bottom_left
        component = z
      end

      begin fixed displacement
        node set = bottom
        component = y
      end

      begin prescribed displacement
        node set = top
        component = y
        function = line
        scale factor = -0.01
      end

      ## TODO: Do we need to add traction BC for plane stress? Is there a plane stress element?

      begin solver
        begin cg
          reference = external
          target relative residual = 1e-10
          begin full tangent preconditioner
            iteration update = 10
          end full tangent preconditioner
        end cg
      end solver

    end adagio region adagio

  end adagio procedure adagio

end sierra

SConstruct

Note that Sierra requires a separate construction environment from the launching Conda environment. This is because Sierra ships with a version of Python that conflicts with the launching Conda environment. You may need to update the Sierra activation shell command according to the instructions on your local system.

A diff against the SConstruct file from Tutorial 04: Simulation is included below to help identify the changes made in this tutorial.

waves-tutorials/tutorial_cubit/SConstruct

--- /home/runner/work/waves/waves/build/docs/tutorials_tutorial_04_simulation_SConstruct
+++ /home/runner/work/waves/waves/build/docs/tutorial_cubit_SConstruct
@@ -1,7 +1,10 @@
 #! /usr/bin/env python
 
 import os
+import sys
+import typing
 import pathlib
+import subprocess
 
 import waves
 
@@ -48,6 +51,20 @@
     metavar="COMMAND",
     help=f"Override for the Abaqus command. Repeat to specify more than one (default: {default_abaqus_commands})",
 )
+default_cubit_commands = [
+    "/apps/Cubit-16.12/cubit",
+    "/usr/projects/ea/Cubit/Cubit-16.12/cubit",
+    "cubit",
+]
+AddOption(
+    "--cubit-command",
+    dest="cubit_command",
+    nargs=1,
+    type="string",
+    action="append",
+    metavar="COMMAND",
+    help=f"Override for the Cubit command. Repeat to specify more than one (default: {default_cubit_commands})",
+)
 
 # Comments used in tutorial code snippets: marker-2
 
@@ -58,6 +75,7 @@
     unconditional_build=GetOption("unconditional_build"),
     print_build_failures=GetOption("print_build_failures"),
     abaqus_commands=GetOption("abaqus_command"),
+    cubit_commands=GetOption("cubit_command"),
 )
 
 # Conditionally print failed task *.stdout files
@@ -69,6 +87,28 @@
 env["ABAQUS_PROGRAM"] = env.AddProgram(
     env["abaqus_commands"] if env["abaqus_commands"] is not None else default_abaqus_commands
 )
+env["CUBIT_PROGRAM"] = env.AddCubit(
+    env["cubit_commands"] if env["cubit_commands"] is not None else default_cubit_commands
+)
+env["FIERRO_IMPLICIT_PROGRAM"] = env.AddProgram(["fierro-parallel-implicit"])
+
+
+# Sierra requires a separate construction environment
+def return_modulepath(modules: typing.Iterable[str]) -> pathlib.Path:
+    """Return parent path of first found module or the current working directory"""
+    return next((pathlib.Path(path).parent for path in modules if pathlib.Path(path).exists()), pathlib.Path("."))
+
+
+sierra_modules = [
+    "/projects/aea_compute/modulefiles/sierra/5.21.6",
+]
+sierra_modulefile_parent = return_modulepath(sierra_modules)
+try:
+    envSierra = waves.scons_extensions.shell_environment(f"module use {sierra_modulefile_parent} && module load sierra")
+except subprocess.CalledProcessError:
+    print("Failed to initialize the Sierra environment", file=sys.stderr)
+    envSierra = Environment()
+envSierra["sierra"] = waves.scons_extensions.add_program(envSierra, ["sierra"])
 
 # Comments used in tutorial code snippets: marker-4
 
@@ -84,26 +124,33 @@
 for key, value in project_variables.items():
     env[key] = value
 
-# Make the project package importable for Python and Abaqus Python environments
-env.PrependENVPath("PYTHONPATH", project_dir)
-
 # Comments used in tutorial code snippets: marker-5
 
 # Add builders and pseudo-builders
 env.Append(BUILDERS={})
 
+envSierra.Append(
+    BUILDERS={
+        "Sierra": waves.scons_extensions.sierra_builder_factory(program=envSierra["sierra"]),
+    }
+)
+
 # Comments used in tutorial code snippets: marker-6
 
 # Add simulation targets
 workflow_configurations = [
-    "tutorial_01_geometry",
-    "tutorial_02_partition_mesh",
-    "tutorial_03_solverprep",
-    "tutorial_04_simulation",
+    "abaqus",
+    "sierra",
+    "fierro",
 ]
 for workflow in workflow_configurations:
     build_dir = env["variant_dir_base"] / workflow
-    SConscript(workflow, variant_dir=build_dir, exports={"env": env}, duplicate=False)
+    SConscript(
+        workflow,
+        variant_dir=build_dir,
+        exports={"env": env, "envSierra": envSierra},
+        duplicate=False,
+    )
 
 # Comments used in tutorial code snippets: marker-7
 

Note that the Cubit Python files don’t perform any imports from the current modsim project package, so the PYTHONPATH modification is no longer required. This tutorial is created in a new, stand-alone subdirectory, so the previous tutorial workflow configurations are no longer available. Only the sierra and abaqus workflow configurations will be found by SCons at execution time. Finally, note that the cubit SConscript file is not called by the SConstruct file. Instead, the cubit configuration is reused by the sierra and abaqus workflows, so the Cubit tasks only need to be defined once. To handle this task reuse some additional variable import and export statements are required by the cubit configuration file.

Build Targets

9. Build the new targets

$ pwd
/path/to/waves-tutorials/tutorial_cubit
$ scons sierra
scons: Reading SConscript files ...
Checking whether /apps/abaqus/Commands/abq2024 program exists.../apps/abaqus/Commands/abq2024
Checking whether abq2024 program exists...no
Checking whether /apps/Cubit-16.12/cubit program exists.../apps/Cubit-16.12/cubit
Checking whether cubit program exists...no
Checking whether sierra program exists.../projects/sierra/sierra5121/install/tools/sntools/engine/sierra
scons: done reading SConscript files.
scons: Building targets ...
Copy("build/sierra/rectangle_compression.i", "modsim_package/sierra/rectangle_compression.i")
cd /home/roppenheimer/waves-tutorials/tutorial_cubit/build/sierra && python /home/roppenheimer/waves-tutorials/tutorial_cubit/modsim_package/cubit/rectangle_geometry.py > rectangle_geometry.stdout 2>&1
cd /home/roppenheimer/waves-tutorials/tutorial_cubit/build/sierra && python /home/roppenheimer/waves-tutorials/tutorial_cubit/modsim_package/cubit/rectangle_partition.py > rectangle_partition.stdout 2>&1
cd /home/roppenheimer/waves-tutorials/tutorial_cubit/build/sierra && python /home/roppenheimer/waves-tutorials/tutorial_cubit/modsim_package/cubit/rectangle_mesh.py --element-type SHELL --solver sierra > rectangle_mesh.stdout 2>&1
cd /home/roppenheimer/waves-tutorials/tutorial_cubit/build/sierra && /projects/sierra/sierra5121/install/tools/sntools/engine/sierra adagio -i rectangle_compression.i > rectangle_compression.stdout 2>&1
scons: done building targets.

Output Files

Explore the contents of the build directory using the tree command against the build/abaqus directory, as shown below.

$ pwd
/home/roppenheimer/waves-tutorials/tutorial_cubit
$ tree build/sierra/
build/sierra/
|-- rectangle_compression.e
|-- rectangle_compression.i
|-- rectangle_compression.log
|-- rectangle_compression.stdout
|-- rectangle_geometry.cub
|-- rectangle_geometry.stdout
|-- rectangle_mesh.cub
|-- rectangle_mesh.g
|-- rectangle_mesh.stdout
|-- rectangle_partition.cub
`-- rectangle_partition.stdout

0 directories, 11 files