Debian Codegraph @

src/atlas/functionspace/detail/BlockStructuredColumnsInterface.cc

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 #include <cstring>
12
13 #include "BlockStructuredColumnsInterface.h"
14
15 #include "atlas/field/FieldSet.h"
16 #include "atlas/field/detail/FieldImpl.h"
17 #include "atlas/grid/Distribution.h"
18 #include "atlas/grid/Grid.h"
19 #include "atlas/grid/Partitioner.h"
20 #include "atlas/grid/detail/distribution/DistributionImpl.h"
21 #include "atlas/runtime/Exception.h"
22
23 namespace atlas {
24 namespace functionspace {
25
26 // ----------------------------------------------------------------------------
27 // Fortran interfaces
28 // ----------------------------------------------------------------------------
29
30 namespace detail {
31 struct BlockStructuredColumnsFortranAccess {
32 detail::StructuredColumns::Map2to1& ij2gp_;
33 BlockStructuredColumnsFortranAccess(const detail::BlockStructuredColumns& fs) :
34 ij2gp_(const_cast<detail::StructuredColumns&>(fs.structuredcolumns()).ij2gp_) {};
35 };
36 } // namespace detail
37
38
39 extern "C" {
40
41 const detail::BlockStructuredColumns* atlas__functionspace__BStructuredColumns__new__grid(
42 const Grid::Implementation* grid, const eckit::Configuration* config) {
43 return new detail::BlockStructuredColumns(Grid(grid), grid::Partitioner(), *config);
44 }
45
46 const detail::BlockStructuredColumns* atlas__functionspace__BStructuredColumns__new__grid_dist(
47 const Grid::Implementation* grid, const grid::DistributionImpl* dist, const eckit::Configuration* config) {
48 return new detail::BlockStructuredColumns(Grid(grid), grid::Distribution(dist), *config);
49 }
50
51 const detail::BlockStructuredColumns* atlas__functionspace__BStructuredColumns__new__grid_dist_vert(
52 const Grid::Implementation* grid, const grid::DistributionImpl* dist, const Vertical* vert,
53 const eckit::Configuration* config) {
54 return new detail::BlockStructuredColumns(Grid(grid), grid::Distribution(dist), *vert, *config);
55 }
56 const detail::BlockStructuredColumns* atlas__functionspace__BStructuredColumns__new__grid_dist_config(
57 const Grid::Implementation* grid, const grid::DistributionImpl* dist, const eckit::Configuration* config) {
58 return new detail::BlockStructuredColumns(Grid(grid), grid::Distribution(dist), *config);
59 }
60
61 const detail::BlockStructuredColumns* atlas__functionspace__BStructuredColumns__new__grid_part(
62 const Grid::Implementation* grid, const PartitionerImpl* partitioner, const eckit::Configuration* config) {
63 return new detail::BlockStructuredColumns(Grid(grid), grid::Partitioner(partitioner), *config);
64 }
65
66 const detail::BlockStructuredColumns* atlas__functionspace__BStructuredColumns__new__grid_part_vert(
67 const Grid::Implementation* grid, const PartitionerImpl* partitioner, const Vertical* vert,
68 const eckit::Configuration* config) {
69 return new detail::BlockStructuredColumns(Grid(grid), *vert, grid::Partitioner(partitioner), *config);
70 }
71
72 void atlas__functionspace__BStructuredColumns__gather_field(const detail::BlockStructuredColumns* This,
73 const field::FieldImpl* local, field::FieldImpl* global) {
74 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_BlockStructuredColumns");
75 ATLAS_ASSERT(global != nullptr, "Cannot access uninitialised atlas_Field");
76 ATLAS_ASSERT(local != nullptr, "Cannot access uninitialised atlas_Field");
77 const Field l(local);
78 Field g(global);
79 This->gather(l, g);
80 }
81
82 void atlas__functionspace__BStructuredColumns__scatter_field(const detail::BlockStructuredColumns* This,
83 const field::FieldImpl* global, field::FieldImpl* local) {
84 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_BlockStructuredColumns");
85 ATLAS_ASSERT(global != nullptr, "Cannot access uninitialised atlas_Field");
86 ATLAS_ASSERT(local != nullptr, "Cannot access uninitialised atlas_Field");
87 const Field g(global);
88 Field l(local);
89 This->scatter(g, l);
90 }
91
92 void atlas__functionspace__BStructuredColumns__gather_fieldset(const detail::BlockStructuredColumns* This,
93 const field::FieldSetImpl* local,
94 field::FieldSetImpl* global) {
95 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_BlockStructuredColumns");
96 ATLAS_ASSERT(global != nullptr, "Cannot access uninitialised atlas_FieldSet");
97 ATLAS_ASSERT(local != nullptr, "Cannot access uninitialised atlas_FieldSet");
98 const FieldSet l(local);
99 FieldSet g(global);
100 This->gather(l, g);
101 }
102
103 void atlas__functionspace__BStructuredColumns__scatter_fieldset(const detail::BlockStructuredColumns* This,
104 const field::FieldSetImpl* global,
105 field::FieldSetImpl* local) {
106 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_BlockStructuredColumns");
107 ATLAS_ASSERT(global != nullptr, "Cannot access uninitialised atlas_FieldSet");
108 ATLAS_ASSERT(local != nullptr, "Cannot access uninitialised atlas_FieldSet");
109 const FieldSet g(global);
110 FieldSet l(local);
111 This->scatter(g, l);
112 }
113
114 void atlas__fs__BStructuredColumns__checksum_fieldset(const detail::BlockStructuredColumns* This,
115 const field::FieldSetImpl* fieldset, char*& checksum, idx_t& size,
116 int& allocated) {
117 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_BlockStructuredColumns");
118 ATLAS_ASSERT(fieldset != nullptr, "Cannot access uninitialised atlas_FieldSet");
119 std::string checksum_str(This->checksum(fieldset));
120 size = static_cast<idx_t>(checksum_str.size());
121 checksum = new char[size + 1];
122 allocated = true;
123 std::strncpy(checksum, checksum_str.c_str(), size + 1);
124 }
125
126 void atlas__fs__BStructuredColumns__checksum_field(const detail::BlockStructuredColumns* This, const field::FieldImpl* field,
127 char*& checksum, idx_t& size, int& allocated) {
128 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_BlockStructuredColumns");
129 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
130 std::string checksum_str(This->checksum(field));
131 size = static_cast<idx_t>(checksum_str.size());
132 checksum = new char[size + 1];
133 allocated = true;
134 std::strncpy(checksum, checksum_str.c_str(), size + 1);
135 }
136
137 void atlas__fs__BStructuredColumns__index_host(const detail::BlockStructuredColumns* This, idx_t*& data, idx_t& i_min,
138 idx_t& i_max, idx_t& j_min, idx_t& j_max) {
139 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_BlockStructuredColumns");
140 auto _This = detail::BlockStructuredColumnsFortranAccess{*This};
141 data = _This.ij2gp_.data_.data();
142 i_min = _This.ij2gp_.i_min_ + 1;
143 i_max = _This.ij2gp_.i_max_ + 1;
144 j_min = _This.ij2gp_.j_min_ + 1;
145 j_max = _This.ij2gp_.j_max_ + 1;
146 }
147
148 idx_t atlas__fs__BStructuredColumns__j_begin(const detail::BlockStructuredColumns* This) {
149 return This->structuredcolumns().j_begin() + 1;
150 }
151 idx_t atlas__fs__BStructuredColumns__j_end(const detail::BlockStructuredColumns* This) {
152 return This->structuredcolumns().j_end();
153 }
154 idx_t atlas__fs__BStructuredColumns__i_begin(const detail::BlockStructuredColumns* This, idx_t j) {
155 return This->structuredcolumns().i_begin(j - 1) + 1;
156 }
157 idx_t atlas__fs__BStructuredColumns__i_end(const detail::BlockStructuredColumns* This, idx_t j) {
158 return This->structuredcolumns().i_end(j - 1);
159 }
160 idx_t atlas__fs__BStructuredColumns__j_begin_halo(const detail::BlockStructuredColumns* This) {
161 return This->structuredcolumns().j_begin_halo() + 1;
162 }
163 idx_t atlas__fs__BStructuredColumns__j_end_halo(const detail::BlockStructuredColumns* This) {
164 return This->structuredcolumns().j_end_halo();
165 }
166 idx_t atlas__fs__BStructuredColumns__i_begin_halo(const detail::BlockStructuredColumns* This, idx_t j) {
167 return This->structuredcolumns().i_begin_halo(j - 1) + 1;
168 }
169 idx_t atlas__fs__BStructuredColumns__i_end_halo(const detail::BlockStructuredColumns* This, idx_t j) {
170 return This->structuredcolumns().i_end_halo(j - 1);
171 }
172 idx_t atlas__fs__BStructuredColumns__block_begin(const detail::BlockStructuredColumns* This, idx_t jblk) {
173 return This->block_begin(jblk);
174 }
175 idx_t atlas__fs__BStructuredColumns__block_size(const detail::BlockStructuredColumns* This, idx_t jblk) {
176 return This->block_size(jblk);
177 }
178 idx_t atlas__fs__BStructuredColumns__nproma(const detail::BlockStructuredColumns* This) {
179 return This->nproma();
180 }
181 idx_t atlas__fs__BStructuredColumns__nblks(const detail::BlockStructuredColumns* This) {
182 return This->nblks();
183 }
184
185 field::FieldImpl* atlas__fs__BStructuredColumns__xy(const detail::BlockStructuredColumns* This) {
186 return This->xy().get();
187 }
188
189 field::FieldImpl* atlas__fs__BStructuredColumns__z(const detail::BlockStructuredColumns* This) {
190 ATLAS_ASSERT(This != nullptr);
191 field::FieldImpl* field;
192 {
193 Field f = This->z();
194 field = f.get();
195 field->attach();
196 }
197 field->detach();
198 return field;
199 }
200
201 field::FieldImpl* atlas__fs__BStructuredColumns__partition(const detail::BlockStructuredColumns* This) {
202 return This->partition().get();
203 }
204
205 field::FieldImpl* atlas__fs__BStructuredColumns__global_index(const detail::BlockStructuredColumns* This) {
206 return This->global_index().get();
207 }
208
209 field::FieldImpl* atlas__fs__BStructuredColumns__index_i(const detail::BlockStructuredColumns* This) {
210 return This->index_i().get();
211 }
212
213 field::FieldImpl* atlas__fs__BStructuredColumns__index_j(const detail::BlockStructuredColumns* This) {
214 return This->index_j().get();
215 }
216
217 idx_t atlas__fs__BStructuredColumns__size(const detail::BlockStructuredColumns* This) {
218 return This->size();
219 }
220
221 idx_t atlas__fs__BStructuredColumns__sizeOwned(const detail::BlockStructuredColumns* This) {
222 return This->structuredcolumns().sizeOwned();
223 }
224
225 idx_t atlas__fs__BStructuredColumns__levels(const detail::BlockStructuredColumns* This) {
226 return This->levels();
227 }
228
229 const GridImpl* atlas__fs__BStructuredColumns__grid(const detail::BlockStructuredColumns* This) {
230 return This->grid().get();
231 }
232 }
233
234
235 // ----------------------------------------------------------------------------
236
237 } // namespace functionspace
238 } // namespace atlas