A sphere with three ocean waves in differing shades of blue. Next to the sphere, there is the bolded text "Ocean Color". Under that, there are two acronyms, separated by a vertical pipe: OB.DAAC (Ocean Biology Distributed Active Archive Center) and OBPG (Ocean Biology Processing Group). Lorem ipsum dolor sit amet
NASA Logo
Ocean Color Science Software

ocssw V2022
Variable.hpp
Go to the documentation of this file.
1 #ifndef FOCS_VARIABLE
2 #define FOCS_VARIABLE
3 
4 #include "Product.hpp"
5 #include "focs/NVector.hpp"
6 #include <iostream>
7 #include <string>
8 #include <unordered_map>
9 #include <vector>
10 #include "genutils.h"
11 namespace focs {
12 
13 //TODO: change attributes to share with product attributes, or at least copy the theory
14 
15 enum class OcType {
16  Char, String, Float, Double, LongDouble,
17  Int8, Int16, Int32, Int64,
18  Uint8, Uint16, Uint32, Uint64,
19  Unknown
20 };
21 // Geospatial = the data moves throughout reading tiles
22 enum class OcGeospatialType {
23  Yes, Line, Pixel, No
24 };
25 
26 template<typename T>
27 class VariableScaler {
28  public:
29  VariableScaler(){}
30  virtual ~VariableScaler(){}
31  virtual T apply(const T& data) {return data;}
32 };
33 template<typename T>
34 class SlopeInterceptScaler : public VariableScaler<T> {
35  public:
36  SlopeInterceptScaler(double slope, double intercept) : slope_{slope}, intercept_{intercept} {}
37  T apply(const T& data) override {
38  return slope_ * data + intercept_;
39  }
40  private:
41  double slope_;
42  double intercept_;
43 };
44 template<typename T>
45 class VariableFill {
46  public:
47  VariableFill(){}
48  virtual ~VariableFill(){}
49  virtual bool is_fill(const T&) {return false;}
50 };
51 template<typename T>
52 class VariableFillValue : public VariableFill<T> {
53  public:
54  VariableFillValue(T value) : value_{value} {}
55  bool is_fill(const T& data) override {
56  return data == value_;
57  }
58  private:
59  T value_;
60 };
61 template<typename T>
62 class VariableFillRange : public VariableFill<T> {
63  public:
64  VariableFillRange(T min, T max) : min_{min}, max_{max} {}
65  bool is_fill(const T& data) override {
66  return !(data < min_ || data > max_);
67  }
68  private:
69  T min_;
70  T max_;
71 };
72 class BaseVariable {
73  public:
74  // typedef void base_type;
75  // typedef void type;
76 
77  BaseVariable() = default;
78  BaseVariable(const Product& provides) : provides_{provides} {}
79  virtual ~BaseVariable(){}
80 
81  std::unordered_map<std::string, std::string>::const_iterator attributes_begin() const {return attributes_.begin();}
82  std::unordered_map<std::string, std::string>::const_iterator attributes_end() const {return attributes_.end();}
83 
84  auto& attributes(){return attributes_;}
85  auto& dimensions(){return dimensions_;}
86 
87  virtual void* _data(){return nullptr;}
88  virtual const void* _data() const { return nullptr; }
89  bool has_data() const {return _data() != nullptr;}
90 
91  const Product& provides(){ return provides_; }
92  Product& get_product(){ return provides_; }
93  void provides(const Product& provides) { provides_ = provides; }
94  const Product& provides() const { return provides_; }
95 
96  const auto& name(){
97  return provides().name();
98  }
99 
100  bool matches(const Product& needs) const { return provides_.matches(needs); }
101  bool matches(const BaseVariable& needs) const { return provides_.matches(needs.provides()); }
102 
103  virtual OcType get_type() const { return OcType::Unknown; }
104  virtual size_t dimension_count() const { return 0; }
105 
106  OcGeospatialType is_geospatial() const { return geo_type_; }
107  void geospatial(OcGeospatialType geo_type) { geo_type_ = geo_type; }
108 
109  virtual void rotate(const size_t number_of_lines){ (void) number_of_lines; }
110 
111  template<typename T>
112  OcType get_type(T) const {
113  if (std::is_same<T, char>::value){
114  return OcType::Char;
115  } else if (std::is_same<T, std::string>::value){
116  return OcType::String;
117  } else if (std::is_same<T, float>::value){
118  return OcType::Float;
119  } else if (std::is_same<T, double>::value){
120  return OcType::Double;
121  } else if (std::is_same<T, long double>::value){
122  return OcType::LongDouble;
123  } else if (std::is_same<T, int8_t>::value){
124  return OcType::Int8;
125  } else if (std::is_same<T, int16_t>::value){
126  return OcType::Int16;
127  } else if (std::is_same<T, int32_t>::value){
128  return OcType::Int32;
129  } else if (std::is_same<T, int64_t>::value){
130  return OcType::Int64;
131  } else if (std::is_same<T, uint8_t>::value){
132  return OcType::Uint8;
133  } else if (std::is_same<T, uint16_t>::value){
134  return OcType::Uint16;
135  } else if (std::is_same<T, uint32_t>::value){
136  return OcType::Uint32;
137  } else if (std::is_same<T, uint64_t>::value){
138  return OcType::Uint64;
139  }
140  return OcType::Unknown;
141  }
142 
143  netCDF::NcType type_to_nc(){
144  switch (get_type()){
145  case OcType::Char:
146  return netCDF::NcType::nc_CHAR;
147  case OcType::String:
148  return netCDF::NcType::nc_STRING;
149  case OcType::Float:
150  return netCDF::NcType::nc_FLOAT;
151  case OcType::Double:
152  return netCDF::NcType::nc_DOUBLE;
153  case OcType::LongDouble:
154  return netCDF::NcType::nc_DOUBLE;
155  case OcType::Int8:
156  return netCDF::NcType::nc_BYTE;
157  case OcType::Int16:
158  return netCDF::NcType::nc_SHORT;
159  case OcType::Int32:
160  return netCDF::NcType::nc_INT;
161  case OcType::Int64:
162  return netCDF::NcType::nc_INT64;
163  case OcType::Uint8:
164  return netCDF::NcType::nc_UBYTE;
165  case OcType::Uint16:
166  return netCDF::NcType::nc_USHORT;
167  case OcType::Uint32:
168  return netCDF::NcType::nc_UINT;
169  case OcType::Uint64:
170  return netCDF::NcType::nc_UINT64;
171  case OcType::Unknown:
172  return netCDF::NcType::nc_OPAQUE;
173  }
174  return {};
175  }
176 
177  protected:
178  Product provides_{};
179  std::unordered_map<std::string, std::string> attributes_{};
180  std::vector<std::pair<std::string, size_t>> dimensions_{};
181  OcGeospatialType geo_type_{OcGeospatialType::Yes}; // only FileReaders will be making data not based on a DataRecord, which makes them geospatial by nature
182 };
183 
184 template<typename T, size_t Dims>
185 class Variable : public BaseVariable {
186  public:
187  typedef T base_type;
188  typedef typename NVector<T, Dims>::type type;
189 
190  Variable(){}
191  Variable(const Product& provides) : BaseVariable(provides) {}
192  Variable(const type&& data) : data_{data} {}
193  const void* _data() const override {
194  return static_cast<const void*>(&data_);
195  }
196  void* _data() override {
197  return static_cast<void*>(&data_);
198  }
199  const type& data() const {
200  return data_;
201  }
202  type& data(){
203  return data_;
204  }
205  auto& operator[](const size_t i){
206  return data_[i];
207  }
208 
209  OcType get_type() const override { return BaseVariable::get_type(T{}); }
210  size_t dimension_count() const override { return Dims; }
211 
212  VariableFill<T>* fill_value() const { return fill_value_.get(); }
213  void fill_value(std::unique_ptr<VariableFill<T>>&& fill_value) { fill_value_ = std::move(fill_value); }
214  void fill_value(const T& fill_value) { fill_value_ = std::make_unique<VariableFillValue<T>>(fill_value); }
215 
216  void scaler(std::unique_ptr<VariableScaler<T>>&& scaler){scaler_ = std::move(scaler);}
217  VariableScaler<T>* scaler(){return scaler_.get();}
218 
219  bool is_fill_value(const T& value){
220  if (fill_value_){
221  return fill_value_->is_fill(value);
222  }
223  return false;
224  }
225  template<typename TT>
226  bool is_fill_value(const TT& value){
227  if (fill_value_){
228  return fill_value_->is_fill(value);
229  }
230  return false;
231  }
232  template<typename TT, typename std::enable_if<std::is_same<TT, double>::value>::type* = nullptr>
233  void apply_scaling(TT* v, const size_t count){
234  if (scaler_){
235  for (size_t i=0;i<count;i++){
236  if (is_fill_value(v[i])){
237  v[i] = BAD_FLT;
238  } else {
239  v[i] = scaler_->apply(v[i]);
240  }
241  }
242  }
243  }
244  template<typename TT, typename std::enable_if<std::is_same<TT, long double>::value>::type* = nullptr>
245  void apply_scaling(TT* v, const size_t count){
246  if (scaler_){
247  for (size_t i=0;i<count;i++){
248  if (is_fill_value(v[i])){
249  v[i] = BAD_FLT;
250  } else {
251  v[i] = scaler_->apply(v[i]);
252  }
253  }
254  }
255  }
256  template<typename TT, typename std::enable_if<std::is_same<TT, float>::value>::type* = nullptr>
257  void apply_scaling(TT* v, const size_t count){
258  if (scaler_){
259  for (size_t i=0;i<count;i++){
260  if (is_fill_value(v[i])){
261  v[i] = BAD_FLT;
262  } else {
263  v[i] = scaler_->apply(v[i]);
264  }
265  }
266  }
267  }
268  template<typename TT, typename std::enable_if<!std::is_floating_point<TT>::value>::type* = nullptr>
269  void apply_scaling(TT* v, const size_t count){
270  if (scaler_){
271  for (size_t i=0;i<count;i++){
272  if (!is_fill_value(v[i])){
273  v[i] = scaler_->apply(v[i]);
274  }
275  }
276  }
277  }
278  virtual void rotate(const size_t number_of_lines) override {
279  if (Dims == 2){
280  switch (is_geospatial()){
281  case OcGeospatialType::Yes:
282  case OcGeospatialType::Line:
283  {
284  using std::swap;
285  const size_t swap_start = data_.size() - number_of_lines;
286  // std::cout << "Rotation, starting at " << swap_start << "\n";
287  for (size_t i=0;i<number_of_lines;i++){
288  swap(data_[i], data_[swap_start + i]);
289  }
290  }
291  break;
292  default:
293  break;
294  }
295  }
296  }
297  protected:
298  type data_{};
299  // FillValueT fill_value_{std::numeric_limits<FillValueT>::max};
300  std::unique_ptr<VariableScaler<T>> scaler_{};
301  std::unique_ptr<VariableFill<T>> fill_value_{};
302 };
303 template<typename T>
304 std::ostream& operator<<(std::ostream& os, const Variable<T, 2>& v){
305  os << "focs::Variable{" << v.provides() << ", ";
306  const size_t max_i = v.data().size() - 1;
307  const size_t max_j = v.data()[0].size() - 1;
308  // os << "(" << max_i << "x" << max_j << "), ";
309  os << "[\n";
310  for (size_t i=0;i<=max_i;i++){
311  os << "\t[";
312  for (size_t j=0;j<=max_j;j++){
313  os << v.data()[i][j];
314  if (j != max_j){
315  os << ", ";
316  }
317  }
318  os << "]";
319  if (i != max_i){
320  os << ",";
321  }
322  os << "\n";
323  }
324  os << "]}";
325  return os;
326 }
327 
328 } // namespace focs
329 
330 #endif // FOCS_VARIABLE
focs::BaseVariable::dimensions_
std::vector< std::pair< std::string, size_t > > dimensions_
Definition: Variable.hpp:180
value
int32 value
Definition: Granule.c:1235
focs::VariableFillValue::VariableFillValue
VariableFillValue(T value)
Definition: Variable.hpp:54
focs::BaseVariable::BaseVariable
BaseVariable(const Product &provides)
Definition: Variable.hpp:78
focs::VariableFillRange::is_fill
bool is_fill(const T &data) override
Definition: Variable.hpp:65
focs::Variable::apply_scaling
void apply_scaling(TT *v, const size_t count)
Definition: Variable.hpp:233
focs::BaseVariable::attributes_
std::unordered_map< std::string, std::string > attributes_
Definition: Variable.hpp:179
needs
MOD_PR03 Production as they are both run by PGE01 It processes every granule that MOD_PR01 produces See MOD_PR01_pr txt for the actual timing since they are imposed by MOD_PR01 s needs
Definition: MOD_PR03_pr.txt:7
j
int j
Definition: decode_rs.h:73
focs::BaseVariable::type_to_nc
netCDF::NcType type_to_nc()
Definition: Variable.hpp:143
focs::BaseVariable::get_product
Product & get_product()
Definition: Variable.hpp:92
focs::Product::name
void name(std::string name)
Definition: Product.hpp:560
focs::Variable::fill_value
VariableFill< T > * fill_value() const
Definition: Variable.hpp:212
focs::Variable::scaler_
std::unique_ptr< VariableScaler< T > > scaler_
Definition: Variable.hpp:300
focs::VariableFill::~VariableFill
virtual ~VariableFill()
Definition: Variable.hpp:48
focs::Variable::rotate
virtual void rotate(const size_t number_of_lines) override
Definition: Variable.hpp:278
focs::VariableFill::is_fill
virtual bool is_fill(const T &)
Definition: Variable.hpp:49
color_dtdb.v
v
Definition: color_dtdb.py:430
focs::Variable::fill_value
void fill_value(std::unique_ptr< VariableFill< T >> &&fill_value)
Definition: Variable.hpp:213
focs::Variable::type
NVector< T, Dims >::type type
Definition: Variable.hpp:188
focs::BaseVariable::matches
bool matches(const BaseVariable &needs) const
Definition: Variable.hpp:101
focs::BaseVariable::attributes_begin
std::unordered_map< std::string, std::string >::const_iterator attributes_begin() const
Definition: Variable.hpp:81
focs::BaseVariable::attributes
auto & attributes()
Definition: Variable.hpp:84
focs::VariableScaler::~VariableScaler
virtual ~VariableScaler()
Definition: Variable.hpp:30
focs::Product::matches
bool matches(const std::vector< Product > &other) const
Definition: Product.hpp:578
focs::Variable::dimension_count
size_t dimension_count() const override
Definition: Variable.hpp:210
focs::BaseVariable::geo_type_
OcGeospatialType geo_type_
Definition: Variable.hpp:181
focs::NVector::type
std::vector< typename NVector< T, Dims - 1 >::type > type
Definition: NVector.hpp:6
focs::BaseVariable::~BaseVariable
virtual ~BaseVariable()
Definition: Variable.hpp:79
focs::operator<<
std::ostream & operator<<(std::ostream &os, const std::vector< T > &data) noexcept
Definition: Product.hpp:159
focs::OcGeospatialType
OcGeospatialType
Definition: Variable.hpp:22
focs::SlopeInterceptScaler::apply
T apply(const T &data) override
Definition: Variable.hpp:37
focs::Variable::scaler
VariableScaler< T > * scaler()
Definition: Variable.hpp:217
focs::BaseVariable::provides
void provides(const Product &provides)
Definition: Variable.hpp:93
focs::Variable::fill_value
void fill_value(const T &fill_value)
Definition: Variable.hpp:214
focs::BaseVariable::get_type
OcType get_type(T) const
Definition: Variable.hpp:112
focs::Variable::data
type & data()
Definition: Variable.hpp:202
os
subroutine os(tamoy, trmoy, pizmoy, tamoyp, trmoyp, palt, phirad, nt, mu, np, rm, gb, rp, xl)
Definition: 6sm1.f:5484
focs::Variable::operator[]
auto & operator[](const size_t i)
Definition: Variable.hpp:205
focs::BaseVariable::attributes_end
std::unordered_map< std::string, std::string >::const_iterator attributes_end() const
Definition: Variable.hpp:82
slope
float32 slope[]
Definition: l2lists.h:30
max
#define max(A, B)
Definition: main_biosmap.c:61
focs::BaseVariable::dimensions
auto & dimensions()
Definition: Variable.hpp:85
focs::Variable::Variable
Variable(const Product &provides)
Definition: Variable.hpp:191
focs::BaseVariable::BaseVariable
BaseVariable()=default
intercept
float32 intercept[]
Definition: l2lists.h:44
focs::BaseVariable::geospatial
void geospatial(OcGeospatialType geo_type)
Definition: Variable.hpp:107
focs::Variable::scaler
void scaler(std::unique_ptr< VariableScaler< T >> &&scaler)
Definition: Variable.hpp:216
focs::OcType
OcType
Definition: Variable.hpp:15
focs::BaseVariable::rotate
virtual void rotate(const size_t number_of_lines)
Definition: Variable.hpp:109
focs::BaseVariable::dimension_count
virtual size_t dimension_count() const
Definition: Variable.hpp:104
data
no change in intended resolving MODur00064 Corrected handling of bad ephemeris attitude data
Definition: HISTORY.txt:356
min
#define min(A, B)
Definition: main_biosmap.c:62
focs::Variable::data
const type & data() const
Definition: Variable.hpp:199
focs::BaseVariable::get_type
virtual OcType get_type() const
Definition: Variable.hpp:103
BAD_FLT
#define BAD_FLT
Definition: jplaeriallib.h:19
focs::VariableScaler::apply
virtual T apply(const T &data)
Definition: Variable.hpp:31
focs::Variable::fill_value_
std::unique_ptr< VariableFill< T > > fill_value_
Definition: Variable.hpp:301
focs::BaseVariable::name
const auto & name()
Definition: Variable.hpp:96
focs::VariableFillValue::is_fill
bool is_fill(const T &data) override
Definition: Variable.hpp:55
focs::Variable::is_fill_value
bool is_fill_value(const TT &value)
Definition: Variable.hpp:226
focs::Variable::_data
const void * _data() const override
Definition: Variable.hpp:193
focs::BaseVariable::has_data
bool has_data() const
Definition: Variable.hpp:89
focs::Variable::is_fill_value
bool is_fill_value(const T &value)
Definition: Variable.hpp:219
focs::BaseVariable::_data
virtual void * _data()
Definition: Variable.hpp:87
focs::BaseVariable::is_geospatial
OcGeospatialType is_geospatial() const
Definition: Variable.hpp:106
focs::BaseVariable::provides
const Product & provides()
Definition: Variable.hpp:91
focs::BaseVariable::provides
const Product & provides() const
Definition: Variable.hpp:94
focs::Variable::_data
void * _data() override
Definition: Variable.hpp:196
focs::BaseVariable::_data
virtual const void * _data() const
Definition: Variable.hpp:88
focs::BaseVariable::matches
bool matches(const Product &needs) const
Definition: Variable.hpp:100
i
int i
Definition: decode_rs.h:71
focs::Variable::Variable
Variable(const type &&data)
Definition: Variable.hpp:192
focs::Variable::get_type
OcType get_type() const override
Definition: Variable.hpp:209
focs::SlopeInterceptScaler::SlopeInterceptScaler
SlopeInterceptScaler(double slope, double intercept)
Definition: Variable.hpp:36
focs::VariableFillRange::VariableFillRange
VariableFillRange(T min, T max)
Definition: Variable.hpp:64
count
int count
Definition: decode_rs.h:79


ABOUT

Our Team

Contact Us

DATA

Get Started

Find Data

Use Data

TOOLS

SeaBASS

SeaDAS

Giovanni Data Visualizer

Worldview Mapping Interface

Mission Quality Monitor

HELP

How to Use Earthdata Search

Level 3 & 4 Browser Help

File Search Help

Search & Download Help

Earthdata Forum

Join Mailing List

How to Cite Data

CONNECT WITH US
COMPLIANCE

Web Privacy Policy

Data & Information Policy

Communications Policy

Accessibility

Freedom of Information Act

USA.gov

Responsible NASA Official: Sean Bailey
Curator: OceanColor Webmaster