psd.h

Go to the documentation of this file.

/* Copyright (C) 2017

   Jana Mendrok <jana.mendrok@gmail.com>
   Patrick Eriksson <patrick.eriksson@chalmers.se>
                      
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. 
*/

#ifndef psd_h
#define psd_h

#include "array.h"
#include "gridded_fields.h"
#include "interpolation.h"
#include "matpackVII.h"
#include "messages.h"
#include "optproperties.h"
#include "ppath.h"

// ------------------------------------------------------
// Macros to avoid duplication of code
// ------------------------------------------------------

#define START_OF_PSD_METHODS()                                                 \
  const Index nin = pnd_agenda_input_names.nelem();                            \
  const Index ndx = dpnd_data_dx_names.nelem();                                \
  const Index np = pnd_agenda_input.nrows();                                   \
  const Index nsi = psd_size_grid.nelem();                                     \
  ArrayOfIndex dx2in(ndx);                                                     \
                                                                               \
  if (pnd_agenda_input.ncols() != nin)                                         \
    throw runtime_error(                                                       \
        "Length of *pnd_agenda_input_names* and number of "                    \
        "columns in *pnd_agenda_input* must be equal.");                       \
  if (ndx) {                                                                   \
    if (ndx > nin)                                                             \
      throw runtime_error(                                                     \
          "The length of *dpnd_data_dx_names* can not "                        \
          "exceed the one of *pnd_agenda_input_names*.");                      \
    for (Index i = 0; i < ndx; i++) {                                          \
      dx2in[i] = find_first(pnd_agenda_input_names, dpnd_data_dx_names[i]);    \
      if (dx2in[i] < 0) {                                                      \
        ostringstream os;                                                      \
        os << "dpnd_data_dx_names[" << i << "] is " << dpnd_data_dx_names[i]   \
           << "\nThis string could not be found in *pnd_agenda_input_names*."; \
        throw std::runtime_error(os.str());                                    \
      }                                                                        \
    }                                                                          \
  }                                                                            \
                                                                               \
  psd_data.resize(np, nsi);                                                    \
  psd_data = 0.0;                                                              \
  if (ndx) {                                                                   \
    dpsd_data_dx.resize(ndx, np, nsi);                                         \
    dpsd_data_dx = 0.0;                                                        \
  } else {                                                                     \
    dpsd_data_dx.resize(0, 0, 0);                                              \
  }

void psd_cloudice_MH97(Vector& psd,
                       const Vector& diameter,
                       const Numeric& iwc,
                       const Numeric& t,
                       const bool noisy);

void psd_mgd_mass_and_something(Matrix& psd_data,
                                Tensor3& dpsd_data_dx,
                                const String& something,
                                const Vector& psd_size_grid,
                                const Vector& pnd_agenda_input_t,
                                const Matrix& pnd_agenda_input,
                                const ArrayOfString& pnd_agenda_input_names,
                                const ArrayOfString& dpnd_data_dx_names,
                                const Numeric& scat_species_a,
                                const Numeric& scat_species_b,
                                const Numeric& n0,
                                const Numeric& mu,
                                const Numeric& la,
                                const Numeric& ga,
                                const Numeric& t_min,
                                const Numeric& t_max,
                                const Index& picky,
                                const Verbosity&);

void psd_mono_common(Matrix& psd_data,
                     Tensor3& dpsd_data_dx,
                     const String& type,
                     const Vector& pnd_agenda_input_t,
                     const Matrix& pnd_agenda_input,
                     const ArrayOfString& pnd_agenda_input_names,
                     const ArrayOfString& dpnd_data_dx_names,
                     const ArrayOfArrayOfScatteringMetaData& scat_meta,
                     const Index& species_index,
                     const Numeric& t_min,
                     const Numeric& t_max,
                     const Index& picky,
                     const Verbosity&);

void psd_rain_W16(Vector& psd, const Vector& diameter, const Numeric& rwc);

void psd_mgd_smm_common(Matrix& psd_data,
                        Tensor3& dpsd_data_dx,
                        const String& psd_name,
                        const Vector& psd_size_grid,
                        const Vector& pnd_agenda_input_t,
                        const Matrix& pnd_agenda_input,
                        const ArrayOfString& pnd_agenda_input_names,
                        const ArrayOfString& dpnd_data_dx_names,
                        const Numeric& scat_species_a,
                        const Numeric& scat_species_b,
                        const Numeric& n_alpha_in,
                        const Numeric& n_b_in,
                        const Numeric& mu_in,
                        const Numeric& gamma_in,
                        const Numeric& t_min,
                        const Numeric& t_max,
                        const Index& picky,
                        const Verbosity&);

void psd_snow_F07(Vector& psd,
                  const Vector& diameter,
                  const Numeric& swc,
                  const Numeric& t,
                  const Numeric alpha,
                  const Numeric beta,
                  const String& regime);

void psd_SB06(Vector& psd,
              Matrix& dpsd,
              const Vector& mass,
              const Numeric& N_tot,
              const Numeric& WC,
              const String& hydrometeor_type);

void psd_MY05(Vector& psd,
              Matrix& dpsd,
              const Vector& diameter_max,
              const Numeric N_tot,
              const Numeric WC,
              const String psd_type);

Numeric dm_from_iwc_n0(Numeric iwc, Numeric n0, Numeric rho);

Numeric n0_from_iwc_dm(Numeric iwc, Numeric dm, Numeric rho);

Numeric n0_from_t(Numeric t);


#endif  //psd_h