Changeset 872 for trunk/src/STMathWrapper.h

Timestamp:

03/06/06 11:24:02 (18 years ago)

Author:

mar637

Message:

SDMemTable -> Scnatable handling (asap2)

File:

• trunk/src/STMathWrapper.h (modified) (1 diff)

trunk/src/STMathWrapper.h

@@ -1 @@
-//#---------------------------------------------------------------------------
-//# SDMathWrapper.h: Wrapper classes to use CountedPtr
-//#---------------------------------------------------------------------------
-//# Copyright (C) 2004
-//# ATNF
-//#
-//# This program is free software; you can redistribute it and/or modify it
-//# under the terms of the GNU General Public License as published by the Free
-//# Software Foundation; either version 2 of the License, or (at your option)
-//# any later version.
-//#
-//# This program is distributed in the hope that it will be useful, but
-//# WITHOUT ANY WARRANTY; without even the implied warranty of
-//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
-//# Public License for more details.
-//#
-//# You should have received a copy of the GNU General Public License along
-//# with this program; if not, write to the Free Software Foundation, Inc.,
-//# 675 Massachusetts Ave, Cambridge, MA 02139, USA.
-//#
-//# Correspondence concerning this software should be addressed as follows:
-//#        Internet email: Malte.Marquarding@csiro.au
-//#        Postal address: Malte Marquarding,
-//#                        Australia Telescope National Facility,
-//#                        P.O. Box 76,
-//#                        Epping, NSW, 2121,
-//#                        AUSTRALIA
-//#
-//# $Id:
-//#---------------------------------------------------------------------------
-#ifndef SDMATHWRAPPER_H
-#define SDMATHWRAPPER_H
+//
+// C++ Interface: STMathWrapper
+//
+// Description:
+//
+//
+// Author: Malte Marquarding <Malte.Marquarding@csiro.au>, (C) 2006
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef ASAPSTMATHWRAPPER_H
+#define ASAPSTMATHWRAPPER_H
 
 #include <vector>
 #include <string>
 
-#include <boost/python/tuple.hpp>
+#include <casa/Utilities/CountedPtr.h>
 
-#include "SDMemTableWrapper.h"
-#include "SDMath.h"
+#include "STMath.h"
+#include "Scantable.h"
+#include "ScantableWrapper.h"
 
 namespace asap {
 
-namespace SDMathWrapper {
+/**
+Wrapper class to handle ScantableWrapper
 
+@author Malte Marquarding
+*/
+class STMathWrapper : public STMath {
+public:
+  STMathWrapper() {;}
+  STMathWrapper(bool insitu) : STMath(insitu) {;}
 
-  static SDMath sdmath;
-  // Quotient
-  SDMemTableWrapper quotient(const SDMemTableWrapper& on,
-                             const SDMemTableWrapper& off,
-                             casa::Bool preserveContinuum);
+  virtual ~STMathWrapper() {;}
 
-  // Simple binary operations
-  SDMemTableWrapper binaryOperate(const SDMemTableWrapper& left,
-                                  const SDMemTableWrapper& right,
-                                  const std::string& op, bool doTSys);
-  
-  // Multiply
-  void scaleInSitu(SDMemTableWrapper& in, float factor, bool doAll, 
-                   bool doTSys);
-  SDMemTableWrapper scale(const SDMemTableWrapper& in, float factor, 
-                          bool all, bool doTSys);
-  
-  // Add
-  void addInSitu(SDMemTableWrapper& in, float offset, bool doAall);
-  SDMemTableWrapper add(const SDMemTableWrapper& in, float offset, bool all);
+  ScantableWrapper
+    average( const std::vector<ScantableWrapper>& in,
+             const std::vector<bool>& mask,
+             const std::string& weight,
+             const std::string& avmode,
+             bool alignfreq)
+  {
+    std::vector<casa::CountedPtr<Scantable> > sts;
+    for (int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
+    return ScantableWrapper(STMath::average(sts, mask, weight, avmode, alignfreq));
+  }
 
-// Smooth
-  void smoothInSitu(SDMemTableWrapper& in, const std::string& kernel,
-                     float width, bool doAll);
-  SDMemTableWrapper smooth(const SDMemTableWrapper& in,
-                           const std::string& kernel, float width, bool doAll);
+  ScantableWrapper
+    unaryOperate( const ScantableWrapper& in, float val,
+                  const std::string& mode, bool tsys=false )
+  { return ScantableWrapper(STMath::unaryOperate(in.getCP(), val, mode, tsys)); }
 
-// Bin up
-  void binInSitu(SDMemTableWrapper& in, int width);
-  SDMemTableWrapper bin(const SDMemTableWrapper& in, int width);
+  ScantableWrapper quotient( const ScantableWrapper& in,
+                             const std::string& mode = "NEAREST",
+                             bool preserve = true )
+  { return ScantableWrapper(STMath::quotient(in.getCP(), mode, preserve)); }
 
-// Resample 
-  void resampleInSitu(SDMemTableWrapper& in, const std::string& method, 
-                      float width);
-  SDMemTableWrapper resample(const SDMemTableWrapper& in, 
-                             const std::string& method, 
-                             float width);
+  ScantableWrapper
+    freqSwitch( const ScantableWrapper& in )
+  { return ScantableWrapper(STMath::freqSwitch(in.getCP())); }
 
-// Convert brightness between Jy and K
-  void convertFluxInSitu(SDMemTableWrapper& in, float D, float eta, 
-                         float JyPerK, bool doAll);
-  SDMemTableWrapper convertFlux(const SDMemTableWrapper& in, float D, 
-                                float eta, float JyPerK, bool doAll);
+  std::vector<float> statistic(const ScantableWrapper& in,
+                               const std::vector<bool>& mask,
+                               const std::string& which)
+  { return STMath::statistic(in.getCP(), mask, which); }
 
-// Apply gain elevation correction
-  void gainElevationInSitu (SDMemTableWrapper& in, const std::vector<float>& coeffs,
-                            const std::string& fileName, 
-                            const std::string& method, bool doAll);
-  SDMemTableWrapper gainElevation(const SDMemTableWrapper& in, const std::vector<float>& coeffs,
-                                  const std::string& fileName, 
-                                  const std::string& method, bool doAll);
+  ScantableWrapper bin( const ScantableWrapper& in, int width=5)
+  { return ScantableWrapper(STMath::bin(in.getCP(), width)); }
 
-// Apply frequency alignment
-  void frequencyAlignmentInSitu (SDMemTableWrapper& in, const std::string& refTime,
-                                 const std::string& method, bool perFreqID);
-  SDMemTableWrapper frequencyAlignment(const SDMemTableWrapper& in, const std::string& refTime,
-                                       const std::string& method, bool perFreqID);
+  ScantableWrapper
+    resample(const ScantableWrapper& in,
+             const std::string& method, float width)
+  { return ScantableWrapper(STMath::resample(in.getCP(), method, width)); }
 
-// XY Phase rotation
-  void rotateXYPhaseInSitu(SDMemTableWrapper& in, float angle, bool doAll);
+  ScantableWrapper
+    smooth(const ScantableWrapper& in, const std::string& kernel, float width)
+  { return ScantableWrapper(STMath::smooth(in.getCP(), kernel, width)); }
 
-// LinPol Phase rotation
-  void rotateLinPolPhaseInSitu(SDMemTableWrapper& in, float angle, bool doAll);
+  ScantableWrapper
+    gainElevation(const ScantableWrapper& in,
+                  const std::vector<float>& coeff,
+                  const std::string& filename,
+                  const std::string& method)
 
-// Apply opacity correction
-  void opacityInSitu(SDMemTableWrapper& in, float tau, bool doAll);
-  SDMemTableWrapper opacity(const SDMemTableWrapper& in, float tau, 
-                            bool doAll);
+  { return
+      ScantableWrapper(STMath::gainElevation(in.getCP(), coeff, filename, method)); }
 
-// Average in time
-  SDMemTableWrapper average(boost::python::tuple tpl,
-                            const std::vector<bool>& mask,
-                            bool scanAv, const std::string& wt);
+  ScantableWrapper
+    convertFlux(const ScantableWrapper& in, float d,
+                float etaap, float jyperk)
+  { return ScantableWrapper(STMath::convertFlux(in.getCP(), d, etaap, jyperk)); }
 
-// Average polarizations
-  void averagePolInSitu(SDMemTableWrapper& in,  const std::vector<bool>& mask,
-                        const std::string& weightStr);
-  SDMemTableWrapper averagePol(const SDMemTableWrapper& in,
-                               const std::vector<bool>& mask,
-                               const std::string& weightStr);
+  ScantableWrapper opacity(const ScantableWrapper& in,
+                                      float tau)
+  { return ScantableWrapper(STMath::opacity(in.getCP(), tau)); }
 
-  // Frequency Switching
-  void SDMathWrapper::frequencySwitchInSitu(SDMemTableWrapper& in);
+  ScantableWrapper
+    merge(const std::vector<ScantableWrapper >& in)
 
-  SDMemTableWrapper 
-  SDMathWrapper::frequencySwitch(const SDMemTableWrapper& in);
-
-  // Statistics
-  std::vector<float> statistic(const SDMemTableWrapper& in,
-                               const std::vector<bool>& mask, 
-                               const std::string& which, int row);
+  {
+    std::vector<casa::CountedPtr<Scantable> > sts;
+    for (int i=0; i<in.size(); ++i) sts.push_back(in[i].getCP());
+    return ScantableWrapper(STMath::merge(sts)); }
 
 };
 
-} // namespace
+}
+
 #endif