:py:mod:`exo_k.atm_profile`
===========================

.. py:module:: exo_k.atm_profile

.. autoapi-nested-parse::

   @author: jeremy leconte

   This module contain classes to handle atmospheric profiles.
   Radiative properties are handled in atm.py which contains a daughter class.

   The nomenclature for layers, levels, etc., can be found in atm.py.



Module Contents
---------------

.. py:class:: Atm_profile(composition=None, psurf=None, ptop=None, logplay=None, tlay=None, Tsurf=None, Tstrat=None, grav=None, Rp=None, Mgas=None, Rstar=None, rcp=None, Nlay=20, logplev=None, aerosols=None, Nlev=None, tlev=None, **kwargs)


   Bases: :py:obj:`object`

   A class defining an atmospheric PT profile with some global data
   (gravity, etc.)

   The derived class :class:`~exo_k.atm.Atm` handles
   radiative transfer calculations.


   Initializes atmospheric profiles

   :param composition: Keys are molecule names and values the vmr.
                       Vmr can be arrays of size Nlev-1 (i.e. the number of layers).
   :type composition: :class:`dict`
   :param grav: Planet surface gravity (gravity constant with altitude for now).
   :type grav: :class:`float`
   :param Rp: Planet radius. If float, meters are assumed.
   :type Rp: :class:`float` or :class:`Astropy.unit quantity`
   :param rcp: Adiabatic lapse rate for the gas (R/cp)
   :type rcp: :class:`float`
   :param Mgas: Molar mass of the gas (kg/mol). If given, overrides the molar mass computed
                from composition.
   :type Mgas: :class:`float`, *optional*

   There are two ways to define the profile.
   You can define:

   * Nlay: int
     Number of layers
   * psurf, Tsurf: float
     Surface pressure (Pa) and temperature
   * ptop: float
     Pressure at the top of the model (Pa)
   * Tstrat: float
     Stratospheric temperature

   This way you will have an adiabatic atmosphere with Tsurf at the ground that
   becomes isothermal wherever T=<Tstrat.
   You can also specify:

   * logplay or play: array, np.ndarray
   * tlay: array, np.ndarray (same size)
     These will become the pressures (Pa; the log10 if you give
     logplay) and temperatures of the layers.
     This will be used to define the surface and top pressures.
     Nlay becomes the size of the arrays.

   .. warning::
       Layers are counted from the top down (increasing pressure order).
       All methods follow the same convention.

   .. py:method:: set_logPT_profile(logplay, tlay, logplev=None)

      Set the logP-T profile of the atmosphere with a new one

      :param logplay: Log pressure (in Pa) of the layer
      :type logplay: :class:`array`, :class:`np.ndarray`
      :param tlay: temperature of the layers.
      :type tlay: :class:`array`, :class:`np.ndarray (same size)`

      :param logplev: If provided, allows the user to choose the location
                      of the level surfaces separating the layers.
      :type logplev: :class:`array`, :class:`np.ndarray (size Nlay+1)`


   .. py:method:: set_T_profile(tlay)

      Reset the temperature profile without changing the pressure levels



   .. py:method:: compute_pressure_levels()

      Computes various pressure related quantities



   .. py:method:: update_pressure_profile(play=None, plev=None)

      Updates pressure levels without changing temperatures.

      To be used Atm_evolution class.


   .. py:method:: set_adiab_profile(Tsurf=None, Tstrat=None)

      Initializes the logP-T atmospheric profile with an adiabat with index R/cp=rcp

      :param Tsurf: Surface temperature.
      :type Tsurf: :class:`float`
      :param Tstrat: Temperature of the stratosphere. If None is given,
                     an isothermal atmosphere with T=Tsurf is returned.
      :type Tstrat: :class:`float`, *optional*


   .. py:method:: set_grav(grav=None)

      Sets the surface gravity of the planet

      :param grav: surface gravity (m/s^2)
      :type grav: :class:`float`


   .. py:method:: compute_layer_masses()

      compute_layer_masses



   .. py:method:: set_gas(composition_dict, Mgas=None, compute_Mgas=True)

      Sets the composition of the atmosphere.

      The composition_dict gives the composition in the layers, but we will
      need the composition in the radiative layers, so the interpolation is
      done here. For the moment we do a geometrical average.

      .. important::
          For the first initialization, compute_Mgas must be False
          because we need Gas_mix to be initialized before we know the number of layers
          in the atmosphere, but the number of layers is needed by set_Mgas!
          So set_Mgas needs to be called at the end of the initialization.

      :param composition_dict: Keys are molecule names, and values are volume mixing ratios.
                               A 'background' value means that the gas will be used to fill up to vmr=1
                               If they do not add up to 1 and there is no background gas_mix,
                               the rest of the gas_mix is considered transparent.
      :type composition_dict: :class:`dictionary`
      :param compute_Mgas: If False, the molar mass of the gas is not updated.
      :type compute_Mgas: :class:`bool`


   .. py:method:: set_Mgas(Mgas=None)

      Sets the mean molar mass of the atmosphere.

      :param Mgas: Mean molar mass in the radiative layers (kg/mol).
                   If None is given, the mmm is computed from the composition.
      :type Mgas: :class:`float` or :class:`array` of :class:`size Nlay-1`


   .. py:method:: set_rcp(rcp=None)

      Sets the adiabatic index of the atmosphere

      :param rcp: R/c_p
      :type rcp: :class:`float`


   .. py:method:: set_aerosols(aerosols)

      Sets the aerosols dictionary

      performs the interlayer averaging so that we only have properties at
      the middle of radiative layers


   .. py:method:: set_Rp(Rp)

      Sets the radius of the planet

      :param Rp: radius of the planet (m)
      :type Rp: :class:`float`


   .. py:method:: set_Rstar(Rstar)

      Sets the radius of the star

      :param Rstar: radius of the star (m)
      :type Rstar: :class:`float`


   .. py:method:: compute_number_density()

      Computes the number density (m^-3) profile of the atmosphere
      in the radiative layers


   .. py:method:: compute_mass_density()

      Computes the mass density (kg/m^-3) profile of the atmosphere
      in the radiative layers


   .. py:method:: compute_layer_col_density()

      Computes the column number density (molecules/m^2) per
      radiative layer of the atmosphere.

      There are Nlay-1 radiative layers as they go from the middle of a layer to the next.


   .. py:method:: compute_altitudes()

      Compute altitudes of the level surfaces (zlev) and mid layers (zlay).



   .. py:method:: compute_area()

      Computes the area of the annulus covered by each
      radiative layer (from a mid layer to the next) in a transit setup.


   .. py:method:: compute_tangent_path()

      Computes a triangular array of the tangent path length (in m) spent in each
      radiative layer.

      self.tangent_path[ilay][jlay] is the length that the ray that is tangent to the ilay
      radiative layer spends in the jlay>=ilay layer
      (accounting for a factor of 2 due to symmetry)


   .. py:method:: plot_T_profile(ax, invert_p=True, use_altitudes=False, xscale=None, yscale=None, **kwarg)

      Plot the T P profile

      :param ax: A pyplot axes instance where to put the plot.
      :type ax: :class:`pyplot.Axes`
      :param x/yscale: If 'log' log axes are used.
      :type x/yscale: :class:`str`, *optional*


   .. py:method:: write_soundings(dirname='.', fmt='%.10e', cp=None, qvap=None, p0=None, p_dry=None)

      Writes sounding files that can be used to initiate the mesoscale model