Get Simulation Default Settings

This example demonstrates how to retrieve the default simulation settings for a specific G-Code. This is useful for understanding what parameters will be used when running a simulation, and for customizing those parameters as needed.

Tip

Before proceeding, ensure you have completed the Code Generation setup to generate the required types and documents for your language.

Note

You must have a G-Code in READY status before querying default settings. See the Create G-Code example first.

GraphQL Operations

Create the following GraphQL query file, then run your language’s codegen tool to generate the types.

Default Simulation Settings

queries/DefaultSimulationSettings.graphql

query DefaultSimulationSettings($gcodeId: ID!) {
  defaultSimulationSettings(gcodeId: $gcodeId) {
    roomTemperature
    stabilizedAirTemperature
    nozzleTemperature
    platformTemperature
    fanSpeed
    airTemperatureAboveBuildPlate
  }
}

API Reference:

• DefaultSimulationSettings type - Full default settings object structure

Code Example

1. Setup the client and configuration

   TypeScript

   index.ts

   import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
   import { DefaultSimulationSettingsDocument } from "./queries/__generated/DefaultSimulationSettings.generated";
   
   // Load PAT from environment
   const PAT = process.env.PAT;
   if (!PAT) {
     throw new Error("PAT environment variable is required");
   }
   
   // Create Apollo Client
   const client = new ApolloClient({
     cache: new InMemoryCache(),
     link: new HttpLink({
       uri: "https://api.helioadditive.com/graphql",
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${PAT}`,
       },
     }),
   });
   
   // Replace with an actual G-Code ID from your account
   const GCODE_ID = process.env.GCODE_ID ?? "your-gcode-id";
   
   // Helper function to convert Kelvin to Celsius
   function kelvinToCelsius(kelvin: number): number {
     return kelvin - 273.15;
   }

   Python

   main.py

   import asyncio
   import os
   import httpx
   from client.client import Client
   
   # Load PAT from environment
   PAT = os.environ.get("PAT")
   if not PAT:
       raise ValueError("PAT environment variable is required")
   
   # Replace with an actual G-Code ID from your account
   GCODE_ID = os.environ.get("GCODE_ID", "your-gcode-id")
   
   # Create GraphQL client
   headers = {"Authorization": f"Bearer {PAT}"}
   graphql_client = Client(
       url="https://api.helioadditive.com/graphql",
       headers=headers,
       http_client=httpx.AsyncClient(headers=headers, timeout=60)
   )
   
   def kelvin_to_celsius(kelvin: float) -> float:
       """Convert Kelvin to Celsius."""
       return kelvin - 273.15

   Rust

   src/main.rs

   use graphql_client::{GraphQLQuery, Response};
   use reqwest::header::{AUTHORIZATION, CONTENT_TYPE};
   
   #[derive(GraphQLQuery)]
   #[graphql(
       schema_path = "schema.graphqls",
       query_path = "queries/DefaultSimulationSettings.graphql",
       response_derives = "Debug"
   )]
   struct DefaultSimulationSettings;
   
   fn kelvin_to_celsius(kelvin: f64) -> f64 {
       kelvin - 273.15
   }
   
   // Load from environment in main()
   let pat = std::env::var("PAT").expect("PAT environment variable must be set");
   let gcode_id = std::env::var("GCODE_ID").unwrap_or_else(|_| "your-gcode-id".to_string());

   C++

   src/main.cpp

   #include <iostream>
   #include <string>
   #include <cstdlib>
   
   #include <cpr/cpr.h>
   #include <boost/json.hpp>
   
   #include "DefaultSimulationSettingsClient.h"
   #include "graphqlservice/GraphQLResponse.h"
   #include "graphqlservice/JSONResponse.h"
   
   namespace DefaultSimulationSettings = graphql::client::query::DefaultSimulationSettings;
   
   // Helper function to send GraphQL HTTP requests
   graphql::response::Value sendHttpRequest(
       const std::string& query,
       graphql::response::Value& variables,
       const std::string& pat
   ) {
       std::string body = boost::json::serialize(boost::json::object{
           {"query", query},
           {"variables", boost::json::parse(graphql::response::toJSON(std::move(variables))).as_object()}
       });
   
       auto response = cpr::Post(
           cpr::Url{"https://api.helioadditive.com/graphql"},
           cpr::Header{
               {"Content-Type", "application/json"},
               {"Authorization", "Bearer " + pat}
           },
           cpr::Body{body}
       );
   
       return graphql::response::parseJSON(boost::json::serialize(
           boost::json::parse(response.text).as_object()["data"].as_object()
       ));
   }
   
   // Helper function to convert Kelvin to Celsius
   double kelvinToCelsius(double kelvin) {
       return kelvin - 273.15;
   }
   
   // Load PAT from environment in main()
   const char* pat_env = std::getenv("PAT");
   if (!pat_env) {
       std::cerr << "PAT environment variable is required" << std::endl;
       return 1;
   }
   std::string pat(pat_env);
   
   // Replace with an actual G-Code ID from your account
   const char* gcode_env = std::getenv("GCODE_ID");
   std::string gcodeId = gcode_env ? gcode_env : "your-gcode-id";

2. Fetch the default simulation settings

   Query the API to get the default settings for your G-Code.

   TypeScript

   async function getSimulationDefaults(gcodeId: string) {
     console.log(`Fetching default simulation settings for G-Code: ${gcodeId}`);
   
     const { data } = await client.query({
       query: DefaultSimulationSettingsDocument,
       variables: { gcodeId },
       fetchPolicy: "no-cache",
     });
   
     const settings = data?.defaultSimulationSettings;
     if (!settings) {
       throw new Error("Failed to get default simulation settings");
     }
   
     return settings;
   }

   Python

   async def get_simulation_defaults(gcode_id: str):
       """Fetch default simulation settings for a G-Code."""
       print(f"Fetching default simulation settings for G-Code: {gcode_id}")
   
       result = await graphql_client.default_simulation_settings(gcode_id=gcode_id)
       return result

   Rust

   async fn get_simulation_defaults(
       client: &reqwest::Client,
       pat: &str,
       gcode_id: &str,
   ) -> Result<default_simulation_settings::DefaultSimulationSettings, Box<dyn std::error::Error>> {
       println!("Fetching default simulation settings for G-Code: {}", gcode_id);
   
       let variables = default_simulation_settings::Variables {
           gcode_id: gcode_id.to_string(),
       };
   
       let response = client
           .post("https://api.helioadditive.com/graphql")
           .header(CONTENT_TYPE, "application/json")
           .header(AUTHORIZATION, format!("Bearer {}", pat))
           .json(&DefaultSimulationSettings::build_query(variables))
           .send()
           .await?;
   
       let body: Response<default_simulation_settings::ResponseData> = response.json().await?;
   
       if let Some(errors) = body.errors {
           return Err(format!("GraphQL errors: {:?}", errors).into());
       }
   
       Ok(body.data.unwrap().default_simulation_settings)
   }

   C++

   auto getSimulationDefaults(const std::string& gcodeId, const std::string& pat) {
       std::cout << "Fetching default simulation settings for G-Code: " << gcodeId << std::endl;
   
       const std::string query = DefaultSimulationSettings::GetRequestText();
       graphql::response::Value variables = DefaultSimulationSettings::serializeVariables(
           DefaultSimulationSettings::Variables{.gcodeId = gcodeId}
       );
   
       auto response = DefaultSimulationSettings::parseResponse(sendHttpRequest(query, variables, pat));
       return response.defaultSimulationSettings;
   }

3. Display the settings

   Print the default settings in a readable format.

   TypeScript

   function displaySettings(settings: any) {
     console.log("\nDefault Simulation Settings:");
     console.log("============================");
     console.log(`Room Temperature: ${settings.roomTemperature}K (${kelvinToCelsius(settings.roomTemperature).toFixed(1)}°C)`);
     console.log(`Stabilized Air Temperature: ${settings.stabilizedAirTemperature}K (${kelvinToCelsius(settings.stabilizedAirTemperature).toFixed(1)}°C)`);
     console.log(`Nozzle Temperature: ${settings.nozzleTemperature}K (${kelvinToCelsius(settings.nozzleTemperature).toFixed(1)}°C)`);
     console.log(`Platform Temperature: ${settings.platformTemperature}K (${kelvinToCelsius(settings.platformTemperature).toFixed(1)}°C)`);
     console.log(`Fan Speed: ${settings.fanSpeed}%`);
     console.log(`Air Temperature Above Build Plate: ${settings.airTemperatureAboveBuildPlate}K (${kelvinToCelsius(settings.airTemperatureAboveBuildPlate).toFixed(1)}°C)`);
   }

   Python

   def display_settings(settings):
       """Print the default settings in a readable format."""
       print("\nDefault Simulation Settings:")
       print("============================")
       print(f"Room Temperature: {settings.room_temperature}K ({kelvin_to_celsius(settings.room_temperature):.1f}°C)")
       print(f"Stabilized Air Temperature: {settings.stabilized_air_temperature}K ({kelvin_to_celsius(settings.stabilized_air_temperature):.1f}°C)")
       print(f"Nozzle Temperature: {settings.nozzle_temperature}K ({kelvin_to_celsius(settings.nozzle_temperature):.1f}°C)")
       print(f"Platform Temperature: {settings.platform_temperature}K ({kelvin_to_celsius(settings.platform_temperature):.1f}°C)")
       print(f"Fan Speed: {settings.fan_speed}%")
       print(f"Air Temperature Above Build Plate: {settings.air_temperature_above_build_plate}K ({kelvin_to_celsius(settings.air_temperature_above_build_plate):.1f}°C)")

   Rust

   fn display_settings(settings: &default_simulation_settings::DefaultSimulationSettings) {
       println!("\nDefault Simulation Settings:");
       println!("============================");
       println!(
           "Room Temperature: {}K ({:.1}°C)",
           settings.room_temperature,
           kelvin_to_celsius(settings.room_temperature)
       );
       println!(
           "Stabilized Air Temperature: {}K ({:.1}°C)",
           settings.stabilized_air_temperature,
           kelvin_to_celsius(settings.stabilized_air_temperature)
       );
       println!(
           "Nozzle Temperature: {}K ({:.1}°C)",
           settings.nozzle_temperature,
           kelvin_to_celsius(settings.nozzle_temperature)
       );
       println!(
           "Platform Temperature: {}K ({:.1}°C)",
           settings.platform_temperature,
           kelvin_to_celsius(settings.platform_temperature)
       );
       println!("Fan Speed: {}%", settings.fan_speed);
       println!(
           "Air Temperature Above Build Plate: {}K ({:.1}°C)",
           settings.air_temperature_above_build_plate,
           kelvin_to_celsius(settings.air_temperature_above_build_plate)
       );
   }

   C++

   void displaySettings(const auto& settings) {
       std::cout << "\nDefault Simulation Settings:" << std::endl;
       std::cout << "============================" << std::endl;
       std::cout << "Room Temperature: " << settings.roomTemperature << "K ("
                 << kelvinToCelsius(settings.roomTemperature) << "°C)" << std::endl;
       std::cout << "Stabilized Air Temperature: " << settings.stabilizedAirTemperature << "K ("
                 << kelvinToCelsius(settings.stabilizedAirTemperature) << "°C)" << std::endl;
       std::cout << "Nozzle Temperature: " << settings.nozzleTemperature << "K ("
                 << kelvinToCelsius(settings.nozzleTemperature) << "°C)" << std::endl;
       std::cout << "Platform Temperature: " << settings.platformTemperature << "K ("
                 << kelvinToCelsius(settings.platformTemperature) << "°C)" << std::endl;
       std::cout << "Fan Speed: " << settings.fanSpeed << "%" << std::endl;
       std::cout << "Air Temperature Above Build Plate: " << settings.airTemperatureAboveBuildPlate << "K ("
                 << kelvinToCelsius(settings.airTemperatureAboveBuildPlate) << "°C)" << std::endl;
   }

4. Put it all together

   Combine all the steps and run the example.

   TypeScript

   // Example usage
   getSimulationDefaults(GCODE_ID)
     .then((settings) => {
       displaySettings(settings);
       console.log("\nExample completed successfully!");
     })
     .catch(console.error);

   Python

   if __name__ == "__main__":
       async def main():
           settings = await get_simulation_defaults(GCODE_ID)
           display_settings(settings)
           print("\nExample completed successfully!")
   
       asyncio.run(main())

   Rust

   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       let pat = std::env::var("PAT").expect("PAT environment variable must be set");
       let gcode_id = std::env::var("GCODE_ID").unwrap_or_else(|_| "your-gcode-id".to_string());
   
       let client = reqwest::Client::new();
       let settings = get_simulation_defaults(&client, &pat, &gcode_id).await?;
       display_settings(&settings);
   
       println!("\nExample completed successfully!");
       Ok(())
   }

   C++

   int main() {
       const char* pat_env = std::getenv("PAT");
       if (!pat_env) {
           std::cerr << "PAT environment variable is required" << std::endl;
           return 1;
       }
       std::string pat(pat_env);
   
       const char* gcode_env = std::getenv("GCODE_ID");
       std::string gcodeId = gcode_env ? gcode_env : "your-gcode-id";
   
       try {
           auto settings = getSimulationDefaults(gcodeId, pat);
           displaySettings(settings);
           std::cout << "\nExample completed successfully!" << std::endl;
           return 0;
       } catch (const std::exception& e) {
           std::cerr << "Error: " << e.what() << std::endl;
           return 1;
       }
   }

Running the Example

1. Create a .env.local file with your PAT and G-Code ID:

   PAT="your-personal-access-token"
   GCODE_ID="your-gcode-id"

2. Update the GCODE_ID with a valid G-Code ID from your account that is in READY status.

3. Run the example:

   TypeScript

   bun run index.ts

   Python

   uv run main.py

   Rust

   cargo run

   C++

   mkdir build && cd build
   cmake .. -DVCPKG_DIR=$(pwd)/../vcpkg/installed/arm64-osx
   make
   ./SimulationDefaultsExample

Using Default Settings with a Simulation

You can use these default settings as a starting point and override specific values when creating a simulation:

TypeScript

import { CreateSimulationDocument } from "./mutations/__generated/CreateSimulation.generated";

// First, get the defaults
const defaults = await getSimulationDefaults(GCODE_ID);

// Then create a simulation with some overrides
const { data } = await client.mutate({
  mutation: CreateSimulationDocument,
  variables: {
    input: {
      gcodeId: GCODE_ID,
      name: "my-simulation",
      // Use defaults but override room temperature
      roomTemperature: 298.15, // 25°C instead of default
      // Other values will use G-Code defaults automatically
    },
  },
});

Python

# First, get the defaults
defaults = await get_simulation_defaults(GCODE_ID)

# Then create a simulation with some overrides
result = await graphql_client.create_simulation(
    input={
        "gcodeId": GCODE_ID,
        "name": "my-simulation",
        # Use defaults but override room temperature
        "roomTemperature": 298.15,  # 25°C instead of default
        # Other values will use G-Code defaults automatically
    }
)

Rust

// First, get the defaults
let defaults = get_simulation_defaults(&client, &pat, &gcode_id).await?;

// Then create a simulation with some overrides
let variables = create_simulation::Variables {
    input: create_simulation::CreateSimulationInput {
        gcode_id: gcode_id.to_string(),
        name: "my-simulation".to_string(),
        // Use defaults but override room temperature
        room_temperature: Some(298.15), // 25°C instead of default
        // Other values will use G-Code defaults automatically
        stabilized_air_temperature: None,
        constant_nozzle_temperature: None,
        constant_platform_temperature: None,
        constant_fan_speed: None,
        air_temperature_above_build_plate: None,
    },
};

C++

// First, get the defaults
auto defaults = getSimulationDefaults(gcodeId, pat);

// Then create a simulation with some overrides
const std::string query = CreateSimulation::GetRequestText();
graphql::response::Value variables = CreateSimulation::serializeVariables(
    CreateSimulation::Variables{
        .input = CreateSimulation::CreateSimulationInput{
            .gcodeId = gcodeId,
            .name = "my-simulation",
            // Use defaults but override room temperature
            .roomTemperature = 298.15  // 25°C instead of default
            // Other values will use G-Code defaults automatically
        }
    }
);

auto response = CreateSimulation::parseResponse(sendHttpRequest(query, variables, pat));

Tip

The default settings are automatically derived from the G-Code file and the associated printer and material. By querying these first, you can understand what values will be used and decide if any overrides are needed for your specific use case.