source: trunk/python/scantable.py@ 496

Last change on this file since 496 was 489, checked in by mar637, 20 years ago
  • added history to all functions, which modify the data
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 28.4 KB
Line 
1from asap._asap import sdtable
2from asap import rcParams
3from numarray import ones,zeros
4import sys
5
6class scantable(sdtable):
7 """
8 The ASAP container for scans
9 """
10
11 def __init__(self, filename, average=None, unit=None):
12 """
13 Create a scantable from a saved one or make a reference
14 Parameters:
15 filename: the name of an asap table on disk
16 or
17 the name of a rpfits/sdfits/ms file
18 (integrations within scans are auto averaged
19 and the whole file is read)
20 or
21 [advanced] a reference to an existing
22 scantable
23 average: average all integrations withinb a scan on read.
24 The default (True) is taken from .asaprc.
25 unit: brightness unit; must be consistent with K or Jy.
26 Over-rides the default selected by the reader
27 (input rpfits/sdfits/ms) or replaces the value
28 in existing scantables
29 """
30 if average is None or type(average) is not bool:
31 average = rcParams['scantable.autoaverage']
32
33 varlist = vars()
34 self._vb = rcParams['verbose']
35 self._p = None
36
37 if isinstance(filename,sdtable):
38 sdtable.__init__(self, filename)
39 if unit is not None:
40 self.set_fluxunit(unit)
41 else:
42 import os.path
43 if not os.path.exists(filename):
44 print "File '%s' not found." % (filename)
45 return
46 filename = os.path.expandvars(filename)
47 if os.path.isdir(filename):
48 # crude check if asap table
49 if os.path.exists(filename+'/table.info'):
50 sdtable.__init__(self, filename)
51 if unit is not None:
52 self.set_fluxunit(unit)
53 else:
54 print "The given file '%s'is not a valid asap table." % (filename)
55 return
56 else:
57 from asap._asap import sdreader
58 ifSel = -1
59 beamSel = -1
60 r = sdreader(filename,ifSel,beamSel)
61 print 'Importing data...'
62 r._read([-1])
63 tbl = r._getdata()
64 if unit is not None:
65 tbl.set_fluxunit(unit)
66 if average:
67 from asap._asap import average as _av
68 tmp = tuple([tbl])
69 print 'Auto averaging integrations...'
70 tbl2 = _av(tmp,(),True,'none')
71 sdtable.__init__(self,tbl2)
72 del r,tbl
73 else:
74 sdtable.__init__(self,tbl)
75 self._add_history("scantable", varlist)
76
77 def save(self, name=None, format=None, stokes=False, overwrite=False):
78 """
79 Store the scantable on disk. This can be an asap (aips++) Table, SDFITS,
80 Image FITS or MS2 format.
81 Parameters:
82 name: the name of the outputfile. For format="FITS" this
83 is the directory file name into which all the files
84 will be written (default is 'asap_FITS')
85 format: an optional file format. Default is ASAP.
86 Allowed are - 'ASAP' (save as ASAP [aips++] Table),
87 'SDFITS' (save as SDFITS file)
88 'FITS' (saves each row as a FITS Image)
89 'ASCII' (saves as ascii text file)
90 'MS2' (saves as an aips++
91 MeasurementSet V2)
92 stokes: Convert to Stokes parameters (only available
93 currently with FITS and ASCII formats.
94 Default is False.
95 overwrite: If the file should be overwritten if it exists.
96 The default False is to return with warning
97 without writing the output. USE WITH CARE.
98 Example:
99 scan.save('myscan.asap')
100 scan.save('myscan.sdfits','SDFITS')
101 """
102 from os import path
103 if format is None: format = rcParams['scantable.save']
104 suffix = '.'+format.lower()
105 if name is None or name =="":
106 name = 'scantable'+suffix
107 print "No filename given. Using default name %s..." % name
108 name = path.expandvars(name)
109 if path.isfile(name) or path.isdir(name):
110 if not overwrite:
111 print "File %s already exists." % name
112 return
113 format2 = format.upper()
114 if format2 == 'ASAP':
115 self._save(name)
116 else:
117 from asap._asap import sdwriter as _sw
118 w = _sw(format2)
119 w.write(self, name, stokes)
120 return
121
122 def copy(self):
123 """
124 Return a copy of this scantable.
125 Parameters:
126 none
127 Example:
128 copiedscan = scan.copy()
129 """
130 sd = scantable(sdtable._copy(self))
131 return sd
132
133 def get_scan(self, scanid=None):
134 """
135 Return a specific scan (by scanno) or collection of scans (by
136 source name) in a new scantable.
137 Parameters:
138 scanid: a scanno or a source name
139 Example:
140 scan.get_scan('323p459')
141 # gets all scans containing the source '323p459'
142 """
143 if scanid is None:
144 print "Please specify a scan no or name to retrieve from the scantable"
145 try:
146 if type(scanid) is str:
147 s = sdtable._getsource(self,scanid)
148 return scantable(s)
149 elif type(scanid) is int:
150 s = sdtable._getscan(self,[scanid])
151 return scantable(s)
152 elif type(scanid) is list:
153 s = sdtable._getscan(self,scanid)
154 return scantable(s)
155 else:
156 print "Illegal scanid type, use 'int' or 'list' if ints."
157 except RuntimeError:
158 print "Couldn't find any match."
159
160 def __str__(self):
161 return sdtable._summary(self,True)
162
163 def summary(self,filename=None, verbose=None):
164 """
165 Print a summary of the contents of this scantable.
166 Parameters:
167 filename: the name of a file to write the putput to
168 Default - no file output
169 verbose: print extra info such as the frequency table
170 The default (False) is taken from .asaprc
171 """
172 info = sdtable._summary(self, verbose)
173 if verbose is None: verbose = rcParams['scantable.verbosesummary']
174 if filename is not None:
175 if filename is "":
176 filename = 'scantable_summary.txt'
177 from os.path import expandvars, isdir
178 filename = expandvars(filename)
179 if not isdir(filename):
180 data = open(filename, 'w')
181 data.write(info)
182 data.close()
183 else:
184 print "Illegal file name '%s'." % (filename)
185 print info
186
187 def set_cursor(self, thebeam=0,theif=0,thepol=0):
188 """
189 Set the spectrum for individual operations.
190 Parameters:
191 thebeam,theif,thepol: a number
192 Example:
193 scan.set_cursor(0,0,1)
194 pol1sig = scan.stats(all=False) # returns std dev for beam=0
195 # if=0, pol=1
196 """
197 varlist = vars()
198 self.setbeam(thebeam)
199 self.setpol(thepol)
200 self.setif(theif)
201 self._add_history("set_cursor",varlist)
202 return
203
204 def get_cursor(self):
205 """
206 Return/print a the current 'cursor' into the Beam/IF/Pol cube.
207 Parameters:
208 none
209 Returns:
210 a list of values (currentBeam,currentIF,currentPol)
211 Example:
212 none
213 """
214 i = self.getbeam()
215 j = self.getif()
216 k = self.getpol()
217 if self._vb:
218 print "--------------------------------------------------"
219 print " Cursor position"
220 print "--------------------------------------------------"
221 out = 'Beam=%d IF=%d Pol=%d ' % (i,j,k)
222 print out
223 return i,j,k
224
225 def stats(self, stat='stddev', mask=None, allaxes=None):
226 """
227 Determine the specified statistic of the current beam/if/pol
228 Takes a 'mask' as an optional parameter to specify which
229 channels should be excluded.
230 Parameters:
231 stat: 'min', 'max', 'sumsq', 'sum', 'mean'
232 'var', 'stddev', 'avdev', 'rms', 'median'
233 mask: an optional mask specifying where the statistic
234 should be determined.
235 allaxes: if True apply to all spectra. Otherwise
236 apply only to the selected (beam/pol/if)spectra only.
237 The default is taken from .asaprc (True if none)
238 Example:
239 scan.set_unit('channel')
240 msk = scan.create_mask([100,200],[500,600])
241 scan.stats(stat='mean', mask=m)
242 """
243 if allaxes is None: allaxes = rcParams['scantable.allaxes']
244 from asap._asap import stats as _stats
245 from numarray import array,zeros,Float
246 if mask == None:
247 mask = ones(self.nchan())
248 axes = ['Beam','IF','Pol','Time']
249
250 beamSel,IFSel,polSel = (self.getbeam(),self.getif(),self.getpol())
251 if allaxes:
252 n = self.nbeam()*self.nif()*self.npol()*self.nrow()
253 shp = [self.nbeam(),self.nif(),self.npol(),self.nrow()]
254 arr = array(zeros(n),shape=shp,type=Float)
255
256 for i in range(self.nbeam()):
257 self.setbeam(i)
258 for j in range(self.nif()):
259 self.setif(j)
260 for k in range(self.npol()):
261 self.setpol(k)
262 arr[i,j,k,:] = _stats(self,mask,stat,-1)
263 retval = {'axes': axes, 'data': arr, 'cursor':None}
264 tm = [self._gettime(val) for val in range(self.nrow())]
265 if self._vb:
266 self._print_values(retval,stat,tm)
267 self.setbeam(beamSel)
268 self.setif(IFSel)
269 self.setpol(polSel)
270 return retval
271
272 else:
273 statval = _stats(self,mask,stat,-1)
274 out = ''
275 for l in range(self.nrow()):
276 tm = self._gettime(l)
277 out += 'Time[%s]:\n' % (tm)
278 if self.nbeam() > 1: out += ' Beam[%d] ' % (beamSel)
279 if self.nif() > 1: out += ' IF[%d] ' % (IFSel)
280 if self.npol() > 1: out += ' Pol[%d] ' % (polSel)
281 out += '= %3.3f\n' % (statval[l])
282 out += "--------------------------------------------------\n"
283
284 if self._vb:
285 print "--------------------------------------------------"
286 print " ",stat
287 print "--------------------------------------------------"
288 print out
289 retval = {'axes': axes, 'data': array(statval), 'cursor':(i,j,k)}
290 return retval
291
292 def stddev(self,mask=None, allaxes=None):
293 """
294 Determine the standard deviation of the current beam/if/pol
295 Takes a 'mask' as an optional parameter to specify which
296 channels should be excluded.
297 Parameters:
298 mask: an optional mask specifying where the standard
299 deviation should be determined.
300 allaxes: optional flag to show all or a cursor selected
301 spectrum of Beam/IF/Pol. Default is all or taken
302 from .asaprc
303
304 Example:
305 scan.set_unit('channel')
306 msk = scan.create_mask([100,200],[500,600])
307 scan.stddev(mask=m)
308 """
309 if allaxes is None: allaxes = rcParams['scantable.allaxes']
310 return self.stats(stat='stddev',mask=mask, allaxes=allaxes);
311
312 def get_tsys(self, allaxes=None):
313 """
314 Return the System temperatures.
315 Parameters:
316 allaxes: if True apply to all spectra. Otherwise
317 apply only to the selected (beam/pol/if)spectra only.
318 The default is taken from .asaprc (True if none)
319 Returns:
320 a list of Tsys values.
321 """
322 if allaxes is None: allaxes = rcParams['scantable.allaxes']
323 from numarray import array,zeros,Float
324 axes = ['Beam','IF','Pol','Time']
325
326 if allaxes:
327 n = self.nbeam()*self.nif()*self.npol()*self.nrow()
328 shp = [self.nbeam(),self.nif(),self.npol(),self.nrow()]
329 arr = array(zeros(n),shape=shp,type=Float)
330
331 for i in range(self.nbeam()):
332 self.setbeam(i)
333 for j in range(self.nif()):
334 self.setif(j)
335 for k in range(self.npol()):
336 self.setpol(k)
337 arr[i,j,k,:] = self._gettsys()
338 retval = {'axes': axes, 'data': arr, 'cursor':None}
339 tm = [self._gettime(val) for val in range(self.nrow())]
340 if self._vb:
341 self._print_values(retval,'Tsys',tm)
342 return retval
343
344 else:
345 i,j,k = (self.getbeam(),self.getif(),self.getpol())
346 statval = self._gettsys()
347 out = ''
348 for l in range(self.nrow()):
349 tm = self._gettime(l)
350 out += 'Time[%s]:\n' % (tm)
351 if self.nbeam() > 1: out += ' Beam[%d] ' % (i)
352 if self.nif() > 1: out += ' IF[%d] ' % (j)
353 if self.npol() > 1: out += ' Pol[%d] ' % (k)
354 out += '= %3.3f\n' % (statval[l])
355 out += "--------------------------------------------------\n"
356
357 if self._vb:
358 print "--------------------------------------------------"
359 print " TSys"
360 print "--------------------------------------------------"
361 print out
362 retval = {'axes': axes, 'data': array(statval), 'cursor':(i,j,k)}
363 return retval
364
365 def get_time(self, row=-1):
366 """
367 Get a list of time stamps for the observations.
368 Return a string for each integration in the scantable.
369 Parameters:
370 row: row no of integration. Default -1 return all rows
371 Example:
372 none
373 """
374 out = []
375 if row == -1:
376 for i in range(self.nrow()):
377 out.append(self._gettime(i))
378 return out
379 else:
380 if row < self.nrow():
381 return self._gettime(row)
382
383 def set_unit(self, unit='channel'):
384 """
385 Set the unit for all following operations on this scantable
386 Parameters:
387 unit: optional unit, default is 'channel'
388 one of '*Hz','km/s','channel', ''
389 """
390 varlist = vars()
391 if unit in ['','pixel', 'channel']:
392 unit = ''
393 inf = list(self._getcoordinfo())
394 inf[0] = unit
395 self._setcoordinfo(inf)
396 if self._p: self.plot()
397 self._add_history("set_unit",varlist)
398
399 def set_instrument(self, instr):
400 """
401 Set the instrument for subsequent processing
402 Parameters:
403 instr: Select from 'ATPKSMB', 'ATPKSHOH', 'ATMOPRA',
404 'DSS-43' (Tid), 'CEDUNA', and 'HOBART'
405 """
406 self._setInstrument(instr)
407 self._add_history("set_instument",vars())
408
409 def set_doppler(self, doppler='RADIO'):
410 """
411 Set the doppler for all following operations on this scantable.
412 Parameters:
413 doppler: One of 'RADIO', 'OPTICAL', 'Z', 'BETA', 'GAMMA'
414 """
415 varlist = vars()
416 inf = list(self._getcoordinfo())
417 inf[2] = doppler
418 self._setcoordinfo(inf)
419 if self._p: self.plot()
420 self._add_history("set_doppler",vars())
421
422 def set_freqframe(self, frame=None):
423 """
424 Set the frame type of the Spectral Axis.
425 Parameters:
426 frame: an optional frame type, default 'LSRK'.
427 Examples:
428 scan.set_freqframe('BARY')
429 """
430 if frame is None: frame = rcParams['scantable.freqframe']
431 varlist = vars()
432 valid = ['REST','TOPO','LSRD','LSRK','BARY', \
433 'GEO','GALACTO','LGROUP','CMB']
434 if frame in valid:
435 inf = list(self._getcoordinfo())
436 inf[1] = frame
437 self._setcoordinfo(inf)
438 self._add_history("set_freqframe",varlist)
439 else:
440 print "Please specify a valid freq type. Valid types are:\n",valid
441
442 def get_unit(self):
443 """
444 Get the default unit set in this scantable
445 Parameters:
446 Returns:
447 A unit string
448 """
449 inf = self._getcoordinfo()
450 unit = inf[0]
451 if unit == '': unit = 'channel'
452 return unit
453
454 def get_abcissa(self, rowno=0):
455 """
456 Get the abcissa in the current coordinate setup for the currently
457 selected Beam/IF/Pol
458 Parameters:
459 rowno: an optional row number in the scantable. Default is the
460 first row, i.e. rowno=0
461 Returns:
462 The abcissa values and it's format string (as a dictionary)
463 """
464 abc = self._getabcissa(rowno)
465 lbl = self._getabcissalabel(rowno)
466 return abc, lbl
467 #return {'abcissa':abc,'label':lbl}
468
469 def create_mask(self, *args, **kwargs):
470 """
471 Compute and return a mask based on [min,max] windows.
472 The specified windows are to be INCLUDED, when the mask is
473 applied.
474 Parameters:
475 [min,max],[min2,max2],...
476 Pairs of start/end points specifying the regions
477 to be masked
478 invert: optional argument. If specified as True,
479 return an inverted mask, i.e. the regions
480 specified are EXCLUDED
481 Example:
482 scan.set_unit('channel')
483
484 a)
485 msk = scan.set_mask([400,500],[800,900])
486 # masks everything outside 400 and 500
487 # and 800 and 900 in the unit 'channel'
488
489 b)
490 msk = scan.set_mask([400,500],[800,900], invert=True)
491 # masks the regions between 400 and 500
492 # and 800 and 900 in the unit 'channel'
493
494 """
495 varlist = vars()
496 u = self._getcoordinfo()[0]
497 if self._vb:
498 if u == "": u = "channel"
499 print "The current mask window unit is", u
500 n = self.nchan()
501 data = self._getabcissa()
502 msk = zeros(n)
503 for window in args:
504 if (len(window) != 2 or window[0] > window[1] ):
505 print "A window needs to be defined as [min,max]"
506 return
507 for i in range(n):
508 if data[i] >= window[0] and data[i] < window[1]:
509 msk[i] = 1
510 if kwargs.has_key('invert'):
511 if kwargs.get('invert'):
512 from numarray import logical_not
513 msk = logical_not(msk)
514 self._add_history("create_mask", varlist)
515 return msk
516
517 def get_restfreqs(self):
518 """
519 Get the restfrequency(s) stored in this scantable.
520 The return value(s) are always of unit 'Hz'
521 Parameters:
522 none
523 Returns:
524 a list of doubles
525 """
526 return list(self._getrestfreqs())
527
528 def lines(self):
529 """
530 Print the list of known spectral lines
531 """
532 sdtable._lines(self)
533
534 def set_restfreqs(self, freqs=None, unit='Hz', lines=None, source=None,
535 theif=None):
536 """
537 Select the restfrequency for the specified source and IF OR
538 replace for all IFs. If the 'freqs' argument holds a scalar,
539 then that rest frequency will be applied to the selected
540 data (and added to the list of available rest frequencies).
541 In this way, you can set a rest frequency for each
542 source and IF combination. If the 'freqs' argument holds
543 a vector, then it MUST be of length the number of IFs
544 (and the available restfrequencies will be replaced by
545 this vector). In this case, *all* data ('source' and
546 'theif' are ignored) have the restfrequency set per IF according
547 to the corresponding value you give in the 'freqs' vector.
548 E.g. 'freqs=[1e9,2e9]' would mean IF 0 gets restfreq 1e9 and
549 IF 1 gets restfreq 2e9.
550
551 You can also specify the frequencies via known line names
552 in the argument 'lines'. Use 'freqs' or 'lines'. 'freqs'
553 takes precedence. See the list of known names via function
554 scantable.lines()
555 Parameters:
556 freqs: list of rest frequencies
557 unit: unit for rest frequency (default 'Hz')
558 lines: list of known spectral lines names (alternative to freqs).
559 See possible list via scantable.lines()
560 source: Source name (blank means all)
561 theif: IF (-1 means all)
562 Example:
563 scan.set_restfreqs(freqs=1.4e9, source='NGC253', theif=2)
564 scan.set_restfreqs(freqs=[1.4e9,1.67e9])
565 """
566 varlist = vars()
567 if source is None:
568 source = ""
569 if theif is None:
570 theif = -1
571 t = type(freqs)
572 if t is int or t is float:
573 freqs = [freqs]
574 if freqs is None:
575 freqs = []
576 t = type(lines)
577 if t is str:
578 lines = [lines]
579 if lines is None:
580 lines = []
581 sdtable._setrestfreqs(self, freqs, unit, lines, source, theif)
582 self._add_history("set_restfreqs", varlist)
583
584
585
586 def flag_spectrum(self, thebeam, theif, thepol):
587 """
588 This flags a selected spectrum in the scan 'for good'.
589 USE WITH CARE - not reversible.
590 Use masks for non-permanent exclusion of channels.
591 Parameters:
592 thebeam,theif,thepol: all have to be explicitly
593 specified
594 Example:
595 scan.flag_spectrum(0,0,1)
596 flags the spectrum for Beam=0, IF=0, Pol=1
597 """
598 if (thebeam < self.nbeam() and
599 theif < self.nif() and
600 thepol < self.npol()):
601 sdtable.setbeam(self, thebeam)
602 sdtable.setif(self, theif)
603 sdtable.setpol(self, thepol)
604 sdtable._flag(self)
605 self._add_history("flag_spectrum", vars())
606 else:
607 print "Please specify a valid (Beam/IF/Pol)"
608 return
609
610 def plot(self, what='spectrum',col='Pol', panel=None):
611 """
612 Plot the spectra contained in the scan. Alternatively you can also
613 Plot Tsys vs Time
614 Parameters:
615 what: a choice of 'spectrum' (default) or 'tsys'
616 col: which out of Beams/IFs/Pols should be colour stacked
617 panel: set up multiple panels, currently not working.
618 """
619 print "Warning! Not fully functional. Use plotter.plot() instead"
620
621 validcol = {'Beam':self.nbeam(),'IF':self.nif(),'Pol':self.npol()}
622
623 validyax = ['spectrum','tsys']
624 from asap.asaplot import ASAPlot
625 if not self._p:
626 self._p = ASAPlot()
627 #print "Plotting not enabled"
628 #return
629 if self._p.is_dead:
630 del self._p
631 self._p = ASAPlot()
632 npan = 1
633 x = None
634 if what == 'tsys':
635 n = self.nrow()
636 if n < 2:
637 print "Only one integration. Can't plot."
638 return
639 self._p.hold()
640 self._p.clear()
641 if panel == 'Time':
642 npan = self.nrow()
643 self._p.set_panels(rows=npan)
644 xlab,ylab,tlab = None,None,None
645 self._vb = False
646 sel = self.get_cursor()
647 for i in range(npan):
648 if npan > 1:
649 self._p.subplot(i)
650 for j in range(validcol[col]):
651 x = None
652 y = None
653 m = None
654 tlab = self._getsourcename(i)
655 import re
656 tlab = re.sub('_S','',tlab)
657 if col == 'Beam':
658 self.setbeam(j)
659 elif col == 'IF':
660 self.setif(j)
661 elif col == 'Pol':
662 self.setpol(j)
663 if what == 'tsys':
664 x = range(self.nrow())
665 xlab = 'Time [pixel]'
666 m = list(ones(len(x)))
667 y = []
668 ylab = r'$T_{sys}$'
669 for k in range(len(x)):
670 y.append(self._gettsys(k))
671 else:
672 x,xlab = self.get_abcissa(i)
673 y = self._getspectrum(i)
674 ylab = r'Flux'
675 m = self._getmask(i)
676 llab = col+' '+str(j)
677 self._p.set_line(label=llab)
678 self._p.plot(x,y,m)
679 self._p.set_axes('xlabel',xlab)
680 self._p.set_axes('ylabel',ylab)
681 self._p.set_axes('title',tlab)
682 self._p.release()
683 self.set_cursor(sel[0],sel[1],sel[2])
684 self._vb = rcParams['verbose']
685 return
686
687 print out
688
689 def _print_values(self, dat, label='', timestamps=[]):
690 d = dat['data']
691 a = dat['axes']
692 shp = d.getshape()
693 out = ''
694 for i in range(shp[3]):
695 out += '%s [%s]:\n' % (a[3],timestamps[i])
696 t = d[:,:,:,i]
697 for j in range(shp[0]):
698 if shp[0] > 1: out += ' %s[%d] ' % (a[0],j)
699 for k in range(shp[1]):
700 if shp[1] > 1: out += ' %s[%d] ' % (a[1],k)
701 for l in range(shp[2]):
702 if shp[2] > 1: out += ' %s[%d] ' % (a[2],l)
703 out += '= %3.3f\n' % (t[j,k,l])
704 out += "-"*80
705 out += "\n"
706 print "-"*80
707 print " ", label
708 print "-"*80
709 print out
710
711 def history(self):
712 hist = list(self._gethistory())
713 print "-"*80
714 for h in hist:
715 if h.startswith("---"):
716 print h
717 else:
718 items = h.split("##")
719 date = items[0]
720 func = items[1]
721 items = items[2:]
722 print date
723 print "Function: %s\n Parameters:" % (func)
724 for i in items:
725 s = i.split("=")
726 print " %s = %s" % (s[0],s[1])
727 print "-"*80
728 return
729
730 def _add_history(self, funcname, parameters):
731 # create date
732 sep = "##"
733 from datetime import datetime
734 dstr = datetime.now().strftime('%Y/%m/%d %H:%M:%S')
735 hist = dstr+sep
736 hist += funcname+sep#cdate+sep
737 if parameters.has_key('self'): del parameters['self']
738 for k,v in parameters.iteritems():
739 if type(v) is dict:
740 for k2,v2 in v.iteritems():
741 hist += k2
742 hist += "="
743 if isinstance(v2,scantable):
744 hist += 'scantable'
745 elif k2 == 'mask':
746 hist += str(self._zip_mask(v2))
747 else:
748 hist += str(v2)
749 else:
750 hist += k
751 hist += "="
752 if isinstance(v,scantable):
753 hist += 'scantable'
754 elif k == 'mask':
755 hist += str(self._zip_mask(v))
756 else:
757 hist += str(v)
758 hist += sep
759 hist = hist[:-2] # remove trailing '##'
760 self._addhistory(hist)
761
762
763 def _zip_mask(self, mask):
764 mask = list(mask)
765 i = 0
766 segments = []
767 while mask[i:].count(1):
768 i += mask[i:].index(1)
769 if mask[i:].count(0):
770 j = i + mask[i:].index(0)
771 else:
772 j = len(mask)
773 segments.append([i,j])
774 i = j
775 return segments
Note: See TracBrowser for help on using the repository browser.