Changeset 896

Timestamp:

03/10/06 12:09:29 (18 years ago)

Author:

mar637

Message:

enable polarimetry in asap2

Location:

trunk/src

Files:

• STFocus.cpp (modified) (2 diffs)
• STFocus.h (modified) (1 diff)
• STMath.cpp (modified) (1 diff)
• STMath.h (modified) (2 diffs)
• Scantable.cpp (modified) (9 diffs)
• Scantable.h (modified) (5 diffs)
• ScantableWrapper.h (modified) (6 diffs)
• Templates.cpp (modified) (2 diffs)
• python_Scantable.cpp (modified) (1 diff)

trunk/src/STFocus.cpp

@@ -45 +45 @@
 }
 
-STFocus & asap::STFocus::operator =( const STFocus & other )
+STFocus& asap::STFocus::operator =( const STFocus & other )
 {
   if (this != &other) {
@@ -94 +94 @@
 
 void asap::STFocus::getEntry( Float& rotation, Float& angle, Float& ftan,
-                              uInt id)
+                              uInt id) const
 {
   Table t = table_(table_.col("ID") == Int(id) );

trunk/src/STFocus.h

@@ -41 +41 @@
 
   void getEntry( casa::Float& rotation, casa::Float& angle,
-                       casa::Float& ftan, casa::uInt id);
+                       casa::Float& ftan, casa::uInt id) const;
 
   const casa::String& name() const { return name_; }

trunk/src/STMath.cpp

@@ -871 +871 @@
   return out;
 }
+
+CountedPtr< Scantable >
+  STMath::invertPhase( const CountedPtr < Scantable >& in )
+{
+  applyToPol(in, &STPol::invertPhase, Float(0.0));
+}
+
+CountedPtr< Scantable >
+  STMath::rotateXYPhase( const CountedPtr < Scantable >& in, float phase )
+{
+   return applyToPol(in, &STPol::rotatePhase, Float(phase));
+}
+
+CountedPtr< Scantable >
+  STMath::rotateLinPolPhase( const CountedPtr < Scantable >& in, float phase )
+{
+  return applyToPol(in, &STPol::rotateLinPolPhase, Float(phase));
+}
+
+CountedPtr< Scantable > STMath::applyToPol( const CountedPtr<Scantable>& in,
+                                             STPol::polOperation fptr,
+                                             Float phase )
+{
+  CountedPtr< Scantable > out = getScantable(in, false);
+  Table& tout = out->table();
+  Block<String> cols(4);
+  cols[0] = String("SCANNO");
+  cols[1] = String("BEAMNO");
+  cols[2] = String("IFNO");
+  cols[3] = String("CYCLENO");
+  TableIterator iter(tout, cols);
+  STPol* stpol = NULL;
+  stpol =STPol::getPolClass(Scantable::getFactories(), out->getPolType() );
+  while (!iter.pastEnd()) {
+    Table t = iter.table();
+    ArrayColumn<Float> speccol(t, "SPECTRA");
+    Matrix<Float> pols = speccol.getColumn();
+    Matrix<Float> out;
+    try {
+      stpol->setSpectra(pols);
+      (stpol->*fptr)(phase);
+      speccol.putColumn(stpol->getSpectra());
+      delete stpol;stpol=0;
+    } catch (AipsError& e) {
+      delete stpol;stpol=0;
+      throw(e);
+    }
+    ++iter;
+  }
+  return out;
+}
+
+CountedPtr< Scantable >
+  STMath::swapPolarisations( const CountedPtr< Scantable > & in )
+{
+  CountedPtr< Scantable > out = getScantable(in, false);
+  Table& tout = out->table();
+  Table t0 = tout(tout.col("POLNO") == 0);
+  Table t1 = tout(tout.col("POLNO") == 1);
+  if ( t0.nrow() != t1.nrow() )
+    throw(AipsError("Inconsistent number of polarisations"));
+  ArrayColumn<Float> speccol0(t0, "SPECTRA");
+  ArrayColumn<uChar> flagcol0(t0, "FLAGTRA");
+  ArrayColumn<Float> speccol1(t1, "SPECTRA");
+  ArrayColumn<uChar> flagcol1(t1, "FLAGTRA");
+  Matrix<Float> s0 = speccol0.getColumn();
+  Matrix<uChar> f0 = flagcol0.getColumn();
+  speccol0.putColumn(speccol1.getColumn());
+  flagcol0.putColumn(flagcol1.getColumn());
+  speccol1.putColumn(s0);
+  flagcol1.putColumn(f0);
+  return out;
+}

trunk/src/STMath.h

@@ -24 +24 @@
 #include "Scantable.h"
 #include "STDefs.h"
+#include "STPol.h"
 #include "Logger.h"
 
@@ -99 +100 @@
     merge(const std::vector<casa::CountedPtr<Scantable> >& in);
 
+  casa::CountedPtr<Scantable>
+    invertPhase( const casa::CountedPtr<Scantable>& in);
+  casa::CountedPtr<Scantable>
+    rotateXYPhase( const casa::CountedPtr<Scantable>& in, float phase);
+  casa::CountedPtr<Scantable>
+    rotateLinPolPhase( const casa::CountedPtr<Scantable>& in, float phase);
+
   /// @todo frequency alignment
 
+  casa::CountedPtr<Scantable>
+    swapPolarisations(const casa::CountedPtr<Scantable>& in);
+
 private:
+  casa::CountedPtr<Scantable>  applyToPol( const casa::CountedPtr<Scantable>& in,
+                                           STPol::polOperation fptr,
+                                           casa::Float phase);
+
   static imethod stringToIMethod(const std::string& in);
   static WeightType stringToWeight(const std::string& in);

trunk/src/Scantable.cpp

@@ -54 +54 @@
 
 #include "Scantable.h"
+#include "STPolLinear.h"
 #include "STAttr.h"
 
@@ -59 +60 @@
 
 namespace asap {
+
+std::map<std::string, STPol::STPolFactory *> Scantable::factories_;
+
+void Scantable::initFactories() {
+  if ( factories_.empty() ) {
+    Scantable::factories_["linear"] = &STPolLinear::myFactory;
+  }
+}
 
 Scantable::Scantable(Table::TableType ttype) :
   type_(ttype)
 {
+  initFactories();
   setupMainTable();
   freqTable_ = STFrequencies(*this);
@@ -85 +95 @@
   type_(ttype)
 {
+  initFactories();
   Table tab(name, Table::Update);
   Int version;
@@ -566 +577 @@
   if ( selector_.empty() )
     throw(AipsError("Trying to flag whole scantable. Aborted."));
+  TableVector<uChar> tvec(table_, "FLAGTRA");
+  uChar userflag = 1 << 7;
+  tvec = userflag;
 }
 
@@ -580 +594 @@
 }
 
-std::vector<float> Scantable::getSpectrum(int whichrow) const
-{
+std::vector<float> Scantable::getSpectrum( int whichrow,
+                                           const std::string& poltype) const
+{
+  std::vector<float> out;
   Vector<Float> arr;
-  specCol_.get(whichrow, arr);
-  std::vector<float> out;
+  uInt requestedpol = polCol_(whichrow);
+  String basetype = getPolType();
+  if ( String(poltype) == basetype) {
+    specCol_.get(whichrow, arr);
+  } else {
+    STPol* stpol = 0;
+    stpol =STPol::getPolClass(Scantable::factories_, basetype);
+    try {
+      uInt row = uInt(whichrow);
+      stpol->setSpectra(getPolMatrix(row));
+      Float frot,fang,ftan;
+      focusTable_.getEntry(frot, fang, ftan, row);
+      stpol->setPhaseCorrections(frot, fang, ftan);
+      arr = stpol->getSpectrum(requestedpol, poltype);
+      delete stpol;
+    } catch (AipsError& e) {
+      delete stpol;
+      throw(e);
+    }
+  }
   arr.tovector(out);
   return out;
 }
-
 
 void asap::Scantable::setSpectrum( const std::vector<float>& spec,
@@ -597 +630 @@
   specCol_.get(whichrow, arr);
   if ( spectrum.nelements() != arr.nelements() )
-    throw AipsError("The specturm has incorrect number of channels.");
+    throw AipsError("The spectrum has incorrect number of channels.");
   specCol_.put(whichrow, spectrum);
 }
@@ -616 +649 @@
   return table_;
 }
+
+std::string Scantable::getPolType() const
+{
+  return table_.keywordSet().asString("POLTYPE");
+}
+
 
 std::string Scantable::getPolarizationLabel(bool linear, bool stokes,
@@ -655 +694 @@
   oss << setw(15) << "Beams:" << setw(4) << nbeam() << endl
       << setw(15) << "IFs:" << setw(4) << nif() << endl
-      << setw(15) << "Polarisations:" << setw(4) << npol() << endl
+      << setw(15) << "Polarisations:" << setw(4) << npol()
+      << "(" << getPolType() << ")" << endl
       << setw(15) << "Channels:"  << setw(4) << nchan() << endl;
   oss << endl;
@@ -839 +879 @@
 
 
+Matrix<Float> asap::Scantable::getPolMatrix( uInt whichrow ) const
+{
+  ROTableRow row(table_);
+  const TableRecord& rec = row.get(whichrow);
+  Table t =
+    originalTable_( originalTable_.col("SCANNO") == Int(rec.asuInt("SCANNO"))
+                    && originalTable_.col("BEAMNO") == Int(rec.asuInt("BEAMNO"))
+                    && originalTable_.col("IFNO") == Int(rec.asuInt("IFNO"))
+                    && originalTable_.col("CYCLENO") == Int(rec.asuInt("CYCLENO")) );
+  ROArrayColumn<Float> speccol(t, "SPECTRA");
+  return speccol.getColumn();
+}
+
 
 }//namespace asap

trunk/src/Scantable.h

@@ -39 +39 @@
 #include "STSelector.h"
 #include "STHistory.h"
-
-
+#include "STPol.h"
 
 namespace asap {
@@ -205 +204 @@
   int npol(int scanno=-1) const;
 
+  std::string getPolType() const;
+
   /**
    * Get the number of channels in the data or a specific IF. This currently
@@ -246 +247 @@
 
   std::vector<bool> getMask(int whichrow) const;
-  std::vector<float> getSpectrum(int whichrow) const;
+  std::vector<float> getSpectrum(int whichrow,
+                                 const std::string& poltype ="linear") const;
 
   void setSpectrum(const std::vector<float>& spec, int whichrow);
 
-  std::vector<float> getStokesSpectrum( int whichrow=0,
-                                        bool dopol=false) const;
   std::string getPolarizationLabel(bool linear, bool stokes,
                                    bool linpol,
@@ -303 +303 @@
   STHistory& history() { return historyTable_; }
 
+  static const std::map<std::string, STPol::STPolFactory *>& getFactories()
+    { return factories_; }
+
 private:
+
+  casa::Matrix<casa::Float> getPolMatrix( casa::uInt whichrow ) const;
+
   /**
    * Turns a time vale into a formatted string
@@ -395 +401 @@
   casa::ScalarColumn<casa::uInt> mmolidCol_;
 
+  static std::map<std::string, STPol::STPolFactory *> factories_;
+  void initFactories();
+
 };
 

trunk/src/ScantableWrapper.h

@@ -63 +63 @@
   }
 
-  std::vector<float> getSpectrum(int whichRow=0) const {
-    return table_->getSpectrum(whichRow);
+  std::vector<float> getSpectrum( int whichrow=0,
+                                  const std::string& poltype="linear" ) const {
+    return table_->getSpectrum(whichrow, poltype);
   }
-  /*
-  std::vector<float> getStokesSpectrum(int whichRow=0,
-                                       bool linPol=false) const {
-    return table_->getStokesSpectrum(whichRow, linPol);
-  }
-
-  std::vector<float> stokesToPolSpectrum(int whichRow=0, bool linear=false,
-                                         int polIdx=-1) const {
-    return table_->stokesToPolSpectrum(whichRow, linear, polIdx);
-  }
-  */
   //  std::string getPolarizationLabel(bool linear, bool stokes, bool linPol, int polIdx) const {
   // Boost fails with 4 arguments.
@@ -85 +75 @@
   }
 
-  std::vector<double> getAbcissa(int whichRow=0) const
-    { return table_->getAbcissa(whichRow); }
+  std::vector<double> getAbcissa(int whichrow=0) const
+    { return table_->getAbcissa(whichrow); }
 
-  std::string getAbcissaLabel(int whichRow=0) const
-    { return table_->getAbcissaLabel(whichRow); }
+  std::string getAbcissaLabel(int whichrow=0) const
+    { return table_->getAbcissaLabel(whichrow); }
 
-  float getTsys(int whichRow=0) const
-    { return table_->getTsys(whichRow); }
+  float getTsys(int whichrow=0) const
+    { return table_->getTsys(whichrow); }
 
-  std::string getTime(int whichRow=0) const
-    { return table_->getTime(whichRow); }
+  std::string getTime(int whichrow=0) const
+    { return table_->getTime(whichrow); }
 
   std::string getFluxUnit() const { return table_->getFluxUnit(); }
@@ -103 +93 @@
   void setInstrument(const std::string& name) {table_->setInstrument(name);}
 
-  std::vector<bool> getMask(int whichRow=0) const
-    { return table_->getMask(whichRow); }
+  std::vector<bool> getMask(int whichrow=0) const
+    { return table_->getMask(whichrow); }
 
   void flag() { table_->flag(); }
 
-  std::string getSourceName(int whichRow=0) const
-    { return table_->getSourceName(whichRow); }
+  std::string getSourceName(int whichrow=0) const
+    { return table_->getSourceName(whichrow); }
 
-  float getElevation(int whichRow=0) const
-    { return table_->getElevation(whichRow); }
+  float getElevation(int whichrow=0) const
+    { return table_->getElevation(whichrow); }
 
-  float getAzimuth(int whichRow=0) const
-    { return table_->getAzimuth(whichRow); }
+  float getAzimuth(int whichrow=0) const
+    { return table_->getAzimuth(whichrow); }
 
-  float getParAngle(int whichRow=0) const
-    { return table_->getParAngle(whichRow); }
+  float getParAngle(int whichrow=0) const
+    { return table_->getParAngle(whichrow); }
 
 
@@ -133 +123 @@
   void setSelection(const STSelector& sts)
     { return table_->setSelection(sts);}
+
+  std::string getPolType() const { return table_->getPolType(); }
 
   int nif(int scanno=-1) const {return table_->nif(scanno);}
@@ -175 +167 @@
     { table_->addHistory(hist); }
   /*
-  void addFit(int whichRow, const std::vector<double>& p,
+  void addFit(int whichrow, const std::vector<double>& p,
               const std::vector<bool>& m, const std::vector<string>& f,
               const std::vector<int>& c) {
@@ -183 +175 @@
     casa::Vector<casa::String> f2 = mathutil::toVectorString(f);
     casa::Vector<casa::Int> c2(c);
-    table_->addFit(casa::uInt(whichRow), p2,m2,f2,c2);
+    table_->addFit(casa::uInt(whichrow), p2,m2,f2,c2);
   }
-  SDFitTable getSDFitTable(int whichRow) {
-    return table_->getSDFitTable(casa::uInt(whichRow));
+  SDFitTable getSDFitTable(int whichrow) {
+    return table_->getSDFitTable(casa::uInt(whichrow));
   }
   */

trunk/src/Templates.cpp

@@ -74 +74 @@
 template class TabVecRep<Float>;
 
+template class ROTableVector<uChar>;
+template class TableVector<uChar>;
+template class TabVecScaCol<uChar>;
+template class TabVecTemp<uChar>;
+template class TabVecRep<uChar>;
+
 template void convertArray<Bool, uChar>(Array<Bool> &, Array<uChar> const &);
 template void convertArray<uChar, Bool>(Array<uChar> &, Array<Bool> const &);
@@ -110 +116 @@
                         Bool, Bool);
 }
-//template Array<Bool> SDPolUtil::stokesData (Array<Bool>& dataIn, Bool);
-//template Array<Float> SDPolUtil::computeStokesDataForWriter(Array<Float>& dataIn, Bool);
-//template Array<uChar> SDPolUtil::computeStokesDataForWriter(Array<uChar>& dataIn, Bool);
 

trunk/src/python_Scantable.cpp

@@ -63 +63 @@
     .def("_setInstrument", &ScantableWrapper::setInstrument)
     .def("_getspectrum", &ScantableWrapper::getSpectrum,
-         (boost::python::arg("whichrow")=0))
-    /*
-    .def("nstokes", &ScantableWrapper::nStokes)
-    .def("_getstokesspectrum", &ScantableWrapper::getStokesSpectrum,
-         (boost::python::arg("whichrow")=0),
-         (boost::python::arg("linpol")=false) )
-    .def("_stokestopolspectrum", &ScantableWrapper::stokesToPolSpectrum,
-         (boost::python::arg("whichrow")=0),
-         (boost::python::arg("linear")=false),
-         (boost::python::arg("thepol")=-1) )
-    */
+         (arg("whichrow")=0, arg("poltype")=std::string("linear")) )
+    .def("poltype", &ScantableWrapper::getPolType )
     .def("_getpolarizationlabel", &ScantableWrapper::getPolarizationLabel,
-         (boost::python::arg("linear")=false),
-         (boost::python::arg("stokes")=false),
-         (boost::python::arg("linpol")=false) )
-//         (boost::python::arg("thepol")=0) )        // Boost fails with 4 arguments
-   .def("_setspectrum",&ScantableWrapper::setSpectrum,
+         ( arg("linear")=false, arg("stokes")=false,
+           arg("linpol")=false, arg("thepol")=0 ) )
+    .def("_setspectrum",&ScantableWrapper::setSpectrum,
          (boost::python::arg("whichrow")=0) )
     .def("_getabcissa", &ScantableWrapper::getAbcissa,