Debian Codegraph @

src/atlas/functionspace/detail/StructuredColumnsInterface.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 "StructuredColumnsInterface.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 StructuredColumnsFortranAccess {
32 detail::StructuredColumns::Map2to1& ij2gp_;
33 StructuredColumnsFortranAccess(const detail::StructuredColumns& fs):
34 ij2gp_(const_cast<detail::StructuredColumns&>(fs).ij2gp_) {}
35 };
36 } // namespace detail
37
38
39 extern "C" {
40
41 const detail::StructuredColumns* atlas__functionspace__StructuredColumns__new__grid(
42 const Grid::Implementation* grid, const eckit::Configuration* config) {
43 return new detail::StructuredColumns(Grid(grid), grid::Partitioner(), *config);
44 }
45
46 const detail::StructuredColumns* atlas__functionspace__StructuredColumns__new__grid_dist(
47 const Grid::Implementation* grid, const grid::DistributionImpl* dist, const eckit::Configuration* config) {
48 return new detail::StructuredColumns(Grid(grid), grid::Distribution(dist), *config);
49 }
50
51 const detail::StructuredColumns* atlas__functionspace__StructuredColumns__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::StructuredColumns(Grid(grid), grid::Distribution(dist), *vert, *config);
55 }
56 const detail::StructuredColumns* atlas__functionspace__StructuredColumns__new__grid_dist_config(
57 const Grid::Implementation* grid, const grid::DistributionImpl* dist, const eckit::Configuration* config) {
58 return new detail::StructuredColumns(Grid(grid), grid::Distribution(dist), *config);
59 }
60
61 const detail::StructuredColumns* atlas__functionspace__StructuredColumns__new__grid_part(
62 const Grid::Implementation* grid, const PartitionerImpl* partitioner, const eckit::Configuration* config) {
63 return new detail::StructuredColumns(Grid(grid), grid::Partitioner(partitioner), *config);
64 }
65
66 const detail::StructuredColumns* atlas__functionspace__StructuredColumns__new__grid_part_vert(
67 const Grid::Implementation* grid, const PartitionerImpl* partitioner, const Vertical* vert,
68 const eckit::Configuration* config) {
69 return new detail::StructuredColumns(Grid(grid), *vert, grid::Partitioner(partitioner), *config);
70 }
71
72 void atlas__functionspace__StructuredColumns__gather_field(const detail::StructuredColumns* This,
73 const field::FieldImpl* local, field::FieldImpl* global) {
74 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_StructuredColumns");
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__StructuredColumns__scatter_field(const detail::StructuredColumns* This,
83 const field::FieldImpl* global, field::FieldImpl* local) {
84 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_StructuredColumns");
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__StructuredColumns__gather_fieldset(const detail::StructuredColumns* This,
93 const field::FieldSetImpl* local,
94 field::FieldSetImpl* global) {
95 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_StructuredColumns");
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__StructuredColumns__scatter_fieldset(const detail::StructuredColumns* This,
104 const field::FieldSetImpl* global,
105 field::FieldSetImpl* local) {
106 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_StructuredColumns");
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__StructuredColumns__checksum_fieldset(const detail::StructuredColumns* This,
115 const field::FieldSetImpl* fieldset, char*& checksum, idx_t& size,
116 int& allocated) {
117 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_StructuredColumns");
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__StructuredColumns__checksum_field(const detail::StructuredColumns* This, const field::FieldImpl* field,
127 char*& checksum, idx_t& size, int& allocated) {
128 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_StructuredColumns");
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__StructuredColumns__index_host(const detail::StructuredColumns* 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_StructuredColumns");
140 auto _This = detail::StructuredColumnsFortranAccess{*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__StructuredColumns__j_begin(const detail::StructuredColumns* This) {
149 return This->j_begin() + 1;
150 }
151 idx_t atlas__fs__StructuredColumns__j_end(const detail::StructuredColumns* This) {
152 return This->j_end();
153 }
154 idx_t atlas__fs__StructuredColumns__i_begin(const detail::StructuredColumns* This, idx_t j) {
155 return This->i_begin(j - 1) + 1;
156 }
157 idx_t atlas__fs__StructuredColumns__i_end(const detail::StructuredColumns* This, idx_t j) {
158 return This->i_end(j - 1);
159 }
160 idx_t atlas__fs__StructuredColumns__j_begin_halo(const detail::StructuredColumns* This) {
161 return This->j_begin_halo() + 1;
162 }
163 idx_t atlas__fs__StructuredColumns__j_end_halo(const detail::StructuredColumns* This) {
164 return This->j_end_halo();
165 }
166 idx_t atlas__fs__StructuredColumns__i_begin_halo(const detail::StructuredColumns* This, idx_t j) {
167 return This->i_begin_halo(j - 1) + 1;
168 }
169 idx_t atlas__fs__StructuredColumns__i_end_halo(const detail::StructuredColumns* This, idx_t j) {
170 return This->i_end_halo(j - 1);
171 }
172
173 field::FieldImpl* atlas__fs__StructuredColumns__xy(const detail::StructuredColumns* This) {
174 return This->xy().get();
175 }
176
177 field::FieldImpl* atlas__fs__StructuredColumns__z(const detail::StructuredColumns* This) {
178 ATLAS_ASSERT(This != nullptr);
179 field::FieldImpl* field;
180 {
181 Field f = This->z();
182 field = f.get();
183 field->attach();
184 }
185 field->detach();
186 return field;
187 }
188
189 field::FieldImpl* atlas__fs__StructuredColumns__partition(const detail::StructuredColumns* This) {
190 return This->partition().get();
191 }
192
193 field::FieldImpl* atlas__fs__StructuredColumns__global_index(const detail::StructuredColumns* This) {
194 return This->global_index().get();
195 }
196
197 field::FieldImpl* atlas__fs__StructuredColumns__index_i(const detail::StructuredColumns* This) {
198 return This->index_i().get();
199 }
200
201 field::FieldImpl* atlas__fs__StructuredColumns__index_j(const detail::StructuredColumns* This) {
202 return This->index_j().get();
203 }
204
205 idx_t atlas__fs__StructuredColumns__size(const detail::StructuredColumns* This) {
206 return This->size();
207 }
208
209 idx_t atlas__fs__StructuredColumns__sizeOwned(const detail::StructuredColumns* This) {
210 return This->sizeOwned();
211 }
212
213 idx_t atlas__fs__StructuredColumns__levels(const detail::StructuredColumns* This) {
214 return This->levels();
215 }
216
217 const GridImpl* atlas__fs__StructuredColumns__grid(const detail::StructuredColumns* This) {
218 return This->grid().get();
219 }
220 }
221
222
223 // ----------------------------------------------------------------------------
224
225 } // namespace functionspace
226 } // namespace atlas