Line data    Source code

       1             : /*
       2             :  * SpectralWindow.cc
       3             :  *
       4             :  *  Created on: Feb 15, 2013
       5             :  *      Author: jjacobs
       6             :  */
       7             : 
       8             : 
       9             : #include <casacore/ms/MeasurementSets.h>
      10             : #include <casacore/ms/MeasurementSets/MSColumns.h>
      11             : #include <casacore/tables/Tables.h>
      12             : #include <stdcasa/UtilJ.h>
      13             : #include <msvis/MSVis/SpectralWindow.h>
      14             : #include <memory>
      15             : 
      16             : using namespace std;
      17             : using namespace casacore;
      18             : 
      19             : namespace casa {
      20             : namespace ms {
      21             : 
      22           0 : SpectralWindow::SpectralWindow (const MSSpWindowColumns & columns, Int spectralWindowId)
      23           0 : : id_p (spectralWindowId)
      24             : {
      25           0 :     fillScalars (columns);
      26             : 
      27           0 :     fillArrays (columns);
      28           0 : }
      29             : 
      30             : void
      31           0 : SpectralWindow::fillArrays(const MSSpWindowColumns & columns)
      32             : {
      33             :     // Read in the data as parallel arrays
      34             : 
      35           0 :     Vector<Double> effectiveBandwidth = getArray (columns.effectiveBW());
      36           0 :     Vector<Double> frequency = getArray (columns.chanFreq());
      37           0 :     Vector<Double> resolution = getArray (columns.resolution());
      38           0 :     Vector<Double> width = getArray (columns.chanWidth ());
      39             : 
      40             :     // Use the arrays to create an array of channel objects
      41             : 
      42           0 :     for (Int i = 0; i <  (int) effectiveBandwidth.nelements(); i ++){
      43             : 
      44           0 :         channels_p.push_back(SpectralChannel (frequency (i), width(i),
      45           0 :                                               effectiveBandwidth (i), resolution(i)));
      46             :     }
      47           0 : }
      48             : 
      49             : Vector<Double>
      50           0 : SpectralWindow::getArray (const ArrayColumn<Double> & arrayColumn)
      51             : {
      52           0 :     Vector<Double> array;
      53           0 :     arrayColumn.get (id_p, array, true);
      54             : 
      55           0 :     return array;
      56             : }
      57             : 
      58             : template<typename T>
      59             : T
      60           0 : SpectralWindow::getScalar (const ScalarColumn<T> & column)
      61             : {
      62           0 :     return column.get (id_p);
      63             : }
      64             : 
      65             : void
      66           0 : SpectralWindow::fillScalars (const MSSpWindowColumns & columns)
      67             : {
      68           0 :     flagged_p = getScalar (columns.flagRow());
      69           0 :     frequencyGroup_p = getScalar (columns.freqGroup());
      70           0 :     frequencyGroupName_p = getScalar (columns.freqGroupName());
      71           0 :     frequencyMeasureReference_p = getScalar (columns.measFreqRef());
      72           0 :     ifConversionChain_p = getScalar (columns.ifConvChain());
      73           0 :     name_p = getScalar (columns.name());
      74           0 :     nChannels_p = getScalar (columns.numChan());
      75           0 :     netSideband_p = getScalar (columns.netSideband());
      76           0 :     totalBandwidth_p = getScalar (columns.totalBandwidth());
      77           0 :     referenceFrequency_p = getScalar (columns.refFrequency());
      78           0 : }
      79             : 
      80           0 : SpectralWindows::SpectralWindows (const MeasurementSet * ms)
      81             : {
      82             :     // Get the Spectral Columns Object
      83             : 
      84           0 :     unique_ptr <MSColumns> msColumns (new MSColumns (* ms));
      85           0 :     const MSSpWindowColumns & spectralWindowColumns = msColumns->spectralWindow();
      86             : 
      87             :     // Create on spectral window object per row in the table.
      88             : 
      89           0 :     Int nRows = spectralWindowColumns.nrow();
      90             : 
      91           0 :     for (Int row = 0; row < nRows; row ++){
      92             : 
      93           0 :         windows_p.push_back (SpectralWindow (spectralWindowColumns, row));
      94             :     }
      95           0 : }
      96             : 
      97             : SpectralWindows::const_iterator
      98           0 : SpectralWindows::begin () const
      99             : {
     100           0 :     return windows_p.begin();
     101             : }
     102             : 
     103             : bool
     104           0 : SpectralWindows::empty () const
     105             : {
     106           0 :     return windows_p.empty();
     107             : }
     108             : 
     109             : SpectralWindows::const_iterator
     110           0 : SpectralWindows::end () const
     111             : {
     112           0 :     return windows_p.end();
     113             : }
     114             : 
     115             : const SpectralWindow &
     116           0 : SpectralWindows::get (Int id) const
     117             : {
     118           0 :     Assert (id >= 0 && id < (int) size());
     119             : 
     120           0 :     return windows_p [id];
     121             : }
     122             : 
     123             : size_t
     124           0 : SpectralWindows::size () const
     125             : {
     126           0 :     return windows_p.size();
     127             : }
     128             : 
     129             : const SpectralChannel &
     130           0 : SpectralWindow::get (Int i) const
     131             : {
     132           0 :     Assert (i >= 0 && i < (int) nChannels());
     133           0 :     return channels_p [i];
     134             : }
     135             : 
     136             : 
     137             : Bool
     138           0 : SpectralWindow::isFlagged () const
     139             : {
     140           0 :     return flagged_p;
     141             : }
     142             : 
     143             : Int
     144           0 : SpectralWindow::frequencyGroup () const
     145             : {
     146           0 :     return frequencyGroup_p;
     147             : }
     148             : 
     149             : String
     150           0 : SpectralWindow::frequencyGroupName () const
     151             : {
     152           0 :     return frequencyGroupName_p;
     153             : }
     154             : 
     155             : Int
     156           0 : SpectralWindow::frequencyMeasureReference () const
     157             : {
     158           0 :     return frequencyMeasureReference_p;
     159             : }
     160             : 
     161             : Int
     162           0 : SpectralWindow::id () const
     163             : {
     164           0 :     return id_p;
     165             : }
     166             : 
     167             : 
     168             : Int
     169           0 : SpectralWindow::ifConversionChain () const
     170             : {
     171           0 :     return ifConversionChain_p;
     172             : }
     173             : 
     174             : String
     175           0 : SpectralWindow::name () const
     176             : {
     177           0 :     return name_p;
     178             : }
     179             : 
     180             : Int
     181           0 : SpectralWindow::nChannels () const
     182             : {
     183           0 :     return nChannels_p;
     184             : }
     185             : 
     186             : Int
     187           0 : SpectralWindow::netSideband () const
     188             : {
     189           0 :     return netSideband_p;
     190             : }
     191             : 
     192             : Double
     193           0 : SpectralWindow::totalBandwidth () const
     194             : {
     195           0 :     return totalBandwidth_p;
     196             : }
     197             : 
     198             : Double
     199           0 : SpectralWindow::referenceFrequency () const
     200             : {
     201           0 :     return referenceFrequency_p;
     202             : }
     203             : 
     204             : 
     205             : 
     206             : } // end namespace vi
     207             : } // end namespace casa
     208             : 
     209             :