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           0 :   ISingleLayerWater::ISingleLayerWater(const std::vector<double> &fgrid,
      24             :                                        WaterData::Lines l,
      25             :                                        PartitionTreatment t,
      26             :                                        Continuum c,
      27           0 :                                        double PDrop):
      28             :     WaterData(l,t,c,0.0),
      29           0 :     n(0),
      30           0 :     T(0),
      31           0 :     P(0)    
      32             :   {
      33           0 :     if (PDrop == 0.0)
      34             :     {
      35           0 :       s.reset (new Slice(T, P));
      36           0 :       s->AddColumn(*wcol());
      37           0 :       if (wcont())
      38             :       {
      39           0 :         s->AddColumn(*wcont());
      40             :       }
      41           0 :       sr.reset(new SliceResult(*s,
      42           0 :                                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           0 :     scratch.resize(fgrid.size());
      57           0 :     setBckgT(2.7);
      58           0 :   }
      59             : 
      60           0 :   const std::vector<double> & ISingleLayerWater::TbGrid(void)
      61             :   {
      62           0 :     updatePars();
      63           0 :     sr->UpdateI(*bckg);
      64           0 :     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           0 :   void ISingleLayerWater::updatePars(void)
      82             :   {
      83           0 :     wcol()->setN( n * pmw_mm_to_n );
      84           0 :     if (wcont()) 
      85             :     {
      86           0 :       wcont()->setN( n * pmw_mm_to_n );
      87             :     }
      88             :     
      89           0 :     if (layer)
      90             :     {
      91           0 :       layer->setT(T);
      92           0 :       layer->setP(P);
      93             :     }
      94             :     else
      95             :     {
      96           0 :       s->setT(T);
      97           0 :       s->setP(P);
      98             :     }
      99           0 :   }
     100             : 
     101           0 :   void ISingleLayerWater::setBckgT(double Tbckg)
     102             :   {
     103           0 :     cmbslice.reset(new OpaqueSlice(Tbckg, 0));
     104           0 :     bckg.reset(new SliceResult(*cmbslice,
     105           0 :                                sr->f));
     106           0 :     bckg->UpdateI();
     107           0 :   }
     108             : 
     109             : 
     110           0 :   const std::vector<double> & ISingleLayerWater::getFGrid(void)
     111             :   {
     112           0 :     return sr->f;
     113             :   }
     114             :       
     115             : }
     116             : 
     117             :