Line data    Source code

       1             : // SPDX-License-Identifier: BSD-3-Clause
       2             : // Copyright (c) 2023 Scipp contributors (https://github.com/scipp)
       3             : /// @file
       4             : /// @author Simon Heybrock
       5             : #pragma once
       6             : 
       7             : #include <string>
       8             : #include <string_view>
       9             : 
      10             : #include "scipp/dataset/sized_dict.h"
      11             : #include "scipp/variable/variable.h"
      12             : 
      13             : namespace scipp::dataset {
      14             : 
      15             : /// Policies for attribute propagation in operations with data arrays or
      16             : /// dataset.
      17             : enum class AttrPolicy { Keep, Drop };
      18             : 
      19             : /// Data array, a variable with coordinates, masks, and attributes.
      20             : class SCIPP_DATASET_EXPORT DataArray {
      21             : public:
      22       93217 :   DataArray() = default;
      23             :   DataArray(const DataArray &other, AttrPolicy attrPolicy);
      24             :   DataArray(const DataArray &other);
      25      142411 :   DataArray(DataArray &&other) = default;
      26             : 
      27             :   DataArray(Variable data, Coords coords, Masks masks, Attrs attrs,
      28             :             std::string_view name = "");
      29             :   explicit DataArray(Variable data, typename Coords::holder_type coords = {},
      30             :                      typename Masks::holder_type masks = {},
      31             :                      typename Attrs::holder_type attrs = {},
      32             :                      std::string_view name = "");
      33             : 
      34             :   DataArray &operator=(const DataArray &other);
      35             :   DataArray &operator=(DataArray &&other);
      36             : 
      37       48615 :   bool is_valid() const noexcept { return m_data && m_data->is_valid(); }
      38             : 
      39             :   const std::string &name() const;
      40             :   void setName(std::string_view name);
      41             : 
      42      364202 :   const Coords &coords() const { return *m_coords; }
      43             :   // TODO either ensure Dict does not allow changing sizes, or return by value
      44             :   // here
      45      146905 :   Coords &coords() { return *m_coords; }
      46             : 
      47             :   DataArray drop_coords(const scipp::span<const Dim> coord_names) const;
      48             : 
      49      224125 :   const Masks &masks() const { return *m_masks; }
      50       24508 :   Masks &masks() { return *m_masks; }
      51             : 
      52             :   DataArray drop_masks(const scipp::span<const std::string> mask_names) const;
      53             : 
      54      205481 :   const Attrs &attrs() const { return *m_attrs; }
      55       16080 :   Attrs &attrs() { return *m_attrs; }
      56             : 
      57             :   DataArray drop_attrs(const scipp::span<const Dim> attr_names) const;
      58             : 
      59             :   Coords meta() const;
      60             : 
      61      665908 :   [[nodiscard]] const Dimensions &dims() const { return m_data->dims(); }
      62        3585 :   [[nodiscard]] Dim dim() const { return m_data->dim(); }
      63        5064 :   [[nodiscard]] scipp::index ndim() const { return m_data->ndim(); }
      64       16608 :   [[nodiscard]] scipp::span<const scipp::index> strides() const {
      65       16608 :     return m_data->strides();
      66             :   }
      67      114293 :   [[nodiscard]] DType dtype() const { return m_data->dtype(); }
      68        9246 :   [[nodiscard]] units::Unit unit() const { return m_data->unit(); }
      69             : 
      70         153 :   void setUnit(const units::Unit unit) { m_data->setUnit(unit); }
      71             : 
      72             :   /// Return true if the data array contains data variances.
      73       29762 :   bool has_variances() const { return m_data->has_variances(); }
      74             : 
      75             :   /// Return untyped const view for data (values and optional variances).
      76      253405 :   const Variable &data() const { return *m_data; }
      77             :   /// Return untyped view for data (values and optional variances).
      78       34595 :   Variable data() { return *m_data; }
      79             : 
      80             :   /// Return typed const view for data values.
      81           0 :   template <class T> auto values() const {
      82           0 :     return std::as_const(*m_data).values<T>();
      83             :   }
      84             :   /// Return typed view for data values.
      85         944 :   template <class T> auto values() { return m_data->values<T>(); }
      86             : 
      87             :   /// Return typed const view for data variances.
      88           0 :   template <class T> auto variances() const {
      89           0 :     return std::as_const(*m_data).variances<T>();
      90             :   }
      91             :   /// Return typed view for data variances.
      92          69 :   template <class T> auto variances() { return m_data->variances<T>(); }
      93             : 
      94             :   [[nodiscard]] DataArray
      95             :   rename_dims(const std::vector<std::pair<Dim, Dim>> &names,
      96             :               const bool fail_on_unknown = true) const;
      97             : 
      98             :   void setData(const Variable &data);
      99             : 
     100             :   DataArray slice(const Slice &s) const;
     101             :   void validateSlice(const Slice &s, const DataArray &array) const;
     102             :   [[maybe_unused]] DataArray &setSlice(const Slice &s, const DataArray &array);
     103             :   [[maybe_unused]] DataArray &setSlice(const Slice &s, const Variable &var);
     104             : 
     105             :   DataArray view() const;
     106             :   DataArray view_with_coords(const Coords &coords, const std::string &name,
     107             :                              const bool readonly) const;
     108             : 
     109             :   [[nodiscard]] DataArray as_const() const;
     110             : 
     111             :   bool is_readonly() const noexcept;
     112             : 
     113             : private:
     114             :   // Declared friend so gtest recognizes it
     115             :   friend SCIPP_DATASET_EXPORT std::ostream &operator<<(std::ostream &,
     116             :                                                        const DataArray &);
     117             :   std::string m_name;
     118             :   std::shared_ptr<Variable> m_data;
     119             :   std::shared_ptr<Coords> m_coords;
     120             :   std::shared_ptr<Masks> m_masks;
     121             :   std::shared_ptr<Attrs> m_attrs;
     122             :   bool m_readonly{false};
     123             : };
     124             : 
     125             : SCIPP_DATASET_EXPORT bool operator==(const DataArray &a, const DataArray &b);
     126             : SCIPP_DATASET_EXPORT bool operator!=(const DataArray &a, const DataArray &b);
     127             : 
     128             : [[nodiscard]] SCIPP_DATASET_EXPORT DataArray
     129             : copy(const DataArray &array, AttrPolicy attrPolicy = AttrPolicy::Keep);
     130             : 
     131             : [[nodiscard]] SCIPP_DATASET_EXPORT bool equals_nan(const DataArray &a,
     132             :                                                    const DataArray &b);
     133             : 
     134             : } // namespace scipp::dataset
     135             : 
     136             : namespace scipp {
     137             : using dataset::DataArray;
     138             : } // namespace scipp