There are four main methods to save and replay or reuse your work in EnSight. Each method serves a slightly different use-case and offers different advantages over the others. Understanding their differences will allow you to apply and leverage the best method for your particular use and situation.
Save every command executed in this session. (also known as Journal/Command File).
Can be edited to adjust/change/modify to replay.
Serves as the basis for scripting and python usage.
Save the current state of EnSight.
May be applicable to other similar datasets. Should not be edited by end user.
Save the current state of EnSight along with a thumbnail and description.
Applicable only for the dataset(s) loaded. (Cannot be used for other datasets).
Good for quick exit/restore.
Writes current memory structures of EnSight to disk.
Applicable only for this dataset and this machine. (Cannot move dataset nor use on different machine)
Only compatible within the current released version. (Cannot be used with a different version of EnSight)
EnSight is continually journaling all commands that are executed in EnSight. This journal (also known as command file) can be saved off to disk for replay to a new session of EnSight. You can see the journal by going to → → Execution). In this dialog you can specify a file to record the commands to, load commands from, or type in specific commands in the Command entry line.
Journal/Command files provides some key benefits and use-cases:
Benefits
Every command is saved andeditable in plain text editor
Replay of commands re-executes each/every operation done during that session.
Basis for scripting/modification.
Very robust operation (what developers use to test EnSight).
Limitations
Can be slow to restore every command you created. All interim operations are performed (for example, saving out animations).
Not very extensible/variable and can be difficult to write code in.
How to Use/Playback
Via the command line with
-p <filename.enc>.Interactively by using → → Select File to replay from.
To Save
→ → (or upon ).
Alternatively, you can specify a file to continually write to as you progress.
Use Cases
Rerun to get exactly all output/operation as you did.
Edit small aspects/datasets referenced,and play back new output information.
Basisfor creating Python scripts (Journal commands can be automatically turned into Python → Customize).
Journal/Command files serve as a good basic function for robust playback. It may be slow to restore, as it is performing all operations. If you want to simply skip back to where you were in EnSight, Session files or Context files would be the better method.
Context files take the current state of EnSight and save that current state to a file. Context files are good mechanism to restore back to this particular state, skipping over all of the interim operations which were not needed for the current state. Context files can be applied to the same or similar datasets, but are not generally meant for end-user editing.
When handling context files, there are actually 4 separate files created to handle the various pieces of information (.ctx, .ctx_view, .ctx_palette, and .ctx_evs). All four files are needed for proper restore.
Context files provide the following benefits over Journal/Command files:
Benefits
Restore back your current state more quickly/directly. It does not repeat interim steps, nor does it save off images/animations/scenario files/etc.
It can be applied to datasets which have a similar layout (similar part names and variables available).
Limitations
Should not be edited. (Limited extensibility to changes or modification).
Cannot be used in conjunction with other context files. Each context file is meant to be applied from a starting condition.
Some conditions in EnSight are a result of the path to that state. Some conditions in EnSight are not state independent. As this is only a final state recoding, it may not work in all situations.
Does not restore flipbooks.
Cannot be used in conjunction with other context files. Each context file is meant to be applied from a starting condition
How to Use/Playback
Via the command line with
-ctx <filename.ctx>.Interactively by using → →
Use Cases
Can be applied to different datasets.
Note: However, they must be conceptually similar.
When intermediate steps do not matter.
Click → →
If there are multiple cases in the current session, make sure that is chosen.
Click → →
Choose the .ctx file when specifying which file to restore.
There are three other files which are referenced:
.ctx_evs
.ctx_palettes
.ctx_view
Context files can be applied to similar cases
Variables are similarly named and geometry is similarly orientated.
Note: Parts may be different therefore you'll need to map them.
Session files are essentially a context file wrapped up with a screenshot, user description, and put together into a single file (.ens). The goal of session files was to make the transfer of context files easier, and more friendly (screenshot & description), and therefore a simpler workflow for basic usage. As a result, the sessions cannot be applied to any other dataset than the one it was saved from.
Session files offer the following advantages as compared to Context files:
Benefits
Simple, single file option to Context file.
Screenshot & description to allow easier understanding of what that session files will do.
You can
includethe dataset when saving session file. This allows for complete transfer of dataset + session file to third party to restore back to the same point in the post processing state.Note: This will .zip in the entire directory and subdirectories where the dataset resides, regardless of what was used for this dataset. Use with caution as these files can become very large.
Limitations
Shares all the same caveats as Context files.
Tied to the original dataset and cannot be applied to different datasets.
How to Use/Playback
On the command line with providing just the session file after the
ensight(for example, ensight duct.ens).Interactively by using → →
Within the Welcome Window and will show the last 10 (or those saved in your ~/.en- sight211/demos directory).
Use Cases
Quick save/restore.
Simpler workflow for simply use-cases.
Click → →
Note: Optional - include the data files (packed data), and description.
A screen shot is saved.
When restored, EnSight will go back to this state of EnSight.
Session files are dataset specific.
Packed Data
Important: This will zip the whole directory (and subdirectories) into the .ens file.
If you leave this unchecked, a reference to the dataset location is used.
Click Window → Welcome
Most recent session files are stored in My Sessions (last 10).
If session files are placed in ~/.ensight195/demos/, they will show up in the My Examples location.
Can also be restored by selecting → →
Archive files are saving EnSight’s memory to disk. As a result, this is very quick to restore (just reading entire memory from disk).
Important: However, this requires that the dataset:
Has not moved location as it cannot be applied to any other dataset.
Can only be used on the same exact machine it was saved from.
Can only be used with the same version of EnSight that it was generated from.
In addition, the file size can become quite large (entire memory footprint of the EnSight session). As a result it is not often used in practice, as it requires significant disk and last no ability to be used by others or towards other datasets. It can be viewed as a quick save/restore mechanism for individual use.
Relative to the other methods to reuse your work, it has the following benefits and limitations:
Benefits
Very fast to restore (disk → memory).
Limitations
Unique to your machine’s memory.
Dataset cannot move.
Large disk usage.
Cannot be re-used/re-applied to anything else.
Cannot be used with a different version of EnSight.
How to Use/Playback
Interactively by using → →
Use Cases
Not suggested for daily use.
In addition to the above manual methods to save/restore your work, EnSight has a checkpointing capability which allows EnSight to automatically save session files at regular intervals. This works well as a checkpoint in case something goes wrong, or your want to revert back in your workflow. These checkpoints are session files, and therefore have all of the limitations and caveats of such.
The enable checkpointing, go to UserDefinedtools → Utilities → Checkpointing and check the option. You can specify the interval for saving Checkpoints, how many total to keep, and a threshold to delete. Each Checkpoint file is only a few KB in size, so the amount of them should not cause any file storage issues. The capability is persistent once enabled.
Once turned on, the Checkpoints can be restored from the Welcome Window.
EnSight has a checkpointing ability to save session files at regular intervals.
There are four main options available to users to save and restore their work. Each is tailored for a specific use, and as such users should utilize the method which closely matches their use-case and workflow. In practice, most users utilize each for different reasons and leverage the benefits of each for the situation at hand.
Session Files
When you have completed all of your work and wish to get back to the exact starting point.
Context Files
If you're interested in the final state or wish to apply changes to a similar dataset.
Journal/Command Files
Want more flexibility to edit/replay your work in a more complete and general manner.
Want to rerun a subset of operations.
Want to create a smarter/automated re-use, Journal → Python.
Edit Python within EnSight.
Convert Journal commands to Python automatically in the Editor.
Replay via a command line (
-p <filename.py>), or through the Editor or →
Full Backup
When you can spare the large disk footprint, and want to save/resturn to just this dataset, on this machine only.
Separate, but related to save/reuse your work is the idea of States in EnSight. These are similar in concept to sub-context files which really focus on co-existance with other states in EnSight. Users can define as many states as they’d like and easily switch between any of them at any time. Within a single EnSight work session you can setup/save/restore multiple states. The states can be stored independently of the other methods (journal/context/etc), and can be restored to cases separately. When saving Context files, the states are saved as part of that process (the .evs file).
Use Cases
Setup of clips separately from contour plots, separately from different variables or scenes.
As a precursor to Report generation. (Reports traverse the States to provide framework for the material send to the report).
For re-application on the same or similar datasets, you should utilize the creation of States within EnSight, and save Context files. Restoring context files can be applied to similar datasets, and with the inclusion of the States within EnSight, the restore can yield multiple states of EnSight (rather than just the final state of context alone).
For generalized scripting and macro generation, you should utilize the command/journal file as an initial save format, and utilize Python conversion of those commands for the generation of python-syntax scripts or macros.
Separate from Journal/Command files, users can utilize Python scripts to instruct EnSight to perform any/all of the operations available in EnSight. Python allows a level of extensibility and effective variation that is not available via Journal files. Using Python for instructing EnSight is a whole large capability available to the users, and there is a whole section of the documentation focused on using Python driven commands for EnSight. Journalfiles do not have sufficient extensibility/variation to be used effectively.