OOPS
oops/interface/ObsAuxIncrement.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_OBSAUXINCREMENT_H_
12 #define OOPS_INTERFACE_OBSAUXINCREMENT_H_
13 
14 #include <iostream>
15 #include <memory>
16 #include <string>
17 #include <vector>
18 
19 #include "oops/interface/ObsAuxControl.h"
20 #include "oops/interface/ObsSpace.h"
21 #include "oops/util/Logger.h"
22 #include "oops/util/ObjectCounter.h"
23 #include "oops/util/Printable.h"
24 #include "oops/util/Serializable.h"
25 #include "oops/util/Timer.h"
26 
27 namespace eckit {
28  class Configuration;
29 }
30 
31 namespace oops {
32 
33 // -----------------------------------------------------------------------------
34 
35 template <typename OBS>
36 class ObsAuxIncrement : public util::Printable,
37  public util::Serializable,
38  private util::ObjectCounter<ObsAuxIncrement<OBS> > {
39  typedef typename OBS::ObsAuxIncrement ObsAuxIncrement_;
40  typedef ObsAuxControl<OBS> ObsAuxControl_;
41 
42  public:
43  static const std::string classname() {return "oops::ObsAuxIncrement";}
44 
45 /// Constructor, destructor
46  ObsAuxIncrement(const ObsSpace<OBS> &, const eckit::Configuration &);
47  ObsAuxIncrement(const ObsAuxIncrement &, const bool copy = true);
48  ObsAuxIncrement(const ObsAuxIncrement &, const eckit::Configuration &);
49  ~ObsAuxIncrement();
50 
51 /// Interfacing
52  const ObsAuxIncrement_ & obsauxincrement() const {return *aux_;}
53  ObsAuxIncrement_ & obsauxincrement() {return *aux_;}
54 
55 /// Linear algebra operators
56  void diff(const ObsAuxControl_ &, const ObsAuxControl_ &);
57  void zero();
58  ObsAuxIncrement & operator=(const ObsAuxIncrement &);
59  ObsAuxIncrement & operator+=(const ObsAuxIncrement &);
60  ObsAuxIncrement & operator-=(const ObsAuxIncrement &);
61  ObsAuxIncrement & operator*=(const double &);
62  void axpy(const double &, const ObsAuxIncrement &);
63  double dot_product_with(const ObsAuxIncrement &) const;
64 
65 /// I/O and diagnostics
66  void read(const eckit::Configuration &);
67  void write(const eckit::Configuration &) const;
68  double norm() const;
69 
70 /// Serialize and deserialize
71  size_t serialSize() const override;
72  void serialize(std::vector<double> &) const override;
73  void deserialize(const std::vector<double> &, size_t &) override;
74 
75  private:
76  void print(std::ostream &) const override;
77  std::unique_ptr<ObsAuxIncrement_> aux_;
78 };
79 
80 // -----------------------------------------------------------------------------
81 
82 template <typename OBS>
83 ObsAuxControl<OBS> & operator+=(ObsAuxControl<OBS> & xx, const ObsAuxIncrement<OBS> & dx) {
84  Log::trace() << "operator+=(ObsAuxControl, ObsAuxIncrement) starting" << std::endl;
85  util::Timer timer("oops::ObsAuxIncrement", "operator+=ObsAuxControl");
86  xx.obsauxcontrol() += dx.obsauxincrement();
87  Log::trace() << "operator+=(ObsAuxControl, ObsAuxIncrement) done" << std::endl;
88  return xx;
89 }
90 
91 // =============================================================================
92 
93 template<typename OBS>
94 ObsAuxIncrement<OBS>::ObsAuxIncrement(const ObsSpace<OBS> & os,
95  const eckit::Configuration & conf) : aux_()
96 {
97  Log::trace() << "ObsAuxIncrement<OBS>::ObsAuxIncrement starting" << std::endl;
98  util::Timer timer(classname(), "ObsAuxIncrement");
99  aux_.reset(new ObsAuxIncrement_(os.obsspace(), conf));
100  Log::trace() << "ObsAuxIncrement<OBS>::ObsAuxIncrement done" << std::endl;
101 }
102 // -----------------------------------------------------------------------------
103 template<typename OBS>
104 ObsAuxIncrement<OBS>::ObsAuxIncrement(const ObsAuxIncrement & other,
105  const bool copy) : aux_()
106 {
107  Log::trace() << "ObsAuxIncrement<OBS>::ObsAuxIncrement copy starting" << std::endl;
108  util::Timer timer(classname(), "ObsAuxIncrement");
109  aux_.reset(new ObsAuxIncrement_(*other.aux_, copy));
110  Log::trace() << "ObsAuxIncrement<OBS>::ObsAuxIncrement copy done" << std::endl;
111 }
112 // -----------------------------------------------------------------------------
113 template<typename OBS>
114 ObsAuxIncrement<OBS>::ObsAuxIncrement(const ObsAuxIncrement & other,
115  const eckit::Configuration & conf) : aux_()
116 {
117  Log::trace() << "ObsAuxIncrement<OBS>::ObsAuxIncrement interpolated starting" << std::endl;
118  util::Timer timer(classname(), "ObsAuxIncrement");
119  aux_.reset(new ObsAuxIncrement_(*other.aux_, conf));
120  Log::trace() << "ObsAuxIncrement<OBS>::ObsAuxIncrement interpolated done" << std::endl;
121 }
122 // -----------------------------------------------------------------------------
123 template<typename OBS>
124 ObsAuxIncrement<OBS>::~ObsAuxIncrement() {
125  Log::trace() << "ObsAuxIncrement<OBS>::~ObsAuxIncrement starting" << std::endl;
126  util::Timer timer(classname(), "~ObsAuxIncrement");
127  aux_.reset();
128  Log::trace() << "ObsAuxIncrement<OBS>::~ObsAuxIncrement done" << std::endl;
129 }
130 // -----------------------------------------------------------------------------
131 template<typename OBS>
132 void ObsAuxIncrement<OBS>::diff(const ObsAuxControl_ & x1, const ObsAuxControl_ & x2) {
133  Log::trace() << "ObsAuxIncrement<OBS>::diff starting" << std::endl;
134  util::Timer timer(classname(), "diff");
135  aux_->diff(x1.obsauxcontrol(), x2.obsauxcontrol());
136  Log::trace() << "ObsAuxIncrement<OBS>::diff done" << std::endl;
137 }
138 // -----------------------------------------------------------------------------
139 template<typename OBS>
140 void ObsAuxIncrement<OBS>::zero() {
141  Log::trace() << "ObsAuxIncrement<OBS>::zero starting" << std::endl;
142  util::Timer timer(classname(), "zero");
143  aux_->zero();
144  Log::trace() << "ObsAuxIncrement<OBS>::zero done" << std::endl;
145 }
146 // -----------------------------------------------------------------------------
147 template<typename OBS>
148 ObsAuxIncrement<OBS> & ObsAuxIncrement<OBS>::operator=(const ObsAuxIncrement & rhs) {
149  Log::trace() << "ObsAuxIncrement<OBS>::operator= starting" << std::endl;
150  util::Timer timer(classname(), "operator=");
151  *aux_ = *rhs.aux_;
152  Log::trace() << "ObsAuxIncrement<OBS>::operator= done" << std::endl;
153  return *this;
154 }
155 // -----------------------------------------------------------------------------
156 template<typename OBS>
157 ObsAuxIncrement<OBS> & ObsAuxIncrement<OBS>::operator+=(const ObsAuxIncrement & rhs) {
158  Log::trace() << "ObsAuxIncrement<OBS>::operator+= starting" << std::endl;
159  util::Timer timer(classname(), "operator+=");
160  *aux_ += *rhs.aux_;
161  Log::trace() << "ObsAuxIncrement<OBS>::operator+= done" << std::endl;
162  return *this;
163 }
164 // -----------------------------------------------------------------------------
165 template<typename OBS>
166 ObsAuxIncrement<OBS> & ObsAuxIncrement<OBS>::operator-=(const ObsAuxIncrement & rhs) {
167  Log::trace() << "ObsAuxIncrement<OBS>::operator-= starting" << std::endl;
168  util::Timer timer(classname(), "operator-=");
169  *aux_ -= *rhs.aux_;
170  Log::trace() << "ObsAuxIncrement<OBS>::operator-= done" << std::endl;
171  return *this;
172 }
173 // -----------------------------------------------------------------------------
174 template<typename OBS>
175 ObsAuxIncrement<OBS> & ObsAuxIncrement<OBS>::operator*=(const double & zz) {
176  Log::trace() << "ObsAuxIncrement<OBS>::operator*= starting" << std::endl;
177  util::Timer timer(classname(), "operator*=");
178  *aux_ *= zz;
179  Log::trace() << "ObsAuxIncrement<OBS>::operator*= done" << std::endl;
180  return *this;
181 }
182 // -----------------------------------------------------------------------------
183 template<typename OBS>
184 void ObsAuxIncrement<OBS>::axpy(const double & zz, const ObsAuxIncrement & dx) {
185  Log::trace() << "ObsAuxIncrement<OBS>::axpy starting" << std::endl;
186  util::Timer timer(classname(), "axpy");
187  aux_->axpy(zz, *dx.aux_);
188  Log::trace() << "ObsAuxIncrement<OBS>::axpy done" << std::endl;
189 }
190 // -----------------------------------------------------------------------------
191 template<typename OBS>
192 double ObsAuxIncrement<OBS>::dot_product_with(const ObsAuxIncrement & dx) const {
193  Log::trace() << "ObsAuxIncrement<OBS>::dot_product_with starting" << std::endl;
194  util::Timer timer(classname(), "dot_product_with");
195  double zz = aux_->dot_product_with(*dx.aux_);
196  Log::trace() << "ObsAuxIncrement<OBS>::dot_product_with done" << std::endl;
197  return zz;
198 }
199 // -----------------------------------------------------------------------------
200 template<typename OBS>
201 void ObsAuxIncrement<OBS>::read(const eckit::Configuration & conf) {
202  Log::trace() << "ObsAuxIncrement<OBS>::read starting" << std::endl;
203  util::Timer timer(classname(), "read");
204  aux_->read(conf);
205  Log::trace() << "ObsAuxIncrement<OBS>::read done" << std::endl;
206 }
207 // -----------------------------------------------------------------------------
208 template<typename OBS>
209 void ObsAuxIncrement<OBS>::write(const eckit::Configuration & conf) const {
210  Log::trace() << "ObsAuxIncrement<OBS>::write starting" << std::endl;
211  util::Timer timer(classname(), "write");
212  aux_->write(conf);
213  Log::trace() << "ObsAuxIncrement<OBS>::write done" << std::endl;
214 }
215 // -----------------------------------------------------------------------------
216 template<typename OBS>
217 double ObsAuxIncrement<OBS>::norm() const {
218  Log::trace() << "ObsAuxIncrement<OBS>::norm starting" << std::endl;
219  util::Timer timer(classname(), "norm");
220  double zz = aux_->norm();
221  Log::trace() << "ObsAuxIncrement<OBS>::norm done" << std::endl;
222  return zz;
223 }
224 // -----------------------------------------------------------------------------
225 template<typename OBS>
226 size_t ObsAuxIncrement<OBS>::serialSize() const {
227  Log::trace() << "ObsAuxIncrement<OBS>::serialSize" << std::endl;
228  util::Timer timer(classname(), "serialSize");
229  return aux_->serialSize();
230 }
231 // -----------------------------------------------------------------------------
232 template<typename OBS>
233 void ObsAuxIncrement<OBS>::serialize(std::vector<double> & vect) const {
234  Log::trace() << "ObsAuxIncrement<OBS>::serialize starting" << std::endl;
235  util::Timer timer(classname(), "serialize");
236  aux_->serialize(vect);
237  Log::trace() << "ObsAuxIncrement<OBS>::serialize done" << std::endl;
238 }
239 // -----------------------------------------------------------------------------
240 template<typename OBS>
241 void ObsAuxIncrement<OBS>::deserialize(const std::vector<double> & vect, size_t & current) {
242  Log::trace() << "ObsAuxIncrement<OBS>::deserialize starting" << std::endl;
243  util::Timer timer(classname(), "deserialize");
244  aux_->deserialize(vect, current);
245  Log::trace() << "ObsAuxIncrement<OBS>::deserialize done" << std::endl;
246 }
247 // -----------------------------------------------------------------------------
248 template<typename OBS>
249 void ObsAuxIncrement<OBS>::print(std::ostream & os) const {
250  Log::trace() << "ObsAuxIncrement<OBS>::print starting" << std::endl;
251  util::Timer timer(classname(), "print");
252  os << *aux_;
253  Log::trace() << "ObsAuxIncrement<OBS>::print done" << std::endl;
254 }
255 // -----------------------------------------------------------------------------
256 
257 } // namespace oops
258 
259 #endif // OOPS_INTERFACE_OBSAUXINCREMENT_H_
oops::ObsAuxIncrement::operator*=
ObsAuxIncrement & operator*=(const double &)
Definition: oops/interface/ObsAuxIncrement.h:175
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::ObsAuxIncrement::norm
double norm() const
Definition: oops/interface/ObsAuxIncrement.h:217
oops::ObsAuxIncrement::diff
void diff(const ObsAuxControl_ &, const ObsAuxControl_ &)
Linear algebra operators.
Definition: oops/interface/ObsAuxIncrement.h:132
ObsAuxControl.h
oops::ObsAuxIncrement::zero
void zero()
Definition: oops/interface/ObsAuxIncrement.h:140
oops::ObsAuxIncrement::aux_
std::unique_ptr< ObsAuxIncrement_ > aux_
Definition: oops/interface/ObsAuxIncrement.h:77
oops::ObsSpace
Definition: oops/interface/ObsSpace.h:42
oops::ObsAuxIncrement
Definition: oops/interface/ObsAuxIncrement.h:38
oops::ObsSpace::obsspace
ObsSpace_ & obsspace() const
Interfacing.
Definition: oops/interface/ObsSpace.h:61
oops::ObsAuxIncrement::dot_product_with
double dot_product_with(const ObsAuxIncrement &) const
Definition: oops/interface/ObsAuxIncrement.h:192
oops::ObsAuxIncrement::~ObsAuxIncrement
~ObsAuxIncrement()
Definition: oops/interface/ObsAuxIncrement.h:124
oops::ObsAuxControl
Definition: oops/interface/ObsAuxControl.h:35
oops::ObsAuxIncrement::ObsAuxIncrement
ObsAuxIncrement(const ObsSpace< OBS > &, const eckit::Configuration &)
Constructor, destructor.
Definition: oops/interface/ObsAuxIncrement.h:94
oops::ObsAuxIncrement::serialize
void serialize(std::vector< double > &) const override
Definition: oops/interface/ObsAuxIncrement.h:233
oops::ObsAuxIncrement::axpy
void axpy(const double &, const ObsAuxIncrement &)
Definition: oops/interface/ObsAuxIncrement.h:184
oops::ObsAuxIncrement::operator+=
ObsAuxIncrement & operator+=(const ObsAuxIncrement &)
Definition: oops/interface/ObsAuxIncrement.h:157
oops::ObsAuxIncrement::write
void write(const eckit::Configuration &) const
Definition: oops/interface/ObsAuxIncrement.h:209
oops::ObsAuxIncrement::obsauxincrement
const ObsAuxIncrement_ & obsauxincrement() const
Interfacing.
Definition: oops/interface/ObsAuxIncrement.h:52
eckit
Definition: FieldL95.h:22
oops::ObsAuxIncrement::operator-=
ObsAuxIncrement & operator-=(const ObsAuxIncrement &)
Definition: oops/interface/ObsAuxIncrement.h:166
oops::ObsAuxIncrement::classname
static const std::string classname()
Definition: oops/interface/ObsAuxIncrement.h:43
oops::ObsAuxIncrement::operator=
ObsAuxIncrement & operator=(const ObsAuxIncrement &)
Definition: oops/interface/ObsAuxIncrement.h:148
oops::ObsAuxIncrement::obsauxincrement
ObsAuxIncrement_ & obsauxincrement()
Definition: oops/interface/ObsAuxIncrement.h:53
ObsSpace.h
oops::ObsAuxIncrement::serialSize
size_t serialSize() const override
Serialize and deserialize.
Definition: oops/interface/ObsAuxIncrement.h:226
oops::ObsAuxIncrement::ObsAuxIncrement_
OBS::ObsAuxIncrement ObsAuxIncrement_
Definition: oops/interface/ObsAuxIncrement.h:39
oops::ObsAuxIncrement::print
void print(std::ostream &) const override
Definition: oops/interface/ObsAuxIncrement.h:249
oops::ObsAuxIncrement::read
void read(const eckit::Configuration &)
I/O and diagnostics.
Definition: oops/interface/ObsAuxIncrement.h:201
oops::ObsAuxIncrement::ObsAuxControl_
ObsAuxControl< OBS > ObsAuxControl_
Definition: oops/interface/ObsAuxIncrement.h:40
oops::ObsAuxControl::obsauxcontrol
const ObsAuxControl_ & obsauxcontrol() const
Interfacing.
Definition: oops/interface/ObsAuxControl.h:46
oops::ObsAuxIncrement::deserialize
void deserialize(const std::vector< double > &, size_t &) override
Definition: oops/interface/ObsAuxIncrement.h:241