| Release |
Enhancement |
Addressed Issue |
| 2023 Q2 |
Prophet Professional
Workspace Management
Coding Enhancements
- Model point definition variables now have an optional default value. If specified, the default value is returned if the variable is missing from the model point file. This optional default value can also be used with the READ_MODEL_POINT and READ_MODEL_POINT_TEXT functions. These functions now include a new optional parameter for the return value.
- The READ_FLEXIBLE_TABLE function now includes an optional error parameter. If specified, the error parameter is returned if the flexible table has missing values.
- The number of allowed input parameters for user defined functions has been increased to significantly improve the usability and flexibility of this functionality. Users can now specify up to 30 input parameters. This is limited to having a maximum of 10 array inputs with the other 20 being non-array inputs.
- General performance of user defined functions has been optimised in this release. Models containing user defined functions that output arrays may benefit from improved runtimes.
- Reporting Arrays have been optimised in this release by better identifying t-independent variables at preparation time. This may improve your model runtime if your model contains reporting arrays that are not being used.
Nested Structures
- The Inner structure of a Nested Structures run can now be split independently of the Outer run. Users can now choose the appropriate split method for the Inner run by enabling a new check box in the Outer Run Setting, on the Runtime Configuration tab, and then specifying a split type from the dropdown menu for the Inner run. The Inner structures can be split by product or by simulation.
- In addition to splitting the Inner runs independently of the Outer run, different structure links can have different split settings. This new feature allows for a more optimal split of the model leading to improved runtimes and more efficient use of machines. Users can choose if the Inner split type is “Specified at Structure Link Level” or “Specified in Inner Run Setting” and set up the run accordingly.
Aggregation Stochastic
- Aggregation Stochastic results can now be produced with the Flexible Results and Stochastic licence. An extra option is now available within the Aggregation Flexible Results definition.
Results are produced for each product, for each Aggregation definition and are of the form PROD_NAME.Stoch.AGGREGATION_NAME. Results are consistent with Aggregation projection results apart from having the simulation as an extra dimension.
A new function AGG_STOCH_RESULT has been added to Excel Reporting to allow the results to be extracted to Excel and a new Aggregation Stochastic query type has also been included.
The Flexible Results API and Insurance Data Repository have also been updated to support Aggregation Stochastic Results.
Note: Note that users cannot produce Stochastic Summary Results for Aggregation Stochastic. Please refer to the standard documentation for other limits and limitations.
Calculation Engine
The changes and improvements listed here for the Calculation Engine apply to both Prophet Professional and Prophet Enterprise and are therefore not repeated in the Prophet Enterprise section of this bulletin.
User Selectable Calculation Engine
- In this release we have made changes to better separate out the deployment of the Calculation Engine (CE) which is the set of components responsible for performing the evaluation of a model and its inputs during a run. These changes are designed to allow different versions of the CE to be installed side by side on the same set of worker machines.
One of the aims of this update is to allow future service packs for the CE to be deployed more minimally and easily without uninstalling existing components or altering non-CE components including the User Interfaces and Prophet Enterprise back-end services and databases.
The user can configure what version of the CE to use for a workspace in Prophet Professional (PP) or a job in Prophet Enterprise (PE) with suitable controls and default support allowing for the differing nature and usage of the desktop single-user orientated PP versus the server multi-user orientated PE.
Note: Note that there may be limitations on the future compatibility of the CE with respect to older versions of the PP and PE user interfaces, but the intention is for all CE service packs for the same version as the PP and PE user interface to be supported.
Note: Note that these changes are not applicable to versions of Prophet before 2023 Q2 and thus users will initially only be able to choose a single 2023 Q2 CE version to use.
I/O Improvements
- In this release we have made changes to reduce model-point I/O (file reading and writing), on the file server hosting the model points, in the preparation and execution phases of runs/jobs.
These changes should improve both performance and reliability since an overloaded file server can lead to run failures and stall the worker processes from performing the model calculations.
The enhancements either reduce I/O by combining actions on the same data together or move the I/O requests to files local to the worker through better use of worker model point caches. Specific enhancements include:
- Split by Model Point Batch should now generate less I/O during the execution phase. Previously the binary model point file would be re-read at the start of the execution phase to calculate the set of model point batches to split. This calculation has now moved to the preparation phase and uses a local copy of the file cached by earlier steps in preparation.
- Nested Runs would previously copy and read binary model point files multiple times for each product in model point maps in each nested step. We’ve significantly reduced the number of file-read commands by caching binary model point files on the worker.
- Table Optimisations with the Base Optimisation setting should produce less I/O during preparation. Previously the calculation engine would merge all same-as product model point files, for each base product, into a single file, then analyse the merged file. Now there is no merge, instead each model point file is separately analysed.
Note: Note that runs that use a single worker machine, where the model points are hosted on the same machine, will not experience the same level of performance improvements.
Stochastic Summary
- Significant performance improvements have been made to the calculation of Stochastic Summaries. Previously this calculation was only split by run number even if the main part of the run itself was split in a different way. This meant that it could be quite a slow process depending on how many variables and statistics were requested. In this release, the stochastic summary calculations are now split by product and accumulation meaning that it can be parallelised across the available workers.
Additionally, the stochastic summary calculations are now performed as part of the main part of the run rather than afterwards. This means that workers are kept open to process the stochastic summary calculations. It also means that the run finish time will now include the stochastic summary calculation time. Previously this was shown separately in the runlog.
We have seen improvements of up to 80% in the processing time on these stochastic summaries in some of our test cases. Exact performance improvements will depend on the number of products and the number of workers used.
- The feedback to the user in the run monitor has also been improved to give more information about which product or accumulation stochastic summaries are being processed at any one time.
Prophet Professional API
- We have updated the Prophet Professional API to enable users to get the status on whether the following Advanced Optimisation settings in the Run Structure are enabled or disabled. Users can also enable or disable these settings using the Prophet Professional API.
- Disable non global dimensions
- Accumulations process STO files for Products/Accumulations not in the run
- Select dynamic levels to repeat
- We have updated the Prophet Professional API to enable users to determine if the memory available for holding results in the Advanced Memory section of the Run Structure has been set to unlimited or minimal. Users can also specify whether this is set to unlimited or minimal.
- We have updated the Prophet Professional API to enable users to get the status on whether the Debug Dynamic Results option in the Additional Files section of the Run Setting is enabled or disabled. Users can also specify whether this should be enabled or disabled.
- In this release we have replaced XPS runlogs with PDF runlogs, as part of this change we have updated the Prophet Professional API. The option “RunLogOptionsXPS” in the RunLogOption enumeration is now replaced with RunLogOptionPDF. Note that ws.RunLogOptions = RunLogOptionsXPS is no longer supported and users will need to update their VBA scripts to be ws.RunLogOptions = RunLogOptionPDF.
- The DynamicProjResult function has been improved to:
- allow for a shortened input form for the time period. For example, 2022-12 or 2022-12_R_3. Essentially users no longer have to prefix the time period with the text “DynamicPeriod”
- provide a more informative error message if you enter an invalid dynamic loop.
|
Prophet Professional
- There was an issue with Results Diagram View for module links where they did not display correctly. This has now been fixed.
- We addressed an issue where some variables in a module link were not listed in the library definition display window but were visible in the module link definition window.
Prophet Professional API
- There was an issue with importing a workspace from Prophet Professional to Prophet Enterprise. The Run Log Settings selections for errors and warnings options in Prophet Professional were not coming through to the Logging tab of the workspace in Prophet Enterprise. This is now fixed.
Excel Reporting
- An issue when Excel Queries was not locking the results correctly on results copied from Arango (using the Copy Results functionality) has been corrected. Previously all queries were not refreshed and Excel ‘Not Responding’ messages could occur when the copy was still taking place whilst a refresh was started.
Calculation Engine
The addressed issues listed here for the Calculation Engine apply to both Prophet Professional and Prophet Enterprise and are therefore not repeated in the Prophet Enterprise section of this bulletin.
- Table caching (TMC) was being used for debug runs in Prophet Professional in such a way that table changes were not being picked up by the Calculation Engine in-between separate debug runs. TMC is now turned off for debug runs.
- An issue with using OPTION_FIRST_MODEL_POINT extended formula has been fixed. The issue involved the use of VAR_NAME to set the time values for the extended formula itself (not a member variable) and this not being initialised correctly if it was extended due to the first model point being skipped due to an error or IGNORE_MODEL_POINT. Any extra extended time values are now initialised correctly by the system.
- Code generation has been improved to further reduce the occurrence of “out of heap space” errors in compilers when producing product DLLs during preparation. For example, large units of code have now been split up into smaller parts to make them more efficient.
- READ_MODEL_POINT improvements have been made to address an issue when the value being read from the model point file was not the correct data type (text, number or enumeration) required. Data type mismatch issues should now result in an error rather than continuing with a zero value or empty text string. These errors are treated as product level errors. In addition, the RequiredType argument is now better validated to prevent free-form values being entered that
cause undefined behaviour.
- An issue where the exponential function (EXP) with a large input produced an infinite or “inf” return value (special type of number result) has now been fixed to produce an overflow error instead. This solved a problem with the CUMULATIVE_BIVARIATE_NORMAL function which was using the exponential function internally in such a way that the infinite values produced a NaN (“Not a Number”) value in downstream calculations. Some models may now need to have some defensive checks, for example better input validation, put in place to prevent errors that were previously going unnoticed as “infinite” values.
- The runtime logging options in Prophet Professional options were not being used correctly – default logging values were used instead for each run and any user alterations ignored and not persisted. This issue has now been fixed.
- Products that are part of a library with the property “Library for projecting assets as individual model points” set were not producing projection results for model points with an spcode greater than the “Last Sub-Product Code for Existing Business” setting in the structure. Instead, new business cross multiplication profile results were produced which is not applicable to asset library products. This has been fixed so that all asset product model points are treated as existing business and part of normal projection results, and a warning per product is issued in the runlogs to explain the misconfiguration of the model. This warning can be suppressed by increasing the structure setting to 9999 to suppress cross-multiplication completely, but this affects all products including liability products needing cross-multiplication or project new business, or by altering model points for asset products to stay out of that spcode range.
- An issue with preparation times when using lots of cores has been fixed. Previously no preparation tasks would be processed until all the worker processes had been initialised which could result in a noticeable lag. Now the call to initialise workers is done in parallel to processing the tasks so that as soon as some worker processes are initialised, they can start processing tasks while other worker processes are yet to fully come online. Given the limitations of Prophet Professional model preparation, in terms of being limited to both a single machine and the number of cores it can use, this issue was far more noticeable on large scale Prophet Enterprise environments.
- The system variable PROJ_TERM_Y is meant to be an integral value representing how many years of storage is needed for t-dependent variables. However, the system did not enforce that the user expression for PROJ_TERM_Y resulted in an integer, and its subsequent use in other variables could cause errors to occur with results reading or accessing variables out of bounds. The system will now force the value to be an integer, consistent with the casting
previously done when allocating time storage, so that any other variables using it are consistent.
- A problem previously occurred when an accumulation was run (without any products) and stochastically read product results from a previous run. Instead of accessing each simulation accordingly, the accumulation was running the first simulation repeatedly. This has now been fixed.
- The EXP function was previously returning an underflow error on a large negative number. EXP(-X) will now return 0 as X becomes large.
- The use of a variable called NB_SCALAR would incorrectly scale results by the value of this variable. This has been fixed.
- In a nested structures run, the summary section of the runlog for the outer run was missing the number of errors and warnings for in the inner run. This has been added back into the runlog so that errors and warnings can more easily be traced back to their source.
- We have changed the behaviour of retaining simulation results from a previous run such that if the model point file is changed between the two runs then the second run will be prevented and first run will need to be repeated. This is to ensure consistency of results.
- It was previously possible to get inconsistent results depending on whether a READ_RESULT to another product was read from memory or disk. This was caused by the variable not being written to disk as it was not in the output group and hence zero was read whereas when read from memory the correct value was accessed. To avoid this inconsistency an error will now be given in both cases if the variable being read is not in the output group. In many use cases Prophet is able to determine what variables are needed and to add them to the output group automatically. However, in some cases this is not possible. This may now cause your model to fail with an error that the product is unable to read the variable from the lower-level product. If this happens you will need to make sure that all variables that are missing but are required to be read higher in the structure are included in the output group (which is set in the run setting).
- When processing accumulations in a model when using the ‘Minimal Memory Mode’ option results to be accumulated were stored in memory. Now this memory is released. This has the effect of reducing memory peaks significantly for some models that make use of this option. However, if multiple accumulations read the same results files then performance may be affected as the results then need to be read from disk.
- An issue caused when an accumulation having no results to accumulate and dependencies between products was not handled well by the system code. Instead, it resulted in a “Failed to load Structure Analysis file” error. This has been fixed.
- Previously we had an issue where products that use READ_MODEL_POINT did not return an error when the variable did not exist in the model point file. This has now been corrected.
- When running a model with no generic tables provided, the runlog and output window in debug view has now been improved to show “Generic Table could not be read: . Invalid argument”.
- There was an issue when a user tried to use the READ_GLOBAL function in debug mode. It would fail at preparation stage. This has now been addressed.
- An issue when a user requested only product total results but received all SPCODE result files as well has been fixed.
- An issue where READ_RESULTS might cause errors with SAME_AS products has been fixed. This was caused when the variables needed by the higher-level products were different for each product.
- There was an issue when running a run pair with base products and same-as products with the run pair split by product. If the diagnostic files were selected in the structure, the run failed due to simultaneous access to the diagnostic files by the base products and the same-as products. This has now been fixed.
- There was an issue when using TMPO set to BASE and products having switch statements in them. Preparation sometimes failed depending on the tables and model. This has now been fixed.
- There was an issue where negative parameters in extended formula arrays were returning values and not erroring. For example ARRAY(0,-1) was instead returning the value for ARRAY(0,0). This has now been fixed.
The bullets below detail some improvements to performance that have been made in this release.
- We have fixed a performance issue relating to results reading functions where Parallel Model Point Processing (PMPP) is turned on. Improvements can be observed when using READ_RESULTS or CALL_DLL functions and where the model has a lot of reading and storing of results.
- A performance issue reading results from another run when there are lots of run number results present has been addressed.
- We have made a small performance improvement to models which have large numbers of aggregations and model point variables.
- We have made a small performance improvement to PROJ_RESULT and STOCH_RESULT. This should be particularly evident when using a large Excel spreadsheet making lots of these function calls.
- There was an issue with a longer run execution time due to Projection text results (PRN) being written out twice; once by the worker and the second time by the task master. This has now been fixed by only writing out the results once from the worker.
- If a model accesses local memory or results from disk then different results could occur if a result is calculated by a lower-level product and read into a higher product or accumulation. In this case, if the read result is not output due to the target variable group and Prophet is unable to determine the variable required at preparation time, then a value of 0 would be written to disk. However, the actual value, calculated at runtime, will be in memory. If a run is split across machines or cores, then Prophet would access the disk result. If it is a local run, then Prophet would access the memory.
We have now made this consistent such that both a local run, and a run split across multiple cores, will return an error. To ensure no error is reported the user should ensure that any variables being read by higher level products are included in the target output variable group.
Flexible Results
- We have made some small performance improvements to the calculation of Aggregation Projections. This is particularly noticeable when the model has a large number of model point variables.
- We have improved the warning message when an invalid aggregation value exists in the model point file. This should help the user to identify the problem line in the file more easily.
- An issue where Prophet Professional results view, and Excel returned different numbers for Aggregation Projection Results has been addressed.
- An overflow issue previously caused values for Aggregation Projection results to return 0 in Excel. This has been fixed.
- An Individual Policy run incorrectly required the master product to be included in the Individual Policy Results definition even if it was not included in the run. This has been fixed.
|
| 2022 Q1 |
Prophet Professional
Calculation engine functionality
- Enhancements have been made to looped modules. We now allow for rebasing to be applied in products that use looped modules. This provides additional flexibility to modules and also the use of AVX processing.
- The outer run pair that contains a nested structure can now be non-dynamic. This enables users to easily switch between a point-in-time calculation or projection.
Calculation engine performance
- ENUM_SIZE calls are now replaced by their values at preparation rather than evaluated during the execution of the model. This helps preparation to simplify IF conditions that use ENUM_SIZE, in order to reduce the amount of model code that needs to be compiled and executed.
- A redesign of binary model point files has significantly improved the performance of these files. Whilst the writing of these files should see some performance improvement, the main difference will be observed when reading the data. Opening large binary model point files directly in Prophet Professional should appear quicker and more responsive, as should using these files through the Flexible Results Application Programming Interface (FR API) and Insurance Data Repository.
- In this release we have made changes to improve preparation. This has been achieved by making changes to new business processing as well as checksum input/output operations with an aim to reduce IO across the network.
- We have reduced the number of network operations involved in getting information from tables and model point files during run execution. For assumption tables stored in a remote file server, the Prophet Worker can now store and read them locally rather than reading the same tables multiple times across networks. Similarly, model point files from a remote file server can be cached in the local worker machine at machine level rather than at the worker process level. The cache is temporary for each job and is used by multiple worker processes thus reducing network IO. Cached files can be utilised for multiple run numbers of the same job. However in this release, we don’t support caching of stochastic (FAS) tables and the following run types:
- Nested Structures
- High Performance Computing
- Assumptions Manager/Analysis of Change
- Deterministic runs on General Insurance Reserving Interface.
Prophet Professional API
- We have added more methods in Prophet Professional API to remove accumulations and products from accumulations. Users are now able to do using the API as well as the Prophet Professional user interface.
- Users can use the Prophet Professional API to enable the Use in memory dynamic/stochastic calculations option or the Apply strong t-limiting option in product properties. This allows users to use Prophet Professional API to set up a model and enable these without having to open Prophet Professional.
|
Prophet Professional
- Prophet uses Firebird to manage and structure data within workspaces. The Firebird Database Engine has been upgraded from version 2.1.3 to version 3.0.6 as part of routine maintenance. When you open a workspace on a remote file server running an older version of Workspace Server with Firebird Server version 2.1.3 running, the workspace is copied locally and workspace sharing functionality is not available. Users who want to maintain previous functionality should upgrade their Workspace Servers to use the latest version.
- A blank screen when viewing save point results in some models has been fixed. This was caused by missing information in some of the results files.
- Restoring a large workspace has been optimised so Prophet no longer remains unresponsive before being able to restore. The time taken to display the Restore dialog has also been reduced.
- The time stamp of a backed-up workspace (pbuz or pbu) was previously changed during the restore process. This has now been fixed and the time stamp of the backup remains unchanged after a workspace is restored.
- The search time in a library with modules has been improved by caching module inputs during the search. Furthermore, a new option, Shallow Search, has been introduced to enable users to speed up the search further by ignoring default module inputs.
- When duplicating a User Defined Function (UDF) which is in a locked book, users were previously unable to amend the book setting of this duplicated UDF. This has now been enabled.
- Some workspaces were particularly slow when saving model point files in Prophet Release 2021 Q2. This has been improved in this release.
- An issue with opening a workspace using the General Insurance Reserving Interface has been resolved. This issue occurred on a Network Attached Storage (NAS) Server or Windows File Server without Firebird installed.
Prophet Professional API
- Using the Prophet Professional API, users can now open a workspace located on a remote file server that does not have the Workspace Server installed.
Excel Reporting
- An issue was found when using mixed-case or lower-case product names in Excel Reporting’s Stoch_Summary function. This could cause the cache to mistakenly reload and parse the stored cache values from disk for each call, causing poor performance. This issue has now been fixed.
- An issue was found where refreshing Excel Reporting did not update the Dynamic_Result calls even if the model had been rerun and their values had changed. This issue has now been fixed.
- Stoch_Summary error handling in Excel Reporting has been improved so that invalid summary names now return an error rather than zero.
Calculation Engine
- Intermediate results are results that are output by the Calculation Engine and deleted at the end of the run. This folder is now named IntRes and not IntermediateResults in order to reduce path lengths, which can trigger Windows file IO errors during a run.
- In Release 2021 Q2 we made some improvements to the performance of PROJ_RESULT when a large quantity of run numbers were available. PROJ_RESULT allows results to be read from one run number to another. However, when a large quantity of run numbers are available in the results folder Prophet was previously checking each one, which had a performance impact. This has been improved significantly enhancing the performance of runs that have this scenario.
- If an annual generic table definition was used in an AVX-enabled looped module, a compiler error would result during preparation. This has now been fixed.
- If a block of code in an AVX-enabled looped module referenced the same variable at two different fixed time periods, it would result in a compiler error during preparation. This has been fixed.
- If an AVX-enabled looped module array variable had some elements that were module loop dependent and other elements that were module loop independent, then a compiler error during preparation would occur. This has now been fixed.
- The error messaging has been improved when accessing a normal array variable out of bounds using an integer literal in the array dimension.
- There was an issue that prevented a compiler error appearing when passing a string array into the READ_MORT function. The calculation engine now provides a sensible error during preparation that the passed-in argument is not the right data type.
- Error messages have been improved for modules. When modules contain missing variables that are only referenced by other module variables, the error message is now clearer, enabling users to identify the source of the problem.
- Improvements to nested structure table map validation now prevent a compiler error occurring when a non-array variable is passed as a table key. Instead, a more meaningful error is produced.
- The model point data type validation has been improved so that integer variables in the model, either optimised by the system to be integral or special system variables such as DURATIONIF_M, now check and error if a field being read from the model point file is text rather than numeric. Previously it would silently use 0 instead. Floating point variables already performed the same check and thus all numeric variables reading model points are now consistent in their checking. Note that a non-integral model point field being assigned to an integral variable will be converted to an integral value without warning or error.
- A bug has been fixed where T-dependent extended formulae, that used VAR_NAME to assign values for storage, caused variables to not be calculated for the correct time periods required by the model.
- When module array variable outputs were referenced by the parent product without specifying their dimensions, preparation would incorrectly t-limit some of the array elements. This has been fixed.
- In the dynamic runs with expiring model points, that use array variables with NO_CALC in their definitions, some array elements could have uncalculated values that would appear as blank or -1.23E-300, depending on the results viewer, rather than zero; additional checks have now been put in place to better prevent this happening to cumulative variables.
- Split-by-product dynamic runs with dynamic debug results switched on would not correctly produce per policy projection results. This has now been fixed.
- Split-by-product runs were not producing projection result text files when requested by the user. This has now been fixed and per-policy projection result text file support added as well.
- An issue where inner same-as product metadata was not copied into nested structure save points, causing those results to be inaccessible or invisible to users, has been addressed.
- Large models with many variables, including array variable elements, could trigger a compiler error regarding it as being out of heap space. Code generation during preparation has been altered to try to prevent this issue.
- In certain circumstances Prophet could use a compiler other than the workspace-configured compiler if the latter was not installed, for example it could use an installed Microsoft 2019 compiler rather than a user-requested Microsoft 2017 compiler. This issue has now been fixed and a suitable error generated that the required compiler is not installed.
- An issue with PRINT_TO_FILE error handling has been fixed. Previously if the output file could not be created or opened, for example because the path was too long, no error would be produced.
- An issue where PRINT_TO_FILE would truncate lines of output more than 1000 characters long has been fixed.
- Certain models using persistent extended formula arrays would cause extended formula diagnostic functionality to trigger a runtime error about accessing an uncalculated element of a persistent array. This issue has now been fixed.
- In certain circumstances models using structure targeting and module links could fail to run unless structure files folders were deleted in the workspace before running. This issue has now been fixed.
- User-defined functions were not always code-generated and compiled correctly when structure targeting was enabled. This resulted in an undeclared identifier preparation error. This has now been fixed.
|
| 2021 Q2 |
Diagnostic files
Diagnostic files can be produced at runtime to help identify code generation errors, analyse performance and optimise model code. In Release 2021 Q2 Service Pack 9 we have made significant improvements to the following diagnostic files to enhance the information available:
- Product/Module diagnostic file.
- Runtime diagnostic file.
Two new diagnostic files have also been developed for Release 2021 Q2 Service Pack 9:
- Structure diagnostic file.
- Extended Formula diagnostic file.
Enhancements to product and module diagnostic files
Compilation diagnostic files and a runtime diagnostic files can be produced by the model. Across these two types the following enhancements have been added:
- More information on the variable properties.
- Details on a variable’s storage in memory.
- Justification for inclusion of a variable in a product loop (calculation, rebase or goal-seek).
- Information on the table and function usage of the variables.
- Complex time reference information.
- In-memory dynamic storage and sequencing information
Structure diagnostic file
This new structure diagnostic file gives information to the user about the objects within the structure such as the products, modules and accumulations. The following information is included:
- Structure object information.
- Memory usage information for IMD/IMS persistent variables.
- Total memory usage for a product.
- Total runtime for a product.
Extended formula diagnostic file
This new extended formula diagnostic file gives information to the user about the extended formula variables used in a product. The following is included:
- T-dependent and persistent information.
- Information on the resizing of arrays.
- Memory usage of extended formula members.
Flexible Results
We have made improvements to Flexible Results for 2021 Q2 with enhancements to aggregation results, the Flexible Results API and the Prophet Professional API.
Aggregation results
Released in 2020, aggregation results enable you to generate projection results aggregated by a model point variable of your choosing, called the aggregation variable. This results type has been enhanced for Release 2021 Q2 Service Pack 9 so that they can be calculated in dynamic runs.
Dynamic aggregation results are calculated using the in-memory dynamic method and can only be calculated for existing business. They are stored for the final dynamic loop, and are not written as part of dynamic debug output, save point results or for variables calculated within a module.
Further to this, aggregation projection results are now available for queries within Excel.
Flexible Results API
- It is now possible to return Metadata regarding run settings, audit data on the tables used, number of model points read per product, runlog messages and additional product information can now all be obtained using the API.
Prophet Professional API
- A new property has been added to the API to retrieve the number of policies selected in an individual policy results definition.
Calculation Engine
In Release 2021 Q2 Service Pack 9 we have made a number of improvements across several parts of the calculation engine:
- Users can now produce individual policy stochastic results without producing standard stochastic results by clearing the Include Stochastic Results check box in a run setting.
- Subsequent dynamic periods of nested structure runs have been enhanced to allow structure link skipping to happen for each year up to 20 years.
- We now support Prophet code compilation using the 2019 edition of the Microsoft Visual 2019 C++ compiler. We no longer support compilation using the 2015 edition.
Module links
In Release 2021 Q2 Service Pack 9 we have introduced several enhancements to reduce recalculation of in-memory dynamic products by decreasing the number of post-decision variables. Additional changes have also been included to enable better use of this new functionality. Changes include:
- Module links will now be evaluated to be pre-decision where possible. This prevents the recalculation of the entire module link in later dynamic loops. If the module link contains any decision variables then the entire module link is set to be post-decision.
- Module input sources can now be defined to take the value from a specified time-period. This allows the timeperiod for a t-independent variable to be determined and fixed for all dynamic loops. In turn this can remove a dynamic decision and can again improve recalculation.
- Goal-seeking loops are now pre-decision by default, if any part of the loop is found to be post-decision then the entire loop will be converted to be post-decision.
Note that these changes may result in some differences in the output of results due to more variables now being predecision. Specifically:
- When a variable is pre-decision it will not be included in new business SP code transfers. This may result in some differences in the results for new and existing business SP codes, however the results for SP code 0 will be unaffected.
- Individual model point output values are zero for all pre-decision variables.
- Pre-decision goal seeking loops may see changes due to the absence of recalculation, if this recalculation is required then you may force the loop to be post-decision.
Intex plugin
In Release 2021 Q2 we have made a number of improvements to Intex. These improvements have been focused on allowing modellers to use Intex more efficiently.
- A new function has been added to extract collar information about a tranche.
- A new function has been added to extract schedule dependency information about a tranche.
- A new function has been added to control whether all tranches for a deal or just those needed for a requested tranche are calculated when extracting cashflows.
- Two new functions have been added to snapshot and reset the state of the PAY_TO_PAY functionality so that you can project forwards from a common future date under different index or prepayment assumptions.
User interface enhancements
In Release 2021 Q2 Service Pack 9 we have made a number of improvements across several parts of the user interface:
- Auto-scan on products has been improved, reducing the amount of time taken to scan a large number of products with modules.
- The time taken to open Product Diagram View, a library or a product has been improved.
- Opening, editing and duplicating a table is quicker than previous release.
- A new tab has been added on the Product Schedule and Module Schedule called User Defined Functions, allowing users to see which variables from the selected product or module use UDFs.
- The ability to use Find and Replace functionality has been added for user defined functions within a library.
- Advanced compare options Ignore Module Links and Shallow Compare have been introduced to speed up the comparison on products or libraries with modules.
- Users can import books directly from a library in a standard workspace without having to create the standard workspace first.
- Prophet Viewer is now able to open larger files.
- It is now possible to delete objects in a workspace using the API.
- Some of the Calculation Engine options on the Options dialog box have been reorganised. A new tab called Runtime Settings has been introduced. It contains options for Compilers, Calculation Engine Settings, Module Settings and New Business.
Licensing
The following improvements have been made to the Prophet licensing technology:
- In the Client Licence Server (CLS) there is new Export functionality, allowing you to export the filtered on-screen data to a csv file. You can export data from the following tabs: Licences, Licence Consumptions, Synchronisations, Users and the Clients details tab (for a specific client machine).
- CLS users now have roles. User permissions have been split into two roles – Administrator and Licence Administrator – allowing you to better manage CLS user access and entitlements.
- The Administrator role is for those users responsible for server maintenance, ensuring its connectivity with both the FIS Licence Server and Prophet users. These users also have permission to create and delete CLS users.
- The Licence Administrator role is intended for those users tasked with administering the licences themselves, for example, adding users to a group licence and looking at licence consumption history.
- In the CLS portal, users now have the option to remove multiple group licence users in one go from the group licence Users tab. Previously, users would have to be removed separately.
- A new option has been added to the CLS installation giving you the ability to change the CLS hostname to the fully qualified domain name. Previously the hostname was set to the ‘simple’ name of the server on which the CLS was being installed by default.
- You can now view a detached licence’s products and features on the detached tab in Prophet Licensing.
- The CLS user documentation is now provided as HTML5 help embedded in the CLS portal, to make the documentation much easier to access. The help is completely accessible from within the web browser, with no read access to the CLS installation directory required.
|
Prophet Professional 2021 Q2 Service Pack 9
- The Solution Installer failed to install some workspace templates when Prophet Professional 2021 Q2 Service Pack 8 is installed. The issue was related to the Firebird upgrade in Service Pack 8. This issue has been resolved.
- Projection text results (PRN files) were written twice; by the workers after each product and again by the taskmaster at the end of the run pair/job. This could lead to longer run execution times. They are now only generated by the workers.
Prophet Professional 2021 Q2 Service Pack 8
- There was an issue of running several runs continuously in a model with modules and same-as products. The issue was due to some missing system files of the same-as products. This issue has now been resolved.
- In this service pack the version of Firebird used has changed from 2.1.3 to 2.5.9, which has the following implications for upgrading workspaces in Prophet Professional. A workspace may only be opened in a newer version of Prophet Professional by going down or right in the table below.
If you try to open a workspace in a different order, you will be presented with the following error message:
If you try to open a workspace with a lower Prophet version, you will see a standard warning message before upgrading, “This Workspace was created using an early version of Prophet. Do you want to update it to the current version?”. If select “No”, nothing will happen, and the workspace will close. If select “Yes”, the workspace will be forcefully updated, and a new IBB file will be created.
- A warning message has been added during workspace upgrading process if there is a change in an internal file format between different service packs of the same Prophet Professional Release Version. Once upgrade to a new internal file format, users won’t be able to open the workspace in a lower service pack version.
Prophet Professional 2021 Q2 Service Pack 7
- An issue of being unable to view any variables in Module (Results) Diagram View for pre-decision module links has been resolved.
- There was an issue where pre-decision module link output was not persisted beyond the first dynamic loop iteration. This issue was related to not correctly producing the right type of module link DLL for pre-decision vs post-decision module links and has now been fixed.
- There was a merged code preparation error with pre-decision module link t-independent outputs that only feed directly into post-decision module link inputs with no product variable accessing or storing the output. This has now been resolved.
- There was an issue with PMPP mode running significantly slower than non-PMPP when the model was making intensive use of READ_RESULTS function due to a critical section in the error handling logic. This has now been optimised and will also benefit models that make intensive use of table reading functions and plugin calls where similar logic applied.
- There was an issue with extended formula diagnostic output when time dependent extended formula containing persistent members used QUIT statements to prevent calculations for some time periods. This caused the run to fail with an error: “attempt to use an uncalculated element of a persistent array”. This has now been resolved.
- There was an issue with pre-decision conditional module links where the condition flag was set to false in the first dynamic loop iteration. This caused a structured exception and has now been resolved by clearing the module link calculated flag for subsequent dynamic loop iterations and allowing the condition to be re-evaluated.
- There was an issue where models were failing in preparation with “out of heap space” errors. Code generation has been optimised by splitting up large code blocks in areas of the code generation known to exhibit this problem. This should reduce the occurrence of this problem.
- There was a calculation engine issue caused by module inputs/outputs being in a different order in the parent product and the modules. This manifested as the wrong data types being passed between module and product and related errors occurring such as expecting an array variable but not receiving one. This has now been fixed by making sure the parent product and module code generation are consistent.
- There was a run failed, with no errors reported, issue when re-submitting certain (previously) successful run pairs that use modules. The run pair failed due to erroneously detecting certain module link meta data results files were missing when in fact they were not needed. This has now been resolved.
Prophet Professional 2021 Q2 Service Pack 3
- An issue whereby Excel Reporting could not access results when using copy result functionality and modules. The error reported an issue with a missing metadata file. This has now been fixed allowing such files to be read correctly using Excel Reporting. Note this issue has also been fixed in 2020 Q2 Service Pack 4.
- An issue with PMPP was introduced in Prophet 2020 Q2. For run pairs that would inevitably fail, doing the run with PMPP switched on would not output the error messages in the runlog. This resulted in the runlog saying that no errors had occurred, and the user could not see why the run had failed.
Prophet Professional 2021 Q2 Service Pack 2
- There was an issue installing the Client Licence Server because some machines didn’t allow the user to elevate PowerShell execution privileges. This has been fixed in the CLS installer.
- PRINT_TO_FILE allows users to print data during runtime to a specified file. There was a bug that prevented the file from exceeding 1000 characters. This has now been fixed.
- An issue where save point results for a nested structures model were shown as empty has been resolved.
- An issue where metadata in the FRAPIResultsSource.GetRunNumberList() method was returning default values for jobs with a failed status has been fixed so that data is returned if available.
Prophet Professional 2021 Q2
User interface
- An issue with saving extended formulas in Formula Editor has been resolved.
- When importing and replacing an existing locked book where a variable is no longer in the source book, instead of removing the variable from the target library, users can now choose to delete or retain the variable in the library.
- Users can now import and replace an existing library when the source library has variables removed from a locked book within the source library. After importing, these variables won’t be in the locked book but will remain in the library.
- An issue of finding and replacing column headings in tables has been resolved.
- Duplicating a product would previously keep that product in memory. Making changes to the product, such as deleting input variables or rescanning, would not affect that stored product, therefore doing a comparison to the original product would show no differences until the product was opened and closed again. This has been fixed.
- Performing a Prophet backup on a workspace with a space in the path could miss some files from the backup. This has been fixed.
- An issue with date and time stamps updating incorrectly when importing a product into a workspace has been fixed.
- In the main user interface the first letter in a new product will always be capitalised. With the Prophet API it was possible to create products with the first letter in lower case, and if you ran such a product then the results would be created incorrectly. This has been fixed so that the API is now consistent with the user interface and the first letter in new products is always upper case.
- User Defined Functions (UDFs) are now correctly imported when importing a product to a workspace.
- The ability to prepare module code for every product-module pair is directly linked to the choice of the Fast runtime or Fast compile setting. The use of product-module link pair with fast runtime caused the preparation of some models with lots of module links to be adversely affected. We have made a number of changes to correct this.
Fast runtime users can now choose whether to prepare based on the module or the module link. This is done through a check box on the module link form.
Note: By default this option is hidden and switched off; users can make it visible from the Options dialog box.
The Fast compile option was not affected and remains unchanged.
- A bug that meant the Run selected policies only option in the runlog was incorrect for runs producing individual policy results has been fixed.
- A bug that meant results from the incorrect dynamic loop could be returned when viewing dynamic debug results for individual binary model point output has been fixed.
Calculation engine
- A bug in which reading outside array bounds fails in descending optimised loops for 2-dimensional arrays has been fixed so that zeroes are returned outside the array bounds.
- A bug that could cause structured exceptions when an extended formula array resized while being read has been fixed.
- An issue that meant aggregation results models containing extended formula variables would occasionally fail has been fixed.
- A bug has been fixed where some looped module inputs, that vary by loop iteration and are used directly in IF conditions, were not updated for each loop iteration within their dependent module formulas.
- The error handling of the ARRAY_MAX function has been improved to prevent structured exceptions in some cases and make clearer where the syntax is incorrect in other cases.
- A syntax-checking bug has been fixed that caused incorrect formulas, with respect to data types and comparisons, to not be caught properly. This resulted in malformed C++ code generation and a “merged code error” with C++ compiler messages that would not be understandable in terms of the underlying fault in the model’s definition.
- A t-limiting bug has been fixed that caused errors involving uncalculated values and out-of-bound time references to be masked and zeroes silently used instead.
- A t-limiting issue affecting t-independent extended formula, sequenced in the same calculation group as variables that are not t-limited, has been fixed. This issue had caused extended formula variables to appear in the DGN but not actually be executed and was observed due to incorrectly ignored breakpoints in the Prophet Debugger. Perturbing the sequencing by adding in references to the affected extended formula had been the only workaround prior to the fix.
- An introduced issue has been fixed whereby t-limiting information was not passed properly between module and product when using array variables and rebasing.
- An update to the 2017 and 2019 compilers, to fix a C++ defect, caused existing Prophet code generation to start failing. Prophet code generation and compiler flags have been altered to comply with the new rules.
- The validation check that ensured that each data row in a model point file had the same number of columns as the header, after allowing for treating consecutive column delimiters as one column delimiter, was only working on the first data row. The check has now been fixed to all the model point data rows.
- An inefficiency that causes empty or zero-filled results files to be produced for unexecuted products, when a run is aborted, has been fixed.
n An issue where lots of small files and empty subfolders were left behind in the Prophet temporary directory after a run finished has been fixed.
- We have addressed an inefficiency in the handling of dynamic debug results files in order to reduce the number of unnecessarily repetitive file operations. In addition, the code for creating a sub-directory, whose parent folder(s) may not exist yet, has been optimised to further reduce file operations.
- The logic for moving or copying a file over the top of an existing file was inefficient and could fail if the file server did not delete the existing file in a timely fashion, for example due to anti-virus scanning. This issue has been addressed.
- A performance inefficiency in READ_RESULTS has been fixed that particularly affected products that read a lot of results such as Summary products or ALS External.
- An inefficiency in the results formats introduced in 2019 Q2, that caused the results to include unnecessary data repetitively, has been addressed. The issue was most noticeable when using stochastic results on the file system where the number of variables and time periods per simulation was low. However, the issue still represented an inefficiency for other results types such as projection, especially when variables and time periods were heavily trimmed by the user.
- An issue causing runs to display “invalid date/time string” warnings in the run monitor has been addressed. The issue was compiler-related and only affected certain regional settings in a non-deterministic manner.
- An issue has been fixed where reading a pre-existing accumulation’s stochastic results, during a new stochastic split by product run that reads but doesn’t rerun the accumulation, caused them to be altered.
- A bug that meant projection and individual policy projection text results would not be produced when running split by product has been fixed.
n In the previous release if you changed the selected variable group on an aggregation results definition post-run then every product selected in the definition was regenerated. This has been fixed such that only the products affected by that change in variable group are regenerated.
- An issue where certain results types, when using the file system for results storage, are appended to for each dynamic iteration rather than replaced, has been addressed. This caused certain results to grow significantly bigger than pre-2019 Q2 results. To fix this issue, t-independent variables are only output in the first dynamic loop for aproj, astoch, pproj and pstoch. This also prevents additional issues where t-independent cumulative variables, including ones that do not vary by dynamic loop start date, effectively reduced significantly as policies expired across dynamic loop iterations and where the sum across aggregation values might not agree with the totals when one or more aggregation values ended up with no more active policies left to process prior to the end of the dynamic loop. These latter issues still exist for legacy results types, with respect to spcodes, such as projection and stochastic.
- An issue where Prophet does not release memory from its results cache when the operating system is running low on free physical memory, has been addressed. This affected machines with a small amount of memory installed or 64-bit results reading processes and caused such processes to fail with memory errors. Processes that read Prophet results and are affected by this include Excel and Prophet Results Database.
- An inefficiency with the READ_RESULTS function was introduced in Release 2019 Q2 where the Calculation Engine (CE) checked the results frequently to identify whether a requested result was part of a product or accumulation. This involved checking whether the requested product or accumulation was part of the currently executing run pair, and if not, checking whether it was part of the pre-existing workspace results, which is relatively expensive in terms of run time. Performing this check repeatedly for every READ_RESULTS call could significantly impact the runtime of products using lots of READ_RESULTS calls, for example Summary library products. If the workspace was located on a remote location to the worker(s) then the performance impact could be more adverse. This issue affected models where a lot of products and accumulations results being accessed were either missing or not part of the current run pair. This issue has now been fixed.
- Prophet 2019 Q2 introduced an issue in which all variables for a particular set of variable-by-time results are loaded into the results cache when a single variable is requested. The issue only affects the CE results-reading runtime functions PROJ_RESULT and STOCH_RESULT and the Excel Reporting worksheet functions of the same name. This can cause a significant memory increase during runs which access a small subset of variables across a large number of these sets, for example a summary product accessing a small set of variables across a large number of products and sub product codes using the affected functions. This issue has now been addressed for results stored using the file system directly but not for results stored using ArangoDB.
- Two threading issues in the Prophet 2020 Q2 Calculation Engine that affect PMPP have now been fixed:
- If using PMPP and READ_FLEXIBLE_TABLE it was possible to get a putResults error of the type “concurrent or recursive” calls.
- If using PMPP and modules it was possible to get a structured exception when two DLLs both tried to load the same table at the same time. Depending on whether fast runtime or fast compile was used in the structure, or whether a module link was set to be looped, a DLL could represent a single module shared amongst module links in the same product or individual module links.
- An issue where the Calculated variables run structure option was being used with rebasing and modules has been fixed. This issue could affect results due to variables being put in different positions in the rebase loop.
Excel Reporting
- An issue involving the time taken for Excel Reporting to open projection results has been fixed.
- In previous versions, on the Prophet tab of the ribbon in Excel, if you clicked Options and then cleared the default selection of Show Variable Errors, an “unset nullable” error was returned instead of zero. This issue has now been resolved.
- An issue has been fixed involving Excel Reporting queries not executing properly if worksheet functions were called first and the results subfolder was passed in as the result store location to the query.
Prophet Results Database
- When using the -sbp and -show parameters together, the child processes would be closed before any errors could be viewed. This has been addressed so that if any information has output to the child processes, they will be paused so they can be viewed and closed by the user.
- An error which appeared when uploading ArangoDB results created using overridden results directory names has been fixed.
- Uploading pstoch results without pproj results previously resulted in empty tables for both results types, this has been fixed.
- In the last two releases, users would get an error and failure to create the AUDIT table when importing Analysis of Change jobs. This has been fixed.
Licensing
- Validation has been inserted to prevent detached licence users from changing their Client Licence Server (CLS) configuration details in Prophet Licensing, as this renders the licence unusable.
- At CLS installation, in cases where startup of the CLS Windows service took longer than 90 seconds, the installation could fail with error code 1920. A change to the CLS installer should mean this error no longer appears.
- Robustness of the CLS Windows service has been improved by removing a database shrink operation.
- Email verification in the CLS has been improved such that you can no longer add duplicate user email addresses to the same group licence.
- There was an issue recording licence consumptions in the CLS portal when the CLS machine’s disk was full. This has been fixed so that now if licence acquisition works then the consumption is correctly rendered in the CLS portal.
- Some settings changes in the CLS require a restart of the CLS Windows service to take effect. However the message informing CLS users of this was easy to miss. The instruction to restart is now clearer.
Installer
- The installers now include 2019 C++ runtimes as a prerequisite rather than relying on them having been deployed with other Windows updates.
Plugins
- An inefficiency in the Intex plugin has been fixed so that we no longer request the underlying Intex API produce output that can’t be accessed by a call to the Intex plugin.
- A missing ADCO DLL that was only needed when using ADCO implicitly with Intex, via the INTEX.DEAL function call, has been added back into ADCO Plugin version 2.2.
- Intex has dropped support for calling ADCO directly from within their software to get prepayment rates. This functionality no longer works and resulted in a structured exception in the Intex plugin for versions 3.4h onwards. The Intex plugin now does a check to error gracefully if you try to use the ADCO prepayment method when calling INTEX.DEAL. 3.4f_p2_sp1 is the last Intex plugin to support this method. We are working on an alternative approach for a future release.
- A bug has been fixed in the Intex plugin affecting the PAY_TO_PAY function when requesting certain results types such as WAC, WALA or collateral balance ratio. The problem was that a weighted average calculation did not divide by the sum of the weights at the end.
|
| 2020 Q2 |
Flexible Results
Aggregation results
With Release 2020 Q2 Service Pack 3, for Flexible Results users we have introduced aggregation results as a new results type.
For those with a valid licence, aggregation results enable you to generate projection results aggregated by a model point variable of your choosing, called the aggregation variable. Aggregation projection results can be created for up to two aggregation variables per product in addition to the existing sub-product aggregation functionality in standard projection results.
With the effective date of IFRS 17 and US GAAP LDTI approaching, aggregation results have been designed to help companies report across different groups of insurance contracts. They provide a simplified method of summing values across multiple model points in a contract group by reducing code and can result in faster runtimes.
To facilitate this new results type, a new Aggregation Results Definition workspace object has been created. This workspace object, which you later include in the Results section of the run setting, is where you define the variable that your new results type will be indexed by (the aggregation variable), the products for which the results should be generated and the variables that you will get in your aggregation results output.
The aggregation variable can be a number or text data type, making it more versatile than the SPCODE grouping for standard projection results. The new results definition can also be created, edited and added to your run via the API.
Aggregation results can be viewed directly in Prophet Professional, Results Diagram View, Results Viewer and with Excel Reporting through a new AGG_PROJ_RESULT function. As well as the Excel Reporting function, a Prophet runtime function by the same name is available to read aggregation results from another run.
For this first release, aggregation results are not supported for stochastic and dynamic processing. They will also only be produced in conjunction with the New Business in Model Point File new business method.
Individual policy results
Individual policy results, previously only available to clients with a Production Interface licence, are now also available to users licensed for Flexible Results. Individual policy results allow you to create projection or stochastic output for specified policies in your model point file, up to a 100 policy limit. Note this differs from individual model point output which is for all model points and can only be produced for up to two time periods.
The specification of these results adopts a similar approach to aggregation results, via a workspace object which can then be referenced by multiple run settings. Individual policy results can also be set up via the API, read via the POLICY_RESULT Excel Reporting function and viewed directly in Prophet Professional, Results Diagram View and Results Viewer.
Flexible Results API
The Flexible Results API (FR API) is a .NET Dynamic Linked Library (DLL) that can be used by a bespoke application to read Prophet results directly and at scale, which can then be transformed and stored as appropriate. This removes the need to use the Prophet Results Database (PRD) for transient data storage.
The Insurance Data Repository (IDR) now uses FR API as an alternative data source with minimal changes to any existing jobs that were using PRD as a data source. This can reduce the time taken to load results data from the filesystem into IDR, as well as reducing storage needs.
Calculation engine enhancements
In Release 2020 Q2 Service Pack 3 we have made several large improvements to the calculation engine, with a major area of focus being the performance of products containing modules:
- Table and model point optimisations (TMPO), a Prophet Enterprise licensed optimisation, has now been made available for use with products using modules. This means Prophet can use details from the tables that will be used during a run, in order to determine additional optimisations that can be made. For example, replacing a table read in the product or module with a constant value if possible, reducing time reading this value during the run and allowing additional optimisations to be carried out using this constant.
- Module inputs have now been enhanced to allow members of a module link to be directly used as an input source, of another module link in the same product, without using a product variable as an intermediary. This reduces the need to declare and maintain intermediary variables in the parent product of the module links purely for the purpose of passing information between module links, and potentially allows the engine to reduce the storage needed and amount of data being transferred in memory.
- It is often possible to do optimisations in Prophet based on whether a variable is constant or not. Values that have been defined as constants by a user, as well as variables that are determined to be constant at the preparation stage (when using TMPO), can now be shared across the product-module boundary; previously a constant module link input source would not cause the input to be optimised as a constant inside the module link and constants in the module links would not cause the product to be further optimised. The use of constants during the preparation of a product or module allows for optimisations, such as removing branches of IF conditions and reducing time periods calculated/stored, to be made in order to reduce calculations carried out downstream from the constants and reduce the storage required for variables that are always constant. By sharing constants between the products and the modules, more of these optimisations can be carried out.
- Using the Fast runtime or Fast compile setting in the run structure respectively, you are now able to choose to prepare module code for every product-module link pair or for every product-module pair. This option allows for module code optimisations that improve runtime to be carried out without the restrictions imposed by code being shared between every module link limiting them. However, preparation may now take longer when using the fast runtime setting.
- In previous releases, in all cases, the rebase loop must be contained within the calculation loop, and these loops must be contained with the goal-seek loop. In Release 2020 Q2 Service Pack 3 we have altered this behaviour to allow the rebasing and goal-seeking loops to be separated. This is possible where only rebasing and goal-seeking are used and the rebase loop can be determined to be entirely after the goal-seek loop. This change allows for a, potentially significant, reduction in the recalculation of rebasing variables that no longer need to be included in the goal-seek loop.
- The ADCo plugin SET_RATES function now supports IndexForecast and HPIForecast for the RateName argument.
User Interface enhancements
In Release 2020 Q2 Service Pack 3 we have made a number of improvements across several parts of the user interface.
Enhancements to libraries
- A new variable category can be created automatically when a variable is assigned to that category.
- The indicator expression limit has been increased from 240 characters to 500 characters.
- A column called Returns Array has been added to the User Defined Functions tab of an open library. This is to quickly show whether a user defined function returns an array or not.
- You can now see who last modified a book. This information is available in the Modified By field in either the Book dialog box or Books tab of a library.
- Multiple core variables can be deleted from a library using one click.
Enhancements to comparison
- Importing user defined functions from a library comparison has been enabled.
- If you are comparing an object in one workspace to that in another workspace then “Prophet.prw” no longer needs to be added to the workspace location file path.
Enhancements to viewing results
- The results grid now copes better with larger sets of results by reducing the amount of memory it needs to allocate on opening.
- The Suppress Zeros setting is remembered after re-opening the results.
Enhancement to backup and restore
- When restoring a backed-up workspace, the file size of the items once restored can now be seen in the Restore dialog box.
Prophet Professional Application Programming Interface (API)
In Release 2020 Q2 Service Pack 3 we have made following improvements to the PP API:
- A new function is available to obtain dynamic debug results.
- A warning message relating to missing compilers has been added when a user submits a run.
Licensing
The following improvement has been made to the licensing technology which was released as part of Prophet Release 2018 Q3:
- In the Client Licence Server (CLS) portal, a new label Available CLS Instances (as of last synchronisation) has been added so that it is clear if the CLS instance is ready for disaster recovery.
|
Prophet Professional 2020 Q2 Service Pack 3
Prophet Professional 2020 Q2
User interface
- An issue saving extended formula definitions that had over 200,000 characters has been fixed.
- An issue saving definitions instantiating a parameterised extended formula has been fixed.
- An “out of memory” error caused by a problem in the logic used by Diagram View and formula auto-complete has been fixed.
- Previously for a run setting comparison, comparing a non-blank entry to a blank entry was not treated as a difference. This has been corrected to report a difference in the comparison.
- It is now possible to import indicators from a library comparison.
- An issue with copying and pasting the module link grid into Microsoft Excel or text files has been resolved. Users can use shortcut keys to copy and paste the whole grid with headings.
- A bug preventing you from changing the mortality tables location in the Prophet Professional Options dialog has been fixed.
- An issue that meant you were unable to view individual binary model point results in Prophet Viewer has been fixed.
- A bug in Results Viewer that meant querying results for a single time period would return empty values has been fixed.
- Messaging feedback in both the run monitor and runlogs has now been improved when the calculation engine cannot run because the results it needs to replace are being used by another process such as Excel.
Calculation engine
- An issue where models using User Defined Functions could fail to compile, for example when full table and model point optimisations are used, has been fixed.
- A merged code error during preparation, caused by Prophet incorrectly performing integer optimisations for some calculations relating to module inputs, has been fixed.
- An issue where changing the future accumulation period of a run could lead to an error if running without regenerating has now been fixed.
- An issue where runs could sporadically fail when lots of Same As products were in the run has been fixed. The issue related to preparation metadata files for the base product being unnecessarily copied to the same results location repeatedly and would disproportionately affect certain remote file servers.
- An issue where writing out more than 2GB of individual model point results for a single product caused the run to error has been fixed.
- An issue where model point values with more than 8 decimal places specified could sometimes result in an error has been fixed.
- There was an issue where blank spaces in a product alias table were not converted to the default value for the alias. This could cause incorrect results reading or errors in some models when using READ_RESULTS. This issue has been fixed.
- A bug where the use of SUM, PROD, MINT or MAXT did not force the expression they operated on to be correctly t- limited has been fixed.
- An issue where t-dependent module inputs were not t-limited properly has been fixed.
- The use of table and model point optimisations could previously cause inconsistencies by moving variables into or out of inner product loops. This has been corrected.
- Previously there were three issues with requested results output if the run was being split across multiple machines, all have been fixed:
- Projection results would be produced even if not requested.
- Accumulation results would be produced even if not requested.
- The Only product totals run setting option would incorrectly include results for each sub-product code as well as the product total results files.
- A bug which meant that dynamic debug results were not produced for all dynamic loops in the individual policy output has been fixed.
- Pre-existing stochastic summary cache files are now deleted for each product and run number in a newly submitted run pair.
- An issue which meant codegen diagnostics files were unnecessarily produced for Same As products has been fixed.
- An issue where models that use modules, but not model points, would output constants in the module links as zero has been fixed.
- An issue in some runs that meant a PREM_AMOUNT variable not being present could result in INF/NAN values has been fixed and an appropriate error is now given.
Performance
- A performance issue where in-memory dynamic temporary data was, for certain run types, stored on the remote file server rather than the local workers, has been fixed. Because of this fix users may now find their local worker storage is insufficient for large in-memory dynamic runs. If increasing the size of the volume hosting ProgramData (the default local worker storage location) is not possible, the location (and thus volume) used by the local worker for temporary job data is configurable.
- There was a performance issue that caused the output of certain results files to bypass the Windows file cache, and write the output using smaller than necessary data packets when writing to a remote file server, causing some Prophet models to run noticeably slower. This has now been fixed.
- There was a performance issue with the end-of-run processing when writing large quantities of PRINT_TO_FILE output for certain run types. The issue involved merging and copying temporary PRINT_TO_FILE files to their final output path using smaller than necessary data packets, which disproportionately affected output to a remote file server. This has now been fixed.
Prophet Debugger
- An issue where stopping the Prophet Debugger did not promptly stop the calculation engine has been fixed. The debugger now sends a cancel/abort message to the calculation engine rather than request it stop at the end of the current level number.
- An issue caused by the changes to results in the last release meant that the Debugger would not run models that included modules. This has now been fixed.
Excel Reporting
- An issue where an entire projection results file was loaded into memory, rather than the individual variables required by a spreadsheet, has been fixed so that memory usage is similar to pre-2019 Q2 releases. This is important since a lot of Excel users still use 32-bit Excel which is limited to 2-4GB of memory.
- In the case of spreadsheets using many STOCH_RESULT and STOCH_SUMMARY functions, there were occasions where Prophet 2019 Q2 exhibited reduced performance relative to the prior release, particularly when reading a small amount of data from each results file. This has now been fixed.
- The performance of the stochastic summary cache has been enhanced.
- The stochastic summary functionality can now work without error even if the cache file is in a read-only location.
- A missing file that prevented Excel Reporting from being installed independently of the worker installation has now been added to the Excel Reporting installation.
Prophet Results Database
- There was a bug which meant that results uploaded across a network could take longer in Prophet 2019 Q2 relative to the prior release. This has been fixed.
- Variables in module links that are determined to be constant are now identified as such and variable properties are stored in the appropriate <ProductName#Module_Link>_PRJ_CONST_INFO table rather than the corresponding VAR_INFO table.
Licensing
- An issue which meant a Prophet machine with a name using non-Latin (7-bit ASCII) characters would be unable to acquire a licence from a Client Licence Server has been fixed.
- Where a proxy (with authentication) is being used in synchronisation between the Client Licence Server and FIS Licence Server, the maximum accepted proxy server password length has been increased from 20 to 25 characters.
- When a Prophet user’s Active Directory account did not have access to the default Active Directory entities they would have difficulty acquiring a licence. This has been fixed.
- The default properties of the Windows service underlying the Client Licence Server have been amended to make the service more resilient and installation easier.
- An issue which meant the Prophet Enterprise API would be unable to cope with a Prophet Licensing client when attempting to run multiple requests in parallel has been fixed.
Plugins
- An issue where the ADCo plugin function SET_PARAM truncated and forced four of the paramName argument values to have integral values when set, when in fact they could be non-integral, has been fixed.
|
| 2018 Q3 |
Licensing
Prophet Release 2018 Q3 introduces a new licensing technology. The previous licensing solution will not be supported with any release from Prophet Release 2018 Q3 onwards.Pre Release 2018 Q3 Prophet versions will continue to work and will be supported following the standard support lifecycle. However if you require new licence keys for additional users or due to hardware replacement then this will not be possible after December 2020. We therefore advise that all clients upgrade to Prophet Release 2018 Q3 or later well in advance of December 2020 in order to avoid any down time. Please contact your account manager to discuss how we can be of help.Unlike previous versions of Prophet this licensing framework will be written and controlled by FIS. This has some major advantages including simpler client installations and more rapid response to issues. Licences will now be user driven rather than machine. This will help both clients and FIS to implement the solution much more quickly, when new machines are added or replaced in an environment or when a disaster scenario occurs. We will also be able to expand the functionality beyond the restrictions imposed previously. Other advantages include better auditability and tracking of licences and improved support for virtualised environments.The licence options for Prophet Release 2018 Q3 are:
- User licences: Tied to an individual user’s Active Directory account such that only the Prophet user with the email specified on the licence can acquire it. This is similar to the previous Machine-locked solution.
- Group licences: These are licences that can be used by multiple users (from a defined list) within an Active Directory group, as controlled by their email addresses and selected by the customer. This is similar to the previous Floating licence.
- Site licences: These are licences that can be obtained by anyone who has access to the client licence server that is distributing the licence. The technology is safe for virtualised environments.
New licences will be allocated as follows. Machine-locked licences will be transferred, one-to-one, into User licences. Floating licences will be transferred, one-to-one, into Group licences.
New licences will be pushed out by us to your Client Licence Server (CLS). The CLS synchronises with the FIS Licence Server (FLS). The CLS therefore requires access to the internet and individual machines require access to the CLS. If a disaster event occurs and the CLS is lost then a new CLS simply connects to the FLS where replacement licences are synced.
If you require more advice or support regarding the changes to the licence solution please contact FIS Client Services or your local FIS representative.
User-Defined Functions
User Defined Functions (UDFs) are new objects available in Prophet Professional Release 2018 Q3. UDFs are designed to help reduce the need for repeated code within Prophet. In turn errors should also be reduced and maintenance of the code should also be easier. Each function allows for up to 250 lines of code with 9 inputs. They will return a single value out. The functions will not persist and all information must be passed in via parameters. Functions are stored in a Prophet library and can be imported across libraries and workspaces.
The following screenshots show how the new functions are created and how the format of how they are defined. For more details please see the Prophet documentation and help.
Nested Structures
New functionality to allow users to compare save point data has been introduced in Prophet Professional Release 2018 Q3. Users can compare data between nested points or between save points. This allows users to analyse the save point data to see where differences or changes are taking place. This will help users to explain results or to find errors in their nested structures code.
Additional minor enhancements have also been introduced to model and table maps to help users to identify and fix issues.
Backup and Restore
Prophet Backup and Restore has remained largely unchanged since its introduction into Prophet. Prophet Professional Release 2018 Q3 has reworked this functionality to improve flexibility and auditability.
Users can more easily control what goes into a backup file and also what to restore. Users are also able to see more information in Prophet about the backup including who created it, when it was created and what version of Prophet was used without having to restore the workspace first.
User interface
In the indicator expression section of a variable auto-complete has been introduced.
The Modified by field has been added to more Prophet objects so as to improve auditability. |
Calculations
- We have fixed an issue when reading tables inside a module that would cause the worker to crash.
- Products that fail to generate will now not try to build. This will save user time.
- ” in the description for a enum previously caused the run to fail.
- An issues introduced to Copy Results has been fixed. This issue was introduced in a previous release and caused the results to be replaced rather than merged.
- A memory leak caused by enumerations has been fixed.
- A memory leak with In Memory Dynamic models has been fixed.
- A structured exception error when running a large Model Point file has been fixed. Previously Model Point Files over 1GB in size may experience issues.
- Errors causing runs to fail when using Table and Model Point optimisations have been fixed.
- Errors with nested structures runs and long file paths have been fixed.
User interface
- An issue whereby models created with reference to Intex were unable to remove reference to it have been fixed.
- An error resulting from editing the language in workspace options has been fixed
- Pasting in invalid data into individual policy results grid resulted in ‘Argument out of range error’. This has been fixed.
- Some issues around unlinking same as products have been fixed.
- Opening a product schedule for a second time caused an access violation error which has been fixed.
- Some performance issues with the formula editor have been addressed.
- An issue which prevented some tables opening caused by a table constraint has been fixed.
- Altering window size in diagram view incorrectly caused the individual parts to reset. This has been addressed.
- Changing a definition type now deletes the definitions from all libraries rather than the current one as previous.
- An issue entering a number in a table in exponential format when the exponent was a multiple of 10 would cause the value to be incorrectly altered has been fixed.
- Errors after importing enumerations have been fixed.
- Issues with fonts in code editor when used with Chinese windows locale have been addressed.
- Warnings asking you to save when no changes have been made have been removed.
- Appending definitions on export between 2 workspaces was not working. This has been fixed.
- We have improved the performance of the pre-run checks that are performed right at the start of a run.
- The description of structures, reports and table maps now have a limit of 80 characters in a similar way to other objects. If you use longer descriptions then these will be truncated on upgrade.
- Attempting to delete a product that is referenced by an accumulation would fail after it has been run. This has been fixed.
- Using initialise in table editor would fail if descriptions were included. This has been fixed.
- Diagram view may have incorrectly shown the wrong variable results for module link variables. This has been fixed.
- An issue with some queries in Excel being unable to be saved has been fixed.
- Altering the font in queries caused an exception which has been addressed.
Modules
- Improved error and warning messages when things go wrong. An issue calling a plugin from a module caused the product to fail.
- Code generation errors when attempting to read an array variable from a module may sometimes occur. This has been addressed.
- Arrayed module input variables are not correctly put in Post Calculation Loop. This has been fixed.
- We have fixed an issue whereby SWITCH statements were unable to reference module variables.
- An issue creating a new variable definition for a link variable caused an incorrect error which has now been removed. Similarly changing a variable from number or text to link caused an inconsistency in the variable definition has been fixed.
- After deleting a module link variable the module is still shown under the product in the tree. This has been corrected.
Nested Structures
- In some circumstances when an inner run fails the runlog was not produced. This has been fixed.
- New business failed when there was no existing business.
- Over optimisation issues which caused some runs to fail in apparently unrelated products has been resolved.
- An issue where models may fail when using Nested Structures with IMD and Reporting Arrays has been addressed.
- ENTRY_YEAR given incorrect value for wrong value in inner product new business.
- Inner structure warnings were not correctly produced when using split by simulation.
- Attempting to view a table map preview when the table map is empty resulted in an application error. This has been fixed.
Prophet API
- It was previously possible to set incorrect flags for dynamic runs which in turn caused unexpected run errors. It is now not possible to set these incorrect combinations.
- Excel would crash if you submitted a run to the API without setting the run setting.
- It was previously possible to set an incorrect dynamic period using the API. This has been fixed.
Runlogs
- Runlogs did not refresh properly if the Results Viewer was left open whilst a run occurred.
- Using the hyperlinks for the errors in a runlog would sometimes result in the runlog messages not being viewable. This has been fixed.
|
| 9.0.4 |
Nested Structures
We have introduced the ability to skip structure link processing in subsequent dynamic loops to improve runtimes. For each structure link in your run, you may specify in the run settings a different dynamic period for the structure link after a specified initial projection period. Prophet will then only execute that structure link according to your revised frequency. This is useful if you are more concerned about your short-term projections than those in the long-term.Nested Structures is now compatible with dynamic loop at start/end in the outer run.Table maps can now have six dimensions.Table maps, model point maps and structure links can now be imported from one workspace to another.Model point map variables can now be sorted by clicking on the headers.Searching within a workspace now searches the contents of model point maps and table maps.Modules
Module links can now be conditionally executed on the value of a variable specified on the module link form. Provided this variable is time independent and of type number, if its value is 1 the module link will be executed, and will not otherwise. This provides the user with greater flexibility in controlling the calculations executed in their run. In products that contain a large number of model points, conditioning module links could help reduce runtime.If a module link is conditionally executed, an advanced option flag has been added to the module link form to specify whether zero should be returned from an unexecuted module link when referenced at runtime. If this flag is not enabled, Prophet will instead produce an error.
The use of conditional module links is, in addition, fully supported with our other software:
- Uploading workspaces to PE
- Comparing results with PQA or queries
- Storing results with PRD
In the product tree the modules being used by the product are now shown. In a similar way under an indicator in the tree the associated modules that use that indicator are now shown.
Module diagnostic files are now shown more clearly in the tree. Previously it was not clear which files were product and which were module diagnostic files. These have now been separated.
We have improved the Module Tag functionality so that users can now search for tags and see which modules are associated to a tag in the tree. This helps users to manage the modules that they have in a workspace.
Module links and the variable name are now shown on separate lines with diagram view. This helps to improve the appearance when viewing variables of this type given the likely larger combined length of the two.
Compare
Historically Prophet has been able to compare products and libraries. We have added the ability to compare run settings, structures and structure links. These objects are compared in a similar way to products and libraries, and like these objects can be compared within the same workspace and across different workspaces.
A further enhancement to the comparison functionality is that following a product compare, input variables can be imported from one product to the other.
Calculations
If an Extended formula uses the function OPTION FIRST_MODEL_POINT_ONLY but needs to recalculate outside of the first model point then it will now error.
The READ_FLEXIBLE_TABLE statement has been updated to support the use of string literals with mapped explicit indices.
In Release 9.0 Update 3 the performance statistics provided in the runtime code generation diagnostics file for array variables gave the runtime for each individual array element; this has been updated to provide the sum-total for those array variables optimised out at preparation.
User Interface
A new total ‘Array Size’ column has been added in Details View for array variables.
When choosing the array dimension, in the properties of a variable the size of the dimension is now displayed.
When performing a find and replace, the changes would be performed one at a time and a validation after each change was then performed. This could make the formula invalid. It is now possible to perform a find and replace across the whole code in one go without performing a validation.
Flexible Table conversion can now be performed from outside of the table and without interaction by the user.
Prophet printouts can now optionally include the associated actuarial documentation.
Individual projection results grids can now be edited and managed from within Excel. Within the grid the user can now also delete multiple rows in one go. Similarly, within model point maps, multiple rows can be highlighted and deleted.
Previously, when clearing the Same As checkbox in the product properties, that product would be recreated with the default code from the library with the same indicators. This has been changed so that the new product becomes an exact replica of the original product. If a user wants to create a new product with the same indicators but with the default code then the user will now need to create a new product and add the corresponding indicators.
The product link alias and structure link alias screens have been enhanced.
Within a product, it is now possible re-hide core variables once they have been unhidden.
Diagram View
To help users track results, it is now possible to highlight a whole row of results within Diagram View. This is achieved by clicking on the date in the middle panel.
Within Structure Diagram View the boxes will be resized when the names are too big.
There is a new option to fix the layout of Diagram View so the layout can be remembered between instances of Diagram View and workspaces.
API
Commands within the API exist to be able to add a product to a structure. Extra checks have been added to prevent a product from being added to a structure which would make the structure invalid – for instance, due to the dynamic period of that level.
New commands to be able to amend the structure properties to support skip structure link have been added.
Prophet Results Database
Stochastic summary results can now be uploaded to a SQL Server Database using PRD.
Improved interconnectivity with Prophet Enterprise:
- Job ID now included as a field in the SETTINGS table.
- New -standalone argument added allowing results to be uploaded into separate tables for each run number. This was designed to facilitate the upload of Analysis of Change runs from Assumptions Manager.
New field in the RESULTS_INFO table containing the command line used at upload.
Changed the data types of various fields in the uploaded tables so that they are more appropriate, robust and consistent.
Further enhancements made for new functionality such as modules and individual policy results:
- SETTINGS table updated.
- Tables containing nothing other than key value fields are now optimised out of the upload (this frequently occurred with use of the -vars argument).
- Installation
The system installer now checks if the machine, once it has a worker deployed on it, has the correct SMB2 settings. SMB2 is a network protocol used to implement windows file sharing. The settings relate to how the file sharing client, in this case the worker machine, caches metadata information about file shares, which are used for sharing a workspace with workers. Examples of such caching include directory listings, file existence and file properties. This caching, if left enabled, can cause worker grids to have an incoherent image of what is and is not on the file shares, thus causing runtime errors, for example where a file that is seen to exist by one worker is not seen by another worker.The installer, if it detects the presence of SMB2 caching, now provides an additional option, selected by default, on the worker settings installation page. This option allows the user to automatically fix the SMB2 settings on the machine to which the worker is deployed. If the machine will not be used as part of a multi-machine distributed run or job then you do not need to turn off the SMB2 caching. In addition, the calculation engine checks the settings at the start of a run or job that uses multiple machines, and if unsuitable settings are detected it generates a warning in the system log part of the run log.
|
Calculations
- We have fixed various issues with Nested Structures and Modules.
- Debugging models with Public Persistent extended formula arrays no longer gives a code generation error.
- Updating table names used in Nested Structures’ table maps now works correctly upon next run even if you do not explicitly regenerate the structure.
- Split run by model point batches now works with modules.
- Array functions (such as SUM, MAXT, MINT, PROD) whose ranges are not time constant, are now correctly allowed for by the sequencer when working out time periods that need calculating for different variables.
- PROJ_RESULT and STOCH_RESULT, used in model runs, no longer think results are missing for an entire product and run number if some of the requested spcodes or variables are absent – this caused subsequent valid result requests to fail even when the results were present.
- The Run Monitor now shows more information about the internal progress of structure links when splitting nested structures by product or simulation.
- Improved the sequencing of optimised array variables when used with a goal seeking loop – previously they were sometimes not correctly included, or recalculated, in the goal seeking loop when they should have been.
- A model point optimisation bug, where part of the preparation logic would not always pass successfully has been fixed.
- A table optimisation bug causing a compile failure, involving hard coded table names in certain generic or stochastic table calls, has been fixed.
- Module links failing to execute did not always cause their products to fail as well – runs could complete with values for the main product produced and thus the run log would suggest the run had been successful; this has been addressed.
- If dimension bounds are changed and none of these dimensions are used by any of a module’s variables, then that module is no longer needlessly recompiled.
User Interface
- Previously importing libraries from one workspace to another incorrectly brought no enumerations that were referenced. This has been fixed.
- A change to table notes now prompts the user to save the table when closing so it’s less easy to close without saving table notes.
- It is now possible to set a conditional breakpoint to an enumeration element’s name when previously this had to be the element’s index value.
- An issue with opening save point model point files when ‘Show Default Row Value Column’ option was selected for Names/Descriptions has been fixed.
- In Diagram View number format now also applies to non-time-dependent values as soon as it’s changed and the number of decimal places is persisted in the Number Format dialog box.
- The dropdown for array filter in Diagram View has been fixed. Previously the blank entry was being removed and selecting an item could display a different item.
- Previously the name of the diagnostic file for a long product name or a product and module link was truncated in the tree, making it impossible to open. This has been fixed: the whole name is shown and the file can be opened.
- When changing variable definitions to module links every variable definition is opened. As it is only possible to have 50 windows open at a time in Prophet Professional, multi-select and changing more than 50 definitions was resulting in an application error. This has been changed so it is not possible to open more than 50 windows in this manner.
- An application error when there were multiple qualifying definitions has been fixed.
- A formatting issue in formula editor with enumerations when the value was in more than one enumeration has been fixed.
- FAC to Stochastic converter is now working as expected when the ‘Include Subdirectories’ check box is selected.
- When there are a large number of table constraints, for example on a mortality table, and an incorrect value was added, the error message could become unreadable. This has been fixed.
- Runs can fail if the path to the workspace contains non-ASCII characters. We have provided a warning when trying to execute a run that this may cause issues, enabling the user to mitigate the issue as soon as possible.
- Changing a non-dimension property of multiple variables which were a mixture of array and non-array variable caused the dimensions to be lost, this is no longer the case.
- The summary section on a batch compare when there were no differences is now being shown.
Prophet Results Database
- Improved the handling of invalid numeric values (e.g. +/-INF and NANs) sometimes found in results.
- There is now input validation for text files used with any of the results filters – invalid values are no longer permitted.
- Variables for a particular module link can now be specified with the -vars argument.
|
| 9.0.3 |
Nested Structures
A new text constraint has been introduced to allow more efficient code for reading array variables from the inner product.Nested Structures objects can now be printed from the Prophet User Interface.Nested Structures controls have been added to the Prophet Professional API.Modules
Module tags have been introduced as properties on a module. When editing the module link these modules can be chosen to help the user to select which module should be selected.Module results can now be uploaded to the PRD.Diagram View has been enhanced so that users can move easily between product and module diagram view.
Modules can now be used with the PMPP run option.
Indicators can be restricted to only be used in modules or products.Search results now include module link variables.Modules with Nested Structures
Modules can now be used in products that run within an inner or outer structure within the Nested Structure environment.Books
Variables that are not in a book can now easily be printed.
API
In addition to the Nested Structures setting some other properties have been added to the API such as properties from the run setting that were missing. |
User interface
We have improved the printing of lists of objects where those objects have long names.An issue where the debugger would not stop on an array inside an extended formula has been fixed.Library validate has been corrected such that an error is given when a referenced variable is renamed or the properties changed.Calculations
When a product has no model point file a binary individual model point file was produced when the option was turned on. This file is not able to be opened and causes an issue uploading the results to PRD. The file is no longer produced for products with no model points.A runlog issue where messages were duplicated when using Model Point Batches split method has been fixed.Nested Structures
If using Nested Structures then previously the default maximum projection term would not feed through to the inner run setting. This has been corrected.When using a text variable within a DCS grouping Nested Structures run would cause the run to fail. This has been fixed.Various improvements have made to the save point diagram view.Previously inner run settings could be deleted without removing them from structure links. This could then affect upload to Prophet Enterprise. A warning is now given and if accepted the links are removed from relevant structure links.
Renaming a Model Point Map was incorrectly not renaming the DCS script. This has been fixed.
An issue where Structure Diagram View was not showing the inner structure correctly has been fixed.
An issue where Read_Nested_Stat was not working when reading a Same As Product has been fixed.
Modules
Adding a module link as a watch variable within the debugger and toggling a break point was not possible when the module link was open. This has been fixed.
The option ‘First level for stochastic results files’ was not working correctly for module variables. Results for all module variables were produced even if the product was below the level specified. This has been fixed.
Filtering the structure in the user interface now correctly applies the filter to modules as well as other objects. |
