def loadSimpleSpec(self,text="", regionList=[], sensors=[], actuators=[], customs=[], adj=[], outputfile=""):
"""
Load a simple spec given by the arguments without reading from a spec file
For Slurp
region, sensors, actuators, customs are lists of strings representing props
adj is a list of tuples [(region1,region2),...]
"""
if outputfile == "":
logging.error("Need to specify output filename")
return
self.proj.compile_options['decompose'] = False
self.proj.project_root = os.path.abspath(os.path.dirname(os.path.expanduser(outputfile)))
self.proj.project_basename, ext = os.path.splitext(os.path.basename(outputfile))
self.proj.specText=text
# construct a list of region objects with given names
self.proj.rfi = regions.RegionFileInterface()
for rname in regionList:
self.proj.rfi.regions.append(regions.Region(name=rname))
self.proj.enabled_sensors = sensors
self.proj.enabled_actuators = actuators
self.proj.all_customs = customs
# construct adjacency matrix
self.proj.rfi.transitions= [[[] for j in range(len(self.proj.rfi.regions))] for i in range(len(self.proj.rfi.regions))]
for tran in adj:
idx0 = self.proj.rfi.indexOfRegionWithName(tran[0])
idx1 = self.proj.rfi.indexOfRegionWithName(tran[1])
self.proj.rfi.transitions[idx0][idx1] = [(0,0)] # fake trans face
self.proj.rfi.transitions[idx1][idx0] = [(0,0)]
def make_boundary_and_obstacles(regionsList):
"""
create obstacles and boundary based on all roads
"""
bound_poly = Polygon.Polygon()
for r in regionsList:
points = [(pt.x, pt.y) for pt in r.getPoints()]
bound_poly += Polygon.Polygon(points)
print '------------------------------------'
print "Boundary Polygon:" + str(bound_poly)
print '------------------------------------'
# form holes regions
obstacle_regions_list = []
for idx_contour, contour in enumerate(bound_poly):
if bound_poly.isHole(idx_contour):
#print contour
obstacle_region = regions.Region(
name="hole" + str(idx_contour)) #position=regions.Point(x, y)
for idx_pt, pt in enumerate(contour):
obstacle_region.addPoint(
regions.Point(pt[0] - obstacle_region.position.x,
pt[1] - obstacle_region.position.y), idx_pt)
obstacle_region.isObstacle = True
obstacle_regions_list.append(obstacle_region)
else: #this is boundary
bound_region = regions.Region(
name="boundary") #position=regions.Point(x, y)
for idx_boundary, pt in enumerate(contour):
bound_region.addPoint(
regions.Point(pt[0] - bound_region.position.x,
pt[1] - bound_region.position.y),
idx_boundary)
#for x in [region.getPoints() for region in obstacle_regions_list]:
# print list(x)
#print [x for x in bound_region.getPoints()]
round_floating_points(obstacle_regions_list + [bound_region])
return obstacle_regions_list + [bound_region]
def testFieldsDict(self):
# 'description' and 'notes' should be missing.
self.assertEqual(
{
'keyboards': ['xkb:b::b'],
'keyboard_mechanical_layout': 'e',
'description': 'description',
'locales': ['d'],
'region_code': 'aa',
'regulatory_domain': 'AA',
'time_zones': ['c']
}, (regions.Region('aa', 'xkb:b::b', 'c', 'd', 'e', 'description',
'notes').GetFieldsDict()))
def createPoly(name, region_point_list):
"""
create poly
"""
x_origin, y_origin = 0, 0
poly = regions.Region(name=name) #position=regions.Point(x, y)
for idx, (x, y) in enumerate(region_point_list):
if not idx:
x_origin, y_origin = x, y
poly.addPoint(regions.Point(((offset_x+x)*scale-poly.position[0]),\
((offset_y+y)*scale-poly.position[1])),idx)
return poly
def testConsolidateRegionsDups(self):
"""Test duplicate handling. Two identical Regions are OK."""
# Make two copies of the same region.
region_list = [regions.Region('aa', 'xkb:b::b', 'c', 'd', 'e')
for _ in range(2)]
# It's OK.
self.assertEquals(
{'aa': region_list[0]}, regions.ConsolidateRegions(region_list))
# Modify the second copy.
region_list[1].keyboards = ['f']
# Not OK anymore!
self.assertRaisesRegexp(
regions.RegionException, "Conflicting definitions for region 'aa':",
regions.ConsolidateRegions, region_list)
def __init__(self, image, regions_path, fixture_path, template_path):
self.image = image
self.graphics = image
self.paths['regions'] = regions_path
self.paths['fixtures'] = fixture_path
self.paths['templates'] = template_path
for i in range(0,self.rows):
region_row = []
for j in range(0,self.cols):
name = '{0}{1}'.format(i,j)
#Default Colors and dimensions for search regions are the same
k = 0 if j < 2 else j-1
k = 0 if j < 2 else j-1
region = regions.Region(name, self.type_dims[k], self.available_colors[i])
region_row.append(region)
self.regions.append(region_row)
self.load()
self.draw()
def load_dataset_from_hdf(fname):
"""Load dataset from HDF5 file and instantiate a `VoigtFit.Dataset' class."""
with h5py.File(fname, 'r') as hdf:
z_sys = hdf.attrs['redshift']
ds = dataset.DataSet(z_sys)
ds.velspan = hdf.attrs['velspan']
ds.verbose = hdf.attrs['verbose']
if 'name' in hdf.attrs.keys():
ds.set_name(hdf.attrs['name'])
else:
ds.set_name('')
# Load .data:
data = hdf['data']
for chunk in data.values():
res = chunk.attrs['res']
norm = chunk.attrs['norm']
ds.add_data(chunk['wl'].value, chunk['flux'].value, res,
err=chunk['error'].value, normalized=norm)
# Load .regions:
# --- this will be deprecated in later versions
hdf_regions = hdf['regions']
for reg in hdf_regions.values():
region_lines = list()
for line_tag, line_group in reg['lines'].items():
act = line_group.attrs['active']
# Add check for backward compatibility:
if line_tag in dataset.lineList['trans']:
line_instance = dataset.Line(line_tag, active=act)
region_lines.append(line_instance)
ds.all_lines.append(line_tag)
ds.lines[line_tag] = line_instance
else:
print(" [WARNING] - Anomaly detected for line:")
print(" %s" % line_tag)
print(" I suspect that the atomic linelist has changed...")
print("")
# Instantiate the Region Class with the first Line:
line_init = region_lines[0]
v = reg.attrs['velspan']
specID = reg.attrs['specID']
Region = regions.Region(v, specID, line_init)
if len(region_lines) == 1:
# The first and only line has already been loaded
pass
elif len(region_lines) > 1:
# Load the rest of the lines:
for line in region_lines[1:]:
Region.lines.append(line)
else:
err_msg = "Something went wrong in this region: %s. No lines are defined!" % str(reg.name)
raise ValueError(err_msg)
# Set region data and attributes:
Region.res = reg.attrs['res']
Region.normalized = reg.attrs['normalized']
Region.cont_err = reg.attrs['cont_err']
Region.new_mask = reg.attrs['new_mask']
Region.kernel_fwhm = reg.attrs['kernel_fwhm']
try:
Region.label = reg.attrs['label']
except KeyError:
Region.label = ''
Region.kernel = reg['kernel'].value
Region.wl = reg['wl'].value
Region.flux = reg['flux'].value
Region.mask = reg['mask'].value
Region.err = reg['error'].value
ds.regions.append(Region)
# Load .molecules:
molecules = hdf['molecules']
if len(molecules) > 0:
for molecule, band_data in molecules.items():
bands = [[b, J] for b, J in band_data]
ds.molecules[molecule] = bands
# No need to call ds.add_molecule
# lines are added above when defining the regions.
# Load .components:
components = hdf['components']
if 'best_fit' in hdf:
# --- Prepare fit parameters [class: lmfit.Parameters]
ds.best_fit = Parameters()
for ion, comps in components.items():
ds.components[ion] = list()
if len(comps) > 0:
for n, comp in enumerate(comps.values()):
if 'best_fit' in hdf:
# If 'best_fit' exists, use the best-fit values.
# The naming for 'best_fit' and 'components' is parallel
# so one variable in components can easily be identified
# in the best_fit data group by replacing the path:
pointer = comp.name
fit_pointer = pointer.replace('components', 'best_fit')
z = hdf[fit_pointer+'/z'].value
z_err = hdf[fit_pointer+'/z'].attrs['error']
b = hdf[fit_pointer+'/b'].value
b_err = hdf[fit_pointer+'/b'].attrs['error']
logN = hdf[fit_pointer+'/logN'].value
logN_err = hdf[fit_pointer+'/logN'].attrs['error']
else:
z = comp['z'].value
z_err = None
b = comp['b'].value
b_err = None
logN = comp['logN'].value
logN_err = None
# Extract component options:
opts = dict()
for varname in ['z', 'b', 'N']:
if varname == 'N':
hdf_name = 'logN'
else:
hdf_name = varname
tie = comp[hdf_name].attrs['tie_%s' % varname]
tie = None if tie == 'None' else tie
vary = comp[hdf_name].attrs['var_%s' % varname]
opts['tie_%s' % varname] = tie
opts['var_%s' % varname] = vary
# Add component to DataSet class:
ds.add_component(ion, z, b, logN, **opts)
if 'best_fit' in hdf:
# Add Parameters to DataSet.best_fit:
z_name = 'z%i_%s' % (n, ion)
b_name = 'b%i_%s' % (n, ion)
N_name = 'logN%i_%s' % (n, ion)
ds.best_fit.add(z_name, value=z, vary=opts['var_z'])
ds.best_fit[z_name].stderr = z_err
ds.best_fit.add(b_name, value=b, vary=opts['var_b'],
min=0., max=500.)
ds.best_fit[b_name].stderr = b_err
ds.best_fit.add(N_name, value=logN, vary=opts['var_N'],
min=0., max=40.)
ds.best_fit[N_name].stderr = logN_err
if 'best_fit' in hdf:
# Now the components have been defined in ds, so I can use them for the loop
# to set the parameter ties:
for ion, comps in ds.components.items():
for n, comp in enumerate(comps):
z, b, logN, opts = comp
z_name = 'z%i_%s' % (n, ion)
b_name = 'b%i_%s' % (n, ion)
N_name = 'logN%i_%s' % (n, ion)
if opts['tie_z']:
ds.best_fit[z_name].expr = opts['tie_z']
if opts['tie_b']:
ds.best_fit[b_name].expr = opts['tie_b']
if opts['tie_N']:
ds.best_fit[N_name].expr = opts['tie_N']
return ds
def ParseRegions(e, smod):
nregions = int(e[0])
print " - reading %d regions..." % nregions
at = 1
regs = {}
all_regions = {} # Includes groups.
import regions
reload(regions)
for i in range(nregions):
try:
nvoxels = int(e[at])
except:
print " - reached end of file before reading all regions"
break
at += 1
rvs = e[at:at + (nvoxels * 3)]
at += nvoxels * 3
print "Region %d - %d voxels" % (i, nvoxels)
rpoints = numpy.reshape(rvs, (nvoxels, 3)).astype(numpy.int32)
#print rpoints
nparents = int(e[at])
at += 1
parents = e[at:at + nparents].astype(numpy.int)
at += nparents
rid = i + 1
reg = regions.Region(smod, rid, rpoints[0])
smod.mask[rpoints[:, 2], rpoints[:, 1],
rpoints[:, 0]] = rid # set mask at points
all_regions[reg.rid] = reg
regs[reg.rid] = reg
last_reg = reg
reg.preg = None
for pi in parents:
if pi in all_regions:
preg = all_regions[pi]
else:
preg = regions.Region(smod, pi)
preg.max_point = rpoints[0]
all_regions[pi] = preg
last_reg.preg = preg
if preg.cregs.count(last_reg) == 0:
preg.cregs.append(last_reg)
last_reg = preg
# Regions table only includes top level groups.
groups = [reg for reg in all_regions.values() if reg.preg is None]
return all_regions, groups, at
def processInitialGrid(self):
for source in self.regionSources:
self.regions.append(regions.Region(source))
# load in the LTLMoP library
import regions
# load in topo file
print "Loading '{}'...".format(sys.argv[1])
with open(sys.argv[1]) as f:
data = f.read()
data = json.loads(data)
# create LTLMoP regions
rfi = regions.RegionFileInterface()
for rn in data["region_names"]:
newRegion = regions.Region(name=rn)
rfi.regions.append(newRegion)
# force topology (we avoid LTLMoP's automatic coincident edge detection)
rfi.transitions = [[[] for j in range(len(rfi.regions))]
for i in range(len(rfi.regions))]
for path in data["adjacencies"]:
r1 = rfi.indexOfRegionWithName(path[0])
r2 = rfi.indexOfRegionWithName(path[1])
fake_face = [frozenset((regions.Point(1, 2), regions.Point(3, 4)))]
rfi.transitions[r1][r2] = fake_face
rfi.transitions[r2][r1] = fake_face
# save file
output_filename = os.path.splitext(sys.argv[1])[0] + ".converted.regions"
rfi.writeFile(output_filename)
if args.doRegions:
eta_edges_all = [[-3, 3.], [-3, 0., 3.], [-3, 0., 3.],
[-3, -1.0, 1.0, 3],
[-3, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3]]
phi_ndivisions = [2, 2, 3, 3, 10]
jetCollections = {
"df%i" % i: pd.DataFrame()
for i in range(len(phi_ndivisions))
}
legends = []
for i, (eta_edges, phi) in enumerate(zip(eta_edges_all,
phi_ndivisions)):
phi_edges = np.linspace(-np.pi, np.pi, phi)
PFRegions = np.array([[
regions.Region(eta_edges[i], eta_edges[i + 1], phi_edges[j],
phi_edges[j + 1])
for j in range(len(phi_edges) - 1)
] for i in range(len(eta_edges) - 1)])
nRegions = (len(PFRegions) * len(PFRegions[0]))
legends.append(r'Seed, %i regions' % nRegions)
print("Using %i regions for jet reconstruction:" % nRegions)
print("Eta bins: ")
print(eta_edges)
print("Phi bins: ")
print(phi_edges)
for index, event in events.groupby(level=0):
if event.empty: continue
particles_regionized = regions.regionize(event, PFRegions)
for eta_bins in particles_regionized:
for phi_bins in eta_bins: