Overview#

We are going to show all the code first, and then we will be analysing it step by step. Each of the blocks is easy to understand and it all builds on top of the examples we showed in the previous parts of this tutorial.

import inductiva
import time

# Allocate 50 cloud machines
# Note that we are using an ElasticMachineGroup
cloud_machine = inductiva.resources.ElasticMachineGroup(
    provider="GCP",
    machine_type="n2-highcpu-2",
    spot=True,
    min_machines=1,
    max_machines=50)

openfast_project = inductiva.projects.Project(
    name="Openfast_WavesWN",
    append=True)
openfast_project.open()

for depth in range(100, 200, 2):

    print(f"Preparing files for depth = {depth}")
    target_dir = f"variations/params_for_depth_{depth}"

    # This is where we instantiate the configuration
    # files with the specific values
    inductiva.TemplateManager.render_dir(
        source_dir="input_files",
        target_dir=target_dir,
        overwrite=True,
        water_depth=depth)

    # Initialize OpenFAST simulator
    openfast = inductiva.simulators.OpenFAST(
        version="4.0.2"

    task = openfast.run(
        input_dir=target_dir,
        commands=[
        "openfast 5MW_OC4Semi_WSt_WavesWN/"
        "5MW_OC4Semi_WSt_WavesWN.fst"],
        on=cloud_machine)

openfast_project.wait()
openfast_project.close()
cloud_machine.terminate()

Let’s now break this script into parts.

Code Section 1: Allocating the Cloud Machine Group#

We are allocating an elastic machine group to run our simulations. This group has a minimum number of machines active and a maximum capacity. Machines are dynamically turned on or off based on demand, ensuring efficient resource utilization.

Since some simulations may take longer than others, this elastic setup prevents idle waiting. When a machine completes its task and has no more simulations to run, it does not need to wait for all other machines to finish. Instead, the elastic machine group automatically scales down, optimizing cloud usage and reducing costs.

# Allocate cloud machine
cloud_machine = inductiva.resources.ElasticMachineGroup(
    provider="GCP",
    machine_type="n2-highcpu-2",
    spot=True,
    min_machines=1,
    max_machines=50)

Code Section 2: Setting Up Our Project#

To keep our simulations organized, we use a project-based approach. Setting up a project is straightforward: we create it with append mode enabled, which indicates that we’ll be adding tasks to the project rather than just querying its data. Once the project is created and opened, all subsequent simulations will automatically be associated with our Openfast_WavesWN project.

openfast_project = inductiva.projects.Project(
    name="Openfast_WavesWN",
    append=True
)
openfast_project.open()

This ensures that all simulations remain structured and easily accessible within the project.

Code Section 3: Looping over parameters assignment and starting the simulation#

We now enter a loop responsible for generating new input files and running each simulation.

First, we iterate over the specified water depths. For each depth, we generate input files using the render_dir method, which replaces the water_depth variable in our 5MW_OC4Semi_WSt_WavesWN.fst.jinja template with the corresponding depth value. The generated input files are then stored in a dedicated folder, target_dir (variations/params_for_depth_{depth}).

Next, we initialize the OpenFAST simulator and run the simulation using the newly created input directory. Each simulation task is stored in a list, allowing us to track and wait for all tasks to complete.

for depth in range(100, 200, 2):

    print(f"Preparing files for depth = {depth}")
    target_dir = f"variations/params_for_depth_{depth}"

    # Generate input files with the specified water depth
    inductiva.TemplateManager.render_dir(
        source_dir="input_files",
        target_dir=target_dir,
        overwrite=True,
        water_depth=depth
    )

    # Initialize OpenFAST simulator
    openfast = inductiva.simulators.OpenFAST(
        version="4.0.2"
    )

    # Run the simulation on the allocated cloud machines
    task = openfast.run(
        input_dir=target_dir,
        commands=[
            "openfast 5MW_OC4Semi_WSt_WavesWN/"
            "5MW_OC4Semi_WSt_WavesWN.fst"
        ],
        on=cloud_machine
    )

Code Section 4: Waiting for the simulations to finish#

In this last part of the code we are just waiting for all the tasks to finish.

Once all tasks are done we close our project and turn off our cloud machines.

openfast_project.wait()

openfast_project.close()
cloud_machine.terminate()

Note: You can list all the tasks from this project by running this command on your command line interface inductiva tasks list -p Openfast_WavesWN -n 50

Showing tasks for project: Openfast_WavesWN.

 ID                          SIMULATOR     STATUS     SUBMITTED         STARTED           COMPUTATION TIME     RESOURCE TYPE
 9ousr15npia4f9fphfjm1rmrn   openfast      Success    12/02, 15:25:00   12/02, 15:25:00   0:00:34              GCP n2-highcpu-2
 pt3i70i4hmzn740og3ber5yvs   openfast      Success    12/02, 15:24:54   12/02, 15:24:54   0:00:32              GCP n2-highcpu-2
 60ygm64qsd56fmcjxgytq93pr   openfast      Success    12/02, 15:24:47   12/02, 15:24:47   0:00:35              GCP n2-highcpu-2
 ...
 8gvt5i0x0qeaj2x7ftf7pwxyd   openfast      Success    12/02, 15:20:37   12/02, 15:20:37   0:00:31              GCP n2-highcpu-2
 gnq3smc96ht404hz4ucvoovw6   openfast      Success    12/02, 15:20:14   12/02, 15:20:19   0:00:33              GCP n2-highcpu-2
 iox5b1040tagfnwi9a3j26axr   openfast      Success    12/02, 15:20:07   12/02, 15:20:19   0:00:31              GCP n2-highcpu-2

To see more details about a task, use `inductiva tasks info <task_id>`.