Source Code for Module Proxy.AIPSData

  1  # Copyright (C) 2005, 2006 Joint Institute for VLBI in Europe 
  2  # 
  3  # This program is free software; you can redistribute it and/or modify 
  4  # it under the terms of the GNU General Public License as published by 
  5  # the Free Software Foundation; either version 2 of the License, or 
  6  # (at your option) any later version. 
  7  # 
  8  # This program is distributed in the hope that it will be useful, 
  9  # but WITHOUT ANY WARRANTY; without even the implied warranty of 
 10  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 11  # GNU General Public License for more details. 
 12   
 13  # You should have received a copy of the GNU General Public License 
 14  # along with this program; if not, write to the Free Software 
 15  # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 16   
 17  """ 
 18   
 19  This module provides the bits and pieces to implement AIPSImage and 
 20  AIPSUVData objects. 
 21   
 22  """ 
 23   
 24  # Bits from Obit. 
 25  import Obit, OErr, OSystem 
 26  import AIPSDir 
 27  import Image, UV 
 28  import TableList 
 29   
 30  # Wizardry bits. 
 31  from Wizardry.AIPSData import AIPSUVData as WAIPSUVData 
 32  from Wizardry.AIPSData import AIPSImage as WAIPSImage 
 33   
 34 -class AIPSData: 
 35 -    def __init__(self): 
 36          self.err = OErr.OErr() 
 37          return 
 38   
 39 -    def exists(self, desc): 
 40          """Checks that this instance of AIPSData refers to a dataset that is 
 41          actually present in the AIPS catalogue.""" 
 42   
 43          assert(not self.err.isErr) 
 44          cno = Obit.AIPSDirFindCNO(desc['disk'], desc['userno'], desc['name'], 
 45                                    desc['klass'], self.type,  desc['seq'], 
 46                                    self.err.me) 
 47          if cno == -1: 
 48              OErr.PClear(self.err) 
 49              return False 
 50          return True 
 51   
 52 -    def verify(self, desc): 
 53          data = self._init(desc) 
 54          return True                # Return something other than None. 
 55   
 56 -    def header(self, desc): 
 57          """Returns the data header.""" 
 58          data = self._init(desc) 
 59          return data.header._generate_dict() 
 60   
 61 -    def _len(self, desc): 
 62          data = self._init(desc) 
 63          return len(data) 
 64   
 65 -    def keywords(self, desc): 
 66          data = self._init(desc) 
 67          return data.keywords._generate_dict() 
 68   
 69 -    def stokes(self, desc): 
 70          data = self._init(desc) 
 71          return data.stokes 
 72   
 73 -    def tables(self, desc): 
 74          data = self._init(desc) 
 75          return data.tables 
 76   
 77 -    def table_highver(self, desc, type): 
 78          """Returns the highest version number of the specified table type.""" 
 79          data = self._init(desc) 
 80          return data.table_highver(type) 
 81   
 82 -    def rename(self, desc, name, klass, seq): 
 83          """Renames the data set.""" 
 84          data = self._init(desc) 
 85          return data.rename(name, klass, seq) 
 86   
 87 -    def zap(self, desc, force): 
 88          """Removes the data set from the AIPS catalogue.""" 
 89          self._init(desc).zap(force) 
 90          return True                # Return something other than None. 
 91   
 92 -    def clrstat(self, desc): 
 93          """Unsets the 'busy' state in the AIPS catalogue. Useful should an 
 94                  AIPS task die mid-step.""" 
 95          self._init(desc).clrstat() 
 96          return True                # Return something other than None. 
 97   
 98 -    def keywords_table(self, desc, type, version): 
 99          data = self._init(desc) 
100          table = data.table(type, version) 
101          try: 
102              result = table.keywords._generate_dict() 
103          finally: 
104              table.close() 
105              pass 
106          return result 
107   
108 -    def version_table(self, desc, type, version): 
109          data = self._init(desc) 
110          table = data.table(type, version) 
111          try: 
112              result = table.version 
113          finally: 
114              table.close() 
115              pass 
116          return result 
117   
118 -    def _getitem_table(self, desc, type, version, key): 
119          data = self._init(desc) 
120          table = data.table(type, version) 
121          try: 
122              result = table[key]._generate_dict() 
123          finally: 
124              table.close() 
125              pass 
126          return result 
127   
128 -    def _len_table(self, desc, type, version): 
129          data = self._init(desc) 
130          table = data.table(type, version) 
131          try: 
132              result = len(table) 
133          finally: 
134              table.close() 
135              pass 
136          return result 
137   
138 -    def zap_table(self, desc, type, version): 
139          """Remove the specified version of the indicated table type.""" 
140          data = self._init(desc) 
141          data.zap_table(type, version) 
142          return True                # Return something other than None. 
143   
144 -    def _getitem_history(self, desc, key): 
145          data = self._init(desc) 
146          history = data.history 
147          try: 
148              result = history[key] 
149          finally: 
150              history.close() 
151              pass 
152          return result 
153   
154      pass                           # class AIPSData 
155   
156   
157 -class AIPSImage(AIPSData): 
158 -    def __init__(self): 
159          self.type = 'MA' 
160          AIPSData.__init__(self) 
161          return 
162   
163 -    def _init(self, desc): 
164          userno = OSystem.PGetAIPSuser() 
165          uvdata = WAIPSImage(desc['name'], desc['klass'], desc['disk'], 
166                              desc['seq'], desc['userno']) 
167          OSystem.PSetAIPSuser(userno) 
168          return uvdata 
169   
170      pass 
171   
172   
173 -class AIPSUVData(AIPSData): 
174 -    def __init__(self): 
175          self.type = 'UV' 
176          AIPSData.__init__(self) 
177          return 
178   
179 -    def _init(self, desc): 
180          userno = OSystem.PGetAIPSuser() 
181          uvdata = WAIPSUVData(desc['name'], desc['klass'], desc['disk'], 
182                               desc['seq'], desc['userno']) 
183          OSystem.PSetAIPSuser(userno) 
184          return uvdata 
185   
186 -    def antennas(self, desc): 
187          uvdata = self._init(desc) 
188          return uvdata.antennas 
189   
190 -    def polarizations(self, desc): 
191          uvdata = self._init(desc) 
192          return uvdata.polarizations 
193   
194 -    def sources(self, desc): 
195          uvdata = self._init(desc) 
196          return uvdata.sources 
197   
198      pass 
199   
200   
201 -class AIPSCat: 
202 -    def __init__(self): 
203          self.err = OErr.OErr() 
204          return 
205   
206 -    def cat(self, disk, userno): 
207          _userno = OSystem.PGetAIPSuser() 
208          OSystem.PSetAIPSuser(userno) 
209   
210          try: 
211              num_slots = AIPSDir.PNumber(disk, userno, self.err) 
212          except OErr.OErr, err: 
213              OErr.PClear(err) 
214              return [] 
215   
216          catalog = [] 
217          for cno in xrange(1, num_slots): 
218              entry = AIPSDir.PInfo(disk, userno, cno, self.err) 
219              if entry: 
220                  dict = {} 
221                  dict['cno'] = cno 
222                  dict['name'] = entry[0:12].strip() 
223                  dict['klass'] = entry[13:19].strip() 
224                  dict['seq'] = int(entry[20:25]) 
225                  dict['type'] = entry[26:28] 
226                  dict['date'] = entry[29:40] 
227                  dict['time'] = entry[41:49] 
228                  catalog.append(dict) 
229                  pass 
230              continue 
231          OSystem.PSetAIPSuser(_userno) 
232          return catalog 
233   
234      pass 
235