The Joint Effort for Data assimilation Integration Observation

The Joint Effort for Data assimilation Integration Observation Space Structures Joint Center for Satellite Data Assimilation (JCSDA)

Interfaces Classes All model or observation specific classes are wrapped into an interface class Using the C++ templates this is not strictly necessary but provides a convenient place to group all interfaces and make them visible Each interface class contains a (smart) pointer to the actual implementation defined by the “model trait” and passes the calls down The interface layer is also used to instrument the code Timing statistics Trace execution Interface classes are all in oops/src/oops/interface

Interfaces Classes template <typename MODEL> class State { typedef typename MODEL: : State_; public: /// Most methods have been removed for readability /// Interfacing State_ & state() {return *state_; } const State_ & state() const {return *state_; } /// Get state values at observation locations void get. Values(const Locations_ &, const Variables &, Geo. Va. Ls_ &) const; private: boost: : scoped_ptr<State_> state_; ; { Class of specific implementation (from trait) Access specific object (only for use in interface classes) Name of method is name of class in lowercase Smart pointer to actual object

Interfaces Classes Example of a method in an interface class template<typename MODEL> void State<MODEL>: : get. Values(const Locations_ & locs, const Variables & vars, Geo. Va. Ls_ & gvals) const} Log: : trace() << "State<MODEL>: : get. Values starting" << std: : endl; util: : Timer timer(classname(), "get. Values"); state_->get. Values(locs. locations(), vars, gvals. geovals()); Log: : trace() << "State<MODEL>: : get. Values done" << std: : endl; } Trace method on entry and exit Timer will be destructed when going out of scope Constructor and destructor do the work Method of specific implementation is called, with actual arguments

UFO: the interface advantage Obs. Locations Variables Obs. Operators State Observations Field Values at Locations • JEDI/UFO introduces standard interfaces between the model and observation worlds • Observation operators are independent of the model and can easily be shared, exchanged, compared

Observation Interface Classes Observation-related classes implemented in OOPS-JEDI Observations Departures Next slides Observation-related classes required by OOPS-JEDI Geo. Va. Ls Locations Variables UFO interfaces (next presentation) Observation. Space Obs. Vector Obs. Operator Linear. Obs. Operator Obs. Error. Covariance Next slides Obs. Aux. Control Obs. Aux. Increment Obs. Aux. Covariance For bias correction (not implemented yet in UFO)

Observations Class Observations are organized by type, although types can be any convenient grouping template <typename MODEL> class Observations : public util: : Printable { public: explicit Observations(const Obs. Space_ &); explicit Observations(const Observations &); ~Observations(); Observations & operator=(const Observations &); /// Access std: : size_t size() const {return obs_. size(); } Obs. Vector_ & operator[](const std: : size_t ii) {return obs_. at(ii); } const Obs. Vector_ & operator[](const std: : size_t ii) const {return obs_. at(ii); } /// Interactions with Departures std: : vector<boost: : shared_ptr<Obs. Vector_> > operator-(const Observations & other) const; Observations & operator+=(const Departures_ &); /// Save observations values void save(const std: : string &) const; void read(const eckit: : Configuration &); private: void print(std: : ostream &) const; boost: : ptr_vector<Obs. Vector_> obs_; ; {

Departures Class class Departures : public util: : Printable, public Generalized. Departures { public: // Constructors and destructor explicit Departures(const Obs. Space_ &); explicit Departures(std: : vector<boost: : shared_ptr<Obs. Vector_> >); explicit Departures(const Departures &); ~Departures(); /// Access std: : size_t size() const {return dep_. size(); } Obs. Vector_ & operator[](const std: : size_t ii) {return *dep_. at(ii); } const Obs. Vector_ & operator[](const std: : size_t ii) const {return *dep_. at(ii); } // Linear algebra operators Departures & operator=(const Departures &); Departures & operator+=(const Departures &); Departures & operator-=(const Departures &); Departures & operator*=(const double &); Departures & operator*=(const Departures &); Departures & operator/=(const Departures &); void zero(); void invert(); void axpy(const double &, const Departures &); double dot_product_with(const Departures &) const; /// Save departures values void save(const std: : string &) const; private: void print(std: : ostream &) const; std: : vector<boost: : shared_ptr<Obs. Vector_> > dep_; ; {

Observation. Space Class template <typename MODEL> class Observation. Space : public util: : Printable, private boost: : noncopyable, private util: : Object. Counter<Observation. Space<MODEL> > { public: static const std: : string classname() {return "oops: : Observation. Space"; } Observation. Space(const eckit: : Configuration &, const util: : Date. Time; (& ~Observation. Space(); /// Interfacing Obs. Space_ & observationspace() const {return *obsdb_; } /// Assimilation window const util: : Date. Time & window. Start() const {return obsdb_->window. Start(); } const util: : Date. Time & window. End() const {return obsdb_->window. End(); } const eckit: : Configuration & config() const {return obsdb_->config(); } // Other Locations_ locations(const util: : Date. Time &, const util: : Date. Time &) const; void generate. Distribution(const eckit: : Configuration &); void print. Jo(const Obs. Vector_ &, const Obs. Vector_ &) const; private: void print(std: : ostream &) const; boost: : shared_ptr<Obs. Space_> obsdb_; ; {

Obs. Vector Class template <typename MODEL> class Obs. Vector : public util: : Printable, private util: : Object. Counter<Obs. Vector<MODEL> > { public: explicit Obs. Vector(const Observation. Space<MODEL> &); explicit Obs. Vector(const Obs. Vector &, const bool copy = true); explicit Obs. Vector(Obs. Vector_ *); ~Obs. Vector(); /// Interfacing Obs. Vector_ & obsvector() {return *data_; } const Obs. Vector_ & obsvector() const {return *data_; } // Linear algebra Obs. Vector & operator = (const Obs. Vector &); Obs. Vector & operator*= (const double &); Obs. Vector & operator+= (const Obs. Vector &); Obs. Vector & operator-= (const Obs. Vector &); Obs. Vector & operator*= (const Obs. Vector &); Obs. Vector & operator/= (const Obs. Vector &); void zero(); void axpy(const double &, const Obs. Vector &); void invert(); void random(); double dot_product_with(const Obs. Vector &) const; unsigned int size() const {return data_->size(); } //I/O void read(const std: : string &); void save(const std: : string &) const; private: void print(std: : ostream &) const; boost: : scoped_ptr<Obs. Vector_> data_; ; {

Obs. Operator Class template <typename MODEL> class Obs. Operator : public util: : Printable, private boost: : noncopyable, private util: : Object. Counter<Obs. Operator<MODEL> > { public: static const std: : string classname() {return "oops: : Obs. Operator"; } explicit Obs. Operator(const Obs. Space_ &); ~Obs. Operator(); /// Obs Operator void obs. Equiv(const simulate. Obs(const Geo. Va. Ls_ &, Obs. Vector_ &, const Obs. Aux. Control_ &) const; /// Interfacing const Obs. Operator. Base_ & obsoperator() const {return *oper_; } /// Other const Variables & variables() const; // Required inputs variables from Model private: void print(std: : ostream &) const; boost: : scoped_ptr<Obs. Operator. Base_> oper_; ; {

Linear. Obs. Operator Class template <typename MODEL> class Linear. Obs. Operator : public util: : Printable, private boost: : noncopyable, private util: : Object. Counter<Linear. Obs. Operator<MODEL> > { public: static const std: : string classname() {return "oops: : Linear. Obs. Operator"; } explicit Linear. Obs. Operator(const Obs. Space_ &); ~Linear. Obs. Operator(); /// Interfacing const Linear. Obs. Oper. Base_ & linearobsoperator() const {return *oper_; } /// Obs Operators void set. Trajectory(const Geo. Va. Ls_ &, const Obs. Aux. Control_ &); void obs. Equiv. TL(const Geo. Va. Ls_ &, Obs. Vector_ &, const Obs. Aux. Increment_ &) const; void obs. Equiv. AD(Geo. Va. Ls_ &, const Obs. Vector_ &, Obs. Aux. Increment_ &) const; /// Other const Variables & variables() const; // Required inputs variables from Linear. Model private: void print(std: : ostream &) const; boost: : scoped_ptr<Linear. Obs. Oper. Base_> oper_; ; {

Obs. Error. Covariance Class template <typename MODEL> class Obs. Error. Covariance : public util: : Printable, private util: : Object. Counter<Obs. Error. Covariance<MODEL> >, private boost: : noncopyable} public: static const std: : string classname() {return "oops: : Obs. Error. Covariance"; } Obs. Error. Covariance(const Obs. Space_ &, const eckit: : Configuration &); ~Obs. Error. Covariance(); /// Linearize and reset for inner loop if needed void linearize(const Obs. Vector_ &); /// Multiply a Departure by f$Rf$ and f$R^{-1}f$ Obs. Vector_ * multiply(const Obs. Vector_ &) const; Obs. Vector_ * inverse. Multiply(const Obs. Vector_ &) const; /// Generate random perturbation void randomize(Obs. Vector_ &) const; /// Get mean error for Jo table double get. RMSE() const; private: void print(std: : ostream &) const; boost: : scoped_ptr<Obs. Error. Base_> covar_; ; {