FieldView
User's Guide

SOFTWARE RELEASE
VERSION 2025

When FieldView is started, it uses a default port number of 12345. Each instance of FieldView must use a unique port number. You can run two or more versions of FieldView on a single machine, assuming your licenses support this, by specifying an explicit port number (where port_number is any port that is not in use by another process) as follows:

fv -port port_number

It is also possible to start FieldView by specifying a port number, range of port numbers, where FieldView will use the first open port in that range, or -port none:

fv -port 21000:22000

However, the -port none option will prohibit use of FieldView Servers.

FieldView also provides the environment variable FV_DEFAULT_PORT for this setting.

FieldView can be run in batch mode without displaying the graphical user interface. Batch mode is enabled by starting FieldView with the -batch argument. It must be used in conjunction with an FVX program (-fvx name), a Python program (-python name), an automatic script restart (-s name) or a restart (-f name). DataGuide^TM processing can also be used.

When FieldView is run in batch mode from the command line using the -batch switch, it does not require an X-server to run.

To run a script in batch, use:

To run a restart in batch, and generate a DataGuide^TM file at the same time, use:

Batch mode, when combined with script commands such as PROBE, INTEGRATE and EXPORT, will allow you to analyze many datasets in succession, examine very large and/or transient datasets non-interactively, and run FieldView overnight.

FieldView can run using a reduced cost batch license, which only permits batch operation. When running with this type of license, the FieldView interface will not be launched. The purpose of this type of license is to let you run many FieldView batch jobs without having to use your interactive licenses.

To run a batch job using a batch-only license, use one of the command line options [-fvb | -fvb8 | -fvb16 | -fvb32 | -fvb64 | -hpcfvb]. (This forces FieldView to run in batch mode, making the -batch command line option unnecessary.)

A FieldView Restart can be run at start-up using the following command line argument:

On startup, FieldView looks for a -f name argument on the command line. If this argument is present, FieldView will automatically read restart_name.dat, along with any files that begin with restart_name and have a standard FieldView file extension (such as restart_name.map for a Colormap restart file, or restart_name.iso for an Iso-surface restart file). Note that name can include slashes to access directories other than the current directory.

A FieldView script can be run at start-up using the following command line argument:

where script_name is the name of the script file. This is often used in conjunction with Batch mode (see above). Script files are described in Restart Files and Script Language in the Reference Manual.

An FVX script can be run at start-up using the following command line argument:

where fvx_name is the name of the FVX program file. This is often used in conjunction with Batch mode (see above). FVX programming is described in FieldView Extension Language in the Reference Manual.

A python script can be run at start-up using the following command line argument:

where name is the name of the python program file. This is often used in conjunction with Batch mode (see above). Python-enabled FVX programming is described in FieldView Extension Language in the Reference Manual.

DataGuide^TM lets you create specially formatted files (based on grid and results files) that will substantially decrease read in time. The time savings for very large transient datasets, for example, can be extraordinary. DataGuide^TM licensing is included to both create and also to use DataGuide^TM files. Command-line switches are needed to create DataGuide^TM files. Once the files are created, if they reside in the same directory as the grid and results file, they will be automatically used by FieldView. The data read-in process is no different for you. Note that this feature cannot be used if your data has been read with Parallel FieldView, unless read in Partitioned File (PFPR) format. If tried, FieldView will issue a corresponding message.

When the "-fc" command line option is used when running FieldView, the transform specification of the mouse buttons is changed. Instead of the normal FieldView definitions of the three default mouse operations, FAST-like transforms are mapped to the mouse buttons. In addition, the default demotion mode will be None and the default tracking will change from Track to Running.

In order to change the internal values of the gas constant (R) and gamma (\(\gamma\)), command line switches will have to be used. The command line switches are:

The possible values of the gas constant are values strictly greater than 0. The normal value used in the PLOT3D functions is R = 1. This assumes a perfect gas. Whether the value of the gas constant you enter is required to be normalized or not will depend on your normalization of these quantities in your solver.

The value of gamma has to be strictly greater than 1.0. The normal value used in the PLOT3D functions is \(\gamma\) = 1.4.

If either the gas constant (R) or gamma (\(\gamma\)) is supplied by the user the value(s) will be echoed in the console window.

The graphics window size can be controlled during both interactive and batch mode operation of FieldView. The default window size while running FieldView interactively is discussed in the Graphics Layout Size section of Working with FieldView, and can be controlled with Graphics Layout Size from the Tools or View menu, or the -size command line option. The default window size when running in batch mode (with the -batch command line option) is 640x480.

You can control the image size by using the following command line argument:

where WIDTH and HEIGHT are measured in pixels. For example, to set the image portion of the graphics window to 640x480, use the following command to run FieldView:

This command line argument works in conjunction with all of the other FieldView arguments, for restarts, scripts, batch mode, etc.

Getting a "command not found" error indicates that the directory containing the FieldView executable (FV_HOME/bin) is not in your command search path. To correct this, either this path should be put in your search path (as described in the Installation Guide) or you will need to type the full pathname to start up FieldView. For example, if FieldView is loaded in the directory /usr1, you will need to type the following to start up FieldView: /usr1/fv/bin/fv.

When FieldView is installed, the shell script fv (located in the FV_HOME/bin subdirectory) is created with an environment variable: FV_HOME. There are a number of other files which use the explicit value of FV_HOME (the installation path), including python files, so the FieldView installation should never be moved. Instead, reinstall FieldView.

The FieldView process will not terminate if it was ever placed in the background during the current session.

FieldView is designed to make it as easy as possible to use client-server mode in day-to-day operations. Complete coverage of how to create a server config file is covered in Installing FieldView Servers (Optional) in the Installation Guide. There are a few key concepts to the architecture:

FieldView will attempt to acquire a port during startup for use in communication with FV servers. This is always done, whether or not you intend to run client-server. By default, it attempts to acquire port number 12345. If it cannot acquire this port, FV will shut down. This can happen when another program is already using this port number, such as another copy of FV running on the same machine or occasionally if FieldView is killed rather than exited cleanly. If FieldView does not exit cleanly, the port is often tied up for 2-4 minutes.The following is a typical symptom of port unavailability:

[Client]: The specified address is already in use.

To avoid port conflicts, you can request a different port number by using the -port switch on the FV command line. You should keep in mind that ports with numbers below 1000 are reserved. And, the policy for port use is sometimes part of a security protocol. You should consult with your system administrator if you have questions about port usage at your site. Here are examples showing how to specify a single port, or a preferred range of ports where FV will use the first open port in that range:

If you will not be using client/server, or the "Local Parallel" options, you can tell FV not to request any port as follows:

fv -port none

The port number can also be changed by setting the environment variable FV_DEFAULT_PORT. If both the environment variable and the -port switch are used, the -port switch will take precedence.

By default, CFD data is read directly with the FieldView Client. The Data Input Panel also allows reading of data using separate server process(es), which can run locally or on a remote system. For instance, the option Local Parallel will run several server processes locally. A Server Configuration option is also provided for use of custom Server Configuration (.srv) files, if provided by the user. The manual option allows you to read your data by manually obtaining a remote shell (ssh, plink) to your server, and running FieldView's fvrunsrv (with its corresponding arguments. See Manual Server).

The data input pull down provides control over Direct and Client-server operation, as shown below.

For more information on these Data Input options, please refer to the Reference Manual. Reading Data Interactively with FieldView Parallel in the Reference Manual

Using Parallel Servers in FieldView is as simple as using the Client-Server feature. If you have some familiarity with how Client-Server works, then setting up and running FieldView Parallel should be straightforward extension. In addition, FieldView can run local Parallel depending on whether you have multiple cores and/or a FieldView parallel license. Reading data using local FieldView Parallel has been described in detail in the section called Parallel Datasets in the Reference Manual.

Similar to the Client-Server feature, you will need to install SERVER programs on to the controller nodes of the system(s) where you wish to run FieldView Parallel. (Note that the FieldView Servers are installed along with the Client, or with smaller Server Only installation packages.) We support both shared memory and cluster configurations.

Again, similar to running Client-Server, you will need to configure files which will permit you to run in the FieldView Parallel Server programs. A simple example of a FieldView Parallel Server Configuration (.srv) file to run the shared memory mpi version of FieldView Parallel on a shared memory system is given below:

This example sets the AutoStart parameter to launch the FieldView Parallel server program(s) automatically. As with Client-Server, you can also configure this to run manually. If you do, you will need to execute the fvrunsrv command manually.

Note that FieldView also supports the usage of Job Schedulers (eg. PBS) on HPC systems when adding the field Scheduler: to your Server Configuration (.srv) file. For more on this subject, please refer to the Installing and Using myFVMPI section of the Installation Guide.

A total of nine (9) processes has been chosen. This has been set with the command line argument '-np 9' for the fvrunsrv command. This means that there will be one controller process (which acts solely as a dispatcher) and eight (8) worker processes (which read data) started on this shared memory system named my_shmem_system. The fvrunsrv command also starts the FieldView Parallel server program, fvsrv_par.

A start directory, /usr2/data/test_PAR, is set so that when the file browser to read data comes up, it will be started at this location.

A simple example of a FieldView Parallel Server Configuration (.srv) file to run FieldView Parallel using a system such as a LINUX cluster might look like:

In this case, again the AutoStart option has been chosen.

For a parallel cluster, we will need to have the MPI and FieldView Parallel Server programs installed on the controller node of the system, in this case called my_cluster_system. The installation location for this set of files can be anywhere you choose. When this FieldView Parallel Server is selected, a total of five (5) processes will be run. Again, one of these will be a controller process, and the remaining four (4) will be used to read and process the dataset.

For the cluster option, MPI will use the default "machine" file openmpi-default-hostfile, found within the MPI installation with FieldView. If you do not want to let MPI use defaults and would rather specify which nodes of your cluster will be used as FieldView "worker" servers, you can:

For Server Configuration (.srv) files, use the MachineFile: field in a Server Configuration (.srv) fileto specify a custom machine file in the Server Configuration (.srv) file.

Note: For Manual client-server, specify your parallel "worker" nodes using the -machinefile or -hosts argument to the command fvrunsrv.

Note also that all nodes of a cluster must be able to resolve the path used for the field ServerDirectory: in the Server Configuration file (.srv) in order to find the program fvsrv_par. Please see Testing & Configuring FieldView Servers of the Installation Guide for additional details if needed.

To read data, go to the Data Input pulldown menu and use Server Configuration to select your Server Configuration (.srv) file.

If both examples for the server configuration files are placed in the /fv/sconfig directory, then when the Choose Server option is selected from the Data Input menu, both the cluster and shared memory based FieldView Parallel options to read data will be present (as illustrated above).

After this point, we can now read the data via a browser which starts on the Controller server system.

Also, once the dataset has been read in successfully, you can see the outline of each of the individual grids in the graphics window. For the case of unstructured data, the number of grids for a given dataset, as well as the number of nodes and elements for each grid will be listed in the console window. There will be one line in the console window corresponding to each grid. A typical console window output might contain the following lines:

Yes, FieldView's Auto Partitioner can create a multigrid dataset or repartition existing multi-grid PLOT3D or OVERFLOW-2 input data. For more details, see the Auto Partitioner section of this manual.

At the present time, there is no feature in FieldView, or standalone utility capable of creating partitioned files from a multigrid dataset.

The degree to which certain operations in FieldView Parallel will scale depends upon several factors pertaining to the dataset, and may also depend upon hardware issues as well. As such, it is difficult to make generally applicable statements concerning the performance of FieldView Parallel. Some testing results are included here. FieldView Parallel testing was carried out on a set of test cases run using FLUENT 6.3.26 and Acusim 1.7e. Boundary results were present in the FLUENT FV-UNS exports. Details for four benchmark cases, all containing 38 grids, and made up entirely of either tetrahedral cells or arbitrary polyhedral cells, are summarized in the table below:

Timing tests were performed using an HP xw8600 system with 4 dual core CPU (Intel X5460, 3.166GHz). The system was configured with 32GB of RAM. Elapsed timings were obtained running Parallel Shared Memory (shmem). Averaged results on scale-up factors recorded for each of the benchmarks are presented below.

Benchmark timings were obtained for the tasks of reading data, creating coordinate and iso-surfaces and sweeping these same surfaces. Overall time savings are reported as a percentage relative to the time required to complete these tasks using FieldView in Client-Server mode. Using the just three worker processes (for np values to the left of the dotted line) we expect to see scaling improvement of 2x or better.

Benchmark timings were also carried out on a partitioned FV Unstructured dataset composed of 53 grid and results files with a total of 153 million nodes. The test system was an HP 740C with 8 blades or compute nodes. Each compute node was configured with an Intel XEON 4 core (Intel X5260, 3.33GHz, dual core, dual processor), a local file system and 16GB RAM. Local file systems were connected with a GigE network switch.

Timing tests were obtained as follows. For the case of one compute node, all 53 partitions were read from the local file system on that node. For two compute nodes, the 53 partitions were spread across the file systems for two nodes, and the dataset was read again. By utilizing all 8 compute nodes, a 7X reduction in the time required to read data was achieved.

Owing to the complexity and diversity of datasets, networks and file systems, it is often difficult to identify where problems may be occurring during postprocessing operations. To understand how effectively FieldView (Parallel or Direct) may be running for a given dataset in a given environment, we provide a Script Command TIMING ON/OFF (which can be nested) to report CPU and Elapsed timings for any (scripted) operation. Below, two examples are shown for standard '.scr' script (Restart Files and Script Language, Reference Manual), then FVX '.fvx' script (FieldView Extension Language (FVX), Reference Manual.) The second example is suitable for Python '.py' scripts:

The above examples show how you can add Comment to give your output context. The following output example shows how this will be used, and how the timing reports will look:

Note that timings are taken at the FieldView Client, thus CPU time may be very small as compared to Elapsed when operations are performed on a remote FieldView Server. Interpretation of the timing information that FieldView produces will be involved since the performance of FieldView will be dependent not only on the hardware environment but also on the type of datasets being examined and the tests actually being performed. If you encounter what you believe are performance problems with FieldView, we recommend that you send your complete timing output and testing methodology to us so that we can analyze the results for you. You can direct all output to a file with most unix shells using the following command line syntax:

fv -s my_script.scr 2>&1 | tee my.log