Get Optimization Default Settings

This example demonstrates how to retrieve the default optimization settings for a specific G-Code. This is useful for understanding what parameters will be used when running an optimization, 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 Optimization Settings

queries/DefaultOptimizationSettings.graphql

query DefaultOptimizationSettings($gcodeId: ID!) {
  defaultOptimizationSettings(gcodeId: $gcodeId) {
    minVelocity
    maxVelocity
    minVelocityIncrement
    minExtruderFlowRate
    maxExtruderFlowRate
    tolerance
    maxIterations
    nNodes
    optimizer
    optimizeOuterwall
    reductionStrategySettings {
      strategy
    }
    residualStrategySettings {
      strategy
      exponentialPenaltyLow
      exponentialPenaltyHigh
    }
    layersToOptimize {
      fromLayer
      toLayer
    }
  }
}

API Reference:

• DefaultOptimizationSettings type - Full default settings object structure
• Optimizer enum - Available optimizer algorithms

Code Example

1. Setup the client and configuration

   TypeScript

   index.ts

   import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
   import { DefaultOptimizationSettingsDocument } from "./queries/__generated/DefaultOptimizationSettings.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";

   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)
   )

   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/DefaultOptimizationSettings.graphql",
       response_derives = "Debug"
   )]
   struct DefaultOptimizationSettings;
   
   // 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 "DefaultOptimizationSettingsClient.h"
   #include "graphqlservice/GraphQLResponse.h"
   #include "graphqlservice/JSONResponse.h"
   
   namespace DefaultOptimizationSettings = graphql::client::query::DefaultOptimizationSettings;
   
   // 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()
       ));
   }
   
   // 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 optimization settings

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

   TypeScript

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

   Python

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

   Rust

   async fn get_optimization_defaults(
       client: &reqwest::Client,
       pat: &str,
       gcode_id: &str,
   ) -> Result<default_optimization_settings::DefaultOptimizationSettings, Box<dyn std::error::Error>> {
       println!("Fetching default optimization settings for G-Code: {}", gcode_id);
   
       let variables = default_optimization_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(&DefaultOptimizationSettings::build_query(variables))
           .send()
           .await?;
   
       let body: Response<default_optimization_settings::ResponseData> = response.json().await?;
   
       if let Some(errors) = body.errors {
           return Err(format!("GraphQL errors: {:?}", errors).into());
       }
   
       Ok(body.data.unwrap().default_optimization_settings)
   }

   C++

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

3. Display the settings

   Print the default settings in a readable format.

   TypeScript

   function displaySettings(settings: any) {
     console.log("\nDefault Optimization Settings:");
     console.log("==============================");
     console.log(`Min Velocity: ${settings.minVelocity} m/s`);
     console.log(`Max Velocity: ${settings.maxVelocity} m/s`);
     console.log(`Min Velocity Increment: ${settings.minVelocityIncrement} m/s`);
     console.log(`Min Extruder Flow Rate: ${settings.minExtruderFlowRate}`);
     console.log(`Max Extruder Flow Rate: ${settings.maxExtruderFlowRate}`);
     console.log(`Tolerance: ${settings.tolerance}`);
     console.log(`Max Iterations: ${settings.maxIterations}`);
     console.log(`Number of Nodes: ${settings.nNodes}`);
     console.log(`Optimizer: ${settings.optimizer}`);
     console.log(`Optimize Outer Wall: ${settings.optimizeOuterwall}`);
   
     if (settings.layersToOptimize && settings.layersToOptimize.length > 0) {
       console.log("\nLayers to Optimize:");
       for (const range of settings.layersToOptimize) {
         console.log(`  From layer ${range.fromLayer} to layer ${range.toLayer}`);
       }
     }
   }

   Python

   def display_settings(settings):
       """Print the default settings in a readable format."""
       print("\nDefault Optimization Settings:")
       print("==============================")
       print(f"Min Velocity: {settings.min_velocity} m/s")
       print(f"Max Velocity: {settings.max_velocity} m/s")
       print(f"Min Velocity Increment: {settings.min_velocity_increment} m/s")
       print(f"Min Extruder Flow Rate: {settings.min_extruder_flow_rate}")
       print(f"Max Extruder Flow Rate: {settings.max_extruder_flow_rate}")
       print(f"Tolerance: {settings.tolerance}")
       print(f"Max Iterations: {settings.max_iterations}")
       print(f"Number of Nodes: {settings.n_nodes}")
       print(f"Optimizer: {settings.optimizer}")
       print(f"Optimize Outer Wall: {settings.optimize_outerwall}")
   
       if settings.layers_to_optimize:
           print("\nLayers to Optimize:")
           for layer_range in settings.layers_to_optimize:
               print(f"  From layer {layer_range.from_layer} to layer {layer_range.to_layer}")

   Rust

   fn display_settings(settings: &default_optimization_settings::DefaultOptimizationSettings) {
       println!("\nDefault Optimization Settings:");
       println!("==============================");
       println!("Min Velocity: {} m/s", settings.min_velocity);
       println!("Max Velocity: {} m/s", settings.max_velocity);
       println!("Min Velocity Increment: {} m/s", settings.min_velocity_increment);
       println!("Min Extruder Flow Rate: {}", settings.min_extruder_flow_rate);
       println!("Max Extruder Flow Rate: {}", settings.max_extruder_flow_rate);
       println!("Tolerance: {}", settings.tolerance);
       println!("Max Iterations: {}", settings.max_iterations);
       println!("Number of Nodes: {}", settings.n_nodes);
       println!("Optimizer: {:?}", settings.optimizer);
       println!("Optimize Outer Wall: {}", settings.optimize_outerwall);
   
       if let Some(layers) = &settings.layers_to_optimize {
           println!("\nLayers to Optimize:");
           for range in layers {
               println!("  From layer {} to layer {}", range.from_layer, range.to_layer);
           }
       }
   }

   C++

   void displaySettings(const auto& settings) {
       std::cout << "\nDefault Optimization Settings:" << std::endl;
       std::cout << "==============================" << std::endl;
       std::cout << "Min Velocity: " << settings.minVelocity << " m/s" << std::endl;
       std::cout << "Max Velocity: " << settings.maxVelocity << " m/s" << std::endl;
       std::cout << "Min Velocity Increment: " << settings.minVelocityIncrement << " m/s" << std::endl;
       std::cout << "Min Extruder Flow Rate: " << settings.minExtruderFlowRate << std::endl;
       std::cout << "Max Extruder Flow Rate: " << settings.maxExtruderFlowRate << std::endl;
       std::cout << "Tolerance: " << settings.tolerance << std::endl;
       std::cout << "Max Iterations: " << settings.maxIterations << std::endl;
       std::cout << "Number of Nodes: " << settings.nNodes << std::endl;
       std::cout << "Optimizer: " << settings.optimizer << std::endl;
       std::cout << "Optimize Outer Wall: " << (settings.optimizeOuterwall ? "Yes" : "No") << std::endl;
   
       if (settings.layersToOptimize && !settings.layersToOptimize->empty()) {
           std::cout << "\nLayers to Optimize:" << std::endl;
           for (const auto& range : *settings.layersToOptimize) {
               std::cout << "  From layer " << range.fromLayer << " to layer " << range.toLayer << std::endl;
           }
       }
   }

4. Put it all together

   Combine all the steps and run the example.

   TypeScript

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

   Python

   if __name__ == "__main__":
       async def main():
           settings = await get_optimization_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_optimization_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 = getOptimizationDefaults(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
   ./OptimizationDefaultsExample

Using Default Settings with an Optimization

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

TypeScript

import { CreateOptimizationDocument } from "./mutations/__generated/CreateOptimization.generated";

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

// Then create an optimization with some overrides
const { data } = await client.mutate({
  mutation: CreateOptimizationDocument,
  variables: {
    input: {
      gcodeId: GCODE_ID,
      name: "my-optimization",
      optimizationSettings: {
        // Use custom layer range instead of default
        layersToOptimize: [{ fromLayer: 1, toLayer: 50 }],
        // Override max velocity
        maxVelocity: defaults.maxVelocity * 0.8,
        // Keep other defaults by not specifying them
      },
    },
  },
});

Python

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

# Then create an optimization with some overrides
result = await graphql_client.create_optimization(
    input={
        "gcodeId": GCODE_ID,
        "name": "my-optimization",
        "optimizationSettings": {
            # Use custom layer range instead of default
            "layersToOptimize": [{"fromLayer": 1, "toLayer": 50}],
            # Override max velocity
            "maxVelocity": defaults.max_velocity * 0.8,
            # Keep other defaults by not specifying them
        },
    }
)

Rust

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

// Then create an optimization with some overrides
let variables = create_optimization::Variables {
    input: create_optimization::CreateOptimizationInput {
        gcode_id: gcode_id.to_string(),
        name: "my-optimization".to_string(),
        optimization_settings: Some(create_optimization::OptimizationSettingsInput {
            // Use custom layer range instead of default
            layers_to_optimize: Some(vec![create_optimization::LayerRangeInput {
                from_layer: 1,
                to_layer: 50,
            }]),
            // Override max velocity
            max_velocity: Some(defaults.max_velocity * 0.8),
            // Keep other defaults by not specifying them
            min_velocity: None,
            tolerance: None,
            max_iterations: None,
            optimizer: None,
            optimize_outerwall: None,
            residual_strategy_settings: None,
            reduction_strategy_settings: None,
        }),
        room_temperature: None,
        stabilized_air_temperature: None,
        constant_nozzle_temperature: None,
        constant_platform_temperature: None,
        constant_fan_speed: None,
    },
};

C++

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

// Then create an optimization with some overrides
const std::string query = CreateOptimization::GetRequestText();
graphql::response::Value variables = CreateOptimization::serializeVariables(
    CreateOptimization::Variables{
        .input = CreateOptimization::CreateOptimizationInput{
            .gcodeId = gcodeId,
            .name = "my-optimization",
            .optimizationSettings = CreateOptimization::OptimizationSettingsInput{
                // Use custom layer range instead of default
                .layersToOptimize = std::vector<CreateOptimization::LayerRangeInput>{
                    CreateOptimization::LayerRangeInput{.fromLayer = 1, .toLayer = 50}
                },
                // Override max velocity
                .maxVelocity = defaults.maxVelocity * 0.8
                // Keep other defaults by not specifying them
            }
        }
    }
);

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

Tip

Querying the defaults before running an optimization helps you understand the bounds of the optimization and make informed decisions about which parameters to override for your specific use case.