Example Scripts to Automate Simulations

  private void solverSettings(Simulation simX) {

    Simulation sim_1 = getActiveSimulation();
    for (int i=1; i<=3; i++) {
	  sim_1.saveState("Case_" + i + ".sim");
      
      ...
      
      StepStoppingCriterion stopCrit = (StepStoppingCriterion) 
        sim_1.getSolverStoppingCriterionManager()
        .getSolverStoppingCriterion("Maximum Steps");

      //Get max stopping criteria number and add additional iteration steps
      IntegerValue iter_count = stopCrit.getMaximumNumberStepsObject();
      double j = iter_count.getQuantity().getValue();
      iter_count.getQuantity().setValue(j);

      sim_1.getSimulationIterator().run();
    }
    // Save final sim file and exit
    sim_1.saveState("Case_" + i + "_Full.sim");
  }
}

public class CreateMassBalanceMonitor {
    Simulation sim = getActiveSimulation();
    // Obtain the region object
    Region region = sim.getRegionManager().getRegion(Region_Name);

    // Create mass flow monitors for all inlets and outlets
    MassFlowReport mass_flow_report_1 = sim.getReportManager()
      .createReport(MassFlowReport.class);
    mass_flow_report_1.setPresentationName("MF_inlets");

    MassFlowReport mass_flow_report_2 = sim.getReportManager()
      .createReport(MassFlowReport.class);
    mass_flow_report_2.setPresentationName("MF_outlets");

    for (Boundary boundary : region.getBoundaryManager().getBoundaries()) {
      if (boundary.getBoundaryType() instanceof InletBoundary) {
        mass_flow_report_1.getParts().addObjects(boundary);
      } else if (boundary.getBoundaryType() instanceof OutletBoundary) {
        mass_flow_report_2.getParts().addObjects(boundary);
      }
    }
    // Calculate mass balance
    ExpressionReport massBalanceReport = sim.getReportManager()
      .createReport(ExpressionReport.class);
    massBalanceReport.setPresentationName("Mass_Balance");
    massBalanceReport.setDefinition(
      "${MF_inlets.Report} - ${MF_outlets.Report}"
    );
    // Optional: Adding these reports to scalar and XY plots
    MonitorPlot massFlowRatePlot = sim.getPlotManager().createMonitorPlot();
    massFlowRatePlot.setPresentationName("Mass Flow Rate Plot");
    massFlowRatePlot.getMonitorManager().addObjects(massFlowRateReportInlet, 
      massFlowRateReportOutlet);

    MonitorPlot massBalancePlot = sim.getPlotManager().createMonitorPlot();
    massBalancePlot.setPresentationName("Mass Balance Plot");
    massBalancePlot.getMonitorManager().addObjects(massBalanceReport);
  }
}

  private void generateReports(Simulation simX) {
    String rept_file = "Rep_Output.txt";
    PrintWriter out_file = new PrintWriter(new FileWriter(new File(resolvePath(rept_file))));
    Collection <Report> report_list = simX.getReportManager().getObjects();
    Iterator<Integer> rep_counter = report_list.iterator();
    while (rep_counter.hasNext()) {
      String report_name  = report_list.next().getPresentationName();
      double report_value = report_list.next().getReportMonitorValue();
      String report_units = report_list.next().getUnits().GetPresentationName();
      System.out.println(report_name + " has value " + report_value + " " 
        + report_units(); 
    }
  }

  private void saveReptPlots(Simulation simX) {
    String sep = System.getProperty("file.separator");
    for (StarPlot p : simX.getPlotManager().getObjects()) {
      simX.println("Data exported for plot: " + p.getPresentationName());
      p.export(simX.getSessionDir() + sep + p.getPresentationName() + ".csv", ",");
    }
  }

import star.common.*;
import star.vis.*;
import java.io.File;
import java.util.Scanner; 

public class ExportScenesAndPlots extends StarMacro {
  public void execute() {
    Simulation sim = getActiveSimulation();
    
    //get the name of the simulation's directory
    String dir = sim.getSessionDir(); 
    //get the right separator for your operative system
    String sep = System.getProperty("file.separator");
    File resultFolder = new File(dir + "\\" + sim + "_Results");
    resultFolder.mkdir();

    File sceneFolder = new File(resultFolder + "\\Scenes");
    sceneFolder.mkdir();
    File plotFolder = new File(resultFolder + "\\Plots");
    plotFolder.mkdir();
    
    for (Scene scn: sim.getSceneManager().getScenes()) {
      sim.println("Saving Scene: " + scn.getPresentationName());
      scn.printAndWait(resolvePath(sceneFolder + sep + scn.getPresentationName() + ".jpg"), 1,800,450);	
    }
    for (StarPlot plt : sim.getPlotManager().getObjects()) {
      sim.println("Saving Plot: " + plt.getPresentationName());
      plt.encode(resolvePath(plotFolder + sep + plt.getPresentationName() + ".jpg"), "jpg", 800, 450);
    }
  }
}

public class printMatProps extends StarMacro { 
  public void execute() {
    Simulation sim = getActiveSimulation(); 
    Collection<Material> materials = sim.get(MaterialManager.class).getObjects(); 
    for (Material mat : materials) { 
      String matName = mat.getPresentationName(); 
      System.out.println("Material: " + matName); 
      
      Collection<MaterialProperty> properties = mat.getMaterialProperties(); 
      for (MaterialProperty property : properties) { 
        String propertyName = property.getPresentationName(); 
        double propertyValue = property.getValue(); 
        System.out.println(" Property: " + propertyName + ", Value: " + propertyValue); 
      } 
    } 
  } 
}

public class CreateHistograms extends StarMacro {
  public void execute() {
    createHistogramsMeshQuality("CellQuality");
    createHistogramsMeshQuality("Skewness");
  }
  private void createHistogramsMeshQuality(String quality_type) {
    Simulation sim = getActiveSimulation();
    
    RegionManager regionManager = sim.getRegionManager();
    Collection<Region> allRegions = regionManager.getRegions();
    List<Region> solidRegions = new ArrayList<>();
    List<Region> fluidRegions = new ArrayList<>();
    for (Region region : allRegions) {
      // Check if region contains solid cells
      if (region.getInterfaceBoundaryManager().getInterfaceBoundaries().size() > 0) {
        solidRegions.add(region);
      } else {
        fluidRegions.add(region);
      }
    }
    // Define the cell quality scalar field function
    PrimitiveFieldFunction cellQualityFunction = 
      (PrimitiveFieldFunction) sim.getFieldFunctionManager().getFunction(quality_type);

    // Create histograms for solid regions
    for (Region solidRegion : solidRegions) {
      createHistogram(sim, solidRegion, cellQualityFunction, 
        solidRegion.getPresentationName() + " " + quality_type + " Histogram";
    }
    // Create histograms for fluid regions
    for (Region fluidRegion : fluidRegions) {
      createHistogram(sim, fluidRegion, cellQualityFunction, 
        fluidRegion.getPresentationName() + " " + quality_type + " Histogram";
    }
  }
  private void createHistogram(Simulation sim, Region region, 
                 PrimitiveFieldFunction function, String plotName) {
    // Create histogram report
    HistogramReport histogramReport = sim.getReportManager()
      .createReport(HistogramReport.class);
    histogramReport.setFieldFunction(function);
    histogramReport.getParts().setObjects(region);
    histogramReport.setPresentationName(plotName);

    // Create and display the plot
    ReportPlot histogramPlot = sim.getPlotManager().createReportPlot(histogramReport);
    histogramPlot.open();
  }
}

  public void execute() {
    // Specify the point through which the planes pass and field function and range
    double[] point = {0.0, 0.0, 0.0}; 
    double[] v_range = {0.0, 10.0};
    double[] p_range = {1000, 1E6};
    double[] t_range = {300, 400};
    String scalarFieldFunctionName = "VelocityMagnitude"; 
    createScalarSceneOnPlane("X", point, "Pressure", p_range);
    createScalarSceneOnPlane("Y", point, "Temperature", t_range);
    createScalarSceneOnPlane("Z", point, "Velocity", v_range);
  }
  private void createScalarSceneOnPlane(String planeAxis, double[] point, 
    String scalarFF, double[] scalarRange) {
    Simulation sim = getActiveSimulation();
    
    ScalarScene scalarScene = sim.getSceneManager().createScalarScene("Scalar Scene", "Scalar Scene");
    scalarScene.initializeAndWait();
    FieldFunction scalarFieldFunction = sim.getFieldFunctionManager().getFunction(scalarFF);
    scalarScene.getDisplayerManager().getScalarDisplayers().get(0)
      .getScalarDisplayQuantity().setFieldFunction(scalarFieldFunction);

    // Set the number of color bands to 11
    scalarScene.getDisplayerManager().getScalarDisplayers().get(0)
      .getScalarDisplayQuantity().getColorMap().setNumberOfColors(11);
    scalarScene.getDisplayerManager().getScalarDisplayers().get(0)
      .getScalarDisplayQuantity().setRange(scalarRange);

    // Create and set plane section
    PlaneSection planeSection = (PlaneSection) sim.getPartManager().createImplicitPart(new 
      NeoObjectVector(new Object[] {}), new NeoObjectVector(new Object[] {}), "PlaneSection", 0, 0, 0, 0);
    planeSection.getInputParts().setObjects(sim.getRegionManager().getRegions());
    planeSection.getOriginCoordinate().setCoordinate(point[0], point[1], point[2]);

    // Set plane normal based on the specified axis
    if (planeAxis.equalsIgnoreCase("X")) {
      planeSection.getOrientationCoordinate().setCoordinate(1, 0, 0);
    } else if (planeAxis.equalsIgnoreCase("Y")) {
      planeSection.getOrientationCoordinate().setCoordinate(0, 1, 0);
    } else if (planeAxis.equalsIgnoreCase("Z")) {
      planeSection.getOrientationCoordinate().setCoordinate(0, 0, 1);
    }

    // Add plane section to scalar scene
    scalarScene.getDisplayerManager().getPartDisplayer("Scalar Scene 1")
      .getInputParts().setObjects(planeSection);

    // Align view perpendicular to the plane and zoom to fit window (reset camera)
    if (planeAxis.equalsIgnoreCase("X")) {
      scalarScene.open(true);
      scalarScene.resetCamera();
      scalarScene.getViewManager().getAxesOrientation().setCoordinateSystemView(
        scalarScene.getActiveCamera(), CoordinateSystemViewType.XY);
    } else if (planeAxis.equalsIgnoreCase("Y")) {
      scalarScene.open(true);
      scalarScene.resetCamera();
      scalarScene.getViewManager().getAxesOrientation().setCoordinateSystemView(
        scalarScene.getActiveCamera(), CoordinateSystemViewType.YZ);
    } else if (planeAxis.equalsIgnoreCase("Z")) {
      scalarScene.open(true);
      scalarScene.resetCamera();
      scalarScene.getViewManager().getAxesOrientation().setCoordinateSystemView(
        scalarScene.getActiveCamera(), CoordinateSystemViewType.ZX);
    }
    String file_name = scalarFF + "_" + planeAxis + "_"+ point[0] + "_"point[1] +
      "_" + point[2] + ".png";
    scalarScene.printAndWait(resolvePath(file_name), 1, 800, 600);
    scalarScene.close();
  }

public class ProcessSimFiles {

  public static void main(String[] args) {
    // Folder containing the *.sim files
    File folder = new File("E:/CFD_Projects");
    String b_inlet = "inlet;
    
    // List all .sim files in the folder
    File[] files = folder.listFiles((dir, name)->name.toLowerCase().endsWith(".sim"));
    if (files == null || files.length == 0) {
      System.out.println("No .sim files found.");
      return;
    }
    Simulation sim = getActiveSimulation();
    for (File f : files) {
      postProcesSim(sim, f, b_inlet);
    }
  }
  private static void postProcesSim(Simulation sim, File file, String bnd_name) {
    ...
  }
}

public void CreateAnimation (Simulation sim, double fps, Scene sc_name, String field_var) {
  
  // Set up the time steps for the animation
  SolutionHistory solutionHistory = (SolutionHistory) sim.get(SolutionHistoryManager.class)
    .getObjects().iterator().next();
  RecordedSolutionView recordedSolutionView = solutionHistory.getRecordedSolutionViewManager().createView();
  recordedSolutionView.setMode(RecordedSolutionViewMode.DISPLAY_EVERY_STEP);
  
  // Create an animation from the recorded solution view
  Animation animation = 
    (Animation) sim.getRepresentationManager().createRepresentation(Animation.class, "Animation", "");
  animation.setFramesFromView(recordedSolutionView);
  
  // Set the scalar scene for the animation
  Scene scene = sim.getSceneManager().getScenes().get(sc_name);
  ScalarDisplayer scalarDisplayer = 
    (ScalarDisplayer) scene.getDisplayerManager().getDisplayer(field_var);
  scalarDisplayer.setRepresentation(animation);
  
  // Set the animation properties
  animation.setFramesPerSecond(fps);
  animation.setStartFrame(0);
  animation.setEndFrame(recordedSolutionView.getLastFrame());
  
  // Export the animation as a video
  File animationFile = new File("STAR-animation.mp4");
  File exportFile = new File(animationFile.getAbsolutePath());
  sim.getAnimationExporterManager().exportVideo(animation, exportFile, "mp4");
  }
}

public void SweepAnimation (Simulation sim, Scene sc_name, double fps, double z0,
  double zn, double dz) {   
  // Create a new XY-Plane section at origin
  PartManager partManager = simulation.getPartManager();
  plane_xy plane_xy = (plane_xy) partManager.createImplicitPart(new NeoObjectVector(
    new Object[]{}), new DoubleVector(new double[]{0.0, 0.0, 1.0}), 
    new DoubleVector(new double[]{0.0, 0.0, 0.0}));
  plane_xy.getOrientationCoordinate().setCoordinate(new DoubleVector(new double[] {0.0, 0.0, 1.0}));
  plane_xy.getPositionCoordinate().setCoordinate(new DoubleVector(new double[] {0.0, 0.0, 0.0}));
  plane_xy.getInputParts().setQuery(null);
  
  // Add the plane section to the scene and set the displayer
  sc_name.setInputParts(new NeoObjectVector(new Object[] {plane_xy}));
  sc_name.open();
  ScalarDisplayer scalarDisplayer = sc_name.getDisplayerManager()
    .createDisplayer(ScalarDisplayer.class);
  scalarDisplayer.getInputParts().setQuery(null);
  scalarDisplayer.getInputParts().setObjects(plane_xy);
  
  // Set up the animation properties
  Animation animation = simulation.getRepresentationManager().createRepresentation(
    Animation.class, "Sweep Animation", "");
  animation.setFramesPerSecond(fps);
  
  // Loop through the range and update plane position
  for (double zp = z0; zp <= zn; zp += dz) {
    plane_xy.getPositionCoordinate().setCoordinate(new DoubleVector(new double[] {0.0, 0.0, zp}));
    sc_name.printAndWait();
    animation.addFrame(scene);
  }
  // Export the animation as a video
  File animationFile = new File("sweep_animation.mp4");
  File exportFile = new File(animationFile.getAbsolutePath());
  simulation.getAnimationExporterManager().exportVideo(animation, exportFile, "mp4");
  }
}