58 const Index& scat_data_checked,
62 const Vector& wc_grid,
66 const Index nss = scat_data.
nelem();
67 const Index nf = f_grid.nelem();
68 const Index nt = T_grid.nelem();
69 const Index nw = wc_grid.nelem();
72 "*scat_data* and *pnd_agenda_array* are inconsistent "
75 "*scat_data* and *pnd_agenda_array_input_names* are "
76 "inconsistent in size.");
78 "This method requires one-moment PSDs, but *pnd_agenda_array_input_names* "
79 "for the selected scattering species does not have length one.");
81 "The scat_data must be flagged to have passed a "
82 "consistency check (scat_data_checked=1).");
85 hydrotable.
set_name(
"Table of particle optical properties");
86 hydrotable.
data.resize(4, nf, nt, nw);
89 hydrotable.
set_grid(0, {
"Extinction [m-1]",
90 "Single scattering albedo [-]",
91 "Asymmetry parameter [-]",
92 "Radar reflectivity [m2]"});
101 const Index nsa = 361;
107 Tensor3 dpnd_data_dx;
108 Matrix pnd_agenda_input(nt, 1);
112 Tensor3 pfun(nf, nt, nsa);
113 const Numeric fourpi = 4.0 *
PI;
117 for (Index iw = 0; iw < nw; iw++) {
119 pnd_agenda_input = wc_grid[iw];
126 pnd_agenda_array_input_names[iss],
145 for (Index iv = 0; iv < nf; iv++) {
146 for (Index it = 0; it < nt; it++) {
147 hydrotable.
data(0,iv,it,iw) = ext(iv,it);
148 hydrotable.
data(1,iv,it,iw) = 1.0 - (abs(iv,it) / ext(iv,it));
151 hydrotable.
data(3,iv,it,iw) = fourpi * pfun(iv,it,nsa-1);
160 Matrix& particle_masses,
165 particle_masses.resize(np_total, 1);
168 for (Index i_ss = 0; i_ss < scat_meta.
nelem(); i_ss++) {
169 for (Index i_se = 0; i_se < scat_meta[i_ss].
nelem(); i_se++) {
171 scat_meta[i_ss][i_se].mass <= 0 || scat_meta[i_ss][i_se].mass > 1.,
172 "A presumably incorrect value found for "
173 "scat_meta[", i_ss,
"][", i_se,
"].mass.\n"
174 "The value is ", scat_meta[i_ss][i_se].mass)
176 particle_masses(i_se_flat, 0) = scat_meta[i_ss][i_se].mass;
185 Matrix& particle_masses,
191 particle_masses = 0.;
195 for (Index i_ss = 0; i_ss < scat_meta.
nelem(); i_ss++) {
196 for (Index i_se = 0; i_se < scat_meta[i_ss].
nelem(); i_se++) {
198 scat_meta[i_ss][i_se].mass <= 0 || scat_meta[i_ss][i_se].mass > 1.,
199 "A presumably incorrect value found for "
200 "scat_meta[", i_ss,
"][", i_se,
"].mass.\n"
201 "The value is ", scat_meta[i_ss][i_se].mass)
203 particle_masses(i_se_flat, i_ss) = scat_meta[i_ss][i_se].mass;
211 Tensor3& dpnd_data_dx,
212 const Vector& pnd_size_grid,
213 const Matrix& psd_data,
214 const Vector& psd_size_grid,
215 const Tensor3& dpsd_data_dx,
216 const Index& quad_order,
219 const Index np = psd_data.nrows();
220 const Index ng = psd_size_grid.nelem();
222 const bool do_dx = !dpsd_data_dx.empty();
226 "The method requires that length of *psd_size_grid* is >= 2.");
228 "So far, the method requires that *psd_size_grid* and "
229 "*pnd_size_grid* have same length.");
230 for (Index i = 0; i < ng; i++) {
232 "So far, the method requires that *psd_size_grid* and "
233 "*pnd_size_grid* are identical.");
236 "Number of columns in *psd_data* and length of "
237 "*psd_size_grid* must match.");
239 pnd_data.resize(np, ng);
242 "Number of columns in *dpsd_data_dx* and length of "
243 "*psd_size_grid* must match.");
244 ndx = dpsd_data_dx.npages();
245 dpnd_data_dx.resize(ndx, np, ng);
247 dpnd_data_dx.resize(0, 0, 0);
253 Vector psd_size_grid_sorted(ng);
255 for (Index i = 0; i < ng; i++)
256 psd_size_grid_sorted[i] = psd_size_grid[intarr[i]];
259 "*psd_size_grid* is not allowed to contain "
260 "duplicate values.");
263 Vector quadweights(ng);
266 for (Index i = 0; i < ng; i++) {
267 for (Index ip = 0; ip < np; ip++) {
268 pnd_data(ip, intarr[i]) = quadweights[i] * psd_data(ip, intarr[i]);
272 for (Index ip = 0; ip < np; ip++) {
273 for (Index ix = 0; ix < ndx; ix++) {
274 dpnd_data_dx(ix, ip, intarr[i]) =
275 quadweights[i] * dpsd_data_dx(ix, ip, intarr[i]);
284 Tensor3& dpnd_data_dx,
285 const Vector& pnd_size_grid,
286 const Matrix& psd_data,
287 const Vector& psd_size_grid,
288 const Tensor3& dpsd_data_dx,
290 const Vector& f_grid,
291 const Index& scat_data_checked,
292 const Index& quad_order,
293 const Index& scat_index,
294 const Numeric& threshold_rsec,
295 const Numeric& threshold_bext,
296 const Numeric& threshold_rpnd,
299 const Index np = psd_data.nrows();
300 const Index ng = psd_size_grid.nelem();
302 const bool do_dx = !dpsd_data_dx.empty();
306 "The method requires that length of *psd_size_grid* is >= 3.");
308 "So far, the method requires that *psd_size_grid* and"
309 " *pnd_size_grid* have the same length.");
310 for (Index i = 0; i < ng; i++) {
312 "So far, the method requires that *psd_size_grid* and"
313 " *pnd_size_grid* are identical.");
316 "Number of columns in *psd_data* and length of"
317 " *psd_size_grid* must match.");
319 pnd_data.resize(np, ng);
322 "Number of columns in *dpsd_data_dx* and length of"
323 " *psd_size_grid* must match.");
324 ndx = dpsd_data_dx.npages();
325 dpnd_data_dx.resize(ndx, np, ng);
327 dpnd_data_dx.resize(0, 0, 0);
331 "*scat_data* must have passed a consistency check"
332 " (scat_data_checked=1).\n"
333 "Alternatively, use *pndFromPsdBasic*.");
335 "*scat_index* exceeds the number of available"
336 " scattering species.");
338 "Number of scattering elements in this scattering"
339 " species (*scat_index*) inconsistent with length of"
340 " *pnd_size_grid*.");
345 Vector psd_size_grid_sorted(ng);
347 for (Index i = 0; i < ng; i++)
348 psd_size_grid_sorted[i] = psd_size_grid[intarr[i]];
351 "*psd_size_grid* is not allowed to contain "
352 "duplicate values.");
355 Vector quadweights(ng);
358 for (Index i = 0; i < ng;
361 for (Index ip = 0; ip < np; ip++)
363 pnd_data(ip, intarr[i]) = quadweights[i] * psd_data(ip, intarr[i]);
367 for (Index ip = 0; ip < np; ip++) {
368 for (Index ix = 0; ix < ndx; ix++) {
369 dpnd_data_dx(ix, ip, intarr[i]) =
370 quadweights[i] * dpsd_data_dx(ix, ip, intarr[i]);
378 Index nf = f_grid.
nelem();
379 Matrix bulkext(np, nf, 0.);
380 Vector ext(nf), ext_s0(nf), ext_s1(nf), ext_l0(nf), ext_l1(nf);
424 for (Index ise = 0; ise < ng;
427 if (sds[intarr[ise]].ext_mat_data.nshelves() > 1)
428 ext = sds[intarr[ise]].ext_mat_data(joker, 0, 0, 0, 0);
430 ext = sds[intarr[ise]].ext_mat_data(0, 0, 0, 0, 0);
437 else if (ise == ng - 2)
439 else if (ise == ng - 1)
442 for (Index ip = 0; ip < np; ip++)
443 if (abs(sum(pnd_data(ip, joker))) > 0.)
444 for (Index f = fstart; f < (fstart + nf); f++)
445 bulkext(ip, f) += pnd_data(ip, intarr[ise]) * ext[f];
448 Numeric max0 = 0, max1 = 0;
449 for (Index ip = 0; ip < np; ip++)
451 max0 =
max(abs(pnd_data(ip, intarr[0])), max0);
452 max1 =
max(abs(pnd_data(ip, intarr[ng - 1])), max1);
456 for (Index ip = 0; ip < np; ip++)
458 if (abs(sum(pnd_data(ip, joker))) > 0.) {
459 for (Index f = fstart; f < (fstart + nf); f++) {
475 if (abs(bulkext(ip, f)) > 1e-2 * threshold_bext) {
477 ext_s0[f] * abs(psd_data(ip, intarr[0])) >=
478 ext_s1[f] * abs(psd_data(ip, intarr[1])),
479 " Bin-width normalized extinction (ext*psd) not decreasing"
480 " at small size edge\n"
481 " at atm level #", ip,
" and freq point #", f,
".\n"
482 " ext_s0=", ext_s0[f],
483 ", psd_s0=", abs(psd_data(ip, intarr[0])),
484 ", ext_s0*psd_s0=", ext_s0[f] * abs(psd_data(ip, intarr[0])),
486 " ext_s1=", ext_s1[f],
487 ", psd_s1=", abs(psd_data(ip, intarr[1])),
488 ", ext_s1*psd_s1=", ext_s1[f] * abs(psd_data(ip, intarr[1])),
490 " Total bulk ext = ", abs(bulkext(ip, f)),
"\n"
491 " Need to add smaller sized particles!\n")
494 ext_l0[f] * abs(psd_data(ip, intarr[ng - 1])) >=
495 ext_l1[f] * abs(psd_data(ip, intarr[ng - 2])),
496 "Bin-width normalized extinction (ext*psd) not decreasing"
497 " at large size edge\n"
498 "at atm level #", ip,
" and freq point #", f,
".\n"
499 " ext_l0=", ext_l0[f],
500 ", psd_l0=", abs(psd_data(ip, intarr[ng - 1])),
502 ext_l0[f] * abs(psd_data(ip, intarr[ng - 1])),
504 " ext_l1=", ext_l1[f],
505 ", psd_l1=", abs(psd_data(ip, intarr[ng - 2])),
507 ext_l1[f] * abs(psd_data(ip, intarr[ng - 2])),
"\n"
508 " Total bulk ext = ", abs(bulkext(ip, f)),
"\n"
509 " Need to add larger sized particles!\n")
514 if (abs(bulkext(ip, f)) > threshold_bext) {
515 if (abs(pnd_data(ip, intarr[0])) > threshold_rpnd * max0) {
517 abs(pnd_data(ip, intarr[0])) * ext_s0[f] / abs(bulkext(ip, f));
522 threshold_rsec * abs(bulkext(ip, f)),
523 "Contribution of edge bin to total extinction too high"
524 " (", contrib * 1e2,
"% of ", abs(bulkext(ip, f)),
525 ") at small size edge\n"
526 "at atm level #", ip,
" and freq point #", f,
".\n"
527 " Need to add smaller sized particles or refine the size"
528 " grid on the small size edge!\n")
530 if (abs(pnd_data(ip, intarr[ng - 1])) > threshold_rpnd * max1) {
531 contrib = abs(pnd_data(ip, intarr[ng - 1])) * ext_l0[f] /
537 threshold_rsec * abs(bulkext(ip, f)),
538 "Contribution of edge bin to total extinction too high"
539 " (", contrib * 1e2,
"% of ", abs(bulkext(ip, f)),
540 ") at large size edge\n"
541 "at atm level #", ip,
" and freq point #", f,
".\n"
542 " Need to add larger sized particles or refine the size"
543 " grid on the large size edge!\n")
557 ArrayOfTensor4& dpnd_field_dx,
558 const Index& atmosphere_dim,
559 const Vector& p_grid,
560 const Vector& lat_grid,
561 const Vector& lon_grid,
562 const Tensor3& t_field,
563 const Index& cloudbox_on,
568 const Tensor4& particle_bulkprop_field,
572 const Index& jacobian_do,
582 "*particle_bulkprop_field* is empty.");
587 chk_atm_field(
"t_field", t_field, atmosphere_dim, p_grid, lat_grid, lon_grid);
589 particle_bulkprop_field,
591 particle_bulkprop_names.
nelem(),
597 const Index nss = scat_data.
nelem();
600 particle_bulkprop_names.
nelem() != particle_bulkprop_field.nbooks(),
601 "Number of fields in *particle_bulkprop_field*"
602 " inconsistent with number of names in"
603 " *particle_bulkprop_names*.");
605 "At least one field per scattering species required"
606 " in *particle_bulkprop_field*.");
609 "Length of *cloudbox_limits* incorrect with respect "
610 "to *atmosphere_dim*.");
611 ARTS_USER_ERROR_IF (cloudbox_limits[1] <= cloudbox_limits[0] || cloudbox_limits[0] < 0 ||
612 cloudbox_limits[1] >= p_grid.
nelem(),
613 "Invalid data in pressure part of *cloudbox_limits*.");
614 if (atmosphere_dim > 1) {
615 ARTS_USER_ERROR_IF (cloudbox_limits[3] <= cloudbox_limits[2] || cloudbox_limits[2] < 0 ||
616 cloudbox_limits[3] >= lat_grid.
nelem(),
617 "Invalid data in latitude part of *cloudbox_limits*.");
618 if (atmosphere_dim > 2) {
619 ARTS_USER_ERROR_IF (cloudbox_limits[5] <= cloudbox_limits[4] || cloudbox_limits[4] < 0 ||
620 cloudbox_limits[5] >= lon_grid.
nelem(),
621 "Invalid data in longitude part of *cloudbox_limits*.");
627 "*scat_data* and *scat_species* are inconsistent in size.");
629 "*scat_data* and *scat_meta* are inconsistent in size.");
631 "*scat_data* and *pnd_agenda_array* are inconsistent "
634 "*scat_data* and *pnd_agenda_array_input_names* are "
635 "inconsistent in size.");
639 const Index np = cloudbox_limits[1] - cloudbox_limits[0] + 1;
640 Index np_nonzero = np;
641 Index ip_offset = cloudbox_limits[0];
644 Index ilat_offset = 0;
645 if (atmosphere_dim > 1) {
646 nlat = cloudbox_limits[3] - cloudbox_limits[2] + 1;
647 ilat_offset = cloudbox_limits[2];
650 Index ilon_offset = 0;
651 if (atmosphere_dim > 2) {
652 nlon = cloudbox_limits[5] - cloudbox_limits[4] + 1;
653 ilon_offset = cloudbox_limits[4];
658 constexpr std::string_view estring =
659 "*particle_bulkprop_field* allowed to contain"
660 " non-zero values only inside the cloudbox.";
662 if (cloudbox_limits[0] != 0) {
664 joker, Range(0, ip_offset + 1), joker, joker)) > 0 ||
665 min(particle_bulkprop_field(
666 joker, Range(0, ip_offset + 1), joker, joker)) < 0,
672 if (cloudbox_limits[1] != p_grid.
nelem() - 1) {
673 const Index np_above = p_grid.nelem() + 1 - (np + ip_offset);
675 joker, Range(cloudbox_limits[1], np_above), joker, joker)) > 0 ||
676 min(particle_bulkprop_field(
677 joker, Range(cloudbox_limits[1], np_above), joker, joker)) < 0,
685 for (Index i = 0; i < nss; i++) {
687 "*scat_data* and *scat_meta* have inconsistent sizes.");
688 ncumse[i + 1] = ncumse[i] + scat_data[i].
nelem();
693 pnd_field.resize(ncumse[nss], np, nlat, nlon);
701 dpnd_field_dx.resize(0);
703 nq = jacobian_quantities.
nelem();
704 dpnd_field_dx.resize(nq);
705 scatspecies_to_jq.resize(nss);
707 for (Index iq = 0; iq < nq; iq++) {
708 if (jacobian_quantities[iq] == Jacobian::Special::ScatteringString) {
710 find_first(scat_species, jacobian_quantities[iq].Subtag());
712 "Jacobian quantity with index ", iq,
" refers to\n"
713 " ", jacobian_quantities[iq].Subtag(),
714 "\nbut this species could not be found in *scat_species*.")
715 scatspecies_to_jq[ihit].push_back(iq);
716 dpnd_field_dx[iq].resize(ncumse[nss], np, nlat, nlon);
717 dpnd_field_dx[iq] = 0.0;
723 for (Index is = 0; is < nss; is++) {
725 Range se_range(ncumse[is], ncumse[is + 1] - ncumse[is]);
729 const Index nin = pnd_agenda_array_input_names[is].
nelem();
732 for (Index i = 0; i < nin; i++) {
733 i_pbulkprop[i] =
find_first(particle_bulkprop_names,
734 pnd_agenda_array_input_names[is][i]);
736 "Pnd-agenda with index ", is,
" is set to require \"",
737 pnd_agenda_array_input_names[is][i],
"\",\nbut this quantity "
738 "could not found in *particle_bulkprop_names*.\n"
739 "(Note that temperature must be written as \"Temperature\")")
748 ndx = scatspecies_to_jq[is].
nelem();
749 dpnd_data_dx_names.resize(ndx);
750 for (Index ix = 0; ix < ndx; ix++) {
751 dpnd_data_dx_names[ix] =
752 jacobian_quantities[scatspecies_to_jq[is][ix]].SubSubtag();
757 for (Index ilon = 0; ilon < nlon; ilon++) {
758 for (Index ilat = 0; ilat < nlat; ilat++) {
761 if ((nlat > 1 && (ilat == 0 || ilat == nlat - 1)) ||
762 (nlon > 1 && (ilon == 0 || ilon == nlon - 1))) {
766 Matrix pnd_agenda_input(np_nonzero, nin);
768 for (Index i = 0; i < nin; i++) {
769 for (Index ip = 0; ip < np_nonzero; ip++) {
770 pnd_agenda_input(ip, i) =
771 particle_bulkprop_field(i_pbulkprop[i],
778 Vector pnd_agenda_input_t(np);
780 for (Index ip = 0; ip < np_nonzero; ip++) {
781 pnd_agenda_input_t[ip] =
782 t_field(ip_offset + ip, ilat_offset + ilat, ilon_offset + ilon);
787 Tensor3 dpnd_data_dx;
795 pnd_agenda_array_input_names[is],
800 for (Index ip = 0; ip < np_nonzero; ip++) {
801 pnd_field(se_range, pf_offset+ip, ilat, ilon) = pnd_data(ip, joker);
803 for (Index ix = 0; ix < ndx; ix++) {
804 for (Index ip = 0; ip < np_nonzero; ip++) {
805 dpnd_field_dx[scatspecies_to_jq[is][ix]](se_range, pf_offset+ip, ilat, ilon) =
806 dpnd_data_dx(ix, ip, joker);
818 Numeric& scat_species_a,
819 Numeric& scat_species_b,
821 const Index& species_index,
823 const Numeric& x_fit_start,
824 const Numeric& x_fit_end,
825 const Index& do_only_x,
828 const Index nss = scat_meta.
nelem();
831 "Selected scattering species index is ", species_index,
833 "is not allowed since *scat_meta* has only ", nss,
" elements.")
835 const Index nse = scat_meta[species_index].
nelem();
837 "The scattering species must have at least two "
838 "elements to use this method.");
844 for (Index i = 0; i < nse; i++) {
845 mass[i] = scat_meta[species_index][i].mass;
850 scat_species_x.resize(nse);
852 if (x_unit ==
"dveq") {
853 for (Index i = 0; i < nse; i++) {
854 scat_species_x[i] = scat_meta[species_index][i].diameter_volume_equ;
869 else if (x_unit ==
"dmax") {
870 for (Index i = 0; i < nse; i++) {
871 scat_species_x[i] = scat_meta[species_index][i].diameter_max;
886 else if (x_unit ==
"area") {
887 for (Index i = 0; i < nse; i++) {
889 scat_meta[species_index][i].diameter_area_equ_aerodynamical;
904 else if (x_unit ==
"mass") {
905 scat_species_x = mass;
912 ARTS_USER_ERROR (
"You have selected the x_unit: ", x_unit,
"\nwhile accepted "
913 "choices are: \"dveq\", \"dmax\", \"mass\" and \"area\"")
This file contains the definition of Array.
Index TotalNumberOfElements(const Array< Array< base > > &aa)
Determine total number of elements in an ArrayOfArray.
Index find_first(const Array< base > &x, const base &w)
Find first occurance.
base max(const Array< base > &x)
Max function.
base min(const Array< base > &x)
Min function.
The global header file for ARTS.
Constants of physical expressions as constexpr.
void pnd_agenda_arrayExecute(Workspace &ws, Matrix &pnd_data, Tensor3 &dpnd_data_dx, const Index agenda_array_index, const Vector &pnd_agenda_input_t, const Matrix &pnd_agenda_input, const ArrayOfString &pnd_agenda_input_names, const ArrayOfString &dpnd_data_dx_names, const ArrayOfAgenda &input_agenda_array)
This can be used to make arrays out of anything.
Index nelem() const ARTS_NOEXCEPT
void set_name(const String &s)
Set name of this gridded field.
void set_grid_name(Index i, const String &s)
Set grid name.
void set_grid(Index i, const Vector &g)
Set a numeric grid.
void bin_quadweights(Vector &w, const Vector &x, const Index &order)
Internal cloudbox functions.
#define ARTS_USER_ERROR(...)
#define ARTS_USER_ERROR_IF(condition,...)
Functions for disort interface.
This file contains basic functions to handle ASCII files.
Header file for interpolation.cc.
void pndFromPsdBasic(Matrix &pnd_data, Tensor3 &dpnd_data_dx, const Vector &pnd_size_grid, const Matrix &psd_data, const Vector &psd_size_grid, const Tensor3 &dpsd_data_dx, const Index &quad_order, const Verbosity &)
WORKSPACE METHOD: pndFromPsdBasic.
void particle_massesFromMetaDataSingleCategory(Matrix &particle_masses, const ArrayOfArrayOfScatteringMetaData &scat_meta, const Verbosity &)
WORKSPACE METHOD: particle_massesFromMetaDataSingleCategory.
void pndFromPsd(Matrix &pnd_data, Tensor3 &dpnd_data_dx, const Vector &pnd_size_grid, const Matrix &psd_data, const Vector &psd_size_grid, const Tensor3 &dpsd_data_dx, const ArrayOfArrayOfSingleScatteringData &scat_data, const Vector &f_grid, const Index &scat_data_checked, const Index &quad_order, const Index &scat_index, const Numeric &threshold_rsec, const Numeric &threshold_bext, const Numeric &threshold_rpnd, const Verbosity &)
WORKSPACE METHOD: pndFromPsd.
void ScatSpeciesSizeMassInfo(Vector &scat_species_x, Numeric &scat_species_a, Numeric &scat_species_b, const ArrayOfArrayOfScatteringMetaData &scat_meta, const Index &species_index, const String &x_unit, const Numeric &x_fit_start, const Numeric &x_fit_end, const Index &do_only_x, const Verbosity &)
WORKSPACE METHOD: ScatSpeciesSizeMassInfo.
void pnd_fieldCalcFromParticleBulkProps(Workspace &ws, Tensor4 &pnd_field, ArrayOfTensor4 &dpnd_field_dx, const Index &atmosphere_dim, const Vector &p_grid, const Vector &lat_grid, const Vector &lon_grid, const Tensor3 &t_field, const Index &cloudbox_on, const ArrayOfIndex &cloudbox_limits, const ArrayOfString &scat_species, const ArrayOfArrayOfSingleScatteringData &scat_data, const ArrayOfArrayOfScatteringMetaData &scat_meta, const Tensor4 &particle_bulkprop_field, const ArrayOfString &particle_bulkprop_names, const ArrayOfAgenda &pnd_agenda_array, const ArrayOfArrayOfString &pnd_agenda_array_input_names, const Index &jacobian_do, const ArrayOfRetrievalQuantity &jacobian_quantities, const Verbosity &)
WORKSPACE METHOD: pnd_fieldCalcFromParticleBulkProps.
void HydrotableCalc(Workspace &ws, GriddedField4 &hydrotable, const ArrayOfAgenda &pnd_agenda_array, const ArrayOfArrayOfString &pnd_agenda_array_input_names, const ArrayOfArrayOfSingleScatteringData &scat_data, const Index &scat_data_checked, const Vector &f_grid, const Index &iss, const Vector &T_grid, const Vector &wc_grid, const Verbosity &)
WORKSPACE METHOD: HydrotableCalc.
void particle_massesFromMetaData(Matrix &particle_masses, const ArrayOfArrayOfScatteringMetaData &scat_meta, const Verbosity &)
WORKSPACE METHOD: particle_massesFromMetaData.
void nlinspace(Vector &x, const Numeric start, const Numeric stop, const Index n)
nlinspace
Declarations having to do with the four output streams.
Numeric asymmetry_parameter(ConstVectorView sa_grid, ConstVectorView pfun)
asymmetry_parameter
void derive_scat_species_a_and_b(Numeric &a, Numeric &b, const Vector &x, const Vector &mass, const Numeric &x_fit_start, const Numeric &x_fit_end)
Internal functions for microphysics calculations (size distributions etc.)
constexpr Numeric pi
The following mathematical constants are generated in python Decimal package by the code:
void ext_abs_pfun_from_tro(MatrixView ext_data, MatrixView abs_data, Tensor3View pfun_data, const ArrayOfSingleScatteringData &scat_data, const Index &iss, ConstMatrixView pnd_data, ArrayOfIndex &cloudbox_limits, ConstVectorView T_grid, ConstVectorView sa_grid, const Index f_index)
Extinction, absorption and phase function for one scattering species, 1D and TRO.
Scattering database structure and functions.
This file contains header information for the dealing with command line parameters.
This file contains declerations of functions of physical character.
Internal functions associated with size distributions.
Declaration of functions in rte.cc.
Contains sorting routines.
void get_sorted_indexes(ArrayOfIndex &sorted, const T &data)
get_sorted_indexes
Header file for special_interp.cc.
This file contains basic functions to handle XML data files.