Changes in trunk/src/Scantable.cpp [2463:2348]

File:

• trunk/src/Scantable.cpp (modified) (13 diffs)

trunk/src/Scantable.cpp

@@ -70 +70 @@
 #include "STUpgrade.h"
 #include "Scantable.h"
-
-#define debug 1
 
 using namespace casa;
@@ -1887 +1885 @@
 }
 
-void asap::Scantable::regridSpecChannel( double dnu, int nChan )
-{
-  LogIO os( LogOrigin( "Scantable", "regridChannel()", WHERE ) ) ;
-  os << "Regrid abcissa with spectral resoultion " << dnu << " " << freqTable_.getUnitString() << " with channel number " << ((nChan>0)? String(nChan) : "covering band width")<< LogIO::POST ;
-  int freqnrow = freqTable_.table().nrow() ;
-  Vector<bool> firstTime( freqnrow, true ) ;
-  double oldincr, factor;
-  uInt currId;
-  Double refpix ;
-  Double refval ;
-  Double increment ;
-  for ( int irow = 0 ; irow < nrow() ; irow++ ) {
-    currId = mfreqidCol_(irow);
-    vector<double> abcissa = getAbcissa( irow ) ;
-    if (nChan < 0) {
-      int oldsize = abcissa.size() ;
-      double bw = (abcissa[oldsize-1]-abcissa[0]) +                     \
-        0.5 * (abcissa[1]-abcissa[0] + abcissa[oldsize-1]-abcissa[oldsize-2]) ;
-      nChan = int( ceil( abs(bw/dnu) ) ) ;
-    }
-    // actual regridding
-    regridChannel( nChan, dnu, irow ) ;
-
-    // update FREQUENCIES subtable
-    if (firstTime[currId]) {
-      oldincr = abcissa[1]-abcissa[0] ;
-      factor = dnu/oldincr ;
-      firstTime[currId] = false ;
-      freqTable_.getEntry( refpix, refval, increment, currId ) ;
-
-      //refval = refval - ( refpix + 0.5 * (1 - factor) ) * increment ;
-      if (factor > 0 ) {
-        refpix = (refpix + 0.5)/factor - 0.5;
-      } else {
-        refpix = (abcissa.size() - 0.5 - refpix)/abs(factor) - 0.5;
-      }
-      freqTable_.setEntry( refpix, refval, increment*factor, currId ) ;
-      //os << "ID" << currId << ": channel width (Orig) = " << oldincr << " [" << freqTable_.getUnitString() << "], scale factor = " << factor << LogIO::POST ;
-      //os << "     frequency increment (Orig) = " << increment << "-> (New) " << increment*factor << LogIO::POST ;
-    }
-  }
-}
-
 void asap::Scantable::regridChannel( int nChan, double dnu )
 {
@@ -1950 +1905 @@
   }
 
-  // change channel number for specCol_, flagCol_, and tsysCol_ (if necessary)
+  // change channel number for specCol_ and flagCol_
+  Vector<Float> newspec( nChan, 0 ) ;
+  Vector<uChar> newflag( nChan, false ) ;
   vector<string> coordinfo = getCoordInfo() ;
   string oldinfo = coordinfo[0] ;
@@ -1976 +1933 @@
   Vector<Float> oldspec = specCol_( irow ) ;
   Vector<uChar> oldflag = flagsCol_( irow ) ;
-  Vector<Float> oldtsys = tsysCol_( irow ) ;
   Vector<Float> newspec( nChan, 0 ) ;
-  Vector<uChar> newflag( nChan, true ) ;
-  Vector<Float> newtsys ;
-  bool regridTsys = false ;
-  if (oldtsys.size() == oldspec.size()) {
-    regridTsys = true ;
-    newtsys.resize(nChan,false) ;
-    newtsys = 0 ;
-  }
+  Vector<uChar> newflag( nChan, false ) ;
 
   // regrid
@@ -1991 +1940 @@
   int oldsize = abcissa.size() ;
   double olddnu = abcissa[1] - abcissa[0] ;
-  //int ichan = 0 ;
+  //int refChan = 0 ;
+  //double frac = 0.0 ;
+  //double wedge = 0.0 ;
+  //double pile = 0.0 ;
+  int ichan = 0 ;
   double wsum = 0.0 ;
-  Vector<double> zi( nChan+1 ) ;
-  Vector<double> yi( oldsize + 1 ) ;
-  yi[0] = abcissa[0] - 0.5 * olddnu ;
-  for ( int ii = 1 ; ii < oldsize ; ii++ )
-    yi[ii] = 0.5* (abcissa[ii-1] + abcissa[ii]) ;
-  yi[oldsize] = abcissa[oldsize-1] \
-    + 0.5 * (abcissa[oldsize-1] - abcissa[oldsize-2]) ;
-  //zi[0] = abcissa[0] - 0.5 * olddnu ;
-  zi[0] = ((olddnu*dnu > 0) ? yi[0] : yi[oldsize]) ;
-  for ( int ii = 1 ; ii < nChan ; ii++ )
+  Vector<Float> zi( nChan+1 ) ;
+  Vector<Float> yi( oldsize + 1 ) ;
+  zi[0] = abcissa[0] - 0.5 * olddnu ;
+  zi[1] = zi[1] + dnu ;
+  for ( int ii = 2 ; ii < nChan ; ii++ )
     zi[ii] = zi[0] + dnu * ii ;
   zi[nChan] = zi[nChan-1] + dnu ;
-  // Access zi and yi in ascending order
-  int izs = ((dnu > 0) ? 0 : nChan ) ;
-  int ize = ((dnu > 0) ? nChan : 0 ) ;
-  int izincr = ((dnu > 0) ? 1 : -1 ) ;
-  int ichan =  ((olddnu > 0) ? 0 : oldsize ) ;
-  int iye = ((olddnu > 0) ? oldsize : 0 ) ;
-  int iyincr = ((olddnu > 0) ? 1 : -1 ) ;
-  //for ( int ii = izs ; ii != ize ; ii+=izincr ){
-  int ii = izs ;
-  while (ii != ize) {
-    // always zl < zr
-    double zl = zi[ii] ;
-    double zr = zi[ii+izincr] ;
-    // Need to access smaller index for the new spec, flag, and tsys.
-    // Values between zi[k] and zi[k+1] should be stored in newspec[k], etc.
-    int i = min(ii, ii+izincr) ;
-    //for ( int jj = ichan ; jj != iye ; jj+=iyincr ) {
-    int jj = ichan ;
-    while (jj != iye) {
-      // always yl < yr
-      double yl = yi[jj] ;
-      double yr = yi[jj+iyincr] ;
-      // Need to access smaller index for the original spec, flag, and tsys.
-      // Values between yi[k] and yi[k+1] are stored in oldspec[k], etc.
-      int j = min(jj, jj+iyincr) ;
-      if ( yr <= zl ) {
-        jj += iyincr ;
-        continue ;
-      }
-      else if ( yl <= zl ) {
-        if ( yr < zr ) {
-          if (!oldflag[j]) {
-            newspec[i] += oldspec[j] * ( yr - zl ) ;
-            if (regridTsys) newtsys[i] += oldtsys[j] * ( yr - zl ) ;
-            wsum += ( yr - zl ) ;
-          }
-          newflag[i] = newflag[i] && oldflag[j] ;
-        }
-        else {
-          if (!oldflag[j]) {
-            newspec[i] += oldspec[j] * abs(dnu) ;
-            if (regridTsys) newtsys[i] += oldtsys[j] * abs(dnu) ;
-            wsum += abs(dnu) ;
-          }
-          newflag[i] = newflag[i] && oldflag[j] ;
-          ichan = jj ;
-          break ;
-        }
-      }
-      else if ( yl < zr ) {
-        if ( yr <= zr ) {
-          if (!oldflag[j]) {
-            newspec[i] += oldspec[j] * ( yr - yl ) ;
-            if (regridTsys) newtsys[i] += oldtsys[j] * ( yr - yl ) ;
-            wsum += ( yr - yl ) ;
-          }
-          newflag[i] = newflag[i] && oldflag[j] ;
-        }
-        else {
-          if (!oldflag[j]) {
-            newspec[i] += oldspec[j] * ( zr - yl ) ;
-            if (regridTsys) newtsys[i] += oldtsys[j] * ( zr - yl ) ;
-            wsum += ( zr - yl ) ;
-          }
-          newflag[i] = newflag[i] && oldflag[j] ;
-          ichan = jj ;
-          break ;
-        }
-      }
-      else {
-        ichan = jj - iyincr ;
-        break ;
-      }
-      jj += iyincr ;
-    }
-    if ( wsum != 0.0 ) {
-      newspec[i] /= wsum ;
-      if (regridTsys) newtsys[i] /= wsum ;
-    }
-    wsum = 0.0 ;
-    ii += izincr ;
-  }
-//   if ( dnu > 0.0 ) {
-//     for ( int ii = 0 ; ii < nChan ; ii++ ) {
-//       double zl = zi[ii] ;
-//       double zr = zi[ii+1] ;
-//       for ( int j = ichan ; j < oldsize ; j++ ) {
-//         double yl = yi[j] ;
-//         double yr = yi[j+1] ;
-//         if ( yl <= zl ) {
-//           if ( yr <= zl ) {
-//             continue ;
-//           }
-//           else if ( yr <= zr ) {
-//          if (!oldflag[j]) {
-//            newspec[ii] += oldspec[j] * ( yr - zl ) ;
-//            if (regridTsys) newtsys[ii] += oldtsys[j] * ( yr - zl ) ;
-//            wsum += ( yr - zl ) ;
-//          }
-//          newflag[ii] = newflag[ii] && oldflag[j] ;
-//           }
-//           else {
-//          if (!oldflag[j]) {
-//            newspec[ii] += oldspec[j] * dnu ;
-//            if (regridTsys) newtsys[ii] += oldtsys[j] * dnu ;
-//            wsum += dnu ;
-//          }
-//          newflag[ii] = newflag[ii] && oldflag[j] ;
-//             ichan = j ;
-//             break ;
-//           }
-//         }
-//         else if ( yl < zr ) {
-//           if ( yr <= zr ) {
-//          if (!oldflag[j]) {
-//            newspec[ii] += oldspec[j] * ( yr - yl ) ;
-//            if (regridTsys) newtsys[ii] += oldtsys[j] * ( yr - yl ) ;
-//               wsum += ( yr - yl ) ;
-//          }
-//          newflag[ii] = newflag[ii] && oldflag[j] ;
-//           }
-//           else {
-//          if (!oldflag[j]) {
-//            newspec[ii] += oldspec[j] * ( zr - yl ) ;
-//            if (regridTsys) newtsys[ii] += oldtsys[j] * ( zr - yl ) ;
-//            wsum += ( zr - yl ) ;
-//          }
-//          newflag[ii] = newflag[ii] && oldflag[j] ;
-//             ichan = j ;
-//             break ;
-//           }
-//         }
-//         else {
-//           ichan = j - 1 ;
-//           break ;
-//         }
-//       }
-//       if ( wsum != 0.0 ) {
-//         newspec[ii] /= wsum ;
-//      if (regridTsys) newtsys[ii] /= wsum ;
-//       }
-//       wsum = 0.0 ;
+  yi[0] = abcissa[0] - 0.5 * olddnu ;
+  yi[1] = abcissa[1] + 0.5 * olddnu ;
+  for ( int ii = 2 ; ii < oldsize ; ii++ )
+    yi[ii] = abcissa[ii-1] + olddnu ;
+  yi[oldsize] = abcissa[oldsize-1] + 0.5 * olddnu ;
+  if ( dnu > 0.0 ) {
+    for ( int ii = 0 ; ii < nChan ; ii++ ) {
+      double zl = zi[ii] ;
+      double zr = zi[ii+1] ;
+      for ( int j = ichan ; j < oldsize ; j++ ) {
+        double yl = yi[j] ;
+        double yr = yi[j+1] ;
+        if ( yl <= zl ) {
+          if ( yr <= zl ) {
+            continue ;
+          }
+          else if ( yr <= zr ) {
+            newspec[ii] += oldspec[j] * ( yr - zl ) ;
+            newflag[ii] = newflag[ii] || oldflag[j] ;
+            wsum += ( yr - zl ) ;
+          }
+          else {
+            newspec[ii] += oldspec[j] * dnu ;
+            newflag[ii] = newflag[ii] || oldflag[j] ;
+            wsum += dnu ;
+            ichan = j ;
+            break ;
+          }
+        }
+        else if ( yl < zr ) {
+          if ( yr <= zr ) {
+              newspec[ii] += oldspec[j] * ( yr - yl ) ;
+              newflag[ii] = newflag[ii] || oldflag[j] ;
+              wsum += ( yr - yl ) ;
+          }
+          else {
+            newspec[ii] += oldspec[j] * ( zr - yl ) ;
+            newflag[ii] = newflag[ii] || oldflag[j] ;
+            wsum += ( zr - yl ) ;
+            ichan = j ;
+            break ;
+          }
+        }
+        else {
+          ichan = j - 1 ;
+          break ;
+        }
+      }
+      if ( wsum != 0.0 )
+        newspec[ii] /= wsum ;
+      wsum = 0.0 ;
+    }
+  }
+  else if ( dnu < 0.0 ) {
+    for ( int ii = 0 ; ii < nChan ; ii++ ) {
+      double zl = zi[ii] ;
+      double zr = zi[ii+1] ;
+      for ( int j = ichan ; j < oldsize ; j++ ) {
+        double yl = yi[j] ;
+        double yr = yi[j+1] ;
+        if ( yl >= zl ) {
+          if ( yr >= zl ) {
+            continue ;
+          }
+          else if ( yr >= zr ) {
+            newspec[ii] += oldspec[j] * abs( yr - zl ) ;
+            newflag[ii] = newflag[ii] || oldflag[j] ;
+            wsum += abs( yr - zl ) ;
+          }
+          else {
+            newspec[ii] += oldspec[j] * abs( dnu ) ;
+            newflag[ii] = newflag[ii] || oldflag[j] ;
+            wsum += abs( dnu ) ;
+            ichan = j ;
+            break ;
+          }
+        }
+        else if ( yl > zr ) {
+          if ( yr >= zr ) {
+            newspec[ii] += oldspec[j] * abs( yr - yl ) ;
+            newflag[ii] = newflag[ii] || oldflag[j] ;
+            wsum += abs( yr - yl ) ;
+          }
+          else {
+            newspec[ii] += oldspec[j] * abs( zr - yl ) ;
+            newflag[ii] = newflag[ii] || oldflag[j] ;
+            wsum += abs( zr - yl ) ;
+            ichan = j ;
+            break ;
+          }
+        }
+        else {
+          ichan = j - 1 ;
+          break ;
+        }
+      }
+      if ( wsum != 0.0 )
+        newspec[ii] /= wsum ;
+      wsum = 0.0 ;
+    }
+  }
+//    * ichan = 0
+//    ***/
+//   //ofs << "olddnu = " << olddnu << ", dnu = " << dnu << endl ;
+//   pile += dnu ;
+//   wedge = olddnu * ( refChan + 1 ) ;
+//   while ( wedge < pile ) {
+//     newspec[0] += olddnu * oldspec[refChan] ;
+//     newflag[0] = newflag[0] || oldflag[refChan] ;
+//     //ofs << "channel " << refChan << " is included in new channel 0" << endl ;
+//     refChan++ ;
+//     wedge += olddnu ;
+//     wsum += olddnu ;
+//     //ofs << "newspec[0] = " << newspec[0] << " wsum = " << wsum << endl ;
+//   }
+//   frac = ( wedge - pile ) / olddnu ;
+//   wsum += ( 1.0 - frac ) * olddnu ;
+//   newspec[0] += ( 1.0 - frac ) * olddnu * oldspec[refChan] ;
+//   newflag[0] = newflag[0] || oldflag[refChan] ;
+//   //ofs << "channel " << refChan << " is partly included in new channel 0" << " with fraction of " << ( 1.0 - frac ) << endl ;
+//   //ofs << "newspec[0] = " << newspec[0] << " wsum = " << wsum << endl ;
+//   newspec[0] /= wsum ;
+//   //ofs << "newspec[0] = " << newspec[0] << endl ;
+//   //ofs << "wedge = " << wedge << ", pile = " << pile << endl ;
+
+//   /***
+//    * ichan = 1 - nChan-2
+//    ***/
+//   for ( int ichan = 1 ; ichan < nChan - 1 ; ichan++ ) {
+//     pile += dnu ;
+//     newspec[ichan] += frac * olddnu * oldspec[refChan] ;
+//     newflag[ichan] = newflag[ichan] || oldflag[refChan] ;
+//     //ofs << "channel " << refChan << " is partly included in new channel " << ichan << " with fraction of " << frac << endl ;
+//     refChan++ ;
+//     wedge += olddnu ;
+//     wsum = frac * olddnu ;
+//     //ofs << "newspec[" << ichan << "] = " << newspec[ichan] << " wsum = " << wsum << endl ;
+//     while ( wedge < pile ) {
+//       newspec[ichan] += olddnu * oldspec[refChan] ;
+//       newflag[ichan] = newflag[ichan] || oldflag[refChan] ;
+//       //ofs << "channel " << refChan << " is included in new channel " << ichan << endl ;
+//       refChan++ ;
+//       wedge += olddnu ;
+//       wsum += olddnu ;
+//       //ofs << "newspec[" << ichan << "] = " << newspec[ichan] << " wsum = " << wsum << endl ;
 //     }
+//     frac = ( wedge - pile ) / olddnu ;
+//     wsum += ( 1.0 - frac ) * olddnu ;
+//     newspec[ichan] += ( 1.0 - frac ) * olddnu * oldspec[refChan] ;
+//     newflag[ichan] = newflag[ichan] || oldflag[refChan] ;
+//     //ofs << "channel " << refChan << " is partly included in new channel " << ichan << " with fraction of " << ( 1.0 - frac ) << endl ;
+//     //ofs << "wedge = " << wedge << ", pile = " << pile << endl ;
+//     //ofs << "newspec[" << ichan << "] = " << newspec[ichan] << " wsum = " << wsum << endl ;
+//     newspec[ichan] /= wsum ;
+//     //ofs << "newspec[" << ichan << "] = " << newspec[ichan] << endl ;
 //   }
-//   else if ( dnu < 0.0 ) {
-//     for ( int ii = 0 ; ii < nChan ; ii++ ) {
-//       double zl = zi[ii] ;
-//       double zr = zi[ii+1] ;
-//       for ( int j = ichan ; j < oldsize ; j++ ) {
-//         double yl = yi[j] ;
-//         double yr = yi[j+1] ;
-//         if ( yl >= zl ) {
-//           if ( yr >= zl ) {
-//             continue ;
-//           }
-//           else if ( yr >= zr ) {
-//          if (!oldflag[j]) {
-//            newspec[ii] += oldspec[j] * abs( yr - zl ) ;
-//            if (regridTsys) newtsys[ii] += oldtsys[j] * abs( yr - zl ) ;
-//            wsum += abs( yr - zl ) ;
-//          }
-//          newflag[ii] = newflag[ii] && oldflag[j] ;
-//           }
-//           else {
-//          if (!oldflag[j]) {
-//            newspec[ii] += oldspec[j] * abs( dnu ) ;
-//            if (regridTsys) newtsys[ii] += oldtsys[j] * abs( dnu ) ;
-//            wsum += abs( dnu ) ;
-//          }
-//          newflag[ii] = newflag[ii] && oldflag[j] ;
-//             ichan = j ;
-//             break ;
-//           }
-//         }
-//         else if ( yl > zr ) {
-//           if ( yr >= zr ) {
-//          if (!oldflag[j]) {
-//            newspec[ii] += oldspec[j] * abs( yr - yl ) ;
-//            if (regridTsys) newtsys[ii] += oldtsys[j] * abs( yr - yl ) ;
-//            wsum += abs( yr - yl ) ;
-//          }
-//          newflag[ii] = newflag[ii] && oldflag[j] ;
-//           }
-//           else {
-//          if (!oldflag[j]) {
-//            newspec[ii] += oldspec[j] * abs( zr - yl ) ;
-//            if (regridTsys) newtsys[ii] += oldtsys[j] * abs( zr - yl ) ;
-//            wsum += abs( zr - yl ) ;
-//          }
-//          newflag[ii] = newflag[ii] && oldflag[j] ;
-//             ichan = j ;
-//             break ;
-//           }
-//         }
-//         else {
-//           ichan = j - 1 ;
-//           break ;
-//         }
-//       }
-//       if ( wsum != 0.0 ) {
-//         newspec[ii] /= wsum ;
-//      if (regridTsys) newtsys[ii] /= wsum ;
-//       }
-//       wsum = 0.0 ;
-//     }
+
+//   /***
+//    * ichan = nChan-1
+//    ***/
+//   // NOTE: Assumed that all spectra have the same bandwidth
+//   pile += dnu ;
+//   newspec[nChan-1] += frac * olddnu * oldspec[refChan] ;
+//   newflag[nChan-1] = newflag[nChan-1] || oldflag[refChan] ;
+//   //ofs << "channel " << refChan << " is partly included in new channel " << nChan-1 << " with fraction of " << frac << endl ;
+//   refChan++ ;
+//   wedge += olddnu ;
+//   wsum = frac * olddnu ;
+//   //ofs << "newspec[" << nChan - 1 << "] = " << newspec[nChan-1] << " wsum = " << wsum << endl ;
+//   for ( int jchan = refChan ; jchan < oldsize ; jchan++ ) {
+//     newspec[nChan-1] += olddnu * oldspec[jchan] ;
+//     newflag[nChan-1] = newflag[nChan-1] || oldflag[jchan] ;
+//     wsum += olddnu ;
+//     //ofs << "channel " << jchan << " is included in new channel " << nChan-1 << " with fraction of " << frac << endl ;
+//     //ofs << "newspec[" << nChan - 1 << "] = " << newspec[nChan-1] << " wsum = " << wsum << endl ;
 //   }
-// //   //ofs << "olddnu = " << olddnu << ", dnu = " << dnu << endl ;
-// //   pile += dnu ;
-// //   wedge = olddnu * ( refChan + 1 ) ;
-// //   while ( wedge < pile ) {
-// //     newspec[0] += olddnu * oldspec[refChan] ;
-// //     newflag[0] = newflag[0] || oldflag[refChan] ;
-// //     //ofs << "channel " << refChan << " is included in new channel 0" << endl ;
-// //     refChan++ ;
-// //     wedge += olddnu ;
-// //     wsum += olddnu ;
-// //     //ofs << "newspec[0] = " << newspec[0] << " wsum = " << wsum << endl ;
-// //   }
-// //   frac = ( wedge - pile ) / olddnu ;
-// //   wsum += ( 1.0 - frac ) * olddnu ;
-// //   newspec[0] += ( 1.0 - frac ) * olddnu * oldspec[refChan] ;
-// //   newflag[0] = newflag[0] || oldflag[refChan] ;
-// //   //ofs << "channel " << refChan << " is partly included in new channel 0" << " with fraction of " << ( 1.0 - frac ) << endl ;
-// //   //ofs << "newspec[0] = " << newspec[0] << " wsum = " << wsum << endl ;
-// //   newspec[0] /= wsum ;
-// //   //ofs << "newspec[0] = " << newspec[0] << endl ;
-// //   //ofs << "wedge = " << wedge << ", pile = " << pile << endl ;
-
-// //   /***
-// //    * ichan = 1 - nChan-2
-// //    ***/
-// //   for ( int ichan = 1 ; ichan < nChan - 1 ; ichan++ ) {
-// //     pile += dnu ;
-// //     newspec[ichan] += frac * olddnu * oldspec[refChan] ;
-// //     newflag[ichan] = newflag[ichan] || oldflag[refChan] ;
-// //     //ofs << "channel " << refChan << " is partly included in new channel " << ichan << " with fraction of " << frac << endl ;
-// //     refChan++ ;
-// //     wedge += olddnu ;
-// //     wsum = frac * olddnu ;
-// //     //ofs << "newspec[" << ichan << "] = " << newspec[ichan] << " wsum = " << wsum << endl ;
-// //     while ( wedge < pile ) {
-// //       newspec[ichan] += olddnu * oldspec[refChan] ;
-// //       newflag[ichan] = newflag[ichan] || oldflag[refChan] ;
-// //       //ofs << "channel " << refChan << " is included in new channel " << ichan << endl ;
-// //       refChan++ ;
-// //       wedge += olddnu ;
-// //       wsum += olddnu ;
-// //       //ofs << "newspec[" << ichan << "] = " << newspec[ichan] << " wsum = " << wsum << endl ;
-// //     }
-// //     frac = ( wedge - pile ) / olddnu ;
-// //     wsum += ( 1.0 - frac ) * olddnu ;
-// //     newspec[ichan] += ( 1.0 - frac ) * olddnu * oldspec[refChan] ;
-// //     newflag[ichan] = newflag[ichan] || oldflag[refChan] ;
-// //     //ofs << "channel " << refChan << " is partly included in new channel " << ichan << " with fraction of " << ( 1.0 - frac ) << endl ;
-// //     //ofs << "wedge = " << wedge << ", pile = " << pile << endl ;
-// //     //ofs << "newspec[" << ichan << "] = " << newspec[ichan] << " wsum = " << wsum << endl ;
-// //     newspec[ichan] /= wsum ;
-// //     //ofs << "newspec[" << ichan << "] = " << newspec[ichan] << endl ;
-// //   }
-
-// //   /***
-// //    * ichan = nChan-1
-// //    ***/
-// //   // NOTE: Assumed that all spectra have the same bandwidth
-// //   pile += dnu ;
-// //   newspec[nChan-1] += frac * olddnu * oldspec[refChan] ;
-// //   newflag[nChan-1] = newflag[nChan-1] || oldflag[refChan] ;
-// //   //ofs << "channel " << refChan << " is partly included in new channel " << nChan-1 << " with fraction of " << frac << endl ;
-// //   refChan++ ;
-// //   wedge += olddnu ;
-// //   wsum = frac * olddnu ;
-// //   //ofs << "newspec[" << nChan - 1 << "] = " << newspec[nChan-1] << " wsum = " << wsum << endl ;
-// //   for ( int jchan = refChan ; jchan < oldsize ; jchan++ ) {
-// //     newspec[nChan-1] += olddnu * oldspec[jchan] ;
-// //     newflag[nChan-1] = newflag[nChan-1] || oldflag[jchan] ;
-// //     wsum += olddnu ;
-// //     //ofs << "channel " << jchan << " is included in new channel " << nChan-1 << " with fraction of " << frac << endl ;
-// //     //ofs << "newspec[" << nChan - 1 << "] = " << newspec[nChan-1] << " wsum = " << wsum << endl ;
-// //   }
-// //   //ofs << "wedge = " << wedge << ", pile = " << pile << endl ;
-// //   //ofs << "newspec[" << nChan - 1 << "] = " << newspec[nChan-1] << " wsum = " << wsum << endl ;
-// //   newspec[nChan-1] /= wsum ;
-// //   //ofs << "newspec[" << nChan - 1 << "] = " << newspec[nChan-1] << endl ;
-
-// //   // ofs.close() ;
+//   //ofs << "wedge = " << wedge << ", pile = " << pile << endl ;
+//   //ofs << "newspec[" << nChan - 1 << "] = " << newspec[nChan-1] << " wsum = " << wsum << endl ;
+//   newspec[nChan-1] /= wsum ;
+//   //ofs << "newspec[" << nChan - 1 << "] = " << newspec[nChan-1] << endl ;
+
+//   // ofs.close() ;
 
   specCol_.put( irow, newspec ) ;
   flagsCol_.put( irow, newflag ) ;
-  if (regridTsys) tsysCol_.put( irow, newtsys );
 
   return ;
@@ -2853 +2697 @@
   }
 
-  addAuxWaveNumbers(whichrow, addNWaves, rejectNWaves, nWaves);
+  addAuxWaveNumbers(addNWaves, rejectNWaves, nWaves);
 }
 
@@ -2935 +2779 @@
 }
 
-void Scantable::addAuxWaveNumbers(const int whichrow, const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, std::vector<int>& nWaves)
-{
-  std::vector<int> tempAddNWaves, tempRejectNWaves;
+void Scantable::addAuxWaveNumbers(const std::vector<int>& addNWaves, const std::vector<int>& rejectNWaves, std::vector<int>& nWaves)
+{
   for (uInt i = 0; i < addNWaves.size(); ++i) {
-    tempAddNWaves.push_back(addNWaves[i]);
-  }
-  if ((tempAddNWaves.size() == 2) && (tempAddNWaves[1] == -999)) {
-    setWaveNumberListUptoNyquistFreq(whichrow, tempAddNWaves);
-  }
-
-  for (uInt i = 0; i < rejectNWaves.size(); ++i) {
-    tempRejectNWaves.push_back(rejectNWaves[i]);
-  }
-  if ((tempRejectNWaves.size() == 2) && (tempRejectNWaves[1] == -999)) {
-    setWaveNumberListUptoNyquistFreq(whichrow, tempRejectNWaves);
-  }
-
-  for (uInt i = 0; i < tempAddNWaves.size(); ++i) {
     bool found = false;
     for (uInt j = 0; j < nWaves.size(); ++j) {
-      if (nWaves[j] == tempAddNWaves[i]) {
+      if (nWaves[j] == addNWaves[i]) {
         found = true;
         break;
       }
     }
-    if (!found) nWaves.push_back(tempAddNWaves[i]);
-  }
-
-  for (uInt i = 0; i < tempRejectNWaves.size(); ++i) {
+    if (!found) nWaves.push_back(addNWaves[i]);
+  }
+
+  for (uInt i = 0; i < rejectNWaves.size(); ++i) {
     for (std::vector<int>::iterator j = nWaves.begin(); j != nWaves.end(); ) {
-      if (*j == tempRejectNWaves[i]) {
+      if (*j == rejectNWaves[i]) {
         j = nWaves.erase(j);
       } else {
@@ -2976 +2805 @@
     sort(nWaves.begin(), nWaves.end());
     unique(nWaves.begin(), nWaves.end());
-  }
-}
-
-void Scantable::setWaveNumberListUptoNyquistFreq(const int whichrow, std::vector<int>& nWaves)
-{
-  if ((nWaves.size() == 2)&&(nWaves[1] == -999)) {
-    int val = nWaves[0];
-    int nyquistFreq = nchan(getIF(whichrow))/2+1;
-    nWaves.clear();
-    if (val > nyquistFreq) {  // for safety, at least nWaves contains a constant; CAS-3759
-      nWaves.push_back(0);
-    }
-    while (val <= nyquistFreq) {
-      nWaves.push_back(val);
-      val++;
-    }
   }
 }
@@ -3031 +2844 @@
 
       //FOR DEBUGGING------------
-      /*
       if (whichrow < 0) {// == nRow -1) {
         cout << "+++ i=" << setw(3) << whichrow << ", IF=" << setw(2) << getIF(whichrow);
@@ -3043 +2855 @@
         cout << flush;
       }
-      */
       //-------------------------
 
@@ -3378 +3189 @@
   std::vector<bool> mask = getMask(whichrow);
   uInt maskSize = mask.size();
-  if (inMask.size() != 0) {
-    if (maskSize != inMask.size()) {
-      throw(AipsError("mask sizes are not the same."));
-    }
-    for (uInt i = 0; i < maskSize; ++i) {
-      mask[i] = mask[i] && inMask[i];
-    }
+  if (maskSize != inMask.size()) {
+    throw(AipsError("mask sizes are not the same."));
+  }
+  for (uInt i = 0; i < maskSize; ++i) {
+    mask[i] = mask[i] && inMask[i];
   }
 
@@ -3706 +3515 @@
 std::string Scantable::getMaskRangeList(const std::vector<bool>& mask, int whichrow, const casa::String& coordInfo, bool hasSameNchan, bool verbose)
 {
-  if (mask.size() <= 0) {
-    throw(AipsError("The mask elements should be > 0"));
+  if (mask.size() < 2) {
+    throw(AipsError("The mask elements should be > 1"));
   }
   int IF = getIF(whichrow);
@@ -3740 +3549 @@
 std::vector<int> Scantable::getMaskEdgeIndices(const std::vector<bool>& mask)
 {
-  if (mask.size() <= 0) {
-    throw(AipsError("The mask elements should be > 0"));
+  if (mask.size() < 2) {
+    throw(AipsError("The mask elements should be > 1"));
   }