Line data    Source code

       1             : /**
       2             :    \file rtranfer.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             :    Renamed rtranfer.cc 2023
       8             : 
       9             :    Some code was previously in slice.hpp/slice.cpp 
      10             : 
      11             : */
      12             : 
      13             : #include "rtranfer.h"
      14             : 
      15             : #include "slice.h"
      16             : #include "basicphys.h"
      17             : #include "layers.h"
      18             : 
      19             : namespace LibAIR2 {
      20             :   
      21         162 :   RTResult::RTResult(const std::vector<double> &fp):
      22         162 :     I(fp.size(), 0.0),
      23         162 :     Tb(fp.size()),
      24         162 :     _f(fp),
      25         162 :     f(_f)    
      26             :   {
      27         162 :   }
      28             : 
      29    79505305 :   const std::vector<double> &  RTResult::UpdateTb()
      30             :   {
      31  3259717505 :     for (size_t i =0 ; i< f.size() ; ++i)
      32             :     {
      33  3180212200 :       Tb[i]  = I[i] / std::pow(f[i],2)  * CSquared_On_TwoK;  ;
      34             :     }
      35    79505305 :     return Tb;
      36             :   }  
      37             : 
      38             : 
      39         162 :   SliceResult::SliceResult( const Slice & p_slice,
      40         162 :                             const std::vector<double> & f ) :
      41             :     RTResult(f),
      42         162 :     tx(f.size()),
      43         162 :     slice(p_slice)
      44             :   {
      45             : 
      46         162 :   }
      47             : 
      48    79505305 :   void SliceResult::UpdateI(const SliceResult & bckg)
      49             :   {
      50             : 
      51    79505305 :     slice.ComputeTx( f, tx);
      52             :     
      53  3259717505 :     for (size_t i =0 ; i< f.size() ; ++i)
      54             :     {
      55  6360424400 :       I[i]  = tx[i] * bckg.I[i] + 
      56  3180212200 :         BPlanck(f[i], slice.getT())  * (1-tx[i]) ;
      57             :     }
      58    79505305 :   }
      59             : 
      60          81 :   void SliceResult::UpdateI(void)
      61             :   {
      62          81 :     slice.ComputeTx( f, tx);
      63             : 
      64        3321 :     for (size_t i =0 ; i< f.size() ; ++i)
      65             :     {
      66        3240 :       I[i]  = BPlanck(f[i], slice.getT())  * (1-tx[i]) ;
      67             :     }
      68             : 
      69          81 :   }
      70             : 
      71           0 :   LayerResult::LayerResult(const Layer & p_layer,
      72           0 :                            const std::vector<double> & f ):
      73             :     RTResult(f),
      74           0 :     layer(p_layer)
      75             :   {
      76           0 :   }
      77             : 
      78           0 :   void LayerResult::UpdateI(const SliceResult & bckg)
      79             :   {
      80             :     typedef std::shared_ptr<SliceResult> sr_p;
      81             : 
      82           0 :     sr_p current( new SliceResult(bckg));
      83           0 :     for ( Layer::sliceL_t::const_iterator slice = layer.getFar();
      84           0 :           slice != layer.getEnd();
      85           0 :           ++slice)
      86             :     {
      87           0 :       sr_p newslice( new SliceResult( **slice,
      88           0 :                                       f));
      89           0 :       newslice->UpdateI( *current);
      90           0 :       current=newslice;
      91           0 :     }
      92             :     
      93             :     // Copy result
      94           0 :     I=current->getI();
      95             :     
      96           0 :   }
      97             :   
      98             : }
      99             : 
     100             :