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 slice.hpp
      10             :    Renamed slice.h 2023
      11             : 
      12             : */
      13             : 
      14             : #ifndef _LIBAIR_SLICE_HPP__
      15             : #define _LIBAIR_SLICE_HPP__
      16             : 
      17             : #include <vector>
      18             : 
      19             : namespace LibAIR2 {
      20             : 
      21             :   // Forward declarations
      22             :   class Column;
      23             : 
      24             :   /**
      25             :      \brief A slice is an infinitesimally thin layer of the atmosphere
      26             :    described by single temperature and pressure.
      27             : 
      28             :   */
      29             :   class Slice {
      30             : 
      31             :     /*
      32             :       Not exposing these as const public members since one could
      33             :       envisage performance saving by updating existing slices.
      34             :      */
      35             : 
      36             :     /// Slice temperature
      37             :     double T;
      38             :     /// Slice pressure
      39             :     double P;
      40             : 
      41             :     std::vector<const Column *> cols;
      42             : 
      43             :   public:
      44             :     
      45             :     /// Scaling for all of the columns
      46             :     const double scale;
      47             : 
      48             :     // ---------- Construction / Destruction --------------
      49             : 
      50             :     Slice( double T , double P,
      51             :            double scale=1.0);
      52             : 
      53           0 :     virtual ~Slice() {};
      54             : 
      55             :     // ---------- Public interface ------------------------
      56             : 
      57             :     /**
      58             :        Add a column to this slice. The list of columns is used to
      59             :        compute the transmission of this slice.
      60             :      */
      61             :     void AddColumn (const Column & c);
      62             :     
      63             :     /// Returns the slice temperature
      64           0 :     double getT(void) const
      65           0 :     { return T ; } ;
      66             : 
      67             :     /// Set the temperature
      68           0 :     void setT(double Tnew)
      69             :     {
      70           0 :       T=Tnew;
      71           0 :     }
      72             :     
      73             : 
      74             :     /// Returns the slice pressure
      75           0 :     double getP(void) const
      76           0 :     { return P ; } ;
      77             : 
      78             :     /// Set the pressure of the slice
      79           0 :     void setP(double Pnew) 
      80             :     {
      81           0 :       P=Pnew;
      82           0 :     }
      83             : 
      84             :     /**
      85             :        \brief Compute the transmisison of this slice
      86             : 
      87             :        \param f The frequency grid  
      88             :        \param res The transmission coefficients are stored here
      89             : 
      90             :      */
      91             :     virtual void ComputeTx (const std::vector<double> & f,
      92             :                             std::vector<double> & res) const ;
      93             : 
      94             :   };
      95             : 
      96             :   /** \brief A slice whose transmission is always zero
      97             :    */
      98             :   class OpaqueSlice :
      99             :     public Slice
     100             :   {
     101             : 
     102             :   public:
     103             : 
     104             :     // ---------- Construction / Destruction --------------
     105             : 
     106             :     OpaqueSlice( double T , double P);
     107             : 
     108             :     // ---------- Inherited from Slice
     109             :     virtual void ComputeTx (const std::vector<double> & f,
     110             :                             std::vector<double> & res) const ;
     111             : 
     112             :   };
     113             : 
     114             : 
     115             : 
     116             : }
     117             : 
     118             : #endif
     119             :