Line data    Source code

       1             : /**
       2             :    \file singlelayerwater.cpp
       3             : 
       4             :    Bojan Nikolic <b.nikolic@mrao.cam.ac.uk>
       5             :    Initial version February 2009
       6             :    Maintained by ESO since 2013.
       7             :    Renamed singlelayerwater.cc 2023
       8             :    
       9             : */
      10             : 
      11             : #include "slice.h"
      12             : #include "columns.h"
      13             : #include "basicphys.h"
      14             : #include "partitionsum.h"
      15             : #include "partitionsum_testdata.h"
      16             : #include "rtranfer.h"
      17             : #include "layers.h"
      18             : 
      19             : #include "singlelayerwater.h"
      20             : 
      21             : namespace LibAIR2 {
      22             : 
      23          81 :   ISingleLayerWater::ISingleLayerWater(const std::vector<double> &fgrid,
      24             :                                        WaterData::Lines l,
      25             :                                        PartitionTreatment t,
      26             :                                        Continuum c,
      27          81 :                                        double PDrop):
      28             :     WaterData(l,t,c,0.0),
      29          81 :     n(0),
      30          81 :     T(0),
      31          81 :     P(0)    
      32             :   {
      33          81 :     if (PDrop == 0.0)
      34             :     {
      35          81 :       s.reset (new Slice(T, P));
      36          81 :       s->AddColumn(*wcol());
      37          81 :       if (wcont())
      38             :       {
      39          81 :         s->AddColumn(*wcont());
      40             :       }
      41         162 :       sr.reset(new SliceResult(*s,
      42          81 :                                fgrid));
      43             :     }
      44             :     else
      45             :     {
      46             :       // We have a layer!
      47           0 :       layer.reset(new IsoTLayer(T,P, PDrop));
      48           0 :       layer->AddColumn(*wcol());
      49           0 :       if (wcont())
      50             :       {
      51           0 :         layer->AddColumn(*wcont());
      52             :       }
      53           0 :       sr.reset(new LayerResult(*layer,
      54           0 :                                fgrid));
      55             :     }
      56          81 :     scratch.resize(fgrid.size());
      57          81 :     setBckgT(2.7);
      58          81 :   }
      59             : 
      60    79505305 :   const std::vector<double> & ISingleLayerWater::TbGrid(void)
      61             :   {
      62    79505305 :     updatePars();
      63    79505305 :     sr->UpdateI(*bckg);
      64    79505305 :     return sr->UpdateTb();
      65             :   }
      66             : 
      67             :   const std::vector<double> 
      68           0 :   &ISingleLayerWater::TbGrid(const SliceResult &background)
      69             :   {
      70           0 :     updatePars();
      71           0 :     sr->UpdateI(background);
      72           0 :     return sr->UpdateTb();
      73             :   }
      74             :     
      75             :   
      76           0 :   const SliceResult & ISingleLayerWater::getBckg(void) const
      77             :   {
      78           0 :     return *bckg;
      79             :   }
      80             : 
      81    79505305 :   void ISingleLayerWater::updatePars(void)
      82             :   {
      83    79505305 :     wcol()->setN( n * pmw_mm_to_n );
      84    79505305 :     if (wcont()) 
      85             :     {
      86    79505305 :       wcont()->setN( n * pmw_mm_to_n );
      87             :     }
      88             :     
      89    79505305 :     if (layer)
      90             :     {
      91           0 :       layer->setT(T);
      92           0 :       layer->setP(P);
      93             :     }
      94             :     else
      95             :     {
      96    79505305 :       s->setT(T);
      97    79505305 :       s->setP(P);
      98             :     }
      99    79505305 :   }
     100             : 
     101          81 :   void ISingleLayerWater::setBckgT(double Tbckg)
     102             :   {
     103          81 :     cmbslice.reset(new OpaqueSlice(Tbckg, 0));
     104         162 :     bckg.reset(new SliceResult(*cmbslice,
     105          81 :                                sr->f));
     106          81 :     bckg->UpdateI();
     107          81 :   }
     108             : 
     109             : 
     110           0 :   const std::vector<double> & ISingleLayerWater::getFGrid(void)
     111             :   {
     112           0 :     return sr->f;
     113             :   }
     114             :       
     115             : }
     116             : 
     117             :