14#include "matpack_data.h"
21#include "gsl_gauss_legendre.h"
44 Vector& za_grid_weights,
46 const Index& N_za_grid,
47 const Index& N_aa_grid,
48 const String& za_grid_type,
53 else if (N_aa_grid < 1) {
55 os <<
"N_aa_grid must be > 0 (even for 1D).";
56 throw std::runtime_error(os.str());
62 if (N_za_grid % 2 == 1) {
64 os <<
"N_za_grid must be even.";
65 throw runtime_error(os.str());
68 Index nph = N_za_grid / 2;
71 za_grid.resize(N_za_grid);
73 za_grid_weights.resize(N_za_grid);
76 if (za_grid_type ==
"double_gauss") {
84 GSL::Integration::GaussLegendre(xtemp, wtemp, nph);
93 x[xtemp.nelem() - 1] = acos((xtemp[0] + 1) / 2) /
DEG2RAD;
94 w[wtemp.nelem() - 1] = wtemp[0] / 2;
96 for (Index i = 0; i < xtemp.nelem() - 1; i++) {
97 x[i] = acos((xtemp[xtemp.nelem() - 1 - i] + 1) / 2.) /
DEG2RAD;
98 x[xtemp.nelem() + i] = acos(1 - (xtemp[i + 1] + 1) / 2.) /
DEG2RAD;
100 w[i] = wtemp[wtemp.nelem() - 1 - i] / 2;
101 w[wtemp.nelem() + i] = wtemp[i + 1] / 2;
104 for (Index i = 0; i < xtemp.nelem(); i++) {
105 x[i] = acos((xtemp[xtemp.nelem() - 1 - i] + 1) / 2.) /
DEG2RAD;
106 x[xtemp.nelem() + i] = acos(1 - (xtemp[i] + 1) / 2.) /
DEG2RAD;
108 w[i] = wtemp[wtemp.nelem() - 1 - i] / 2;
109 w[wtemp.nelem() + i] = wtemp[i] / 2;
113 for (Index i = 0; i < nph; i++) {
117 za_grid[za_grid.nelem() - 1 - i] = 180 - x[i];
120 za_grid_weights[i] =
w[i];
121 za_grid_weights[za_grid_weights.nelem() - 1 - i] =
w[i];
124 }
else if (za_grid_type ==
"linear") {
129 for (Index i = 0; i < N_za_grid; i++) {
130 za_grid[i] = (x[i] + 1) * 90.;
134 za_grid_weights[i] =
w[i] * sin(za_grid[i] *
DEG2RAD);
136 }
else if (za_grid_type ==
"linear_mu") {
145 za_grid_temp.resize(x.nelem());
147 for (Index i = 0; i < N_za_grid; i++) {
148 za_grid_temp[i] = acos(x[i]) /
DEG2RAD;
152 za_grid = reverse(za_grid_temp);
153 za_grid_weights = reverse(
w);
157 os <<
"The selected grid type is not implemented";
158 throw std::runtime_error(os.str());
164 if (za_grid[0] < 0) {
168 if (za_grid[za_grid.nelem() - 1] > 180) {
169 za_grid[za_grid.nelem() - 1] = 180.;
175 const Vector& p_grid,
176 const Tensor4& irradiance_field,
177 const Tensor3& specific_heat_capacity,
181 heating_rates.resize(irradiance_field.nbooks(),
182 irradiance_field.npages(),
183 irradiance_field.nrows());
195 for (Index
b = 1;
b < irradiance_field.nbooks() - 1;
b++) {
196 for (Index p = 0; p < irradiance_field.npages(); p++) {
197 for (Index r = 0; r < irradiance_field.nrows(); r++) {
198 net_flux_b = (irradiance_field(
b - 1, p, r, 0) +
199 irradiance_field(
b - 1, p, r, 1));
200 net_flux_t = (irradiance_field(
b + 1, p, r, 0) +
201 irradiance_field(
b + 1, p, r, 1));
203 heating_rates(
b, p, r) = (net_flux_t - net_flux_b) /
204 (p_grid[
b + 1] - p_grid[
b - 1]) * g0 /
205 specific_heat_capacity(
b, p, r);
210 idx = irradiance_field.nbooks();
213 for (Index p = 0; p < irradiance_field.npages(); p++) {
214 for (Index r = 0; r < irradiance_field.nrows(); r++) {
217 (irradiance_field(0, p, r, 0) + irradiance_field(0, p, r, 1));
219 (irradiance_field(1, p, r, 0) + irradiance_field(1, p, r, 1));
221 (irradiance_field(2, p, r, 0) + irradiance_field(0, p, r, 1));
223 heating_rates(0, p, r) = (-3 * net_flux_b + 4 * net_flux_c - net_flux_t) /
224 (p_grid[2] - p_grid[0]) * g0 /
225 specific_heat_capacity(0, p, r);
228 net_flux_t = (irradiance_field(idx - 1, p, r, 0) +
229 irradiance_field(idx - 1, p, r, 1));
230 net_flux_c = (irradiance_field(idx - 2, p, r, 0) +
231 irradiance_field(idx - 2, p, r, 1));
232 net_flux_b = (irradiance_field(idx - 3, p, r, 0) +
233 irradiance_field(idx - 3, p, r, 1));
235 heating_rates(idx - 1, p, r) =
236 -(-3 * net_flux_t + 4 * net_flux_c - net_flux_b) /
237 (p_grid[idx-1] - p_grid[idx-3]) * g0 / specific_heat_capacity(0, p, r);
244 const Tensor5& radiance_field,
245 const Vector& za_grid,
246 const Vector& aa_grid,
247 const Vector& za_grid_weights,
250 const Index N_scat_za = za_grid.nelem();
251 const Index N_scat_aa = aa_grid.nelem();
253 Tensor4 radiance_field_aa_integrated;
258 radiance_field_aa_integrated =
259 radiance_field(joker, joker, joker, joker, 0);
260 radiance_field_aa_integrated *= 2 *
PI;
264 radiance_field_aa_integrated.resize(radiance_field.nshelves(),
265 radiance_field.nbooks(),
266 radiance_field.npages(),
267 radiance_field.nrows());
268 radiance_field_aa_integrated = 0.;
270 for (Index
b = 0;
b < radiance_field_aa_integrated.nbooks();
b++) {
271 for (Index p = 0; p < radiance_field_aa_integrated.npages(); p++) {
272 for (Index r = 0; r < radiance_field_aa_integrated.nrows(); r++) {
273 for (Index
c = 0;
c < radiance_field_aa_integrated.ncols();
c++) {
274 for (Index i = 0; i < N_scat_aa - 1; i++) {
275 radiance_field_aa_integrated(
b, p, r,
c) +=
276 (radiance_field(
b, p, r,
c, i) +
277 radiance_field(
b, p, r,
c, i + 1)) /
278 2. * abs(aa_grid[i + 1] - aa_grid[i]) *
DEG2RAD;
287 irradiance_field.resize(radiance_field.nshelves(),
288 radiance_field.nbooks(),
289 radiance_field.npages(),
291 irradiance_field = 0;
295 for (Index
b = 0;
b < irradiance_field.nbooks();
b++) {
296 for (Index p = 0; p < irradiance_field.npages(); p++) {
297 for (Index r = 0; r < irradiance_field.nrows(); r++) {
298 for (Index i = 0; i < N_scat_za; i++) {
299 if (za_grid[i] <= 90.) {
300 irradiance_field(
b, p, r, 0) +=
301 radiance_field_aa_integrated(
b, p, r, i) *
302 cos(za_grid[i] *
DEG2RAD) * (-1.) * za_grid_weights[i];
304 irradiance_field(
b, p, r, 1) +=
305 radiance_field_aa_integrated(
b, p, r, i) *
306 cos(za_grid[i] *
DEG2RAD) * (-1.) * za_grid_weights[i];
316 const Vector& f_grid,
317 const Tensor5& spectral_radiation_field,
319 if (f_grid.nelem() != spectral_radiation_field.nshelves()) {
321 "The length of f_grid does not match with\n"
322 " the first dimension of the spectral_radiation_field");
326 radiation_field.resize(spectral_radiation_field.nbooks(),
327 spectral_radiation_field.npages(),
328 spectral_radiation_field.nrows(),
329 spectral_radiation_field.ncols());
333 for (Index i = 0; i < spectral_radiation_field.nshelves() - 1; i++) {
334 const Numeric df = f_grid[i + 1] - f_grid[i];
336 for (Index
b = 0;
b < radiation_field.nbooks();
b++) {
337 for (Index p = 0; p < radiation_field.npages(); p++) {
338 for (Index r = 0; r < radiation_field.nrows(); r++) {
339 for (Index
c = 0;
c < radiation_field.ncols();
c++) {
340 radiation_field(
b, p, r,
c) +=
341 (spectral_radiation_field(i + 1,
b, p, r,
c) +
342 spectral_radiation_field(i,
b, p, r,
c)) /
353 const Vector& f_grid,
354 const Tensor7& spectral_radiation_field,
356 if (f_grid.nelem() != spectral_radiation_field.nlibraries()) {
358 "The length of f_grid does not match with\n"
359 " the first dimension of the spectral_radiation_field");
363 radiation_field.resize(spectral_radiation_field.nvitrines(),
364 spectral_radiation_field.nshelves(),
365 spectral_radiation_field.nbooks(),
366 spectral_radiation_field.npages(),
367 spectral_radiation_field.nrows());
371 for (Index i = 0; i < spectral_radiation_field.nlibraries() - 1; i++) {
372 const Numeric df = f_grid[i + 1] - f_grid[i];
374 for (Index s = 0; s < radiation_field.nshelves(); s++) {
375 for (Index
b = 0;
b < radiation_field.nbooks();
b++) {
376 for (Index p = 0; p < radiation_field.npages(); p++) {
377 for (Index r = 0; r < radiation_field.nrows(); r++) {
378 for (Index
c = 0;
c < radiation_field.ncols();
c++) {
379 radiation_field(s,
b, p, r,
c) +=
380 (spectral_radiation_field(i + 1, s,
b, p, r,
c, 0) +
381 spectral_radiation_field(i, s,
b, p, r,
c, 0)) /
393 Tensor5& spectral_irradiance_field,
394 const Tensor7& spectral_radiance_field,
395 const Vector& za_grid,
396 const Vector& aa_grid,
397 const Vector& za_grid_weights,
400 const Index N_scat_za = spectral_radiance_field.npages();
401 const Index N_scat_aa = spectral_radiance_field.nrows();
403 Tensor5 iy_field_aa_integrated;
408 iy_field_aa_integrated =
409 spectral_radiance_field(joker, joker, joker, joker, joker, 0, 0);
410 iy_field_aa_integrated *= 2 *
PI;
414 iy_field_aa_integrated.resize(spectral_radiance_field.nlibraries(),
415 spectral_radiance_field.nvitrines(),
416 spectral_radiance_field.nshelves(),
417 spectral_radiance_field.nbooks(),
418 spectral_radiance_field.npages());
419 iy_field_aa_integrated = 0.;
421 for (Index s = 0; s < iy_field_aa_integrated.nshelves(); s++) {
422 for (Index
b = 0;
b < iy_field_aa_integrated.nbooks();
b++) {
423 for (Index p = 0; p < iy_field_aa_integrated.npages(); p++) {
424 for (Index r = 0; r < iy_field_aa_integrated.nrows(); r++) {
425 for (Index
c = 0;
c < iy_field_aa_integrated.ncols();
c++) {
426 for (Index i = 0; i < N_scat_aa - 1; i++) {
427 iy_field_aa_integrated(s,
b, p, r,
c) +=
428 (spectral_radiance_field(s,
b, p, r,
c, i, 0) +
429 spectral_radiance_field(s,
b, p, r,
c, i + 1, 0)) /
430 2. * abs(aa_grid[i + 1] - aa_grid[i]) *
DEG2RAD;
440 spectral_irradiance_field.resize(spectral_radiance_field.nlibraries(),
441 spectral_radiance_field.nvitrines(),
442 spectral_radiance_field.nshelves(),
443 spectral_radiance_field.nbooks(),
445 spectral_irradiance_field = 0;
448 for (Index s = 0; s < spectral_irradiance_field.nshelves(); s++) {
449 for (Index
b = 0;
b < spectral_irradiance_field.nbooks();
b++) {
450 for (Index p = 0; p < spectral_irradiance_field.npages(); p++) {
451 for (Index r = 0; r < spectral_irradiance_field.nrows(); r++) {
452 for (Index i = 0; i < N_scat_za; i++) {
453 if (za_grid[i] <= 90.) {
454 spectral_irradiance_field(s,
b, p, r, 0) +=
455 iy_field_aa_integrated(s,
b, p, r, i) *
456 cos(za_grid[i] *
DEG2RAD) * (-1.) * za_grid_weights[i];
458 spectral_irradiance_field(s,
b, p, r, 1) +=
459 iy_field_aa_integrated(s,
b, p, r, i) *
460 cos(za_grid[i] *
DEG2RAD) * (-1.) * za_grid_weights[i];
472 Tensor7& spectral_radiance_field,
473 Tensor3& trans_field,
474 const Agenda& propmat_clearsky_agenda,
475 const Agenda& water_p_eq_agenda,
476 const Agenda& iy_space_agenda,
477 const Agenda& iy_surface_agenda,
478 const Agenda& iy_cloudbox_agenda,
479 const Index& stokes_dim,
480 const Vector& f_grid,
481 const Index& atmosphere_dim,
482 const Vector& p_grid,
483 const Tensor3& z_field,
484 const Tensor3& t_field,
486 const Tensor4& vmr_field,
488 const Tensor3& wind_u_field,
489 const Tensor3& wind_v_field,
490 const Tensor3& wind_w_field,
491 const Tensor3& mag_u_field,
492 const Tensor3& mag_v_field,
493 const Tensor3& mag_w_field,
494 const Matrix& z_surface,
495 const Numeric& ppath_lmax,
496 const Numeric& rte_alonglos_v,
497 const String& rt_integration_option,
498 const Tensor3& surface_props_data,
499 const Vector& za_grid,
500 const Index& use_parallel_za [[maybe_unused]],
503 if (atmosphere_dim != 1)
504 throw runtime_error(
"This method only works for atmosphere_dim = 1.");
507 const Index nl = p_grid.nelem();
508 const Index nf = f_grid.nelem();
509 const Index nza = za_grid.nelem();
512 spectral_radiance_field.resize(nf, nl, 1, 1, nza, 1, stokes_dim);
513 trans_field.resize(nf, nl, nza);
516 const Index cloudbox_on = 0, ppath_inside_cloudbox_do = 0;
520 const String iy_unit =
"1";
522 const Vector rte_pos2(0);
523 const Index iy_agenda_call1 = 1;
524 const Tensor3 iy_transmittance(0, 0, 0);
525 const Index jacobian_do = 0;
528 const Numeric z_space = z_field(nl - 1, 0, 0) + 10;
546#pragma omp parallel for if (!arts_omp_in_parallel() && nza > 1 && \
547 use_parallel_za) firstprivate(wss)
548 for (Index i = 0; i < nza; i++) {
549 if (failed)
continue;
553 Vector ppvar_p, ppvar_t;
554 Matrix iy, ppvar_vmr, ppvar_wind, ppvar_mag, ppvar_f;
557 Tensor4 ppvar_trans_cumulat, ppvar_trans_partial;
558 ArrayOfMatrix iy_aux;
559 ArrayOfTensor3 diy_dx;
562 Vector rte_los(1, za_grid[i]);
563 Vector rte_pos(1, za_grid[i] < 90 ? z_surface(0, 0) : z_space);
571 ppath_inside_cloudbox_do,
577 ppath.
gp_p[ppath.
np - 1].idx == nl - 2);
615 propmat_clearsky_agenda,
617 rt_integration_option,
630 if (za_grid[i] < 90) {
631 spectral_radiance_field(joker, i0, 0, 0, i, 0, joker) =
632 ppvar_iy(joker, joker, 0);
633 spectral_radiance_field(joker, nl - 1, 0, 0, i, 0, joker) =
634 ppvar_iy(joker, joker, ppath.
np - 1);
635 trans_field(joker, 0, i) = ppvar_trans_partial(0, joker, 0, 0);
636 trans_field(joker, nl - 1, i) =
637 ppvar_trans_partial(ppath.
np - 1, joker, 0, 0);
639 spectral_radiance_field(joker, nl - 1, 0, 0, i, 0, joker) =
640 ppvar_iy(joker, joker, 0);
641 spectral_radiance_field(joker, i0, 0, 0, i, 0, joker) =
642 ppvar_iy(joker, joker, ppath.
np - 1);
643 trans_field(joker, nl - 1, i) = ppvar_trans_partial(0, joker, 0, 0);
644 trans_field(joker, 0, i) =
645 ppvar_trans_partial(ppath.
np - 1, joker, 0, 0);
649 for (Index p = 1; p < ppath.
np - 1; p++) {
651 if (ppath.
gp_p[p].fd[0] < 1e-2) {
652 spectral_radiance_field(
653 joker, ppath.
gp_p[p].idx, 0, 0, i, 0, joker) =
654 ppvar_iy(joker, joker, p);
655 trans_field(joker, ppath.
gp_p[p].idx, i) =
656 ppvar_trans_partial(p, joker, 0, 0);
663 for (Index p = 0; p < i0; p++) {
664 spectral_radiance_field(joker, p, 0, 0, i, 0, joker) =
665 spectral_radiance_field(joker, i0, 0, 0, i, 0, joker);
666 trans_field(joker, p, i) = trans_field(joker, i0, i);
669 }
catch (
const std::exception& e) {
670#pragma omp critical(planep_setabort)
674 os <<
"Run-time error at nza #" << i <<
": \n" << e.what();
675#pragma omp critical(planep_push_fail_msg)
676 fail_msg.push_back(os.str());
681 if (fail_msg.
nelem()) {
683 for (
auto& msg : fail_msg) os << msg <<
'\n';
684 throw runtime_error(os.str());
690 Tensor7& spectral_radiance_field,
691 const Index& atmosphere_dim,
692 const Vector& p_grid,
693 const Index& cloudbox_on,
695 const Tensor7& cloudbox_field,
697 if (atmosphere_dim > 1)
698 throw runtime_error(
"This method can only be used for 1D calculations.\n");
700 throw runtime_error(
"Cloudbox is off. This is not handled by this method.");
701 if (cloudbox_limits[0] || cloudbox_limits[1] != p_grid.
nelem() - 1)
703 "The cloudbox must cover all pressure levels "
704 "to use this method.");
707 spectral_radiance_field = cloudbox_field;
713 Tensor7& spectral_radiance_field,
714 const Agenda& propmat_clearsky_agenda,
715 const Agenda& water_p_eq_agenda,
716 const Agenda& iy_space_agenda,
717 const Agenda& iy_surface_agenda,
718 const Agenda& iy_cloudbox_agenda,
719 const Index& stokes_dim,
720 const Vector& f_grid,
721 const Index& atmosphere_dim,
722 const Vector& p_grid,
723 const Tensor3& z_field,
724 const Tensor3& t_field,
726 const Tensor4& vmr_field,
728 const Tensor3& wind_u_field,
729 const Tensor3& wind_v_field,
730 const Tensor3& wind_w_field,
731 const Tensor3& mag_u_field,
732 const Tensor3& mag_v_field,
733 const Tensor3& mag_w_field,
734 const Matrix& z_surface,
735 const Index& cloudbox_on,
737 const Tensor7& cloudbox_field,
738 const Numeric& ppath_lmax,
739 const Numeric& rte_alonglos_v,
740 const String& rt_integration_option,
741 const Tensor3& surface_props_data,
742 const Vector& za_grid,
743 const Index& use_parallel_za [[maybe_unused]],
746 if (atmosphere_dim != 1)
747 throw runtime_error(
"This method only works for atmosphere_dim = 1.");
749 throw runtime_error(
"No ned to use this method with cloudbox=0.");
750 if (cloudbox_limits[0])
752 "The first element of *cloudbox_limits* must be zero "
753 "to use this method.");
756 const Index nl = p_grid.nelem();
757 const Index nf = f_grid.nelem();
758 const Index nza = za_grid.nelem();
761 spectral_radiance_field.resize(nf, nl, 1, 1, nza, 1, stokes_dim);
764 spectral_radiance_field(joker,
765 Range(0, cloudbox_limits[1] + 1),
770 joker) = cloudbox_field;
773 const Index ppath_inside_cloudbox_do = 0;
774 const String iy_unit =
"1";
776 const Vector rte_pos2(0);
777 const Index iy_agenda_call1 = 1;
778 const Tensor3 iy_transmittance(0, 0, 0);
779 const Index jacobian_do = 0;
782 const Numeric z_space = z_field(nl - 1, 0, 0) + 10;
792 const Index i0 = cloudbox_limits[1];
793 const Numeric z_top = z_field(i0 + 1, 0, 0);
800#pragma omp parallel for if (!arts_omp_in_parallel() && nza > 1 && \
801 use_parallel_za) firstprivate(wss)
802 for (Index i = 0; i < nza; i++) {
803 if (failed)
continue;
807 Vector ppvar_p, ppvar_t;
808 Matrix iy, ppvar_vmr, ppvar_wind, ppvar_mag, ppvar_f;
811 Tensor4 ppvar_trans_cumulat, ppvar_trans_partial;
812 ArrayOfMatrix iy_aux;
813 ArrayOfTensor3 diy_dx;
816 Vector rte_los(1, za_grid[i]);
817 Vector rte_pos(1, za_grid[i] < 90 ? z_top : z_space);
825 ppath_inside_cloudbox_do,
831 ppath.
gp_p[ppath.
np - 1].idx == nl - 2);
869 propmat_clearsky_agenda,
871 rt_integration_option,
885 if (za_grid[i] < 90) {
886 spectral_radiance_field(joker, i0 + 1, 0, 0, i, 0, joker) =
887 ppvar_iy(joker, joker, 0);
888 spectral_radiance_field(joker, nl - 1, 0, 0, i, 0, joker) =
889 ppvar_iy(joker, joker, ppath.
np - 1);
891 spectral_radiance_field(joker, nl - 1, 0, 0, i, 0, joker) =
892 ppvar_iy(joker, joker, 0);
896 for (Index p = 1; p < ppath.
np - 1; p++) {
898 if (ppath.
gp_p[p].fd[0] < 1e-2) {
899 spectral_radiance_field(
900 joker, ppath.
gp_p[p].idx, 0, 0, i, 0, joker) =
901 ppvar_iy(joker, joker, p);
905 }
catch (
const std::exception& e) {
906#pragma omp critical(planep_setabort)
910 os <<
"Run-time error at nza #" << i <<
": \n" << e.what();
911#pragma omp critical(planep_push_fail_msg)
912 fail_msg.push_back(os.str());
917 if (fail_msg.
nelem()) {
919 for (
auto& msg : fail_msg) os << msg <<
'\n';
920 throw runtime_error(os.str());
Declarations required for the calculation of absorption coefficients.
Declarations for agendas.
Constants of physical expressions as constexpr.
Index nelem() const ARTS_NOEXCEPT
#define ARTS_ASSERT(condition,...)
void spectral_irradiance_fieldFromSpectralRadianceField(Tensor5 &spectral_irradiance_field, const Tensor7 &spectral_radiance_field, const Vector &za_grid, const Vector &aa_grid, const Vector &za_grid_weights, const Verbosity &)
WORKSPACE METHOD: spectral_irradiance_fieldFromSpectralRadianceField.
constexpr Numeric DEG2RAD
void heating_ratesFromIrradiance(Tensor3 &heating_rates, const Vector &p_grid, const Tensor4 &irradiance_field, const Tensor3 &specific_heat_capacity, const Numeric &g0, const Verbosity &)
WORKSPACE METHOD: heating_ratesFromIrradiance.
void irradiance_fieldFromRadiance(Tensor4 &irradiance_field, const Tensor5 &radiance_field, const Vector &za_grid, const Vector &aa_grid, const Vector &za_grid_weights, const Verbosity &)
WORKSPACE METHOD: irradiance_fieldFromRadiance.
void spectral_radiance_fieldClearskyPlaneParallel(Workspace &ws, Tensor7 &spectral_radiance_field, Tensor3 &trans_field, const Agenda &propmat_clearsky_agenda, const Agenda &water_p_eq_agenda, const Agenda &iy_space_agenda, const Agenda &iy_surface_agenda, const Agenda &iy_cloudbox_agenda, const Index &stokes_dim, const Vector &f_grid, const Index &atmosphere_dim, const Vector &p_grid, const Tensor3 &z_field, const Tensor3 &t_field, const EnergyLevelMap &nlte_field, const Tensor4 &vmr_field, const ArrayOfArrayOfSpeciesTag &abs_species, const Tensor3 &wind_u_field, const Tensor3 &wind_v_field, const Tensor3 &wind_w_field, const Tensor3 &mag_u_field, const Tensor3 &mag_v_field, const Tensor3 &mag_w_field, const Matrix &z_surface, const Numeric &ppath_lmax, const Numeric &rte_alonglos_v, const String &rt_integration_option, const Tensor3 &surface_props_data, const Vector &za_grid, const Index &use_parallel_za, const Verbosity &verbosity)
WORKSPACE METHOD: spectral_radiance_fieldClearskyPlaneParallel.
void spectral_radiance_fieldCopyCloudboxField(Tensor7 &spectral_radiance_field, const Index &atmosphere_dim, const Vector &p_grid, const Index &cloudbox_on, const ArrayOfIndex &cloudbox_limits, const Tensor7 &cloudbox_field, const Verbosity &)
WORKSPACE METHOD: spectral_radiance_fieldCopyCloudboxField.
void spectral_radiance_fieldExpandCloudboxField(Workspace &ws, Tensor7 &spectral_radiance_field, const Agenda &propmat_clearsky_agenda, const Agenda &water_p_eq_agenda, const Agenda &iy_space_agenda, const Agenda &iy_surface_agenda, const Agenda &iy_cloudbox_agenda, const Index &stokes_dim, const Vector &f_grid, const Index &atmosphere_dim, const Vector &p_grid, const Tensor3 &z_field, const Tensor3 &t_field, const EnergyLevelMap &nlte_field, const Tensor4 &vmr_field, const ArrayOfArrayOfSpeciesTag &abs_species, const Tensor3 &wind_u_field, const Tensor3 &wind_v_field, const Tensor3 &wind_w_field, const Tensor3 &mag_u_field, const Tensor3 &mag_v_field, const Tensor3 &mag_w_field, const Matrix &z_surface, const Index &cloudbox_on, const ArrayOfIndex &cloudbox_limits, const Tensor7 &cloudbox_field, const Numeric &ppath_lmax, const Numeric &rte_alonglos_v, const String &rt_integration_option, const Tensor3 &surface_props_data, const Vector &za_grid, const Index &use_parallel_za, const Verbosity &verbosity)
WORKSPACE METHOD: spectral_radiance_fieldExpandCloudboxField.
void RadiationFieldSpectralIntegrate(Tensor4 &radiation_field, const Vector &f_grid, const Tensor5 &spectral_radiation_field, const Verbosity &)
WORKSPACE METHOD: RadiationFieldSpectralIntegrate.
void AngularGridsSetFluxCalc(Vector &za_grid, Vector &aa_grid, Vector &za_grid_weights, const Index &N_za_grid, const Index &N_aa_grid, const String &za_grid_type, const Verbosity &)
WORKSPACE METHOD: AngularGridsSetFluxCalc.
void ppathPlaneParallel(Ppath &ppath, const Index &atmosphere_dim, const Tensor3 &z_field, const Matrix &z_surface, const Index &cloudbox_on, const ArrayOfIndex &cloudbox_limits, const Index &ppath_inside_cloudbox_do, const Vector &rte_pos, const Vector &rte_los, const Numeric &ppath_lmax, const Verbosity &)
WORKSPACE METHOD: ppathPlaneParallel.
void iyEmissionStandard(Workspace &ws, Matrix &iy, ArrayOfMatrix &iy_aux, ArrayOfTensor3 &diy_dx, Vector &ppvar_p, Vector &ppvar_t, EnergyLevelMap &ppvar_nlte, Matrix &ppvar_vmr, Matrix &ppvar_wind, Matrix &ppvar_mag, Matrix &ppvar_f, Tensor3 &ppvar_iy, Tensor4 &ppvar_trans_cumulat, Tensor4 &ppvar_trans_partial, const Index &iy_id, const Index &stokes_dim, const Vector &f_grid, const Index &atmosphere_dim, const Vector &p_grid, const Tensor3 &t_field, const EnergyLevelMap &nlte_field, const Tensor4 &vmr_field, const ArrayOfArrayOfSpeciesTag &abs_species, const Tensor3 &wind_u_field, const Tensor3 &wind_v_field, const Tensor3 &wind_w_field, const Tensor3 &mag_u_field, const Tensor3 &mag_v_field, const Tensor3 &mag_w_field, const Index &cloudbox_on, const String &iy_unit, const ArrayOfString &iy_aux_vars, const Index &jacobian_do, const ArrayOfRetrievalQuantity &jacobian_quantities, const Ppath &ppath, const Vector &rte_pos2, const Agenda &propmat_clearsky_agenda, const Agenda &water_p_eq_agenda, const String &rt_integration_option, const Agenda &iy_main_agenda, const Agenda &iy_space_agenda, const Agenda &iy_surface_agenda, const Agenda &iy_cloudbox_agenda, const Index &iy_agenda_call1, const Tensor3 &iy_transmittance, const Numeric &rte_alonglos_v, const Tensor3 &surface_props_data, const Verbosity &verbosity)
WORKSPACE METHOD: iyEmissionStandard.
void nlinspace(Vector &x, const Numeric start, const Numeric stop, const Index n)
nlinspace
void calculate_weights_linear(Vector &x, Vector &w, const Index nph)
calculate_weights_linear
Declarations having to do with the four output streams.
Agenda get_iy_main_agenda(Workspace &ws, const String &option)
constexpr Numeric pi
The following mathematical constants are generated in python Decimal package by the code:
constexpr auto deg2rad(auto x) noexcept
Converts degrees to radians.
Contains sorting routines.
The structure to describe a propagation path and releated quantities.
Index np
Number of points describing the ppath.
ArrayOfGridPos gp_p
Index position with respect to the pressure grid.
Index index_of_zsurface(const Numeric &z_surface, ConstVectorView z_profile)
Lccates the surface with respect to pressure levels.
This file contains the Workspace class.