Line data    Source code

       1             : /**
       2             :    \file columns.cpp
       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.cc 2023
       9             : 
      10             : */
      11             : 
      12             : #include "columns.h"
      13             : 
      14             : #include "slice.h"
      15             : #include "lineparams.h"
      16             : #include "lineshapes.h"
      17             : #include "basicphys.h"
      18             : 
      19             : namespace LibAIR2 {
      20             : 
      21   159010610 :   void Column::setN(double nnew)
      22             :   {
      23   159010610 :     n=nnew;
      24   159010610 :   }
      25             : 
      26           0 :   TrivialGrossColumn::TrivialGrossColumn(const HITRAN_entry  & he,
      27           0 :                                          double n):
      28             :     Column(n),
      29           0 :     he( new HITRAN_entry(he) ),
      30           0 :     pt(NULL)
      31             :   {
      32             : 
      33           0 :   }
      34             : 
      35          81 :   TrivialGrossColumn::TrivialGrossColumn(const HITRAN_entry  & he,
      36             :                                          const PartitionTable *pt,
      37          81 :                                          double n) :
      38             :     Column(n),
      39          81 :     he( new HITRAN_entry(he) ),
      40          81 :     pt(pt)
      41             :   {
      42          81 :   }
      43             : 
      44    79505305 :   void TrivialGrossColumn::ComputeTau( const std::vector<double> & f,
      45             :                                        const Slice & s,
      46             :                                        std::vector<double> & res) const
      47             :   {
      48    79505305 :     res.resize(f.size() );
      49             : 
      50             :     CLineParams cp;
      51             : 
      52    79505305 :     if ( pt == NULL)
      53             :     {
      54           0 :       ComputeLinePars( *he, 
      55             :                        s.getT() , s.getP(),
      56             :                        0, 296,
      57             :                        cp);
      58             :     }
      59             :     else
      60             :     {
      61   159010610 :       ComputeLineParsWQ( *he, 
      62    79505305 :                          *pt,
      63             :                          s.getT() , s.getP(),
      64             :                          0, 296,
      65             :                          cp);
      66             :     }
      67             : 
      68  3259717505 :     for(size_t i =0 ; i < f.size() ; ++i )
      69             :     {
      70  6360424400 :       res[i]= GrossLine( f[i],
      71  6360424400 :                          cp.f0, cp.gamma, cp.S) * getN();
      72             :     }
      73             :     
      74             :     
      75             :     
      76    79505305 :   }
      77             : 
      78           0 :   H2OCol::H2OCol(const PartitionTable * pt,
      79           0 :                  size_t nl):
      80             :     Column(0),
      81           0 :     ltable(get_h2o_lines()),
      82           0 :     pt(pt)
      83             :   {
      84           0 :     if (nl==0)
      85             :     {
      86           0 :       nlines=get_h2o_lines_n();
      87             :     }
      88             :     else
      89             :     {
      90           0 :       nlines=nl;
      91             :     }
      92           0 :   }
      93             : 
      94           0 :   void H2OCol::ComputeTau(const std::vector<double> &f,
      95             :                           const Slice &s,
      96             :                           std::vector<double> &res) const
      97             :   {
      98           0 :     res=std::vector<double>(f.size(), 0.0);
      99           0 :     const double N=getN();
     100             :     CLineParams cp;
     101             : 
     102           0 :     for(size_t i=0; i<nlines; ++i)
     103             :     {
     104           0 :       ComputeLineParsWQ(ltable[i], 
     105           0 :                         *pt,
     106             :                         s.getT(),
     107             :                         s.getP(),
     108             :                         0, 296,
     109             :                         cp);
     110             : 
     111           0 :       for(size_t i =0 ; i < f.size() ; ++i )
     112             :       {
     113           0 :         res[i]+=GrossLine(f[i],
     114             :                           cp.f0,
     115             :                           cp.gamma,
     116           0 :                           cp.S)*N;
     117             :       }
     118             :     }
     119           0 :   }
     120             : 
     121          81 :   ContinuumColumn::ContinuumColumn( double n,
     122          81 :                                     ContinuumParams * cp) :
     123             :     Column(n),
     124          81 :     cp(cp)
     125             :   {
     126             : 
     127          81 :   }
     128             : 
     129    79505305 :   void ContinuumColumn::ComputeTau( const std::vector<double> & f,
     130             :                                     const Slice & s,
     131             :                                     std::vector<double> & res) const
     132             :   {
     133             : 
     134    79505305 :     const double nair = ( s.getP() / STP2::P_STP) * 
     135    79505305 :       (STP2::T_STP / s.getT() ) * STP2::N_STP;
     136             : 
     137             : 
     138    79505305 :     const double r = cp->C0 * pow( cp->T0 / s.getT() , cp->m) * getN() * nair;
     139             : 
     140  3259717505 :     for(size_t i =0 ; i < f.size() ; ++i )
     141             :     {
     142  3180212200 :       res[i]= r * pow(f[i],2) ; 
     143             :     }
     144             : 
     145    79505305 :   }
     146             :   
     147           0 :   EmpContColumn::EmpContColumn(double n,
     148           0 :                                double f0):
     149             :     Column(n),
     150           0 :     ff(1.0/f0)
     151             :   {
     152           0 :   }
     153             :   
     154           0 :   void EmpContColumn::ComputeTau(const std::vector<double> &f,
     155             :                                  const Slice &s,
     156             :                                  std::vector<double> &res) const
     157             :   {
     158             :     (void) s; // use not yet implemented
     159           0 :     const double r=getN();
     160           0 :     for(size_t i=0 ; i<f.size(); ++i)
     161             :     {
     162           0 :       res[i]= r * pow(f[i]*ff,2) ; 
     163             :     }
     164             :     
     165           0 :   }
     166             : 
     167             : }
     168             : 
     169             :