OOPS
oops/interface/ModelAuxIncrement.h
Go to the documentation of this file.
1 /*
2  * (C) Copyright 2009-2016 ECMWF.
3  *
4  * This software is licensed under the terms of the Apache Licence Version 2.0
5  * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
6  * In applying this licence, ECMWF does not waive the privileges and immunities
7  * granted to it by virtue of its status as an intergovernmental organisation nor
8  * does it submit to any jurisdiction.
9  */
10 
11 #ifndef OOPS_INTERFACE_MODELAUXINCREMENT_H_
12 #define OOPS_INTERFACE_MODELAUXINCREMENT_H_
13 
14 #include <iostream>
15 #include <memory>
16 #include <string>
17 #include <vector>
18 
19 
20 #include "oops/interface/Geometry.h"
21 #include "oops/interface/ModelAuxControl.h"
22 #include "oops/util/Logger.h"
23 #include "oops/util/ObjectCounter.h"
24 #include "oops/util/Printable.h"
25 #include "oops/util/Serializable.h"
26 #include "oops/util/Timer.h"
27 
28 namespace eckit {
29  class Configuration;
30 }
31 
32 namespace oops {
33 
34 // -----------------------------------------------------------------------------
35 
36 template <typename MODEL>
37 class ModelAuxIncrement : public util::Printable,
38  public util::Serializable,
39  private util::ObjectCounter<ModelAuxIncrement<MODEL> > {
40  typedef typename MODEL::ModelAuxIncrement ModelAuxIncrement_;
41  typedef Geometry<MODEL> Geometry_;
42  typedef ModelAuxControl<MODEL> ModelAuxControl_;
43 
44  public:
45  static const std::string classname() {return "oops::ModelAuxIncrement";}
46 
47 /// Constructor, destructor
48  ModelAuxIncrement(const Geometry_ &, const eckit::Configuration &);
49  explicit ModelAuxIncrement(const ModelAuxIncrement &, const bool copy = true);
50  ModelAuxIncrement(const ModelAuxIncrement &, const eckit::Configuration &);
51  ~ModelAuxIncrement();
52 
53 /// Interfacing
54  const ModelAuxIncrement_ & modelauxincrement() const {return *aux_;}
55  ModelAuxIncrement_ & modelauxincrement() {return *aux_;}
56 
57 /// Linear algebra operators
58  void diff(const ModelAuxControl_ &, const ModelAuxControl_ &);
59  void zero();
60  ModelAuxIncrement & operator=(const ModelAuxIncrement &);
61  ModelAuxIncrement & operator+=(const ModelAuxIncrement &);
62  ModelAuxIncrement & operator-=(const ModelAuxIncrement &);
63  ModelAuxIncrement & operator*=(const double &);
64  void axpy(const double &, const ModelAuxIncrement &);
65  double dot_product_with(const ModelAuxIncrement &) const;
66 
67 /// I/O and diagnostics
68  void read(const eckit::Configuration &);
69  void write(const eckit::Configuration &) const;
70  double norm() const;
71 
72 /// Serialize and deserialize
73  size_t serialSize() const override;
74  void serialize(std::vector<double> &) const override;
75  void deserialize(const std::vector<double> &, size_t &) override;
76 
77  private:
78  void print(std::ostream &) const override;
79  std::unique_ptr<ModelAuxIncrement_> aux_;
80 };
81 
82 // -----------------------------------------------------------------------------
83 
84 template <typename MODEL>
85 ModelAuxControl<MODEL> & operator+=(ModelAuxControl<MODEL> & xx,
86  const ModelAuxIncrement<MODEL> & dx) {
87  Log::trace() << "operator+=(ModelAuxControl, ModelAuxIncrement) starting" << std::endl;
88  util::Timer timer("oops::ModelAuxIncrement", "operator+=ModelAuxControl");
89  xx.modelauxcontrol() += dx.modelauxincrement();
90  Log::trace() << "operator+=(ModelAuxControl, ModelAuxIncrement) done" << std::endl;
91  return xx;
92 }
93 
94 // =============================================================================
95 
96 template<typename MODEL>
97 ModelAuxIncrement<MODEL>::ModelAuxIncrement(const Geometry_ & resol,
98  const eckit::Configuration & conf) : aux_()
99 {
100  Log::trace() << "ModelAuxIncrement<MODEL>::ModelAuxIncrement starting" << std::endl;
101  util::Timer timer(classname(), "ModelAuxIncrement");
102  aux_.reset(new ModelAuxIncrement_(resol.geometry(), conf));
103  Log::trace() << "ModelAuxIncrement<MODEL>::ModelAuxIncrement done" << std::endl;
104 }
105 // -----------------------------------------------------------------------------
106 template<typename MODEL>
107 ModelAuxIncrement<MODEL>::ModelAuxIncrement(const ModelAuxIncrement & other,
108  const bool copy) : aux_()
109 {
110  Log::trace() << "ModelAuxIncrement<MODEL>::ModelAuxIncrement copy starting" << std::endl;
111  util::Timer timer(classname(), "ModelAuxIncrement");
112  aux_.reset(new ModelAuxIncrement_(*other.aux_, copy));
113  Log::trace() << "ModelAuxIncrement<MODEL>::ModelAuxIncrement copy done" << std::endl;
114 }
115 // -----------------------------------------------------------------------------
116 template<typename MODEL>
117 ModelAuxIncrement<MODEL>::ModelAuxIncrement(const ModelAuxIncrement & other,
118  const eckit::Configuration & conf) : aux_()
119 {
120  Log::trace() << "ModelAuxIncrement<MODEL>::ModelAuxIncrement interpolated starting" << std::endl;
121  util::Timer timer(classname(), "ModelAuxIncrement");
122  aux_.reset(new ModelAuxIncrement_(*other.aux_, conf));
123  Log::trace() << "ModelAuxIncrement<MODEL>::ModelAuxIncrement interpolated done" << std::endl;
124 }
125 // -----------------------------------------------------------------------------
126 template<typename MODEL>
127 ModelAuxIncrement<MODEL>::~ModelAuxIncrement() {
128  Log::trace() << "ModelAuxIncrement<MODEL>::~ModelAuxIncrement starting" << std::endl;
129  util::Timer timer(classname(), "~ModelAuxIncrement");
130  aux_.reset();
131  Log::trace() << "ModelAuxIncrement<MODEL>::~ModelAuxIncrement done" << std::endl;
132 }
133 // -----------------------------------------------------------------------------
134 template<typename MODEL>
135 void ModelAuxIncrement<MODEL>::diff(const ModelAuxControl_ & x1, const ModelAuxControl_ & x2) {
136  Log::trace() << "ModelAuxIncrement<MODEL>::diff starting" << std::endl;
137  util::Timer timer(classname(), "diff");
138  aux_->diff(x1.modelauxcontrol(), x2.modelauxcontrol());
139  Log::trace() << "ModelAuxIncrement<MODEL>::diff done" << std::endl;
140 }
141 // -----------------------------------------------------------------------------
142 template<typename MODEL>
143 void ModelAuxIncrement<MODEL>::zero() {
144  Log::trace() << "ModelAuxIncrement<MODEL>::zero starting" << std::endl;
145  util::Timer timer(classname(), "zero");
146  aux_->zero();
147  Log::trace() << "ModelAuxIncrement<MODEL>::zero done" << std::endl;
148 }
149 // -----------------------------------------------------------------------------
150 template<typename MODEL>
151 ModelAuxIncrement<MODEL> & ModelAuxIncrement<MODEL>::operator=(const ModelAuxIncrement & rhs) {
152  Log::trace() << "ModelAuxIncrement<MODEL>::operator= starting" << std::endl;
153  util::Timer timer(classname(), "operator=");
154  *aux_ = *rhs.aux_;
155  Log::trace() << "ModelAuxIncrement<MODEL>::operator= done" << std::endl;
156  return *this;
157 }
158 // -----------------------------------------------------------------------------
159 template<typename MODEL>
160 ModelAuxIncrement<MODEL> & ModelAuxIncrement<MODEL>::operator+=(const ModelAuxIncrement & rhs) {
161  Log::trace() << "ModelAuxIncrement<MODEL>::operator+= starting" << std::endl;
162  util::Timer timer(classname(), "operator+=");
163  *aux_ += *rhs.aux_;
164  Log::trace() << "ModelAuxIncrement<MODEL>::operator+= done" << std::endl;
165  return *this;
166 }
167 // -----------------------------------------------------------------------------
168 template<typename MODEL>
169 ModelAuxIncrement<MODEL> & ModelAuxIncrement<MODEL>::operator-=(const ModelAuxIncrement & rhs) {
170  Log::trace() << "ModelAuxIncrement<MODEL>::operator-= starting" << std::endl;
171  util::Timer timer(classname(), "operator-=");
172  *aux_ -= *rhs.aux_;
173  Log::trace() << "ModelAuxIncrement<MODEL>::operator-= done" << std::endl;
174  return *this;
175 }
176 // -----------------------------------------------------------------------------
177 template<typename MODEL>
178 ModelAuxIncrement<MODEL> & ModelAuxIncrement<MODEL>::operator*=(const double & zz) {
179  Log::trace() << "ModelAuxIncrement<MODEL>::operator*= starting" << std::endl;
180  util::Timer timer(classname(), "operator*=");
181  *aux_ *= zz;
182  Log::trace() << "ModelAuxIncrement<MODEL>::operator*= done" << std::endl;
183  return *this;
184 }
185 // -----------------------------------------------------------------------------
186 template<typename MODEL>
187 void ModelAuxIncrement<MODEL>::axpy(const double & zz, const ModelAuxIncrement & dx) {
188  Log::trace() << "ModelAuxIncrement<MODEL>::axpy starting" << std::endl;
189  util::Timer timer(classname(), "axpy");
190  aux_->axpy(zz, *dx.aux_);
191  Log::trace() << "ModelAuxIncrement<MODEL>::axpy done" << std::endl;
192 }
193 // -----------------------------------------------------------------------------
194 template<typename MODEL>
195 double ModelAuxIncrement<MODEL>::dot_product_with(const ModelAuxIncrement & dx) const {
196  Log::trace() << "ModelAuxIncrement<MODEL>::dot_product_with starting" << std::endl;
197  util::Timer timer(classname(), "dot_product_with");
198  double zz = aux_->dot_product_with(*dx.aux_);
199  Log::trace() << "ModelAuxIncrement<MODEL>::dot_product_with done" << std::endl;
200  return zz;
201 }
202 // -----------------------------------------------------------------------------
203 template<typename MODEL>
204 void ModelAuxIncrement<MODEL>::read(const eckit::Configuration & conf) {
205  Log::trace() << "ModelAuxIncrement<MODEL>::read starting" << std::endl;
206  util::Timer timer(classname(), "read");
207  aux_->read(conf);
208  Log::trace() << "ModelAuxIncrement<MODEL>::read done" << std::endl;
209 }
210 // -----------------------------------------------------------------------------
211 template<typename MODEL>
212 void ModelAuxIncrement<MODEL>::write(const eckit::Configuration & conf) const {
213  Log::trace() << "ModelAuxIncrement<MODEL>::write starting" << std::endl;
214  util::Timer timer(classname(), "write");
215  aux_->write(conf);
216  Log::trace() << "ModelAuxIncrement<MODEL>::write done" << std::endl;
217 }
218 // -----------------------------------------------------------------------------
219 template<typename MODEL>
220 double ModelAuxIncrement<MODEL>::norm() const {
221  Log::trace() << "ModelAuxIncrement<MODEL>::norm starting" << std::endl;
222  util::Timer timer(classname(), "norm");
223  double zz = aux_->norm();
224  Log::trace() << "ModelAuxIncrement<MODEL>::norm done" << std::endl;
225  return zz;
226 }
227 // -----------------------------------------------------------------------------
228 template<typename MODEL>
229 size_t ModelAuxIncrement<MODEL>::serialSize() const {
230  Log::trace() << "ModelAuxIncrement<MODEL>::serialSize" << std::endl;
231  util::Timer timer(classname(), "serialSize");
232  return aux_->serialSize();
233 }
234 // -----------------------------------------------------------------------------
235 template<typename MODEL>
236 void ModelAuxIncrement<MODEL>::serialize(std::vector<double> & vect) const {
237  Log::trace() << "ModelAuxIncrement<MODEL>::serialize starting" << std::endl;
238  util::Timer timer(classname(), "serialize");
239  aux_->serialize(vect);
240  Log::trace() << "ModelAuxIncrement<MODEL>::serialize done" << std::endl;
241 }
242 // -----------------------------------------------------------------------------
243 template<typename MODEL>
244 void ModelAuxIncrement<MODEL>::deserialize(const std::vector<double> & vect, size_t & current) {
245  Log::trace() << "ModelAuxIncrement<MODEL>::deserialize starting" << std::endl;
246  util::Timer timer(classname(), "deserialize");
247  aux_->deserialize(vect, current);
248  Log::trace() << "ModelAuxIncrement<MODEL>::deserialize done" << std::endl;
249 }
250 // -----------------------------------------------------------------------------
251 template<typename MODEL>
252 void ModelAuxIncrement<MODEL>::print(std::ostream & os) const {
253  Log::trace() << "ModelAuxIncrement<MODEL>::print starting" << std::endl;
254  util::Timer timer(classname(), "print");
255  os << *aux_;
256  Log::trace() << "ModelAuxIncrement<MODEL>::print done" << std::endl;
257 }
258 // -----------------------------------------------------------------------------
259 
260 } // namespace oops
261 
262 #endif // OOPS_INTERFACE_MODELAUXINCREMENT_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::ModelAuxIncrement::norm
double norm() const
Definition: oops/interface/ModelAuxIncrement.h:220
oops::ModelAuxIncrement::read
void read(const eckit::Configuration &)
I/O and diagnostics.
Definition: oops/interface/ModelAuxIncrement.h:204
oops::ModelAuxIncrement::ModelAuxControl_
ModelAuxControl< MODEL > ModelAuxControl_
Definition: oops/interface/ModelAuxIncrement.h:42
oops::ModelAuxIncrement::aux_
std::unique_ptr< ModelAuxIncrement_ > aux_
Definition: oops/interface/ModelAuxIncrement.h:79
oops::ModelAuxIncrement::~ModelAuxIncrement
~ModelAuxIncrement()
Definition: oops/interface/ModelAuxIncrement.h:127
oops::ModelAuxControl
Definition: oops/interface/ModelAuxControl.h:35
oops::ModelAuxIncrement::write
void write(const eckit::Configuration &) const
Definition: oops/interface/ModelAuxIncrement.h:212
oops::ModelAuxIncrement::print
void print(std::ostream &) const override
Definition: oops/interface/ModelAuxIncrement.h:252
oops::ModelAuxIncrement::operator=
ModelAuxIncrement & operator=(const ModelAuxIncrement &)
Definition: oops/interface/ModelAuxIncrement.h:151
oops::ModelAuxIncrement::diff
void diff(const ModelAuxControl_ &, const ModelAuxControl_ &)
Linear algebra operators.
Definition: oops/interface/ModelAuxIncrement.h:135
oops::ModelAuxIncrement::dot_product_with
double dot_product_with(const ModelAuxIncrement &) const
Definition: oops/interface/ModelAuxIncrement.h:195
oops::ModelAuxIncrement::operator*=
ModelAuxIncrement & operator*=(const double &)
Definition: oops/interface/ModelAuxIncrement.h:178
eckit
Definition: FieldL95.h:22
oops::ModelAuxIncrement::ModelAuxIncrement
ModelAuxIncrement(const Geometry_ &, const eckit::Configuration &)
Constructor, destructor.
Definition: oops/interface/ModelAuxIncrement.h:97
oops::ModelAuxIncrement::modelauxincrement
const ModelAuxIncrement_ & modelauxincrement() const
Interfacing.
Definition: oops/interface/ModelAuxIncrement.h:54
oops::ModelAuxIncrement::axpy
void axpy(const double &, const ModelAuxIncrement &)
Definition: oops/interface/ModelAuxIncrement.h:187
oops::ModelAuxIncrement::zero
void zero()
Definition: oops/interface/ModelAuxIncrement.h:143
oops::ModelAuxIncrement::classname
static const std::string classname()
Definition: oops/interface/ModelAuxIncrement.h:45
oops::Geometry
Geometry class used in oops; subclass of interface class above.
Definition: oops/interface/Geometry.h:189
oops::ModelAuxIncrement::operator-=
ModelAuxIncrement & operator-=(const ModelAuxIncrement &)
Definition: oops/interface/ModelAuxIncrement.h:169
oops::ModelAuxIncrement::serialize
void serialize(std::vector< double > &) const override
Definition: oops/interface/ModelAuxIncrement.h:236
oops::ModelAuxIncrement::operator+=
ModelAuxIncrement & operator+=(const ModelAuxIncrement &)
Definition: oops/interface/ModelAuxIncrement.h:160
oops::ModelAuxIncrement
Definition: oops/interface/ModelAuxIncrement.h:39
oops::ModelAuxIncrement::ModelAuxIncrement_
MODEL::ModelAuxIncrement ModelAuxIncrement_
Definition: oops/interface/ModelAuxIncrement.h:40
oops::ModelAuxControl::modelauxcontrol
const ModelAuxControl_ & modelauxcontrol() const
Interfacing.
Definition: oops/interface/ModelAuxControl.h:48
oops::ModelAuxIncrement::serialSize
size_t serialSize() const override
Serialize and deserialize.
Definition: oops/interface/ModelAuxIncrement.h:229
ModelAuxControl.h
oops::ModelAuxIncrement::modelauxincrement
ModelAuxIncrement_ & modelauxincrement()
Definition: oops/interface/ModelAuxIncrement.h:55
oops::ModelAuxIncrement::deserialize
void deserialize(const std::vector< double > &, size_t &) override
Definition: oops/interface/ModelAuxIncrement.h:244
Geometry.h
oops::ModelAuxIncrement::Geometry_
Geometry< MODEL > Geometry_
Definition: oops/interface/ModelAuxIncrement.h:41
oops::Geometry::geometry
const Geometry_ & geometry() const
Interfacing with other oops classes.
Definition: oops/interface/Geometry.h:206