ARTS 2.5.4 (git: bcd8c674)
zeemandata.cc
Go to the documentation of this file.
1/* Copyright (C) 2018 Richard Larsson
2
3 This program is free software; you can redistribute it and/or modify it
4 under the terms of the GNU General Public License as published by the
5 Free Software Foundation; either version 2, or (at your option) any
6 later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12
13 You should have received a copy of the GNU General Public License
14 along with this program; if not, write to the Free Software
15 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
16 USA. */
17
29#include "zeemandata.h"
30
31#include "debug.h"
32#include "species_info.h"
33
35 const Numeric& GS,
36 const Numeric& GL) noexcept {
37 if (Quantum::Number::vamdcCheck(qns, Quantum::Number::VAMDC::hunda) and
38 qns.has(QuantumNumberType::Omega,
39 QuantumNumberType::J,
40 QuantumNumberType::Lambda,
41 QuantumNumberType::S)) {
42 auto& Omega = qns[QuantumNumberType::Omega];
43 auto& J = qns[QuantumNumberType::J];
44 auto& Lambda = qns[QuantumNumberType::Lambda];
45 auto& S = qns[QuantumNumberType::S];
47 Omega.upp(), J.upp(), Lambda.upp(), S.upp(), GS, GL),
49 Omega.low(), J.low(), Lambda.low(), S.low(), GS, GL)};
50 }
51
52 if (Quantum::Number::vamdcCheck(qns, Quantum::Number::VAMDC::hundb) and
54 QuantumNumberType::J,
55 QuantumNumberType::Lambda,
56 QuantumNumberType::S)) {
57 auto& N = qns[QuantumNumberType::N];
58 auto& J = qns[QuantumNumberType::J];
59 auto& Lambda = qns[QuantumNumberType::Lambda];
60 auto& S = qns[QuantumNumberType::S];
61 return {
62 Zeeman::SimpleGCaseB(N.upp(), J.upp(), Lambda.upp(), S.upp(), GS, GL),
63 Zeeman::SimpleGCaseB(N.low(), J.low(), Lambda.low(), S.low(), GS, GL)};
64 }
65
66 return {NAN, NAN};
67}
68
71 const Numeric GS = get_lande_spin_constant(qid.Species());
73 return SimpleG(qid.val, GS, GL);
74}
75
77 Rational N,
78 Numeric GS,
79 Numeric GR,
80 Numeric GLE,
81 Numeric B,
82 Numeric D,
83 Numeric H,
84 Numeric gB,
85 Numeric gD,
86 Numeric gH,
87 Numeric lB,
88 Numeric lD,
89 Numeric lH) {
91 using std::atan2, std::cos, std::sin;
92
93 if (J.isUndefined() or N.isUndefined()) return NAN;
94 if (J == 0) return 0;
95
96 auto nom = (lB + lD * (J * J + J + 1) + lH * pow2(J * J + J + 1)) *
97 (2 * sqrt(J * J + J) / (2 * J + 1));
98
99 auto denom =
100 B * J * (J - 1) - D * pow2(J * (J - 1)) + H * pow3(J * (J - 1)) +
101 (gB + gD * J * (J - 1) + gH * pow2(J * (J - 1))) * (J - 1) +
102 (lB + lD * J * (J - 1) + lH * pow2(J * (J - 1))) *
103 (2. / 3. - 2 * J / (2 * J + 1)) -
104 (B * (J + 2) * (J + 1) - D * pow2((J + 2) * (J + 1)) +
105 H * pow3((J + 2) * (J + 1)) -
106 (gB + gD * (J + 2) * (J + 1) + gH * pow2((J + 2) * (J + 1))) * (J + 2) +
107 (lB + lD * (J + 2) * (J + 1) + lH * pow2((J + 2) * (J + 1))) *
108 (2. / 3. - 2 * (J + 1) / (2 * J + 1)));
109
110 auto phi = atan2(2 * nom, denom) / 2;
111
112 if (J == N) return (GS + GR) / (J * (J + 1)) - GR;
113 if (J < N)
114 return (GS + GR) * (pow2(cos(phi)) / J - pow2(sin(phi)) / (J + 1)) +
115 2 * GLE * cos(2 * phi) / (2 * J + 1) - GR;
116 return (GS + GR) * (pow2(sin(phi)) / J - pow2(cos(phi)) / (J + 1)) -
117 2 * GLE * cos(2 * phi) / (2 * J + 1) - GR;
118}
119
121 Rational j,
122 Numeric gperp,
123 Numeric gpara) {
124 using Constant::pow2;
125 if (k.isUndefined() or j.isUndefined() or j == 0) return 0;
126 return gperp + (gperp + gpara) * (pow2(k) / (j * (j + 1)));
127}
128
131 if (qid.Isotopologue() == "O2-66") {
132 if (qid.val.has(QuantumNumberType::J,
134 QuantumNumberType::v1)) {
135 if (qid.val[QuantumNumberType::v1].low() == 0 and
136 qid.val[QuantumNumberType::v1].upp() == 0) {
137 constexpr Numeric GS = 2.002084;
138 constexpr Numeric GLE = 2.77e-3;
139 constexpr Numeric GR = -1.16e-4;
140 constexpr Numeric B = 43100.44276e6;
141 constexpr Numeric D = 145.1271e3;
142 constexpr Numeric H = 49e-3;
143 constexpr Numeric lB = 59501.3438e6;
144 constexpr Numeric lD = 58.3680e3;
145 constexpr Numeric lH = 290.8e-3;
146 constexpr Numeric gB = -252.58634e6;
147 constexpr Numeric gD = -243.42;
148 constexpr Numeric gH = -1.46e-3;
149
150 auto JU = qid.val[QuantumNumberType::J].upp();
151 auto NU = qid.val[QuantumNumberType::N].upp();
153 JU, NU, GS, GR, GLE, B, D, H, gB, gD, gH, lB, lD, lH);
154 auto JL = qid.val[QuantumNumberType::J].low();
155 auto NL = qid.val[QuantumNumberType::N].low();
157 JL, NL, GS, GR, GLE, B, D, H, gB, gD, gH, lB, lD, lH);
158 return Model(gu, gl);
159 }
160 }
161 } else if (qid.Isotopologue() == "O2-68") {
162 if (qid.val.has(QuantumNumberType::J,
164 QuantumNumberType::v1)) {
165 if (qid.val[QuantumNumberType::v1].low() == 0 and
166 qid.val[QuantumNumberType::v1].upp() == 0) {
167 constexpr Numeric GS = 2.002025;
168 constexpr Numeric GLE = 2.813e-3;
169 constexpr Numeric GR = -1.26e-4;
170 constexpr Numeric B = 40707.38657e6;
171 constexpr Numeric D = 129.4142e3;
172 constexpr Numeric H = 0;
173 constexpr Numeric lB = 59499.0375e6;
174 constexpr Numeric lD = 54.9777e3;
175 constexpr Numeric lH = 272.1e-3;
176 constexpr Numeric gB = -238.51530e6;
177 constexpr Numeric gD = -217.77;
178 constexpr Numeric gH = -1.305e-3;
179
180 auto JU = qid.val[QuantumNumberType::J].upp();
181 auto NU = qid.val[QuantumNumberType::N].upp();
183 JU, NU, GS, GR, GLE, B, D, H, gB, gD, gH, lB, lD, lH);
184 auto JL = qid.val[QuantumNumberType::J].low();
185 auto NL = qid.val[QuantumNumberType::N].low();
187 JL, NL, GS, GR, GLE, B, D, H, gB, gD, gH, lB, lD, lH);
188 return Model(gu, gl);
189 }
190 }
191 } else if (qid.Isotopologue() == "CO-26") {
192 constexpr Numeric gperp =
193 -0.2689 /
194 Constant::mass_ratio_electrons_per_proton; // Flygare and Benson 1971
195
196 return Model(gperp, gperp);
197 } else if (qid.Isotopologue() == "OCS-622") {
198 constexpr Numeric gperp =
199 -.02889 /
200 Constant::mass_ratio_electrons_per_proton; // Flygare and Benson 1971
201 constexpr Numeric gpara =
202 0 /
203 Constant::mass_ratio_electrons_per_proton; // Flygare and Benson 1971
204 if (qid.val.has(QuantumNumberType::J, QuantumNumberType::Ka)) {
205 auto JU = qid.val[QuantumNumberType::J].upp();
206 auto KU = qid.val[QuantumNumberType::Ka].upp();
207 auto JL = qid.val[QuantumNumberType::J].low();
208 auto KL = qid.val[QuantumNumberType::Ka].low();
209
210 return Model(closed_shell_trilinear(KU, JU, gperp, gpara),
211 closed_shell_trilinear(KL, JL, gperp, gpara));
212 }
213 } else if (qid.Isotopologue() == "OCS-624") {
214 constexpr Numeric gperp =
215 -.0285 /
216 Constant::mass_ratio_electrons_per_proton; // Flygare and Benson 1971
217 constexpr Numeric gpara =
218 -.061 /
219 Constant::mass_ratio_electrons_per_proton; // Flygare and Benson 1971
220
221 if (qid.val.has(QuantumNumberType::J, QuantumNumberType::Ka)) {
222 auto JU = qid.val[QuantumNumberType::J].upp();
223 auto KU = qid.val[QuantumNumberType::Ka].upp();
224 auto JL = qid.val[QuantumNumberType::J].low();
225 auto KL = qid.val[QuantumNumberType::Ka].low();
226
227 return Model(closed_shell_trilinear(KU, JU, gperp, gpara),
228 closed_shell_trilinear(KL, JL, gperp, gpara));
229 }
230 } else if (qid.Isotopologue() == "CO2-626") {
231 constexpr Numeric gperp =
232 -.05508 /
233 Constant::mass_ratio_electrons_per_proton; // Flygare and Benson 1971
234 constexpr Numeric gpara =
235 0 /
236 Constant::mass_ratio_electrons_per_proton; // Flygare and Benson 1971
237
238 if (qid.val.has(QuantumNumberType::J, QuantumNumberType::Ka)) {
239 auto JU = qid.val[QuantumNumberType::J].upp();
240 auto KU = qid.val[QuantumNumberType::Ka].upp();
241 auto JL = qid.val[QuantumNumberType::J].low();
242 auto KL = qid.val[QuantumNumberType::Ka].low();
243
244 return Model(closed_shell_trilinear(KU, JU, gperp, gpara),
245 closed_shell_trilinear(KL, JL, gperp, gpara));
246 }
247 }
248
249 // Set to zero otherwise as we practically say "there's no Zeeman effect" then
250 return Model(0, 0);
251}
252
254 Model m = GetAdvancedModel(qid);
255 if (m.empty()) m = GetSimpleModel(qid);
256 *this = m;
257}
258
260 return Eigen::Vector3d(v, u, w).normalized();
261}
262
264 using std::cos;
265 using std::sin;
266 return Eigen::Vector3d(cos(a) * sin(z), sin(a) * sin(z), cos(z));
267}
268
269Eigen::Vector3d ev_xyz_by_za_local(Numeric z, Numeric a) {
270 using std::cos;
271 using std::sin;
272 return Eigen::Vector3d(cos(a) * cos(z), sin(a) * cos(z), -sin(z));
273}
274
276 Numeric u, Numeric v, Numeric w, Numeric z, Numeric a) noexcept {
277 Derived output;
278
279 // If there is no magnetic field, bailout quickly
280 output.H = std::hypot(u, v, w);
281 if (output.H == 0) {
282 output = FromPreDerived(0, 0, 0);
283 } else {
284 // XYZ vectors normalized
285 const Eigen::Vector3d n = los_xyz_by_za_local(z, a);
286 const Eigen::Vector3d ev = ev_xyz_by_za_local(z, a);
287 const Eigen::Vector3d nH = los_xyz_by_uvw_local(u, v, w);
288
289 // Normalized vector (which are also the magnetic field derivatives)
290 output.dH_dv = nH[0];
291 output.dH_du = nH[1];
292 output.dH_dw = nH[2];
293
294 // Compute theta (and its derivatives if possible)
295 const Numeric cos_theta = n.dot(nH);
296 const Numeric sin_theta = std::sqrt(1 - Constant::pow2(cos_theta));
297 output.theta = std::acos(cos_theta);
298 if (sin_theta not_eq 0) {
299 const Eigen::Vector3d dtheta =
300 (nH * cos_theta - n) / (output.H * sin_theta);
301 output.dtheta_dv = dtheta[0];
302 output.dtheta_du = dtheta[1];
303 output.dtheta_dw = dtheta[2];
304 } else {
305 output.dtheta_dv = 0;
306 output.dtheta_du = 0;
307 output.dtheta_dw = 0;
308 }
309
310 // Compute eta (and its derivatives if possible)
311 const Eigen::Vector3d inplane = nH - nH.dot(n) * n;
312 const Numeric y = ev.cross(inplane).dot(n);
313 const Numeric x = ev.dot(inplane);
314 output.eta = std::atan2(y, x);
315 if (x not_eq 0 or y not_eq 0) {
316 const Eigen::Vector3d deta =
317 n.cross(nH) / (output.H * (Constant::pow2(x) + Constant::pow2(y)));
318 output.deta_dv = deta[0];
319 output.deta_du = deta[1];
320 output.deta_dw = deta[2];
321 } else {
322 output.deta_dv = 0;
323 output.deta_du = 0;
324 output.deta_dw = 0;
325 }
326 }
327
328 return output;
329}
330
331namespace Zeeman {
333 Rational Jl,
335 Index n) const ARTS_NOEXCEPT {
337 using Constant::pow2;
338
339 auto ml = Ml(Ju, Jl, type, n);
340 auto mu = Mu(Ju, Jl, type, n);
341 auto dm = Rational(dM(type));
342 return PolarizationFactor(type) *
343 pow2(wigner3j(Jl, Rational(1), Ju, ml, -dm, -mu));
344}
345
346std::ostream& operator<<(std::ostream& os, const Model& m) {
347 os << m.mdata.gu << ' ' << m.mdata.gl;
348 return os;
349}
350
351std::istream& operator>>(std::istream& is, Model& m) {
352 is >> double_imanip() >> m.mdata.gu >> m.mdata.gl;
353 return is;
354}
355
356std::ostream& operator<<(bofstream& bof, const Model& m) {
357 bof << m.mdata.gu << m.mdata.gl;
358 return bof;
359}
360
361std::istream& operator>>(bifstream& bif, Model& m) {
362 bif >> m.mdata.gu >> m.mdata.gl;
363 return bif;
364}
365
367 const Numeric ST = std::sin(theta), CT = std::cos(theta), ST2 = ST * ST,
368 CT2 = CT * CT, ST2C2E = ST2 * std::cos(2 * eta),
369 ST2S2E = ST2 * std::sin(2 * eta);
370
373 1 + CT2, ST2C2E, ST2S2E, 2 * CT, 4 * CT, 2 * ST2S2E, -2 * ST2C2E);
374 pv.pi =
375 PolarizationVector(ST2, -ST2C2E, -ST2S2E, 0, 0, -2 * ST2S2E, 2 * ST2C2E);
377 1 + CT2, ST2C2E, ST2S2E, -2 * CT, -4 * CT, 2 * ST2S2E, -2 * ST2C2E);
378 return pv;
379}
380
382 const Numeric eta) noexcept {
383 const Numeric ST = std::sin(theta), CT = std::cos(theta),
384 C2E = std::cos(2 * eta), S2E = std::sin(2 * eta), dST = CT,
385 dST2 = 2 * ST * dST, dCT = -ST, dST2C2E = dST2 * C2E,
386 dST2S2E = dST2 * S2E, dCT2 = 2 * CT * dCT;
387
390 dCT2, dST2C2E, dST2S2E, 2 * dCT, 4 * dCT, 2 * dST2S2E, -2 * dST2C2E);
392 dST2, -dST2C2E, -dST2S2E, 0, 0, -2 * dST2S2E, 2 * dST2C2E);
394 dCT2, dST2C2E, dST2S2E, -2 * dCT, -4 * dCT, 2 * dST2S2E, -2 * dST2C2E);
395 return pv;
396}
397
399 Numeric eta) noexcept {
400 const Numeric ST = std::sin(theta), ST2 = ST * ST, C2E = std::cos(2 * eta),
401 S2E = std::sin(2 * eta), dST2C2E = -2 * ST2 * S2E,
402 dST2S2E = 2 * ST2 * C2E;
403
405 pv.sm =
406 PolarizationVector(0, dST2C2E, dST2S2E, 0, 0, 2 * dST2S2E, -2 * dST2C2E);
408 0, -dST2C2E, -dST2S2E, 0, 0, -2 * dST2S2E, 2 * dST2C2E);
409 pv.sp =
410 PolarizationVector(0, dST2C2E, dST2S2E, 0, 0, 2 * dST2S2E, -2 * dST2C2E);
411 return pv;
412}
413
414#pragma GCC diagnostic push
415#pragma GCC diagnostic ignored "-Wreturn-type"
417 Polarization type) noexcept {
418 switch (type) {
420 return data.sm;
421 case Polarization::Pi:
422 return data.pi;
424 return data.sp;
426 return data.sm;
427 }
428}
429#pragma GCC diagnostic pop
430
432 const ComplexVectorView& abs,
433 const PolarizationVector& polvec,
434 const bool do_phase) ARTS_NOEXCEPT {
435 ARTS_ASSERT(pm.NumberOfZenithAngles() == 1)
436 ARTS_ASSERT(pm.NumberOfAzimuthAngles() == 1)
437 ARTS_ASSERT(pm.NumberOfFrequencies() == abs.nelem())
438 ARTS_ASSERT(do_phase ? pm.NumberOfNeededVectors() == 7
439 : pm.NumberOfNeededVectors() == 4)
440
441 const auto& pol_real = polvec.attenuation();
442 const auto& pol_imag = polvec.dispersion();
443
444 MatrixView out = pm.Data()(0, 0, joker, joker);
445 MapToEigen(out).leftCols<4>().noalias() += MapToEigen(abs.real()) * pol_real;
446 if (do_phase)
447 MapToEigen(out).rightCols<3>().noalias() +=
448 MapToEigen(abs.imag()) * pol_imag;
449}
450
452 const ComplexVectorView& abs,
453 const ComplexVectorView& dabs,
454 const PolarizationVector& polvec,
455 const PolarizationVector& dpolvec_dtheta,
456 const PolarizationVector& dpolvec_deta,
457 const Numeric dH,
458 const Numeric dt,
459 const Numeric de,
460 const bool do_phase) ARTS_NOEXCEPT {
461 ARTS_ASSERT(pm.NumberOfZenithAngles() == 1)
462 ARTS_ASSERT(pm.NumberOfAzimuthAngles() == 1)
463 ARTS_ASSERT(pm.NumberOfFrequencies() == abs.nelem())
464 ARTS_ASSERT(do_phase ? pm.NumberOfNeededVectors() == 7
465 : pm.NumberOfNeededVectors() == 4)
466
467 const auto& pol_real = polvec.attenuation();
468 const auto& pol_imag = polvec.dispersion();
469 auto da_r =
470 (dt * dpolvec_dtheta.attenuation() + de * dpolvec_deta.attenuation());
471 auto da_i =
472 (dt * dpolvec_dtheta.dispersion() + de * dpolvec_deta.dispersion());
473
474 MatrixView out = pm.Data()(0, 0, joker, joker);
475 MapToEigen(out).leftCols<4>().noalias() +=
476 dH * MapToEigen(dabs.real()) * pol_real + MapToEigen(abs.real()) * da_r;
477 if (do_phase)
478 MapToEigen(out).rightCols<3>().noalias() +=
479 dH * MapToEigen(dabs.imag()) * pol_imag + MapToEigen(abs.imag()) * da_i;
480}
481} // namespace Zeeman
The ComplexVectorView class.
The MatrixView class.
Definition: matpackI.h:1182
A list of many quantum numbers. Should always remain sorted.
Implements rational numbers to work with other ARTS types.
Definition: rational.h:43
constexpr bool isUndefined() const noexcept
Is the object not defined.
Definition: rational.h:93
Main Zeeman Model.
Definition: zeemandata.h:296
SplittingData mdata
Definition: zeemandata.h:298
Numeric Strength(Rational Ju, Rational Jl, Polarization type, Index n) const ARTS_NOEXCEPT
Gives the strength of one subline of a given polarization.
Definition: zeemandata.cc:332
bool empty() const noexcept
Returns true if the Model represents no Zeeman effect.
Definition: zeemandata.h:320
constexpr Model(SplittingData gs={NAN, NAN}) noexcept
Default copy/init of Model from its only private variable.
Definition: zeemandata.h:302
Polarization vector for Zeeman Propagation Matrix.
Definition: zeemandata.h:422
Binary output file stream class.
Definition: bifstream.h:43
Binary output file stream class.
Definition: bofstream.h:42
Input manipulator class for doubles to enable nan and inf parsing.
Definition: double_imanip.h:42
Helper macros for debugging.
#define ARTS_NOEXCEPT
Definition: debug.h:80
#define ARTS_ASSERT(condition,...)
Definition: debug.h:83
#define abs(x)
#define dabs(x)
MatrixViewMap MapToEigen(Tensor3View &A, const Index &i)
Definition: lin_alg.cc:684
NUMERIC Numeric
The type to use for all floating point numbers.
Definition: matpack.h:33
INDEX Index
The type to use for all integer numbers and indices.
Definition: matpack.h:39
const Joker joker
constexpr auto pow2(T x) noexcept -> decltype(x *x)
power of two
Definition: constants.h:66
constexpr auto pow3(T x) noexcept -> decltype(pow2(x) *x)
power of three
Definition: constants.h:72
bool vamdcCheck(const ValueList &l, VAMDC type) ARTS_NOEXCEPT
Implements Zeeman modeling.
Definition: zeemandata.cc:331
std::ostream & operator<<(std::ostream &os, const Model &m)
Definition: zeemandata.cc:346
constexpr Index dM(Polarization type) noexcept
Gives the change of M given a polarization type.
Definition: zeemandata.h:52
constexpr Numeric SimpleGCaseB(Rational N, Rational J, Rational Lambda, Rational S, Numeric GS, Numeric GL) noexcept
Computes the Zeeman splitting coefficient.
Definition: zeemandata.h:226
const PolarizationVector & SelectPolarization(const AllPolarizationVectors &data, Polarization type) noexcept
Selects the polarization vector depending on polarization type.
Definition: zeemandata.cc:416
constexpr Derived FromPreDerived(Numeric H, Numeric theta, Numeric eta) noexcept
Sets Derived from predefined Derived parameters.
Definition: zeemandata.h:606
constexpr Numeric SimpleGCaseA(Rational Omega, Rational J, Rational Lambda, Rational Sigma, Numeric GS, Numeric GL) noexcept
Computes the Zeeman splitting coefficient.
Definition: zeemandata.h:262
constexpr Numeric PolarizationFactor(Polarization type) noexcept
The renormalization factor of a polarization type.
Definition: zeemandata.h:198
Derived FromGrids(Numeric u, Numeric v, Numeric w, Numeric z, Numeric a) noexcept
Computes the derived plane from ARTS grids.
Definition: zeemandata.cc:275
AllPolarizationVectors AllPolarization_deta(Numeric theta, Numeric eta) noexcept
The derivative of AllPolarization wrt eta.
Definition: zeemandata.cc:398
AllPolarizationVectors AllPolarization_dtheta(Numeric theta, const Numeric eta) noexcept
The derivative of AllPolarization wrt theta.
Definition: zeemandata.cc:381
Polarization
Zeeman polarization selection.
Definition: zeemandata.h:44
Model GetAdvancedModel(const QuantumIdentifier &qid) ARTS_NOEXCEPT
Returns an advanced Zeeman model.
Definition: zeemandata.cc:129
void dsum(PropagationMatrix &pm, const ComplexVectorView &abs, const ComplexVectorView &dabs, const PolarizationVector &polvec, const PolarizationVector &dpolvec_dtheta, const PolarizationVector &dpolvec_deta, const Numeric dH, const Numeric dt, const Numeric de, const bool do_phase) ARTS_NOEXCEPT
Sums the Zeeman components derivatives into a propagation matrix.
Definition: zeemandata.cc:451
void sum(PropagationMatrix &pm, const ComplexVectorView &abs, const PolarizationVector &polvec, const bool do_phase) ARTS_NOEXCEPT
Sums the Zeeman components into a propagation matrix.
Definition: zeemandata.cc:431
std::istream & operator>>(std::istream &is, Model &m)
Definition: zeemandata.cc:351
Model GetSimpleModel(const QuantumIdentifier &qid) ARTS_NOEXCEPT
Returns a simple Zeeman model.
Definition: zeemandata.cc:69
constexpr Rational Ml(Rational Ju, Rational Jl, Polarization type, Index n) noexcept
Gives the lower state M value at an index.
Definition: zeemandata.h:180
AllPolarizationVectors AllPolarization(Numeric theta, Numeric eta) noexcept
Computes the polarization of each polarization type.
Definition: zeemandata.cc:366
constexpr Rational Mu(Rational Ju, Rational Jl, Polarization type, Index n) noexcept
Gives the upper state M value at an index.
Definition: zeemandata.h:159
#define u
#define v
#define w
#define a
Numeric sqrt(const Rational r)
Square root.
Definition: rational.h:728
#define N
Definition: rng.cc:164
Numeric get_lande_spin_constant(const Species::Species species) noexcept
Get the Lande spin constant.
Definition: species_info.cc:30
Numeric get_lande_lambda_constant() noexcept
Get the Lande Lambda constant.
Definition: species_info.cc:44
Some molecular constants.
A logical struct for global quantum numbers with species identifiers.
PolarizationVector for each Polarization.
Definition: zeemandata.h:480
Contains derived values useful for Zeeman calculations.
Definition: zeemandata.h:560
Numeric deta_dv
Definition: zeemandata.h:562
Numeric dtheta_du
Definition: zeemandata.h:561
Numeric dtheta_dw
Definition: zeemandata.h:561
Numeric dtheta_dv
Definition: zeemandata.h:561
Numeric deta_du
Definition: zeemandata.h:562
Numeric deta_dw
Definition: zeemandata.h:562
Main storage for Zeeman splitting coefficients.
Definition: zeemandata.h:285
Numeric wigner3j(const Rational j1, const Rational j2, const Rational j3, const Rational m1, const Rational m2, const Rational m3)
Wigner 3J symbol.
Eigen::Vector3d los_xyz_by_za_local(Numeric z, Numeric a)
Definition: zeemandata.cc:263
Numeric case_b_g_coefficient_o2(Rational J, Rational N, Numeric GS, Numeric GR, Numeric GLE, Numeric B, Numeric D, Numeric H, Numeric gB, Numeric gD, Numeric gH, Numeric lB, Numeric lD, Numeric lH)
Definition: zeemandata.cc:76
Zeeman::SplittingData SimpleG(const Quantum::Number::ValueList &qns, const Numeric &GS, const Numeric &GL) noexcept
Definition: zeemandata.cc:34
constexpr Numeric closed_shell_trilinear(Rational k, Rational j, Numeric gperp, Numeric gpara)
Definition: zeemandata.cc:120
Eigen::Vector3d ev_xyz_by_za_local(Numeric z, Numeric a)
Definition: zeemandata.cc:269
Eigen::Vector3d los_xyz_by_uvw_local(Numeric u, Numeric v, Numeric w)
Definition: zeemandata.cc:259
Headers and class definition of Zeeman modeling.