Debian Codegraph @

src/atlas/numerics/fvm/Nabla.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 "eckit/config/Parametrisation.h"
12
13 #include "atlas/array/ArrayView.h"
14 #include "atlas/array/MakeView.h"
15 #include "atlas/field/Field.h"
16 #include "atlas/mesh/HybridElements.h"
17 #include "atlas/mesh/Mesh.h"
18 #include "atlas/mesh/Nodes.h"
19 #include "atlas/numerics/fvm/Method.h"
20 #include "atlas/numerics/fvm/Nabla.h"
21 #include "atlas/parallel/omp/omp.h"
22 #include "atlas/runtime/Exception.h"
23 #include "atlas/runtime/Log.h"
24 #include "atlas/util/CoordinateEnums.h"
25
26 // =======================================================
27
28 using Topology = atlas::mesh::Nodes::Topology;
29 using Range = atlas::array::Range;
30
31 namespace atlas {
32 namespace numerics {
33 namespace fvm {
34
35 namespace {
36 static NablaBuilder<Nabla> __fvm_nabla("fvm");
37 }
38
39 Nabla::Nabla(const numerics::Method& method, const eckit::Parametrisation& p): atlas::numerics::NablaImpl(method, p) {
40 fvm_ = dynamic_cast<const fvm::Method*>(&method);
41 if (!fvm_) {
42 throw_Exception("atlas::numerics::fvm::Nabla needs a atlas::numerics::fvm::Method", Here());
43 }
44 Log::debug() << "Nabla constructed for method " << fvm_->name() << " with "
45 << fvm_->node_columns().nb_nodes_global() << " nodes total" << std::endl;
46 fvm_->attach();
47
48 p.get("metric_approach", metric_approach_);
49 // Experimental, only affects divergence and curl !!!
50 // metric_approach = 0 ORIGINAL, DEFAULT
51 // metric_term cos(y) is multiplied with each wind component
52 // --> cell-interface: avg = 0.5*( cos(y1)*u1 + cos(y2)*u2 )
53 // metric_approach = 1:
54 // metric_term cos(0.5*(y1+y2)) is used at cell interface
55 // --> cell-interface: avg = 0.5*(u1+u2)*cos(0.5*(y1+y2))
56 // Results seem to indicate that approach=0 is overall better, although approach=1
57 // seems to handle pole slightly better (error factor 2 to 4 times lower)
58
59 setup();
60 }
61
62 Nabla::~Nabla() = default;
63
64 void Nabla::setup() {
65 const mesh::Edges& edges = fvm_->mesh().edges();
66
67 const idx_t nedges = fvm_->edge_columns().nb_edges();
68
69 const auto edge_flags = array::make_view<int, 1>(edges.flags());
70 auto is_pole_edge = [&](idx_t e) { return Topology::check(edge_flags(e), Topology::POLE); };
71
72 // Filter pole_edges out of all edges
73 std::vector<idx_t> tmp(nedges);
74 idx_t c(0);
75 for (idx_t jedge = 0; jedge < nedges; ++jedge) {
76 if (is_pole_edge(jedge)) {
77 tmp[c++] = jedge;
78 }
79 }
80 pole_edges_.clear();
81 pole_edges_.reserve(c);
82 for (idx_t jedge = 0; jedge < c; ++jedge) {
83 pole_edges_.push_back(tmp[jedge]);
84 }
85 }
86
87 void Nabla::gradient(const Field& field, Field& grad_field) const {
88 if (field.variables() > 1) {
89 return gradient_of_vector(field, grad_field);
90 }
91 else {
92 return gradient_of_scalar(field, grad_field);
93 }
94 }
95
96 void Nabla::gradient_of_scalar(const Field& scalar_field, Field& grad_field) const {
97 Log::debug() << "Compute gradient of scalar field " << scalar_field.name() << " with fvm method" << std::endl;
98
99 auto dispatch = [&](auto value) {
100 using Value = std::decay_t<decltype(value)>;
101
102 const Value radius = fvm_->radius();
103 const Value deg2rad = M_PI / 180.;
104
105 const mesh::Edges& edges = fvm_->mesh().edges();
106 const mesh::Nodes& nodes = fvm_->mesh().nodes();
107
108 const idx_t nnodes = fvm_->node_columns().nb_nodes();
109 const idx_t nedges = fvm_->edge_columns().nb_edges();
110
111 const auto scalar = scalar_field.levels()
112 ? array::make_view<Value, 2>(scalar_field).slice(Range::all(), Range::all())
113 : array::make_view<Value, 1>(scalar_field).slice(Range::all(), Range::dummy());
114 auto grad = grad_field.levels()
115 ? array::make_view<Value, 3>(grad_field).slice(Range::all(), Range::all(), Range::all())
116 : array::make_view<Value, 2>(grad_field).slice(Range::all(), Range::dummy(), Range::all());
117
118 const idx_t nlev = scalar.shape(1);
119 if (grad.shape(1) != nlev) {
120 throw_AssertionFailed("gradient field should have same number of levels", Here());
121 }
122
123 const auto lonlat_deg = array::make_view<double, 2>(nodes.lonlat());
124 const auto dual_volumes = array::make_view<double, 1>(nodes.field("dual_volumes"));
125 const auto dual_normals = array::make_view<double, 2>(edges.field("dual_normals"));
126 const auto node2edge_sign = array::make_view<double, 2>(nodes.field("node2edge_sign"));
127
128 const mesh::Connectivity& node2edge = nodes.edge_connectivity();
129 const mesh::MultiBlockConnectivity& edge2node = edges.node_connectivity();
130
131 array::ArrayT<Value> avgS_arr(nedges, nlev, 2ul);
132 auto avgS = array::make_view<Value, 3>(avgS_arr);
133
134 const Value scale = deg2rad * deg2rad * radius;
135
136 atlas_omp_parallel {
137 atlas_omp_for(idx_t jedge = 0; jedge < nedges; ++jedge) {
138 idx_t ip1 = edge2node(jedge, 0);
139 idx_t ip2 = edge2node(jedge, 1);
140 Value S[2] = { static_cast<Value>(dual_normals(jedge, LON)), static_cast<Value>(dual_normals(jedge, LAT))};
141
142 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
143 Value avg = (scalar(ip1, jlev) + scalar(ip2, jlev)) * Value{0.5};
144 avgS(jedge, jlev, LON) = S[LON] * deg2rad * avg;
145 avgS(jedge, jlev, LAT) = S[LAT] * deg2rad * avg;
146 }
147 }
148
149 atlas_omp_for(idx_t jnode = 0; jnode < nnodes; ++jnode) {
150 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
151 grad(jnode, jlev, LON) = 0.;
152 grad(jnode, jlev, LAT) = 0.;
153 }
154 for (idx_t jedge = 0; jedge < node2edge.cols(jnode); ++jedge) {
155 const idx_t iedge = node2edge(jnode, jedge);
156 if (iedge < nedges) {
157 const Value add = node2edge_sign(jnode, jedge);
158 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
159 grad(jnode, jlev, LON) += add * avgS(iedge, jlev, LON);
160 grad(jnode, jlev, LAT) += add * avgS(iedge, jlev, LAT);
161 }
162 }
163 }
164
165 const Value y = lonlat_deg(jnode, LAT) * deg2rad;
166 const Value metric_y = Value{1.} / (static_cast<Value>(dual_volumes(jnode)) * scale);
167 const Value metric_x = metric_y / std::cos(y);
168 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
169 grad(jnode, jlev, LON) *= metric_x;
170 grad(jnode, jlev, LAT) *= metric_y;
171 }
172 }
173 }
174 };
175 ATLAS_ASSERT( scalar_field.datatype() == grad_field.datatype() );
176 switch (scalar_field.datatype().kind()) {
177 case (DataType::KIND_REAL32): {
178 dispatch(float{});
179 break;
180 }
181 case (DataType::KIND_REAL64): {
182 dispatch(double{});
183 break;
184 }
185 default:
186 ATLAS_NOTIMPLEMENTED;
187 }
188 }
189
190 // ================================================================================
191
192 void Nabla::gradient_of_vector(const Field& vector_field, Field& grad_field) const {
193 Log::debug() << "Compute gradient of vector field " << vector_field.name() << " with fvm method" << std::endl;
194
195 auto dispatch = [&](auto value) {
196 using Value = std::decay_t<decltype(value)>;
197
198 const Value radius = fvm_->radius();
199 const Value deg2rad = M_PI / 180.;
200
201 const mesh::Edges& edges = fvm_->mesh().edges();
202 const mesh::Nodes& nodes = fvm_->mesh().nodes();
203
204 const idx_t nnodes = fvm_->node_columns().nb_nodes();
205 const idx_t nedges = fvm_->edge_columns().nb_edges();
206
207 const auto vector =
208 vector_field.levels()
209 ? array::make_view<Value, 3>(vector_field).slice(Range::all(), Range::all(), Range::all())
210 : array::make_view<Value, 2>(vector_field).slice(Range::all(), Range::dummy(), Range::all());
211 auto grad = grad_field.levels()
212 ? array::make_view<Value, 3>(grad_field).slice(Range::all(), Range::all(), Range::all())
213 : array::make_view<Value, 2>(grad_field).slice(Range::all(), Range::dummy(), Range::all());
214
215 const idx_t nlev = vector.shape(1);
216 if (grad.shape(1) != nlev) {
217 throw_AssertionFailed("gradient field should have same number of levels", Here());
218 }
219
220 const auto lonlat_deg = array::make_view<double, 2>(nodes.lonlat());
221 const auto dual_volumes = array::make_view<double, 1>(nodes.field("dual_volumes"));
222 const auto dual_normals = array::make_view<double, 2>(edges.field("dual_normals"));
223 const auto node2edge_sign = array::make_view<double, 2>(nodes.field("node2edge_sign"));
224 const auto edge_flags = array::make_view<int, 1>(edges.flags());
225 auto is_pole_edge = [&](idx_t e) { return Topology::check(edge_flags(e), Topology::POLE); };
226
227 const mesh::Connectivity& node2edge = nodes.edge_connectivity();
228 const mesh::MultiBlockConnectivity& edge2node = edges.node_connectivity();
229
230 array::ArrayT<Value> avgS_arr(nedges, nlev, 4ul);
231 array::ArrayView<Value, 3> avgS = array::make_view<Value, 3>(avgS_arr);
232
233 const Value scale = deg2rad * deg2rad * radius;
234
235 enum
236 {
237 LONdLON = 0,
238 LONdLAT = 1,
239 LATdLON = 2,
240 LATdLAT = 3
241 };
242
243 atlas_omp_parallel {
244 atlas_omp_for(idx_t jedge = 0; jedge < nedges; ++jedge) {
245 idx_t ip1 = edge2node(jedge, 0);
246 idx_t ip2 = edge2node(jedge, 1);
247 Value pbc = 1. - 2. * is_pole_edge(jedge);
248
249 Value S[2] = {static_cast<Value>(dual_normals(jedge,LON)), static_cast<Value>(dual_normals(jedge,LAT))};
250 Value avg[2];
251
252 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
253 avg[LON] = (vector(ip1, jlev, LON) + pbc * vector(ip2, jlev, LON)) * Value{0.5};
254 avg[LAT] = (vector(ip1, jlev, LAT) + pbc * vector(ip2, jlev, LAT)) * Value{0.5};
255 avgS(jedge, jlev, LONdLON) = S[LON] * deg2rad * avg[LON];
256 // above = 0 at pole because of dual_normals
257 avgS(jedge, jlev, LONdLAT) = S[LAT] * deg2rad * avg[LON];
258 avgS(jedge, jlev, LATdLON) = S[LON] * deg2rad * avg[LAT];
259 // above = 0 at pole because of dual_normals
260 avgS(jedge, jlev, LATdLAT) = S[LAT] * deg2rad * avg[LAT];
261 }
262 }
263
264 atlas_omp_for(idx_t jnode = 0; jnode < nnodes; ++jnode) {
265 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
266 grad(jnode, jlev, LONdLON) = 0.;
267 grad(jnode, jlev, LONdLAT) = 0.;
268 grad(jnode, jlev, LATdLON) = 0.;
269 grad(jnode, jlev, LATdLAT) = 0.;
270 }
271 for (idx_t jedge = 0; jedge < node2edge.cols(jnode); ++jedge) {
272 const idx_t iedge = node2edge(jnode, jedge);
273 if (iedge < nedges) {
274 Value add = node2edge_sign(jnode, jedge);
275 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
276 grad(jnode, jlev, LONdLON) += add * avgS(iedge, jlev, LONdLON);
277 grad(jnode, jlev, LONdLAT) += add * avgS(iedge, jlev, LONdLAT);
278 grad(jnode, jlev, LATdLON) += add * avgS(iedge, jlev, LATdLON);
279 grad(jnode, jlev, LATdLAT) += add * avgS(iedge, jlev, LATdLAT);
280 }
281 }
282 }
283 const Value y = lonlat_deg(jnode, LAT) * deg2rad;
284 const Value metric_y = Value{1.} / (static_cast<Value>(dual_volumes(jnode)) * scale);
285 const Value metric_x = metric_y / std::cos(y);
286 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
287 grad(jnode, jlev, LONdLON) *= metric_x;
288 grad(jnode, jlev, LATdLON) *= metric_x;
289 grad(jnode, jlev, LONdLAT) *= metric_y;
290 grad(jnode, jlev, LATdLAT) *= metric_y;
291 }
292 }
293 }
294 // Fix wrong node2edge_sign for vector quantities
295 for (size_t jedge = 0; jedge < pole_edges_.size(); ++jedge) {
296 const idx_t iedge = pole_edges_[jedge];
297 const idx_t jnode = edge2node(iedge, 1);
298 const Value metric_y = Value{1.} / (static_cast<Value>(dual_volumes(jnode)) * scale);
299 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
300 grad(jnode, jlev, LONdLAT) -= 2. * avgS(iedge, jlev, LONdLAT) * metric_y;
301 grad(jnode, jlev, LATdLAT) -= 2. * avgS(iedge, jlev, LATdLAT) * metric_y;
302 }
303 }
304 };
305 ATLAS_ASSERT( vector_field.datatype() == grad_field.datatype() );
306 switch (vector_field.datatype().kind()) {
307 case (DataType::KIND_REAL32): {
308 dispatch(float{});
309 break;
310 }
311 case (DataType::KIND_REAL64): {
312 dispatch(double{});
313 break;
314 }
315 default:
316 ATLAS_NOTIMPLEMENTED;
317 }
318 }
319
320 // ================================================================================
321
322 void Nabla::divergence(const Field& vector_field, Field& div_field) const {
323
324 auto dispatch = [&](auto value) {
325 using Value = std::decay_t<decltype(value)>;
326
327 const Value radius = fvm_->radius();
328 const Value deg2rad = M_PI / 180.;
329
330 const mesh::Edges& edges = fvm_->mesh().edges();
331 const mesh::Nodes& nodes = fvm_->mesh().nodes();
332
333 const idx_t nnodes = fvm_->node_columns().nb_nodes();
334 const idx_t nedges = fvm_->edge_columns().nb_edges();
335
336 const auto vector =
337 vector_field.levels()
338 ? array::make_view<Value, 3>(vector_field).slice(Range::all(), Range::all(), Range::all())
339 : array::make_view<Value, 2>(vector_field).slice(Range::all(), Range::dummy(), Range::all());
340 auto div = div_field.levels() ? array::make_view<Value, 2>(div_field).slice(Range::all(), Range::all())
341 : array::make_view<Value, 1>(div_field).slice(Range::all(), Range::dummy());
342
343 const idx_t nlev = vector.shape(1);
344 if (div.shape(1) != nlev) {
345 throw_AssertionFailed("div_field should have same number of levels", Here());
346 }
347
348 const auto lonlat_deg = array::make_view<double, 2>(nodes.lonlat());
349 const auto dual_volumes = array::make_view<double, 1>(nodes.field("dual_volumes"));
350 const auto dual_normals = array::make_view<double, 2>(edges.field("dual_normals"));
351 const auto node2edge_sign = array::make_view<double, 2>(nodes.field("node2edge_sign"));
352 const auto edge_flags = array::make_view<int, 1>(edges.flags());
353 auto is_pole_edge = [&](idx_t e) { return Topology::check(edge_flags(e), Topology::POLE); };
354
355 const mesh::Connectivity& node2edge = nodes.edge_connectivity();
356 const mesh::MultiBlockConnectivity& edge2node = edges.node_connectivity();
357
358 array::ArrayT<Value> avgS_arr(nedges, nlev, 2ul);
359 array::ArrayView<Value, 3> avgS = array::make_view<Value, 3>(avgS_arr);
360
361 const Value scale = deg2rad * deg2rad * radius;
362
363 enum
364 {
365 LONdLON = 0,
366 LATdLAT = 1
367 };
368 atlas_omp_parallel {
369 atlas_omp_for(idx_t jedge = 0; jedge < nedges; ++jedge) {
370 Value pbc = 1 - is_pole_edge(jedge);
371
372 idx_t ip1 = edge2node(jedge, 0);
373 idx_t ip2 = edge2node(jedge, 1);
374 Value y1 = lonlat_deg(ip1, LAT) * deg2rad;
375 Value y2 = lonlat_deg(ip2, LAT) * deg2rad;
376
377 Value cosy1, cosy2;
378 if (metric_approach_ == 0) {
379 cosy1 = std::cos(y1) * pbc;
380 cosy2 = std::cos(y2) * pbc;
381 }
382 else {
383 cosy1 = cosy2 = std::cos(0.5 * (y1 + y2)) * pbc;
384 }
385
386 Value S[2] = {static_cast<Value>(dual_normals(jedge, LON)) * deg2rad, static_cast<Value>(dual_normals(jedge, LAT)) * deg2rad};
387 Value avg[2];
388
389 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
390 Value u1 = vector(ip1, jlev, LON);
391 Value u2 = vector(ip2, jlev, LON);
392 Value v1 = vector(ip1, jlev, LAT) * cosy1;
393 Value v2 = vector(ip2, jlev, LAT) * cosy2;
394
395 avg[LON] = (u1 + u2) * 0.5;
396 avg[LAT] = (v1 + v2) * 0.5;
397
398 avgS(jedge, jlev, LONdLON) = avg[LON] * S[LON];
399 avgS(jedge, jlev, LATdLAT) = avg[LAT] * S[LAT];
400 }
401 }
402
403 atlas_omp_for(idx_t jnode = 0; jnode < nnodes; ++jnode) {
404 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
405 div(jnode, jlev) = 0.;
406 }
407 for (idx_t jedge = 0; jedge < node2edge.cols(jnode); ++jedge) {
408 idx_t iedge = node2edge(jnode, jedge);
409 if (iedge < nedges) {
410 Value add = node2edge_sign(jnode, jedge);
411 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
412 div(jnode, jlev) += add * (avgS(iedge, jlev, LONdLON) + avgS(iedge, jlev, LATdLAT));
413 }
414 }
415 }
416 const Value y = lonlat_deg(jnode, LAT) * deg2rad;
417 Value metric = Value{1.} / (static_cast<Value>(dual_volumes(jnode)) * scale * std::cos(y));
418 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
419 div(jnode, jlev) *= metric;
420 }
421 }
422 }
423
424 };
425 ATLAS_ASSERT( vector_field.datatype() == div_field.datatype() );
426 switch (vector_field.datatype().kind()) {
427 case (DataType::KIND_REAL32): {
428 dispatch(float{});
429 break;
430 }
431 case (DataType::KIND_REAL64): {
432 dispatch(double{});
433 break;
434 }
435 default:
436 ATLAS_NOTIMPLEMENTED;
437 }
438 }
439
440 void Nabla::curl(const Field& vector_field, Field& curl_field) const {
441 auto dispatch = [&](auto value) {
442 using Value = std::decay_t<decltype(value)>;
443
444
445 const Value radius = fvm_->radius();
446 const Value deg2rad = M_PI / 180.;
447
448 const mesh::Edges& edges = fvm_->mesh().edges();
449 const mesh::Nodes& nodes = fvm_->mesh().nodes();
450
451 const idx_t nnodes = fvm_->node_columns().nb_nodes();
452 const idx_t nedges = fvm_->edge_columns().nb_edges();
453
454 const auto vector =
455 vector_field.levels()
456 ? array::make_view<Value, 3>(vector_field).slice(Range::all(), Range::all(), Range::all())
457 : array::make_view<Value, 2>(vector_field).slice(Range::all(), Range::dummy(), Range::all());
458 auto curl = curl_field.levels() ? array::make_view<Value, 2>(curl_field).slice(Range::all(), Range::all())
459 : array::make_view<Value, 1>(curl_field).slice(Range::all(), Range::dummy());
460
461 const idx_t nlev = vector.shape(1);
462 if (curl.shape(1) != nlev) {
463 throw_AssertionFailed("curl field should have same number of levels", Here());
464 }
465
466 const auto lonlat_deg = array::make_view<double, 2>(nodes.lonlat());
467 const auto dual_volumes = array::make_view<double, 1>(nodes.field("dual_volumes"));
468 const auto dual_normals = array::make_view<double, 2>(edges.field("dual_normals"));
469 const auto node2edge_sign = array::make_view<double, 2>(nodes.field("node2edge_sign"));
470 const auto edge_flags = array::make_view<int, 1>(edges.flags());
471 auto is_pole_edge = [&](idx_t e) { return Topology::check(edge_flags(e), Topology::POLE); };
472
473
474 const mesh::Connectivity& node2edge = nodes.edge_connectivity();
475 const mesh::MultiBlockConnectivity& edge2node = edges.node_connectivity();
476
477 array::ArrayT<Value> avgS_arr(nedges, nlev, 2ul);
478 array::ArrayView<Value, 3> avgS = array::make_view<Value, 3>(avgS_arr);
479
480 const Value scale = deg2rad * deg2rad * radius;
481
482 enum
483 {
484 LONdLAT = 0,
485 LATdLON = 1
486 };
487
488
489 atlas_omp_parallel {
490 atlas_omp_for(idx_t jedge = 0; jedge < nedges; ++jedge) {
491 idx_t ip1 = edge2node(jedge, 0);
492 idx_t ip2 = edge2node(jedge, 1);
493 Value y1 = lonlat_deg(ip1, LAT) * deg2rad;
494 Value y2 = lonlat_deg(ip2, LAT) * deg2rad;
495
496 Value pbc = 1 - is_pole_edge(jedge);
497 Value cosy1;
498 Value cosy2;
499 if (metric_approach_ == 0) {
500 cosy1 = std::cos(y1) * pbc;
501 cosy2 = std::cos(y2) * pbc;
502 }
503 else {
504 cosy1 = cosy2 = std::cos(Value{0.5} * (y1 + y2)) * pbc;
505 }
506
507 Value S[2] = {static_cast<Value>(dual_normals(jedge, LON)) * deg2rad, static_cast<Value>(dual_normals(jedge, LAT)) * deg2rad};
508 Value avg[2];
509
510 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
511 Value u1 = vector(ip1, jlev, LON) * cosy1;
512 Value u2 = vector(ip2, jlev, LON) * cosy2;
513 Value v1 = vector(ip1, jlev, LAT);
514 Value v2 = vector(ip2, jlev, LAT);
515
516 avg[LON] = (u1 + u2) * Value{0.5};
517 avg[LAT] = (v1 + v2) * Value{0.5};
518
519 avgS(jedge, jlev, LONdLAT) = avg[LON] * S[LAT];
520 avgS(jedge, jlev, LATdLON) = avg[LAT] * S[LON];
521 }
522 }
523
524 atlas_omp_for(idx_t jnode = 0; jnode < nnodes; ++jnode) {
525 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
526 curl(jnode, jlev) = 0.;
527 }
528 for (idx_t jedge = 0; jedge < node2edge.cols(jnode); ++jedge) {
529 idx_t iedge = node2edge(jnode, jedge);
530 if (iedge < nedges) {
531 double add = node2edge_sign(jnode, jedge);
532 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
533 curl(jnode, jlev) += add * (avgS(iedge, jlev, LATdLON) - avgS(iedge, jlev, LONdLAT));
534 }
535 }
536 }
537 Value y = static_cast<Value>(lonlat_deg(jnode, LAT)) * deg2rad;
538 Value metric = Value{1.} / (static_cast<Value>(dual_volumes(jnode)) * scale * std::cos(y));
539 for (idx_t jlev = 0; jlev < nlev; ++jlev) {
540 curl(jnode, jlev) *= metric;
541 }
542 }
543 }
544 };
545 ATLAS_ASSERT( vector_field.datatype() == curl_field.datatype() );
546 switch (vector_field.datatype().kind()) {
547 case (DataType::KIND_REAL32): {
548 dispatch(float{});
549 break;
550 }
551 case (DataType::KIND_REAL64): {
552 dispatch(double{});
553 break;
554 }
555 default:
556 ATLAS_NOTIMPLEMENTED;
557 }
558 }
559
560 void Nabla::laplacian(const Field& scalar, Field& lapl) const {
561 Field grad(fvm_->node_columns().createField(option::name("grad") | option::levels(scalar.levels()) |
562 option::variables(2) | option::datatype(scalar.datatype())));
563 gradient(scalar, grad);
564 if (fvm_->node_columns().halo().size() < 2) {
565 fvm_->node_columns().haloExchange(grad);
566 }
567 divergence(grad, lapl);
568 }
569
570 const FunctionSpace& Nabla::functionspace() const {
571 return fvm_->node_columns();
572 }
573
574 } // namespace fvm
575 } // namespace numerics
576 } // namespace atlas