Changeset 1656 for branches/alma

Timestamp:

11/05/09 21:47:49 (15 years ago)

Author:

WataruKawasaki

Message:

New Development: Yes

JIRA Issue: Yes (CAS-1433)

Ready to Release: Yes

Interface Changes: Yes

What Interface Changed: functionalities for row-based flagging added

Test Programs:

Put in Release Notes: No

Module(s): sdflag

Description: Added the following functionalities:

sd.scantable._flag_row()

• to execute row-based flagging

sd.scantable._getflagrow()

• to get row-based flagging info

Location:

branches/alma/src

Files:

• Scantable.cpp (modified) (6 diffs)
• Scantable.h (modified) (4 diffs)
• ScantableWrapper.h (modified) (1 diff)
• python_Scantable.cpp (modified) (1 diff)

branches/alma/src/Scantable.cpp

@@ -109 +109 @@
 {
   initFactories();
+
   Table tab(name, Table::Update);
   uInt version = tab.keywordSet().asuInt("VERSION");
@@ -124 +125 @@
   attach();
 }
+/*
+Scantable::Scantable(const std::string& name, Table::TableType ttype) :
+  type_(ttype)
+{
+  initFactories();
+  Table tab(name, Table::Update);
+  uInt version = tab.keywordSet().asuInt("VERSION");
+  if (version != version_) {
+    throw(AipsError("Unsupported version of ASAP file."));
+  }
+  if ( type_ == Table::Memory ) {
+    table_ = tab.copyToMemoryTable(generateName());
+  } else {
+    table_ = tab;
+  }
+
+  attachSubtables();
+  originalTable_ = table_;
+  attach();
+}
+*/
 
 Scantable::Scantable( const Scantable& other, bool clear )
@@ -204 +226 @@
   td.addColumn(ScalarColumnDesc<Int>("REFBEAMNO"));
 
+  td.addColumn(ScalarColumnDesc<uInt>("FLAGROW"));
+
   td.addColumn(ScalarColumnDesc<Double>("TIME"));
   TableMeasRefDesc measRef(MEpoch::UTC); // UTC as default
@@ -261 +285 @@
   originalTable_ = table_;
 }
-
 
 void Scantable::attach()
@@ -289 +312 @@
   mfocusidCol_.attach(table_, "FOCUS_ID");
   mmolidCol_.attach(table_, "MOLECULE_ID");
+
+  //Add auxiliary column for row-based flagging (CAS-1433 Wataru Kawasaki)
+  attachAuxColumnDef(flagrowCol_, "FLAGROW", 0);
+
+}
+
+template<class T, class T2>
+void Scantable::attachAuxColumnDef(ScalarColumn<T>& col,
+                                   const String& colName,
+                                   const T2& defValue)
+{
+  try {
+    col.attach(table_, colName);
+  } catch (TableError& err) {
+    String errMesg = err.getMesg();
+    if (errMesg == "Table column " + colName + " is unknown") {
+      table_.addColumn(ScalarColumnDesc<T>(colName));
+      col.attach(table_, colName);
+      col.fillColumn(static_cast<T>(defValue));
+    } else {
+      throw;
+    }
+  } catch (...) {
+    throw;
+  }
+}
+
+template<class T, class T2>
+void Scantable::attachAuxColumnDef(ArrayColumn<T>& col,
+                                   const String& colName,
+                                   const Array<T2>& defValue)
+{
+  try {
+    col.attach(table_, colName);
+  } catch (TableError& err) {
+    String errMesg = err.getMesg();
+    if (errMesg == "Table column " + colName + " is unknown") {
+      table_.addColumn(ArrayColumnDesc<T>(colName));
+      col.attach(table_, colName);
+
+      int size = 0;
+      ArrayIterator<T2>& it = defValue.begin();
+      while (it != defValue.end()) {
+        ++size;
+        ++it;
+      }
+      IPosition ip(1, size);
+      Array<T>& arr(ip);
+      for (int i = 0; i < size; ++i)
+        arr[i] = static_cast<T>(defValue[i]);
+      
+      col.fillColumn(arr);
+    } else {
+      throw;
+    }
+  } catch (...) {
+    throw;
+  }
 }
 
@@ -668 +749 @@
     flagsCol_.put(i, flgs);
   }
+}
+
+void Scantable::flagRow(const std::vector<uInt>& rows, bool unflag)
+{
+  if ( selector_.empty() && (rows.size() == table_.nrow()) )
+    throw(AipsError("Trying to flag whole scantable."));
+
+  uInt rowflag = (unflag ? 0 : 1);
+  std::vector<uInt>::const_iterator it;
+  for (it = rows.begin(); it != rows.end(); ++it)
+    flagrowCol_.put(*it, rowflag);
 }
 

branches/alma/src/Scantable.h

@@ -231 +231 @@
 
   /**
+   * Flag the data in a row-based manner. (CAS-1433 Wataru Kawasaki)
+   * param[in] rows    list of row numbers to be flagged
+   */
+  void flagRow( const std::vector<casa::uInt>& rows = std::vector<casa::uInt>(), bool unflag=false);
+
+  /**
+   * Get flagRow info at the specified row. If true, the whole data 
+   * at the row should be flagged.
+   */
+  bool getFlagRow(int whichrow) const
+    { return (flagrowCol_(whichrow) > 0); }
+
+  /**
    * Return a list of row numbers with respect to the original table.
    * @return a list of unsigned ints
@@ -447 +460 @@
   void regridChannel( int nchan, double dnu ) ;
   void regridChannel( int nchan, double dnu, int irow ) ;
+
  
 private:
@@ -523 +537 @@
   casa::ScalarColumn<casa::Float> paraCol_;
   casa::ScalarColumn<casa::String> srcnCol_, fldnCol_;
-  casa::ScalarColumn<casa::uInt> scanCol_, beamCol_, ifCol_, polCol_, cycleCol_;
+  casa::ScalarColumn<casa::uInt> scanCol_, beamCol_, ifCol_, polCol_, cycleCol_, flagrowCol_;
   casa::ScalarColumn<casa::Int> rbeamCol_, srctCol_;
   casa::ArrayColumn<casa::Float> specCol_, tsysCol_;
@@ -544 +558 @@
   void initFactories();
 
+  /**
+   * Add an auxiliary column to the main table and attach it to a 
+   * cached column. Use for adding new columns that the original asap2
+   * tables do not have. 
+   * @param[in] col      reference to the cached column to be attached
+   * @param[in] colName  column name in asap table
+   * @param[in] defValue default value to fill in the column
+   *
+   * 25/10/2009 Wataru Kawasaki
+   */
+  template<class T, class T2> void attachAuxColumnDef(casa::ScalarColumn<T>&,
+                                                       const casa::String&,
+                                                       const T2&);
+  template<class T, class T2> void attachAuxColumnDef(casa::ArrayColumn<T>&,
+                                                      const casa::String&,
+                                                      const casa::Array<T2>&);
 };
 

branches/alma/src/ScantableWrapper.h

@@ -108 +108 @@
     { table_->flag(msk, unflag); }
 
+  void flagRow(const std::vector<casa::uInt>& rows=std::vector<casa::uInt>(), bool unflag=false)
+    { table_->flagRow(rows, unflag); }
+
+  bool getFlagRow(int whichrow=0) const
+    { return table_->getFlagRow(whichrow); }
+
   std::string getSourceName(int whichrow=0) const
     { return table_->getSourceName(whichrow); }

branches/alma/src/python_Scantable.cpp

@@ -105 +105 @@
     .def("get_antennaname", &ScantableWrapper::getAntennaName)
     .def("_flag", &ScantableWrapper::flag)
+    .def("_flag_row", &ScantableWrapper::flagRow)
+    .def("_getflagrow", &ScantableWrapper::getFlagRow,
+         (boost::python::arg("whichrow")=0) )
     .def("_save",  &ScantableWrapper::makePersistent)
     .def("_summary",  &ScantableWrapper::summary,