Changeset 1677 for branches/alma/src

Timestamp:

01/27/10 18:29:48 (15 years ago)

Author:

Takeshi Nakazato

Message:

New Development: No

JIRA Issue: Yes CAS-1823

Ready to Release: Yes

Interface Changes: Yes

What Interface Changed: The mode parameter is added to scantable.scale() method.

Test Programs: s = sd.scantable('yourfile',False)

factor = []
for i in range(s.nrow()):

factor.append(i)

s2 = s + factor

Put in Release Notes: Yes

Module(s): -

Description: Describe your changes here...

Basic operations (addition, subtraction, multiplication, division)
of scantable with one dimensional list are implemented.
Size of list operand should be equal to either number of spectral channel
or number of row. In the former case, the list is operated as
channel-by-channel manner, while it is operated as row-by-row manner
in the latter case.
If number of spectral channel is equal to number of row, row-by-row
operation will be done.

The user is able to select operation mode (channel-by-channel or row-by-row)
manually by using lower level function, stmath.arrayop().

The scantable.scale() method is updated to allow list scaling factor.
Scaling is done in channel-by-channel manner if mode is set to 'channel',
while in row-by-row manner if mode is set to 'row'.

Location:

branches/alma/src

Files:

• STMath.cpp (modified) (1 diff)
• STMath.h (modified) (1 diff)
• STMathWrapper.h (modified) (1 diff)
• python_STMath.cpp (modified) (1 diff)

branches/alma/src/STMath.cpp

@@ -497 +497 @@
       if ( tsys ) {
         ts += val;
+        tsysCol.put(i, ts);
+      }
+    }
+  }
+  return out;
+}
+
+CountedPtr< Scantable > STMath::arrayOperate( const CountedPtr< Scantable >& in,
+                                              const std::vector<float> val,
+                                              const std::string& mode,
+                                              bool tsys,
+                                              const std::string& op )
+{
+  CountedPtr< Scantable > out ;
+  if ( op == "channel" ) {
+    out = arrayOperateChannel( in, val, mode, tsys ) ;
+  }
+  else if ( op == "row" ) {
+    out = arrayOperateRow( in, val, mode, tsys ) ;
+  }
+  else {
+    throw( AipsError( "Unknown array operation mode." ) ) ;
+  }
+  return out ;
+}
+
+CountedPtr< Scantable > STMath::arrayOperateChannel( const CountedPtr< Scantable >& in,
+                                                     const std::vector<float> val,
+                                                     const std::string& mode,
+                                                     bool tsys )
+{
+  // conformity of SPECTRA and TSYS
+  if ( tsys ) {
+    TableIterator titer(in->table(), "IFNO");
+    while ( !titer.pastEnd() ) {
+      ArrayColumn<Float> specCol( in->table(), "SPECTRA" ) ;
+      ArrayColumn<Float> tsysCol( in->table(), "TSYS" ) ;
+      Array<Float> spec = specCol.getColumn() ;
+      Array<Float> ts = tsysCol.getColumn() ;
+      if ( !spec.conform( ts ) ) {
+        throw( AipsError( "SPECTRA and TSYS must conform in shape if you want to apply operation on Tsys." ) ) ;
+      }
+      titer.next() ;
+    }
+  }
+
+  // check if all spectra in the scantable have the same number of channel
+  vector<uInt> nchans;
+  vector<uInt> ifnos = in->getIFNos() ;
+  for ( uInt i = 0 ; i < ifnos.size() ; i++ ) {
+    nchans.push_back( in->nchan( ifnos[i] ) ) ;
+  }
+  Vector<uInt> mchans( nchans ) ;
+  if ( anyNE( mchans, mchans[0] ) ) {
+    throw( AipsError("All spectra in the input scantable must have the same number of channel for vector operation." ) ) ;
+  }
+
+  // check if vector size is equal to nchan
+  Vector<Float> fact( val ) ;
+  if ( fact.nelements() != mchans[0] ) {
+    throw( AipsError("Vector size must be same as number of channel.") ) ;
+  }
+
+  // check divided by zero
+  if ( ( mode == "DIV" ) && anyEQ( fact, (float)0.0 ) ) {
+    throw( AipsError("Divided by zero is not recommended." ) ) ;
+  }
+
+  CountedPtr< Scantable > out = getScantable(in, false);
+  Table& tab = out->table();
+  ArrayColumn<Float> specCol(tab,"SPECTRA");
+  ArrayColumn<Float> tsysCol(tab,"TSYS");
+  for (uInt i=0; i<tab.nrow(); ++i) {
+    Vector<Float> spec;
+    Vector<Float> ts;
+    specCol.get(i, spec);
+    tsysCol.get(i, ts);
+    if (mode == "MUL" || mode == "DIV") {
+      if (mode == "DIV") fact = (float)1.0 / fact;
+      spec *= fact;
+      specCol.put(i, spec);
+      if ( tsys ) {
+        ts *= fact;
+        tsysCol.put(i, ts);
+      }
+    } else if ( mode == "ADD"  || mode == "SUB") {
+      if (mode == "SUB") fact *= (float)-1.0 ;
+      spec += fact;
+      specCol.put(i, spec);
+      if ( tsys ) {
+        ts += fact;
+        tsysCol.put(i, ts);
+      }
+    }
+  }
+  return out;
+}
+
+CountedPtr< Scantable > STMath::arrayOperateRow( const CountedPtr< Scantable >& in,
+                                                 const std::vector<float> val,
+                                                 const std::string& mode,
+                                                 bool tsys )
+{
+  // conformity of SPECTRA and TSYS
+  if ( tsys ) {
+    TableIterator titer(in->table(), "IFNO");
+    while ( !titer.pastEnd() ) {
+      ArrayColumn<Float> specCol( in->table(), "SPECTRA" ) ;
+      ArrayColumn<Float> tsysCol( in->table(), "TSYS" ) ;
+      Array<Float> spec = specCol.getColumn() ;
+      Array<Float> ts = tsysCol.getColumn() ;
+      if ( !spec.conform( ts ) ) {
+        throw( AipsError( "SPECTRA and TSYS must conform in shape if you want to apply operation on Tsys." ) ) ;
+      }
+      titer.next() ;
+    }
+  }
+
+  // check if vector size is equal to nrow
+  Vector<Float> fact( val ) ;
+  if ( fact.nelements() != in->nrow() ) {
+    throw( AipsError("Vector size must be same as number of row.") ) ;
+  }
+
+  // check divided by zero
+  if ( ( mode == "DIV" ) && anyEQ( fact, (float)0.0 ) ) {
+    throw( AipsError("Divided by zero is not recommended." ) ) ;
+  }
+
+  CountedPtr< Scantable > out = getScantable(in, false);
+  Table& tab = out->table();
+  ArrayColumn<Float> specCol(tab,"SPECTRA");
+  ArrayColumn<Float> tsysCol(tab,"TSYS");
+  if (mode == "DIV") fact = (float)1.0 / fact;
+  if (mode == "SUB") fact *= (float)-1.0 ;
+  for (uInt i=0; i<tab.nrow(); ++i) {
+    Vector<Float> spec;
+    Vector<Float> ts;
+    specCol.get(i, spec);
+    tsysCol.get(i, ts);
+    if (mode == "MUL" || mode == "DIV") {
+      spec *= fact[i];
+      specCol.put(i, spec);
+      if ( tsys ) {
+        ts *= fact[i];
+        tsysCol.put(i, ts);
+      }
+    } else if ( mode == "ADD"  || mode == "SUB") {
+      spec += fact[i];
+      specCol.put(i, spec);
+      if ( tsys ) {
+        ts += fact[i];
+        tsysCol.put(i, ts);
+      }
+    }
+  }
+  return out;
+}
+
+CountedPtr< Scantable > STMath::array2dOperate( const CountedPtr< Scantable >& in,
+                                                const std::vector< std::vector<float> > val,
+                                                const std::string& mode,
+                                                bool tsys )
+{
+  // conformity of SPECTRA and TSYS
+  if ( tsys ) {
+    TableIterator titer(in->table(), "IFNO");
+    while ( !titer.pastEnd() ) {
+      ArrayColumn<Float> specCol( in->table(), "SPECTRA" ) ;
+      ArrayColumn<Float> tsysCol( in->table(), "TSYS" ) ;
+      Array<Float> spec = specCol.getColumn() ;
+      Array<Float> ts = tsysCol.getColumn() ;
+      if ( !spec.conform( ts ) ) {
+        throw( AipsError( "SPECTRA and TSYS must conform in shape if you want to apply operation on Tsys." ) ) ;
+      }
+      titer.next() ;
+    }
+  }
+
+  // some checks 
+  vector<uInt> nchans;
+  for ( uInt i = 0 ; i < in->nrow() ; i++ ) {
+    nchans.push_back( (in->getSpectrum( i )).size() ) ;
+  }
+  //Vector<uInt> mchans( nchans ) ;
+  vector< Vector<Float> > facts ;
+  for ( uInt i = 0 ; i < nchans.size() ; i++ ) {
+    Vector<Float> tmp( val[i] ) ;
+    // check divided by zero
+    if ( ( mode == "DIV" ) && anyEQ( tmp, (float)0.0 ) ) {
+      throw( AipsError("Divided by zero is not recommended." ) ) ;
+    }
+    // conformity check
+    if ( tmp.nelements() != nchans[i] ) {
+      stringstream ss ;
+      ss << "Row " << i << ": Vector size must be same as number of channel." ;
+      throw( AipsError( ss.str() ) ) ;
+    }
+    facts.push_back( tmp ) ;
+  }
+
+
+  CountedPtr< Scantable > out = getScantable(in, false);
+  Table& tab = out->table();
+  ArrayColumn<Float> specCol(tab,"SPECTRA");
+  ArrayColumn<Float> tsysCol(tab,"TSYS");
+  for (uInt i=0; i<tab.nrow(); ++i) {
+    Vector<Float> fact = facts[i] ;
+    Vector<Float> spec;
+    Vector<Float> ts;
+    specCol.get(i, spec);
+    tsysCol.get(i, ts);
+    if (mode == "MUL" || mode == "DIV") {
+      if (mode == "DIV") fact = (float)1.0 / fact;
+      spec *= fact;
+      specCol.put(i, spec);
+      if ( tsys ) {
+        ts *= fact;
+        tsysCol.put(i, ts);
+      }
+    } else if ( mode == "ADD"  || mode == "SUB") {
+      if (mode == "SUB") fact *= (float)-1.0 ;
+      spec += fact;
+      specCol.put(i, spec);
+      if ( tsys ) {
+        ts += fact;
         tsysCol.put(i, ts);
       }

branches/alma/src/STMath.h

@@ -117 +117 @@
   casa::CountedPtr<Scantable>
     unaryOperate( const casa::CountedPtr<Scantable>& in, float val,
+                  const std::string& mode, bool tsys=false );
+
+  // array operation
+  casa::CountedPtr<Scantable>
+    arrayOperate( const casa::CountedPtr<Scantable>& in,
+                  const std::vector<float> val,
+                  const std::string& mode, bool tsys=false,
+                  const std::string& op="channel" );
+
+  // channel operation
+  casa::CountedPtr<Scantable>
+    arrayOperateChannel( const casa::CountedPtr<Scantable>& in, 
+                         const std::vector<float> val,
+                         const std::string& mode, bool tsys=false );
+
+  // row operation
+  casa::CountedPtr<Scantable>
+    arrayOperateRow( const casa::CountedPtr<Scantable>& in, 
+                     const std::vector<float> val,
+                     const std::string& mode, bool tsys=false );
+
+  // 2d array operation
+  casa::CountedPtr<Scantable>
+    array2dOperate( const casa::CountedPtr<Scantable>& in,
+                  const std::vector< std::vector<float> > val,
                   const std::string& mode, bool tsys=false );
 

branches/alma/src/STMathWrapper.h

@@ -73 +73 @@
   { return ScantableWrapper(STMath::unaryOperate(in.getCP(), val, mode, tsys)); }
 
+  ScantableWrapper arrayOperate( const ScantableWrapper& in, 
+                                 const std::vector<float> val,
+                                 const std::string& mode, bool tsys=false,
+                                 const std::string& op="channel" )
+  { return ScantableWrapper(STMath::arrayOperate(in.getCP(), val, mode, tsys, op)); }
+
+  ScantableWrapper array2dOperate( const ScantableWrapper& in, 
+                                   const std::vector< std::vector<float> > val,
+                                   const std::string& mode, bool tsys=false )
+  { return ScantableWrapper(STMath::array2dOperate(in.getCP(), val, mode, tsys)); }
+
   ScantableWrapper binaryOperate( const ScantableWrapper& left,
                                   const ScantableWrapper& right,

branches/alma/src/python_STMath.cpp

@@ -49 +49 @@
         .def("_averagebeams", &STMathWrapper::averageBeams)
         .def("_unaryop", &STMathWrapper::unaryOperate)
+        .def("_arrayop", &STMathWrapper::arrayOperate)
+        //.def("_array2dop", &STMathWrapper::array2dOperate)
         .def("_binaryop", &STMathWrapper::binaryOperate)
         .def("_auto_quotient", &STMathWrapper::autoQuotient)