OOPS
test/interface/LinearObsOperator.h
Go to the documentation of this file.
1 /*
2  * (C) Copyright 2017-2018 UCAR
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  */
7 
8 #ifndef TEST_INTERFACE_LINEAROBSOPERATOR_H_
9 #define TEST_INTERFACE_LINEAROBSOPERATOR_H_
10 
11 #include <memory>
12 #include <string>
13 #include <vector>
14 
15 #define ECKIT_TESTING_SELF_REGISTER_CASES 0
16 
17 
18 #include "eckit/testing/Test.h"
19 #include "oops/base/Variables.h"
20 #include "oops/interface/LinearObsOperator.h"
21 #include "oops/interface/ObsAuxControl.h"
22 #include "oops/interface/ObsAuxCovariance.h"
23 #include "oops/interface/ObsAuxIncrement.h"
24 #include "oops/interface/ObsDiagnostics.h"
25 #include "oops/interface/ObsOperator.h"
26 #include "oops/runs/Test.h"
27 #include "oops/util/dot_product.h"
28 #include "oops/util/Expect.h"
29 #include "oops/util/Logger.h"
30 #include "test/interface/ObsTestsFixture.h"
31 #include "test/TestEnvironment.h"
32 
33 namespace test {
34 
35 const char *expectConstructorToThrow = "expect constructor to throw exception with message";
36 const char *expectSetTrajectoryToThrow = "expect setTrajectory to throw exception with message";
37 const char *expectSimulateObsToThrow = "expect simulateObs to throw exception with message";
38 const char *expectSimulateObsTLToThrow = "expect simulateObsTL to throw exception with message";
39 const char *expectSimulateObsADToThrow = "expect simulateObsAD to throw exception with message";
40 
41 // -----------------------------------------------------------------------------
42 /// \brief tests constructor and print method
43 template <typename OBS> void testConstructor() {
44  typedef ObsTestsFixture<OBS> Test_;
45  typedef oops::LinearObsOperator<OBS> LinearObsOperator_;
46  typedef typename LinearObsOperator_::Parameters_ LinearObsOperatorParameters_;
47 
48  for (std::size_t jj = 0; jj < Test_::obspace().size(); ++jj) {
49  const eckit::LocalConfiguration & conf = Test_::config(jj);
50  // Use ObsOperator section of yaml unless LinearObsOperator is specified
51  std::string confname = "obs operator";
52  if (conf.has("linear obs operator")) confname = "linear obs operator";
53  eckit::LocalConfiguration linobsopconf(conf, confname);
54  LinearObsOperatorParameters_ linobsopparams;
55  linobsopparams.validateAndDeserialize(linobsopconf);
56 
57  if (!Test_::config(jj).has(expectConstructorToThrow)) {
58  std::unique_ptr<LinearObsOperator_> linobsop(
59  new LinearObsOperator_(Test_::obspace()[jj], linobsopparams));
60  EXPECT(linobsop.get());
61  oops::Log::test() << "Testing LinearObsOperator: " << *linobsop << std::endl;
62  linobsop.reset();
63  EXPECT(!linobsop.get());
64  } else {
65  // The constructor is expected to throw an exception containing the specified string.
66  const std::string expectedMessage = Test_::config(jj).getString(expectConstructorToThrow);
67  EXPECT_THROWS_MSG(LinearObsOperator_(Test_::obspace()[jj], linobsopparams),
68  expectedMessage.c_str());
69  }
70  }
71 }
72 
73 // -----------------------------------------------------------------------------
74 
75 template <typename OBS> void testLinearity() {
76  typedef ObsTestsFixture<OBS> Test_;
77  typedef oops::GeoVaLs<OBS> GeoVaLs_;
78  typedef oops::ObsAuxControl<OBS> ObsAuxCtrl_;
79  typedef oops::ObsAuxIncrement<OBS> ObsAuxIncr_;
80  typedef oops::ObsAuxCovariance<OBS> ObsAuxCov_;
81  typedef oops::ObsOperator<OBS> ObsOperator_;
82  typedef typename ObsOperator_::Parameters_ ObsOperatorParameters_;
83  typedef oops::LinearObsOperator<OBS> LinearObsOperator_;
84  typedef typename LinearObsOperator_::Parameters_ LinearObsOperatorParameters_;
85  typedef oops::ObsVector<OBS> ObsVector_;
86 
87  const double zero = 0.0;
88  const double coef = 3.14;
89  const double tol = 1.0e-11;
90 
91  for (std::size_t jj = 0; jj < Test_::obspace().size(); ++jj) {
92  const eckit::LocalConfiguration & conf = Test_::config(jj);
93  if (conf.has(expectConstructorToThrow) ||
94  conf.has(expectSetTrajectoryToThrow) ||
95  conf.has(expectSimulateObsToThrow) ||
96  conf.has(expectSimulateObsTLToThrow))
97  continue;
98 
99  // initialize observation operator (set variables requested from the model,
100  // variables simulated by the observation operator, other init)
101  eckit::LocalConfiguration obsopconf(conf, "obs operator");
102  ObsOperatorParameters_ obsopparams;
103  obsopparams.validateAndDeserialize(obsopconf);
104  ObsOperator_ hop(Test_::obspace()[jj], obsopparams);
105  // initialize TL/AD observation operator (set model variables for Jacobian),
106  // other init)
107  // Use ObsOperator section of yaml unless LinearObsOperator is specified
108  std::string confname = "obs operator";
109  if (conf.has("linear obs operator")) confname = "linear obs operator";
110  eckit::LocalConfiguration linobsopconf(conf, confname);
111  LinearObsOperatorParameters_ linobsopparams;
112  linobsopparams.validateAndDeserialize(linobsopconf);
113  LinearObsOperator_ hoptl(Test_::obspace()[jj], linobsopparams);
114 
115  // initialize obs bias
116  eckit::LocalConfiguration biasconf = conf.getSubConfiguration("obs bias");
117  typename ObsAuxCtrl_::Parameters_ biasparams;
118  biasparams.validateAndDeserialize(biasconf);
119  const ObsAuxCtrl_ ybias(Test_::obspace()[jj], biasparams);
120  ObsAuxIncr_ ybinc(Test_::obspace()[jj], biasparams);
121 
122  // read geovals from the file
123  const eckit::LocalConfiguration gconf(conf, "geovals");
124  oops::Variables hopvars = hop.requiredVars();
125  hopvars += ybias.requiredVars();
126  const GeoVaLs_ gval(gconf, Test_::obspace()[jj], hopvars);
127 
128  // initialize Obs. Bias Covariance
129  const ObsAuxCov_ Bobsbias(Test_::obspace()[jj], biasparams);
130 
131  // set trajectory for TL/AD to be the geovals from the file
132  hoptl.setTrajectory(gval, ybias);
133 
134  // create obsvector
135  ObsVector_ dy1(Test_::obspace()[jj]);
136 
137  // create geovals
138  GeoVaLs_ dx(gconf, Test_::obspace()[jj], hoptl.requiredVars());
139 
140  // test rms(H * (dx, ybinc)) = 0, when dx = 0
141  dx.zero();
142  ybinc.zero();
143  hoptl.simulateObsTL(dx, dy1, ybinc);
144  EXPECT(dy1.rms() == zero);
145 
146  // test rms(H * (dx, ybinc)) > 0, when dx is random
147  dx.random();
148  Bobsbias.randomize(ybinc);
149  hoptl.simulateObsTL(dx, dy1, ybinc);
150  EXPECT(dy1.rms() > zero);
151 
152  // test k * H * (dx, ybinc) ~ H * (k*dx, k*ybinc)
153  dy1 *= coef;
154  dx *= coef;
155  ybinc *= coef;
156  ObsVector_ dy2(Test_::obspace()[jj]);
157  hoptl.simulateObsTL(dx, dy2, ybinc);
158 
159  dy2 -= dy1;
160  EXPECT(dy2.rms() / dy1.rms() < tol);
161  }
162 }
163 
164 // -----------------------------------------------------------------------------
165 
166 template <typename OBS> void testAdjoint() {
167  typedef ObsTestsFixture<OBS> Test_;
168  typedef oops::GeoVaLs<OBS> GeoVaLs_;
169  typedef oops::ObsOperator<OBS> ObsOperator_;
170  typedef typename ObsOperator_::Parameters_ ObsOperatorParameters_;
171  typedef oops::LinearObsOperator<OBS> LinearObsOperator_;
172  typedef typename LinearObsOperator_::Parameters_ LinearObsOperatorParameters_;
173  typedef oops::ObsAuxControl<OBS> ObsAuxCtrl_;
174  typedef oops::ObsAuxIncrement<OBS> ObsAuxIncr_;
175  typedef oops::ObsAuxCovariance<OBS> ObsAuxCov_;
176  typedef oops::ObsVector<OBS> ObsVector_;
177 
178  const double zero = 0.0;
179 
180  for (std::size_t jj = 0; jj < Test_::obspace().size(); ++jj) {
181  const eckit::LocalConfiguration & conf = Test_::config(jj);
182  if (conf.has(expectConstructorToThrow) ||
183  conf.has(expectSetTrajectoryToThrow) ||
184  conf.has(expectSimulateObsToThrow) ||
185  conf.has(expectSimulateObsTLToThrow) ||
186  conf.has(expectSimulateObsADToThrow))
187  continue;
188 
189  // initialize observation operator (set variables requested from the model,
190  // variables simulated by the observation operator, other init)
191  eckit::LocalConfiguration obsopconf(conf, "obs operator");
192  ObsOperatorParameters_ obsopparams;
193  obsopparams.validateAndDeserialize(obsopconf);
194  ObsOperator_ hop(Test_::obspace()[jj], obsopparams);
195  // initialize TL/AD observation operator (set model variables for Jacobian),
196  // other init)
197  // Use ObsOperator section of yaml unless LinearObsOperator is specified
198  std::string confname = "obs operator";
199  if (conf.has("linear obs operator")) confname = "linear obs operator";
200  eckit::LocalConfiguration linobsopconf(conf, confname);
201  LinearObsOperatorParameters_ linobsopparams;
202  linobsopparams.validateAndDeserialize(linobsopconf);
203  LinearObsOperator_ hoptl(Test_::obspace()[jj], linobsopparams);
204 
205  const double tol = conf.getDouble("linear obs operator test.tolerance AD");
206  // initialize bias correction
207  eckit::LocalConfiguration biasconf = conf.getSubConfiguration("obs bias");
208  typename ObsAuxCtrl_::Parameters_ biasparams;
209  biasparams.validateAndDeserialize(biasconf);
210  const ObsAuxCtrl_ ybias(Test_::obspace()[jj], biasparams);
211  ObsAuxIncr_ ybinc1(Test_::obspace()[jj], biasparams); // TL
212  ObsAuxIncr_ ybinc2(Test_::obspace()[jj], biasparams); // AD
213 
214  // initialize Obs. Bias Covariance
215  const ObsAuxCov_ Bobsbias(Test_::obspace()[jj], biasparams);
216 
217  // read geovals from the file
218  eckit::LocalConfiguration gconf(conf, "geovals");
219  oops::Variables hopvars = hop.requiredVars();
220  hopvars += ybias.requiredVars();
221  const GeoVaLs_ gval(gconf, Test_::obspace()[jj], hopvars);
222 
223  // set TL/AD trajectory to the geovals from the file
224  hoptl.setTrajectory(gval, ybias);
225 
226  ObsVector_ dy1(Test_::obspace()[jj]);
227  ObsVector_ dy2(Test_::obspace()[jj]);
228  GeoVaLs_ dx1(gconf, Test_::obspace()[jj], hoptl.requiredVars());
229  GeoVaLs_ dx2(gconf, Test_::obspace()[jj], hoptl.requiredVars());
230 
231  // calculate dy1 = H (dx1, ybinc1) (with random dx1, and random ybinc1)
232  dx1.random();
233  EXPECT(dot_product(dx1, dx1) > zero); // BOOST_REQUIRE
234  Bobsbias.randomize(ybinc1);
235  hoptl.simulateObsTL(dx1, dy1, ybinc1);
236  EXPECT(dot_product(dy1, dy1) > zero);
237 
238  // calculate (dx2, ybinc2) = HT dy2 (with random dy2)
239  dy2.random();
240  EXPECT(dot_product(dy2, dy2) > zero); // BOOST_REQUIRE
241  dx2.zero();
242  ybinc2.zero();
243  hoptl.simulateObsAD(dx2, dy2, ybinc2);
244  EXPECT(dot_product(dx2, dx2) > zero);
245 
246  const double zz1 = dot_product(dx1, dx2) + dot_product(ybinc1, ybinc2);
247  const double zz2 = dot_product(dy1, dy2);
248 
249  oops::Log::test() << "Adjoint test result: (<x,HTy>-<Hx,y>)/<Hx,y> = "
250  << (zz1-zz2)/zz2 << std::endl;
251 
252  EXPECT(zz1 != zero);
253  EXPECT(zz2 != zero);
254  EXPECT(oops::is_close(zz1, zz2, tol));
255  }
256 }
257 
258 // -----------------------------------------------------------------------------
259 
260 template <typename OBS> void testTangentLinear() {
261  // Test ||(hop(x+alpha*dx)-hop(x)) - hoptl(alpha*dx)|| < tol
262  typedef ObsTestsFixture<OBS> Test_;
263  typedef oops::GeoVaLs<OBS> GeoVaLs_;
264  typedef oops::ObsDiagnostics<OBS> ObsDiags_;
265  typedef oops::ObsAuxControl<OBS> ObsAuxCtrl_;
266  typedef oops::ObsAuxIncrement<OBS> ObsAuxIncr_;
267  typedef oops::ObsAuxCovariance<OBS> ObsAuxCov_;
268  typedef oops::ObsOperator<OBS> ObsOperator_;
269  typedef typename ObsOperator_::Parameters_ ObsOperatorParameters_;
270  typedef oops::LinearObsOperator<OBS> LinearObsOperator_;
271  typedef typename LinearObsOperator_::Parameters_ LinearObsOperatorParameters_;
272  typedef oops::ObsVector<OBS> ObsVector_;
273 
274  for (std::size_t jj = 0; jj < Test_::obspace().size(); ++jj) {
275  const eckit::LocalConfiguration & conf = Test_::config(jj);
276  if (conf.has(expectConstructorToThrow) ||
277  conf.has(expectSetTrajectoryToThrow) ||
278  conf.has(expectSimulateObsToThrow) ||
279  conf.has(expectSimulateObsTLToThrow))
280  continue;
281 
282  // initialize observation operator (set variables requested from the model,
283  // variables simulated by the observation operator, other init)
284  eckit::LocalConfiguration obsopconf(conf, "obs operator");
285  ObsOperatorParameters_ obsopparams;
286  obsopparams.validateAndDeserialize(obsopconf);
287  ObsOperator_ hop(Test_::obspace()[jj], obsopparams);
288  // initialize TL/AD observation operator (set model variables for Jacobian),
289  // other init)
290  // Use ObsOperator section of yaml unless LinearObsOperator is specified
291  std::string confname = "obs operator";
292  if (conf.has("linear obs operator")) confname = "linear obs operator";
293  eckit::LocalConfiguration linobsopconf(conf, confname);
294  LinearObsOperatorParameters_ linobsopparams;
295  linobsopparams.validateAndDeserialize(linobsopconf);
296  LinearObsOperator_ hoptl(Test_::obspace()[jj], linobsopparams);
297 
298  const double tol = conf.getDouble("linear obs operator test.tolerance TL");
299  const double alpha = conf.getDouble("linear obs operator test.coef TL", 0.1);
300  const int iter = conf.getInt("linear obs operator test.iterations TL", 1);
301 
302  // initialize obs bias from file
303  eckit::LocalConfiguration biasconf = conf.getSubConfiguration("obs bias");
304  typename ObsAuxCtrl_::Parameters_ biasparams;
305  biasparams.validateAndDeserialize(biasconf);
306  const ObsAuxCtrl_ ybias0(Test_::obspace()[jj], biasparams);
307  ObsAuxCtrl_ ybias(Test_::obspace()[jj], biasparams);
308 
309  // initialize Obs. Bias Covariance
310  const ObsAuxCov_ Bobsbias(Test_::obspace()[jj], biasparams);
311 
312  // read geovals from the file
313  const eckit::LocalConfiguration gconf(conf, "geovals");
314  oops::Variables hopvars = hop.requiredVars();
315  hopvars += ybias0.requiredVars();
316  const GeoVaLs_ x0(gconf, Test_::obspace()[jj], hopvars);
317  GeoVaLs_ x(gconf, Test_::obspace()[jj], hopvars);
318 
319  // set TL trajectory to the geovals and the bias coeff. from the files
320  hoptl.setTrajectory(x0, ybias0);
321 
322  // create obsvectors
323  ObsVector_ y1(Test_::obspace()[jj]);
324  ObsVector_ y2(Test_::obspace()[jj]);
325  ObsVector_ y3(Test_::obspace()[jj]);
326  ObsVector_ bias(Test_::obspace()[jj]);
327  bias.zero();
328 
329  // create obsdatavector to hold diags
330  oops::Variables diagvars;
331  diagvars += ybias0.requiredHdiagnostics();
332  ObsDiags_ ydiag(Test_::obspace()[jj], hop.locations(), diagvars);
333 
334  // y1 = hop(x0, ybias0)
335  hop.simulateObs(x0, y1, ybias0, bias, ydiag);
336 
337  // randomize dx and ybinc
338  GeoVaLs_ dx(gconf, Test_::obspace()[jj], hoptl.requiredVars());
339  dx.random();
340  ObsAuxIncr_ ybinc(Test_::obspace()[jj], biasparams);
341  Bobsbias.randomize(ybinc);
342 
343  // scale dx by x0
344  dx *= x0;
345 
346  for (int jter = 0; jter < iter; ++jter) {
347  // x = x0 + alpha*dx
348  dx *= alpha;
349  x = x0;
350  x += dx;
351  // ybias = ybias0 + alpha*ybinc
352  ybinc *= alpha;
353  ybias = ybias0;
354  ybias += ybinc;
355  bias.zero();
356 
357  // y2 = hop(x0+alpha*dx, ybias0+alpha*ybinc)
358  hop.simulateObs(x, y2, ybias, bias, ydiag);
359  y2 -= y1;
360  // y3 = hoptl(alpha*dx, alpha*ybinc)
361  hoptl.simulateObsTL(dx, y3, ybinc);
362  y2 -= y3;
363 
364  double test_norm = y2.rms();
365  oops::Log::test() << "Iter:" << jter << " ||(h(x+alpha*dx)-h(x)-h'*(alpha*dx))||="
366  << test_norm << std::endl;
367  }
368  EXPECT(y2.rms() < tol);
369  }
370 }
371 
372 // -----------------------------------------------------------------------------
373 
374 template <typename OBS> void testException() {
375  typedef ObsTestsFixture<OBS> Test_;
376  typedef oops::GeoVaLs<OBS> GeoVaLs_;
377  typedef oops::ObsOperator<OBS> ObsOperator_;
378  typedef typename ObsOperator_::Parameters_ ObsOperatorParameters_;
379  typedef oops::LinearObsOperator<OBS> LinearObsOperator_;
380  typedef typename LinearObsOperator_::Parameters_ LinearObsOperatorParameters_;
381  typedef oops::ObsAuxControl<OBS> ObsAuxCtrl_;
382  typedef oops::ObsAuxIncrement<OBS> ObsAuxIncr_;
383  typedef oops::ObsAuxCovariance<OBS> ObsAuxCov_;
384  typedef oops::ObsVector<OBS> ObsVector_;
385 
386  for (std::size_t jj = 0; jj < Test_::obspace().size(); ++jj) {
387  const eckit::LocalConfiguration & conf = Test_::config(jj);
388  if (conf.has(expectConstructorToThrow))
389  continue;
390 
391  // Set up objects prior to throwing exceptions.
392  eckit::LocalConfiguration obsopconf(conf, "obs operator");
393  ObsOperatorParameters_ obsopparams;
394  obsopparams.validateAndDeserialize(obsopconf);
395  ObsOperator_ hop(Test_::obspace()[jj], obsopparams);
396  std::string confname = "obs operator";
397  if (conf.has("linear obs operator")) confname = "linear obs operator";
398  eckit::LocalConfiguration linobsopconf(conf, confname);
399  LinearObsOperatorParameters_ linobsopparams;
400  linobsopparams.validateAndDeserialize(linobsopconf);
401  LinearObsOperator_ hoptl(Test_::obspace()[jj], linobsopparams);
402  eckit::LocalConfiguration biasconf = conf.getSubConfiguration("obs bias");
403  typename ObsAuxCtrl_::Parameters_ biasparams;
404  biasparams.validateAndDeserialize(biasconf);
405  const ObsAuxCtrl_ ybias(Test_::obspace()[jj], biasparams);
406  ObsAuxIncr_ ybinc(Test_::obspace()[jj], biasparams);
407  const ObsAuxCov_ Bobsbias(Test_::obspace()[jj], biasparams);
408  eckit::LocalConfiguration gconf(conf, "geovals");
409  oops::Variables hopvars = hop.requiredVars();
410  hopvars += ybias.requiredVars();
411  const GeoVaLs_ gval(gconf, Test_::obspace()[jj], hopvars);
412  oops::Variables diagvars;
413  diagvars += ybias.requiredHdiagnostics();
414 
415  if (Test_::config(jj).has(expectSetTrajectoryToThrow)) {
416  // The setTrajectory method is expected to throw an exception
417  // containing the specified string.
418  const std::string expectedMessage =
419  Test_::config(jj).getString(expectSetTrajectoryToThrow);
420  EXPECT_THROWS_MSG(hoptl.setTrajectory(gval, ybias),
421  expectedMessage.c_str());
422  // Do not continue further because setTrajectory must be run
423  // before simulateObsTL and simulateObsAD.
424  continue;
425  }
426 
427  if (Test_::config(jj).has(expectSimulateObsTLToThrow)) {
428  hoptl.setTrajectory(gval, ybias);
429  ObsVector_ dy1(Test_::obspace()[jj]);
430  GeoVaLs_ dx1(gconf, Test_::obspace()[jj], hoptl.requiredVars());
431  dx1.random();
432  Bobsbias.randomize(ybinc);
433  // The simulateObsTL method is expected to throw an exception
434  // containing the specified string.
435  const std::string expectedMessage =
436  Test_::config(jj).getString(expectSimulateObsTLToThrow);
437  EXPECT_THROWS_MSG(hoptl.simulateObsTL(dx1, dy1, ybinc),
438  expectedMessage.c_str());
439  }
440 
441  if (Test_::config(jj).has(expectSimulateObsADToThrow)) {
442  hoptl.setTrajectory(gval, ybias);
443  ObsVector_ dy2(Test_::obspace()[jj]);
444  GeoVaLs_ dx2(gconf, Test_::obspace()[jj], hoptl.requiredVars());
445  Bobsbias.randomize(ybinc);
446  dy2.random();
447  dx2.zero();
448  ybinc.zero();
449  // The simulateObsAD method is expected to throw an exception
450  // containing the specified string.
451  const std::string expectedMessage =
452  Test_::config(jj).getString(expectSimulateObsADToThrow);
453  EXPECT_THROWS_MSG(hoptl.simulateObsAD(dx2, dy2, ybinc),
454  expectedMessage.c_str());
455  }
456  }
457 }
458 
459 // -----------------------------------------------------------------------------
460 
461 template <typename OBS>
462 class LinearObsOperator : public oops::Test {
463  typedef ObsTestsFixture<OBS> Test_;
464 
465  public:
466  LinearObsOperator() {}
467  virtual ~LinearObsOperator() {}
468 
469  private:
470  std::string testid() const override {return "test::LinearObsOperator<" + OBS::name() + ">";}
471 
472  void register_tests() const override {
473  std::vector<eckit::testing::Test>& ts = eckit::testing::specification();
474 
475  ts.emplace_back(CASE("interface/LinearObsOperator/testConstructor")
476  { testConstructor<OBS>(); });
477  ts.emplace_back(CASE("interface/LinearObsOperator/testLinearity")
478  { testLinearity<OBS>(); });
479  ts.emplace_back(CASE("interface/LinearObsOperator/testTangentLinear")
480  { testTangentLinear<OBS>(); });
481  ts.emplace_back(CASE("interface/LinearObsOperator/testAdjoint")
482  { testAdjoint<OBS>(); });
483  ts.emplace_back(CASE("interface/LinearObsOperator/testException")
484  { testException<OBS>(); });
485  }
486 
487  void clear() const override {
488  Test_::reset();
489  }
490 };
491 
492 // -----------------------------------------------------------------------------
493 
494 } // namespace test
495 
496 #endif // TEST_INTERFACE_LINEAROBSOPERATOR_H_
oops::LinearObsOperator
MODEL-agnostic part of tangent-linear and adjoint of the nonlinear observation (forward) operator Obs...
Definition: oops/interface/LinearObsOperator.h:44
oops::ObsAuxControl
Auxiliary state related to observations, templated on <OBS>
Definition: oops/interface/ObsAuxControl.h:36
oops::ObsAuxCovariance
Auxiliary error covariance related to observations, templated on <OBS>
Definition: oops/interface/ObsAuxCovariance.h:41
oops::ObsAuxIncrement
Auxiliary increment related to observations, templated on <OBS>
Definition: oops/interface/ObsAuxIncrement.h:43
oops::ObsOperator
MODEL-agnostic part of nonlinear observation (forward) operator. The full nonlinear observation opera...
Definition: oops/interface/ObsOperator.h:47
oops::ObsVector
ObsVector class used in oops; subclass of interface class interface::ObsVector.
Definition: oops/base/ObsVector.h:34
test::LinearObsOperator::testid
std::string testid() const override
Definition: test/interface/LinearObsOperator.h:470
oops_variables_mod::has
logical function has(this, var)
Definition: variables_mod.F90:164
test::expectConstructorToThrow
const char * expectConstructorToThrow
Definition: test/interface/LinearObsOperator.h:35
test::expectSimulateObsTLToThrow
const char * expectSimulateObsTLToThrow
Definition: test/interface/LinearObsOperator.h:38
test::expectSetTrajectoryToThrow
const char * expectSetTrajectoryToThrow
Definition: test/interface/LinearObsOperator.h:36
test::expectSimulateObsToThrow
const char * expectSimulateObsToThrow
Definition: test/interface/LinearObsOperator.h:37
test::expectSimulateObsADToThrow
const char * expectSimulateObsADToThrow
Definition: test/interface/LinearObsOperator.h:39
test::CASE
CASE("test_linearmodelparameterswrapper_valid_name")
Definition: LinearModelFactory.cc:22
test::testConstructor
void testConstructor()
Tests creation and destruction of ObsErrorCovariances.
Definition: ObsErrorCovariance.h:32