Address sanitizer detected a memory leak in CmdFeatureMenuBuilder::MenuItem
objects caused by RiuContextMenuLauncher objects that were never deleted.
Problem: The RiuContextMenuLauncher class has two constructors:
1. RiuContextMenuLauncher(widget, CmdFeatureMenuBuilder&) - sets parent ✓
2. RiuContextMenuLauncher(widget, QStringList&) - missing parent ✗
The second constructor was missing the parent initialization, causing all
RiuContextMenuLauncher objects created with QStringList (used in 10+ locations)
to never be deleted, leading to memory leaks of their internal MenuItem vectors.
Root cause: Missing parent-child relationship meant Qt couldn't automatically
clean up these objects when their associated widgets were destroyed.
Fix: Added `: QObject( widget )` to the second constructor to match the first
constructor's behavior. This ensures Qt's automatic parent-child cleanup
handles the RiuContextMenuLauncher lifecycle properly.
This fixes the systemic issue affecting multiple plot types including:
- Correlation plots, Analysis plots, VFP plots, Well allocation plots
- All locations using `new RiuContextMenuLauncher(widget, {commands})`
Address sanitizer detected a memory leak in CmdFeatureMenuBuilder::MenuItem
objects allocated during context menu creation.
Problem: The RiuContextMenuLauncher constructor was creating a temporary
CmdFeatureMenuBuilder object, populating it with menu items, then copying
the entire object to the member variable m_menuBuilder. This caused
unnecessary memory allocation and copying of std::vector<MenuItem> data.
Root cause: Inefficient constructor implementation:
caf::CmdFeatureMenuBuilder menuBuilder; // temp object
for (cmd : commandIds) menuBuilder << cmd; // populate temp
m_menuBuilder = menuBuilder; // copy entire vector (leak source)
Fix: Build the menu directly into the member variable instead of creating
a temporary object and copying it:
for (cmd : commandIds) m_menuBuilder << cmd; // direct construction
This eliminates the unnecessary temporary object creation and copy operation
that was causing the MenuItem vector allocation detected by the sanitizer.
The fix maintains identical functionality while being more efficient.
Address sanitizer detected a memory leak in QProxyStyle objects
created during GUI theme updates.
Problem: The updateGuiTheme() function was called multiple times (e.g., during
initialization) and repeatedly created new PdmUiTreeViewStyle objects for
every PdmUiTreeViewWidget without checking if the widget already had the
correct style set.
Root cause: Each call to updateGuiTheme() would:
1. Iterate through ALL widgets in the application
2. Create a new PdmUiTreeViewStyle for every tree view widget
3. Call setStyle() which should take ownership, but repeated calls
were causing memory leaks
Fix: Added a check to only create and set a new PdmUiTreeViewStyle if the
widget doesn't already have one. This prevents repeatedly creating new
styles for the same widgets during multiple theme update calls.
The fix uses dynamic_cast to check if the current style is already a
PdmUiTreeViewStyle before creating a new one.
Address sanitizer detected a 1056-byte memory leak in QWidgetItem objects.
This was the actual root cause of the leak reported in the stack trace.
Problem: In ensureWidgetContainsEmptyGridLayout(), when clearing existing
layouts, the code was calling layout->takeAt(0) to remove QLayoutItem
objects but never deleting them. This caused QWidgetItem objects to
accumulate in memory without ever being freed.
The takeAt() method removes items from the layout but does NOT delete them.
The caller is responsible for deleting the returned QLayoutItem objects.
Fix: Added `delete item;` in the cleanup loop to properly free QWidgetItem
objects when clearing layouts before rebuilding the UI.
Address sanitizer detected a 1056-byte memory leak in QWidgetItem objects
created when adding widgets to layouts via QGridLayout::addWidget().
Root cause: PdmUiFieldEditorHandle destructor was using deleteLater() to
destroy widgets, but deleteLater() requires an active event loop to process
the delayed deletions. During application shutdown or certain cleanup
scenarios, the event loop may not process these deletions, causing
QWidgetItem objects to remain allocated.
Changes:
- Replace deleteLater() with immediate delete in destructor
- Update comment to explain why immediate deletion is necessary
- This ensures widgets and their associated QWidgetItem objects are
properly cleaned up when field editors are destroyed
The original comment acknowledged that deleteLater() "will not work unless
you are actually inside an event loop" - this change addresses that issue
by using direct deletion instead.
Address sanitizer detected a 32-byte memory leak in QVBoxLayout objects
created by PdmUiFormLayoutObjectEditor::recursivelyConfigureAndUpdateUiOrderingInGridLayout().
Root cause: QVBoxLayout objects were being both:
1. Added to parent layouts via addLayout() (proper Qt ownership)
2. Stored in m_layouts member vector (redundant storage)
The redundant storage prevented Qt's automatic cleanup, causing memory leaks.
For large point arrays, the scripting causes overflow in the grpc communication. Disable scripting to make sure the grpc object size is below size threshold.
Refactored RigGridBase::cellCornerVertices to return std::array<cvf::Vec3d, 8> by value instead of taking a reference to std::array as an output parameter. This change improves code readability and leverages modern C++ return value optimizations.
Updated all call sites across the codebase to reflect the new function signature.
Previously, we had support for import of well log file including (some) well path geometry. Then, when the full well path was imported later, the well log data was moved to the full well path. This functionality is now removed as it is not working well when we allow import of multiple well path files.
- Renamed class from RimFixedTrajectoryWellPath to RimPointBasedWellPath
- Updated header and implementation files
- Changed PDM object display name to "Point-Based Well Path"
- Updated script keyword from "FixedTrajectoryWellPath" to "PointBasedWellPath"
- Modified CMakeLists_files.cmake to reference new filenames
- Updated all includes and instantiation references
- Applied clang-format-19 to modified C++ files
- Updated Python docstring to reflect new return type
The new name better describes the class purpose of creating well paths
from XYZ coordinate points. All tests continue to pass.
- Updated C++ GRPC interface method names and class names
- Renamed Python method in well_path_collection.py
- Updated all test functions and file names
- Renamed example file to match new method name
- All tests pass with the new method name
The method signature and functionality remain unchanged - only the name
has been updated to be more descriptive.
* Add drag'n'drop support for ensemble summary vectors and ensembles into histogram plots
* Make sure histogram plot is shown and all update signals are connected when loading a project.
* Support ensemble parameter drag'n'drop from data sources into histogram plots.
* Show ensemble parameters in data sources tree.
* Add copy/paste of histogram curves
* Re-use all existing parameters in a plot when dragging a new ensemble into it
* Migrates obsolete color field to main color
* Sets filter mode for older project files
* Adds surfio license information
* Removes log to file preference
* Refines short name generation.
* Adds a bounds check on the node index to prevent accessing invalid memory locations.
This prevents potential crashes caused by out-of-bounds access when retrieving summary variable values.
* Updates warning message for incomplete deltas
* Plot based on a single realization from a file set ensemble is not restored correctly on project load
* Populate result addresses if no addresses are present
* Adds CNV_ (convergence) result name
* Avoid include of RiaResultNames.h in header file
Simplifies color handling by replacing transparency settings with opacity for curve and fill colors.
This change provides a more intuitive user experience and ensures consistent behavior across the application.
- Renames "ColorTransparency" to "ColorOpacity" for RimCurveSetAppearance.
- Introduces "CurveColorOpacity" for RimPlotCurveAppearance.
- Updates blending calculations to correctly use opacity.
- Adjusts UI slider attributes for opacity settings, including minimum, maximum and decimals.
* Make sure RFT curve settings are restored correctly, use three numbers to identify project version string to compare with.
* Increases dialog window sizes for summary template operations
* Move improved summary import setting to Summary tab
* #12838 Use discrete linear as default legend for CNV_* result names
* Bump version to 2025.04.4-dev.10
Add import_fixed_trajectory_well_path() method to WellPathCollection that enables
creation of well paths from coordinate lists in Python. Implements feature request
for programmatic well path creation without file-based imports.
- Add RimFixedTrajectoryWellPath class for coordinate-based well paths
- Add GRPC interface for coordinate data transfer via key-value store
- Add comprehensive Python API with input validation and error handling
- Add example script importing well on Norne.
- Add 7 unit tests covering all functionality and edge cases
The API allows creating well paths like:
well_path = collection.import_fixed_trajectory_well_path(
name="MyWell",
coordinates=[[x1,y1,z1], [x2,y2,z2], ...]
)
Replaces direct PdmField usage for font sizes with the new
RimFontSizeField. This provides a consistent way to manage font
size options across different plot types.
The RimFontSizeField encapsulates the logic for generating font size
options based on the default plot font size from preferences. This
removes redundant code in various plot classes and ensures that font
size settings are synchronized with user preferences.
This makes it possible to configure the capabilities of a field one place and avoids duplication.
Extends scripting capabilities by introducing a `dataType` method to `PdmAbstractFieldScriptingCapability`.
This allows the Python generator to retrieve the data type of a field directly from its scriptability, providing a more flexible and extensible way to determine the data type for scripting purposes.
Clarifies the build process for both Linux and Windows environments, including specific instructions for Visual Studio 2022.
This includes updated prerequisites, build commands, and testing procedures, ensuring a smoother build experience for developers on both platforms.
- Ensures a more robust size multiplier calculation by validating the weighted mean and preventing division by zero.
- Addresses a potential division by zero during curve interpolation when the X values are very close, ensuring a more robust and accurate result.
Enhances the robustness of ensemble data processing by:
- Displaying a tooltip when data is missing for a realization.
- Checks if an enhanced summary file exists before attempting to open it.
- Refines the creation of the realization filter to accurately represent the range of available data.
Ensures that the "Jobs" object name reflects its beta status by appending the appropriate postfix.
This change helps to differentiate beta features from stable ones within the application.
Implements interval-based diameter and roughness configuration for MSW completions
while maintaining backward compatibility with existing single-value approach.
- Add RimDiameterRoughnessInterval class for individual MD intervals
- Add RimDiameterRoughnessIntervalCollection for managing interval collections
- Extend RimMswCompletionParameters with interval-specific mode support
- Support both metric and field unit systems
- Provide validation and overlap detection for intervals
* Add support for getting the perforation length of a well from Python
* Fix issue with sub grid pointers in LGR grids when using active cell opm reader
Kristian Bendiksen
Magne Sjaastad
magnesj
JJ
jonjenssen
Santiago Ospina De Los Ríos