Line data    Source code

       1             : /**
       2             :    Bojan Nikolic <b.nikolic@mrao.cam.ac.uk>, <bojan@bnikolic.co.uk>
       3             :    Initial version June 2010. 
       4             :    Maintained by ESO since 2013.
       5             : 
       6             :    This file is part of LibAIR and is licensed under GNU Public
       7             :    License Version 2
       8             :    
       9             :    \file msspec.cpp
      10             :    Renamed msspec.cc 2023
      11             :    
      12             : */
      13             : 
      14             : #include "msspec.h"
      15             : 
      16             : #include <casacore/ms/MeasurementSets/MeasurementSet.h>
      17             : #include <casacore/tables/Tables/Table.h>
      18             : #include <casacore/ms/MeasurementSets/MSColumns.h>
      19             : 
      20             : namespace LibAIR2 {
      21             : 
      22          25 :   void loadSpec(const casacore::MeasurementSet &ms,
      23             :                 const std::vector<int> &spws,
      24             :                 MSSpec &s)
      25             :   {
      26          25 :     casacore::MSSpectralWindow specTable(ms.spectralWindow());
      27             :     // Number of spectral windows in this measurement set
      28             : 
      29          25 :     const size_t nspw=specTable.nrow();
      30             : 
      31             :     // Number of channels 
      32             :     casacore::ScalarColumn<casacore::Int> nc
      33             :       (specTable,
      34          25 :        casacore::MSSpectralWindow::columnName(casacore::MSSpectralWindow::NUM_CHAN));
      35             : 
      36             :     // Frequencies of the channels
      37             :     casacore::ArrayColumn<casacore::Double>
      38             :       chfreq(specTable,
      39          25 :              casacore::MSSpectralWindow::columnName(casacore::MSSpectralWindow::CHAN_FREQ));
      40             : 
      41          25 :     std::vector<int> spwsout = spws;
      42          25 :     size_t nspwout = spwsout.size();
      43          25 :     if(nspw==0){
      44           0 :       for(size_t i=0; i<nspw; i++){
      45           0 :         if(nc(i)!=4){
      46           0 :           spwsout.push_back(i);
      47             :         }
      48             :       }
      49           0 :       nspwout=spwsout.size();
      50             :     }
      51             : 
      52          25 :     s.spws.resize(nspwout);
      53             : 
      54         605 :     for (size_t ispw=0; ispw<nspwout; ++ispw)
      55             :     {
      56         580 :       size_t spwid=spwsout[ispw];
      57             : 
      58         580 :       s.spws[ispw].spwid=spwid;
      59         580 :       casacore::Array<casacore::Double> freq;
      60         580 :       chfreq.get(spwid, freq, casacore::True);
      61         580 :       s.spws[ispw].chf.resize(nc(spwid));
      62       14012 :       for(size_t i=0; i< static_cast<size_t>(nc(spwid)); ++i)
      63             :       {
      64       13432 :         s.spws[ispw].chf[i]=freq(casacore::IPosition(1,i));
      65             :       }
      66         580 :     }
      67          25 :   }
      68             : 
      69             :   std::ostream & 
      70           0 :   operator<<(std::ostream &os,
      71             :              const MSSpec &s)
      72             :   {
      73           0 :     os<<"This MS has "<<s.spws.size()<<" spectral windows"
      74           0 :       <<std::endl;
      75           0 :     for (size_t spw=0; spw<s.spws.size(); ++spw)
      76             :     {
      77           0 :       os<<"SPW "<<spw<<" has "<<s.spws[spw].chf.size()<<" channels ";
      78           0 :       if (s.spws[spw].chf.size()==1)
      79             :       {
      80           0 :         os<<"at frequency "<<s.spws[spw].chf[0];
      81             :       }
      82             :       else
      83             :       {
      84           0 :         os<<"starting at frequency "<<s.spws[spw].chf[0]
      85           0 :           <<" and with last at frequency "<<s.spws[spw].chf[s.spws[spw].chf.size()-1];
      86             :       }
      87           0 :       os<<std::endl;
      88             :     }
      89           0 :     return os;
      90             :   }
      91             : 
      92             :   std::map<size_t, size_t>
      93          58 :   SPWDataDescMap(const casacore::MeasurementSet &ms)
      94             :   {
      95          58 :     std::map<size_t, size_t> res;
      96          58 :     const casacore::MSDataDescription dd(ms.dataDescription());
      97          58 :     const size_t n=dd.nrow();
      98             : 
      99             :     casacore::ScalarColumn<casacore::Int>
     100             :       spwid(dd,
     101          58 :             casacore::MSDataDescription::columnName(casacore::MSDataDescriptionEnums::SPECTRAL_WINDOW_ID));
     102             : 
     103             : 
     104         580 :     for(size_t i=0; i<n; ++i)
     105             :     {
     106             :       int spw;
     107         522 :       spwid.get(i, spw);
     108         522 :       res.insert(std::pair<size_t, size_t>(spw, i));
     109             :     }
     110         116 :     return res;
     111          58 :   }
     112             : 
     113             :   std::map<size_t, size_t>
     114          25 :   DataDescSPWMap(const casacore::MeasurementSet &ms)
     115             :   {
     116          25 :     std::map<size_t, size_t> res;
     117          25 :     const casacore::MSDataDescription dd(ms.dataDescription());
     118          25 :     const size_t n=dd.nrow();
     119             : 
     120             :     casacore::ScalarColumn<casacore::Int>
     121             :       spwid(dd,
     122          25 :             casacore::MSDataDescription::columnName(casacore::MSDataDescriptionEnums::SPECTRAL_WINDOW_ID));
     123             : 
     124             : 
     125         250 :     for(size_t i=0; i<n; ++i)
     126             :     {
     127             :       int spw;
     128         225 :       spwid.get(i, spw);
     129         225 :       res.insert(std::pair<size_t, size_t>(i, spw));
     130             :     }
     131          50 :     return res;
     132          25 :   }
     133             : 
     134          25 :   void dataSPWs(const casacore::MeasurementSet &ms,
     135             :                 std::vector<size_t> &spw,
     136             :                 const std::vector<size_t> &sortedI)
     137             :   {
     138          25 :     std::map<size_t, size_t> map=DataDescSPWMap(ms);
     139          25 :     const casacore::MSMainColumns cols(ms);
     140          25 :     const casacore::ScalarColumn<casacore::Int> &dd=cols.dataDescId();
     141          25 :     const size_t nrows=dd.nrow();          
     142          25 :     spw.resize(nrows);
     143      514106 :     for(size_t ii=0; ii<nrows; ++ii)
     144             :     {
     145      514081 :       size_t i = sortedI[ii];
     146             : 
     147      514081 :       spw[ii]=map[dd(i)];
     148             :     }
     149          25 :   }
     150             : 
     151         621 :   size_t numSPWs(const casacore::MeasurementSet &ms){
     152         621 :     casacore::MSSpectralWindow specTable(ms.spectralWindow());
     153             : 
     154        1242 :     return specTable.nrow();
     155         621 :   }
     156             : 
     157             : 
     158             : }
     159             : 
     160             : 
     161             :