pSeven Core

https://www.pseven.io/product/pseven-core/manual/v2025.07/
Admin
pSeven Core is a powerful Python-based toolkit for predictive modeling, data analysis, and...
Tokens:283,978
Snippets:1,520
Trust Score:6.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Start lmadmin License Server on Linux

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/license_setup

These commands navigate to the installation directory of the FlexNet Publisher License Server (lmadmin) and then start the server process on a Linux system.

```shell
$ cd /opt/FNPLicenseServerManager
$ ./lmadmin

```

--------------------------------

### Running GTDF Example from Command Line

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtdf

Command to execute the GTDF simple example using Python's module execution. Requires the pseven-core library to be installed.

```bash
python -m da.p7core.examples.gtdf.example_gtdf_simple
```

--------------------------------

### Install pSeven Core using pip

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/install

Installs or upgrades the pSeven Core package to the latest version from PyPI using pip. Ensure Python and pip are installed and configured correctly.

```bash
python -m pip install --upgrade psevencore

```

--------------------------------

### Running Example as Module (Shell)

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Executes the example script for output variances validation using Python's module execution. This command requires the 'da.p7core.examples.gtapprox' package to be installed and accessible.

```bash
python -m da.p7core.examples.gtapprox.example_output_variances
```

--------------------------------

### Main Function for Model Export Example Setup

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Sets up the main parameters for the model export demonstration, including dimensionality, factor size for training samples, and the size of the test sample. It also defines the location for saving results.

```python
def main(main_directory = getcwd()):
  x_dim = 5
  y_dim = 1
  factor_size = 15
  test_sample_size = 50000

  results_location = path.join(main_directory, 'results')
  if access(results_location, F_OK):
    print('The results directory already exists. Will overwrite all saved files!\n')
  else:
    mkdir(results_location)

  print('Generating full-factorial training sample... \n')
  train_points = full_factorial(0, 1, factor_size, x_dim)
  train_values = data_generator(train_points)

  print('Generating random test sample... \n')
  test_points = np.random.rand(test_sample_size, x_dim)
  test_values = data_generator(test_points)

  builder = gtapprox.Builder()
  log = StreamLogger(stdout, LogLevel.DEBUG)
  builder.set_logger(log)
  options = {
    'GTApprox/LogLevel': 'ERROR',
    'GTApprox/EnableTensorFeature': 'on',
  }
  builder.options.set(options)

  print('Training the model (may take a few minutes)...')
  start_time = time()
  model = builder.build(train_points, train_values)
  print(' - training took %s seconds' % str(time() - start_time))

  #smoothing_factor = 0.1 # any value in [0, 1]
  #model = model.smooth(smoothing_factor)

  print(' - calculating prediction...\n')
  start_time = time()
  test_values_prediction = model.calc(test_points)
  eval_time_python = (time() - start_time) / test_sample_size * 1e6


```

--------------------------------

### Run pSeven Core Example as Python Module

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/introduction

Executes a pSeven Core example by calling its module path using the `python -m` command. This method is preferred as it does not require the `.py` extension and handles package structures automatically. Ensure all third-party Python modules (SciPy, pandas, Matplotlib, psutil) are installed.

```shell
python -m da.p7core.examples.gtopt.example_gtopt_ZDT1
```

--------------------------------

### Run Example Module Command

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Executes the example script as a Python module from the command line. This is a convenient way to run the example without needing to navigate to the script's directory or import it directly.

```bash
python -m da.p7core.examples.gtapprox.example_moa_discontinuous_func
```

--------------------------------

### Run GTOpt Examples

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/codesamples/gtopt

The `main` function orchestrates the execution of various GTOpt example functions, including trivial optimization, constrained problems, and stochastic problems. It prints separators and status messages to indicate the progress and completion of each example. This function serves as the entry point for running the demonstration.

```python
def main():
  """Example of GTOpt usage."""

  print('Find the minimum of function')
  print('=' * 60)
  trivial_example()
  print('=' * 60)
  print('Finished!')
  print('')

  print('Find the minimum of two functions')
  print('=' * 60)
  trivial_example_two()
  print('=' * 60)
  print('Finished!')
  print('')

  print('Find the minimum of functions with constraint')
  print('=' * 60)
  advanced_example()
  print('=' * 60)
  print('Finished!')
  print('')

  print('Find a point satisfying the constraint')
  print('=' * 60)
  constraint_example()
  print('=' * 60)
  print('Finished!')
  print('')

  print('Stochastic problem example')
  print('=' * 60)
  stochastic_example()
  print('=' * 60)
  print('Finished!')
  print('')

if __name__ == "__main__":
  main()
```

--------------------------------

### Run Example via Command Line

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Provides the command to execute the GTApprox MoA example script from the command line. This allows users to run the demonstration and see the approximation results.

```bash
python -m da.p7core.examples.gtapprox.example_moa_basic
```

--------------------------------

### Set Executable Permissions for Example Script (Linux)

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/introduction

Grants execute permissions to a downloaded pSeven Core example script on Linux systems using the `chmod` command. This is necessary if you intend to run the script directly (e.g., by double-clicking or `./example_file_name.py`), especially if pSeven Core was installed as a regular user.

```shell
chmod 744 example_file_name.py
```

--------------------------------

### Running Example as Script (Shell)

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Provides instructions to run the example script directly from the command line. This method is suitable when the script is saved as 'example_output_variances.py' in the current directory.

```bash
python example_output_variances.py
```

--------------------------------

### Run Tensor Approximation Example (Command Line)

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

This command executes the tensor approximation example script using Python's module execution. It assumes the script is located within the 'da.p7core.examples.gtapprox' package. This is a common way to run specific examples or modules without needing to know the exact file path.

```bash
python -m da.p7core.examples.gtapprox.example_tensor_approx
```

--------------------------------

### Running the GTOpt batch mode example script - Shell

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

Command to execute the GTOpt batch mode example as a Python module. This command initiates the script that demonstrates the differences between normal and batch optimization modes within the GTOpt library.

```shell
python -m da.p7core.examples.gtopt.example_gtopt_ZDT1_batch

```

--------------------------------

### Find pSeven Core Installation Directory

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/troubleshooting

This command helps locate the installation directory of the pSeven Core package. It's useful when troubleshooting `IOError: [Errno 2] No such file or directory` related to example scripts not finding data files.

```python
import da
print('\n'.join(da.__path__))
```

--------------------------------

### Run GTOpt Fitting Example from Command Line

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

This command executes the GTOpt fitting example script using Python's module execution. It requires the script to be available in the specified path. This is the primary way to run the provided example.

```shell
python -m da.p7core.examples.gtopt.example_gtopt_fitting
```

--------------------------------

### Shell Command: Run GTOpt ZDT1 Example

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

Command to execute the GTOpt ZDT1 multi-objective optimization example using the Python module. This command assumes the script is part of the p7core examples package.

```bash
python -m da.p7core.examples.gtopt.example_gtopt_ZDT1

```

--------------------------------

### Import License File on Linux Server using lmadmin

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/license_setup

This command imports the license file into the FlexNet Publisher License Server on Linux. It requires navigating to the server's installation directory and executing the 'lmadmin' utility with the '-import' flag, followed by the path to the license file.

```bash
cd /opt/FNPLicenseServerManager
./lmadmin -import licenses/datadvd/12345.lic
```

--------------------------------

### Running GTApprox Example (Python Module)

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

This command executes the example script for the GTApprox model using the Additive Gaussian Process covariance function. It is run as a Python module from the command line. Ensure the 'da' package is installed and accessible in your Python environment.

```bash
python -m da.p7core.examples.gtapprox.example_additive_gp
```

--------------------------------

### Run GT SDA Feature Selection Example Script

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtsda

Executes the example script 'example_gtsda_selector_simple.py' to demonstrate GT SDA feature selection. This script likely includes the setup for the artificial model function and the generation of training data.

```bash
python example_gtsda_selector_simple.py
```

--------------------------------

### Copy License File to Linux Server

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/license_setup

These commands create a directory for license files and then copy the license file (e.g., '12345.lic') into the appropriate location within the FlexNet Publisher License Server installation directory on Linux. The target directory is typically within 'licenses/datadvd'.

```bash
mkdir -p /opt/FNPLicenseServerManager/licenses/datadvd
cp 12345.lic /opt/FNPLicenseServerManager/licenses/datadvd
```

--------------------------------

### Running the SBO Example

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

This command provides instructions on how to execute the Python script that demonstrates Surrogate Based Optimization (SBO) using GTOpt. It specifies running the example_gtopt_SBO module via the Python interpreter.

```bash
python -m da.p7core.examples.gtopt.example_gtopt_SBO

```

--------------------------------

### Copy pSeven Vendor Daemon to Linux Server

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/license_setup

This command copies the pSeven vendor daemon, including the 'datadvd' directory and its contents, to the FlexNet Publisher License Server installation directory on a Linux system. Ensure the destination path is correct for your installation.

```bash
cp -R datadvd /opt/FNPLicenseServerManager
```

--------------------------------

### Run GTApprox Example Export to C (Command Line)

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

This command executes the GTApprox example script for exporting to C using Python's module execution functionality. It requires the 'da.p7core.examples.gtapprox.example_export_to_c' module to be accessible in the Python path. This is typically run from a command prompt or terminal.

```bash
python -m da.p7core.examples.gtapprox.example_export_to_c
```

--------------------------------

### Execute Monte Carlo Example from Command Line (Python)

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtdoe

This command demonstrates how to run the GTDoE Monte Carlo example using Python's module execution feature. It assumes the example code is located within the da.p7core.examples.gtdoe package. Running this command will execute the monteCarloIncremental function with predefined parameters and display convergence graphs.

```bash
python -m da.p7core.examples.gtdoe.example_gtdoe_montecarlo

```

--------------------------------

### Run pSeven Core Example as Python Script

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/introduction

Executes a pSeven Core example by directly running its Python script file. This method requires the `.py` extension and that any necessary data files are in the same directory. Ensure you have write access to the current working directory for plot saving. If running scripts from the package directory, copies are recommended.

```shell
python example_gtopt_ZDT1.py
```

--------------------------------

### Analytical Gradients Example in GTOpt (Python)

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/changelog

Provides a simpler example demonstrating the use of analytical gradients in GTOpt. This example, found in the Code Samples section, is intended to make it easier for users to understand and implement gradient-based optimization.

```python
from MACROS.CodeSamples import example_gtopt_gradients

# Call the example function
example_gtopt_gradients.run()

```

--------------------------------

### GTApprox Examples in Python and C

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/codesamples/index

These examples showcase the GTApprox module for surrogate modeling and approximation. They include adaptive design of experiments, generic approximation, internal validation, and axis rotations. The examples are provided in Python and C.

```python
# example_adaptive_doe.py
# This file demonstrates adaptive design of experiments with GTApprox.
```

```python
# example_gtapprox.py
# This file contains a generic example for GTApprox.
```

```python
# example_internal_validation.py
# This file demonstrates internal validation of models using GTApprox.
```

```python
# example_axis_rotations.py
# This file shows examples of axis rotations within GTApprox.
```

```c
// example_gtmodel.c
// This file contains C code for a GTModel used with GTApprox.
```

--------------------------------

### GTOpt Examples in Python

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/codesamples/index

Demonstrates various optimization scenarios using pSeven Core's GTOpt module. These examples showcase different optimization techniques and problem formulations. They are intended for users familiar with optimization concepts and pSeven Core.

```python
# example_gtopt.py
# This file contains example code for GTOpt.
```

```python
# example_gtopt_generic.py
# This file contains example code for generic GTOpt usage.
```

```python
# example_gtopt_gradients.py
# This file demonstrates GTOpt with gradient information.
```

```python
# example_gtopt_ackley_function.py
# This file shows GTOpt applied to the Ackley function.
```

```python
# example_gtopt_triangle.py
# This file contains an example of GTOpt optimization within a triangular region.
```

```python
# example_gtopt_dfo.py
# This file demonstrates Direct Function Optimization (DFO) with GTOpt.
```

```python
# example_gtopt_co.py
# This file shows an example of a Constrained Optimization (CO) using GTOpt.
```

```python
# example_gtopt_atc.py
# This file demonstrates an example for Adaptive Trust-region methods with GTOpt.
```

```python
# example_gtopt_rdo.py
# This file contains an example for Robust Design Optimization (RDO) using GTOpt.
```

```python
# example_gtopt_MOSBO.py
# This file demonstrates an example for Multi-Objective Simultaneous Bayesian Optimization (MOSBO) with GTOpt.
```

```python
# example_gtopt_co_parallel.py
# This file shows a parallel implementation of Constrained Optimization (CO) using GTOpt.
```

--------------------------------

### Run Example Script for Validity Domain

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Demonstrates how to execute a Python script named 'example_get_validity_domain.py' using the 'python -m' command. This command is used to run a module from the command line, useful for executing examples or tests within a package structure.

```shell
python -m da.p7core.examples.gtapprox.example_get_validity_domain
```

--------------------------------

### Import Modules for pSeven Core GP Example

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Imports necessary libraries for the Gaussian Process example, including numpy for numerical operations, matplotlib for plotting, and pSeven Core's gtapprox module for approximation.

```python
import os

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

from da.p7core import gtapprox
```

--------------------------------

### Python: Main Execution Block for GTSDA Selector Example

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/codesamples/gtsda

This is the main entry point for the script. It calls the 'run_example' function to execute the GTSDA Selector demonstration, printing separator lines before and after the example output for clarity.

```python
def main():
  """
  Example of GTSDA Selector usage.
  """
  print('=' * 60)
  run_example()
  print('=' * 60)

if __name__ == "__main__":
  main()
```

--------------------------------

### Configure and Run GTOpt Solver with Watcher

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

Sets up and runs the GTOpt solver with the custom watcher. An instance of `gtopt.Solver` is created, the custom `IntermediateResult` watcher is set using `set_watcher()`, and the optimization is started with specified options, including a maximum number of expensive iterations.

```python
optimizer = gtopt.Solver()
optimizer.set_watcher(IntermediateResult())
result = optimizer.solve(faf(), options={"GTopt/MaximumExpensiveIterations": 200})
```

--------------------------------

### GTDoE Examples in Python

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/codesamples/index

These Python examples showcase the GTDoE module for Design of Experiments. They cover multi-dimensional factors, adaptive grid strategies, and level specifications, providing practical illustrations for setting up and running DOE studies.

```python
# example_gtdoe.py
# This file contains a generic example for GTDoE.
```

```python
# example_gtdoe_multidim_factors.py
# This file demonstrates GTDoE with multi-dimensional factors.
```

```python
# example_gtdoe_adaptive_grid.py
# This file shows GTDoE with an adaptive grid strategy.
```

```python
# example_gtdoe_levels.py
# This file demonstrates GTDoE with specified factor levels.
```

--------------------------------

### Advanced Python Example

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/toc

A Python script demonstrating the joint usage of multiple PSeven Core modules. This example highlights how different components of the library can be combined to solve complex problems.

```python
# example_joint_usage.py
# Example demonstrating the combined usage of various PSeven Core modules.
```

--------------------------------

### Main Function for SBO Example

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

The main function orchestrates the SBO example. It prepares the optimizer, then solves the same problem twice: once without SBO and once with SBO enabled by marking the objective as 'Expensive'. Finally, it prints and compares the results, including the number of function calls.

```python
def main():
  optimizer = optimizer_prepare()

  # solve problem not using SBO
  problem = SBOSampleProblem()
  print("\n\nSolving the sample problem without using surrogate based optimization...\n")
  result = solve_problem(problem, optimizer)
  print("\nSolved, wait for SBO version to finish...\n")

  # solve the same problem using SBO
  problem_sbo = SBOSampleProblem()
  # define an objective expensive
  problem_sbo.set_objective_hints(0, {'@GTOpt/EvaluationCostType': 'Expensive'})
  # uncomment the following line to obtain the full trace of SBO process (WARNING: this log is about 6 MB size!)
  # optimizer.options.set({'GTOpt/LogLevel': 'DEBUG'})
  print("\n\nSolving the sample problem using surrogate based optimization...\n")
  result_sbo = solve_problem(problem_sbo, optimizer)
  print("\nSolved.\n\nResults:")

  # compare results
  print("=" * 60)
  print("Without SBO.\n")
  print("Optimal point:")
  result.optimal.pprint()
  print("User function calls: %s" % (problem.count))

  print("=" * 60)
  print("Using SBO.\n")
  print("Optimal point:")
  result_sbo.optimal.pprint()
  print("User function calls: %s" % (problem_sbo.count))

  print("=" * 60)
  print("\nFinished!\n")

```

--------------------------------

### GTDoE Python Examples

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/toc

Python scripts for the GTDoE module, which handles Design of Experiments. Examples cover basic usage, multi-dimensional factors, adaptive grids, and setting experiment levels, useful for efficient experimental planning.

```python
# example_gtdoe.py
# Basic example for the GTDoE (Design of Experiments) module.
```

```python
# example_gtdoe_multidim_factors.py
# Demonstrates GTDoE with multi-dimensional factors.
```

```python
# example_gtdoe_adaptive_grid.py
# Example of adaptive grid generation in GTDoE.
```

```python
# example_gtdoe_levels.py
# Shows how to define and use experimental levels in GTDoE.
```

--------------------------------

### GTApprox Python Examples

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/toc

Python scripts showcasing the GTApprox module for model approximation and surrogate modeling. Includes examples for adaptive design of experiments, basic GTApprox usage, internal validation, axis rotations, and mixture of approximators.

```python
# example_adaptive_doe.py
# Demonstrates adaptive design of experiments with GTApprox.
```

```python
# example_gtapprox.py
# Basic usage example for the GTApprox module.
```

```python
# example_internal_validation.py
# Example showing internal validation of GTApprox models.
```

```python
# example_axis_rotations.py
# Illustrates axis rotations in GTApprox.
```

--------------------------------

### Python: Main execution flow for GTOpt ZDT1 example

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

Orchestrates the execution of the GTOpt multi-objective optimization example. It creates an instance of the ZDT1 problem, calls the solve_problem method to run the optimizer, and then calls the plot method to visualize the results. Prints status messages throughout the process.

```python
def main():
  problem = ZDT1()
  print('=' * 60)
  print('Solve problem %s' % problem.__class__.__name__)
  result = solve_problem(problem)
  plot(result)
  print('Finished!')
  print('=' * 60)

```

--------------------------------

### GTOpt Python Examples

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/toc

Python scripts demonstrating various functionalities of the GTOpt module, including multi-objective optimization, surrogate-based optimization, batch processing, and parallel execution. These examples showcase how to define problems, use solvers, and leverage advanced optimization techniques.

```python
# example_gtopt.py
# Demonstrates basic usage of GTOpt for optimization.
```

```python
# example_gtopt_generic.py
# Shows how to use GTOpt with generic problem definitions.
```

```python
# example_gtopt_gradients.py
# Illustrates GTOpt's capability for gradient-based optimization.
```

```python
# example_gtopt_ackley_function.py
# Example of optimizing the Ackley function using GTOpt.
```

```python
# example_gtopt_triangle.py
# Demonstrates GTOpt for problems involving triangular domains.
```

```python
# example_gtopt_dfo.py
# Example of Direct Function Optimization with GTOpt.
```

```python
# example_gtopt_co.py
# Illustrates Constrained Optimization with GTOpt.
```

```python
# example_gtopt_atc.py
# Example for Adaptive Trust-region Control in GTOpt.
```

```python
# example_gtopt_rdo.py
# Demonstrates Robust Design Optimization using GTOpt.
```

```python
# example_gtopt_MOSBO.py
# Example of Multi-Objective Surrogate-Based Optimization with GTOpt.
```

```python
# example_gtopt_co_parallel.py
# Shows parallel execution for constrained optimization in GTOpt.
```

--------------------------------

### Main execution logic for GTOpt batch mode example - Python

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

The main function orchestrates the execution of the GTOpt batch mode example. It instantiates ZDT1 problem classes for both normal and batch modes, solves them using the `solve_problem` function, and prints the results, including the total number of evaluation calls for each mode.

```python
def main():
  # solve in normal mode

  problem = ZDT1()
  print('=' * 60)
  print('Solve the ZDT1 problem in normal mode.')
  result = solve_problem(problem)
  print(str(result))
  print("\nOptimal points:")
  result.optimal.pprint(limit=10)  # most points omitted to shorten output

  # solve in batch mode, maximum batch size is 10
  problem_batch = ZDT1Batch()
  print('=' * 60)
  print('Solve the ZDT1 problem in batch mode.')
  result_batch = solve_problem(problem_batch, 10)
  print(str(result_batch))
  print("\nOptimal points:")
  result_batch.optimal.pprint(limit=10)  # most points omitted to shorten output

  # print evaluations
  print('=' * 60)
  print('Number of evaluation calls\n')
  print('Normal mode: %s total' % (problem.count))
  print('Batch mode: %s total' % (problem_batch.count))

  print('Finished!')
  print('=' * 60)

```

--------------------------------

### Example Training Log Warnings

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/guide/gtapprox/technique_selection

Demonstrates example warning messages that may appear in the training log when a time limit is exceeded or when a model is created on a subset of the training set. These warnings provide information about the training settings used.

```text
[w] Model was created on a subset of the training set using the following options:
[w]   GTApprox/Accelerator = 1
[w]   GTApprox/EnableTensorFeature = False

```

--------------------------------

### Import Modules for GT Approx Example

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Imports necessary libraries for the GT Approx example, including os for file operations, matplotlib for plotting, numpy for numerical operations, and specific modules from da.p7core for GT Approx and related functionalities.

```python
import os

import matplotlib.pyplot as plt
import numpy as np

from da.p7core import gtapprox, gtdoe
```

--------------------------------

### Main Workflow Execution

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtdf

Orchestrates the GTDF example workflow: generates training data, builds models, generates test data, calculates model values, and visualizes the results. Requires various GTDF functions and Matplotlib. Executes the full example and shows plots.

```python
import matplotlib.pyplot as plt
# Assuming getTrainData, buildModels, getTestData, calculateValues, plot_train, plot_test, plot_approximations, show_plots are defined elsewhere

def main():
  """
  Toy example of GTDF usage.
  """
  print('GTDF usage example')
  print('=' * 50)
  print('Generate training sample...')
  trainData = getTrainData()
  print('Build models...')
  models = buildModels(*trainData)
  print('Generate test sample...')
  testPoints, lowFidelityTestValues, highFidelityTestValues = getTestData(1000)
  print('Calculate model values for the test sample...')
  modelsValues = calculateValues(testPoints, *models)
  print('Plotting...')
  figure_handle = plt.figure(figsize=(8.5, 8))
  # visualize training sample
  plot_train(*trainData)
  # visualize test sample
  plot_test(testPoints, lowFidelityTestValues, highFidelityTestValues)
  # visualize approximations
  plot_approximations(testPoints, *modelsValues)
  # show and save plots
  show_plots()

if __name__ == "__main__":
  main()
```

--------------------------------

### Import GTOpt, Matplotlib, and Math Modules

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

Imports necessary modules for GTOpt functionality, plotting with Matplotlib, and mathematical operations like exponentiation. These are foundational imports for the optimization example.

```python
from da.p7core import gtopt
import matplotlib.pyplot as plt
from math import exp
```

--------------------------------

### Full Design of Experiments Example in Python

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/start/doe

This is a complete example demonstrating the generation of a design of experiments using pSeven Core's GTDoE module. It includes importing necessary modules, initializing and configuring the generator, generating the sample, and printing the results.

```python
import sys

from da.p7core import gtdoe
from da.p7core import loggers

generator = gtdoe.Generator()
generator.set_logger(loggers.StreamLogger(sys.stderr, loggers.LogLevel.DEBUG))
generator.options.set('GTDoE/Technique', 'OLHS')
generator.options.set('GTDoE/LogLevel', 'Debug')

result = generator.generate(bounds=([-5.0, 0.0], [10.0, 15.0]), count=20)
print(result.points)
```

--------------------------------

### Upgrade/Downgrade pSeven Core to a Specific Version using pip

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/install

Allows for upgrading or downgrading pSeven Core to a specific version, such as '2024.4.18'. This command ensures the exact specified version is installed, overwriting any existing installation.

```bash
python -m pip install --force-reinstall psevencore==2024.4.18

```

--------------------------------

### Install lmadmin on Linux (Silent Mode)

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/license_setup

This command performs a silent installation of the FlexNet Publisher License Server (lmadmin) on a Linux system, specifying a custom installation directory. It requires privileged user access.

```shell
$ ./lmadmin-i86_lsb-11_14_0_1.bin -DUSER_INSTALL_DIR=/opt/FNPLicenseServerManager -i silent

```

--------------------------------

### Importing necessary modules for GTOpt - Python

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

Imports core components from the da.p7core library, including gtopt and loggers, along with standard Python modules like pprint, sys, and math. These are essential for running GTOpt examples and utilizing its optimization and logging features.

```python
from da.p7core import gtopt
from da.p7core import loggers

from pprint import pprint

import sys
from math import sqrt

```

--------------------------------

### Repair pSeven Core Installation using pip

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/install

Reinstalls the pSeven Core package, either to the latest version or a specific version, to repair a corrupted or problematic installation. This is done using the `--force-reinstall` option with pip.

```bash
python -m pip install --force-reinstall psevencore

```

```bash
python -m pip install --force-reinstall psevencore==2024.4.18

```

--------------------------------

### Joint Usage Example in Python

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/codesamples/advanced

This Python script demonstrates the joint usage of various pSeven Core functionalities. It serves as an example for advanced integration scenarios. No specific external dependencies are mentioned beyond the pSeven Core library itself. The script's input and output are defined by its internal logic and interactions with the pSeven environment.

```python
#
# coding: utf-8
# Copyright (C) pSeven SAS, 2010-present

```

--------------------------------

### Setting up and configuring the optimizer

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

Initializes the `gtopt.Solver` and configures its logger to stream output. It also sets optimization options, including the maximum number of expensive iterations and global phase intensity, to control the Sequential Bayesian Optimization process.

```python
def main():
  # configure optimizer
  optimizer = gtopt.Solver()
  optimizer.set_logger(loggers.StreamLogger())
  # logging options
  optimizer.options.set({'GTOpt/LogLevel': 'Warn'})
  # limit SBO iterations

  print("*"*90)

  optimizer.options.set({'GTOpt/MaximumExpensiveIterations': 10})
  optimizer.options.set({'GTOpt/GlobalPhaseIntensity': 0})

```

--------------------------------

### Run GTDR Airfoil Example with Python

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtdr

This command executes the GTDR airfoil generation example using the Python module 'da.p7core.examples.gtdr.example_gtdr_airfoil'. Ensure you have pSeven Core installed and the necessary script files in your environment.

```bash
python -m da.p7core.examples.gtdr.example_gtdr_airfoil

```

--------------------------------

### Importing Modules for Monte Carlo Integration

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtdoe

Imports necessary libraries for Monte Carlo integration, including GTDoE, logging, numerical operations (NumPy), and plotting (Matplotlib). SciPy is also a recommended dependency for this example. Matplotlib version 1.1 or later is advised for correct plot display.

```python
from da.p7core import gtdoe
from da.p7core.loggers import StreamLogger

import os
import numpy as np
import matplotlib.pyplot as plt

```

--------------------------------

### Full Example Code for Sensitivity Analysis

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/start/sensitivity_analysis

This comprehensive code snippet integrates all the necessary components for performing sensitivity analysis, including importing modules, defining the analytic function and blackbox, setting up the analyzer, and executing both blackbox-based and sample-based analysis.

```python
import numpy as np

from da.p7core import gtsda
from da.p7core import blackbox
from da.p7core import loggers

def analytic_function(x):
  g = 9.8
  k = 1.5
  f = x[:, 0] - (2 * x[:, 1] * g) / (k * x[:, 2])
  return f

class ExampleBlackbox(blackbox.Blackbox):
  def prepare_blackbox(self):

    # add new variables to problem
    self.add_variable((40, 60), 'H')
    self.add_variable((67, 74), 'M')
    self.add_variable((20, 40), 'sigma')

    # add new response to problem
    self.add_response()

  def evaluate(self, queryx):
    result = analytic_function(queryx)
    return result

analyzer = gtsda.Analyzer()

analyzer.options.set("GTSDA/Seed", 100)
analyzer.set_logger(loggers.StreamLogger())

bbox = ExampleBlackbox()

result = analyzer.rank(blackbox=bbox, budget=500)

print(result)

print("Results:")
for i, s in enumerate(result.scores):
  print('score for blackbox response[%d]: %s' % (i, s))

X = np.hstack((np.random.uniform(low=40.0, high=60.0, size=(10000, 1)),
               np.random.uniform(low=67.0, high=74.0, size=(10000, 1)),
               np.random.uniform(low=20.0, high=40.0, size=(10000, 1))))
Y = analytic_function(X)

result = analyzer.rank(x=X, y=Y)

print(result)

print("Results:")
for i, s in enumerate(result.scores):
  print('score for output[%d]: %s' % (i, s))
```

--------------------------------

### Get FlexNet Host ID on Linux

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/license_setup

This command retrieves the unique FlexNet host ID for a Linux machine, which is required when requesting a floating license file from pSeven.

```shell
$ ./lmhostid
lmhostid - Copyright (c) 1989-2012 Flexera Software LLC. All Rights Reserved.
The FLEXnet host ID of this machine is "e05806420eb4"

```

--------------------------------

### Optimizer Configuration Method

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

This function, optimizer_prepare, sets up the GTOpt solver. It initializes the solver, configures a stream logger to output DEBUG level information to standard output, and sets the GTOpt log level to INFO.

```python
def optimizer_prepare():
  opt = gtopt.Solver()
  opt.set_logger(loggers.StreamLogger(sys.stdout, loggers.LogLevel.DEBUG))
  opt.options.set({'GTOpt/LogLevel': 'INFO'})
  return opt

```

--------------------------------

### Get FlexNet Host ID on Windows

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/license_setup

This command retrieves the unique FlexNet host ID for a Windows machine, which is required when requesting a floating license file from pSeven.

```shell
> lmhostid.exe
lmhostid - Copyright (c) 1989-2012 Flexera Software LLC. All Rights Reserved.
The FLEXnet host ID of this machine is "e05806420eb4"

```

--------------------------------

### Uninstall pSeven Core using pip

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/install

Removes the pSeven Core package from the Python environment using pip. This command is applicable for versions 2024.03 and above. Manual removal might be required for older versions.

```bash
python -m pip uninstall psevencore

```

--------------------------------

### Import pSeven Core Optimization Module

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/start/optimization

Initializes the Generic Tool for Optimization (GTOpt) module from the pSeven Core library. This is the first step for setting up any optimization problem.

```python
from da.p7core import gtopt
```

--------------------------------

### Get FLEXnet Host ID using lmhostid utility

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/license_setup

This command-line utility, lmhostid, is used to obtain the FLEXnet host ID of a machine. This ID is crucial for generating a node-locked license file. The output provides the unique host ID required for license requests.

```bash
> lmhostid.exe
lmhostid - Copyright (c) 1989-2013 Flexera Software LLC. All Rights Reserved.
The FLEXnet host ID of this machine is "e05806420eb4"
```

--------------------------------

### Initialize Builder and Build Rough Model

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Initializes the `gtapprox.Builder` and sets a stream logger. It then generates training and test data, and builds a 'rough' approximation model using Smart Selection with a specified `AcceptableQualityLevel` hint.

```python
# generate training data
x, y = get_data(100)

# generate test data
x_test, y_test = get_data(5000)

builder = gtapprox.Builder()
builder.set_logger(loggers.StreamLogger())

hints = {'@GTApprox/AcceptableQualityLevel': 0.1}

rough_time = time.time()
model_smart_rough = builder.build_smart(x, y, x_test=x_test, y_test=y_test, hints=hints)
rough_time = time.time() - rough_time
```

--------------------------------

### Set DATADVD_LICENSE_FILE Environment Variable with Non-Default Port in Windows

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/license_setup

This example shows how to set the DATADVD_LICENSE_FILE environment variable in Windows when the license server uses a non-default port. The port number is specified before the '@' symbol and the server IP address. Replace '9977' with your port and '10.7.18.142' with your server IP.

```batch
> set DATADVD_LICENSE_FILE=9977@10.7.18.142
```

--------------------------------

### Main Workflow: GTApprox Tensor Approximation Example - Python

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Orchestrates the Tensor Approximation process. It includes generating training and testing samples, initializing and configuring the GTApprox builder with Tensor Approximation enabled, and preparing for model building and evaluation.

```python
def main():
  print('='*50)
  print('Generate training sample.')
  numberOfPointsInFactor = 10
  problemDimension = 6
  print('Generate full factorial DoE.')
  trainPoints = full_factorial(0, 1, numberOfPointsInFactor, problemDimension)
  print('Calculate function values.')
  trainValues = data_generator(trainPoints)

  print('='*50)
  print('Generate test sample.')
  numberOfTestPoints = 50000
  print('Generate random DoE.')
  testPoints = np.random.rand(numberOfTestPoints, problemDimension)
  print('Calculate function values.')
  testValues = data_generator(testPoints)

  print('='*50)
  print('Initialize and configure GTApprox builder.')
  builder = gtapprox.Builder()
  logger = loggers.StreamLogger(sys.stdout, loggers.LogLevel.DEBUG)
  print('Set logger.')
  builder.set_logger(logger)
  print('Set logging level to debug.')
  builder.options.set('GTApprox/LogLevel', 'DEBUG')
  print("By default TA technique isn't used, so we should explicitly turn this branch of decision tree on.")
  builder.options.set('GTApprox/EnableTensorFeature', 'On')

  print('='*50)

```

--------------------------------

### Defining Sequential Techniques for Monte Carlo Integration

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtdoe

Defines a dictionary that maps technique names (e.g., 'RandomSeq', 'SobolSeq') to their human-readable descriptions. This dictionary is used to iterate over and test various sequential sampling methods for Monte Carlo integration.

```python
seqTechniqes = {'RandomSeq' : u'Random sampling',
                'SobolSeq' : u'Sobol sequence',
                'FaureSeq' : u'Faure sequence',
                'HaltonSeq' : u'Halton sequence'}

```

--------------------------------

### Printing Task Setup and Calculating Exact Integral Value

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtdoe

Inside the `monteCarloIncremental` function, this snippet prints the current task configuration (dimension, number of points, step, techniques) and calculates the exact analytical value of the integral using the formula Id=∏dk=1sin(k).

```python
  print('=' * 50)
  print('Run GTDoE MonteCarlo example with the following inputs: ')
  print('Dimension: %s' % dim)
  print('Number of points: %s' % maxPoints)
  print('Step: %s' % step)
  print('Techniques: %s' % list(seqTechniqes.keys()))
  print('=' * 50)
  print('Calculating exact value of the integral.')
  correctValue  = np.prod([np.sin(i+1) for i in range(dim)])
  print("Correct value: %f" % correctValue)


```

--------------------------------

### Main execution block and warning in Python

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/codesamples/gtopt

The main execution block (`if __name__ == '__main__':`) includes a time-delayed warning to the user about the potentially long execution time of the example script. It then pauses for 10 seconds, allowing the user to interrupt execution via Ctrl-C before starting the `atc_flow` function.

```python
if __name__ == '__main__':
  # simple long-run warning
  from time import sleep
  print("WARNING: The execution of this example can be time consuming!")
  print("Depending on the execution environment it can takes minutes to complete.")
  print("Press Ctrl-C in 10 seconds to avoid execution...")
  sleep(10)
  print("Starting example...")

  atc_flow(1000, 2.0e-4)
```

--------------------------------

### Import necessary libraries for training with limited memory

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtapprox

Imports required modules for numerical operations, GTApprox, and logging. These are fundamental for the subsequent data generation and model training steps.

```python
import sys
import traceback
import numpy as np

from da.p7core import gtapprox
from da.p7core.loggers import StreamLogger

```

--------------------------------

### GTOpt: Specify Initial Sample for Solver

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/changelog

GTOpt's `Solver.solve()` method now supports initial sample data. This allows users to provide multiple initial guesses or utilize cached data for solving problems, improving efficiency and flexibility in optimization tasks.

```python
da.p7core.gtopt.Solver.solve(_sample_x_=..., _sample_f_=..., _sample_c_=...)
```

--------------------------------

### GTApprox: Fixed Training with Limited Memory Example in Python 2.5

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/support/changelog

This bugfix addresses an issue where the 'Training with Limited Memory' example in GTApprox did not function correctly in Python 2.5. The fix ensures the example runs as expected in this specific environment.

```python
# This code snippet would represent the corrected example.
# Since the original text only mentions the fix, a specific code example is not provided.
# Example of a potential GTApprox training call:
# import pseven.gtapprox
# import numpy as np
# 
# # Dummy data
# train_sample = np.random.rand(10, 2)
# train_target = np.random.rand(10)
# 
# # Dummy model parameters
# model_params = {'algorithm': 'linear'}
# 
# # Build the model (assuming this was part of the fixed example)
# model = pseven.gtapprox.build_model(train_sample, train_target, model_params)

```

--------------------------------

### Python: Solver with Initial Sample Data

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/api/da_p7core_gtopt

Demonstrates the use of the `solve` method with initial sample data (`sample_x`, `sample_f`, `sample_c`). This feature, added in version 2.0 Release Candidate 1, allows providing starting points and pre-evaluated function values to the solver, potentially improving convergence.

```python
solution = solver.solve(my_problem, sample_x=initial_x, sample_f=initial_f, sample_c=initial_c)
```

--------------------------------

### Set Random Seed for Reproducibility in GTOpt Example

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/examples/gtopt

Sets a fixed seed for the random number generator to ensure that the results of the GTOpt robust optimization example are reproducible. This is useful for debugging and comparing different optimization runs.

```python
random.seed(111)

# It may be removed if reproducibility is not needed.
```

--------------------------------

### Setup pSeven Core Optimization Solver

Source: https://www.pseven.io/product/pseven-core/manual/v2025.07/start/optimization

Configures the optimization solver by setting a logger, a custom watcher, and adjusting solver options. This snippet demonstrates how to integrate logging and custom termination conditions into the optimization process.

```python
import sys

from da.p7core import loggers

debug_stdout_logger = loggers.StreamLogger(sys.stdout, loggers.LogLevel.DEBUG)
optimizer.set_logger(debug_stdout_logger)

class CustomWatcher(object):
  def __call__(self, obj):
    return True

simple_watcher = CustomWatcher()
optimizer.set_watcher(simple_watcher)

optimizer.options.set('GTOpt/LogLevel', 'Debug')
```
Tokens:
Raw