def __init__(self, filename=None, new=False):
self.filename = filename
self.bigarray = None
self.titles = []
if filename is not None:
self.parameters = parameters.parameters(filename=filename)
else:
self.parameters = parameters.parameters()
self.ncols = 0
self.nrows = 0
if not new:
self.readfile(filename)
def __init__(self,
unitcell=None,
gv=None,
cosine_tol=0.002,
minpks=10,
hkl_tol=0.01,
ring_1=1,
ring_2=2,
ds_tol=0.005,
wavelength=-1,
uniqueness=0.5,
eta_range=0.,
max_grains=100):
"""
Unitcell would be a unitcell object for generating hkls peaks
gv would be a 3*n array of points in reciprocal space
The rest of the arguments are parameters.
"""
self.unitcell = unitcell
self.gv = gv
if gv is not None: # do init
print('gv:', gv, gv.shape, gv.dtype)
assert gv.shape[1] == 3
self.gv = gv.astype(np.float)
self.ds = np.sqrt((gv * gv).sum(axis=1))
self.ga = np.zeros(len(self.ds), np.int32) - 1 # Grain assignments
self.gvflat = np.ascontiguousarray(gv, np.float)
self.wedge = 0.0 # Default
self.cosine_tol = cosine_tol
self.wavelength = wavelength
self.hkl_tol = hkl_tol
self.ring_1 = ring_1
self.ring_2 = ring_2
self.uniqueness = uniqueness
self.minpks = minpks
self.ds_tol = ds_tol
self.max_grains = max_grains
self.eta_range = eta_range
self.ubis = []
self.scores = []
# it would make more sense to inherit the parameter object - will
# have to think about this some more - how general is it?
from ImageD11 import parameters
self.parameterobj = parameters.parameters(cosine_tol=self.cosine_tol,
hkl_tol=self.hkl_tol,
ring_1=self.ring_1,
ring_2=self.ring_2,
minpks=self.minpks,
uniqueness=self.uniqueness,
ds_tol=self.ds_tol,
wavelength=self.wavelength,
eta_range=self.eta_range,
max_grains=self.max_grains)
# Add a resetting functionality, adapted from
# stackoverflow.com/questions/4866587/pythonic-way-to-reset-an-objects-variables
import copy
self.__pristine_dict = copy.deepcopy(self.__dict__)
def __init__(self,
tolerance=0.01,
intensity_tth_range=(6.1, 6.3),
latticesymmetry=triclinic,
OmFloat=True,
OmSlop=0.25):
"""
"""
self.OMEGA_FLOAT = OmFloat
self.slop = OmSlop
if self.OMEGA_FLOAT:
print("Using", self.slop, "degree slop")
else:
print("Omega is used as observed")
self.tolerance = tolerance
# list of ubi matrices (1 for each grain in each scan)
self.grainnames = []
self.ubisread = {}
self.translationsread = {}
# list of scans and corresponding data
self.scannames = []
self.scantitles = {}
self.scandata = {}
# grains in each scan
self.grains = {}
self.grains_to_refine = []
self.latticesymmetry = latticesymmetry
# ?
self.drlv = None
self.parameterobj = parameters.parameters(**self.pars)
self.intensity_tth_range = intensity_tth_range
self.recompute_xlylzl = False
for k, s in list(self.stepsizes.items()):
self.parameterobj.stepsizes[k] = s
def rdpars(self, parfile=None):
if parfile == None:
parfile = tkFileDialog.askopenfilename(initialdir=os.getcwd())
from ImageD11 import parameters
o = parameters.parameters()
o.loadparameters(parfile)
self.parameters = o.parameters
def make_powder_mask( parfile,
ndeg = 1,
splinefile=None,
dims=(2048, 2048) ):
"""
Compute a two theta and azimuth image
"""
pars = parameters.parameters()
pars.loadparameters( parfile )
if splinefile is None:
spatial = blobcorrector.perfect()
else:
spatial = blobcorrector.correctorclass( splinefile )
xim, yim = spatial.make_pixel_lut ( dims )
peaks = [ np.ravel( xim ) , np.ravel( yim ) ]
tth , eta = transform.compute_tth_eta( peaks , **pars.get_parameters() )
tth.shape = dims
eta.shape = dims
# Assume a circle geometry for now
# tth * eta ~ length on detector
# lim = tth * eta
# need some idea how to cut it up...
# degree bins
m = (eta.astype(np.int) % 2)==0
return m
def setUp(self):
npk = 10240
self.sc = np.random.random(npk) * 2048
self.fc = np.random.random(npk) * 2048
self.pars = parameters.parameters()
self.pars.set('z_center', 980.)
self.pars.set('y_center', 1010.)
self.pars.set('z_size', 48.)
self.pars.set('y_size', 49.)
self.pars.set('distance', 100100.)
def copy(self):
"""
Returns a (deep) copy of the columnfile
"""
cnw = columnfile(self.filename, new=True)
self.chkarray()
cnw.titles = [t for t in self.titles]
cnw.parameters = parameters.parameters(**self.parameters.parameters)
cnw.bigarray = [col.copy() for col in self.__data]
cnw.set_attributes()
return cnw
def readfile(self, filename):
"""
Reads in an ascii columned file
"""
self.titles = []
self.bigarray = None
self.parameters = parameters.parameters(filename=filename)
self.ncols = 0
self.nrows = 0
i = 0
# Check if this is a hdf file: magic number
with open(filename, "rb") as f:
magic = f.read(4)
# 1 2 3 4 bytes
if magic == b'\x89HDF':
print("Reading your columnfile in hdf format")
colfile_from_hdf(filename, obj=self)
return
with open(filename, "r") as f:
raw = f.readlines()
header = True
while header and i < len(raw):
if len(raw[i].lstrip()) == 0:
# skip blank lines
i += 1
continue
if raw[i][0] == "#":
# title line
if raw[i].find("=") > -1:
# key = value line
name, value = clean(raw[i][1:].split("="))
self.parameters.addpar(parameters.par(name, value))
else:
self.titles = raw[i][1:].split()
i += 1
else:
header = False
try:
row0 = [float(v) for v in raw[i].split()]
lastrow = [float(v) for v in raw[-1].split()]
if len(row0) == len(lastrow):
nrows = len(raw) - i
last = None
else:
nrows = len(raw) - i - 1 # skip the last row
last = -1
self.bigarray = np.zeros((len(row0), nrows), np.float)
for i, line in enumerate(raw[i:last]):
self.bigarray[:, i] = [float(v) for v in line.split()]
except:
raise Exception("Problem interpreting your colfile")
(self.ncols, self.nrows) = self.bigarray.shape
self.parameters.dumbtypecheck()
self.set_attributes()
def __init__(self,
unitcell=None,
gv=None,
cosine_tol=0.002,
minpks=10,
hkl_tol=0.01,
ring_1=1,
ring_2=2,
ds_tol=0.005,
wavelength=-1,
uniqueness=0.5,
eta_range=0.,
max_grains=100):
"""
Unitcell would be a unitcell object for generating hkls peaks
gv would be a 3*n array of points in reciprocal space
The rest of the arguments are parameters.
"""
self.unitcell = unitcell
self.gv = gv
if gv is not None:
print 'gv:', gv, gv.shape, gv.dtype
self.wedge = 0.0 # Default
if gv != None:
self.gvflat = np.ascontiguousarray(gv, 'd')
# Makes it contiguous in memory, hkl fast index
self.cosine_tol = cosine_tol
self.wavelength = wavelength
self.hkl_tol = hkl_tol
self.ring_1 = ring_1
self.ring_2 = ring_2
self.uniqueness = uniqueness
self.minpks = minpks
self.ds_tol = ds_tol
self.max_grains = max_grains
self.eta_range = eta_range
self.ubis = []
self.scores = []
# it would make more sense to inherit the parameter object - will
# have to think about this some more - how general is it?
from ImageD11 import parameters
self.parameterobj = parameters.parameters(cosine_tol=self.cosine_tol,
hkl_tol=self.hkl_tol,
ring_1=self.ring_1,
ring_2=self.ring_2,
minpks=self.minpks,
uniqueness=self.uniqueness,
ds_tol=self.ds_tol,
wavelength=self.wavelength,
eta_range=self.eta_range,
max_grains=self.max_grains)
def gridgrains(
ul,
flt,
pars,
minx=-750,
maxx=750,
stepx=25,
miny=-750,
maxy=750,
stepy=25,
tol=0.05,
):
trn = transformer.transformer()
trn.loadfiltered(flt)
trn.parameterobj = parameters.parameters(**pars)
peaks = [trn.getcolumn(trn.xname), trn.getcolumn(trn.yname)]
peaks_xyz = transform.compute_xyz_lab(peaks,
**trn.parameterobj.get_parameters())
omega = trn.getcolumn(trn.omeganame)
trn.updateparameters()
tx = minx - stepx
n = 0
sys.stderr.write("Using tol = %f\n" % (tol))
while tx <= maxx:
tx = tx + stepx
ty = miny - stepy
while ty <= maxy:
ty = ty + stepy
trn.parameterobj.set_parameters({'t_x': tx, 't_y': ty})
pars = trn.parameterobj.get_parameters()
tth, eta = transform.compute_tth_eta_from_xyz(
peaks_xyz, omega, **pars)
if 'omegasign' in pars:
om_sgn = float(pars["omegasign"])
else:
om_sgn = 1.0
gv = transform.compute_g_vectors(tth, eta, omega * om_sgn, **pars)
print(tx, ty, end=' ')
for ubi in ul:
ns = score(ubi, gv.T, tol)
print(ns, end=' ')
n += ns
print()
return n
def __init__(self, parfile=None, fltfile=None):
"""
Nothing is passed in
...will need to loadfileparameters and also peaks
"""
self.unitcell = None
# this sets defaults according to class dict.
self.parameterobj = parameters()
for p in PARAMETERS:
self.parameterobj.addpar(p)
# Interesting - is this an alias for the dict?
self.pars = self.parameterobj.get_parameters()
self.colfile = None
self.xname = None
self.yname = None
self.omeganame = None
self.theoryds = None
if parfile is not None:
self.loadfileparameters(parfile)
if fltfile is not None:
self.loadfiltered(fltfile)
def make_pars(parfile):
from ImageD11.parameters import parameters
from ImageD11 import transform
p = parameters()
p.loadparameters(parfile)
rmat = transform.detector_rotation_matrix(float(p.parameters["tilt_x"]),
float(p.parameters["tilt_y"]),
float(p.parameters["tilt_z"]))
fmat = np.array(
[[1, 0, 0], [
0, float(p.parameters['o11']),
float(p.parameters['o12'])
], [0, float(p.parameters['o21']),
float(p.parameters['o22'])]], np.float32)
pars = np.array([
float(p.parameters["y_center"]),
float(p.parameters["y_size"]),
float(p.parameters["z_center"]),
float(p.parameters["z_size"]),
float(p.parameters["distance"])
] + list(np.dot(rmat, fmat).ravel()), np.float32)
return pars
def __init__(self, splinefile=None, parfile=None):
"""
splinefile = fit2d spline file, or None for images
that are already corrected
parfile = ImageD11 parameter file. Can be fitted
using old ImageD11_gui.py or newer fable.transform
plugin.
"""
self.splinefile = splinefile
if self.splinefile is None:
self.spatial = blobcorrector.perfect()
else:
self.spatial = blobcorrector.correctorclass(splinefile)
self.parfile = parfile
self.pars = parameters.parameters()
self.pars.loadparameters(parfile)
for key in self.required_pars:
if key not in self.pars.parameters:
raise Exception("Missing parameter " + str(par))
import sys
from ImageD11.columnfile import columnfile
from ImageD11.parameters import parameters
from ImageD11.transform import compute_xyz_lab, detector_rotation_matrix
import cImageD11_wrap
import numpy as np, time
start = time.time()
c = columnfile(sys.argv[1])
p = parameters()
p.loadparameters(sys.argv[2])
try:
pks = [c.sc, c.fc]
except:
pks = [c.xc, c.yc]
testtilts = [-0.5, 0., 0.24]
tilts = [(x, y, z) for x in testtilts for y in testtilts for z in testtilts]
pars = np.array(
(p.get("z_center"), p.get("y_center"), p.get("z_size"), p.get("y_size")))
dist = np.array((p.get("distance"), 0., 0.))
for o11, o12, o21, o22 in [[1, 0, 0, 1], [-1, 0, 0, 1], [-1, 0, 0, -1],
[1, 0, 0, -1], [0, 1, 1, 0], [0, -1, 1, 0],
[0, -1, -1, 0], [0, 1, -1, 0]]:
for tx, ty, tz in tilts:
p.parameters['tilt_x'] = tx
p.parameters['tilt_y'] = ty
for ubi in ul:
ns = score(ubi, gv.T, tol)
print(ns, end=' ')
n += ns
print()
return n
if __name__ == "__main__":
flt = sys.argv[1]
par = sys.argv[2]
grains = sys.argv[3]
ul = indexing.readubis(grains)
po = parameters.parameters()
po.loadparameters(par)
pars = po.get_parameters()
dcen = float(pars["distance"])
zcen = float(pars["z_center"])
ycen = float(pars["y_center"])
f = open("parmap", "a")
for dist in [dcen * 0.99, dcen, dcen * 1.01]:
pars["distance"] = dist
for yc in [ycen - 1, ycen, ycen + 1]:
pars["y_center"] = yc
for zc in [zcen - 1, zcen, zcen + 1]:
pars["z_center"] = zc
print("\n\n# %f %f %f" % (dist, yc, zc))
npk = gridgrains(ul, flt, pars)
import sys
import numpy as n
from string import split
from xfab import tools
from six.moves import range
if len(sys.argv) < 4:
print("\n")
print("########################################################")
print("Usage:")
print("ubi_to_gff.py input.ubi detector.par output.gff")
print("########################################################")
print("\n")
list_of_grains = ig.read_grain_file(sys.argv[1])
p = ip.parameters()
p.loadparameters(sys.argv[2])
uc = [
p.parameters['cell__a'], p.parameters['cell__b'], p.parameters['cell__c'],
p.parameters['cell_alpha'], p.parameters['cell_beta'],
p.parameters['cell_gamma']
]
print(uc)
grainno = []
x = []
y = []
z = []
rodx = []
rody = []
rodz = []
def main():
"""
A user interface
"""
import sys, time, os, logging
start = time.time()
root = logging.getLogger('')
root.setLevel(logging.WARNING)
try:
from optparse import OptionParser
parser = OptionParser()
parser = get_options(parser)
options, args = parser.parse_args()
except SystemExit:
raise
except:
parser.print_help()
print("\nProblem with your options:")
raise
if options.output is None:
print("You must supply an output file (-o vol.h5)")
sys.exit()
if os.path.exists(options.output):
print("I would overwrite your output file", options.output)
print("If you really want that then delete it first and re-run")
sys.exit()
try:
if options.pars is None:
print("You must supply a parameter file, -p file.pars")
sys.exit()
pars = parameters.parameters()
pars.loadparameters(options.pars)
print("Got parameters from", options.pars)
pd = pars.get_parameters()
names = list(pd.keys())
names.sort()
for name in names:
print("%30s %s" % (name, pd[name]))
except:
print("Problem with parameters:", options.pars)
raise
try:
if options.ubifile is None:
print("You must supply an input ubifile")
ubi = indexing.readubis(options.ubifile)[0]
print("UBI:\n", ubi)
print("Cell parameters:")
print("%.5f %.5f %.5f %.4f %.4f %.4f" % \
indexing.ubitocellpars(ubi))
except:
print("Problem with ubi file:", options.ubifile)
raise
if options.maskfilename is not None:
from fabio.openimage import openimage
try:
mask = (openimage(options.maskfilename).data == 0)
except:
print("Problem with your mask image", options.maskfilename)
raise
print("Using a mask from", options.maskfilename)
print("percent of image used %.3f" %
(100.0 * mask.sum() / mask.shape[0] / mask.shape[1]))
else:
mask = None
first_image = True
nimage = 0
imagefiles = ImageD11_file_series.get_series_from_options(options, args)
print("Subslicing by", options.subslice)
try:
for fim in imagefiles:
if first_image: # allocate volume, compute k etc
first_image = False
mapper = rsv_mapper(fim.data.shape,
pars,
ubi,
options.spline,
np=options.npixels,
border=options.border,
maxpix=options.maxpix,
mask=mask
# FIXME omegarange
)
logging.info("Setting up time %.4f s" % (time.time() - start))
ltp = time.time()
om = float(fim.header['Omega'])
oms = float(fim.header['OmegaStep'])
for i in range(options.subslice):
print(".", end=' ')
omv = om + i * oms / options.subslice
# ==1 : 0*s/1
# ==2 : 0*s/2 , 1*s/2
# ==3 : 0*s/3 , 1*s/3, 2*s/3 etc
mapper.add_image(omv, fim.data)
nimage = nimage + 1
print(" %d %.3f %.4f s, %.4f s" %
(nimage, om, time.time() - ltp, time.time() - start))
if options.images is not None:
if nimage >= options.images:
break
except KeyboardInterrupt:
print("\nCaught a control-c")
if nimage > 0:
print("Problem, trying to save volume so far to:", options.output)
mapper.writevol(options.output)
print("Saved what I had")
sys.exit()
except:
print("\nAn error occured")
if nimage > 0:
print("Problem, trying to save volume so far to:", options.output)
mapper.writevol(options.output)
print("Saved what I had")
raise
if nimage > 0:
mapper.writevol(options.output)
def readfile(self, filename):
"""
Reads in an ascii columned file
"""
self.titles = []
self.bigarray = None
self.parameters = parameters.parameters(filename=filename)
self.ncols = 0
self.nrows = 0
i = 0
try:
raw = open(filename, "r").readlines()
except:
raise Exception("Cannot open %s for reading" % (filename))
header = True
while header and i < len(raw):
if len(raw[i].lstrip()) == 0:
# skip blank lines
i += 1
continue
if raw[i][0] == "#":
# title line
if raw[i].find("=") > -1:
# key = value line
name, value = clean(raw[i][1:].split("="))
self.parameters.addpar(parameters.par(name, value))
else:
self.titles = raw[i][1:].split()
i += 1
else:
header = False
try:
cc = [numpy.fromstring(v, sep=' ') for v in raw[i:]]
self.bigarray = numpy.array(cc).transpose()
except:
raise Exception("Non numeric data on all lines\n")
(self.ncols, self.nrows) = self.bigarray.shape
# data = []
# try:
# fileobj = open(filename,"r").readlines()
# except:
# raise Exception("Cannot open %s for reading"%(filename))
# for line in fileobj:
# i += 1
# if len(line.lstrip())==0:
# # skip blank lines
# continue
# if line[0] == "#":
# # title line
# if line.find("=") > -1:
# # key = value line
# name, value = clean(line[1:].split("="))
# self.parameters.addpar(
# parameters.par( name, value ) )
# else:
# self.titles = clean(line[1:].split())
# self.ncols = len(self.titles)
# continue
# # Assume a data line
# try:
# vals = [ float(v) for v in line.split() ]
# except:
# raise Exception("Non numeric data on line\n"+line)
# if len(vals) != self.ncols:
# raise Exception("Badly formatted column file\n"\
# "expecting %d columns, got %d\n"\
# " line %d in file %s"%
# (self.ncols, len(vals),
# i, self.filename))
# self.nrows += 1
# data.append(vals)
# self.bigarray = numpy.transpose(numpy.array(data))
# if self.nrows > 0:
# assert self.bigarray.shape == (self.ncols, self.nrows)
self.set_attributes()
##########################################################################
# IMPORT PYTHON PACKAGES
from __future__ import absolute_import
from __future__ import print_function
import numpy as np
import math
from xfab import tools
from ImageD11 import parameters
import os
import argparse
import textwrap
from six.moves import range
##########################################################################
myparms = parameters.parameters()
def readparfile(filename):
myparms.loadparameters(filename)
omat = np.zeros((2,2))
if 'cell__a' in myparms.get_parameters().keys():
a0 = float(myparms.get('cell__a'))
if 'cell__b' in myparms.get_parameters().keys():
b0 = float(myparms.get('cell__b'))
if 'cell__c' in myparms.get_parameters().keys():
c0 = float(myparms.get('cell__c'))
if 'cell_alpha' in myparms.get_parameters().keys():
alpha0 = float(myparms.get('cell_alpha'))
if 'cell_beta' in myparms.get_parameters().keys():
beta0 = float(myparms.get('cell_beta'))
def readprms(self,prms):
from ImageD11 import parameters
o = parameters.parameters()
o.loadparameters(prms)
self.pars=o.get_parameters()
def fitallgrains( gfile, pfile, cfile, ngrains = None):
colfile = loadcolfile( cfile )
grains = read_grain_file( gfile )
pars = read_par_file( pfile )
variables = [ 't_x','t_y', 't_z', 'y_center', 'tilt_y', 'tilt_z',
'tilt_x', 'distance', 'wedge']
pfitted = []
grs = []
cfs = []
if ngrains is None:
ng = len(grains)
else:
ng = ngrains
for i in range(ng):
print "***",i,
gr = grains[i]
cf = assignpeaks( gr, pars, colfile, tol = 0.02 )
cfs.append(cf)
grs.append(gr)
pi = parameters( **pars.parameters )
refpars = fitmanygrains( cfs, grs, pi, variables )
for i in range(3):
refpars = fitmanygrains( cfs, grs, refpars, variables )
if 0:
pi = parameters( **pars.parameters )
pi.set('t_x', gr.translation[0])
pi.set('t_y', gr.translation[1])
pi.set('t_z', gr.translation[2])
diff, Ddiff = fitgrainfunc( cf, gr, pi, variables )
print "%.5g"%((diff*diff).ravel().sum()),
gr, pfit = fitgrain( cf, gr, pi, variables, quiet=True )
grains[i] = gr
pfitted.append( pfit )
diff, Ddiff = fitgrainfunc( cf, gr, pfit, variables )
print "%.5g"%((diff*diff).ravel().sum())
if 0:
v = Ddiff.keys()
for v in ['y_center', 'distance']:
pylab.figure(1)
pylab.title("Versus omega")
pylab.plot( cf.omega, project_diff_on_variable( diff, v, Ddiff) , ",", label=v)
pylab.figure(2)
pylab.title("Versus fc")
pylab.plot( cf.fc, project_diff_on_variable( diff, v, Ddiff) , ",", label=v)
pylab.figure(3)
pylab.title("Versus sc")
pylab.plot( cf.sc, project_diff_on_variable( diff, v, Ddiff) , ",", label=v)
pylab.figure(4)
pylab.title("Versus sigo")
pylab.plot( cf.sigo, project_diff_on_variable( diff, v, Ddiff) , ",", label=v)
pylab.legend()
pylab.show()
raw_input()
write_grain_file( gfile+".fit", grains)
return flat
if __name__ == "__main__":
import sys, numpy as np
from ImageD11.grain import read_grain_file
from ImageD11.columnfile import columnfile
from ImageD11.parameters import parameters
from ImageD11.transform import compute_xyz_lab
colfile = sys.argv[1]
grainfile = sys.argv[2]
parfile = sys.argv[3]
pars = parameters()
pars.loadparameters(parfile)
wedge = np.radians(float(pars.get("wedge")))
chi = np.radians(float(pars.get("chi")))
wvln = float(pars.get("wavelength"))
c = columnfile(colfile)
c.nrows = 2
c.bigarray = c.bigarray[:, :2]
print c.bigarray.shape
c.set_attributes()
XL = flatfloat(compute_xyz_lab([c.sc, c.fc], **pars.parameters).T)
om = flatfloat(np.radians(c.omega))
def ubi_to_gff(ubi,par):
from ImageD11 import grain as ig
from ImageD11 import parameters as ip
from string import split
from xfab import tools
from six.moves import range
list_of_grains = ig.read_grain_file(ubi)
p = ip.parameters()
p.loadparameters(par)
uc = [p.parameters['cell__a'],p.parameters['cell__b'],p.parameters['cell__c'],p.parameters['cell_alpha'],p.parameters['cell_beta'],p.parameters['cell_gamma']]
#print(uc)
grainno = []
x = []
y = []
z = []
rodx = []
rody = []
rodz = []
unitcell_a = []
unitcell_b = []
unitcell_c = []
unitcell_alpha = []
unitcell_beta = []
unitcell_gamma = []
U11 = []
U12 = []
U13 = []
U21 = []
U22 = []
U23 = []
U31 = []
U32 = []
U33 = []
eps11 = []
eps22 = []
eps33 = []
eps23 = []
eps13 = []
eps12 = []
titles = ["grainno","x","y","z","rodx","rody","rodz","U11","U12","U13","U21","U22","U23","U31","U32","U33","unitcell_a","unitcell_b","unitcell_c","unitcell_alpha","unitcell_beta","unitcell_gamma","eps11","eps22","eps33","eps23","eps13","eps12"]
for i in range(len(list_of_grains)):
if hasattr(list_of_grains,'name') == False:
grainno.append(i)
elif hasattr(list_of_grains,'name') == True:
grainno.append(eval(split(list_of_grains[i].name,':')[0]))
x.append(list_of_grains[i].translation[0]/1000.)
y.append(list_of_grains[i].translation[1]/1000.)
z.append(list_of_grains[i].translation[2]/1000.)
ubi = list_of_grains[i].ubi
(U,eps) = tools.ubi_to_u_and_eps(ubi,uc)
uc_a, uc_b, uc_c, uc_alpha, uc_beta, uc_gamma = tools.ubi_to_cell(ubi)
unitcell_a.append(uc_a)
unitcell_b.append(uc_b)
unitcell_c.append(uc_c)
unitcell_alpha.append(uc_alpha)
unitcell_beta.append(uc_beta)
unitcell_gamma.append(uc_gamma)
rod = tools.u_to_rod(U)
rodx.append(rod[0])
rody.append(rod[1])
rodz.append(rod[2])
U11.append(U[0,0])
U12.append(U[0,1])
U13.append(U[0,2])
U21.append(U[1,0])
U22.append(U[1,1])
U23.append(U[1,2])
U31.append(U[2,0])
U32.append(U[2,1])
U33.append(U[2,2])
eps11.append(eps[0])
eps12.append(eps[1])
eps13.append(eps[2])
eps22.append(eps[3])
eps23.append(eps[4])
eps33.append(eps[5])
gff = cl.newcolumnfile(titles)
gff.ncols = len(titles)
gff.nrows = len(grainno)
gff.bigarray = np.zeros((gff.ncols,gff.nrows))
gff.set_attributes()
gff.addcolumn(grainno,"grainno")
gff.addcolumn(x,"x")
gff.addcolumn(y,"y")
gff.addcolumn(z,"z")
gff.addcolumn(rodx,"rodx")
gff.addcolumn(rody,"rody")
gff.addcolumn(rodz,"rodz")
gff.addcolumn(U11,"U11")
gff.addcolumn(U12,"U12")
gff.addcolumn(U13,"U13")
gff.addcolumn(U21,"U21")
gff.addcolumn(U22,"U22")
gff.addcolumn(U23,"U23")
gff.addcolumn(U31,"U31")
gff.addcolumn(U32,"U32")
gff.addcolumn(U33,"U33")
gff.addcolumn(unitcell_a,"unitcell_a")
gff.addcolumn(unitcell_b,"unitcell_b")
gff.addcolumn(unitcell_c,"unitcell_c")
gff.addcolumn(unitcell_alpha,"unitcell_alpha")
gff.addcolumn(unitcell_beta,"unitcell_beta")
gff.addcolumn(unitcell_gamma,"unitcell_gamma")
gff.addcolumn(eps11,"eps11")
gff.addcolumn(eps22,"eps22")
gff.addcolumn(eps33,"eps33")
gff.addcolumn(eps23,"eps23")
gff.addcolumn(eps13,"eps13")
gff.addcolumn(eps12,"eps12")
return gff, uc
def __init__(self,
unitcell=None,
ubis=None,
crystal_symmetry=None,
c11=None,c12=None,c13=None,c14=None,c15=None,c16=None,
c22=None,c23=None,c24=None,c25=None,c26=None,
c33=None,c34=None,c35=None,c36=None,
c44=None,c45=None,c46=None,
c55=None,c56=None,
c66=None):
"""
unitcell would be a list of six elements [a, b, c, alpha, beta, gamma]
ubis would be a list of orientation matrices as by ImageD11 convention
symmetry would be isotropic, cubic, tetragonal_high... (see FitAllB.conversion) to form the stiffness tensor C
The rest of the arguments are parameters.
"""
self.cell__a = None
self.cell__b = None
self.cell__c = None
self.cell_alpha = None
self.cell_beta = None
self.cell_gamma = None
if unitcell is not None:
if len(unitcell)==6:
self.cell__a = unitcell[0]
self.cell__b = unitcell[1]
self.cell__c = unitcell[2]
self.cell_alpha = unitcell[3]
self.cell_beta = unitcell[4]
self.cell_gamma = unitcell[5]
else:
raise Exception("The unit cell must be defined by six parameters!")
self.ubis=ubis
self.crystal_symmetry=crystal_symmetry
self.c11=c11
self.c12=c12
self.c13=c13
self.c14=c14
self.c15=c15
self.c16=c16
self.c22=c22
self.c23=c23
self.c24=c24
self.c25=c25
self.c26=c26
self.c33=c33
self.c34=c34
self.c35=c35
self.c36=c36
self.c44=c44
self.c45=c45
self.c46=c46
self.c55=c55
self.c56=c56
self.c66=c66
self.parameterobj = parameters(cell__a=self.cell__a,
cell__b=self.cell__b,
cell__c=self.cell__c,
cell_alpha=self.cell_alpha,
cell_beta=self.cell_beta,
cell_gamma=self.cell_gamma,
crystal_symmetry=self.crystal_symmetry,
c11=self.c11,c12=self.c12,c13=self.c13,c14=self.c14,c15=self.c15,c16=self.c16,
c22=self.c22,c23=self.c23,c24=self.c24,c25=self.c25,c26=self.c26,
c33=self.c33,c34=self.c34,c35=self.c35,c36=self.c36,
c44=self.c44,c45=self.c45,c46=self.c46,
c55=self.c55,c56=self.c56,
c66=self.c66)
self.epsilon=[]
self.sigma=[]
