def test(options):
gvfile = options.gvfile
mr = options.max_res
np = options.np
nsig = options.nsig
from ImageD11 import indexing
print np, mr, nsig
go = grid(np = np , mr = mr , nsig = nsig)
io = indexing.indexer()
io.readgvfile(gvfile)
go.gv_to_grid_new(io.gv )
go.fft()
go.props()
go.peaksearch(open(gvfile+".patterson_pks","w"))
im = go.read_peaks(gvfile+".patterson_pks")
#print "Before reduction", len(go.UBIALL)
#sys.stdout.flush()
#ubinew = go.reduce(go.UBIALL)
#print "After reduction", len(ubinew)
go.UBIALL = ubinew
go.slow_score()
#from matplotlib.pylab import imshow, show
#imshow(im)
#show()
#return im, go
sys.exit()
go.gv_to_grid_old(io.gv)
diff = numpy.ravel(go.grid - go.old_grid)
print "All OK if this is zero",numpy.add.reduce(diff)
print "error at",numpy.argmax(diff),diff.max(),numpy.argmin(diff),diff.min()
def doindex(gve, x, y, z, w):
global NUL
global tmp
global NPKS
global UC
global TOLSEQ
ss = sys.stdout # turns of printing
sys.stdout = NUL
myindexer = indexing.indexer(wavelength=w, unitcell=UC, gv=gve.T)
myindexer.ds = np.sqrt((gve * gve).sum(axis=0))
myindexer.ga = np.zeros(len(myindexer.ds), int) - 1 # Grain assignments
# myindexer.readgvfile( gve )
for ring1 in RING1:
for ring2 in RING2:
myindexer.parameterobj.set_parameters({
'ds_tol': DSTOL,
'minpks': NPKS,
'max_grains': 1000,
'hkl_tol': TOLSEQ[0],
'ring_1': ring1,
'ring_2': ring2
})
myindexer.loadpars()
myindexer.assigntorings()
myindexer.find()
myindexer.scorethem()
grains = [grain.grain(ubi, [x, y, z]) for ubi in myindexer.ubis]
grain.write_grain_file("%s.ubi" % (tmp), grains)
sys.stdout = ss
return len(grains)
def doindex(gve, x, y, z):
global NUL
global tmp
global NPKS
ss = sys.stdout # turns of printing
#sys.stdout = NUL
myindexer = indexing.indexer()
myindexer.readgvfile(gve)
for ring1 in [1, 0, 2]:
for ring2 in [1, 0]:
myindexer.parameterobj.set_parameters({
'ds_tol': 0.004,
'minpks': NPKS,
'max_grains': 1000,
'hkl_tol': 0.02,
'ring_1': ring1,
'ring_2': ring2
})
myindexer.loadpars()
myindexer.assigntorings()
myindexer.find()
myindexer.scorethem()
grains = [grain.grain(ubi, [x, y, z]) for ubi in myindexer.ubis]
grain.write_grain_file("%s.ubi" % (tmp), grains)
sys.stdout = ss
return len(grains)
def __init__(self):
self.objects = {
"peakmerger": peakmerge.peakmerger(),
"transformer": transformer.transformer(),
"indexer": indexing.indexer(),
"solver": eps_sig_solver.solver(),
}
self.commandscript = \
"""# Create objects to manipulate - they hold your data
def testtwin(self):
myindexer = indexing.indexer()
myindexer.readgvfile(os.path.join(os.path.dirname(__file__), 'Al.gve'))
myindexer.updateparameters()
myindexer.parameterobj.set_parameters({
'minpks': 3,
'ring_1': 20,
'ring_2': 20
})
myindexer.loadpars()
myindexer.assigntorings()
myindexer.find()
myindexer.scorethem()
self.assertEqual(len(myindexer.ubis), 1)
def doindex(gve, x, y, z, w, gridpars):
"""
Try to index some g-vectors
"""
NPKS = gridpars['NPKS']
UC = gridpars['UC']
TOLSEQ = gridpars['TOLSEQ']
COSTOL = gridpars['COSTOL']
DSTOL = gridpars['DSTOL']
if "2RFIT" in gridpars:
DOFIT = gridpars['2RFIT']
else:
DOFIT = False
ss = sys.stdout # turns off printing
if gridpars['NUL']:
NUL = open(nulfile, "w")
sys.stdout = NUL
myindexer = indexing.indexer(wavelength=w, unitcell=UC, gv=gve.T)
# added in indexer.__init__
#myindexer.ds = np.sqrt( (gve * gve).sum(axis=0) )
#myindexer.ga = np.zeros(len(myindexer.ds),int)-1 # Grain assignments
for ring1 in gridpars['RING1']:
for ring2 in gridpars['RING2']:
myindexer.parameterobj.set_parameters({
'cosine_tol': COSTOL,
'ds_tol': DSTOL,
'minpks': NPKS,
'max_grains': 1000,
'hkl_tol': TOLSEQ[0],
'ring_1': ring1,
'ring_2': ring2
})
myindexer.loadpars()
myindexer.assigntorings()
try:
myindexer.find()
myindexer.scorethem(fitb4=DOFIT)
except:
pass
# filter out crap
vol = 1 / np.linalg.det(UC.B)
grains = [
grain.grain(ubi, [x, y, z]) for ubi in myindexer.ubis
if np.linalg.det(ubi) > vol * 0.5
]
if gridpars['NUL']:
sys.stdout = ss
return grains
def testtwin(self):
ss = sys.stdout
sys.stdout = fake()
myindexer = indexing.indexer()
myindexer.readgvfile('Al.gve')
myindexer.updateparameters()
myindexer.parameterobj.set_parameters({
'minpks': 3,
'ring_1': 20,
'ring_2': 20
})
myindexer.loadpars()
myindexer.assigntorings()
myindexer.find()
myindexer.scorethem()
sys.stdout = ss
self.assertEqual(len(myindexer.ubis), 1)
def test12(self):
ss = sys.stdout
sys.stdout = fake()
try:
myindexer = indexing.indexer()
myindexer.readgvfile('simAl.gve')
myindexer.updateparameters()
myindexer.parameterobj.set_parameters({
'minpks': '80',
'ring_1': '0',
'ring_2': '1',
})
myindexer.loadpars()
myindexer.assigntorings()
myindexer.find()
myindexer.scorethem()
# myindexer.saveubis( 'test.ubi' )
myindexer.assigntorings()
# myindexer.saveindexing( 'test.idx' )
self.assertEqual(len(myindexer.ubis), 20)
finally:
sys.stdout = ss
from ImageD11 import indexing
import sys
from Numeric import *
from LinearAlgebra import inverse, determinant
from FFT import fftnd, inverse_fftnd
from math import cos, sin, radians, degrees
# test case
if 1:
# Read in the g-vectors
io = indexing.indexer()
io.readgvfile(sys.argv[1])
# Decide on max resolution to use from detector
# higher resolution in reciprocal space = lower in real space
mr = float(sys.argv[2]) # raw_input("Max resolution ?")
cutoff = float(sys.argv[3])
# Array to hold g-vectors on a regular grid
s = 128
g = zeros((s, s, s), Float)
cell_size = s * mr / 2.
print("FFT cell size is 128*mr/2", cell_size)
n_use = 0
n_ignore = 0
import time
start = time.time()
for p in io.gv:
# compute hkl indices in g grid
import time
start = time.time()
# Create objects to manipulate - they hold your data
#
from ImageD11 import indexing
myindexer = indexing.indexer()
#
# Your work starts here:
#
myindexer.readgvfile('simAl.gve')
myindexer.updateparameters()
myindexer.parameterobj.set_parameters({
'minpks': '80',
'ring_1': '0',
'ring_2': '1',
})
myindexer.loadpars()
myindexer.assigntorings()
myindexer.find()
myindexer.scorethem()
myindexer.saveubis('test.ubi')
myindexer.assigntorings()
print "Time:", time.time() - start
myindexer.saveindexing('test.idx')
print "Time:", time.time() - start
def get_eu_gv():
from ImageD11.indexing import indexer, ubitocellpars
o = indexer()
o.readgvfile("eu3.gve", quiet=True)
return o.gv
def grids(flt, tol, npk):
import os
mapfile = open(flt.replace("flt", "maptxt"), "a")
mapfile.write("# %s %f %d\n" % (flt, tol, npk))
dir = flt.replace(".flt", "_mapdir")
os.mkdir(dir)
mytransformer.loadfiltered(flt)
mytransformer.loadfileparameters('krill.prm')
mytransformer.updateparameters()
first = True
for tx in range(-750, 751, 25):
for ty in range(-750, 751, 25):
mytransformer.parameterobj.set_parameters({'t_x': tx, 't_y': ty})
mytransformer.compute_tth_eta()
mytransformer.computegv()
if first:
mytransformer.savegv('map.gve')
myindexer = indexing.indexer()
myindexer.readgvfile('map.gve')
first = False
else:
# Do what readgvfile does...
# Set grain assignments to blanks
# Copy in the g-vectors
gv = np.array([
mytransformer.getcolumn("gx"),
mytransformer.getcolumn("gy"),
mytransformer.getcolumn("gz")
]).T
myindexer.gv = gv
myindexer.ubis = []
myindexer.ga = -1 * np.ones((gv.shape[0], ), int)
myindexer.gvflat = np.reshape(
np.fromstring(myindexer.gv.tostring(), float),
myindexer.gv.shape)
# ds for rings
print(gv.shape)
myindexer.ds = np.sqrt(gv[:, 0] * gv[:, 0] +
gv[:, 1] * gv[:, 1] +
gv[:, 2] * gv[:, 2])
myindexer.ds = myindexer.ds.clip(0, 1.25)
myindexer.scores = []
myindexer.updateparameters()
myindexer.parameterobj.set_parameters({
'hkl_tol': tol,
'minpks': npk,
'ds_tol': '0.01',
'max_grains': '100',
'uniqueness': '0.5',
'eta_range': '0.0',
'ring_1': '3',
'wavelength': '0.26464',
'ring_2': '5',
'cosine_tol': '0.01'
})
myindexer.loadpars()
myindexer.assigntorings()
myindexer.find()
myindexer.scorethem()
mapfile.write("%d %d " % (tx, ty))
if len(myindexer.scores) > 0:
myindexer.saveubis(os.path.join(dir, 'x%d_y%d.ubi' % (tx, ty)))
mapfile.write("%d %d %s\n" %
(len(myindexer.scores), max(
myindexer.scores), str(myindexer.scores)))
else:
mapfile.write("0 0 []\n")
mapfile.flush()
