Debian Codegraph @

src/atlas/util/function/SolidBodyRotation.cc

raw
1 /*
2 * (C) Copyright 2023 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 <cmath>
12
13 #include "atlas/util/Constants.h"
14
15 #include "atlas/util/function/SolidBodyRotation.h"
16
17 namespace atlas {
18
19 namespace util {
20
21 namespace function {
22
23 SolidBodyRotation::SolidBodyRotation(const double beta, const double radius) {
24 sin_beta_ = std::sin(beta * Constants::degreesToRadians());
25 cos_beta_ = std::cos(beta * Constants::degreesToRadians());
26 radius_ = radius;
27 }
28
29 void SolidBodyRotation::wind(const double lon, const double lat, double& u, double& v) const {
30 double x = lon * Constants::degreesToRadians();
31 double y = lat * Constants::degreesToRadians();
32 double cos_x = std::cos(x);
33 double cos_y = std::cos(y);
34 double sin_x = std::sin(x);
35 double sin_y = std::sin(y);
36 u = cos_y * cos_beta_ + cos_x * sin_y * sin_beta_;
37 v = -sin_x * sin_beta_;
38 }
39
40 double SolidBodyRotation::u(const double lon, const double lat) const {
41 double x = lon * Constants::degreesToRadians();
42 double y = lat * Constants::degreesToRadians();
43 double cos_x = std::cos(x);
44 double cos_y = std::cos(y);
45 double sin_y = std::sin(y);
46 return cos_y * cos_beta_ + cos_x * sin_y * sin_beta_;
47 }
48
49 double SolidBodyRotation::v(const double lon, const double lat) const {
50 double x = lon * Constants::degreesToRadians();
51 double sin_x = std::sin(x);
52 return -sin_x * sin_beta_;
53 }
54
55 void SolidBodyRotation::vordiv(const double lon, const double lat, double& vor, double& div) const {
56 double x = lon * Constants::degreesToRadians();
57 double y = lat * Constants::degreesToRadians();
58
59 double cos_x = std::cos(x);
60 double cos_y = std::cos(y);
61 double sin_x = std::sin(x);
62 double sin_y = std::sin(y);
63
64 // Divergence = 1./(R*cos(y)) * ( d/dx( u ) + d/dy( v * cos(y) ) )
65 // Vorticity = 1./(R*cos(y)) * ( d/dx( v ) - d/dy( u * cos(y) ) )
66 double ddx_u = -sin_x * sin_y * sin_beta_;
67 double ddy_cosy_v = (-sin_x * sin_beta_) * (-sin_y);
68 double ddx_v = -cos_x * sin_beta_;
69 double ddy_cosy_u =
70 2 * cos_y * (-sin_y) * cos_beta_ + (-sin_y) * cos_x * sin_y * sin_beta_ + cos_y * cos_x * cos_y * sin_beta_;
71
72 double metric = 1. / (radius_ * cos_y);
73
74 div = metric * (ddx_u + ddy_cosy_v);
75 vor = metric * (ddx_v - ddy_cosy_u);
76 }
77
78 double SolidBodyRotation::vorticity(const double lon, const double lat) const {
79 double x = lon * Constants::degreesToRadians();
80 double y = lat * Constants::degreesToRadians();
81
82 double cos_x = std::cos(x);
83 double cos_y = std::cos(y);
84 double sin_y = std::sin(y);
85
86 // Vorticity = 1./(R*cos(y)) * ( d/dx( v ) - d/dy( u * cos(y) ) )
87 double ddx_v = -cos_x * sin_beta_;
88 double ddy_cosy_u =
89 2 * cos_y * (-sin_y) * cos_beta_ + (-sin_y) * cos_x * sin_y * sin_beta_ + cos_y * cos_x * cos_y * sin_beta_;
90
91 double metric = 1. / (radius_ * cos_y);
92
93 return metric * (ddx_v - ddy_cosy_u);
94 }
95
96 double SolidBodyRotation::divergence(const double lon, const double lat) const {
97 double x = lon * Constants::degreesToRadians();
98 double y = lat * Constants::degreesToRadians();
99
100 double cos_y = std::cos(y);
101 double sin_x = std::sin(x);
102 double sin_y = std::sin(y);
103
104 // Divergence = 1./(R*cos(y)) * ( d/dx( u ) + d/dy( v * cos(y) ) )
105 double ddx_u = -sin_x * sin_y * sin_beta_;
106 double ddy_cosy_v = (-sin_x * sin_beta_) * (-sin_y);
107
108 double metric = 1. / (radius_ * cos_y);
109
110 return metric * (ddx_u + ddy_cosy_v);
111 }
112
113 double SolidBodyRotation::windMagnitude(const double lon, const double lat) const {
114 return std::sqrt(windMagnitudeSquared(lon, lat));
115 }
116
117 double SolidBodyRotation::windMagnitudeSquared(const double lon, const double lat) const {
118 double u, v;
119 wind(lon, lat, u, v);
120 return u * u + v * v;
121 }
122
123 void SolidBodyRotation::windMagnitudeSquaredGradient(const double lon, const double lat, double& dfdx, double& dfdy) const {
124 double x = lon * Constants::degreesToRadians();
125 double y = lat * Constants::degreesToRadians();
126
127 double cos_x = std::cos(x);
128 double cos_y = std::cos(y);
129 double sin_x = std::sin(x);
130 double sin_y = std::sin(y);
131
132 double metric_y = 1. / radius_;
133 double metric_x = metric_y / cos_y;
134
135 double u = cos_y * cos_beta_ + cos_x * sin_y * sin_beta_;
136 double v = -sin_x * sin_beta_;
137 double dudx = metric_x * (-sin_x * sin_y * sin_beta_);
138 double dudy = metric_y * (-sin_y * cos_beta_ + cos_x * cos_y * sin_beta_);
139 double dvdx = metric_x * (-cos_x * sin_beta_);
140 double dvdy = metric_y * (0.);
141 dfdx = 2 * u * dudx + 2 * v * dvdx;
142 dfdy = 2 * u * dudy + 2 * v * dvdy;
143 }
144
145 } // namespace function
146
147 } // namespace util
148
149 } // namespace atlas