Block Library

This page briefly explains the structure of the pSeven’s component library and introduces available blocks.

Block Groups

Blocks on the Block library pane in Edit are organized into four groups based on their functions and intended use. These groups are:

  • Exploration — blocks that implement various design space exploration methods.
  • General — general purpose blocks.
  • Integration — blocks that control external programs and can process program input and output.
  • Modeling — blocks that build models using training data or load and evaluate these models.


Some blocks have special tags shown near their names on the Block library pane. These tags indicate block’s development status:

  • beta: new blocks that may contain some unfinished functionality or miss certain features. These blocks are subject to further updates, but in general they are safe to use. Future updates can add more functions to beta blocks, but it will not affect their backward compatibility.
  • experimental: blocks that are still under development. These blocks will probably be redesigned, replaced with other blocks, or even removed without prior notice. A workflow containing experimental blocks may become incompatible with future pSeven versions, so it is not recommended to use them except for testing purposes.
  • legacy: old blocks that are kept for version compatibility only. In general, such blocks are effectively replaced with new and improved blocks which provide the same functionality. Avoid using legacy blocks in new workflows, as they are going to be removed in future.

All blocks without a tag are up to date and fully functional. Untagged blocks are also compatible with future pSeven versions.

By default, the Block library pane shows only untagged and beta blocks, while experimental and legacy blocks are hidden from the list. You can show or hide beta, experimental, and legacy blocks using commands from the Block library pane’s b_context menu.


The Block library pane with some legacy blocks. 1 Showing legacy blocks is enabled in the pane’s b_context menu. 2 Legacy DoE and Optimizer blocks are listed.


Documentation for most experimental and legacy blocks is not available since using them for production tasks is not recommended.


Exploration blocks implement methods used in design space exploration and design optimization. These blocks are powered by the pSeven Core algorithmic library.

  • Design space exploration: solves a variety of design space exploration tasks using design of experiments and optimization methods.
  • DoE (legacy): generates data samples. This is a legacy block which is kept for compatibility with older versions of pSeven. Currently replaced by the Design space exploration block.
  • IVE (experimental): performs sensitivity analysis.
  • Optimizer (legacy): solves optimization problems.
  • Uncertainty quantification: performs uncertainty quantification studies.


This group includes general purpose tools for handling your data flow, loading files and so on.

  • CSVGenerator: writes a matrix with an optional header to a CSV file.
  • CSVParser: parses a CSV file to a data matrix and a header.
  • Calculator (experimental): matrix calculator with scripting support.
  • Composite: creates a custom component encapsulating other blocks.
  • Condition: creates a conditional node in the workflow useful for data filtering and data flow redirection.
  • Const: outputs preset constant values.
  • Echo: prints the input value to the workflow run log.
  • File: performs file operations.
  • For: creates a for loop in a workflow.
  • Foreach: creates a foreach loop in a workflow.
  • Formula (beta): calculates function and derivative values of user-defined functions.
  • Loader (experimental): reads data from a file and sends this data to an output port.
  • Map: creates a loop which iteratively calculates response values for a list of input values.
  • PythonScript: runs your Python script.
  • Random: pseudo-random number generator.
  • Range (experimental): generates numeric progressions.
  • Saver (experimental): writes data to a file.
  • Submatrix: selects specified rows and columns from an input matrix.


Integration blocks are used to control execution of external programs and process program input and output. In other words, they create an interface between a pSeven workflow and some program — for example, a CAD package or a solver — which allows to run simulation or analysis in this program and use its results in the workflow.

This group includes two kinds of blocks:

  • Direct integration blocks — program-specific blocks, easy to configure.
  • Generic integration blocks — allow integration using any program’s command line interface. Provide greater flexibility than direct integration blocks, but often require some scripting or manual command input.

Direct integration blocks are:

  • ANSYSWorkbench: integrates ANSYS Workbench projects.
  • CATIA (beta): integrates CATIA V5 models.
  • Creo: integrates PTC Creo parts and assemblies.
  • Excel: integrates Excel documents, supports formulas and macros.
  • FloEFD: integrates FloEFD analysis projects.
  • FMI model: integrates FMI models (Functional Mock-up Units).
  • Kompas3D: integrates KOMPAS-3D parts and assemblies.
  • NX: integrates Siemens NX models.
  • SolidWorks: integrates SolidWorks parts and assemblies.
  • STAR-CCM+ (beta): integrates STAR-CCM+ simulation projects.

Generic integration blocks are:

  • Program: launches any program from the command line, executes shell (batch) scripts.
  • Text: can generate a file by writing values of variables into a template, or read values from any text file — for example, input and output files of an external program.


Modeling blocks are used to train and evaluate models. These blocks are powered by the pSeven Core algorithmic library. This group includes two kinds of blocks:

  • Model builders — blocks that receive data and use it to train a predictive model. This model can be saved to a file or sent directly to an evaluating block.
  • Evaluation blocks — blocks that load models and evaluate them on received input data.

Model builder blocks are:

  • ApproxBuilder: builds approximation models.
  • DFBuilder: builds approximation models using several training samples of different fidelity (data fusion models).
  • DRBuilder: builds dimension reduction models.

Evaluation blocks are:

  • Approximation model: evaluates approximation model responses and gradients, estimates model accuracy, provides model information, exports models to various formats. Also supports evaluation of data fusion models.
  • ApproxPlayer (legacy): evaluates an approximation model on the input sample. This is a legacy block which is kept for compatibility with older versions of pSeven. It is not recommended to use: since pSeven 6.12, ApproxPlayer is replaced with the Approximation model block.
  • DFPlayer: evaluates data fusion model responses and gradients, estimates model accuracy and provides model information.
  • DRCompressor: evaluates compressed vectors and compress transformation gradients using a dimension reduction model.
  • DRDecompressor: evaluates decompressed vectors and decompress transformation gradients using a dimension reduction model.