Line data    Source code

       1             : /**
       2             :    Bojan Nikolic <bn204@mrao.cam.ac.uk>, <bojan@bnikolic.co.uk>
       3             :    Initial version February 2008
       4             :    Maintained by ESO since 2013.
       5             : 
       6             :    This file is part of LibAIR and is licensed under GNU Public
       7             :    License Version 2
       8             : 
       9             :    \file rtranfer.hpp
      10             :    Renamed rtransfer.h 2023
      11             : 
      12             :    Radiative transfer. Some code was previously in slice.hpp/slice.cpp
      13             : */
      14             : #ifndef __LIBAIR_RTRANSFER_HPP__
      15             : #define __LIBAIR_RTRANSFER_HPP__
      16             : 
      17             : #include <vector>
      18             : 
      19             : namespace LibAIR2 {
      20             : 
      21             :   // Forward declarations
      22             :   class Slice;
      23             :   class Layer;
      24             :   class SliceResult;
      25             : 
      26             :   /**
      27             :      A container to store the results of radiative transfer
      28             :      calculation.
      29             :    */
      30             :   class RTResult {
      31             : 
      32             :   protected:
      33             :     /// Irradiance of this component
      34             :     std::vector<double> I;
      35             : 
      36             :   private:
      37             :     /// Brighness temperature of this component
      38             :     std::vector<double> Tb;
      39             : 
      40             :     /// Our copy of the frequency grid
      41             :     std::vector<double>  _f;
      42             : 
      43             :   public:
      44             :     
      45             :     /// Frequency grid
      46             :     const std::vector<double> &f;
      47             :     
      48             :     // ---------- Construction / Destruction --------------    
      49             : 
      50             :     /**
      51             :        \param f The grid of frequencies at which result will be
      52             :        computed.
      53             :      */
      54             :     RTResult(const std::vector<double> &fp);
      55             :     
      56           0 :     virtual ~RTResult() {};
      57             : 
      58             : 
      59             :     // ---------- Public interface ------------------------
      60             : 
      61             :     /**
      62             :        \brief Compute the brightness temperature of this component of
      63             :        the atmosphere.
      64             : 
      65             :        Uses the Raleigh-Jeans approximation.
      66             :      */
      67             :     const std::vector<double> & UpdateTb(void);
      68             : 
      69             :     /** \brief Update the irradiance of this slice
      70             :      */
      71             :     virtual void UpdateI(const SliceResult & bckg) = 0;
      72             : 
      73             : 
      74           0 :     const std::vector<double>  & getI(void)
      75             :     {
      76           0 :       return I;
      77             :     }
      78             :   };
      79             : 
      80             :   /**
      81             :      The result of the computation for one slice
      82             :    */
      83             :   class SliceResult:
      84             :     public RTResult
      85             :   {
      86             :     /// Transmissivity of this slice
      87             :     std::vector<double> tx;
      88             : 
      89             :   public:
      90             : 
      91             :     /// Const reference to slice that this result is for
      92             :     const Slice & slice;
      93             : 
      94             :     // ---------- Construction / Destruction --------------
      95             :     SliceResult( const Slice & p_slice,
      96             :                  const std::vector<double> & f ) ;
      97             : 
      98             :     // ---------- Public interface ------------------------
      99             : 
     100             :     virtual void UpdateI(const SliceResult & bckg);
     101             :     /**
     102             :        Update irradiance assuming zero-temperature background. Only
     103             :        makes sense really for opaque slices.
     104             :      */
     105             :     void UpdateI(void);
     106             : 
     107             :   };
     108             : 
     109             :   /**
     110             :      Compute radiative transfer for a layer
     111             :   */
     112             :   class LayerResult:
     113             :     public RTResult
     114             :   {
     115             : 
     116             :   public:    
     117             :     
     118             :     const Layer & layer;
     119             : 
     120             :     // ---------- Construction / Destruction --------------
     121             :     LayerResult(const Layer & p_layer,
     122             :                 const std::vector<double> & f );
     123             :     
     124             :     // ---------- Public interface ------------------------    
     125             : 
     126             :     void UpdateI(const SliceResult & bckg);
     127             : 
     128             :   };
     129             :   
     130             :   
     131             : 
     132             : }
     133             : 
     134             : #endif