Line data    Source code

       1             : /**
       2             :    \file radiometer_utils.cpp
       3             :    Bojan Nikolic <bn204@mrao.cam.ac.uk>, <bojan@bnikolic.co.uk>
       4             :    
       5             :    Initial version March 2008
       6             :    Maintained by ESO since 2013.
       7             :    Renamed radiometer_utils.cc 2023
       8             : 
       9             : */
      10             : 
      11             : #include "radiometer_utils.h"
      12             : 
      13             : #include <algorithm>
      14             : 
      15             : #include "radiometermeasure.h"
      16             : 
      17             : 
      18             : namespace LibAIR2 {
      19             : 
      20             :   /**
      21             :      Helper class for merging of radiometers
      22             :    */
      23             :   struct RadioIter 
      24             :   {
      25             :     std::vector<double>::const_iterator f_i;
      26             :     std::vector<double>::const_iterator c_i;
      27             : 
      28             :     std::vector<double>::const_iterator f_end;
      29             : 
      30         324 :     RadioIter ( const Radiometer * r, 
      31         324 :                 size_t ch) :
      32         324 :       f_i  ( r->getFGrid().begin() ),
      33         324 :       c_i  ( r->getCoeffs(ch).begin()),
      34         324 :       f_end( r->getFGrid().end() )
      35             :     {
      36         324 :     }
      37             : 
      38       21789 :     bool atend(void) const
      39             :     {
      40       21789 :       return ( f_i == f_end  );
      41             :     }
      42             : 
      43        9963 :     bool operator< (  const RadioIter & other ) const
      44             :     {
      45        9963 :       if (atend())
      46             :       {
      47        1458 :         return false;
      48             :       }
      49        8505 :       else if ( other.atend() )
      50             :       {
      51        1215 :         return true;
      52             :       }
      53             :       else
      54             :       {
      55        7290 :         return (*f_i) < (*other.f_i);
      56             :       }
      57             :     }
      58             : 
      59        3240 :     void advance(void)
      60             :     {
      61        3240 :       ++f_i;
      62        3240 :       ++c_i;
      63        3240 :     }
      64             : 
      65             : 
      66             : 
      67             :   };
      68             : 
      69          81 :   std::unique_ptr<Radiometer> MergeRadiometers( std::vector<const Radiometer *> & vr)
      70             :   {
      71             :     
      72             :     // Number of radiometers
      73          81 :     const size_t nr( vr.size() );
      74             :     
      75             :     // The merged frequency grid
      76          81 :     std::vector<double> fg;
      77             : 
      78             :     // The vector of coeffiecients
      79          81 :     std::vector< std::vector<double> >  cv( nr);
      80             : 
      81             :     // The vector iterators
      82          81 :     std::vector< RadioIter >  iv;    
      83         405 :     for ( size_t i =0 ; i < nr ; ++i )
      84         324 :       iv.push_back(RadioIter(vr[i], 0));
      85             : 
      86          81 :     std::vector< RadioIter >::iterator iv_first= iv.begin();
      87             : 
      88             :     while (true)
      89             :     {
      90             :       // i is the radiometer with the smallest current frequency in
      91             :       // the set.
      92             :       std::vector< RadioIter >::iterator i =
      93        3321 :         std::min_element( iv.begin(), iv.end() );
      94             : 
      95        3321 :       if (i->atend())
      96             :       {
      97             :         // we are done
      98          81 :         break;
      99             :       }
     100             : 
     101        3240 :       fg.push_back( * (i->f_i) );
     102       16200 :       for (size_t j = 0  ; j < nr ; ++j)
     103             :       {
     104       12960 :         if ( (i- iv_first)  == (int)j) 
     105             :         {
     106        3240 :           cv[j].push_back( *(i->c_i)  );
     107             :         }
     108             :         else
     109             :         {
     110        9720 :           cv[j].push_back(0.0 );
     111             :         }
     112             :       }
     113             :       
     114        3240 :       i->advance();
     115             : 
     116        3240 :     }
     117             :     
     118         162 :     return std::unique_ptr<Radiometer> ( new Radiometer( fg, cv));
     119             : 
     120          81 :   }
     121             : 
     122             : 
     123             : }
     124             : 
     125             :