xtgeo 4.10.0__cp310-cp310-macosx_11_0_arm64.whl → 4.11.0__cp310-cp310-macosx_11_0_arm64.whl

xtgeo/common/version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '4.10.0'
-__version_tuple__ = version_tuple = (4, 10, 0)
+__version__ = version = '4.11.0'
+__version_tuple__ = version_tuple = (4, 11, 0)
+
+__commit_id__ = commit_id = 'gee9361dd9'

xtgeo/cube/_cube_window_attributes.py

@@ -63,6 +63,7 @@ class CubeAttrs:
     _upper: RegularSurface | None = None  # upper surf, resampled to cube map resolution
     _lower: RegularSurface | None = None  # lower surf, resampled to cube map resolution
     _min_thickness_mask: RegularSurface | None = None  # mask for min. thickness trunc.
+    _mask_map_by_traceidcode: RegularSurface | None = None  # mask for traceidcode 2
 
     _result_attr_maps: dict = field(default_factory=dict)  # holds the resulting maps
 
@@ -94,6 +95,7 @@ class CubeAttrs:
             else self.lower_surface
         )
 
+        # the template surface is the topology that defines the resulting attribute maps
         self._template_surface = (
             upper
             if isinstance(self.upper_surface, (float, int))
@@ -184,7 +186,7 @@ class CubeAttrs:
         from xtgeo import Cube  # avoid circular import by having this here
 
         cubev = self.cube.values.copy()  # copy, so we don't change the input instance
-        cubev[self.cube.traceidcodes == 2] = np.nan  # set dead traces to nan
+        cubev[self.cube.traceidcodes == 2] = 0.0  # set traceidcode 2 to zero
 
         # Create a boolean mask based on the threshold
         mask = self._depth_array < self._outside_depth
@@ -311,13 +313,20 @@ class CubeAttrs:
         attr_map = self._upper.copy()
         attr_map.values = np.ma.masked_invalid(values)
 
+        # apply mask for the cube's dead traces (traceidcode 2)
+        attr_map.values = np.ma.masked_where(
+            self.cube.traceidcodes == 2, attr_map.values
+        )
+
         # now resample to the original input map
         attr_map_resampled = self._template_surface.copy()
         attr_map_resampled.resample(attr_map)
 
-        attr_map_resampled.values = np.ma.masked_where(
-            self.upper_surface.values.mask, attr_map_resampled.values
-        )
+        # Use template_surface consistently for masking (it's already set correctly)
+        if hasattr(self._template_surface.values, "mask"):
+            attr_map_resampled.values = np.ma.masked_where(
+                self._template_surface.values.mask, attr_map_resampled.values
+            )
 
         self._result_attr_maps[attr_name] = attr_map_resampled
 

xtgeo/grid3d/_grid_etc1.py

@@ -1053,13 +1053,18 @@ def inactivate_inside(
         raise RuntimeError("Problems with one or more polygons. Not closed?")
 
 
-def collapse_inactive_cells(self: Grid) -> None:
+def collapse_inactive_cells(self: Grid, internal: bool = True) -> None:
     """Collapse inactive cells."""
-    self._set_xtgformat1()
+    logger.debug("Collapsing inactive cells...")
+    self._set_xtgformat2()
 
-    _cxtgeo.grd3d_collapse_inact(
-        self.ncol, self.nrow, self.nlay, self._zcornsv, self._actnumsv
-    )
+    grid_cpp = _internal.grid3d.Grid(self)
+    new_zcornsv = grid_cpp.collapse_inactive_cells(collapse_internal=internal)
+
+    if new_zcornsv is not None:
+        self._zcornsv = new_zcornsv
+
+    logger.debug("Collapsing inactive cells done")
 
 
 def copy(self: Grid) -> Grid:

xtgeo/grid3d/grid.py

@@ -2295,7 +2295,7 @@ class Grid(_Grid3D):
         * maxangle_topbase_proj (degrees) max angle projected (bird view)
         * minangle_sides (degress) minimum angle, all side surfaces
         * maxangle_sides (degress) maximum angle, all side surfaces
-        * collapsed (int) Integer, 1 of one or more corners are collpased in Z
+        * collapsed (int) Integer, 1 of one or more corners are collapsed in Z
         * faulted (int) Integer, 1 if cell is faulted (one or more neighbours offset)
         * negative_thickness (int) Integer, 1 if cell has negative thickness
         * concave_proj (int) 1 if cell is concave seen from projected bird view
@@ -2332,7 +2332,7 @@ class Grid(_Grid3D):
         inside: bool = True,
         force_close: bool = False,
     ) -> None:
-        """Inacativate grid inside a polygon.
+        """Inactivate grid inside a polygon.
 
         The Polygons instance may consist of several polygons. If a polygon
         is open, then the flag force_close will close any that are not open
@@ -2359,14 +2359,30 @@ class Grid(_Grid3D):
         layer_range: tuple[int, int] | None = None,
         force_close: bool = False,
     ) -> None:
-        """Inacativate grid outside a polygon."""
+        """Inactivate grid outside a polygon."""
         self.inactivate_inside(
             poly, layer_range=layer_range, inside=False, force_close=force_close
         )
 
-    def collapse_inactive_cells(self) -> None:
-        """Collapse inactive layers where, for I J with other active cells."""
-        _grid_etc1.collapse_inactive_cells(self)
+    def collapse_inactive_cells(self, internal: bool = True) -> None:
+        """Collapse inactive layers per I J column (~vertically).
+
+        Seen by I,J column, the inactive cells are collapsed to the first active cell in
+        the column. First transversed from top, then from bottom. If no active cells in
+        the column, the (invisible) Z coordinates are averaged to one common location.
+
+        If `internal` is True (default), then also internal inactive cells (i.e.
+        inactive "hole" surrounded by active cells) are collapsed. In this case the Z
+        coordinates of the adjacent active cells are moved to fill the gap.
+
+        The current grid instance will be updated.
+
+        Args:
+            internal: If True (default), then the internal collapse is also done.
+
+        .. versionchanged:: 4.11 Added ``internal option``, algorithm is improved
+        """
+        _grid_etc1.collapse_inactive_cells(self, internal=internal)
 
     def crop(
         self,

xtgeo/include/fmt/args.h

@@ -0,0 +1,220 @@
+// Formatting library for C++ - dynamic argument lists
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_ARGS_H_
+#define FMT_ARGS_H_
+
+#ifndef FMT_MODULE
+#  include <functional>  // std::reference_wrapper
+#  include <memory>      // std::unique_ptr
+#  include <vector>
+#endif
+
+#include "format.h"  // std_string_view
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename T> struct is_reference_wrapper : std::false_type {};
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+template <typename T> auto unwrap(const T& v) -> const T& { return v; }
+template <typename T>
+auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
+  return static_cast<const T&>(v);
+}
+
+// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
+// 2022 (v17.10.0).
+//
+// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+// templates it doesn't complain about inability to deduce single translation
+// unit for placing vtable. So node is made a fake template.
+template <typename = void> struct node {
+  virtual ~node() = default;
+  std::unique_ptr<node<>> next;
+};
+
+class dynamic_arg_list {
+  template <typename T> struct typed_node : node<> {
+    T value;
+
+    template <typename Arg>
+    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
+
+    template <typename Char>
+    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
+        : value(arg.data(), arg.size()) {}
+  };
+
+  std::unique_ptr<node<>> head_;
+
+ public:
+  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
+    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
+    auto& value = new_node->value;
+    new_node->next = std::move(head_);
+    head_ = std::move(new_node);
+    return value;
+  }
+};
+}  // namespace detail
+
+/**
+ * A dynamic list of formatting arguments with storage.
+ *
+ * It can be implicitly converted into `fmt::basic_format_args` for passing
+ * into type-erased formatting functions such as `fmt::vformat`.
+ */
+template <typename Context> class dynamic_format_arg_store {
+ private:
+  using char_type = typename Context::char_type;
+
+  template <typename T> struct need_copy {
+    static constexpr detail::type mapped_type =
+        detail::mapped_type_constant<T, char_type>::value;
+
+    enum {
+      value = !(detail::is_reference_wrapper<T>::value ||
+                std::is_same<T, basic_string_view<char_type>>::value ||
+                std::is_same<T, detail::std_string_view<char_type>>::value ||
+                (mapped_type != detail::type::cstring_type &&
+                 mapped_type != detail::type::string_type &&
+                 mapped_type != detail::type::custom_type))
+    };
+  };
+
+  template <typename T>
+  using stored_t = conditional_t<
+      std::is_convertible<T, std::basic_string<char_type>>::value &&
+          !detail::is_reference_wrapper<T>::value,
+      std::basic_string<char_type>, T>;
+
+  // Storage of basic_format_arg must be contiguous.
+  std::vector<basic_format_arg<Context>> data_;
+  std::vector<detail::named_arg_info<char_type>> named_info_;
+
+  // Storage of arguments not fitting into basic_format_arg must grow
+  // without relocation because items in data_ refer to it.
+  detail::dynamic_arg_list dynamic_args_;
+
+  friend class basic_format_args<Context>;
+
+  auto data() const -> const basic_format_arg<Context>* {
+    return named_info_.empty() ? data_.data() : data_.data() + 1;
+  }
+
+  template <typename T> void emplace_arg(const T& arg) {
+    data_.emplace_back(arg);
+  }
+
+  template <typename T>
+  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
+    if (named_info_.empty())
+      data_.insert(data_.begin(), basic_format_arg<Context>(nullptr, 0));
+    data_.emplace_back(detail::unwrap(arg.value));
+    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
+      data->pop_back();
+    };
+    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
+        guard{&data_, pop_one};
+    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
+    data_[0] = {named_info_.data(), named_info_.size()};
+    guard.release();
+  }
+
+ public:
+  constexpr dynamic_format_arg_store() = default;
+
+  operator basic_format_args<Context>() const {
+    return basic_format_args<Context>(data(), static_cast<int>(data_.size()),
+                                      !named_info_.empty());
+  }
+
+  /**
+   * Adds an argument into the dynamic store for later passing to a formatting
+   * function.
+   *
+   * Note that custom types and string types (but not string views) are copied
+   * into the store dynamically allocating memory if necessary.
+   *
+   * **Example**:
+   *
+   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
+   *     store.push_back(42);
+   *     store.push_back("abc");
+   *     store.push_back(1.5f);
+   *     std::string result = fmt::vformat("{} and {} and {}", store);
+   */
+  template <typename T> void push_back(const T& arg) {
+    if (detail::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_t<T>>(arg));
+    else
+      emplace_arg(detail::unwrap(arg));
+  }
+
+  /**
+   * Adds a reference to the argument into the dynamic store for later passing
+   * to a formatting function.
+   *
+   * **Example**:
+   *
+   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
+   *     char band[] = "Rolling Stones";
+   *     store.push_back(std::cref(band));
+   *     band[9] = 'c'; // Changing str affects the output.
+   *     std::string result = fmt::vformat("{}", store);
+   *     // result == "Rolling Scones"
+   */
+  template <typename T> void push_back(std::reference_wrapper<T> arg) {
+    static_assert(
+        need_copy<T>::value,
+        "objects of built-in types and string views are always copied");
+    emplace_arg(arg.get());
+  }
+
+  /**
+   * Adds named argument into the dynamic store for later passing to a
+   * formatting function. `std::reference_wrapper` is supported to avoid
+   * copying of the argument. The name is always copied into the store.
+   */
+  template <typename T>
+  void push_back(const detail::named_arg<char_type, T>& arg) {
+    const char_type* arg_name =
+        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
+    if (detail::const_check(need_copy<T>::value)) {
+      emplace_arg(
+          fmt::arg(arg_name, dynamic_args_.push<stored_t<T>>(arg.value)));
+    } else {
+      emplace_arg(fmt::arg(arg_name, arg.value));
+    }
+  }
+
+  /// Erase all elements from the store.
+  void clear() {
+    data_.clear();
+    named_info_.clear();
+    dynamic_args_ = {};
+  }
+
+  /// Reserves space to store at least `new_cap` arguments including
+  /// `new_cap_named` named arguments.
+  void reserve(size_t new_cap, size_t new_cap_named) {
+    FMT_ASSERT(new_cap >= new_cap_named,
+               "set of arguments includes set of named arguments");
+    data_.reserve(new_cap);
+    named_info_.reserve(new_cap_named);
+  }
+
+  /// Returns the number of elements in the store.
+  size_t size() const noexcept { return data_.size(); }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_ARGS_H_