OOPS
oops/interface/Increment.h
Go to the documentation of this file.
1 /*
2  * (C) Copyright 2009-2016 ECMWF.
3  * (C) Copyright 2017-2019 UCAR.
4  *
5  * This software is licensed under the terms of the Apache Licence Version 2.0
6  * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
7  * In applying this licence, ECMWF does not waive the privileges and immunities
8  * granted to it by virtue of its status as an intergovernmental organisation nor
9  * does it submit to any jurisdiction.
10  */
11 
12 #ifndef OOPS_INTERFACE_INCREMENT_H_
13 #define OOPS_INTERFACE_INCREMENT_H_
14 
15 #include <memory>
16 #include <string>
17 #include <vector>
18 
19 #include "atlas/field.h"
20 
21 #include "oops/base/GeneralizedDepartures.h"
22 #include "oops/base/LocalIncrement.h"
23 #include "oops/base/Variables.h"
24 #include "oops/interface/Geometry.h"
25 #include "oops/interface/GeometryIterator.h"
26 #include "oops/interface/State.h"
27 #include "oops/mpi/mpi.h"
28 #include "oops/util/DateTime.h"
29 #include "oops/util/Duration.h"
30 #include "oops/util/gatherPrint.h"
31 #include "oops/util/ObjectCounter.h"
32 #include "oops/util/Printable.h"
33 #include "oops/util/Serializable.h"
34 #include "oops/util/Timer.h"
35 
36 namespace oops {
37 
38 /// Increment Class: Difference between two states
39 /*!
40  * Some fields that are present in a State may not be present in an Increment.
41  */
42 
43 // -----------------------------------------------------------------------------
44 
45 template <typename MODEL>
46 class Increment : public oops::GeneralizedDepartures,
47  public util::Printable,
48  public util::Serializable,
49  private util::ObjectCounter<Increment<MODEL> > {
50  typedef typename MODEL::Increment Increment_;
51  typedef Geometry<MODEL> Geometry_;
52  typedef GeometryIterator<MODEL> GeometryIterator_;
53  typedef State<MODEL> State_;
54 
55  public:
56  static const std::string classname() {return "oops::Increment";}
57 
58 /// Constructor, destructor
59  Increment(const Geometry_ &, const Variables &, const util::DateTime &);
60  Increment(const Geometry_ &, const Increment &);
61  Increment(const Increment &, const bool copy = true);
62  virtual ~Increment();
63 
64 /// Interfacing
65  Increment_ & increment() {return *increment_;}
66  const Increment_ & increment() const {return *increment_;}
67 
68 /// Interactions with State
69  void diff(const State_ &, const State_ &);
70 
71 /// Time
72  const util::DateTime validTime() const {return increment_->validTime();}
73  void updateTime(const util::Duration & dt) {increment_->updateTime(dt);}
74 
75 /// Linear algebra operators
76  void zero();
77  void zero(const util::DateTime &);
78  void ones();
79  void dirac(const eckit::Configuration &);
80  Increment & operator =(const Increment &);
81  Increment & operator+=(const Increment &);
82  Increment & operator-=(const Increment &);
83  Increment & operator*=(const double &);
84  void axpy(const double &, const Increment &, const bool check = true);
85  double dot_product_with(const Increment &) const;
86  void schur_product_with(const Increment &);
87  void random();
88  void accumul(const double &, const State_ &);
89 
90 /// I/O and diagnostics
91  void read(const eckit::Configuration &);
92  void write(const eckit::Configuration &) const;
93  double norm() const;
94 
95  LocalIncrement getLocal(const GeometryIterator_ & iter) const;
96  void setLocal(const LocalIncrement & gp, const GeometryIterator_ & iter);
97 
98 /// Get geometry
99  Geometry_ geometry() const;
100  const Variables & variables() const {return variables_;}
101 
102 /// ATLAS FieldSet
103  void setAtlas(atlas::FieldSet *) const;
104  void toAtlas(atlas::FieldSet *) const;
105  void fromAtlas(atlas::FieldSet *);
106 
107 /// ATLAS fieldset
108  void toAtlas();
109  atlas::FieldSet & atlas() {
110  return atlasFieldSet_;
111  }
112  const atlas::FieldSet & atlas() const {
113  return atlasFieldSet_;
114  }
115 
116 /// Serialize and deserialize
117  size_t serialSize() const override;
118  void serialize(std::vector<double> &) const override;
119  void deserialize(const std::vector<double> &, size_t &) override;
120 
121  void shift_forward(const util::DateTime &);
122  void shift_backward(const util::DateTime &);
123  const eckit::mpi::Comm & timeComm() const {return commTime_;}
124 
125  private:
126  void print(std::ostream &) const override;
127  std::unique_ptr<Increment_> increment_;
128  const Variables variables_;
129  const eckit::mpi::Comm & commTime_;
130  atlas::FieldSet atlasFieldSet_;
131 };
132 
133 // -----------------------------------------------------------------------------
134 
135 template <typename MODEL>
136 State<MODEL> & operator+=(State<MODEL> & xx, const Increment<MODEL> & dx) {
137  Log::trace() << "operator+=(State, Increment) starting" << std::endl;
138  util::Timer timer("oops::Increment", "operator+=(State, Increment)");
139  xx.state() += dx.increment();
140  Log::trace() << "operator+=(State, Increment) done" << std::endl;
141  return xx;
142 }
143 
144 // =============================================================================
145 /// Constructor, destructor
146 // -----------------------------------------------------------------------------
147 
148 template<typename MODEL>
149 Increment<MODEL>::Increment(const Geometry_ & resol, const Variables & vars,
150  const util::DateTime & time)
151  : increment_(), variables_(vars), commTime_(resol.timeComm())
152 {
153  Log::trace() << "Increment<MODEL>::Increment starting" << std::endl;
154  util::Timer timer(classname(), "Increment");
155  increment_.reset(new Increment_(resol.geometry(), vars, time));
156  Log::trace() << "Increment<MODEL>::Increment done" << std::endl;
157 }
158 
159 // -----------------------------------------------------------------------------
160 
161 template<typename MODEL>
162 Increment<MODEL>::Increment(const Geometry_ & resol, const Increment & other)
163  : increment_(), variables_(other.variables_), commTime_(other.commTime_)
164 {
165  Log::trace() << "Increment<MODEL>::Increment starting" << std::endl;
166  util::Timer timer(classname(), "Increment");
167  increment_.reset(new Increment_(resol.geometry(), *other.increment_));
168  Log::trace() << "Increment<MODEL>::Increment done" << std::endl;
169 }
170 
171 // -----------------------------------------------------------------------------
172 
173 template<typename MODEL>
174 Increment<MODEL>::Increment(const Increment & other, const bool copy)
175  : increment_(), variables_(other.variables_), commTime_(other.commTime_)
176 {
177  Log::trace() << "Increment<MODEL>::Increment copy starting" << std::endl;
178  util::Timer timer(classname(), "Increment");
179  increment_.reset(new Increment_(*other.increment_, copy));
180  Log::trace() << "Increment<MODEL>::Increment copy done" << std::endl;
181 }
182 
183 // -----------------------------------------------------------------------------
184 
185 template<typename MODEL>
186 Increment<MODEL>::~Increment() {
187  Log::trace() << "Increment<MODEL>::~Increment starting" << std::endl;
188  util::Timer timer(classname(), "~Increment");
189  increment_.reset();
190  Log::trace() << "Increment<MODEL>::~Increment done" << std::endl;
191 }
192 
193 // -----------------------------------------------------------------------------
194 
195 template<typename MODEL>
196 void Increment<MODEL>::diff(const State_ & x1, const State_ & x2) {
197  Log::trace() << "Increment<MODEL>::diff starting" << std::endl;
198  util::Timer timer(classname(), "diff");
199  increment_->diff(x1.state(), x2.state());
200  Log::trace() << "Increment<MODEL>::diff done" << std::endl;
201 }
202 
203 // -----------------------------------------------------------------------------
204 
205 template<typename MODEL>
206 void Increment<MODEL>::zero() {
207  Log::trace() << "Increment<MODEL>::zero starting" << std::endl;
208  util::Timer timer(classname(), "zero");
209  increment_->zero();
210  Log::trace() << "Increment<MODEL>::zero done" << std::endl;
211 }
212 
213 // -----------------------------------------------------------------------------
214 
215 template<typename MODEL>
216 void Increment<MODEL>::zero(const util::DateTime & tt) {
217  Log::trace() << "Increment<MODEL>::zero starting" << std::endl;
218  util::Timer timer(classname(), "zero");
219  increment_->zero(tt);
220  Log::trace() << "Increment<MODEL>::zero done" << std::endl;
221 }
222 
223 // -----------------------------------------------------------------------------
224 
225 template<typename MODEL>
226 void Increment<MODEL>::ones() {
227  Log::trace() << "Increment<MODEL>::ones starting" << std::endl;
228  util::Timer timer(classname(), "ones");
229  increment_->ones();
230  Log::trace() << "Increment<MODEL>::ones done" << std::endl;
231 }
232 
233 // -----------------------------------------------------------------------------
234 
235 template<typename MODEL>
236 void Increment<MODEL>::dirac(const eckit::Configuration & config) {
237  Log::trace() << "Increment<MODEL>::dirac starting" << std::endl;
238  util::Timer timer(classname(), "dirac");
239  increment_->dirac(config);
240  Log::trace() << "Increment<MODEL>::dirac done" << std::endl;
241 }
242 
243 // -----------------------------------------------------------------------------
244 
245 template<typename MODEL>
246 Increment<MODEL> & Increment<MODEL>::operator=(const Increment & rhs) {
247  Log::trace() << "Increment<MODEL>::operator= starting" << std::endl;
248  util::Timer timer(classname(), "operator=");
249  *increment_ = *rhs.increment_;
250  Log::trace() << "Increment<MODEL>::operator= done" << std::endl;
251  return *this;
252 }
253 
254 // -----------------------------------------------------------------------------
255 
256 template<typename MODEL>
257 Increment<MODEL> & Increment<MODEL>::operator+=(const Increment & rhs) {
258  Log::trace() << "Increment<MODEL>::operator+= starting" << std::endl;
259  util::Timer timer(classname(), "operator+=");
260  *increment_ += *rhs.increment_;
261  Log::trace() << "Increment<MODEL>::operator+= done" << std::endl;
262  return *this;
263 }
264 
265 // -----------------------------------------------------------------------------
266 
267 template<typename MODEL>
268 Increment<MODEL> & Increment<MODEL>::operator-=(const Increment & rhs) {
269  Log::trace() << "Increment<MODEL>::operator-= starting" << std::endl;
270  util::Timer timer(classname(), "operator-=");
271  *increment_ -= *rhs.increment_;
272  Log::trace() << "Increment<MODEL>::operator-= done" << std::endl;
273  return *this;
274 }
275 
276 // -----------------------------------------------------------------------------
277 
278 template<typename MODEL>
279 Increment<MODEL> & Increment<MODEL>::operator*=(const double & zz) {
280  Log::trace() << "Increment<MODEL>::operator*= starting" << std::endl;
281  util::Timer timer(classname(), "operator*=");
282  *increment_ *= zz;
283  Log::trace() << "Increment<MODEL>::operator*= done" << std::endl;
284  return *this;
285 }
286 
287 // -----------------------------------------------------------------------------
288 
289 template<typename MODEL>
290 void Increment<MODEL>::axpy(const double & zz, const Increment & dx, const bool check) {
291  Log::trace() << "Increment<MODEL>::axpy starting" << std::endl;
292  util::Timer timer(classname(), "axpy");
293  increment_->axpy(zz, *dx.increment_, check);
294  Log::trace() << "Increment<MODEL>::axpy done" << std::endl;
295 }
296 
297 // -----------------------------------------------------------------------------
298 
299 template<typename MODEL>
300 double Increment<MODEL>::dot_product_with(const Increment & dx) const {
301  Log::trace() << "Increment<MODEL>::dot_product_with starting" << std::endl;
302  util::Timer timer(classname(), "dot_product_with");
303  double zz = increment_->dot_product_with(*dx.increment_);
304  commTime_.allReduceInPlace(zz, eckit::mpi::Operation::SUM);
305  Log::trace() << "Increment<MODEL>::dot_product_with done" << std::endl;
306  return zz;
307 }
308 
309 // -----------------------------------------------------------------------------
310 
311 template<typename MODEL>
312 void Increment<MODEL>::schur_product_with(const Increment & dx) {
313  Log::trace() << "Increment<MODEL>::schur_product_with starting" << std::endl;
314  util::Timer timer(classname(), "schur_product_with");
315  increment_->schur_product_with(*dx.increment_);
316  Log::trace() << "Increment<MODEL>::schur_product_with done" << std::endl;
317 }
318 
319 // -----------------------------------------------------------------------------
320 
321 template<typename MODEL>
322 void Increment<MODEL>::random() {
323  Log::trace() << "Increment<MODEL>::random starting" << std::endl;
324  util::Timer timer(classname(), "random");
325  increment_->random();
326  Log::trace() << "Increment<MODEL>::random done" << std::endl;
327 }
328 
329 // -----------------------------------------------------------------------------
330 
331 template<typename MODEL>
332 void Increment<MODEL>::accumul(const double & zz, const State_ & xx) {
333  Log::trace() << "Increment<MODEL>::accumul starting" << std::endl;
334  util::Timer timer(classname(), "accumul");
335  increment_->accumul(zz, xx.state());
336  Log::trace() << "Increment<MODEL>::accumul done" << std::endl;
337 }
338 
339 // -----------------------------------------------------------------------------
340 
341 template<typename MODEL>
342 LocalIncrement Increment<MODEL>::getLocal(const GeometryIterator_ & iter) const {
343  Log::trace() << "Increment<MODEL>::getLocal starting" << std::endl;
344  util::Timer timer(classname(), "getLocal");
345  LocalIncrement gp = increment_->getLocal(iter.geometryiter());
346  Log::trace() << "Increment<MODEL>::getLocal done" << std::endl;
347  return gp;
348 }
349 
350 // -----------------------------------------------------------------------------
351 template<typename MODEL>
352 void Increment<MODEL>::setLocal(const LocalIncrement & gp,
353  const GeometryIterator_ & iter) {
354  Log::trace() << "Increment<MODEL>::setLocal starting" << std::endl;
355  util::Timer timer(classname(), "setLocal");
356  increment_->setLocal(gp, iter.geometryiter());
357  Log::trace() << "Increment<MODEL>::setLocal done" << std::endl;
358 }
359 
360 // -----------------------------------------------------------------------------
361 
362 template<typename MODEL>
363 void Increment<MODEL>::read(const eckit::Configuration & conf) {
364  Log::trace() << "Increment<MODEL>::read starting" << std::endl;
365  util::Timer timer(classname(), "read");
366  increment_->read(conf);
367  Log::trace() << "Increment<MODEL>::read done" << std::endl;
368 }
369 
370 // -----------------------------------------------------------------------------
371 
372 template<typename MODEL>
373 void Increment<MODEL>::write(const eckit::Configuration & conf) const {
374  Log::trace() << "Increment<MODEL>::write starting" << std::endl;
375  util::Timer timer(classname(), "write");
376  increment_->write(conf);
377  Log::trace() << "Increment<MODEL>::write done" << std::endl;
378 }
379 
380 // -----------------------------------------------------------------------------
381 
382 template<typename MODEL>
383 double Increment<MODEL>::norm() const {
384  Log::trace() << "Increment<MODEL>::norm starting" << std::endl;
385  util::Timer timer(classname(), "norm");
386  double zz = increment_->norm();
387  zz *= zz;
388  commTime_.allReduceInPlace(zz, eckit::mpi::Operation::SUM);
389  zz = sqrt(zz);
390  Log::trace() << "Increment<MODEL>::norm done" << std::endl;
391  return zz;
392 }
393 
394 // -----------------------------------------------------------------------------
395 
396 template<typename MODEL>
397 Geometry<MODEL> Increment<MODEL>::geometry() const {
398  Log::trace() << "Increment<MODEL>::geometry starting" << std::endl;
399  util::Timer timer(classname(), "geometry");
400  Geometry<MODEL> geom(increment_->geometry());
401  Log::trace() << "Increment<MODEL>::geometry done" << std::endl;
402  return geom;
403 }
404 
405 // -----------------------------------------------------------------------------
406 
407 template<typename MODEL>
408 void Increment<MODEL>::setAtlas(atlas::FieldSet * atlasFieldSet) const {
409  Log::trace() << "Increment<MODEL>::setAtlas starting" << std::endl;
410  util::Timer timer(classname(), "setAtlas");
411  increment_->setAtlas(atlasFieldSet);
412  Log::trace() << "Increment<MODEL>::setAtlas done" << std::endl;
413 }
414 
415 // -----------------------------------------------------------------------------
416 
417 template<typename MODEL>
418 void Increment<MODEL>::toAtlas(atlas::FieldSet * atlasFieldSet) const {
419  Log::trace() << "Increment<MODEL>::toAtlas starting" << std::endl;
420  util::Timer timer(classname(), "toAtlas");
421  increment_->toAtlas(atlasFieldSet);
422  Log::trace() << "Increment<MODEL>::toAtlas done" << std::endl;
423 }
424 
425 // -----------------------------------------------------------------------------
426 
427 template<typename MODEL>
428 void Increment<MODEL>::fromAtlas(atlas::FieldSet * atlasFieldSet) {
429  Log::trace() << "Increment<MODEL>::fromAtlas starting" << std::endl;
430  util::Timer timer(classname(), "fromAtlas");
431  increment_->fromAtlas(atlasFieldSet);
432  Log::trace() << "Increment<MODEL>::fromAtlas done" << std::endl;
433 }
434 
435 // -----------------------------------------------------------------------------
436 
437 template<typename MODEL>
438 void Increment<MODEL>::toAtlas() {
439  Log::trace() << "Increment<MODEL>::toAtlas starting" << std::endl;
440  increment_->toAtlas(&atlasFieldSet_);
441  increment_.reset();
442  Log::trace() << "Increment<MODEL>::toAtlas done" << std::endl;
443 }
444 
445 // -----------------------------------------------------------------------------
446 
447 template<typename MODEL>
448 size_t Increment<MODEL>::serialSize() const {
449  Log::trace() << "Increment<MODEL>::serialSize" << std::endl;
450  util::Timer timer(classname(), "serialSize");
451  return increment_->serialSize();
452 }
453 
454 // -----------------------------------------------------------------------------
455 
456 template<typename MODEL>
457 void Increment<MODEL>::serialize(std::vector<double> & vect) const {
458  Log::trace() << "Increment<MODEL>::serialize starting" << std::endl;
459  util::Timer timer(classname(), "serialize");
460  increment_->serialize(vect);
461  Log::trace() << "Increment<MODEL>::serialize done" << std::endl;
462 }
463 
464 // -----------------------------------------------------------------------------
465 
466 template<typename MODEL>
467 void Increment<MODEL>::deserialize(const std::vector<double> & vect, size_t & current) {
468  Log::trace() << "Increment<MODEL>::Increment deserialize starting" << std::endl;
469  util::Timer timer(classname(), "deserialize");
470  increment_->deserialize(vect, current);
471  Log::trace() << "Increment<MODEL>::Increment deserialize done" << std::endl;
472 }
473 
474 // -----------------------------------------------------------------------------
475 
476 template<typename MODEL>
477 void Increment<MODEL>::shift_forward(const util::DateTime & begin) {
478  Log::trace() << "Increment<MODEL>::Increment shift_forward starting" << std::endl;
479  util::Timer timer(classname(), "shift_forward");
480  static int tag = 159357;
481  size_t mytime = commTime_.rank();
482 
483 // Send values of M.dx_i at end of my subwindow to next subwindow
484  if (mytime + 1 < commTime_.size()) {
485  oops::mpi::send(commTime_, *this, mytime+1, tag);
486  }
487 
488 // Receive values at beginning of my subwindow from previous subwindow
489  if (mytime > 0) {
490  oops::mpi::receive(commTime_, *this, mytime-1, tag);
491  } else {
492  increment_->zero(begin);
493  }
494 
495  ++tag;
496  Log::trace() << "Increment<MODEL>::Increment shift_forward done" << std::endl;
497 }
498 
499 // -----------------------------------------------------------------------------
500 
501 template<typename MODEL>
502 void Increment<MODEL>::shift_backward(const util::DateTime & end) {
503  Log::trace() << "Increment<MODEL>::Increment shift_backward starting" << std::endl;
504  util::Timer timer(classname(), "shift_backward");
505  static int tag = 753951;
506  size_t mytime = commTime_.rank();
507 
508 // Send values of dx_i at start of my subwindow to previous subwindow
509  if (mytime > 0) {
510  oops::mpi::send(commTime_, *this, mytime-1, tag);
511  }
512 
513 // Receive values at end of my subwindow from next subwindow
514  if (mytime + 1 < commTime_.size()) {
515  oops::mpi::receive(commTime_, *this, mytime+1, tag);
516  } else {
517  increment_->zero(end);
518  }
519 
520  ++tag;
521  Log::trace() << "Increment<MODEL>::Increment shift_backward done" << std::endl;
522 }
523 
524 // -----------------------------------------------------------------------------
525 
526 template<typename MODEL>
527 void Increment<MODEL>::print(std::ostream & os) const {
528  Log::trace() << "Increment<MODEL>::print starting" << std::endl;
529  util::Timer timer(classname(), "print");
530  if (commTime_.size() > 1) {
531  gatherPrint(os, *increment_, commTime_);
532  } else {
533  os << *increment_;
534  }
535  Log::trace() << "Increment<MODEL>::print done" << std::endl;
536 }
537 
538 // -----------------------------------------------------------------------------
539 
540 } // namespace oops
541 
542 #endif // OOPS_INTERFACE_INCREMENT_H_
oops
The namespace for the main oops code.
Definition: ErrorCovarianceL95.cc:22
oops::operator+=
State4D< MODEL > & operator+=(State4D< MODEL > &xx, const Increment4D< MODEL > &dx)
Definition: Increment4D.h:126
oops::GeneralizedDepartures
Abstract base class for quantities.
Definition: GeneralizedDepartures.h:22
oops::Increment::Geometry_
Geometry< MODEL > Geometry_
Definition: oops/interface/Increment.h:51
oops::Increment::shift_forward
void shift_forward(const util::DateTime &)
Definition: oops/interface/Increment.h:477
oops::Increment::timeComm
const eckit::mpi::Comm & timeComm() const
Definition: oops/interface/Increment.h:123
oops::GeometryIterator
Definition: oops/interface/GeometryIterator.h:32
oops::Increment::geometry
Geometry_ geometry() const
Get geometry.
Definition: oops/interface/Increment.h:397
oops::Increment::norm
double norm() const
Definition: oops/interface/Increment.h:383
mpi.h
oops::Increment::zero
void zero()
Linear algebra operators.
Definition: oops/interface/Increment.h:206
oops::Increment::setAtlas
void setAtlas(atlas::FieldSet *) const
ATLAS FieldSet.
Definition: oops/interface/Increment.h:408
oops::Increment::operator-=
Increment & operator-=(const Increment &)
Definition: oops/interface/Increment.h:268
oops::Increment::atlas
atlas::FieldSet & atlas()
Definition: oops/interface/Increment.h:109
oops::Increment::getLocal
LocalIncrement getLocal(const GeometryIterator_ &iter) const
Definition: oops/interface/Increment.h:342
oops::Increment::atlas
const atlas::FieldSet & atlas() const
Definition: oops/interface/Increment.h:112
oops::Increment::dirac
void dirac(const eckit::Configuration &)
Definition: oops/interface/Increment.h:236
LocalIncrement.h
oops::Increment::operator=
Increment & operator=(const Increment &)
Definition: oops/interface/Increment.h:246
oops::Increment::dot_product_with
double dot_product_with(const Increment &) const
Definition: oops/interface/Increment.h:300
oops::Increment::increment
const Increment_ & increment() const
Definition: oops/interface/Increment.h:66
oops::Increment::diff
void diff(const State_ &, const State_ &)
Interactions with State.
Definition: oops/interface/Increment.h:196
oops::Increment::accumul
void accumul(const double &, const State_ &)
Definition: oops/interface/Increment.h:332
oops::Increment::read
void read(const eckit::Configuration &)
I/O and diagnostics.
Definition: oops/interface/Increment.h:363
oops::Increment::print
void print(std::ostream &) const override
Definition: oops/interface/Increment.h:527
oops::Increment::axpy
void axpy(const double &, const Increment &, const bool check=true)
Definition: oops/interface/Increment.h:290
oops::Increment::validTime
const util::DateTime validTime() const
Time.
Definition: oops/interface/Increment.h:72
oops::State::state
State_ & state()
Interfacing.
Definition: oops/interface/State.h:56
oops::Increment::Increment
Increment(const Geometry_ &, const Variables &, const util::DateTime &)
Constructor, destructor.
Definition: oops/interface/Increment.h:149
oops::Increment::variables
const Variables & variables() const
Definition: oops/interface/Increment.h:100
oops::GeometryIterator::geometryiter
const GeometryIterator_ & geometryiter() const
Interfacing.
Definition: oops/interface/GeometryIterator.h:48
oops::mpi::send
void send(const eckit::mpi::Comm &comm, const SERIALIZABLE &sendobj, const int dest, const int tag)
Extend eckit Comm for Serializable oops objects.
Definition: oops/mpi/mpi.h:36
oops::Increment::operator+=
Increment & operator+=(const Increment &)
Definition: oops/interface/Increment.h:257
oops::Increment::deserialize
void deserialize(const std::vector< double > &, size_t &) override
Definition: oops/interface/Increment.h:467
oops::Increment::classname
static const std::string classname()
Definition: oops/interface/Increment.h:56
oops::Increment::Increment_
MODEL::Increment Increment_
Definition: oops/interface/Increment.h:50
oops::Increment::State_
State< MODEL > State_
Definition: oops/interface/Increment.h:53
oops::Increment::serialSize
size_t serialSize() const override
Serialize and deserialize.
Definition: oops/interface/Increment.h:448
oops::Increment::~Increment
virtual ~Increment()
Definition: oops/interface/Increment.h:186
oops::Increment::fromAtlas
void fromAtlas(atlas::FieldSet *)
Definition: oops/interface/Increment.h:428
oops::Increment::ones
void ones()
Definition: oops/interface/Increment.h:226
oops::Increment::increment
Increment_ & increment()
Interfacing.
Definition: oops/interface/Increment.h:65
oops::Increment::atlasFieldSet_
atlas::FieldSet atlasFieldSet_
Definition: oops/interface/Increment.h:130
oops::LocalIncrement
Definition: LocalIncrement.h:19
oops::Geometry
Geometry class used in oops; subclass of interface class above.
Definition: oops/interface/Geometry.h:189
oops::Increment::increment_
std::unique_ptr< Increment_ > increment_
Definition: oops/interface/Increment.h:127
oops::Increment::variables_
const Variables variables_
Definition: oops/interface/Increment.h:128
oops::Increment::GeometryIterator_
GeometryIterator< MODEL > GeometryIterator_
Definition: oops/interface/Increment.h:52
oops::Increment::toAtlas
void toAtlas()
ATLAS fieldset.
Definition: oops/interface/Increment.h:438
oops::Increment::updateTime
void updateTime(const util::Duration &dt)
Definition: oops/interface/Increment.h:73
oops::Increment::schur_product_with
void schur_product_with(const Increment &)
Definition: oops/interface/Increment.h:312
oops::State
Encapsulates the model state.
Definition: CostJbState.h:28
oops::Increment::write
void write(const eckit::Configuration &) const
Definition: oops/interface/Increment.h:373
oops::Increment::serialize
void serialize(std::vector< double > &) const override
Definition: oops/interface/Increment.h:457
GeometryIterator.h
State.h
GeneralizedDepartures.h
oops::Variables
Definition: oops/base/Variables.h:23
oops::Increment
Increment Class: Difference between two states.
Definition: CostJbState.h:27
oops::Increment::setLocal
void setLocal(const LocalIncrement &gp, const GeometryIterator_ &iter)
Definition: oops/interface/Increment.h:352
oops::Increment::random
void random()
Definition: oops/interface/Increment.h:322
oops::Increment::shift_backward
void shift_backward(const util::DateTime &)
Definition: oops/interface/Increment.h:502
oops::Increment::operator*=
Increment & operator*=(const double &)
Definition: oops/interface/Increment.h:279
oops::mpi::receive
void receive(const eckit::mpi::Comm &comm, SERIALIZABLE &recvobj, const int source, const int tag)
Definition: oops/mpi/mpi.h:46
Variables.h
oops::Increment::commTime_
const eckit::mpi::Comm & commTime_
Definition: oops/interface/Increment.h:129
Geometry.h
oops::Geometry::geometry
const Geometry_ & geometry() const
Interfacing with other oops classes.
Definition: oops/interface/Geometry.h:206