Changeset 2911

Timestamp:

04/01/14 13:05:18 (11 years ago)

Author:

Takeshi Nakazato

Message:

New Development: No

JIRA Issue: No

Ready for Test: Yes

Interface Changes: No

What Interface Changed: Please list interface changes

Test Programs: test_sdcal

Put in Release Notes: Yes/No

Module(s): Module Names change impacts.

Description: Describe your changes here...

Defined new index iterator class, STIdxIter2.
STIdxIter2 has almost same functionality as STIdxIter and support
various kind of data.

Location:

trunk/src

Files:

• STIdxIter.cpp (modified) (2 diffs)
• STIdxIter.h (modified) (2 diffs)
• STMath.cpp (modified) (1 diff)

trunk/src/STIdxIter.cpp

@@ -5 +5 @@
 #include <casa/Arrays/ArrayMath.h>
 #include <casa/Arrays/ArrayIO.h>
+#include <casa/Utilities/DataType.h>
 #include <tables/Tables/ScalarColumn.h>
+#include <tables/Tables/TableRow.h>
+#include <tables/Tables/TableRecord.h>
 #include "STIdxIter.h"
 
@@ -502 +505 @@
 }
 
+STIdxIter2::STIdxIter2()
+  : cols_(),
+    table_(),
+    counter_(0),
+    num_iter_(0),
+    num_row_(0),
+    sorter_(),
+    index_(),
+    unique_(),
+    pointer_()
+{
+}
+
+STIdxIter2::STIdxIter2( const string &name,
+                      const vector<string> &cols )
+  : cols_(cols),
+    table_(name, Table::Old),
+    counter_(0),
+    num_iter_(0),
+    num_row_(0),
+    sorter_(),
+    index_(),
+    unique_(),
+    pointer_()
+{
+  init();
+}
+
+STIdxIter2::STIdxIter2( const CountedPtr<Scantable> &s,
+                      const vector<string> &cols )
+  : cols_(cols),
+    table_(s->table()),
+    counter_(0),
+    num_iter_(0),
+    num_row_(0),
+    sorter_(),
+    index_(),
+    unique_(),
+    pointer_()
+{
+  init();
+}
+
+STIdxIter2::~STIdxIter2()
+{
+  deallocate();
+}
+
+void STIdxIter2::deallocate()
+{
+  for (vector<void*>::iterator i = pointer_.begin(); i != pointer_.end(); ++i) {
+    free(*i);
+  }
+}
+
+Record STIdxIter2::currentValue() {
+  assert(counter_ < num_iter_);
+  Vector<String> cols(cols_.size());
+  for (uInt i = 0; i < cols.nelements(); ++i) {
+    cols[i] = cols_[i];
+  }
+  const ROTableRow row(table_, cols);
+  const TableRecord rec = row.get(index_[unique_[counter_]]);
+  return Record(rec);
+}
+
+Bool STIdxIter2::pastEnd() {
+  return counter_ >= num_iter_;
+}
+
+void STIdxIter2::next() {
+  counter_++;
+}
+
+vector<uInt> STIdxIter2::tovector( Vector<uInt> v )
+{
+  vector<uInt> ret ;
+  v.tovector( ret ) ;
+  return ret ;
+}
+
+Vector<uInt> STIdxIter2::getRows( StorageInitPolicy policy )
+{
+  assert(num_iter_ > 1);
+  assert(counter_ < num_iter_);
+  if (counter_ == num_iter_ - 1) {
+    uInt start = unique_[counter_];
+    uInt num_row = num_row_ - start;
+    Vector<uInt> rows(IPosition(1, num_row), &(index_.data()[start]), policy);
+    return rows;
+  }
+  else {
+    uInt start = unique_[counter_];
+    uInt end = unique_[counter_ + 1];
+    uInt num_row = end - start;
+    Vector<uInt> rows(IPosition(1, num_row), &(index_.data()[start]), policy);
+    return rows;
+  }
+} 
+
+void STIdxIter2::init()
+{
+  for (uInt i = 0; i < cols_.size(); ++i) {
+    addSortKey(cols_[i]);
+  }
+  num_row_ = table_.nrow();
+  sorter_.sort(index_, num_row_);
+  num_iter_ = sorter_.unique(unique_, index_);
+  // cout << "num_row_ = " << num_row_ << endl
+  //      << "num_iter_ = " << num_iter_ << endl;
+  // cout << "unique_ = " << unique_ << endl;
+  // cout << "index_ = " << index_ << endl;
+}
+
+void STIdxIter2::addSortKey(const string &name)
+{
+  const ColumnDesc &desc = table_.tableDesc().columnDesc(name);
+  const DataType dtype = desc.trueDataType();
+  switch (dtype) {
+  case TpUInt:
+    addColumnToKey<uInt, TpUInt>(name);
+    break;
+  case TpInt:
+    addColumnToKey<Int, TpInt>(name);
+    break;
+  case TpFloat:
+    addColumnToKey<Float, TpFloat>(name);
+    break;
+  case TpDouble:
+    addColumnToKey<Double, TpDouble>(name);
+    break;
+  case TpComplex:
+    addColumnToKey<Complex, TpComplex>(name);
+    break;
+  // case TpString:
+  //   addColumnToKey<String, TpString>(name);
+  //   break;
+  default:
+    deallocate();
+    stringstream oss;
+    oss << name << ": data type is not supported" << endl;
+    throw(AipsError(oss.str()));
+  }
+}
+
+template<class T, DataType U>
+void STIdxIter2::addColumnToKey(const string &name)
+{
+  uInt nrow = table_.nrow();
+  void *raw_storage = malloc(sizeof(T) * nrow);
+  T *storage = reinterpret_cast<T*>(raw_storage);
+  Vector<T> array(IPosition(1, nrow), storage, SHARE); 
+  ROScalarColumn<T> col(table_, name);
+  col.getColumn(array);
+  sorter_.sortKey(storage, U, 0, Sort::Ascending);
+  pointer_.push_back(raw_storage);
+}
 } // namespace
+

trunk/src/STIdxIter.h

@@ -8 +8 @@
 #include <casa/Arrays/IPosition.h>
 #include <casa/BasicSL/String.h>
+
+#include <casa/Utilities/Sort.h>
 
 #include "Scantable.h"
@@ -155 +157 @@
 } ;
 
+class STIdxIter2
+{ 
+public:
+  STIdxIter2() ;
+  STIdxIter2( const string &name,
+                             const vector<string> &cols ) ;
+  STIdxIter2( const CountedPtr<Scantable> &s,
+                          const vector<string> &cols ) ; 
+  virtual ~STIdxIter2() ;
+  Record currentValue();
+  Bool pastEnd() ;
+  void next() ;
+  Vector<uInt> getRows(StorageInitPolicy policy=COPY) ;
+  vector<uInt> getRowsSTL() { return tovector( getRows() ) ; } ;
+  virtual void init();
+private:
+  vector<uInt> tovector(Vector<uInt> v);
+  void addSortKey(const string &name);
+  template<class T, DataType U> void addColumnToKey(const string &name);
+  void deallocate();
+  vector<string> cols_;
+  Table table_;
+  uInt counter_;
+  uInt num_iter_;
+  uInt num_row_;
+  Sort sorter_;
+  Vector<uInt> index_;
+  Vector<uInt> unique_;
+  vector<void*> pointer_;
+} ;
+
 } // namespace
 #endif /* _ASAP_INDEX_ITERATOR_H_ */

trunk/src/STMath.cpp

@@ -3621 +3621 @@
     cols[1] = "POLNO" ;
     cols[2] = "IFNO" ;
-    STIdxIter *iter = new STIdxIterAcc( out, cols ) ;
+    STIdxIter2 iter( out, cols ) ;
     STSelector sel ;
-    while ( !iter->pastEnd() ) {
-      Vector<uInt> ids = iter->current() ;
+    while ( !iter.pastEnd() ) {
+      Record ids = iter.currentValue() ;
       stringstream ss ;
       ss << "SELECT FROM $1 WHERE "
-         << "BEAMNO==" << ids[0] << "&&"
-         << "POLNO==" << ids[1] << "&&"
-         << "IFNO==" << ids[2] ;
+         << "BEAMNO==" << ids.asuInt(cols[0]) << "&&"
+         << "POLNO==" << ids.asuInt(cols[1]) << "&&"
+         << "IFNO==" << ids.asuInt(cols[2]) ;
       //cout << "TaQL string: " << ss.str() << endl ;
       sel.setTaQL( ss.str() ) ;
       aoff->setSelection( sel ) ;
-      Vector<uInt> rows = iter->getRows( SHARE ) ;
+      Vector<uInt> rows = iter.getRows( SHARE ) ;
       // out should be an exact copy of s except that SPECTRA column is empty
       calibrateALMA( out, s, aoff, rows ) ;
       aoff->unsetSelection() ;
       sel.reset() ;
-      iter->next() ;
-    }
-    delete iter ;
+      iter.next() ;
+    }
     s->table_ = torg ;
     s->attach() ;