##########################################
**The ADM modules and programs**
##########################################

**Module mag_adm_vol**
======================================


**Module   : mag_adm**

**Purpose  : (arbitrary) analytic dynamical magnetosphere data**


.. class::  adm_vol_t

   ADM field volume
   
   type, extends (field_vol_t)
  
   :param rho_w(:,:,:): Density in wind regions -- real(WP), allocatable
   :param rho_h(:,:,:): Density in hot regions -- real(WP), allocatable
   :param rho_c(:,:,:): Density in cooled regions -- real(WP), allocatable
   :param v_w(:,:,;): Velocity in wind regions -- real(WP), allocatable
   :param v_h(:,:,:): Velocity in hot regions -- real(WP), allocatable
   :param v_c(:,:,:): Velocity in cooled regions -- real(WP), allocatable
   :param T_h(:,:,:): Temperature in hot regions -- real(WP), allocatable
   :param M_star: Stellar mass -- real(WP)
   :param R_star: Stellar radius -- real(WP)
   :param T_eff: Stellar effective temperature -- real(WP)
   :param X: Hydrogen abundance -- real(WP)
   :param Z: Metal abundance -- real(WP)
   :param M_dot: Wind mass-loss rate -- real(WP)
   :param beta: Wind velocity law exponent -- real(WP)
   :param v_inf: Wind terminal speed -- real(WP)
   :param Lambda: Coooling rate -- real(WP)
   :param R_c: Closure radius (R_star) -- real(WP)
   :param delta: Smoothing length (R_star) -- real(WP)
   :param process_node: process a particular node -- procedure
   :param bcast_nodes: broadcast the class if MPI -- procedure

.. class::  shock_func_t

   shock properties
  
   type, extends (func_t)
  
   :param r_m: radius of the loop apex (point farthest from the star) -- real(WP)
   :param B_m: magnetic field at the loop apex -- real(WP)
   :param g_m: g function (path inegral result) at the loop apex -- real(WP)
   :param B_star: magnetic field value of star -- real(WP)
   :param mu_B: dot product of r and B -- real(WP)
   :param beta: wind acceleration exponent -- real(WP)
   :param r_beta: radius where wind speed is sound speed when following a beta velocity law -- real(WP)
   :param chi_inf: cooling parameter; >>1 is adiabatic, <<1 is radiative -- real(WP)
   :param sp_r: radial spline -- :class:`spline_t`
   :param sp_B: magnetic field spline -- :class:`spline_t`
   :param sp_g: path-integral-function spline -- :class:`spline_t`
   :param verbose: -- logical
   :param eval_c_: evaluate the shock discriminant -- procedure

.. function:: adm_vol_t_ (fv) result (av)

   Construct the adm_vol_t
  
   function
  
   :param fv: field volume -- :class:`field_vol_t`, intent(in)
   :param av: ADM volume -- :class:`adm_vol_t`

.. function:: locate_shock_ (s, r_m, B_m, g_m, B_star, mu_B, &

   locate the shock
  
   function
  
   :param s(:): position along loop -- real(WP), intent(in)
   :param r_m: radius at shock apex -- real(WP), intent(in)
   :param B_m: magnetic field at shock apex -- real(WP), intent(in)
   :param g_m: g function (path inegral result) at the loop apex -- real(WP), intent(in)
   :param B_star: star magnetic field - real(WP), intent(in)
   :param mu_B: dot product of r and B -- real(WP), intent(in)
   :param beta: wind acceleration exponent -- real(WP), intent(in)
   :param r_beta: radius where wind speed is sound speed when following a beta velocity law -- real(WP), intent(in)
   :param chi_inf: cooling parameter; >>1 is adiabatic, <<1 is radiative -- real(WP), intent(in)
   :param sp_r: radial spline -- real(WP), intent(in)
   :param sp_B: magnetic field spline -- real(WP), intent(in)
   :param sp_g: path-tinegral-function spline -- real(WP), intent(in)
   :rtype s_s: s position (along loop) of shock -- real(WP)

.. function:: eval_c_ (this, z) result (f_z)

   Evaluate the shock discriminant function, defined by XADM (B15)
  
   function
  
   :param this: shock in question -- :class:`shock_func_t`, intent(inout)
   :param z: real part is position along path length -- complex(WP), intent(in)
   :rtype f_z: shock discriminant -- complex(WP)

.. function:: read_ (hg, av)

   Read the adm_vol_t
  
   only if hdf5
  
   subroutine
  
   :param hg: ihdf5 data set -- :class:`hgroup_t`, intent(inout)
   :rtype av: ADM volume -- :class:`adm_vol_t`, intent(out)

.. function:: write_ (hg, av)

   Write the adm_vol_t
  
   only if hdf5
  
   subroutine
  
   :param hg: ihdf5 data set -- :class:`hgroup_t`, intent(inout)
   :param av: ADM volume -- :class:`adm_vol_t`, intent(in)

.. function:: process_node (this, vi, fl)

   Process the node
  
   subroutine
  
   :param this: ADM volume -- :class:`adm_vol_t`, intent(inout)
   :param vi(:): position for evaluation -- integer, intent(in) 
   :param fl: field line -- :class:`field_line_t`, intent(in)

.. function:: bcast_ (av, root_rank)

   Broadcast the adm_vol_t
  
   only if MPI
  
   subroutine
  
   :param av: ADM volume to broadcast -- :class:`adm_vol_t`, intent(inout)
   :param root_rank: rank of the root processor node -- integer, intent(in)

.. function:: bcast_nodes (this, vi_a, vi_b, root_rank)

   Broadcast the nodes with indices between i_a and i_b
  
   only if MPI
  
   subroutine
  
   :param this: ADM volume to broadcast -- :class:`adm_vol_t`, intent(inout)
   :param vi_a(:): lower indices of broadcasting -- integer, intent(in)
   :param vi_b(:): upper indices of broadcasting -- integer, intent(in)
   :param root_rank: rank of the root processor node -- integer, intent(in)


**Module build_adm_vol**
======================================


**Program  : build_arrm**

**Purpose  : build adm_vol**