Line data    Source code

       1             : /**
       2             :    \file model_iface.cpp
       3             :    Renamed model_iface.cc 2023
       4             :    
       5             :    Bojan Nikolic <b.nikolic@mrao.cam.ac.uk>, <bojan@bnikolic.co.uk>
       6             :    
       7             : */
       8             : 
       9             : #include "model_iface.h"
      10             : 
      11             : #include <stdio.h>
      12             : 
      13             : #include <bnmin1/src/minim.h>
      14             : 
      15             : #include "models_basic.h"
      16             : #include "radiometermeasure.h"
      17             : #include "slice.h"
      18             : #include "columns.h"
      19             : #include "lineparams.h"
      20             : #include "basicphys.h"
      21             : #include "partitionsum.h"
      22             : #include "partitionsum_testdata.h"
      23             : #include "rtranfer.h"
      24             : #include "layers.h"
      25             :  
      26             : namespace LibAIR2 {
      27             : 
      28         243 :   WVRAtmoQuants::~WVRAtmoQuants(void)
      29             :   {
      30         243 :   }
      31             : 
      32             :   std::array<double, 4>
      33           0 :   WVRAtmoQuantModel::evalFn(double x, const std::string &pname)
      34             :   {
      35             :     std::array<double, 4> res;
      36           0 :     Minim::ModelDesc md(*this);
      37           0 :     double oldval=*md[pname]->p;
      38           0 :     *md[pname]->p=x;
      39           0 :     std::vector<double> Tb(4);
      40           0 :     eval(Tb);
      41           0 :     for(size_t i=0; i<4; ++i)
      42           0 :       res[i]=Tb[i];
      43           0 :     *md[pname]->p=oldval;
      44           0 :     return res;
      45           0 :   }
      46             : 
      47          81 :   CouplingModel::CouplingModel(WVRAtmoQuantModel * am):
      48          81 :     coupling(1.0),
      49          81 :     TTerm(1.0),
      50          81 :     _am(am)
      51             :   {
      52          81 :   }
      53             : 
      54          81 :   void CouplingModel::setSpill(double c, double T)
      55             :   {
      56          81 :     coupling=c;
      57          81 :     TTerm=T;
      58          81 :   }
      59             : 
      60           0 :   double CouplingModel::eval(size_t ch) const 
      61             :   {
      62           0 :     const double TSky=_am->eval(ch);
      63           0 :     return coupling*TSky + (1-coupling)* TTerm;
      64             :   }
      65             : 
      66    77889705 :   void CouplingModel::eval(std::vector<double> & res) const 
      67             :   {
      68    77889705 :     _am->eval(res);
      69   389448525 :     for (size_t i =0 ; i < res.size() ; ++i)
      70   311558820 :       res[i]= coupling * res[i] + (1-coupling)* TTerm;
      71    77889705 :   }
      72             : 
      73           0 :   double CouplingModel::dTdc (size_t ch) const
      74             :   {
      75           0 :     return coupling*_am->dTdc(ch); 
      76             :   }
      77             : 
      78           0 :   double CouplingModel::dTdL_ND (size_t ch) const
      79             :   {
      80           0 :     return coupling*_am->dTdL_ND(ch);
      81             :   }
      82             :   
      83      807800 :   void CouplingModel::dTdL_ND (std::vector<double> & res) const
      84             :   {
      85      807800 :     _am->dTdL_ND(res);
      86             : 
      87     4039000 :     for( double &x: res)
      88             :     {
      89     3231200 :       x*= coupling;
      90             :     }
      91             :       
      92      807800 :   }
      93             :   
      94         243 :   void   CouplingModel::AddParams ( std::vector< Minim::DParamCtr > &pars )
      95             :   {
      96         243 :     _am->AddParams(pars);
      97             : 
      98         243 :     pars.push_back(Minim::DParamCtr ( &coupling ,      
      99             :                                       "coupling", 
     100             :                                       true     ,                       
     101             :                                       "Coupling to sky"
     102             :                                       ));
     103             : 
     104         243 :     pars.push_back(Minim::DParamCtr ( &TTerm ,      
     105             :                                       "TTerm", 
     106             :                                       false,                       
     107             :                                       "Termination temperature"
     108             :                                       ));
     109         243 :   }
     110             : 
     111           0 :   AbsCalModel::AbsCalModel(WVRAtmoQuantModel * am,
     112           0 :                            size_t nchan):
     113           0 :     zero(nchan, 0.0),
     114           0 :     scale(nchan, 1.0),
     115           0 :     _am(am)
     116             :   {
     117           0 :   }
     118             : 
     119           0 :   double AbsCalModel::eval(size_t ch) const 
     120             :   {
     121           0 :     const double TSky=_am->eval(ch);
     122           0 :     return zero[ch]+scale[ch]*TSky;
     123             :   }
     124             : 
     125           0 :   void AbsCalModel::eval(std::vector<double> & res) const 
     126             :   {
     127           0 :     _am->eval(res);
     128           0 :     for (size_t i =0 ; i < res.size() ; ++i)
     129           0 :       res[i]= scale[i] * res[i] + zero[i];
     130           0 :   }
     131             : 
     132           0 :   double AbsCalModel::dTdc (size_t ch) const
     133             :   {
     134           0 :     return scale[ch]*_am->dTdc(ch); 
     135             :   }
     136             : 
     137           0 :   double AbsCalModel::dTdL_ND (size_t ch) const
     138             :   {
     139           0 :     return scale[ch]*_am->dTdL_ND(ch);
     140             :   }
     141             :   
     142           0 :   void AbsCalModel::dTdL_ND (std::vector<double> & res) const
     143             :   {
     144           0 :     _am->dTdL_ND(res);
     145           0 :     for(size_t i=0; i<res.size(); ++i)
     146           0 :       res[i]=scale[i]*res[i];
     147           0 :   }
     148             : 
     149           0 :   void AbsCalModel::AddParams(std::vector<Minim::DParamCtr> &pars)
     150             :   {
     151           0 :     _am->AddParams(pars);
     152             :     char tstr[20];
     153             :     
     154           0 :     for(size_t i=0; i<zero.size(); ++i)
     155             :     {
     156           0 :       sprintf(tstr, "%i", (i+1));
     157           0 :       std::string mychan(tstr);
     158           0 :       pars.push_back(Minim::DParamCtr(&zero[i],      
     159           0 :                                       std::string("abszero")+mychan, 
     160             :                                       true,                       
     161           0 :                                       std::string("Absolute calibration zero of channel ")+mychan
     162             :                                       ));
     163             : 
     164           0 :       pars.push_back(Minim::DParamCtr(&scale[i],      
     165           0 :                                       std::string("absscale")+mychan,
     166             :                                       true,                       
     167           0 :                                       std::string("Absolute calibration scaling of channel ")+mychan
     168             :                                       ));
     169           0 :     }
     170           0 :   }
     171             : 
     172             : 
     173             : 
     174             : }
     175             : 
     176             : 
     177             :