Debian Codegraph @

src/atlas/functionspace/EdgeColumns.h

raw
1 /*
2 * (C) Copyright 2013 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
8 * nor does it submit to any jurisdiction.
9 */
10
11 #pragma once
12
13 #include "atlas/field/FieldSet.h"
14 #include "atlas/functionspace/FunctionSpace.h"
15 #include "atlas/functionspace/detail/FunctionSpaceImpl.h"
16 #include "atlas/mesh/Halo.h"
17 #include "atlas/mesh/Mesh.h"
18 #include "atlas/option.h"
19 #include "atlas/util/Config.h"
20
21 // ----------------------------------------------------------------------------
22 // Forward declarations
23
24 namespace atlas {
25 class FieldSet;
26 }
27
28 namespace atlas {
29 namespace parallel {
30 class HaloExchange;
31 class GatherScatter;
32 class Checksum;
33 } // namespace parallel
34 } // namespace atlas
35
36 namespace atlas {
37 namespace functionspace {
38 namespace detail {
39
40 // ----------------------------------------------------------------------------
41
42 class EdgeColumns : public functionspace::FunctionSpaceImpl {
43 public:
44 EdgeColumns(const Mesh&, const eckit::Configuration& = util::NoConfig());
45
46 ~EdgeColumns() override;
47
48 std::string type() const override { return "Edges"; }
49
50 std::string distribution() const override;
51
52 idx_t nb_edges() const;
53 idx_t nb_edges_global() const; // Only on MPI rank 0, will this be different from 0
54 std::vector<idx_t> nb_edges_global_foreach_rank() const;
55
56 const Mesh& mesh() const { return mesh_; }
57 Mesh& mesh() { return mesh_; }
58
59 const mesh::HybridElements& edges() const { return edges_; }
60 mesh::HybridElements& edges() { return edges_; }
61
62 // -- Field creation methods
63
64 Field createField(const eckit::Configuration&) const override;
65
66 Field createField(const Field&, const eckit::Configuration&) const override;
67
68 // -- Parallelisation aware methods
69
70 void haloExchange(const FieldSet&, bool on_device = false) const override;
71 void haloExchange(const Field&, bool on_device = false) const override;
72 const parallel::HaloExchange& halo_exchange() const;
73
74 void gather(const FieldSet&, FieldSet&) const override;
75 void gather(const Field&, Field&) const override;
76 const parallel::GatherScatter& gather() const override;
77
78 void scatter(const FieldSet&, FieldSet&) const override;
79 void scatter(const Field&, Field&) const override;
80 const parallel::GatherScatter& scatter() const override;
81
82 std::string checksum(const FieldSet&) const;
83 std::string checksum(const Field&) const;
84 const parallel::Checksum& checksum() const;
85
86 idx_t size() const override { return nb_edges_; }
87
88 const Grid& grid() const override;
89
90 Field lonlat() const override;
91
92 Field global_index() const override;
93
94 Field remote_index() const override;
95
96 Field partition() const override;
97
98 std::string mpi_comm() const override { return mesh_.mpi_comm(); }
99
100 private: // methods
101 idx_t config_size(const eckit::Configuration& config) const;
102 array::DataType config_datatype(const eckit::Configuration&) const;
103 std::string config_name(const eckit::Configuration&) const;
104 idx_t config_levels(const eckit::Configuration&) const;
105 array::ArrayShape config_shape(const eckit::Configuration&) const;
106 void set_field_metadata(const eckit::Configuration&, Field&) const;
107 size_t footprint() const override;
108
109 private: // data
110 mutable Grid grid_;
111 Mesh mesh_; // non-const because functionspace may modify mesh
112 mesh::HybridElements& edges_; // non-const because functionspace may modify mesh
113 idx_t nb_levels_;
114 mesh::Halo halo_;
115 idx_t nb_edges_;
116 mutable long nb_edges_global_{-1};
117 mutable util::ObjectHandle<parallel::GatherScatter> gather_scatter_; // without ghost
118 mutable util::ObjectHandle<parallel::HaloExchange> halo_exchange_;
119 mutable util::ObjectHandle<parallel::Checksum> checksum_;
120 };
121
122 // -------------------------------------------------------------------
123
124 extern "C" {
125
126 EdgeColumns* atlas__fs__EdgeColumns__new(Mesh::Implementation* mesh, const eckit::Configuration* config);
127 void atlas__fs__EdgeColumns__delete(EdgeColumns* This);
128 int atlas__fs__EdgeColumns__nb_edges(const EdgeColumns* This);
129 Mesh::Implementation* atlas__fs__EdgeColumns__mesh(EdgeColumns* This);
130 mesh::Edges* atlas__fs__EdgeColumns__edges(EdgeColumns* This);
131 field::FieldImpl* atlas__fs__EdgeColumns__create_field(const EdgeColumns* This, const eckit::Configuration* options);
132 field::FieldImpl* atlas__fs__EdgeColumns__create_field_template(const EdgeColumns* This,
133 const field::FieldImpl* field_template,
134 const eckit::Configuration* options);
135
136 void atlas__fs__EdgeColumns__halo_exchange_fieldset(const EdgeColumns* This, field::FieldSetImpl* fieldset);
137 void atlas__fs__EdgeColumns__halo_exchange_field(const EdgeColumns* This, field::FieldImpl* field);
138 const parallel::HaloExchange* atlas__fs__EdgeColumns__get_halo_exchange(const EdgeColumns* This);
139
140 void atlas__fs__EdgeColumns__gather_fieldset(const EdgeColumns* This, const field::FieldSetImpl* local,
141 field::FieldSetImpl* global);
142 void atlas__fs__EdgeColumns__gather_field(const EdgeColumns* This, const field::FieldImpl* local,
143 field::FieldImpl* global);
144 const parallel::GatherScatter* atlas__fs__EdgeColumns__get_gather(const EdgeColumns* This);
145
146 void atlas__fs__EdgeColumns__scatter_fieldset(const EdgeColumns* This, const field::FieldSetImpl* global,
147 field::FieldSetImpl* local);
148 void atlas__fs__EdgeColumns__scatter_field(const EdgeColumns* This, const field::FieldImpl* global,
149 field::FieldImpl* local);
150 const parallel::GatherScatter* atlas__fs__EdgeColumns__get_scatter(const EdgeColumns* This);
151
152 void atlas__fs__EdgeColumns__checksum_fieldset(const EdgeColumns* This, const field::FieldSetImpl* fieldset,
153 char*& checksum, int& size, int& allocated);
154 void atlas__fs__EdgeColumns__checksum_field(const EdgeColumns* This, const field::FieldImpl* field, char*& checksum,
155 int& size, int& allocated);
156 const parallel::Checksum* atlas__fs__EdgeColumns__get_checksum(const EdgeColumns* This);
157 }
158
159 } // namespace detail
160
161 // -------------------------------------------------------------------
162
163 class EdgeColumns : public FunctionSpace {
164 public:
165 EdgeColumns();
166 EdgeColumns(const FunctionSpace&);
167 EdgeColumns(const Mesh&, const eckit::Configuration&);
168 EdgeColumns(const Mesh& mesh);
169
170 operator bool() const { return valid(); }
171 bool valid() const { return functionspace_; }
172
173 idx_t nb_edges() const;
174 idx_t nb_edges_global() const; // Only on MPI rank 0, will this be different from 0
175
176 const Mesh& mesh() const;
177
178 const mesh::HybridElements& edges() const;
179
180 // -- Parallelisation aware methods
181 const parallel::HaloExchange& halo_exchange() const;
182
183 std::string checksum(const FieldSet&) const;
184 std::string checksum(const Field&) const;
185 const parallel::Checksum& checksum() const;
186
187 private:
188 const detail::EdgeColumns* functionspace_;
189 };
190
191 } // namespace functionspace
192 } // namespace atlas