FV3 Bundle
PostBase.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_BASE_POSTBASE_H_
12 #define OOPS_BASE_POSTBASE_H_
13 
14 #include <boost/noncopyable.hpp>
15 
16 #include "eckit/config/Configuration.h"
17 #include "oops/base/PostTimer.h"
18 #include "oops/util/DateTime.h"
19 #include "oops/util/Duration.h"
20 
21 namespace oops {
22 
23 // -----------------------------------------------------------------------------
24 
25 /// Handles post-processing of model fields.
26 /*!
27  * PostBase is the base class for all state post processors, it
28  * is mostly used so that PostProcessor can hold a vector of such
29  * processors.
30  * By default processing is performed on every call.
31  */
32 
33 template <typename FLDS> class PostBase : private boost::noncopyable {
34  public:
35 /// Constructors and basic operators
36  PostBase() : timer_() {}
37  explicit PostBase(const util::Duration & freq) : timer_(freq) {}
38  explicit PostBase(const eckit::Configuration & conf) : timer_(conf) {}
39  PostBase(const util::DateTime & start, const eckit::Configuration & conf)
40  : timer_(start, conf) {}
41  PostBase(const util::DateTime & start, const util::DateTime & finish,
42  const util::Duration & freq = util::Duration(0))
43  : timer_(start, finish, freq) {}
44 
45  virtual ~PostBase() {}
46 
47 /// Setup
48  void initialize(const FLDS & xx, const util::DateTime & end,
49  const util::Duration & tstep) {
50  timer_.initialize(xx.validTime(), end, tstep);
51  this->doInitialize(xx, end, tstep);
52  }
53 
54 /// Process state or increment
55  void process(const FLDS & xx) {
56  if (timer_.itIsTime(xx.validTime())) this->doProcessing(xx);
57  }
58 
59 /// Final
60  void finalize(const FLDS & xx) {
61  this->doFinalize(xx);
62  }
63 
64  private:
66 
67 /// Actual processing
68  virtual void doProcessing(const FLDS &) = 0;
69  virtual void doInitialize(const FLDS &, const util::DateTime &,
70  const util::Duration &) {}
71  virtual void doFinalize(const FLDS &) {}
72 };
73 
74 // -----------------------------------------------------------------------------
75 
76 } // namespace oops
77 
78 #endif // OOPS_BASE_POSTBASE_H_
virtual void doInitialize(const FLDS &, const util::DateTime &, const util::Duration &)
Definition: PostBase.h:69
void finalize(const FLDS &xx)
Final.
Definition: PostBase.h:60
************************************************************************GNU Lesser General Public License **This file is part of the GFDL Flexible Modeling System(FMS). ! *! *FMS is free software without even the implied warranty of MERCHANTABILITY or *FITNESS FOR A PARTICULAR PURPOSE See the GNU General Public License *for more details **You should have received a copy of the GNU Lesser General Public *License along with FMS If see< http:! ***********************************************************************!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !! MPP_TRANSMIT !! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! subroutine MPP_TRANSMIT_(put_data, put_len, to_pe, get_data, get_len, from_pe, block, tag, recv_request, send_request)!a message-passing routine intended to be reminiscent equally of both MPI and SHMEM!put_data and get_data are contiguous MPP_TYPE_ arrays!at each call, your put_data array is put to to_pe 's get_data! your get_data array is got from from_pe 's put_data!i.e we assume that typically(e.g updating halo regions) each PE performs a put _and_ a get!special PE designations:! NULL_PE:to disable a put or a get(e.g at boundaries)! ANY_PE:if remote PE for the put or get is to be unspecific! ALL_PES:broadcast and collect operations(collect not yet implemented)!ideally we would not pass length, but this f77-style call performs better(arrays passed by address, not descriptor)!further, this permits< length > contiguous words from an array of any rank to be passed(avoiding f90 rank conformance check)!caller is responsible for completion checks(mpp_sync_self) before and after integer, intent(in) ::put_len, to_pe, get_len, from_pe MPP_TYPE_, intent(in) ::put_data(*) MPP_TYPE_, intent(out) ::get_data(*) logical, intent(in), optional ::block integer, intent(in), optional ::tag integer, intent(out), optional ::recv_request, send_request logical ::block_comm integer ::i MPP_TYPE_, allocatable, save ::local_data(:) !local copy used by non-parallel code(no SHMEM or MPI) integer ::comm_tag integer ::rsize if(.NOT.module_is_initialized) call mpp_error(FATAL, 'MPP_TRANSMIT:You must first call mpp_init.') if(to_pe.EQ.NULL_PE .AND. from_pe.EQ.NULL_PE) return block_comm=.true. if(PRESENT(block)) block_comm=block if(debug) then call SYSTEM_CLOCK(tick) write(stdout_unit,'(a, i18, a, i6, a, 2i6, 2i8)')&'T=', tick, ' PE=', pe, ' MPP_TRANSMIT begin:to_pe, from_pe, put_len, get_len=', to_pe, from_pe, put_len, get_len end if comm_tag=DEFAULT_TAG if(present(tag)) comm_tag=tag!do put first and then get if(to_pe.GE.0 .AND. to_pe.LT.npes) then!use non-blocking sends if(debug .and.(current_clock.NE.0)) call SYSTEM_CLOCK(start_tick)!z1l:truly non-blocking send.! if(request(to_pe).NE.MPI_REQUEST_NULL) then !only one message from pe-> to_pe in queue *PE waiting for to_pe ! call error else get_len so only do gets but you cannot have a pure get with MPI call a get means do a wait to ensure put on remote PE is complete error call increase mpp_nml request_multiply call MPP_TRANSMIT end
Definition: conf.py:1
PostBase(const util::DateTime &start, const eckit::Configuration &conf)
Definition: PostBase.h:39
PostBase(const eckit::Configuration &conf)
Definition: PostBase.h:38
PostTimer timer_
Definition: PostBase.h:65
PostBase(const util::DateTime &start, const util::DateTime &finish, const util::Duration &freq=util::Duration(0))
Definition: PostBase.h:41
virtual void doProcessing(const FLDS &)=0
Actual processing.
Handles post-processing of model fields.
Definition: PostBase.h:33
The namespace for the main oops code.
Handles timing of post-processing and similar actions.
Definition: PostTimer.h:32
virtual void doFinalize(const FLDS &)
Definition: PostBase.h:71
virtual ~PostBase()
Definition: PostBase.h:45
************************************************************************GNU Lesser General Public License **This file is part of the GFDL Flexible Modeling System(FMS). ! *! *FMS is free software without even the implied warranty of MERCHANTABILITY or *FITNESS FOR A PARTICULAR PURPOSE See the GNU General Public License *for more details **You should have received a copy of the GNU Lesser General Public *License along with FMS If see< http:! ***********************************************************************subroutine READ_RECORD_CORE_(unit, field, nwords, data, start, axsiz) integer, intent(in) ::unit type(fieldtype), intent(in) ::field integer, intent(in) ::nwords MPP_TYPE_, intent(inout) ::data(nwords) integer, intent(in) ::start(:), axsiz(:) integer(SHORT_KIND) ::i2vals(nwords)!rab used in conjunction with transfer intrinsic to determine size of a variable integer(KIND=1) ::one_byte(8) integer ::word_sz!#ifdef __sgi integer(INT_KIND) ::ivals(nwords) real(FLOAT_KIND) ::rvals(nwords)!#else! integer ::ivals(nwords)! real ::rvals(nwords)!#endif real(DOUBLE_KIND) ::r8vals(nwords) pointer(ptr1, i2vals) pointer(ptr2, ivals) pointer(ptr3, rvals) pointer(ptr4, r8vals) if(mpp_io_stack_size< nwords) call mpp_io_set_stack_size(nwords) call mpp_error(FATAL, 'MPP_READ currently requires use_netCDF option') end subroutine READ_RECORD_CORE_ subroutine READ_RECORD_(unit, field, nwords, data, time_level, domain, position, tile_count, start_in, axsiz_in)!routine that is finally called by all mpp_read routines to perform the read!a non-netCDF record contains:! field ID! a set of 4 coordinates(is:ie, js:je) giving the data subdomain! a timelevel and a timestamp(=NULLTIME if field is static)! 3D real data(stored as 1D)!if you are using direct access I/O, the RECL argument to OPEN must be large enough for the above!in a global direct access file, record position on PE is given by %record.!Treatment of timestamp:! We assume that static fields have been passed without a timestamp.! Here that is converted into a timestamp of NULLTIME.! For non-netCDF fields, field is treated no differently, but is written! with a timestamp of NULLTIME. There is no check in the code to prevent! the user from repeatedly writing a static field. integer, intent(in) ::unit, nwords type(fieldtype), intent(in) ::field MPP_TYPE_, intent(inout) ::data(nwords) integer, intent(in), optional ::time_level type(domain2D), intent(in), optional ::domain integer, intent(in), optional ::position, tile_count integer, intent(in), optional ::start_in(:), axsiz_in(:) integer, dimension(size(field%axes(:))) ::start, axsiz integer ::tlevel !, subdomain(4) integer ::i, error, is, ie, js, je, isg, ieg, jsg, jeg type(domain2d), pointer ::io_domain=> tlevel if(PRESENT(start_in) .AND. PRESENT(axsiz_in)) then if(size(start(! the data domain and compute domain must refer to the subdomain being passed ! In this ! since that attempts to gather all data on PE start
void process(const FLDS &xx)
Process state or increment.
Definition: PostBase.h:55
PostBase()
Constructors and basic operators.
Definition: PostBase.h:36
PostBase(const util::Duration &freq)
Definition: PostBase.h:37
bool itIsTime(const util::DateTime &)
Definition: PostTimer.cc:79
void initialize(const FLDS &xx, const util::DateTime &end, const util::Duration &tstep)
Setup.
Definition: PostBase.h:48
void initialize(const util::DateTime &, const util::DateTime &, const util::Duration &)
Definition: PostTimer.cc:45