In SIMOUT mode, your simulator must return one line per evaluated point, with:

• NINPUTS real values (input variables)
• NOUTPUTS real values (output results)
• All values must be space-separated

Each line should contain NINPUTS + NOUTPUTS real numbers. ALAMO reads these lines from the output file to match simulation points with their results.

Yes, ALAMO can work with Python-based data or simulators. You will need to create a Python wrapper script that:

• Reads input points from input.txt
• Runs your Python code or simulator
• Writes results to output.txt

Example scripts are available in the examples folder of your ALAMO installation (e.g., batpython/e1.py) and can be adapted to your setup.

Yes, you can use Aspen or GAMS with ALAMO by calling them from a wrapper script. The wrapper can be written in Python, Fortran, C, bash, or batch and should:

1. Read input points from input.txt
2. Use a system call to run the Aspen or GAMS executable
3. Write simulation results to output.txt

This setup allows ALAMO to interface with almost any simulator that can be executed from the command line.

You do not need to manually split your data when using ALAMO. Unlike other modeling techniques—such as neural networks—that require separate training, validation, and testing sets, ALAMO uses information criteria (e.g., BIC, AIC) that are mathematically equivalent to leave-one-out cross-validation.

This means:

• No separate test set is required
• All your data can be used for model building
• Fewer measurements are needed compared to methods like neural networks

This makes ALAMO especially efficient when working with limited data.

You cannot directly set NINPUTS in the GUI. It is not required—once you specify NOUTPUTS, ALAMO automatically calculates NINPUTS by subtracting NOUTPUTS from the total number of columns in your spreadsheet.

INITIALPOINTS defines the total number of data points available before model building begins. It is used with:

• NDATA – Number of pre-existing measurements provided by the user
• NSAMPLE – Number of points ALAMO should generate through sampling

Behavior depends on whether INITIALPOINTS is specified:

• If INITIALPOINTS is declared, ALAMO sets NSAMPLE = INITIALPOINTS - NDATA (ignoring any provided NSAMPLE value).
• If INITIALPOINTS is not declared, ALAMO sets INITIALPOINTS = NDATA + NSAMPLE.

This lets you control how much data is available before model training begins.

While ALAMO does not require data splitting, it provides options if you want to separate data for testing or prediction:

• NPREDDATA – Specifies points used only for prediction, not model training.
• NVALSETS and NVALDATA – Define validation sets to test model performance.

These options let you assess predictions on selected data without impacting model training.

The options under the RUN tab depend on your modeling goals. Here is a general guidance:

• Enable Adaptive Sampling – Select if you want ALAMO to iteratively sample new data points to improve model accuracy.

• Use Simulator – Check this if you are linking ALAMO to an external simulator for data generation.

• Save Surrogate Model – Select if you want to export the final model for reuse or analysis.

• Cross Validation – Useful if you want to evaluate model performance using subsets of the data.

For detailed configuration, refer to the demos here and here. You can also see a demo through the Python interface in this tutorial (starting at about 17:37). For a complete description of all the options, please see the ALAMO User Manual.

To get technical support, email info@minlp.com. Please include a screenshot of any warning or error messages you are receiving. This will help our technical team investigate the issue and provide more accurate assistance.

BARON uses a branch-and-reduce algorithm, which it pioneered in the 1990s, to solve MINLP problems to global optimality. This approach combines techniques like branch-and-bound, convex relaxations, and domain reduction to systematically eliminate regions of the search space that cannot contain the global optimum.

BARON's algorithmic innovations have set the standard in global optimization, and many other solvers have since followed its approach.

For a deeper explanation of the methods behind BARON, visit our BARON Publications page.

BARON proves infeasibility only when a valid relaxation—such as a linear, integer, or convex nonlinear relaxation—is infeasible. It does not rely on local solutions of nonconvex subproblems or solver timeouts, as these do not provide formal infeasibility certificates.

Most infeasibility proofs come from infeasible LP relaxations or infeasibilities identified through constraint propagation. BARON includes safeguards to ensure that its solvers do not make false infeasibility claims, maintaining the rigor of its global infeasibility results.

There is no fixed limit on the size of problems BARON can solve. Its ability to handle large-scale models depends on the structure and complexity of the problem, not just the number of variables or constraints.

BARON has successfully solved problems with hundreds of thousands of variables and constraints, especially when the model is well-structured. It uses dynamic memory allocation and will notify the user if a problem exceeds the available hardware resources.

Yes, BARON supports parallel computing when solving MINLPs that include integer variables. During the lower bounding step of its algorithm, BARON can run solvers like CPLEX or CBC in parallel mode, automatically utilizing multiple CPU cores to improve performance.

Yes. As long as your objective function and constraints are provided in algebraic form, BARON can solve MINLP problems that include linear inequality constraints. To see examples, visit the BARON Downloads page.

Yes, during its search for the global optimum, BARON may identify multiple local optima. It reports all improving local optima in the screen log and results file, and at the end of the run, returns the best local optimum found.

Yes, BARON can solve problems with many mixed-integer or binary variables and nonlinear (including quadratic) objective functions. Its global optimization algorithms are designed for exactly this type of problem.

However, whether BARON can solve a specific problem efficiently depends on the structure and difficulty of the model, not just its size.

No, BARON requires algebraic expressions for both the objective function and constraints. It cannot be used for problems where evaluations rely on external simulators or models without explicit equations. This applies across all modeling languages, including Pyomo and MATLAB.

However, The Optimization Firm is planning to offer a separate tool for black-box (derivative-free) optimization in the future.

BARON writes temporary files during execution using default filenames, unless specified otherwise. You can control file names and locations using BARON’s output and file name options (see Section 7.6 in the BARON manual).

No, BARON does not provide tools for converting problem formulations to other formats like AMPL or GAMS.

To view BARON’s progress in real time, use the tee=True option in your solve command. To keep all temporary files generated during the run, also include keepfiles=True. For example:

results = SolverFactory('baron').solve(model, tee=True, keepfiles=True, options={'MaxTime': 1000})

If you want BARON to return multiple feasible solutions (with increased computational time), see the NumSol option in the user manual.

You can pass BARON options using the options keyword in the solve method. For example, to set a time limit of 1000 seconds:

results = SolverFactory('baron').solve(model, options={'MaxTime': 1000})

You can use this method to set any option listed in the BARON User Manual.

Pyomo supports passing starting points to solvers, including BARON. To do this, assign .value attributes to your model variables before calling the solver. BARON does not require starting values for all variables—you can specify only those you want to initialize. Pyomo will automatically include these values when generating the BARON input file.

Set the ProName option in your model:

model = Model(() -> BARON.Optimizer(ProName = "PATH_TO/MY_FILE.bar"))

This saves the .bar file to the specified path and prevents it from being deleted.