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           0 :   void loadSpec(const casacore::MeasurementSet &ms,
      23             :                 const std::vector<int> &spws,
      24             :                 MSSpec &s)
      25             :   {
      26           0 :     casacore::MSSpectralWindow specTable(ms.spectralWindow());
      27             :     // Number of spectral windows in this measurement set
      28             : 
      29           0 :     const size_t nspw=specTable.nrow();
      30             : 
      31             :     // Number of channels 
      32             :     casacore::ScalarColumn<casacore::Int> nc
      33             :       (specTable,
      34           0 :        casacore::MSSpectralWindow::columnName(casacore::MSSpectralWindow::NUM_CHAN));
      35             : 
      36             :     // Frequencies of the channels
      37             :     casacore::ArrayColumn<casacore::Double>
      38             :       chfreq(specTable,
      39           0 :              casacore::MSSpectralWindow::columnName(casacore::MSSpectralWindow::CHAN_FREQ));
      40             : 
      41           0 :     std::vector<int> spwsout = spws;
      42           0 :     size_t nspwout = spwsout.size();
      43           0 :     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           0 :     s.spws.resize(nspwout);
      53             : 
      54           0 :     for (size_t ispw=0; ispw<nspwout; ++ispw)
      55             :     {
      56           0 :       size_t spwid=spwsout[ispw];
      57             : 
      58           0 :       s.spws[ispw].spwid=spwid;
      59           0 :       casacore::Array<casacore::Double> freq;
      60           0 :       chfreq.get(spwid, freq, casacore::True);
      61           0 :       s.spws[ispw].chf.resize(nc(spwid));
      62           0 :       for(size_t i=0; i< static_cast<size_t>(nc(spwid)); ++i)
      63             :       {
      64           0 :         s.spws[ispw].chf[i]=freq(casacore::IPosition(1,i));
      65             :       }
      66           0 :     }
      67           0 :   }
      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           0 :   SPWDataDescMap(const casacore::MeasurementSet &ms)
      94             :   {
      95           0 :     std::map<size_t, size_t> res;
      96           0 :     const casacore::MSDataDescription dd(ms.dataDescription());
      97           0 :     const size_t n=dd.nrow();
      98             : 
      99             :     casacore::ScalarColumn<casacore::Int>
     100             :       spwid(dd,
     101           0 :             casacore::MSDataDescription::columnName(casacore::MSDataDescriptionEnums::SPECTRAL_WINDOW_ID));
     102             : 
     103             : 
     104           0 :     for(size_t i=0; i<n; ++i)
     105             :     {
     106             :       int spw;
     107           0 :       spwid.get(i, spw);
     108           0 :       res.insert(std::pair<size_t, size_t>(spw, i));
     109             :     }
     110           0 :     return res;
     111           0 :   }
     112             : 
     113             :   std::map<size_t, size_t>
     114           0 :   DataDescSPWMap(const casacore::MeasurementSet &ms)
     115             :   {
     116           0 :     std::map<size_t, size_t> res;
     117           0 :     const casacore::MSDataDescription dd(ms.dataDescription());
     118           0 :     const size_t n=dd.nrow();
     119             : 
     120             :     casacore::ScalarColumn<casacore::Int>
     121             :       spwid(dd,
     122           0 :             casacore::MSDataDescription::columnName(casacore::MSDataDescriptionEnums::SPECTRAL_WINDOW_ID));
     123             : 
     124             : 
     125           0 :     for(size_t i=0; i<n; ++i)
     126             :     {
     127             :       int spw;
     128           0 :       spwid.get(i, spw);
     129           0 :       res.insert(std::pair<size_t, size_t>(i, spw));
     130             :     }
     131           0 :     return res;
     132           0 :   }
     133             : 
     134           0 :   void dataSPWs(const casacore::MeasurementSet &ms,
     135             :                 std::vector<size_t> &spw,
     136             :                 const std::vector<size_t> &sortedI)
     137             :   {
     138           0 :     std::map<size_t, size_t> map=DataDescSPWMap(ms);
     139           0 :     const casacore::MSMainColumns cols(ms);
     140           0 :     const casacore::ScalarColumn<casacore::Int> &dd=cols.dataDescId();
     141           0 :     const size_t nrows=dd.nrow();          
     142           0 :     spw.resize(nrows);
     143           0 :     for(size_t ii=0; ii<nrows; ++ii)
     144             :     {
     145           0 :       size_t i = sortedI[ii];
     146             : 
     147           0 :       spw[ii]=map[dd(i)];
     148             :     }
     149           0 :   }
     150             : 
     151           0 :   size_t numSPWs(const casacore::MeasurementSet &ms){
     152           0 :     casacore::MSSpectralWindow specTable(ms.spectralWindow());
     153             : 
     154           0 :     return specTable.nrow();
     155           0 :   }
     156             : 
     157             : 
     158             : }
     159             : 
     160             : 
     161             :