source: trunk/src/SDMemTable.h @ 303

Last change on this file since 303 was 303, checked in by kil064, 19 years ago

add function resetCursor

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 7.7 KB
RevLine 
[2]1//#---------------------------------------------------------------------------
2//# SDMemTable.h: A MemoryTable container for single dish integrations
3//#---------------------------------------------------------------------------
4//# Copyright (C) 2004
[125]5//# ATNF
[2]6//#
7//# This program is free software; you can redistribute it and/or modify it
8//# under the terms of the GNU General Public License as published by the Free
9//# Software Foundation; either version 2 of the License, or (at your option)
10//# any later version.
11//#
12//# This program is distributed in the hope that it will be useful, but
13//# WITHOUT ANY WARRANTY; without even the implied warranty of
14//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
15//# Public License for more details.
16//#
17//# You should have received a copy of the GNU General Public License along
18//# with this program; if not, write to the Free Software Foundation, Inc.,
19//# 675 Massachusetts Ave, Cambridge, MA 02139, USA.
20//#
21//# Correspondence concerning this software should be addressed as follows:
22//#        Internet email: Malte.Marquarding@csiro.au
23//#        Postal address: Malte Marquarding,
24//#                        Australia Telescope National Facility,
25//#                        P.O. Box 76,
26//#                        Epping, NSW, 2121,
27//#                        AUSTRALIA
28//#
29//# $Id:
30//#---------------------------------------------------------------------------
[125]31#ifndef SDMEMTABLE_H
32#define SDMEMTABLE_H
[2]33
34// STL
35#include <string>
36#include <vector>
37// AIPS++
[236]38 #include <casa/aips.h>
[80]39#include <casa/BasicSL/String.h>
40#include <tables/Tables/Table.h>
41#include <casa/Arrays/MaskedArray.h>
[236]42#include "SDDefs.h"
[2]43
[80]44#include <coordinates/Coordinates/SpectralCoordinate.h>
[39]45
[83]46namespace asap {
[2]47
48class SDContainer;
49class SDHeader;
50class SDFrequencyTable;
51
52
53class SDMemTable {
54public:
[19]55  // create a new (empty) SDMemTable
[18]56  SDMemTable();
[50]57  // create a SDMemTable from an (aips++) table on disk
[18]58  SDMemTable(const std::string& name);
[19]59
60  // Copy Construct a SDMemTable, if clear==True only header and
61  // skeleton are copied, otherwise the whole table is copied.
[147]62  SDMemTable(const SDMemTable& other, casa::Bool clear=casa::False);
[2]63
[161]64  // Copy Construct (copy semantics) a SDMemTable, give a scanid constraint
[19]65  // see also getScan()
[125]66  SDMemTable(const casa::Table& tab, const std::string& expr);
[161]67
68  // Assignment operator (copy semantics) 
[138]69  SDMemTable &operator=(const SDMemTable& other);
70 
[2]71  virtual ~SDMemTable();
[19]72
73  // put data from meta conatiner into the table
[39]74  bool putSDContainer(const SDContainer& sdc);
75  bool putSDHeader(const SDHeader& sdh);
76  bool putSDFreqTable(const SDFrequencyTable& sdft);
[21]77
[161]78  //get the data wrapped up in a meta container
[125]79  SDContainer getSDContainer(casa::uInt whichRow=0) const;
[39]80  SDHeader getSDHeader() const;
[293]81
82  // Get SD Frequency table.  Note that this function is largely
83  // unimplemented.  Only the number of freqIDs is filled in presently.
[39]84  SDFrequencyTable getSDFreqTable() const;
[19]85  // get spectrum,mask and tsys for the given row, at the selected
[21]86  // cursor - all as stl vectors
[125]87  virtual std::vector<float> getSpectrum(casa::Int whichRow=0) const;
88  virtual std::vector<bool> getMask(casa::Int whichRow=0) const;
[21]89
[125]90  virtual casa::Float getTsys(casa::Int whichRow=0) const;
[21]91  // get all as aips++ Vectors
[125]92  virtual void getSpectrum(casa::Vector<casa::Float>& spectrum,
[164]93                           casa::Int whichRow=0) const;
[2]94
[88]95  //virtual void getMask(Vector<Bool>& mask,Int whichRow=0) const;
[251]96  std::vector<double> getRestFreqs() const;
97 
[281]98  // get info for current row 
99  // if whichRow == -1 the Header time is given
100  std::string getTime(casa::Int whichRow=0,
101                      casa::Bool showDate=casa::False) const ;
[286]102  casa::MEpoch getEpoch(casa::Int whichRow=0) const;
103  casa::MDirection getDirection(casa::Int whichRow=0,
104                                casa::Bool refBeam=casa::False) const;
105//
[125]106  std::string getSourceName(casa::Int whichRow=0) const;
107  double getInterval(casa::Int whichRow=0) const;
[50]108
[88]109  virtual void setSpectrum(std::vector<float> spectrum, int whichRow=0);
[125]110  virtual void setRestFreqs(std::vector<double> freqs,
111                            const std::string& theunit);
[105]112  virtual void setCoordInfo(std::vector<string> theinfo);
[206]113
[218]114// Get/Set flux unit
[206]115  std::string getFluxUnit() const;
[218]116  void setFluxUnit (const std::string& unit);
[206]117
[236]118// Set Instrument
119  void setInstrument (const std::string& instrument);
120
[19]121  // set the current value
[125]122  virtual bool setIF(casa::Int whichIF=0);
123  virtual bool setBeam(casa::Int whichBeam=0);
124  virtual bool setPol(casa::Int whichPol=0);
[88]125
[303]126  // REset cursor to 0
127  virtual void resetCursor();
128
[88]129  //sets the user mask applied to all spectra
[68]130  virtual bool setMask(std::vector<int> whichChans);
[88]131  // Hard flags the current spectrum, not reversible
132  virtual void flag(int whichRow);
133
[19]134  // return the currently selected values
[154]135  virtual casa::Int getIF() const { return IFSel_; }
136  virtual casa::Int getBeam() const { return beamSel_; }
137  virtual casa::Int getPol() const { return polSel_; }
[263]138
139  // returns unit, conversion frame, doppler, base-frame
[206]140  virtual std::vector<std::string> getCoordInfo() const;
[88]141
[50]142  // number of scans in table
[125]143  virtual casa::Int nScan() const;
[50]144
[206]145  // get a summary of the table
[260]146  virtual std::string summary() const;
[88]147
[206]148  std::vector<std::string> history(int whichRow=0) const;
149  bool appendHistory(const std::string& hist, int whichRow=0);
[19]150  // write to disk as aips++ table
[2]151  void makePersistent(const std::string& filename);
[19]152
[88]153  // get a new SDMemTable containing all rows with the same give SCANID
[164]154  SDMemTable getScan(casa::Int scanID) const;
155  SDMemTable getSource(const std::string& source) const;
[18]156
[125]157  const casa::TableRecord& getHeader() const {return table_.keywordSet();}
[19]158  // get a handle to the "raw" aips++ table
[138]159  const casa::Table& table() const { return table_; }
[2]160
[19]161  // return the number of values
[125]162  casa::Int nBeam() const;
163  casa::Int nIF() const;
164  casa::Int nPol() const;
165  casa::Int nChan() const;
[18]166
[22]167  // return the number of rows (integrations) in the table
[125]168  casa::Int nRow() const { return table_.nrow(); }
[22]169
[19]170  // return a row as a Masked array, internally converting uChar flags
171  // to bool mask
[125]172  casa::MaskedArray<casa::Float> rowAsMaskedArray(casa::uInt whichRow,
[206]173                                                  casa::Bool useSelection =
174                                                  casa::False) const;
[19]175
[286]176  // Return SC, setting only the basic construction state (i.e.
177  // no conversion or velocity or rest frequency state)
178  casa::SpectralCoordinate getSpectralCoordinate(casa::uInt whichIdx) const;
179
180  // Return SC. Set velocity conversion state (unit,doppler),
181  // set rest frequencies.  If row number given (>-0), also set
182  // frame conversion layer (needs direction & time which require row)
183  casa::SpectralCoordinate getSpectralCoordinate(casa::uInt whichIdx, casa::uInt row) const;
184
185  // Set just the reference value, pixel and increment into the table
186  // No other state is extracted.
[125]187  casa::Bool setCoordinate(const casa::SpectralCoordinate& speccord,
188                           casa::uInt whichIdx);
[50]189
[125]190  casa::Int nCoordinates() const;
[88]191
[164]192  std::vector<double> getAbcissa(int whichRow=0) const;
193  std::string getAbcissaString(casa::Int whichRow=0) const;
[212]194
[286]195// Get global reference  types
[281]196  casa::MDirection::Types getDirectionReference() const;
197  casa::MEpoch::Types getTimeReference() const;
[212]198
[286]199// Get global antenna position
200  casa::MPosition getAntennaPosition() const;
201
[236]202// Helper function to check instrument (antenna) name and give enum
[281]203  static Instrument convertInstrument(const casa::String& instrument,
204                                      casa::Bool throwIt);
[236]205
[2]206private:
[105]207  // utility func for nice printout
[260]208  casa::String formatSec(casa::Double x) const;
[281]209  casa::String formatDirection(const casa::MDirection& md) const;
[2]210  void setup();
[19]211  // the current cursor into the array
[125]212  casa::Int IFSel_,beamSel_,polSel_;
[88]213  std::vector<bool> chanMask_;
[50]214  // the underlying memory table
[125]215  casa::Table table_;
[2]216};
217
218}// namespace
219#endif
Note: See TracBrowser for help on using the repository browser.