def update_state(self, mystate):
"""Standard function to update our state"""
mystate('filename_real', [])
mystate('filename_imag', [])
mystate('spline_order', 3)
mystate('normalize', False)
mystate('ampl_interpolation', False)
mystate('verbose', 0)
mystate('l_axis', "L")
mystate('m_axis', "M")
mystate('l_beam_offset', 0.0)
mystate('m_beam_offset', 0.0)
mystate('missing_is_null', False)
# Check filename arguments, and init _vb_key for init_voltage_beams() below
# We may be created with a single filename pair (scalar Jones term), or 4 filenames (full 2x2 matrix)
if isinstance(self.filename_real, str) and isinstance(
self.filename_imag, str):
self._vb_key = ((self.filename_real, self.filename_imag), )
elif len(self.filename_real) == 4 and len(self.filename_imag) == 4:
self._vb_key = tuple(zip(self.filename_real, self.filename_imag))
else:
raise ValueError, "filename_real/filename_imag: either a single filename, or a list of 4 filenames expected"
# other init
mequtils.add_axis('l')
mequtils.add_axis('m')
self._freqaxis = mequtils.get_axis_number("freq")
_verbosity.set_verbose(self.verbose)
def update_state (self,mystate):
"""Standard function to update our state""";
mystate('filename_real',[]);
mystate('filename_imag',[]);
mystate('spline_order',3);
mystate('normalize',False);
mystate('ampl_interpolation',False);
mystate('verbose',0);
mystate('l_axis',"L")
mystate('m_axis',"M")
mystate('l_beam_offset',0.0);
mystate('m_beam_offset',0.0);
mystate('missing_is_null',False);
# Check filename arguments, and init _vb_key for init_voltage_beams() below
# We may be created with a single filename pair (scalar Jones term), or 4 filenames (full 2x2 matrix)
if isinstance(self.filename_real,str) and isinstance(self.filename_imag,str):
self._vb_key = ((self.filename_real,self.filename_imag),);
elif len(self.filename_real) == 4 and len(self.filename_imag) == 4:
self._vb_key = tuple(zip(self.filename_real,self.filename_imag));
else:
raise ValueError,"filename_real/filename_imag: either a single filename, or a list of 4 filenames expected";
# other init
mequtils.add_axis('l');
mequtils.add_axis('m');
self._freqaxis = mequtils.get_axis_number("freq");
_verbosity.set_verbose(self.verbose);
def shape (arg0=None,*args,**kw):
"""Returns a shape object -- basically just a tuple of dimensions. Can
be used as follows:
meq.shape(cells) shape corresponding to Cells
meq.shape(vells) shape of Vells array
meq.shape(vellset) shape of VellSet
meq.shape(nfreq,ntime,...) [nfreq,ntime,...] shape
meq.shape(freq=nf,time=nt,...) [nfreq,ntime,...] shape
""";
if isinstance(arg0,_cells_type):
return shape(**dict([(axis,int(isinstance(grid,float)) or len(grid)) for axis,grid in arg0.grid.iteritems()]));
elif isinstance(arg0,dmi.array_class):
return arg0.shape;
else:
# form up shape from arguments
if isinstance(arg0,(int,long)):
shp = [arg0] + list(args);
else:
shp = list(args);
# now go over keywords
for axis,extent in kw.iteritems():
iaxis = mequtils.get_axis_number(axis);
if iaxis >= len(shp):
shp += [1]*(iaxis-len(shp)+1);
shp[iaxis] = extent;
return shp;
def shape(arg0=None, *args, **kw):
"""Returns a shape object -- basically just a tuple of dimensions. Can
be used as follows:
meq.shape(cells) shape corresponding to Cells
meq.shape(vells) shape of Vells array
meq.shape(vellset) shape of VellSet
meq.shape(nfreq,ntime,...) [nfreq,ntime,...] shape
meq.shape(freq=nf,time=nt,...) [nfreq,ntime,...] shape
"""
if isinstance(arg0, _cells_type):
return shape(**dict([(axis, int(isinstance(grid, float)) or len(grid))
for axis, grid in arg0.grid.items()]))
elif isinstance(arg0, dmi.array_class):
return arg0.shape
else:
# form up shape from arguments
if isinstance(arg0, int):
shp = [arg0] + list(args)
else:
shp = list(args)
# now go over keywords
for axis, extent in kw.items():
iaxis = mequtils.get_axis_number(axis)
if iaxis >= len(shp):
shp += [1] * (iaxis - len(shp) + 1)
shp[iaxis] = extent
return shp
def get_slice(self, *index, **axes):
"""get_slice() returns a FunkSlice of all funklets matching a specified slice.
Slice can be specified in one of two ways: by a vector of axis indices, or by keywords.
E.g.:
get_slice(None,0) or get_slice(freq=0)
returns all funklets for 'name' and the first frequency (first form assumes freq is axis 1,
so time=None and freq=0)
get_slice(0) or get_slice(time=0)
returns all funklets for 'name' and the first timeslot (first form assumes time is axis 0),
get_slice(1,2) or get_slice(time=1,freq=2)
returns all funklets for 'name', timeslot 1, frequency 2.
"""
# make sure index is a vector of max_axes length
if len(index) < mequtils.max_axis:
index = list(index) + [None] * (mequtils.max_axis - len(index))
else:
index = list(index)
# set additional indices from keywords
for axis, num in axes.items():
index[mequtils.get_axis_number(axis)] = num
# build up list of full indices corresponding to specified slice
slice_iaxis = []
indices = [[]]
for iaxis, axis_idx in enumerate(index):
stats = self.pt.axis_stats(iaxis)
# for empty axes, or axes specifed in our call, append number to all indices as is
if axis_idx is not None or stats.empty():
list(map(lambda idx: idx.append(axis_idx), indices))
# non-empty axes NOT specified in our call will be part of the slice
else:
slice_iaxis.append(iaxis)
indices = [
idx + [i] for idx in indices
for i in range(len(stats.grid))
]
# now make funklet list
funkslice = FunkSlice(self.pt, self.name, [], index, slice_iaxis)
for idx in indices:
idx = tuple(idx)
idom = self.pt._domain_reverse_index.get(idx, None)
if idom is not None:
funk = self.pt.parmtable().get_funklet(self.name, idom)
if funk:
funk.domain_index = idom
funk.slice_index = idx
funkslice.funklets.append(funk)
return funkslice
def update_state(self, mystate):
"""Standard function to update our state"""
mystate('filename', [])
mystate('spline_order', 3)
mystate('hier_interpol', True)
mystate('interpol_lm', True)
mystate('l_0', 0.0)
mystate('m_0', 0.0)
mystate('verbose', 0)
mystate('missing_is_null', False)
mystate('beam_symmetry', None)
mystate('normalization_factor', 1)
mystate('rotate_xy', True)
# other init
mequtils.add_axis('l')
mequtils.add_axis('m')
self._freqaxis = mequtils.get_axis_number("freq")
_verbosity.set_verbose(self.verbose)
def update_state (self,mystate):
"""Standard function to update our state""";
mystate('filename',[]);
mystate('spline_order',3);
mystate('hier_interpol',True);
mystate('interpol_lm',True);
mystate('l_0',0.0);
mystate('m_0',0.0);
mystate('verbose',0);
mystate('missing_is_null',False);
mystate('beam_symmetry',None);
mystate('normalization_factor',1);
mystate('rotate_xy',True);
# other init
mequtils.add_axis('l');
mequtils.add_axis('m');
self._freqaxis = mequtils.get_axis_number("freq");
_verbosity.set_verbose(self.verbose);
def get_slice(self, *index, **axes):
"""get_slice() returns a FunkSlice of all funklets matching a specified slice.
Slice can be specified in one of two ways: by a vector of axis indices, or by keywords.
E.g.:
get_slice(None,0) or get_slice(freq=0)
returns all funklets for 'name' and the first frequency (first form assumes freq is axis 1,
so time=None and freq=0)
get_slice(0) or get_slice(time=0)
returns all funklets for 'name' and the first timeslot (first form assumes time is axis 0),
get_slice(1,2) or get_slice(time=1,freq=2)
returns all funklets for 'name', timeslot 1, frequency 2.
"""
# make sure index is a vector of max_axes length
if len(index) < mequtils.max_axis:
index = list(index) + [None] * (mequtils.max_axis - len(index))
else:
index = list(index)
# set additional indices from keywords
for axis, num in axes.items():
index[mequtils.get_axis_number(axis)] = num
# build up list of full indices corresponding to specified slice
slice_iaxis = []
indices = [[]]
for iaxis, axis_idx in enumerate(index):
stats = self.pt.axis_stats(iaxis)
# for empty axes, or axes specifed in our call, append number to all indices as is
if axis_idx is not None or stats.empty():
list(map(lambda idx: idx.append(axis_idx), indices))
# non-empty axes NOT specified in our call will be part of the slice
else:
slice_iaxis.append(iaxis)
indices = [idx + [i] for idx in indices for i in range(len(stats.grid))]
# now make funklet list
funkslice = FunkSlice(self.pt, self.name, [], index, slice_iaxis)
for idx in indices:
idx = tuple(idx)
idom = self.pt._domain_reverse_index.get(idx, None)
if idom is not None:
funk = self.pt.parmtable().get_funklet(self.name, idom)
if funk:
funk.domain_index = idom
funk.slice_index = idx
funkslice.funklets.append(funk)
return funkslice
def update_state (self,mystate):
"""Standard function to update our state""";
mystate('filename_real',[]);
mystate('filename_imag',[]);
mystate('spline_order',3);
mystate('normalize',False);
mystate('ampl_interpolation',False);
mystate('l_0',0.0);
mystate('m_0',0.0);
mystate('verbose',0);
mystate('missing_is_null',False);
# Check filename arguments: we must be created with two identical-length lists
if isinstance(self.filename_real,(list,tuple)) and isinstance(self.filename_imag,(list,tuple)) \
and len(self.filename_real) == len(self.filename_imag) and not len(self.filename_real)%1:
self._vb_key = tuple(zip(self.filename_real,self.filename_imag));
else:
raise ValueError,"filename_real/filename_imag: two lists of filenames of 2N elements each expected";
# other init
mequtils.add_axis('l');
mequtils.add_axis('m');
self._freqaxis = mequtils.get_axis_number("freq");
_verbosity.set_verbose(self.verbose);
def update_state(self, mystate):
"""Standard function to update our state"""
mystate('filename_real', [])
mystate('filename_imag', [])
mystate('spline_order', 3)
mystate('normalize', False)
mystate('ampl_interpolation', False)
mystate('l_0', 0.0)
mystate('m_0', 0.0)
mystate('verbose', 0)
mystate('missing_is_null', False)
# Check filename arguments: we must be created with two identical-length lists
if isinstance(self.filename_real,(list,tuple)) and isinstance(self.filename_imag,(list,tuple)) \
and len(self.filename_real) == len(self.filename_imag) and not len(self.filename_real)%1:
self._vb_key = tuple(zip(self.filename_real, self.filename_imag))
else:
raise ValueError, "filename_real/filename_imag: two lists of filenames of 2N elements each expected"
# other init
mequtils.add_axis('l')
mequtils.add_axis('m')
self._freqaxis = mequtils.get_axis_number("freq")
_verbosity.set_verbose(self.verbose)
def _make_axis_index(self):
"""Builds up various indices based on content of the parmtable"""
# check if cache is up-to-date
cachepath = os.path.join(self.filename, 'ParmTab.cache')
funkpath = os.path.join(self.filename, 'funklets')
self.mtime = os.path.getmtime(funkpath) if os.path.exists(
funkpath) else time.time()
try:
has_cache = os.path.getmtime(cachepath) >= self.mtime
if not has_cache:
dprintf(2, "cache is out of date, will regenerate\n")
except:
dprintf(
0,
"%s: os.path.getmtime() throws exception, assuming cache is out of date\n",
self.filename)
has_cache = False
# try to load the cache if so
t0 = time.time()
if has_cache:
try:
dprintf(2, "loading index cache\n")
self._funklet_names,self._domain_list,self._axis_stats,self._name_components, \
self._domain_fullset,self._domain_cell_index,self._domain_reverse_index \
= pickle.load(open(cachepath, "rb"))
dprintf(2, "elapsed time: %f seconds\n",
time.time() - t0)
t0 = time.time()
return
except:
if verbosity.get_verbose() > 0:
traceback.print_exc()
dprintf(0, "%s: error reading cached stats, regenerating\n",
self.filename)
has_cache = False
# no cache, so regenerate everything
if not has_cache:
self._axis_stats = [
_AxisStats(mequtils.get_axis_id(i))
for i in range(mequtils.max_axis)
]
pt = self.parmtable()
dprintf(2, "loading domain list\n")
self._domain_list = pt.domain_list()
dprintf(2, "elapsed time: %f seconds\n",
time.time() - t0)
t0 = time.time()
dprintf(2, "collecting axis stats\n")
self._axes = {}
for domain in self._domain_list:
for axis, rng in domain.items():
if str(axis) != 'axis_map':
self._axis_stats[mequtils.get_axis_number(
axis)].add_cell(*rng)
dprintf(2, "elapsed time: %f seconds\n",
time.time() - t0)
t0 = time.time()
dprintf(2, "finalizing axis stats\n")
self._domain_fullset = [None] * mequtils.max_axis
for iaxis, stats in enumerate(self._axis_stats):
stats.update()
if not stats.empty():
self._domain_fullset[iaxis] = list(range(len(stats.cells)))
dprintf(2, "axis %s: %d unique cells from %g to %g\n",
stats.name, len(stats.cells), *stats.minmax)
dprintf(2, "elapsed time: %f seconds\n",
time.time() - t0)
t0 = time.time()
dprintf(2, "making subdomain indices\n")
# now make a subdomain index
self._domain_cell_index = [0] * len(self._domain_list)
self._domain_reverse_index = {}
for idom, domain in enumerate(self._domain_list):
index = [None] * mequtils.max_axis
for axis, rng in domain.items():
if str(axis) != 'axis_map':
iaxis = mequtils.get_axis_number(axis)
index[iaxis] = self._axis_stats[iaxis].lookup_cell(
*rng)
# insert into domain_cells_index and domain_reverse_index
index = tuple(index)
self._domain_cell_index[idom] = index
self._domain_reverse_index[index] = idom
dprintf(2, "elapsed time: %f seconds\n",
time.time() - t0)
t0 = time.time()
dprintf(2, "loading funklet name list\n")
self._funklet_names = list(pt.name_list())
dprintf(2, "elapsed time: %f seconds\n",
time.time() - t0)
t0 = time.time()
dprintf(2, "computing funklet indices\n")
self._name_components = {}
for name in self._funklet_names:
for i, token in enumerate(name.split(':')):
self._name_components.setdefault(i, set()).add(token)
self._name_components = [
self._name_components[i]
for i in range(len(self._name_components))
]
for i, values in enumerate(self._name_components):
dprintf(2, "component %d: %s\n", i, ' '.join(values))
dprintf(2, "elapsed time: %f seconds\n",
time.time() - t0)
t0 = time.time()
dprintf(2, "writing cache\n")
try:
pickle.dump((
self._funklet_names,self._domain_list,self._axis_stats,self._name_components, \
self._domain_fullset,self._domain_cell_index,self._domain_reverse_index \
),open(cachepath,'wb')
)
except:
if verbosity.get_verbose() > 0:
traceback.print_exc()
dprintf(
0,
"%s: error writing stats to cache, will probably regenerate next time\n",
self.filename)
dprintf(2, "elapsed time: %f seconds\n",
time.time() - t0)
t0 = time.time()
def _make_axis_index(self):
"""Builds up various indices based on content of the parmtable"""
# check if cache is up-to-date
cachepath = os.path.join(self.filename, 'ParmTab.cache')
funkpath = os.path.join(self.filename, 'funklets')
self.mtime = os.path.getmtime(funkpath) if os.path.exists(funkpath) else time.time()
try:
has_cache = os.path.getmtime(cachepath) >= self.mtime
if not has_cache:
dprintf(2, "cache is out of date, will regenerate\n")
except:
dprintf(0, "%s: os.path.getmtime() throws exception, assuming cache is out of date\n", self.filename)
has_cache = False
# try to load the cache if so
t0 = time.time()
if has_cache:
try:
dprintf(2, "loading index cache\n")
self._funklet_names, self._domain_list, self._axis_stats, self._name_components, \
self._domain_fullset, self._domain_cell_index, self._domain_reverse_index \
= pickle.load(file(cachepath))
dprintf(2, "elapsed time: %f seconds\n", time.time() - t0)
t0 = time.time()
return
except:
if verbosity.get_verbose() > 0:
traceback.print_exc()
dprintf(0, "%s: error reading cached stats, regenerating\n", self.filename)
has_cache = False
# no cache, so regenerate everything
if not has_cache:
self._axis_stats = [_AxisStats(mequtils.get_axis_id(i)) for i in range(mequtils.max_axis)]
pt = self.parmtable()
dprintf(2, "loading domain list\n")
self._domain_list = pt.domain_list()
dprintf(2, "elapsed time: %f seconds\n", time.time() - t0)
t0 = time.time()
dprintf(2, "collecting axis stats\n")
self._axes = {}
for domain in self._domain_list:
for axis, rng in domain.items():
if str(axis) != 'axis_map':
self._axis_stats[mequtils.get_axis_number(axis)].add_cell(*rng)
dprintf(2, "elapsed time: %f seconds\n", time.time() - t0)
t0 = time.time()
dprintf(2, "finalizing axis stats\n")
self._domain_fullset = [None] * mequtils.max_axis
for iaxis, stats in enumerate(self._axis_stats):
stats.update()
if not stats.empty():
self._domain_fullset[iaxis] = list(range(len(stats.cells)))
dprintf(2, "axis %s: %d unique cells from %g to %g\n", stats.name, len(stats.cells), *stats.minmax)
dprintf(2, "elapsed time: %f seconds\n", time.time() - t0)
t0 = time.time()
dprintf(2, "making subdomain indices\n")
# now make a subdomain index
self._domain_cell_index = [0] * len(self._domain_list)
self._domain_reverse_index = {}
for idom, domain in enumerate(self._domain_list):
index = [None] * mequtils.max_axis
for axis, rng in domain.items():
if str(axis) != 'axis_map':
iaxis = mequtils.get_axis_number(axis)
index[iaxis] = self._axis_stats[iaxis].lookup_cell(*rng)
# insert into domain_cells_index and domain_reverse_index
index = tuple(index)
self._domain_cell_index[idom] = index
self._domain_reverse_index[index] = idom
dprintf(2, "elapsed time: %f seconds\n", time.time() - t0)
t0 = time.time()
dprintf(2, "loading funklet name list\n")
self._funklet_names = list(pt.name_list())
dprintf(2, "elapsed time: %f seconds\n", time.time() - t0)
t0 = time.time()
dprintf(2, "computing funklet indices\n")
self._name_components = {}
for name in self._funklet_names:
for i, token in enumerate(name.split(':')):
self._name_components.setdefault(i, set()).add(token)
self._name_components = [self._name_components[i] for i in range(len(self._name_components))]
for i, values in enumerate(self._name_components):
dprintf(2, "component %d: %s\n", i, ' '.join(values))
dprintf(2, "elapsed time: %f seconds\n", time.time() - t0)
t0 = time.time()
dprintf(2, "writing cache\n")
try:
pickle.dump((
self._funklet_names, self._domain_list, self._axis_stats, self._name_components, \
self._domain_fullset, self._domain_cell_index, self._domain_reverse_index \
), file(cachepath, 'w')
)
except:
if verbosity.get_verbose() > 0:
traceback.print_exc()
dprintf(0, "%s: error writing stats to cache, will probably regenerate next time\n", self.filename)
dprintf(2, "elapsed time: %f seconds\n", time.time() - t0)
t0 = time.time()
def update_state (self,mystate):
"""Standard function to update our state""";
mystate('scale',265.667/1.4e+9);
self._freqaxis = mequtils.get_axis_number("freq");
def update_state(self, mystate):
"""Standard function to update our state"""
mystate('scale', 265.667 / 1.4e+9)
self._freqaxis = mequtils.get_axis_number("freq")
