111 batch running features gpu runner

coretrace/CMakeLists.txt

@@ -58,7 +58,6 @@ set(CORETRACE_SRC
 	treemesh.cpp
 	types.cpp
 	vshot.cpp
-
 	simdata_bridge.cpp
 )
 

coretrace/simdriver/main.cpp

@@ -2,21 +2,26 @@
  * @file main.cpp
  * @brief Command-line driver for SolTrace ray tracing.
  *
- * Reads a JSON file to configure SimulationData, runs the ray tracer,
+ * Reads a JSON or .stinput file to configure SimulationData, runs the ray tracer,
  * and writes the ray interaction records to a CSV file.
  *
  * Usage:
- *   simdriver <input.json> <output.csv> [options]
+ *   simdriver <input.json|input.stinput> [<output.csv>] [options]
  *
  * Options:
  *   --threads <n>   Number of parallel threads (default: 1)
  *   --rays <n>      Override the number of rays from the JSON file
+ *   --no-output     Skip result retrieval and CSV output (output file not
+ *                   required when this flag is set)
+ *   --no-csv        Retrieve results but skip writing the CSV file (output
+ *                   file argument not required when this flag is set)
  *   --embree        Use the Embree runner (only available if built with
  *                   SOLTRACE_BUILD_EMBREE_SUPPORT=ON; falls back to native
  *                   runner with a warning if Embree support is absent)
  *   --optix         Use the OptiX runner (only available if built with
  *                   SOLTRACE_BUILD_OPTIX_SUPPORT=ON; falls back to native
  *                   runner with a warning if OptiX support is absent)
+ *   --verbose       Enable verbose logging in the OptiX runner
  */
 
 #include <cstdlib>
@@ -47,11 +52,15 @@ using SolTrace::Runner::RunnerStatus;
 static void print_usage(const char *prog)
 {
     std::cerr
-        << "Usage: " << prog << " <input.json> <output.csv> [options]\n"
+        << "Usage: " << prog << " <input.json|input.stinput> [<output.csv>] [options]\n"
         << "\n"
         << "Options:\n"
         << "  --threads <n>   Number of threads (default: 1)\n"
         << "  --rays <n>      Override number of rays specified in the JSON file\n"
+        << "  --no-output     Skip result retrieval and CSV output\n"
+        << "                  (output file argument not required with this flag)\n"
+        << "  --no-csv        Retrieve results but skip writing the CSV file\n"
+        << "                  (output file argument not required with this flag)\n"
 #ifdef SOLTRACE_EMBREE_SUPPORT
         << "  --embree        Use Embree runner instead of the native runner\n"
         << "                  (requires SOLTRACE_BUILD_EMBREE_SUPPORT=ON at build time)\n"
@@ -60,26 +69,54 @@ static void print_usage(const char *prog)
         << "  --optix         Use OptiX runner instead of the native runner\n"
         << "                  (requires SOLTRACE_BUILD_OPTIX_SUPPORT=ON at build time)\n"
 #endif
+        << "  --verbose       Enable verbose logging in the OptiX runner\n"
         ;
 }
 
 int main(int argc, char *argv[])
 {
-    if (argc < 3)
+    if (argc < 2)
     {
         print_usage(argv[0]);
         return EXIT_FAILURE;
     }
 
+    // Pre-scan for --no-output and --no-csv so we know whether output_file is required
+    bool skip_output = false;
+    bool skip_csv = false;
+    for (int i = 2; i < argc; ++i)
+    {
+        const std::string a = argv[i];
+        if (a == "--no-output") skip_output = true;
+        else if (a == "--no-csv") skip_csv = true;
+    }
+
+    const bool file_optional = skip_output || skip_csv;
+
     const std::string input_file = argv[1];
-    const std::string output_file = argv[2];
+
+    // argv[2], if present and not a flag (does not start with --), is treated as
+    // the output file path.  This allows the user to supply an output path even
+    // when --no-output or --no-csv is also present without it being mis-parsed
+    // as an unknown option.
+    const bool has_output_arg = (argc >= 3) && (std::string(argv[2]).rfind("--", 0) != 0);
+    const std::string output_file = has_output_arg ? argv[2] : "";
+    const int opts_start = has_output_arg ? 3 : 2;
+
+    if (!file_optional && !has_output_arg)
+    {
+        std::cerr << "Error: output file is required unless --no-output or --no-csv is specified\n";
+        print_usage(argv[0]);
+        return EXIT_FAILURE;
+    }
 
     int num_threads = 1;
     long long num_rays_override = -1; // -1 means use what the JSON specifies
     bool use_embree = false;
     bool use_optix = false;
+    bool verbose = false;
 
-    for (int i = 3; i < argc; ++i)
+    for (int i = opts_start; i < argc; ++i)
     {
         const std::string arg = argv[i];
         if (arg == "--threads")
@@ -126,6 +163,10 @@ int main(int argc, char *argv[])
                 return EXIT_FAILURE;
             }
         }
+        else if (arg == "--no-output" || arg == "--no-csv")
+        {
+            // already handled in pre-scan; skip here
+        }
         else if (arg == "--embree")
         {
             use_embree = true;
@@ -134,6 +175,10 @@ int main(int argc, char *argv[])
         {
             use_optix = true;
         }
+        else if (arg == "--verbose")
+        {
+            verbose = true;
+        }
         else
         {
             std::cerr << "Error: unknown option '" << arg << "'\n";
@@ -143,23 +188,55 @@ int main(int argc, char *argv[])
     }
 
     // -------------------------------------------------------------------------
-    // Load simulation data from JSON
+    // Load simulation data from JSON or .stinput file
     // -------------------------------------------------------------------------
     SimulationData simData;
-    try
     {
+        // Determine format by extension
+        auto ends_with = [](const std::string &s, const std::string &suffix)
+        {
+            return s.size() >= suffix.size() &&
+                   s.compare(s.size() - suffix.size(), suffix.size(), suffix) == 0;
+        };
+        const bool is_stinput = ends_with(input_file, ".stinput");
+        const bool is_json = ends_with(input_file, ".json");
+
+        if (!is_stinput && !is_json)
+        {
+            std::cerr << "Error: unrecognised input file extension (expected .json or .stinput): "
+                      << input_file << "\n";
+            return EXIT_FAILURE;
+        }
+
         std::cout << "Loading simulation data from: " << input_file << "...\n";
         auto t_load_start = std::chrono::steady_clock::now();
-        simData.import_json_file(input_file);
+
+        if (is_json)
+        {
+            try
+            {
+                simData.import_json_file(input_file);
+            }
+            catch (const std::exception &e)
+            {
+                std::cerr << "Error loading JSON file: " << e.what() << "\n";
+                return EXIT_FAILURE;
+            }
+        }
+        else // .stinput
+        {
+            if (!simData.import_from_file(input_file))
+            {
+                std::cerr << "Error loading .stinput file: " << input_file << "\n";
+                return EXIT_FAILURE;
+            }
+        }
+
         auto t_load_end = std::chrono::steady_clock::now();
         std::cout << "  Loaded in "
                   << std::chrono::duration<double>(t_load_end - t_load_start).count()
-                  << " s\n";
-    }
-    catch (const std::exception &e)
-    {
-        std::cerr << "Error loading JSON file: " << e.what() << "\n";
-        return EXIT_FAILURE;
+                  << " s\n"
+                  << "  Elements loaded: " << simData.get_number_of_elements() << "\n";
     }
 
     // Override ray count if the user requested it
@@ -217,24 +294,33 @@ int main(int argc, char *argv[])
         std::cout << "  Completed in "
                   << std::chrono::duration<double>(t_run_end - t_run_start).count()
                   << " s\n";
+        std::cout << "  Rays launched: " << runner.get_number_rays_launched() << "\n";
+        std::cout << "  Rays traced:   " << runner.get_number_rays_traced() << "\n";
 
-        std::cout << "Retrieving results...\n";
-        auto t_report_start = std::chrono::steady_clock::now();
-        sts = runner.report_simulation(&result, 0);
-        auto t_report_end = std::chrono::steady_clock::now();
-        if (sts != RunnerStatus::SUCCESS)
+        if (!skip_output)
         {
-            std::cerr << "Error: failed to collect simulation results\n";
-            return EXIT_FAILURE;
+            std::cout << "Retrieving results...\n";
+            auto t_report_start = std::chrono::steady_clock::now();
+            sts = runner.report_simulation(&result, 0);
+            auto t_report_end = std::chrono::steady_clock::now();
+            if (sts != RunnerStatus::SUCCESS)
+            {
+                std::cerr << "Error: failed to collect simulation results\n";
+                return EXIT_FAILURE;
+            }
+            std::cout << "  Retrieved in "
+                      << std::chrono::duration<double>(t_report_end - t_report_start).count()
+                      << " s\n";
+        }
+        else
+        {
+            std::cout << "Skipping result retrieval (--no-output).\n";
         }
-        std::cout << "  Retrieved in "
-                  << std::chrono::duration<double>(t_report_end - t_report_start).count()
-                  << " s\n";
     }
     else
 #endif
 #ifdef SOLTRACE_OPTIX_SUPPORT
-    if (use_optix)
+        if (use_optix)
     {
         OptixRunner runner;
 
@@ -245,6 +331,8 @@ int main(int argc, char *argv[])
             return EXIT_FAILURE;
         }
 
+        runner.set_verbose(verbose);
+
         std::cout << "Using OptiX runner\n";
 
         std::cout << "Setting up simulation...\n";
@@ -272,19 +360,33 @@ int main(int argc, char *argv[])
         std::cout << "  Completed in "
                   << std::chrono::duration<double>(t_run_end - t_run_start).count()
                   << " s\n";
+        std::cout << "  Rays launched: " << runner.get_number_rays_launched() << "\n";
+        std::cout << "  Rays traced:   " << runner.get_number_rays_traced() << "\n";
 
-        std::cout << "Retrieving results...\n";
-        auto t_report_start = std::chrono::steady_clock::now();
-        sts = runner.report_simulation(&result, 0);
-        auto t_report_end = std::chrono::steady_clock::now();
-        if (sts != RunnerStatus::SUCCESS)
+        if (!skip_output)
         {
-            std::cerr << "Error: failed to collect simulation results\n";
-            return EXIT_FAILURE;
+            std::cout << "Retrieving results...\n";
+            auto t_report_start = std::chrono::steady_clock::now();
+            sts = runner.report_simulation(&result, 0);
+            auto t_report_end = std::chrono::steady_clock::now();
+            if (sts != RunnerStatus::SUCCESS)
+            {
+                std::cerr << "Error: failed to collect simulation results\n";
+                return EXIT_FAILURE;
+            }
+            std::cout << "  Retrieved in "
+                      << std::chrono::duration<double>(t_report_end - t_report_start).count()
+                      << " s\n";
+        }
+        else
+        {
+            std::cout << "Skipping result retrieval (--no-output).\n";
+        }
+
+        if (!verbose)
+        {
+            runner.print_timing();
         }
-        std::cout << "  Retrieved in "
-                  << std::chrono::duration<double>(t_report_end - t_report_start).count()
-                  << " s\n";
     }
     else
 #endif
@@ -341,39 +443,59 @@ int main(int argc, char *argv[])
         std::cout << "  Completed in "
                   << std::chrono::duration<double>(t_run_end - t_run_start).count()
                   << " s\n";
+        std::cout << "  Rays launched: " << runner.get_number_rays_launched() << "\n";
+        std::cout << "  Rays traced:   " << runner.get_number_rays_traced() << "\n";
 
-        std::cout << "Retrieving results...\n";
-        auto t_report_start = std::chrono::steady_clock::now();
-        sts = runner.report_simulation(&result, 0);
-        auto t_report_end = std::chrono::steady_clock::now();
-        if (sts != RunnerStatus::SUCCESS)
+        if (!skip_output)
         {
-            std::cerr << "Error: failed to collect simulation results\n";
-            return EXIT_FAILURE;
+            std::cout << "Retrieving results...\n";
+            auto t_report_start = std::chrono::steady_clock::now();
+            sts = runner.report_simulation(&result, 0);
+            auto t_report_end = std::chrono::steady_clock::now();
+            if (sts != RunnerStatus::SUCCESS)
+            {
+                std::cerr << "Error: failed to collect simulation results\n";
+                return EXIT_FAILURE;
+            }
+            std::cout << "  Retrieved in "
+                      << std::chrono::duration<double>(t_report_end - t_report_start).count()
+                      << " s\n";
+        }
+        else
+        {
+            std::cout << "Skipping result retrieval (--no-output).\n";
         }
-        std::cout << "  Retrieved in "
-                  << std::chrono::duration<double>(t_report_end - t_report_start).count()
-                  << " s\n";
     }
 
     // -------------------------------------------------------------------------
     // Write results to CSV
     // -------------------------------------------------------------------------
-    std::cout << "Writing " << result.get_number_of_records()
-              << " ray records to: " << output_file << "...\n";
-    try
+    if (!skip_output && !skip_csv)
     {
-        auto t_write_start = std::chrono::steady_clock::now();
-        result.write_csv_file(output_file);
-        auto t_write_end = std::chrono::steady_clock::now();
-        std::cout << "  Written in "
-                  << std::chrono::duration<double>(t_write_end - t_write_start).count()
-                  << " s\n";
+        std::cout << "Writing " << result.get_number_of_records()
+                  << " ray records to: " << output_file << "...\n";
+        try
+        {
+            auto t_write_start = std::chrono::steady_clock::now();
+            result.write_csv_file(output_file);
+            auto t_write_end = std::chrono::steady_clock::now();
+            std::cout << "  Written in "
+                      << std::chrono::duration<double>(t_write_end - t_write_start).count()
+                      << " s\n";
+        }
+        catch (const std::exception &e)
+        {
+            std::cerr << "Error writing CSV file: " << e.what() << "\n";
+            return EXIT_FAILURE;
+        }
     }
-    catch (const std::exception &e)
+    else if (skip_csv)
     {
-        std::cerr << "Error writing CSV file: " << e.what() << "\n";
-        return EXIT_FAILURE;
+        std::cout << "Skipping CSV output (--no-csv).\n";
+    }
+    else
+    {
+        std::cout << "Skipping CSV output (--no-output).\n";
     }
 
     std::cout << "Done.\n";

coretrace/simulation_data/simulation_parameters.hpp

@@ -21,9 +21,6 @@ struct SimulationParameters
     // TODO: Figure out how to store time...
     DateTime sim_dt;
 
-    bool include_sun_shape_errors;
-    bool include_optical_errors;
-
     std::uint_fast64_t number_of_rays;
     std::uint_fast64_t max_number_of_rays;
     double tolerance;
@@ -33,6 +30,9 @@ struct SimulationParameters
 
     int seed;
 
+    bool include_sun_shape_errors;
+    bool include_optical_errors;
+
     SimulationParameters() : number_of_rays(10000),
                              max_number_of_rays(1000000),
                              tolerance(0.0),