Line data    Source code

       1             : /**
       2             :    \file columns.hpp
       3             :    Bojan Nikolic <bn204@mrao.cam.ac.uk>, <bojan@bnikolic.co.uk>
       4             :    
       5             :    Initial version February 2008
       6             :    Maintained by ESO since 2013.
       7             : 
       8             :    Renamed columns.h 2023
       9             : 
      10             : */
      11             : 
      12             : #ifndef __LIBAIR__COLUMNS__HPP__
      13             : #define __LIBAIR__COLUMNS__HPP__
      14             : 
      15             : #include <vector>
      16             : #include <memory>
      17             : 
      18             : namespace LibAIR2 {
      19             : 
      20             :   // Forwards 
      21             :   struct HITRAN_entry ;
      22             :   struct ContinuumParams ;  
      23             : 
      24             :   class  PartitionTable;
      25             :   class  Slice;
      26             : 
      27             :   /**
      28             :      \brief A base class for types of columns
      29             : 
      30             :    */
      31             :   class Column 
      32             :   {
      33             : 
      34             :     /// The number of atoms of this species in this column
      35             :     double n;
      36             : 
      37             :   public:
      38             : 
      39             :     // ---------- Construction / Destruction --------------
      40             : 
      41           0 :     Column(double n):
      42           0 :       n(n)
      43           0 :     {};
      44             : 
      45             : 
      46           0 :     virtual ~Column() {};
      47             : 
      48             :     // ---------- Public interface ------------------------
      49             : 
      50             : 
      51             :     /** \brief Set the column densitiy to a new value
      52             :      */
      53             :     void setN(double nnew);
      54             : 
      55             :     /** \brief Return the column density 
      56             :      */
      57           0 :     double getN(void) const
      58             :     {
      59           0 :       return n;
      60             :     }
      61             : 
      62             :     /**
      63             :        Compute opacity of this line on a set of frequencies.
      64             :      */
      65             :     virtual void ComputeTau( const std::vector<double> & f,
      66             :                              const Slice & s,
      67             :                              std::vector<double> & res) const = 0;
      68             : 
      69             :   };
      70             : 
      71             :   /**
      72             :      An experiemntal class for a column of a species that only
      73             :      contains a single line.
      74             : 
      75             :      \bug No proper reference temperature handling
      76             :      \bug No volume mixing
      77             :      \bug Single line only
      78             : 
      79             :    */
      80             :   class TrivialGrossColumn :
      81             :     public Column
      82             :   {
      83             :     std::unique_ptr<HITRAN_entry>  he;
      84             : 
      85             :     /**
      86             :        If provided, the partition table goes here. The correction is
      87             :        always applied from the table if it is present.
      88             :      */
      89             :     const PartitionTable * pt;
      90             : 
      91             :   public:
      92             :     
      93             :     // ---------- Construction / Destruction --------------
      94             : 
      95             :     /** 
      96             :         \param n the column density of the species
      97             :      */
      98             :     TrivialGrossColumn(const HITRAN_entry  & he,
      99             :                        double n);
     100             : 
     101             :     /** \brief Costructor taking a PartitionTable
     102             : 
     103             :         The partition table is used in the calculation.
     104             : 
     105             :         \note Not makig a copy of the partition table
     106             :      */
     107             :     TrivialGrossColumn(const HITRAN_entry   & he,
     108             :                        const PartitionTable * pt,
     109             :                        double n);
     110             :     
     111             :     
     112             :     // ---------- Public interface ------------------------
     113             : 
     114             : 
     115             :     // ------------------ Inherited from Column -------------
     116             :     void ComputeTau( const std::vector<double> & f,
     117             :                      const Slice & s,
     118             :                      std::vector<double> & res) const;
     119             : 
     120             :   };
     121             : 
     122             :   /**
     123             : 
     124             :    */
     125             :   class H2OCol:
     126             :     public Column    
     127             :   {
     128             :     
     129             :     const HITRAN_entry * ltable;
     130             :     size_t nlines;
     131             : 
     132             :     const PartitionTable * pt;
     133             : 
     134             :   public:
     135             : 
     136             :     H2OCol(const PartitionTable * pt,
     137             :            size_t nlines=0);
     138             : 
     139             :     // ---------- Public interface ------------------------
     140             :     // ------------------ Inherited from Column -------------
     141             :     void ComputeTau( const std::vector<double> & f,
     142             :                      const Slice & s,
     143             :                      std::vector<double> & res) const;
     144             :     
     145             :   };
     146             : 
     147             :   /** \brief An experimental column to represent the continuum due to
     148             :       a species.
     149             : 
     150             :    */
     151             :   class ContinuumColumn :     
     152             :     public Column
     153             :   {
     154             : 
     155             :     std::unique_ptr<ContinuumParams>  cp;
     156             : 
     157             :   public:
     158             :     
     159             :     // ---------- Construction / Destruction --------------
     160             : 
     161             :     /**
     162             :        \param cp take ownership of this parameter
     163             :      */
     164             :     ContinuumColumn( double n,
     165             :                      ContinuumParams * cp) ;
     166             : 
     167             : 
     168             :     // ------------------ Inherited from Column -------------
     169             :     void ComputeTau( const std::vector<double> & f,
     170             :                      const Slice & s,
     171             :                      std::vector<double> & res) const;    
     172             :     
     173             :     
     174             :   };
     175             : 
     176             :   /** \brief Column representing an empirical continuum
     177             : 
     178             :       The parameter N is intepreted as the opacity at a reference
     179             :       frequency. Frequency squared dependence of opacity is assuemd
     180             :       
     181             :   */
     182             :   class EmpContColumn:
     183             :     public Column
     184             :   {
     185             :     const double ff;
     186             : 
     187             :   public:
     188             : 
     189             :     /**  
     190             :          \param n The initial species column (in this case opacity at
     191             :          f0)
     192             :          
     193             :          \param f0 The reference frequency
     194             :      */
     195             :     EmpContColumn(double n,
     196             :                   double f0);
     197             : 
     198             :     // ------------------ Inherited from Column -------------
     199             :     void ComputeTau(const std::vector<double> &f,
     200             :                     const Slice &s,
     201             :                     std::vector<double> &res) const;        
     202             : 
     203             :   };
     204             : 
     205             : }
     206             : 
     207             : #endif