Functions - Alphabetical List
A
AbelPoissonKernel |
the Abel Poisson kernel |
abs (S2FunHarmonic) |
absolute value of a function Syntax sF = abs(sF) sF = abs(sF, 'bandwidth', bandwidth) |
abs (S2FunTri) |
ABS Absolute value. ABS(X) is the absolute value of the elements of X. When X is complex, ABS(X) is the complex modulus
(magnitude) of the elements of X.
|
abs (vector3d) |
length of vector |
accumarray (vector3d) |
accumarray for vector3d |
acos (S2FunHarmonic) |
cost of a function Syntax sF = acos(sF) sF = acos(sF, 'bandwidth', bandwidth) |
add (crystalSymmetry) |
add additional symmetry operations to a crystal symmetry |
adjustFigurePosition (mtexFigure) |
determine optimal size |
affinetrans (EBSD) |
perform an affine transformation on spatial ebsd data |
alignment (symmetry) |
return alignment of the reference frame as string, e.g. x||a, y||b* |
allPairs |
all pairs of elements of x and y modulo permutation |
allTriple |
all triple of elements of x and y modulo permutation |
angle (S2AxisFieldTri) |
Syntax sVF = angle(sVF,sVF2) sVF = angle(sVF,v) |
angle (S2VectorFieldTri) |
Syntax sVF = angle(sVF,sVF2) sVF = angle(sVF,v) |
angle (fibre) |
angle fibre to orientation or fibre to fibre |
angle (orientation) |
calculates rotational angle between orientations |
angle (quaternion) |
calcualtes the rotational angle between rotations q1 and q2 |
angle (vector3d) |
angle between two vectors |
angle_outer (quaternion) |
calcualtes the rotational angle between all rotations q1 and q2 |
angle_outer (vector3d) |
angle between two vectors Input v1, v2 - @vector3d |
angularVelocityVector (velocityGradientTensor) |
angular velocity vector omega |
annotate |
annotate to a existing figure |
antiSym (tensor) |
the antisymmetric part A = 0.5(T - T.') of a tensor |
apply_recursivly |
apply cmd recursively to all file in a directory |
approximation (S2AxisFieldHarmonic) |
Syntax sAF = S2AxisField.quadrature(v, value) sAF = S2AxisField.quadrature(v, value, 'bandwidth', bw) |
approximation (S2FunHarmonic) |
computes a least square problem to get an approximation Syntax sF = S2FunHarmonic.approximation(S2Grid, f) sF = S2FunHarmonic.approximation(S2Grid,
f, 'bandwidth', bandwidth, 'tol', TOL, 'maxit', MAXIT, 'weights', W)
|
approximation (S2VectorFieldHarmonic) |
Syntax sVF = S2VectorField.quadrature(v, value) sVF = S2VectorField.quadrature(v, value, 'bandwidth', bw) |
ar2rgb |
compute rgb values from angle and radius |
area (grain2d) |
calculates the area of a list of grains |
argin_check |
check ar to be of class classes |
arrow3d (vector3d) |
plot three dimensional arrows |
aspectRatio (grain2d) |
aspectratio = length / width |
assert_grid |
check for valid grid parameters |
assertExt |
assertExt is a function. assertExt(fname, extList) |
axesDual (crystalSymmetry) |
return dual coordinate axes |
axis (orientation) |
rotational axis of an misorientation or two orientations |
axis (quaternion) |
rotational axis of the quaternion |
axis2quat |
rotational axis, roational angle to Quaternion |
axis2quat_outer |
rotational axis, roational angle to Quaternion |
axisAngleColorKey |
|
axisAnglePlot |
create a 3d Euler angle plot |
axisAngleSections |
defines an axis angle section |
axisRatios (strainTensor) |
logarithmic axis ratios of the finite strain ellipsoid |
axisRatios (velocityGradientTensor) |
logarithmic axis ratios of the finite strain ellipsoid |
axisSector (orientationRegion) |
computes the sector of rotational axes for orientations within region |
Back to Top
B
bandwidth (ODF) |
bandwidth of the ODF |
basicHKL (crystalSymmetry) |
plot symmetry |
BCV (orientation) |
biased cross validation |
bingham_test (orientation) |
bingham test for spherical/prolat/oblat case |
BinghamComponent (BinghamComponent) |
BinghamComponent is a class. component = BinghamComponent(kappa, A) |
BinghamODF |
defines a Bingham distributed ODF |
BinghamS2 (BinghamS2) |
Input Z - smoothing parameters; Z(1)>=Z(2)>=Z(3), Z(3)<0 Z(1)=Z(2) rotationally symmetric unimodal distribution Z(1)<<Z(2)
partial girdle distribution
|
binghamS2_demo |
BinghamS2: spherical Bingham distribution function |
binsearch |
binaer search for zero in a motonously increasing function |
birefringence (refractiveIndexTensor) |
birefringence from refractive index tensor |
black2whiteColorMap |
Linear white to black gray-scale color map |
blue2redColorMap |
creates a colormap, ranging from dark blue via white to dark red. |
boundary (sphericalRegion) |
compute boundary points |
boundarySize (grain2d) |
number of boundary segment |
bucketSearch |
n-d search of the closest vertex out of a set of vertices V |
bumpKernel |
the bump kernel Detailed explanation goes here |
BungeColorKey |
assigns rgb values to orientations according the the Euler angles |
BungePlot |
create a 3d Euler angle plot |
byAxisAngle (orientation) |
define orientations by rotational axis and rotational angle |
byAxisAngle (rotation) |
define rotations by rotational axis and rotational angle |
byEuler (orientation) |
define orientations by Euler angles |
byEuler (rotation) |
define rotentations by Euler angles |
byMatrix (orientation) |
define orientations by a matrix |
byMatrix (rotation) |
define rotations by matrices |
byMiller (orientation) |
define orientations by Miller Bravais indeces |
byVertices (sphericalRegion) |
define a spherical region by its vertices |
Back to Top
C
c_hat |
return the second moments for bingham test |
calc_background |
background of spectra |
calc_flags |
check for optional flag |
calcAngleDistribution (ODF) |
compute the angle distribution of an ODF or an MDF |
calcAngleDistribution (orientation) |
calculate angle distribution |
calcAngleDistribution (orientationRegion) |
compute the angle distribution of a uniform ODF for a crystal symmetry |
calcAngleDistribution (symmetry) |
compute the angle distribution of a uniform ODF for a crystal symmetry |
calcAxisDistribution (ODF) |
compute the axis distribution of an ODF or MDF |
calcAxisDistribution (orientationRegion) |
compute the axis distribution of an uniform ODF or MDF |
calcAxisDistribution (symmetry) |
compute the axis distribution of an uniform ODF or MDF |
calcAxisVolume (ODF) |
amount of orientations with a specific misorientation axis |
calcBario (DelaunaySO3) |
compute bariocentric coordinates for an orientation |
calcBario (S2Triangulation) |
S2Triangulation/calcBario is a function. [bario, tId] = calcBario(sT, v, tId) |
calcBinghamODF (orientation) |
calculate ODF from individuel orientations via kernel density estimation |
calcCluster (orientation) |
sort orientations into clusters |
calcComponents (ODF) |
heuristic to find modal orientations |
calcDelaunay (vector3d) |
compute the Delaynay triangulation for a spherical grid |
calcDensity (Miller) |
calculate a density function out of (weighted) crystal directions |
calcDensity (vector3d) |
calculate a density function out of (weighted) unit vectors |
calcError (ODF) |
calculate approximation error between two ODFs |
calcError (PoleFigure) |
RP and mean square error |
calcErrorPF (PoleFigure) |
error polefigure between meassured and recalculated pole figures |
calcFEMODF (PoleFigure) |
PDF to ODF inversion |
calcFourier (BinghamComponent) |
called by ODF/calcFourier |
calcFourier (FourierComponent) |
called by ODF/calcFourier |
calcFourier (ODF) |
compute Fourier coefficients of odf |
calcFourier (femComponent) |
called by ODF/calcFourier |
calcFourier (fibreComponent) |
called by ODF/calcFourier |
calcFourier (uniformComponent) |
called by ODF/calcFourier |
calcFourier (unimodalComponent) |
called by ODF/calcFourier |
calcFourierODF (orientation) |
calculate ODF from individuel orientations via kernel density estimation |
calcGND (EBSDhex) |
compute the geometrically necessary dislocation |
calcGND (EBSDsquare) |
compute the geometrically necessary dislocation |
calcGrains (EBSD) |
grains reconstruction from 2d EBSD data |
calcInvTaylor (orientation) |
Taylor factor from orientation gradient |
calcKearnsFactor |
Syntax |
calcKernel (orientation) |
compute an optimal kernel function for ODF estimation |
calcKernelODF (orientation) |
calculate ODF from individuel orientations via kernel density estimation |
calcMDF (FourierComponent) |
calculate the uncorrelated misorientation distribution function (MDF) from one or two ODF |
calcMDF (ODF) |
calculate the uncorrelated misorientation distribution function (MDF) from one or two ODF |
calcMDF (unimodalComponent) |
calculate the uncorrelated misorientation distribution function (MDF) from one or two ODF |
calcMDF (orientation) |
computes an MDF from individuel orientations or misorientations |
calcMeanDirection (grainBoundary) |
compute a smoothed direction that ignores staircasing |
calcMIndex (ODF) |
M-index of Skemer et al.(2005) based on the difference between uncorrelated and uniform misorientation angle distributions |
calcMIndex (orientation) |
TODO!!! |
calcMisorientation (EBSD) |
calculate uncorrelated misorientations between two ebsd phases |
calcModes (BinghamComponent) |
return the modes of the component |
calcModes (ODF) |
heuristic to find modal orientations |
calcModes (ODFComponent) |
return the modes of the component |
calcModes (fibreComponent) |
return the modes of the component |
calcModes (unimodalComponent) |
return the modes of the component |
calcNormalization (PoleFigure) |
normalization of a meassured pole figure with respect to a second pole figure |
calcODF (MLSSolver) |
apply zero range method |
calcODF (PoleFigure) |
PDF to ODF inversion |
calcODF (orientation) |
computes an ODF from individuel orientations |
calcOrientations (ODF) |
draw random orientations from ODF |
calcPDF (BinghamComponent) |
called by pdf |
calcPDF (FourierComponent) |
calculate pole figure from Fourier coefficients |
calcPDF (ODF) |
calcPDF computed the PDF corresponding to an ODF |
calcPDF (femComponent) |
called by pdf |
calcPDF (fibreComponent) |
calculate pdf for fibre component |
calcPDF (uniformComponent) |
calculate pdf |
calcPDF (unimodalComponent) |
compute the pole density function for a given unimodal component |
calcpdf_special3 (ODF) |
compute the pdf for h = (theta,rhoh), r = (theta,rhor) |
calcPoleFigure (ODF) |
simulate pole figures from an ODF |
calcPoleFigure (PoleFigure) |
simulate pole figure |
calcQuadratureWeights (vector3d) |
compute the area of the Voronoi decomposition |
calcQuat (symmetry) |
calculate quaternions for Laue groups |
calcShearStress (stressTensor) |
shear stress |
calcTaylor (strainTensor) |
compute Taylor factor and strain dependent orientation gradient |
calcTaylor (velocityGradientTensor) |
compute Taylor factor and strain dependent orientation gradient |
calcTensor (EBSD) |
compute the average tensor for an EBSD data set |
calcTensor (FourierComponent) |
compute the average tensor for an ODF |
calcTensor (ODF) |
compute the average tensor for an ODF |
calcTensor (ODFComponent) |
compute the average tensor for an ODF |
calcTensor (orientation) |
compute the average tensor for a vector of orientations |
calcTriplePoints (grainBoundary) |
compute triple points |
calcUnitCell |
compute the unit cell for an EBSD data set |
calcVoronoi (quaternion) |
compute the the Voronoi decomposition for unit quaternions |
calcVoronoi (vector3d) |
compute the area of the Voronoi decomposition |
calcVoronoiArea (vector3d) |
compute the spherical area of the Voronoi decomposition |
calcZeroRange (zeroRangeMethod) |
calculate zero range |
calliper (grain2d) |
Calliper (Feret diameter) of a grain in measurement units, the projection length normal to it and its direction/trend. |
cat (S2FunHarmonic) |
overloads cat |
cat (EBSD) |
overloads [ebsd1,ebsd2,ebsd3..] |
cat (grain2d) |
implements [grain1, grain2] |
cat (PoleFigure) |
implement cat for PoleFigure |
cat (Miller) |
concatenate lists of Miller indices to one list |
cat (S2Grid) |
implements cat for S2Grid |
cat (dislocationSystem) |
implement cat for dislocationSystem |
cat (fibre) |
implement cat for fibre |
cat (quaternion) |
implement cat for quaternion |
cat (rotation) |
implement cat for rotation |
cat (slipSystem) |
implement cat for slipSystem |
cat (vector3d) |
implement cat for vector3d |
CauchyStrain (deformationGradientTensor) |
Cauchy strain or small strain |
cell2file |
write cellstring to file |
centerSpecimen (ODF) |
rotatates an odf with specimen symmetry into its symmetry axes |
centroid (grain2d) |
calculates the barycenters of the grain boundary |
centroid (vector3d) |
compute the centroid of a 2d polygon in 3d |
char (EBSD) |
ebsd -> char |
char (ODF) |
odf -> char |
char (uniformComponent) |
standard output |
char (unimodalComponent) |
called by standard output |
char (PoleFigure) |
standard output |
char (tensor) |
tensor to char |
char (Miller) |
Miller indece to string |
char (SO3Grid) |
convert to char |
char (crystalSymmetry) |
object -> string |
char (quaternion) |
quaternion to char |
char (rotation) |
quaternion to char |
char (specimenSymmetry) |
object -> string |
char (sphericalRegion) |
convert spherical region to char |
char (vector3d) |
convert to char |
ChebCoeff (FourierComponent) |
return Chebyshev coefficient of odf |
check (DelaunaySO3) |
ignore this |
check (symmetry) |
check symmetry |
check_installation |
check whether all binaries are working properly |
check_interfaces |
determine interface from file |
check_option |
check for option in option list |
checkEulerAngleConvention |
checkEulerAngleConvention is a function. r = checkEulerAngleConvention(conv1, conv2) |
checkInside (grain2d) |
check for points or grains to be inside a big grain |
checkInside (S2Triangulation) |
S2Triangulation/checkInside is a function. [isInside, tId, bario] = checkInside(sT, v, tId) |
checkInside (orientationRegion) |
check for points to be inside the orientation region |
checkInside (sphericalRegion) |
check for points to be inside the spherical region |
checkOption |
check for option in option list |
checkSymmetry (tensor) |
tensor/checkSymmetry is a function. out = checkSymmetry(T) |
checkZeroRange (zeroRangeMethod) |
check for zero regions in experiementl pole figures |
ChristoffelTensor (ChristoffelTensor) |
ChristoffelTensor is a class. sT = ChristoffelTensor(varargin) |
ChristoffelTensor (complianceTensor) |
Christoffel tensor of an elasticity tensor for a given direction |
ChristoffelTensor (stiffnessTensor) |
Christoffel tensor of an elasticity tensor for a given direction |
circle (vector3d) |
annotated a circle |
cleanUp (orientationRegion) |
testing: cs = crystalSymmetry('222'); oR = cs.fundamentalRegion; |
cleanUp (sphericalRegion) |
sphericalRegion/cleanUp is a function. sR = cleanUp(sR) |
ClebschGordan |
ClebschGordan.m by David Terr, Raytheon, 6-17-04 Modified on 11-9-04 |
ClebschGordanTensor |
A = [[1 1 -1];[1 1 1];[-1 1 1]]; |
CLim (mtexFigure) |
set color range for figures |
closeAllButCurrentFiles |
close all open files exept for the current one |
clusterBreaker |
Recursively assigns points based on neighboring assignments If flag == 0, the point is fresh, 1, the point is set >1, the
point belongs to a cluster that may have run into the recusion limit
|
cmeans |
m - fuzzifier |
coarser (S1Grid) |
makes S1Grid more coarse |
colon (tensor) |
double dot A:B between two tensors |
colorbar (mtexFigure) |
COLORBAR Display color bar (color scale) COLORBAR appends a colorbar to the current axes in the default (right) location |
complianceTensor (complianceTensor) |
complianceTensor is a class. sT = complianceTensor(varargin) |
compressionDirection (velocityGradientTensor) |
compression direction |
concentration (ODF) |
not yet implemeted |
conformalPlot |
create a 3d Euler angle plot |
conj (S2FunHarmonic) |
conjugate S2FunHarmonic |
conj (tensor) |
conjugate of a tensor |
connectedComponents |
label connected componentes in an graph (adjacency matrix) |
contour (S2Fun) |
spherical contour plot |
contour (vector3d) |
spherical contour plot |
contour3s |
contour-slices |
contourf (S2Fun) |
spherical filled contour plot |
contourf (vector3d) |
spherical filled contour plot |
conv (S2FunHarmonic) |
spherical convolution of sF with a radial function psi |
conv (FourierComponent) |
convolute ODF with kernel psi |
conv (ODF) |
convolute ODF with kernel psi |
convertFigureRGB2ind |
default resolution |
coolColorMap |
COOL Shades of cyan and magenta color map COOL(M) returns an M-by-3 matrix containing a "cool" colormap. COOL, by itself,
is the same length as the current figure's colormap. If no figure exists, MATLAB creates one.
|
copy (S2Grid) |
copy certain condition from grid |
copy (SO3Grid) |
copy nodes by indece |
correct (PoleFigure) |
corrects polfigures for background and defocussing |
cos (S2FunHarmonic) |
cost of a function Syntax sF = cos(sF) sF = cos(sF, 'bandwidth', bandwidth) |
cprintf |
CPRINTF convert an array of any data type to a 2D character array |
cprproject_read |
cprproject_read is a function. phases = cprproject_read(fname) |
cross (S2AxisFieldHarmonic) |
syntax f = cross(sAF,v) f = cross(sAF1,sAF2) f = cross(sAF,sVF) |
cross (S2AxisFieldTri) |
Syntax sVF = cross(sVF1,sVF2) sVF = cross(sVF1,v) |
cross (S2VectorFieldHarmonic) |
pointwise cross product |
cross (S2VectorFieldTri) |
Syntax sVF = cross(sVF1,sVF2) sVF = cross(sVF1,v) |
cross (quaternion) |
pointwise cross product of three quaternions |
cross (vector3d) |
pointwise cross product of two vector3d |
cross_outer (vector3d) |
pointwise cross product of two vector3d |
crossCorrelation (orientation) |
computes the cross correlation for the kernel density estimator |
crystalShape (crystalShape) |
a class representing crystal shapes. |
crystalSymmetry (crystalSymmetry) |
constructor |
CSL |
coincidence site lattice misorientations for cubic symmetry |
ctranspose (S2FunHarmonic) |
ctransposes S2FunHarmonic |
ctranspose (tensor) |
conjugate of a tensor |
ctranspose (orientation) |
inverse orientation |
ctranspose (quaternion) |
transpose quaternion |
ctranspose (vector3d) |
transpose vector |
cubochoricGrid (cubochoricGrid) |
Syntax S3G = cubochoricGrid(ori,alphabeta,gamma) |
cunion |
disjoint union |
curvature (EBSDhex) |
computes the incomplete curvature tensor |
curvature (EBSDsquare) |
computes the incomplete curvature tensor |
curvature (dislocationDensityTensor) |
compute curvature tensor from a (complete) dislocation density tensor |
curvatureTensor (curvatureTensor) |
curvatureTensor is a class. kappa = curvatureTensor(varargin) |
customKernel |
defines a kernel function as a function of the rotational angle |
cut2unitI |
cut2unitI is a function. x = cut2unitI(x) |
Back to Top
D
deformationGradientTensor (deformationGradientTensor) |
deformationGradientTensor is a class. F = deformationGradientTensor(varargin) |
deformationTensor (slipSystem) |
deformation tensor |
deg2dim |
dimension of the harmonic space up to order l |
degree |
x * degree = x in standard arc measure |
DelaunaySO3 (DelaunaySO3) |
Syntax |
deLaValeePoussinKernel |
DELAVALEEPOUSSINKERNEL Summary of this class goes here Detailed explanation goes here |
delete (S1Grid) |
delte points from S1Grid |
delete (S2Grid) |
elilinates points from grid |
delete (SO3Grid) |
clear nodes by indece Input SOG - @SO3Grid indece - int32 |
delete_option |
clear options in option list |
det (tensor) |
compute the determinants of rank 2 tensors |
det (vector3d) |
pointwise determinant or triple product of three vector3d |
det3 |
determinant of a list of 3x3 matrices |
deviatoricStrain (strainTensor) |
deviatoric strain tensor |
deviatoricStress (stressTensor) |
deviatoric stress |
diag (tensor) |
convert rank 1 or rank 0 tensor into diagonal rank 2 tensor |
diameter (grain2d) |
diameter of a grain in measurement units longest distance between any two vertices of the grain boundary |
dim2deg |
dimension to harmonic degree of Wiegner D functions |
directionalMagnitude (tensor) |
magnitude of a tensor in direction v |
directionColorKey |
converts directions to rgb values |
DirichletKernel |
the Dirichlet kernel in the orientation space |
discreteSample (S2Fun) |
takes a random sample of n directions from S2Fun |
discreteSample (ODF) |
draw a random sample |
discreteSample (ODFComponent) |
draw a random sample |
discreteSample (femComponent) |
draw a random sample |
discreteSample (fibreComponent) |
evaluate an odf at orientation g |
discreteSample (uniformComponent) |
draw a random sample |
discreteSample (unimodalComponent) |
draw a random sample |
discreteSample |
take a diskrete sample from a list of vectors, orientations, grains, EBSD |
disjoint (symmetry) |
returns the disjoint of two symmetry groups |
dislocationDensity (curvatureTensor) |
compute the dislocationDensity tensor from a curvature tensor |
dislocationDensityTensor (dislocationDensityTensor) |
dislocation density or Nye tensor |
dislocationSystem (dislocationSystem) |
class representing dislocation systems |
display (S2AxisFieldHarmonic) |
standard output |
display (S2FunHarmonic) |
standard output |
display (S2FunHarmonicSym) |
standard output |
display (S2FunTri) |
standard output |
display (S2VectorFieldHarmonic) |
standard output |
display (S2VectorFieldTri) |
standard output |
display (EBSD) |
standard output |
display (grain2d) |
standard output |
display (grainBoundary) |
standard output |
display (triplePointList) |
standard output |
display (BinghamComponent) |
standard output |
display (FourierComponent) |
called by standard output |
display (ODF) |
standard output |
display (femComponent) |
called by standard output |
display (fibreComponent) |
called by standard output |
display (uniformComponent) |
standard output |
display (unimodalComponent) |
called by standard output |
display (PoleFigure) |
standard output |
display (tensor) |
standard output |
display (DelaunaySO3) |
standard output |
display (Miller) |
standard output |
display (S1Grid) |
standart output |
display (S2Grid) |
standard output |
display (SO3Grid) |
standard output |
display (crystalShape) |
standard output |
display (crystalSymmetry) |
standard output |
display (fibre) |
standard output |
display (orientation) |
standart output |
display (orientationRegion) |
standard output |
display (quaternion) |
standart output |
display (rotation) |
standart output |
display (sphericalRegion) |
standard output |
display (vector3d) |
standard output |
displayClass |
displayClass is a function. displayClass(obj, input) |
dispLine (crystalSymmetry) |
display symmetry as a one-liner |
dispLine (specimenSymmetry) |
display symmetry as a one-liner |
dist (S1Grid) |
distance to all points of S1Grid |
dist_outer (S1Grid) |
distance to all points of S1Grid |
doclink |
doclink is a function. linkText = doclink(fname, lname) |
docmethods |
display all methods for a certain class |
docopt |
DOCOPT Web browser for UNIX platforms. DOCOPT is an M-file that you or your system manager can edit to specify the Web browser
to use with MATLAB. It is used for the WEB function with the -BROWSER option. It is also used for links to external Web sites
from the the Help browser and from Web menu items. DOCOPT applies only to non-Macintosh UNIX platforms.
|
doHClustering (orientation) |
sort orientations into clusters |
doIter (MLSSolver) |
perform one iteration step of the modified least squares algorithm |
dot (S2AxisFieldHarmonic) |
syntax f = dot(sAF,v) f = dot(sAF1,sAF2) f = dot(sAF,sVF) |
dot (S2AxisFieldTri) |
Syntax sVF = dot(sVF,sVF2) sVF = dot(sVF,v) |
dot (S2FunHarmonic) |
inner product |
dot (S2VectorFieldHarmonic) |
pointwise inner product |
dot (S2VectorFieldTri) |
Syntax sVF = dot(sVF,sVF2) sVF = dot(sVF,v) |
dot (Miller) |
inner product between two Miller indece |
dot (orientation) |
compute minimum dot(o1,o2) modulo symmetry |
dot (quaternion) |
inner product of quaternions g1 and g2 |
dot (rotation) |
compute rot1 . rot2 |
dot (vector3d) |
pointwise inner product |
dot_angle (quaternion) |
compute minimum q1 . q2 modulo rotation about zaxis and angle omega |
dot_outer (Miller) |
inner product between two Miller indece |
dot_outer (SO3Grid) |
return outer inner product of all nodes within a eps neighborhood |
dot_outer (orientation) |
dot_outer |
dot_outer (quaternion) |
outer inner product between two quaternions |
dot_outer (rotation) |
dot_outer |
dot_outer (vector3d) |
outer dot product |
double (tensor) |
convert tensor values to matrix |
double (S1Grid) |
convert to double |
double (quaternion) |
quaternion to double |
double (vector3d) |
converts vector3d to double Input v - @vector3d Output x, y, z - double |
doZeroRange (MLSSolver) |
MLSSolver/doZeroRange is a function. doZeroRange(solver, varargin) |
drawNow (mtexFigure) |
mtexFigure/drawNow is a function. drawNow(mtexFig, varargin) |
dspacing (Miller) |
space between crystal planes |
DubnaGrid |
construct specimen grid of the Dubna goniometer |
DubnaPoleFigure |
construct pole figure using Dubna struct file |
dyad |
dyadic tensor product |
dyad (vector3d) |
dyadic tensor product |
dynOption |
class to add dynamic options to a static class Detailed explanation goes here |
dynProp |
class to add dynamic properties to a static class Detailed explanation goes here |
Back to Top
E
eangleProjection |
stereographic, conformal or equal angle projection |
eareaProjection |
equal area projection |
EBSD (EBSD) |
constructor |
EBSDhex (EBSDhex) |
EBSD data on a hexagonal grid. In contrast to arbitrary EBSD data the values are stored in a matrix. |
EBSDsquare (EBSDsquare) |
EBSD data on a rectangular grid. In contrast to arbitrary EBSD data the values are stored in a matrix. |
edistProjection |
equal distant projection |
efopen |
file open with error message |
eig (S2FunHarmonic) |
eigen value of a spherical function |
eig (tensor) |
compute the eigenvalues and eigenvectors of a tensor |
eig2 |
eigenvalue and vectors of a symmetric 2x2 matrix |
eig3 |
eigenvalue and vectors of a symmetric 3x3 matrix |
EinsteinSum |
tensor multiplication according to Einstein summation convention |
EinsteinSum (quaternion) |
tensor multiplication according to Einstein summation |
elements (symmetry) |
extract symmetry elements by multiplicity |
ellipse |
annotate an ellipse in a spherical plot |
ellipsoid (strainTensor) |
Length (1+e) and direction of principal axes of strain ellipsoid from finite, lagrangian/eulerian strain tensor E with eigenvalues
lambda with (1+e) = sqrt(1+2*lambda) for a Lagranage strain tensor (default) (1+e) = sqrt(1-2*lambda) for a Euler strain tensor
Syntax [fe,qe] = ellipsoid(E)
|
end (S2FunHarmonic) |
overloaded end function |
end (tensor) |
overloaded end function |
end (dislocationSystem) |
overloaded end function |
end (fibre) |
overloaded end function |
end (quaternion) |
overloads end function |
end (slipSystem) |
overloaded end function |
end (vector3d) |
overloaded end function |
energyVector (stiffnessTensor) |
Calculates Energy velocity vector (km/s) |
ensurecell |
ensures that v is a cell with size s |
ensureCS (symmetry) |
ensures that an obj has the right crystal symmetry |
ensureNonNeg |
remove small negative values |
entropy (S2FunHarmonic) |
entropy of a function |
entropy (ODF) |
caclulate entropy of ODF |
eq (grain2d) |
== Equal. A == B does element by element comparisons between A and B and returns an array with elements set to logical 1
(TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes.
In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension,
the dimension sizes of the inputs are either the same or one of them is 1.
|
eq (tensor) |
checks whether two tensors are equal |
eq (S1Grid) |
implements G1 == G2 |
eq (crystalSymmetry) |
check S1 == S2 |
eq (dislocationSystem) |
? sS1 == sS2 |
eq (fibre) |
? sS1 == sS2 |
eq (orientationRegion) |
== Equal. A == B does element by element comparisons between A and B and returns an array with elements set to logical 1
(TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes.
In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension,
the dimension sizes of the inputs are either the same or one of them is 1.
|
eq (quaternion) |
? q1 == q2 |
eq (slipSystem) |
? sS1 == sS2 |
eq (sphericalRegion) |
== Equal. A == B does element by element comparisons between A and B and returns an array with elements set to logical 1
(TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes.
In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension,
the dimension sizes of the inputs are either the same or one of them is 1.
|
eq (symmetry) |
check S1 == S2 |
eq (vector3d) |
? v1 == v2 |
equal |
check all elements of A to be equal |
equispacedS2Grid |
defines an equispaced spherical grid |
equispacedSO3Grid |
defines a equispaced grid in the orientation space |
equivalentPerimeter (grain2d) |
returns the equivalent perimeter of grain-polygon |
equivalentRadius (grain2d) |
returns the equivalent radius of grain-polygon |
equivalentStrain (strainTensor) |
von Mises equivalent strain |
equivalentStrain (velocityGradientTensor) |
equivalent strain of a strain tensor |
equivalentStress (stressTensor) |
von Mises equivalent stress |
Euler (quaternion) |
quaternion to euler angle |
euler2quat |
converts euler angle to quaternion |
EulerAngleConvention |
EulerAngleConvention is a function. [convention, labels] = EulerAngleConvention(varargin) |
EulerCycles |
retrieve Euler cycles from an not oriented edge list |
EulerTours |
find Euler tours in an adjacency matrix |
eval (S2AxisFieldHarmonic) |
syntax f = eval(sF,v) |
eval (S2AxisFieldTri) |
Syntax v = eval(sFV,nodes) |
eval (S2FunHarmonic) |
evaluates the spherical harmonic on a given set of points Syntax f = eval(sF,v) |
eval (S2FunTri) |
syntax f = eval(sF,v) |
eval (S2VectorFieldHarmonic) |
syntax f = eval(sVF,v) |
eval (S2VectorFieldTri) |
Syntax v = eval(sFV,nodes) |
eval (BinghamComponent) |
evaluate an odf at orientation g |
eval (FourierComponent) |
evaluate odf using NSOFT |
eval (ODF) |
evaluate an odf at orientation g |
eval (femComponent) |
evaluate an odf at orientation ori |
eval (fibreComponent) |
evaluate an odf at orientation g |
eval (uniformComponent) |
evaluate an odf at orientation g |
eval (unimodalComponent) |
evaluate sum of unimodal components at orientation g |
evalkappa |
eigenvalues of orientation tensor to bingham distribution parameters |
even (S2FunHarmonic) |
even or antipodal part of a spherical function |
exp (Miller) |
misorientation vector to misorientation |
exp (orientation) |
exponential function |
exp (vector3d) |
rotation vector to rotation |
expm (tensor) |
matrix exponential of a tensor |
expm (velocityGradientTensor) |
deformation gradient tensor from velocity gradient tensor |
export (EBSD) |
export EBSD data to a ascii file |
export (ODF) |
export an ODF to an ASCII file |
export (PoleFigure) |
export pole figure in an ASCII file |
export (quaternion) |
export quaternions to a ascii file |
export (vector3d) |
export quaternions to a ascii file |
export_generic (ODF) |
export an ODF to an ASCII file |
export_h5 (EBSD) |
export EBSD data to a ascii file |
export_mtex (ODF) |
export an ODF into the MTEX format |
export_VPSC (ODF) |
export an ODF to the VPSC format |
export_VPSC (orientation) |
export individual orientations to the VPSC format |
expquat |
matrix exponential to convert skew symmetric matrices into quaternions |
extend (EBSD) |
returns the boundings of spatial EBSD data |
extensionDirection (velocityGradientTensor) |
extension direction |
extract_argoption |
extract options from option list |
extract_data |
extract data |
extract_option |
extract options from option list |
extract_SO3grid |
extract_SO3grid is a function. [S3G, options] = extract_SO3grid(obj, varargin) |
extractSphericalRegion |
TODO: maybe consider option 'antipodal' |
Back to Top
F
factor (symmetry) |
factorizes s1 and s2 into l, d, r such that s1 = l * d and s2 = d * r |
FCE (velocityGradientTensor) |
finite strain ellipsoid |
fclencurt |
Fast Clenshaw Curtis Quadrature |
fdct |
fdct is a function. C = fdct(x) |
femComponent (femComponent) |
defines an ODF by finite elements |
femODF |
defines an ODF by finite elements |
fibre (fibre) |
fibre is a class representing a fibre in orientation space. Examples are alpha, beta or gamma fibres. In general a fibre is
defined by a crystal direction h of type <Miller_index.html Miller> and a specimen direction of type <vector3d_index.html
vector3d>.
|
fibre2quat |
arbitrary quaternion q with q * h = r |
fibreComponent (fibreComponent) |
defines an fibre symmetric component |
fibreODF |
defines an fibre symmetric ODF |
fibreVolume (ODF) |
ratio of orientations with a certain orientation |
fibreVolume (orientation) |
ratio of orientations close to a certain fibre |
fibreVonMisesFisherKernel |
extract parameter and halfwidth |
file2cell |
reads a file rowise into a cellstr |
fill (EBSD) |
extrapolate spatial EBSD data by nearest neighbour for tetragonal lattice |
fill (EBSDhex) |
fill spatial EBSD data |
fill (EBSDsquare) |
fill spatial EBSD data |
fillByGrainId (EBSD) |
extrapolate spatial EBSD data by nearest neighbour for tetragonal lattice |
find (S1Grid) |
find close points |
find (S2Grid) |
return index of all points in a epsilon neighborhood of a vector |
find (SO3Grid) |
return indece and distance of all nodes within a eps neighborhood |
find (quaternion) |
return indece and distance of all nodes within a eps neighborhood |
find (vector3d) |
return index of all points in a epsilon neighborhood of a vector |
find_option |
find postions of the options in option_list |
find_type |
parse arguments list for a specific type an returns the first occurance |
findByLocation (EBSD) |
select EBSD data by spatial coordinates |
findByLocation (grain2d) |
select a grain by spatial coordinates |
findByOrientation (EBSD) |
select ebsd data by orientation |
findByOrientation (grain2d) |
select grains by orientation |
findOutlier (PoleFigure) |
find outliers in pole figures |
findTetra (DelaunaySO3) |
find tetrahegon |
finiteStrain (velocityGradientTensor) |
derive finte strain axes and magnitudes from deformation tensor after n-steps (in strain rate units of L) using the solution
of Provost et al.2014 doi:10.1029/2001JB001734
|
fitArea (crystalShape) |
change habitus of crystal shape to fit given faceAreas |
fitDislocationSystems (curvatureTensor) |
fit dislocation systems to a curvature tensor |
fitEllipse (grain2d) |
fit ellipses to grains using the method described in Mulchrone& Choudhury,2004 (https://doi.org/10.1016/S0191-8141(03)00093-2) |
flip (grainBoundary) |
flip a boundary from phase1/phase2 to phase2/phase1 |
fliplr (EBSD) |
flip spatial ebsd-data from left to right |
flipud (EBSD) |
flip spatial ebsd-data from upside down |
FMC_Coarsen |
Performs one coarsening step. |
FMC_interpret |
Interpretation of FMC data and grain assignment |
FMC_MTEX |
setup Wnext |
Fourier (FourierComponent) |
get Fourier coefficients of and ODF |
Fourier (tensor) |
compute the Fourier coefficients of the tensor |
FourierComponent (FourierComponent) |
defines an ODF component by its Fourier coefficients |
FourierODF (ODF) |
compute FourierODF from another ODF |
FourierODF |
defines an ODF by its Fourier coefficients |
free_nfft (MLSSolver) |
MLSSolver/free_nfft is a function. free_nfft(solver) |
fundamentalRegion (symmetry) |
fundamental region in orientation space for a (pair) of symmetries |
fundamentalRegion |
get the fundamental zone in orientation space for a symmetry |
fundamentalRegionEuler (symmetry) |
get the fundamental region in Euler angles |
fundamentalSector (symmetry) |
get the fundamental sector for a symmetry in the inverse pole figure |
Back to Top
G
gammaSections |
gamma sections for ODF and orientation plotting |
GaussWeierstrassKernel |
extract parameter and halfwidth |
gcm |
gcm is a function. mfig = mtexFig |
generic_wizard |
generic_wizard is a function. values = generic_wizard(varargin) |
geodesic (quaternion) |
Calculats the rotation, which is described by the geodesic gamma(t)_{rot1,rot2} from rot1 to rot2 at the location t, for
vectors of n rotations.
|
get_flag |
extract flag from option list |
get_obj_fields |
get_obj_fields is a function. varargout = get_obj_fields(obj, varargin) |
get_option |
extract option from option list |
getCamera |
get xAxis and zAxis position from axis |
getClass |
getClass is a function. out = getClass(list, className, default) |
getColormaps |
getColormaps is a function. [cm, cmd] = getColormaps |
getdata (S2Grid) |
return index of all points in a epsilon neighborhood of a vector |
getDataCursorPos (mtexFigure) |
get the position and value of the data cursor |
getFundamentalRegion (orientation) |
projects orientations to a fundamental region |
getHoldState |
getHoldState is a function. ishold = getHoldState(varargin) |
getmem |
return total system memory in kb |
getMinAxes (rotation) |
rotation/getMinAxes is a function. [axes, angle] = getMinAxes(rot) |
getMTEXpref |
getMTEXpref is a function. value = getMTEXpref(pref, default) |
getSubDirs |
getSubDirs - gets recursively all subdirectories of a given directory. |
getUnitScale |
Syntax factor = getUnitScale(unit) |
gnonomicProjection |
gnonomic projection |
grad (S2FunHarmonic) |
calculates the gradiet of a spherical harmonic |
grad (S2FunTri) |
S2FunTri/grad is a function. g = grad(sF, v) |
grad (FourierComponent) |
gradient at orientation g |
grad (ODF) |
gradient of odf at orientation ori |
grad (ODFComponent) |
gradient at orientation g |
grad (fibreComponent) |
evaluate an odf at orientation g |
grad (uniformComponent) |
gradient of the ODF at orientation g |
grad (unimodalComponent) |
gradient at orientation g |
grain2d (grain2d) |
two dimensional grains |
grainBoundary (grainBoundary) |
grainBoundary list of grain boundaries in 2-D |
GreenStrain (deformationGradientTensor) |
Syntax E = GreenStrain(F) |
gridify (EBSD) |
extend EBSD data to an grid |
GridLength (S1Grid) |
return number of points |
Back to Top
H
h5group2struct |
read h5 group to struct |
halfQuadraticFilter |
haldQuadraticFilter uses the techniques elaborated half-quadratic minmization on manifolds to smooth EBSD data. Properties:
alpha: regularisation parameter in [x,y] direction weight: function handle specified by the regularising function \varphi,
@(t,eps), where eps is its parameter eps: Parameter for the weight tol: Tolerance for the gradient descent threshold:
threshold for subgrain boundaries Methods: smooth: Applies the HQ minimization on the quaternions of the given orientations
|
hasHole (grain2d) |
test if a grain has a hole or not |
hist (grain2d) |
plot a grain size histogram |
hist (ODF) |
calcualtes a histogram of ODF |
HKLDirectionKey |
HKLDirectionKey is a class. dM = HKLDirectionKey(varargin) |
homochoricPlot |
create a 3d Euler angle plot |
horzcat (S2FunHarmonic) |
overloads horzcat |
horzcat (tensor) |
overloads [T1,T2,T3..] |
horzcat (dislocationSystem) |
overloads [v1,v2,v3..] |
horzcat (fibre) |
overloads [v1,v2,v3..] |
horzcat (orientationRegion) |
HORZCAT Horizontal concatenation. [A B] is the horizontal concatenation of matrices A and B. A and B must have the same number
of rows. [A,B] is the same thing. Any number of matrices can be concatenated within one pair of brackets. Horizontal and
vertical concatenation can be combined together as in [1 2;3 4].
|
horzcat (quaternion) |
implements [q1,q2,q3..] |
horzcat (slipSystem) |
overloads [v1,v2,v3..] |
horzcat (sphericalRegion) |
HORZCAT Horizontal concatenation. [A B] is the horizontal concatenation of matrices A and B. A and B must have the same number
of rows. [A,B] is the same thing. Any number of matrices can be concatenated within one pair of brackets. Horizontal and
vertical concatenation can be combined together as in [1 2;3 4].
|
horzcat (vector3d) |
overloads [v1,v2,v3..] |
hotColorMap |
HOT Black-red-yellow-white color map HOT(M) returns an M-by-3 matrix containing a "hot" colormap. HOT, by itself, is the
same length as the current figure's colormap. If no figure exists, MATLAB creates one.
|
hr2quat |
arbitrary quaternion q with q * h = r |
hsl2hsv |
hsl2hsv is a function. [h, s, v] = hsl2hsv(hh, ss, ll) |
hsvColorMap |
HSV Hue-saturation-value color map HSV(M) returns an M-by-3 matrix containing an HSV colormap. HSV, by itself, is the same
length as the current figure's colormap. If no figure exists, MATLAB creates one.
|
HSVDirectionKey |
converts crystal or specimen directions to rgb values |
hull (grain2d) |
replace grains by its convex hull |
Back to Top
I
id2ind (EBSD) |
find ind such that ebsd.id(ind) == id |
import_wizard |
import_wizard is a function. import_wizard(varargin) |
ind2char |
calculates coordinate from one index i - index s - size of matrix |
infernoColorMap |
infernoColorMap is a function. varargout = infernoColorMap(varargin) |
infimalConvolutionFilter |
matrix-valued image with the TV-norm. \argmin_u{\|u-u_0\|_2^2 + \lambda \|\nabla u\|_{2,1} + \mu \|H u\|_{2,1}}, \lambda,\mu
> 0 Written by Johannes Persch, Ronny Bergmann, 09.06.2015 function ma_val_im_reg_2nd_ord minimzes the second order model
of a OUTPUT: u_hat: computed minimizer diff: differences of u and v between two successive iterations
|
init (MLSSolver) |
extract pole figures |
init (zeroRangeMethod) |
zeroRangeMethod/init is a function. init(zrm, varargin) |
initIter (MLSSolver) |
maybe no starting vector of coefficients has been specified |
inpolygon (EBSD) |
checks which ebsd data are within given polygon |
inpolygon (grain2d) |
checks which grains are within given polygon |
inpolygon (grainBoundary) |
checks which gb data are within given polygon |
interp (vector3d) |
spherical interpolation - including some smoothing |
intersect (grainBoundary) |
length of a boundary segment |
inv (complianceTensor) |
compliance to stiffness tensor |
inv (stiffnessTensor) |
stiffness to compliance tensor |
inv (tensor) |
inverse of a tensor |
inv (quaternion) |
quaternion of the inverse roation |
ipfColorKey |
defines an orientation mapping based on a certain inverse pole figure Detailed explanation goes here |
ipfHKLKey |
defines an orientation mapping based on a certain inverse pole figure Detailed explanation goes here |
ipfHSVKey |
defines an orientation mapping based on a certain inverse pole figure |
ipfSections |
ipfSections is a class. oS = ipfSections(CS1, CS2, varargin) |
ipfSpotKey |
Maps an individual color to each given crystal directions being parallel to a specimen direction (fibre) Properties: center
- list of crystal directions @Miller color - n-by-3 list representing RGB values, one for each center psi - @kernel
providing the width and brightness for colored fibre inversePoleFigureDirection - specimen direction @vector3d
|
ipfTSLKey |
orientation mapping as it is used by TSL and HKL software |
isappr |
check double == double |
isempty (S2FunHarmonic) |
overloads isempty |
isempty (PoleFigure) |
overloads length |
isempty (dislocationSystem) |
overloads isempty |
isempty (fibre) |
overloads isempty |
isempty (quaternion) |
overloads isempty |
isempty (slipSystem) |
overloads isempty |
isempty (vector3d) |
overloads isempty |
isempty_cell |
isempty for cells |
iseven |
check double mod 2 == 0 |
isFourier (ODF) |
check whether odf is given by Fourier coefficients |
isImproper (rotation) |
rotation/isImproper is a function. out = isImproper(r) |
isLower (sphericalRegion) |
sphericalRegion/isLower is a function. out = isLower(sR) |
isMisorientation (orientation) |
check whether o is a misorientation |
isnan (quaternion) |
check for nan values |
isnull |
ckeck double == 0 |
isOctave |
isOctave is a function. result = isOctave |
isOutlier (PoleFigure) |
find outliers in pole figures |
isPerp (vector3d) |
check whether v1 and v2 are orthogonal |
ispos |
check double > 0 |
isRGB |
isRGB is a function. out = isRGB(fig) |
isTwinning (grainBoundary) |
Syntax |
isUpper (sphericalRegion) |
sphericalRegion/isUpper is a function. out = isUpper(sR) |
Back to Top
K
K_symmetrised (kernel) |
evaluate kernel modulo symmetries |
KAM (EBSD) |
intragranular average misorientation angle per orientation |
kde |
Reliable and extremely fast kernel density estimator for one-dimensional data; Gaussian kernel is assumed and the bandwidth
is chosen automatically; Unlike many other implementations, this one is immune to problems caused by multimodal densities
with widely separated modes (see example). The estimation does not deteriorate for multimodal densities, because we never
assume a parametric model for the data. INPUTS: data - a vector of data from which the density estimate is constructed;
n - the number of mesh points used in the uniform discretization of the interval [MIN, MAX]; n has to be a power of two;
if n is not a power of two, then n is rounded up to the next power of two, i.e., n is set to n=2^ceil(log2(n)); the default
value of n is n=2^12; MIN, MAX - defines the interval [MIN,MAX] on which the density estimate is constructed; the default
values of MIN and MAX are: MIN=min(data)-Range/10 and MAX=max(data)+Range/10, where Range=max(data)-min(data); OUTPUTS: bandwidth
- the optimal bandwidth (Gaussian kernel assumed); density - column vector of length 'n' with the values of the density estimate
at the grid points; xmesh - the grid over which the density estimate is computed; - If no output is requested, then the
code automatically plots a graph of the density estimate. cdf - column vector of length 'n' with the values of the cdf Reference:
Kernel density estimation via diffusion Z. I. Botev, J. F. Grotowski, and D. P. Kroese (2010) Annals of Statistics, Volume
38, Number 5, pages 2916-2957.
|
kernel (kernel) |
kernel is a class. psi = kernel(A) |
KLCV (orientation) |
Kullback Leibler cross validation for optimal kernel estimation |
kmeans |
k-means++: The Advantages of Careful Seeding", by David Arthur and Sergei Vassilvitskii, SODA 2007. |
KuwaharaFilter |
KuwaharaFilter is a class. F = KuwaharaFilter(varargin) |
Back to Top
L
l1TVFilter (l1TVFilter) |
smoothes quaternions by projecting them into tangential space and performing there smoothing spline approximation |
LaboTeXColorMap |
return LaboTeX colormap |
LaplaceKernel |
extract bandwidth |
Laue (symmetry) |
return the corresponding Laue group |
LaueName (symmetry) |
get Laue name |
ldivide (orientation) |
o .\ v |
le (S2FunHarmonic) |
overloads sF1 <= sF2 |
le (S2FunTri) |
overloads sF1 <= sF2 |
legendre0 |
Legendrepolynome bis zur Odnung N und gibt sie als Matrix zur�ck erste Dimension -> Ordnung zweite Dimension -> x |
length (S2FunHarmonic) |
overloads length |
length (tensor) |
returns the number of tensors |
length (crystalShape) |
overloads length |
length (dislocationSystem) |
overloads length |
length (fibre) |
overloads length |
length (quaternion) |
overloads length |
length (slipSystem) |
overloads length |
length (symmetry) |
number of symmetry elements |
length (vector3d) |
overloads length |
line (rotation) |
draw rotations connected by lines |
line (vector3d) |
Syntax |
linearCompressibility (complianceTensor) |
computes the linear compressibility of an elasticity tensor |
linearCompressibility (stiffnessTensor) |
computes the linear compressibility of an elasticity tensor |
load_generic |
load file using import data and txt2mat |
loadallspectra |
load all spectra files of a Dubna meassurement cycle |
loadCIF |
import crystal symmetry from cif file |
loadData |
import PoleFigure, EBSD, and ODF data |
loadEBSD |
import ebsd data |
loadEBSD_ACOM |
read ACOM files (converted from *.res ASTAR) |
loadEBSD_ang |
read TSL *.ang file |
loadEBSD_brukertxt |
read Bruker *.txt file |
loadEBSD_crc |
interface for Oxford Chanel 5 crc and cpr EBSD data files |
loadEBSD_csv |
loadEBSD_csv is a function. ebsd = loadEBSD_csv(fname, varargin) |
loadEBSD_ctf |
read HKL *.ctf file |
loadEBSD_dream3d |
loadEBSD_dream3d is a function. ebsd = loadEBSD_dream3d(fname, varargin) |
loadEBSD_ebsdimage |
Check extension |
loadEBSD_generic |
load ebsd data from generic text files |
loadEBSD_h5 |
loadEBSD_h5 is a function. [ebsd, header] = loadEBSD_h5(fname, varargin) |
loadEBSD_hdf5 |
Read rotations |
loadEBSD_osc |
loadEBSD_osc is a function. ebsd = loadEBSD_osc(fname, varargin) |
loadEBSD_Oxfordcsv |
loadEBSD_Oxfordcsv is a function. ebsd = loadEBSD_Oxfordcsv(fname, varargin) |
loadEBSD_sor |
load LaboTex *.sor file |
loadGrainSet_hdf5 |
Read EBSD |
loadHelper |
helps to load data-matrix with ColumnNames restricts also data according to conventions (e.g. >4pi) |
loadODF |
import ebsd data |
loadODF_generic |
load pole figure data from (alpha,beta,gamma) files |
loadODF_VPSC |
loadODF_VPSC is a function. [odf, options] = loadODF_VPSC(fname, varargin) |
loadOrientation |
import orientation data from data files |
loadOrientation_DRex |
loadOrientation_DRex is a function. ori = loadOrientation_DRex(fname, varargin) |
loadOrientation_generic |
load Orientation data from generic text files |
loadOrientation_generic2 |
load Orientation data from generic text files |
loadPHL |
loadPHL is a function. cs = loadPHL(fname) |
loadPoleFigure |
import pole figure data |
loadPoleFigure_aachen |
import data fom aachen ptx file |
loadPoleFigure_aachen_exp |
import data fom aachen_exp file |
loadPoleFigure_ana |
import data fom ana file |
loadPoleFigure_beartex |
import data fom BeaTex file |
loadPoleFigure_dubna |
load dubna cnv file |
loadPoleFigure_geesthacht |
load ptx file |
loadPoleFigure_generic |
load pole figure data from (theta,rho,intensity) files |
loadPoleFigure_gpol |
loadPoleFigure_gpol is a function. pf = loadPoleFigure_gpol(fname, varargin) |
loadPoleFigure_ibm |
import data fom ibm file |
loadPoleFigure_juelich |
load juelich data format |
loadPoleFigure_labotex |
load labotex pole figure data |
loadPoleFigure_nja |
loadPoleFigure_nja is a function. pf = loadPoleFigure_nja(fname, varargin) |
loadPoleFigure_out1 |
import polfigure-data form Graz |
loadPoleFigure_philips |
load philips *.txt file |
loadPoleFigure_plf |
load plf file |
loadPoleFigure_popla |
import data fom Popla file |
loadPoleFigure_pwd |
load D5000 powder data file |
loadPoleFigure_rigaku |
import data fom Rigaku SamrtLab txt file |
loadPoleFigure_rigaku_dat |
load *.dat files of rigaku devices |
loadPoleFigure_rigaku_txt |
import data fom ana file |
loadPoleFigure_rigaku_txt2 |
import data fom ana file |
loadPoleFigure_rw1 |
import data from Philip's Xpert binary file format rw1 |
loadPoleFigure_scintag |
import data fom scintag ascii file |
loadPoleFigure_siemens |
load D5000 data file |
loadPoleFigure_slc |
load *.txt file with regular grid |
loadPoleFigure_uxd |
import data fom ana file |
loadPoleFigure_xrd |
import data fom aachen xrd file |
loadPoleFigure_xrdml |
load xrdMeasurement (xrdml) file |
loadspectra |
load a single spectrum o a Dubna meassurement |
loadTensor |
import Tensor data |
loadTensor_generic |
load a Tensor from a file |
loadTensor_mpod |
import Tensor data |
loadTensor_P |
load a Tensor from a file |
loadVector3d |
import ebsd data |
loadVector3d_generic |
load pole figure data from (alpha,beta,gamma) files |
localOrientationGrid |
define a equispaced grid localized to a center orientation |
log (S2FunHarmonic) |
log of a function |
log (orientation) |
the misorientation vector between two orientations |
log (quaternion) |
the logarithmic map that translates a rotation into a rotation vector |
logm (tensor) |
matrix logarithm of a tensor |
logm (orientation) |
the logarithmic map that translates a rotation into a spin tensor |
logm (quaternion) |
the logarithmic map that translates a rotation into a spin tensor |
LSCV (orientation) |
least squares cross valiadation |
Back to Top
M
magmaColorMap |
magmaColorMap is a function. varargout = magmaColorMap(varargin) |
makeS2FunDoc |
makeS2FunDoc is a function. |
map (orientation) |
define orientations by pairs of vectors |
map (rotation) |
define rotations by pairs of vectors |
mapPlot |
class to handle spatial plots of EBSD data and grains |
mat2quat |
converts direction cosine matrix to quaternion |
matrix (tensor) |
return tensor as a matrix |
matrix (quaternion) |
quaternion to direction cosine matrix conversion converts direction cosine matrix to quaternion |
matrix (rotation) |
quaternion to direction cosine matrix conversion converts direction cosine matrix to quaternion |
max (S2Fun) |
global, local and pointwise maxima of spherical functions |
max (S2FunTri) |
MAX Maximum elements of an array. M = MAX(X) is the largest element in the vector X. If X is a matrix, M is a row vector
containing the maximum element from each column. For N-D arrays, MAX(X) operates along the first non-singleton dimension.
|
max (ODF) |
heuristic to find local modal orientations |
max (PoleFigure) |
maximum of two pole figures or the maximum of a single polefigure |
max (tensor) |
MAX Maximum elements of an array. M = MAX(X) is the largest element in the vector X. If X is a matrix, M is a row vector
containing the maximum element from each column. For N-D arrays, MAX(X) operates along the first non-singleton dimension.
|
max (S1Grid) |
return maximum value |
maxAngle (orientationRegion) |
get the maximum angle of the fundamental region |
maxAngle (symmetry) |
get the maximum angle of the fundamental region |
mean (S2Fun) |
calculates the mean value for an univariate S2Fun or calculates the mean along a specified dimension fo a multimodal S2Fun |
mean (S2FunHarmonic) |
calculates the mean value for an univariate S2Fun or calculates the mean along a specified dimension fo a multimodal S2Fun |
mean (S2FunTri) |
mean value of a spherical function |
mean (S2VectorFieldHarmonic) |
syntax f = mean(sVF) |
mean (ODF) |
expected value of an ODF |
mean (PoleFigure) |
mean of pole figure intensities |
mean (tensor) |
mean of a list of tensors |
mean (orientation) |
mean of a list of orientations, principle axes and moments of inertia |
mean (quaternion) |
mean of a list of quaternions, principle axes and moments of inertia |
mean (vector3d) |
computes the mean vector |
mean_CS (quaternion) |
fast mean of |
meanFilter |
implements a convolution filter for quaternion |
meanStress (stressTensor) |
mean stress |
medianFilter |
medianFilter is a class. F = medianFilter(varargin) |
merge (grain2d) |
merge grains along special grain boundaries |
mhyper |
multivariat hypergeometric function 1F1(1/2,p/2, kappa) |
Miller (Miller) |
define a crystal direction by Miller indice |
min (S2FunHarmonic) |
global, local and pointwise minima of spherical functions |
min (S2FunTri) |
MIN Minimum elements of an array. M = MIN(X) is the smallest element in the vector X. If X is a matrix, M is a row vector
containing the minimum element from each column. For N-D arrays, MIN(X) operates along the first non-singleton dimension.
|
min (PoleFigure) |
minimum of two pole figures or the minimum of a single polefigure |
min (tensor) |
MIN Minimum elements of an array. M = MIN(X) is the smallest element in the vector X. If X is a matrix, M is a row vector
containing the minimum element from each column. For N-D arrays, MIN(X) operates along the first non-singleton dimension.
|
min (S1Grid) |
return maximum value |
minAngle (orientationRegion) |
get the minimum angle of the boundary of the fundamental region |
minus (S2Fun) |
overload minus |
minus (S2VectorFieldHarmonic) |
Syntax sVF = sVF1-sVF2 sVF = a-sVF1 sVF = sVF1-a |
minus (S2VectorFieldTri) |
Syntax sVF = sVF1 - sVF2 sVF = sVF - v |
minus (ODF) |
superposeing two ODFs |
minus (PoleFigure) |
implements pf1 - pf2 |
minus (tensor) |
T1 - T2; |
minus (S1Grid) |
- Minus. X - Y subtracts matrix Y from X. X and Y must have compatible sizes. In the simplest cases, they can be the same
size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are
either the same or one of them is 1.
|
minus (quaternion) |
overloads minus |
minus (vector3d) |
overload minus |
mix2 |
mix2 sample ODF |
mldivide (orientation) |
o \ v |
mldivide (quaternion) |
\ Backslash or left matrix divide. A\B is the matrix division of A into B, which is roughly the same as INV(A)*B , except
it is computed in a different way. If A is an N-by-N matrix and B is a column vector with N components, or a matrix with several
such columns, then X = A\B is the solution to the equation A*X = B. A warning message is printed if A is badly scaled or
nearly singular. A\EYE(SIZE(A)) produces the inverse of A.
|
mldivide (rotation) |
o \ v |
MLSSolver (MLSSolver) |
modified least squares solver |
mpower (quaternion) |
q^n |
mpower (vector3d) |
n-th dyadic product |
mPrime (slipSystem) |
m' parameter from Luster and Morris in 1995 |
mrdivide (ODF) |
scaling of the ODF |
mrdivide (PoleFigure) |
implements pf1 ./ b and a ./ pf2 |
mrdivide (tensor) |
implements T / S |
mrdivide (quaternion) |
scalar division |
mtex_assert |
mtex_assert is a function. mtex_assert(cond, varargin) |
mtex_path |
return install dir of mtex |
mtexCifPath |
returns the default path to crystallographic information files (CIF) |
mtexColorbar |
overide buildin Matlab colorbar function |
mtexColorMap |
define an MTEX colormap |
mtexdata |
load of data provided with mtex and often used in documentation |
mtexDataPath |
returns the default path to mtex sample data |
mtexdegchar |
returns the degree character |
mtexEBSDPath |
returns the default path to EBSD data files |
mtexFigure (mtexFigure) |
class to handles figures with equaly sized axes |
MTEXmenu |
show up MTEX menu |
mtexODFPath |
returns the default path to ODF-files |
mtexPoleFigurePath |
returns the default path to PoleFigure data files |
mtexTensorPath |
returns the default path to tensor-files |
mtimes (S2FunHarmonic) |
Syntax sF = sF1 * sF2 sF = a * sF1 sF = sF1 * a |
mtimes (S2FunTri) |
* Matrix multiply. X*Y is the matrix product of X and Y. Any scalar (a 1-by-1 matrix) may multiply anything. Otherwise,
the number of columns of X must equal the number of rows of Y.
|
mtimes (S2VectorFieldHarmonic) |
Syntax sF = sF1*sF2 sF = a*sF1 sF = sF1*a |
mtimes (EBSD) |
rotating the ebsd data by a certain rotation |
mtimes (ODF) |
scaling of the ODF |
mtimes (PoleFigure) |
scaling of PoleFigures, implements pf1 * b and a * pf2 |
mtimes (complianceTensor) |
tensor product S * sigma |
mtimes (stiffnessTensor) |
tensor product C * eps |
mtimes (tensor) |
implements T1 * T2 |
mtimes (SO3Grid) |
outer quaternion multiplication |
mtimes (crystalShape) |
* Matrix multiply. X*Y is the matrix product of X and Y. Any scalar (a 1-by-1 matrix) may multiply anything. Otherwise,
the number of columns of X must equal the number of rows of Y.
|
mtimes (orientation) |
orientation times Miller and orientation times orientation |
mtimes (quaternion) |
quaternionen multiplication q1 * q2 |
mtimes (rotation) |
r = a * b |
mtimes (vector3d) |
scalar multiplication |
Mtv (MLSSolver) |
forward operator |
multiplicityPerpZ (symmetry) |
maximum angle rho |
multiplicityZ (symmetry) |
maximum angle rho |
Mv (MLSSolver) |
forward operator |
Back to Top
N
n (S2VectorField) |
Gives the normal vector of the tangential plane in v |
n2str |
num2str with exact zero |
nadjacent |
Returns the adjacency matrix of the n-neighbours. |
nanmax |
FORMAT: [Y,IDX] = NANMAX(A,DIM,[B]) |
nanmean |
FORMAT: Y = NANMEAN(X,DIM) |
nanmedian |
FORMAT: Y = NANMEDIAN(X,DIM) |
nanmin |
FORMAT: [Y,IDX] = NANMIN(A,DIM,[B]) |
nanplus |
nanplus is a function. [a, count] = nanplus(a, b, count, alpha) |
nansum |
FORMAT: Y = NANSUM(X,DIM) |
ndims (tensor) |
overloads size |
ndims (quaternion) |
overloads ndims |
ne (grain2d) |
~= Not equal. A ~= B does element by element comparisons between A and B and returns an array with elements set to logical
1 (TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes.
In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension,
the dimension sizes of the inputs are either the same or one of them is 1.
|
ne (tensor) |
checks whether two tensors are not equal |
ne (dislocationSystem) |
? sS1 ~= sS2 |
ne (fibre) |
? sS1 ~= sS2 |
ne (orientationRegion) |
~= Not equal. A ~= B does element by element comparisons between A and B and returns an array with elements set to logical
1 (TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes.
In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension,
the dimension sizes of the inputs are either the same or one of them is 1.
|
ne (quaternion) |
q1 ~= q2 ? |
ne (slipSystem) |
? sS1 ~= sS2 |
ne (sphericalRegion) |
~= Not equal. A ~= B does element by element comparisons between A and B and returns an array with elements set to logical
1 (TRUE) where the relation is true and elements set to logical 0 (FALSE) where it is not. A and B must have compatible sizes.
In the simplest cases, they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension,
the dimension sizes of the inputs are either the same or one of them is 1.
|
ne (vector3d) |
? v1 == v2 |
neighbors (grain2d) |
returns the number of neighboring grains |
neuralgas (ODF) |
attempt to distribute measure-sites equally according to invers polefigure density (experimental) |
newer_version |
check matlab version |
newMapPlot |
newMapPlot is a function. [mP, isNew] = newMapPlot(varargin) |
newMtexFigure |
set uo a new plotting figure |
newODFSectionPlot |
generate a new ODF section plot |
newOrientationPlot |
prepare a 3d orientation plot |
newSphericalPlot |
split plot in upper and lower hemisphere |
nextAxis (mtexFigure) |
go to next plot |
nextAxis |
nextAxis is a function. ax = nextAxis(varargin) |
nextstyle |
NEXTSTYLE Get next plot linespec [L,C,M] = NEXTSTYLE(AX) gets the next line style, color and marker for plotting from the
ColorOrder and LineStyleOrder of axes AX.
|
nfold (symmetry) |
maximal n-fold of symmetry axes |
niceEuler (orientation) |
orientation to euler angle |
noisepf (PoleFigure) |
simulate diffraction counts |
norm (S2FunHarmonic) |
the L2 norm of a spherical function |
norm (S2VectorFieldHarmonic) |
pointwise norm of the vectorfield |
norm (S2VectorFieldTri) |
pointwise norm of the vectorfield |
norm (FourierComponent) |
caclulate texture index of ODF |
norm (ODF) |
caclulate texture index of ODF |
norm (tensor) |
tensor frobenius norm |
norm (quaternion) |
quaternion norm sqrt(a^2+b^2+c^2+c^2) |
norm (vector3d) |
vector norm |
normalDirection (velocityGradientTensor) |
normal direction |
normalize (S2VectorField) |
Gives the normal vector of the tangential plane in v |
normalize (PoleFigure) |
normalization of a meassured pole figure with respect to an ODF |
normalize (quaternion) |
normalize quaternion |
normalize (vector3d) |
normalize a vector |
numel (tensor) |
returns the number of tensors |
NWSE |
NWSE is a function. out = NWSE(in) |
Back to Top
O
octahedralStrain (strainTensor) |
the octahedral strains |
ODF (ODF) |
ODF is a class. odf = ODF(components, weights) |
ODFSections (ODFSections) |
ODFSECTIONS Summary of this class goes here Detailed explanation goes here |
omegaSections |
omegaSections is a class. oS = omegaSections(CS1, CS2, h1, h2, r_ref, varargin) |
opticalAxis (refractiveIndexTensor) |
optical axis or axes for a refractive index tensor |
option2str |
transforms option list to comma separated list |
optiondraw |
apply options to handle |
optionplot |
plot y against x using the options in varargin |
orientation (fibre) |
generate a list of orientation out of a fibre |
orientation (orientation) |
orientation - class representing orientations |
orientationColorKey |
abstract class for defining (mis)orientation color keys |
orientationPlot |
ODFSECTIONS |
orientationRegion (orientationRegion) |
sphericalRegion implements a region in orientation space The region is bounded by planes normal to quaternions N i.e., all
quaternions q inside a region satisfy the condition dot(q, N) <= 0 or dot(-q, N) <= 0 for all N
|
orth (vector3d) |
an arbitrary orthogonal vector |
orthographicProjection |
orthographic projection |
orthProj (vector3d) |
vector3d/orthProj is a function. v = orthProj(v, N) |
Back to Top
P
parents (orientation) |
variants of an orientation relationship |
paris (grain2d) |
Percentile Average Relative Indented Surface |
parseXML |
PARSEXML Convert XML file to a MATLAB structure. |
parulaColorMap |
PARULA Blue-green-orange-yellow color map PARULA(M) returns an M-by-3 matrix containing a colormap. The colors begin with
dark purplish-blue and blue, range through green and orange, and end with bright yellow. PARULA is named after a bird, the
tropical parula, which has these colors.
|
PatalaColorKey (PatalaColorKey) |
converts misorientations to rgb values as described in |
pauseline |
pauseline is a function. |
pcolor (S2Fun) |
spherical contour plot |
pcolor (vector3d) |
spherical contour plot |
pdfMatrix (femComponent) |
called by pdf |
pdfMatrix (DelaunaySO3) |
called by pdf |
perimeter (grain2d) |
calculates the perimeter of a grain without or without inclusions |
perimeter (grainBoundary) |
boundary length per grain including holes |
permute (quaternion) |
overloads permute |
permute (rotation) |
overloads permute |
perp (vector3d) |
conmpute an vector best orthogonal to a list of directions |
perturbe (quaternion) |
pertube data randomly by epsilon |
pf2odfSolver |
pf2odfSolver is a class. obj = pf2odfSolver(varargin) |
pfSections |
pfSections is a class. oS = pfSections(CS1, CS2, varargin) |
phaseList |
handles a list of phases |
phi1Sections |
phi1 sections for ODF and orientation plotting |
phi2Sections |
phi2 sections for ODF and orientation plotting |
PhiSections |
PhiSections is a class. oS = PhiSections(varargin) |
plainProjection |
sphericalProjection |
planeIntersect (vector3d) |
pointwise determinant or triple product of three vector3d |
plasmaColorMap |
plasmaColorMap is a function. varargout = plasmaColorMap(varargin) |
plot (S2AxisField) |
plot spherical axis field |
plot (S2Fun) |
plot spherical Function |
plot (S2FunHarmonicSym) |
Syntax |
plot (S2FunTri) |
PLOT Linear plot. PLOT(X,Y) plots vector Y versus vector X. If X or Y is a matrix, then the vector is plotted versus the
rows or columns of the matrix, whichever line up. If X is a scalar and Y is a vector, disconnected line objects are created
and plotted as discrete points vertically at X.
|
plot (S2VectorField) |
plot spherical vector field |
plot (EBSD) |
spatial EBSD plot |
plot (grain2d) |
colorize grains |
plot (grainBoundary) |
plot grain boundaries |
plot (triplePointList) |
plot grain boundaries |
plot (ODF) |
plots odf or append to a previous plot using 'add2all' |
plot (PoleFigure) |
plot pole figure |
plot (zeroRangeMethod) |
plot zero regions in pole figures |
plot (tensor) |
plot a tensor T |
plot (ODFSections) |
plot data into ODF sections |
plot (S1Grid) |
plot grid |
plot (S2Triangulation) |
find all edges given by vertex i and vertex j |
plot (crystalShape) |
colorize grains |
plot (fibre) |
plot a fibre |
plot (orientation) |
annotate a orientation to an existing plot |
plot (orientationRegion) |
plots a spherical region |
plot (quaternion) |
PLOT Linear plot. PLOT(X,Y) plots vector Y versus vector X. If X or Y is a matrix, then the vector is plotted versus the
rows or columns of the matrix, whichever line up. If X is a scalar and Y is a vector, disconnected line objects are created
and plotted as discrete points vertically at X.
|
plot (sphericalRegion) |
plots a spherical region |
plot (symmetry) |
visualize symmetry elements according to international table |
plot (vector3d) |
plot vectors as two dimensional projections on the sphere |
plot (kernel) |
plot the kernel function |
plot3d (S2Fun) |
plot spherical Function |
plot3d (ODF) |
plots odf |
plot3d (vector3d) |
plot spherical data |
plot_spectra |
plot spectra of the Dubna goniometer |
plota2east |
set the default plot direction of the x-axis |
plota2north |
set the default plot direction of the x-axis |
plota2south |
set the default plot direction of the x-axis |
plota2west |
set the default plot direction of the x-axis |
plotAngleDistribution |
plot axis distribution |
plotAxisDistribution |
plot axis distribution |
plotb2east |
set the default plot direction of the x-axis |
plotb2north |
set the default plot direction of the x-axis |
plotb2south |
set the default plot direction of the x-axis |
plotb2west |
set the default plot direction of the x-axis |
plotCustom (vector3d) |
Syntax plotcustom(v,@(x,y) drawCommand(x,y)) % |
plotDiff (ODF) |
difference plot between two odfs or an odf and a pole figure |
plotDiff (PoleFigure) |
difference plot between two pole figures or an odf and a pole figure |
plotEllipse |
plot multiple ellipses |
plotEmptySphere |
plots white sphere |
plotFibre (ODF) |
plot odf along a fibre |
plotFourier (ODF) |
plots Fourier coefficients of the odf |
plotFourier (kernel) |
plot the Chybeyshev coefficients of the kernel function |
plotHKL (crystalSymmetry) |
plot symmetry |
plotIPDF (ODF) |
plot inverse pole figures |
plotIPDF (fibre) |
plot orientations into inverse pole figures |
plotIPDF (orientation) |
plot orientations into inverse pole figures |
plotPDF (ODF) |
plot pole figures |
plotPDF (fibre) |
plot a fibre into pole figures |
plotPDF (orientation) |
plot orientations into pole figures |
plotPDF (kernel) |
plot Radon transformed kernel |
plotS2Grid |
create a regular S2Grid for plotting |
plotSection (S2Fun) |
Syntax plotSection(sF,vector3d.Z) plotSection(sF,vector3d.Z,pi/3) |
plotSection (S2VectorField) |
Syntax plotSection(sVF,vector3d.Z) plotSection(sVF,vector3d.Z,pi/3) |
plotSection (ODF) |
plot ODF sections |
plotSection (orientation) |
plot orientations to ODF sections |
plotSO3Grid |
give a regular grid in orientation space |
plotSpektra (S2FunHarmonic) |
plots Fourier coefficients of a spherical function |
plotUnitCells (EBSD) |
EBSD/plotUnitCells is a function. h = plotUnitCells(ebsd, d, varargin) |
plotUnitCells (EBSDsquare) |
EBSDsquare/plotUnitCells is a function. h = plotUnitCells(ebsd, d, varargin) |
plotUVW (crystalSymmetry) |
plot symmetry |
plotx2east |
set the default plot direction of the x-axis |
plotx2north |
set the default plot direction of the x-axis |
plotx2south |
set the default plot direction of the x-axis |
plotx2west |
set the default plot direction of the x-axis |
plotzIntoPlane |
set the default plot direction of the z-axis |
plotzOutOfPlane |
set the default plot direction of the z-axis |
plus (S2FunHarmonic) |
impements sF1 + sF2 |
plus (S2FunHarmonicSym) |
Syntax sF = sF1.^a |
plus (S2FunTri) |
+ Plus. X + Y adds matrices X and Y. X and Y must have compatible sizes. In the simplest cases, they can be the same size
or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either
the same or one of them is 1.
|
plus (S2VectorFieldHarmonic) |
Syntax sVF = sVF1+sVF2 sVF = a+sVF1 sVF = sVF1+a |
plus (S2VectorFieldTri) |
Syntax sVF = sVF1 + sVF2 sVF = sVF + v |
plus (ODF) |
superposeing two ODFs |
plus (PoleFigure) |
implements pf1 + pf2 |
plus (tensor) |
add two tensors |
plus (S1Grid) |
+ Plus. X + Y adds matrices X and Y. X and Y must have compatible sizes. In the simplest cases, they can be the same size
or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes of the inputs are either
the same or one of them is 1.
|
plus (crystalShape) |
crystal shape should be first argument |
plus (quaternion) |
pointwise addition |
plus (vector3d) |
poitwise addition |
PoissonRatio (complianceTensor) |
computes the Poisson ratio of an elasticity tensor |
PoissonRatio (stiffnessTensor) |
computes the Poisson ratio of an elasticity tensor |
polar (tensor) |
compute the polar decomposition of rank 2 tensors |
polar (velocityGradientTensor) |
polar decomposition of velocity gradient tensor |
polar (S2Grid) |
polar coordinates of S2Grid |
polar (vector3d) |
cartesian to spherical coordinates Input v - @vector3d Output theta - polar angle rho - azimuthal angle r - radius |
polarCoordinates (sphericalRegion) |
compute polar coordinates of with respect to a spherical region |
PoleFigure (PoleFigure) |
constructor |
polyArea (vector3d) |
area of a flat polygon given by vertices v1, v2, ..., v_n |
power (S2FunHarmonic) |
Syntax sF = sF1.^a |
power (S2FunHarmonicSym) |
Syntax sF = sF1.^a |
power (S2FunTri) |
.^ Array power. Z = X.^Y denotes element-by-element powers. X and Y must have compatible sizes. In the simplest cases, they
can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension sizes
of the inputs are either the same or one of them is 1.
|
power (orientation) |
ori.^n |
power (quaternion) |
q.^n |
power (rotation) |
r.^n |
principalComponents (grain2d) |
returns the principalcomponents of grain polygon, without Holes |
proceed_spectra |
procede Dubna spectra |
prod (quaternion) |
overloads q1 * q2 * q3 |
progress |
display progress |
project (ODFSections) |
project orientation to ODF sections used by plotSection |
project2EulerFR (orientation) |
projects orientation to a fundamental region |
project2EulerFR (quaternion) |
projects quaternions to a fundamental region |
project2FundamentalRegion (Miller) |
projects vectors to the fundamental sector of the inverse pole figure |
project2FundamentalRegion (orientation) |
projects orientation to a fundamental region |
project2FundamentalRegion (quaternion) |
projects quaternions to a fundamental region |
project2FundamentalRegion (rotation) |
projects rotation to a fundamental region |
project2FundamentalRegion (vector3d) |
projects vectors to the fundamental sector of the inverse pole figure |
properGroup (symmetry) |
return the corresponding Laue group |
properSubGroup (symmetry) |
return the corresponding Laue group |
Back to Top
Q
qmatrix (quaternion) |
returns the quaternion multiplication matrix |
qq (quaternion) |
returns w * q' * q |
qqplot (orientation) |
quantile-quantile of misorientation angle against random angular misorientation |
quadrature (S2AxisFieldHarmonic) |
Syntax sF = S2AxisField.quadrature(v, value) sF = S2AxisField.quadrature(f) sF = S2AxisField.quadrature(f, 'bandwidth', M) |
quadrature (S2FunHarmonic) |
Syntax sF = S2FunHarmonic.quadrature(nodes,values,'weights',w) sF = S2FunHarmonic.quadrature(f) sF = S2FunHarmonic.quadrature(f,
'bandwidth', bandwidth)
|
quadrature (S2FunHarmonicSym) |
Syntax sF = S2FunHarmonicSym.quadrature(nodes,values,'weights',w,CS) sF = S2FunHarmonicSym.quadrature(f,CS) sF = S2FunHarmonicSym.quadrature(f,
'bandwidth', bandwidth,CS)
|
quadrature (S2VectorFieldHarmonic) |
Syntax sVF = S2VectorField.quadrature(v, value) sVF = S2VectorField.quadrature(f) sVF = S2VectorField.quadrature(f, 'bandwidth',
bw)
|
quadratureS2Grid |
Syntax [S2G, W, M2] = quadratureS2Grid(M) quadrature grid of type chebyshev [S2G, W, M2] = quadratureS2Grid(M, 'gauss') quadrature
grid of type gauss
|
quadric (tensor) |
quadric |
quantile (ODF) |
quantile orientations of an ODF |
quantile |
n percent quantile of x |
quaternion (quaternion) |
quaternion is a class. q = quaternion(varargin) |
quaternionPlot |
create a 3d Euler angle plot |
quiver (S2AxisField) |
quiver spherical axis field |
quiver (S2VectorField) |
quiver spherical vector field |
quiver (EBSD) |
plot directions at ebsd centers |
quiver (grain2d) |
plot directions at grain centers |
quiver (grainBoundary) |
plot directions at grain boundaries |
quiver (vector3d) |
Syntax quiver(v,d) |
quiver3 (S2AxisField) |
3-dimensional quiver spherical axis field |
quiver3 (S2Fun) |
a quiver plot on top of a surface plot |
quiver3 (S2VectorField) |
3-dimensional quiver spherical vector field |
quiver3 (vector3d) |
Syntax quiver(v,d) |
quiverSection (S2Fun) |
Syntax quiverSection(sF,v,vector3d.Z) quiverSection(sF,sVF,vector3d.Z) quiverSection(sF,v,vector3d.Z,pi/3) |
quiverSection (S2VectorField) |
plot a vector field along another vectorfield |
qwarning |
warning with option to stop |
Back to Top
R
radon (S2FunHarmonic) |
Radon transform of a spherical function |
randp |
randp(lambda) returns Poisson distributed Vector with mean lambda |
range |
RANGE Sample range. Y = RANGE(X) returns the range of the values in X. For a vector input, Y is the difference between the
maximum and minimum values. For a matrix input, Y is a vector containing the range for each column. For N-D arrays, RANGE
operates along the first non-singleton dimension.
|
rank (vector3d) |
rank = 1 |
rdivide (S2FunHarmonic) |
Syntax sF = sF1/sF2 sF = sF1/a sF = a/sF1 |
rdivide (S2FunHarmonicSym) |
Syntax sF = sF1/sF2 sF = sF1/a sF = a/sF1 |
rdivide (S2FunTri) |
./ Right array divide. A./B denotes element-by-element division. X and Y must have compatible sizes. In the simplest cases,
they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension
sizes of the inputs are either the same or one of them is 1.
|
rdivide (S2VectorFieldHarmonic) |
Syntax |
rdivide (S2VectorFieldTri) |
Syntax sVF = sVF ./ sF sVF = sVF ./ a |
rdivide (ODF) |
scaling of the ODF |
rdivide (PoleFigure) |
implements pf1 ./ b and a ./ pf2 |
rdivide (tensor) |
./ Right array divide. A./B denotes element-by-element division. X and Y must have compatible sizes. In the simplest cases,
they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension
sizes of the inputs are either the same or one of them is 1.
|
rdivide (quaternion) |
scalar division |
rdivide (vector3d) |
scalar division v ./ s |
real (tensor) |
REAL Complex real part. REAL(X) is the real part of X. See I or J to enter complex numbers. |
real (quaternion) |
real-part of of quaternion |
red2blueColorMap |
creates a colormap, ranging from dark blue via white to dark red. |
reduce (EBSD) |
reduce ebsd data by a factor |
reduce (EBSDhex) |
reduce ebsd data by taking only second pixel |
refine (DelaunaySO3) |
step 1: compute center of any two orientation connected by an edge |
refine (S1Grid) |
refine S1Grid |
refine (S2Grid) |
refine S2Grid |
refine (vector3d) |
refine vectors |
reflection |
defines a reflection at plane with normal n |
refractiveIndex (refractiveIndexTensor) |
refractive index with respect to a propagation direction |
refractiveIndexTensor (refractiveIndexTensor) |
refractiveIndexTensor is a class. rI = refractiveIndexTensor(varargin) |
region (Miller) |
return spherical region associated to a set of crystal directions |
region (vector3d) |
vector3d/region is a function. sR = region(v, varargin) |
regularisation (S2FunHarmonic) |
computes a regularisation Syntax sF = S2FunHarmonic.regularisation(S2Grid,f,lambda) sF = S2FunHarmonic.regularisation(S2Grid,f,lambda,'bandwidth',
bandwidth,'node_weights',W,'fourier_weights',What)
|
regularS2Grid |
Syntax regularS2Grid('points',[72 19]) regularS2Grid('resolution',[5*degree 2.5*degree]) regularS2Grid('theta',theta,'rho',rho) |
regularSO3Grid |
regular grid in Euler orientation space |
reorder (grainBoundary) |
nicely reorder grain boundaries |
repcell |
equivalent to repmat for cells |
repmat (crystalShape) |
implements repmat for crystalShape |
repmat (quaternion) |
overloads repmat |
repmat (rotation) |
overloads repmat |
repmat (vector3d) |
overloads repmat |
reshape (S2FunHarmonic) |
overloads reshape |
reshape (tensor) |
reshape for tensors |
reshape (crystalShape) |
RESHAPE Reshape array. RESHAPE(X,M,N) or RESHAPE(X,[M,N]) returns the M-by-N matrix whose elements are taken columnwise from
X. An error results if X does not have M*N elements.
|
reshape (quaternion) |
overloads reshape |
reshape (rotation) |
overloads reshape |
reshape (vector3d) |
overloads reshape |
residualBurgersVector (slipSystem) |
compute the Schmid factor |
restrict2Lower (sphericalRegion) |
sphericalRegion/restrict2Lower is a function. sR = restrict2Lower(sR) |
restrict2Upper (sphericalRegion) |
sphericalRegion/restrict2Upper is a function. sR = restrict2Upper(sR) |
restrictEBSD_ang |
read file header |
rho (S2VectorField) |
Gives the vector in the tangential plane in v in the direction rho |
rhoInside |
rhoInside is a function. ind = rhoInside(rho, minRho, maxRho) |
rhoRange (sphericalRegion) |
compute range of the polar angle of a spherical region |
RK_symmetrised (kernel) |
sum Radon trasformed kernel |
rmallappdata |
removes all figure appdata |
Rodrigues (quaternion) |
quaternion to rodrigues representation |
rodrigues2quat |
rodrigues2quat is a function. q = rodrigues2quat(R, varargin) |
RodriguesPlot |
create a 3d Euler angle plot |
rotate (BinghamS2) |
rotate a BinghamS2 function |
rotate (S2FunHarmonic) |
rotate a function by a rotation |
rotate (S2FunTri) |
ROTATE Rotate objects about specified origin and direction. ROTATE(H,[THETA PHI],ALPHA) rotates the objects with handles H
through angle ALPHA about an axis described by the 2-element direction vector [THETA PHI] (spherical coordinates). All the
angles are in degrees. The handles in H must be children of the same axes.
|
rotate (S2VectorFieldHarmonic) |
rotate a function by a rotation |
rotate (EBSD) |
rotate EBSD orientations or spatial data around point of origin |
rotate (BinghamComponent) |
rotate component |
rotate (FourierComponent) |
called by ODF/rotate |
rotate (ODF) |
rotate ODF |
rotate (femComponent) |
called by ODF/rotate |
rotate (fibreComponent) |
called by ODF/rotate |
rotate (uniformComponent) |
called by ODF/rotate |
rotate (unimodalComponent) |
called by ODF/rotate |
rotate (PoleFigure) |
rotates pole figures by a certain rotation |
rotate (tensor) |
rotate a tensor by a list of rotations |
rotate (Miller) |
rotate crystal directions |
rotate (S2Triangulation) |
ROTATE Rotate objects about specified origin and direction. ROTATE(H,[THETA PHI],ALPHA) rotates the objects with handles H
through angle ALPHA about an axis described by the 2-element direction vector [THETA PHI] (spherical coordinates). All the
angles are in degrees. The handles in H must be children of the same axes.
|
rotate (crystalShape) |
rotate a crystal shape by an rotation or orientation |
rotate (dislocationSystem) |
rotate dislocation systems system |
rotate (orientationRegion) |
rotate of a orientation region |
rotate (slipSystem) |
rotate slip system |
rotate (sphericalRegion) |
rotate of a spherical region |
rotate (vector3d) |
rotate vector3d by rotation or orientation |
rotate_outer (S2FunHandle) |
rotate a function by a rotation |
rotate_outer (S2FunHarmonic) |
rotate a function by a rotation |
rotate_outer (ODF) |
rotate ODF |
rotate_outer (PoleFigure) |
is called by rot * pf |
rotate_outer (tensor) |
rotate a tensor by a list of rotations |
rotate_outer (Miller) |
rotate crystal directions |
rotate_outer (crystalShape) |
rotate a crystal shape by an rotation or orientation |
rotate_outer (dislocationSystem) |
rotate dislocation systems |
rotate_outer (slipSystem) |
rotate slip system |
rotate_outer (vector3d) |
rotate vector3d by quaternion |
rotation (tensor) |
convertes orthogonal rank 2 tensors into rotations |
rotation (fibre) |
generate a list of orientation out of a fibre |
rotation (rotation) |
defines an rotation |
rotation_special (symmetry) |
returns symmetry elements different from rotation about c-axis |
rotationRate (velocityGradientTensor) |
rotation rate |
round (Miller) |
tries to round miller indizes to greatest common divisor |
round2Miller (orientation) |
find lattice alignements for arbitrary orientations and misorientations |
Back to Top
S
S1Grid (S1Grid) |
Constructor |
S2AxisField (S2AxisField) |
a class represeneting a axis field on the sphere |
S2AxisFieldHarmonic (S2AxisFieldHarmonic) |
a class represeneting a axis field on the sphere |
S2AxisFieldTri (S2AxisFieldTri) |
a class represeneting a function on the sphere |
S2DeLaValleePoussin |
extract parameter and halfwidth |
S2Fun (S2Fun) |
a class represeneting a function on the sphere |
S2Fun_index |
*|S2Fun|* |
S2FunHandle (S2FunHandle) |
a class represeneting a function on the sphere |
S2FunHarmonic (S2FunHarmonic) |
a class representing a function on the sphere |
S2FunHarmonicSym (S2FunHarmonicSym) |
a class represeneting a symmetrised function on the sphere |
S2FunTri (S2FunTri) |
a class represeneting a function on the sphere |
S2Grid (S2Grid) |
Syntax S2Grid(theta,rho) % fills a Sphere with N--nodes regularS2Grid('resolution',5*degree) % construct regular
polar and azimuthal spacing equispacedS2Grid('resolution',5*degree) % construct equispaced nodes
|
S2Kernel (S2Kernel) |
S2Kernel is a class. S2K = S2Kernel(A) |
S2Triangulation (S2Triangulation) |
a class represeneting a triangulation on the sphere |
S2VectorFieldHarmonic (S2VectorFieldHarmonic) |
a class represeneting a function on the sphere |
S2VectorFieldTri (S2VectorFieldTri) |
a class represeneting a function on the sphere |
SantaFe |
the SantaFe-sample ODF |
save_sparse |
convert sparse matrix to jc, ir, pr |
saveFigure |
save figure as graphics file |
saveGrainSet_hdf5 |
Save GrainSet object to HDF5 format |
scale (PoleFigure) |
scale polefigure by a factor |
scaleBar |
Inserts a scale bar on the current ebsd or grain map. |
scatter (Miller) |
plot Miller indece |
scatter (orientation) |
plots orientations in 3d |
scatter (quaternion) |
plot function |
scatter (vector3d) |
Syntax scatter(v) % plot the directions v scatter(v,data) % colorize directions according to data scatter(v,'label',text)
% plot text below markers scatter(v,'label',text,'textaboveMarker') % plot text above markers
|
scatter3d (vector3d) |
plot spherical data |
SchmidFactor (slipSystem) |
compute the Schmid factor |
SchmidTensor |
computes the Schmidt tensor |
sectionLabels |
sectionLabels is a function. [symbol, labelx, labely] = sectionLabels(type) |
segLength (grainBoundary) |
length of a boundary segment |
select (PoleFigure) |
select PoleFigures |
selectInteractive (EBSD) |
select interactively a rectangular region of an EBSD data set |
selectInteractive (grain2d) |
select interactively a rectangular region of an EBSD data set |
selectMaxbyColumn |
find maximum in each row |
selectMaxbyRow |
find maximum in each column |
selectMinbyColumn |
find minimum in each column |
selectMinbyRow |
find minimum in each row |
selector_old (grain2d) |
Grain Selector |
selectPolygon |
select a polygon by mouse |
set_default_option |
set option in option list if not yet present |
set_option |
set option in option list |
setappdata |
make setappdata work with multiple handles |
setCamera |
set Camera according to xAxis and zAxis position |
setColorRange |
set color range for figures |
setdiff (vector3d) |
remove vectors v2 from a set of vectors v1 |
setFont |
FontName = "Consolas"; FontName = "Nimbus Mono PS"; |
setMTEXpref |
setMTEXpref is a function. setMTEXpref(pref, value) |
setNull |
set approx zero to exact zero |
setOption |
set option in option list |
setSubSet (quaternion) |
indexing of quaternions |
shapeFactor (grain2d) |
calculates the shapefactor of the grain-polygon, without Holes |
shearDirection (velocityGradientTensor) |
shear direction |
shearModulus (complianceTensor) |
shear modulus for an compliance tensor |
shearModulus (stiffnessTensor) |
shear modulus for an elasticity tensor |
shift (EBSD) |
shift spatial ebsd-data about (x,y) |
shift (S1Grid) |
shifts S1Grid by delta |
sigmaSections |
sigmaSections is a class. oS = sigmaSections(varargin) |
simultaniousCG (S2FunHarmonic) |
calculates the minimum of a spherical harminc Syntax [v,pos] = simultaniousCG(sF) % the position where the minimum is atained |
size (tensor) |
overloads size |
size (crystalShape) |
overloads size |
size (dislocationSystem) |
overloads size |
size (fibre) |
overloads size |
size (quaternion) |
overloads size |
size (slipSystem) |
overloads size |
size (vector3d) |
overloads size |
size2str |
convert size to string |
slipSystem (slipSystem) |
class representing slip systems |
slope (ODF) |
| grad(r) | |
smiley (S2Fun) |
S2Fun.smiley is a function. f = smiley(v, varargin) |
smooth (EBSD) |
smooth spatial EBSD |
smooth (EBSDhex) |
smooth spatial EBSD data |
smooth (EBSDsquare) |
smooth spatial EBSD data |
smooth (grain2d) |
constraint laplacian smoothing of grain boundaries and inner boundaries. |
smooth (BinghamComponent) |
smooth ODF component |
smooth (FourierComponent) |
smooth ODF component |
smooth (ODF) |
smooth ODF |
smooth (femComponent) |
smooth ODF component |
smooth (fibreComponent) |
smooth ODF component |
smooth (uniformComponent) |
smooth ODF component |
smooth (unimodalComponent) |
smooth ODF component |
smooth (Miller) |
plot Miller indece |
smooth (vector3d) |
low level function for plotting functions on the sphere |
smoothn |
SMOOTHN Robust spline smoothing for 1-D to N-D data. SMOOTHN provides a fast, automatized and robust discretized spline smoothing
for data of arbitrary dimension.
|
SO3Grid (SO3Grid) |
represent orientations in a gridded structure to allow quick access |
SobolevKernel |
SobolevKernel is a class. psi = SobolevKernel(s, varargin) |
sparse (vector3d) |
SPARSE Create sparse matrix. S = SPARSE(X) converts a sparse or full matrix to sparse form by squeezing out any zero elements. |
sparseConcat |
sparseConcat is a function. newSparse = sparseConcat(oldSparse, newRows, newCols, newVals, newSize) |
spatialProfile (EBSD) |
select EBSD data along line segments |
specimenSymmetry (specimenSymmetry) |
defines a specimen symmetry |
spectralTransmission (refractiveIndexTensor) |
Syntax rgb = spectralTransmission(rI,vprop,p,thickness) |
spectralTransmissionColorKey |
spectralTransmissionColorKey is a class. oM = spectralTransmissionColorKey(rI, thickness, varargin) |
sphereVolume (orientation) |
ratio of orientations with a certain orientation |
sphericalClebschGordan |
use global wigner3j |
sphericalPlot |
sphericalPlot is responsible for visualizing spherical data |
sphericalProjection |
sphericalProjection |
sphericalRegion (sphericalRegion) |
sphericalRegion implements a region on the sphere The region is bounded by small circles given by there normal vectors and
the maximum inner product, i.e., all points v inside a region satisfy the conditions dot(v, N) <= alpha
|
sphericalY |
spherical harmonics of degree l |
spinTensor (spinTensor) |
Syntax |
splineFilter |
smoothes quaternions by projecting them into tangential space and performing there smoothing spline approximation |
splitdata |
make n - partitions of a list, returns its indices |
spotColorKey |
Detailed explanation goes here |
spy (SO3Grid) |
spy distance matrix |
sqrt (S2FunHarmonic) |
square root of a function Syntax sF = sqrt(sF) sF = sqrt(sF, 'bandwidth', bandwidth) |
sqrtm (tensor) |
matrix exponential of a tensor |
squareProjection |
equal area projection |
SquareSingularityKernel |
extract parameter and halfwidth |
steepestDescent (S2FunHarmonic) |
calculates the minimum of a spherical harminc Syntax [v,pos] = steepestDescent(sF) % the position where the minimum is atained |
steepestDescent (S2FunHarmonicSym) |
calculates the minimum of a spherical harminc Syntax [f,pos] = steepestDescent(sF) % the position where the minimum is atained |
steepestDescent (ODF) |
find maximum with steepest descent |
steepestDescentX (ODF) |
find maximum with steepest descent |
stiffnessTensor (stiffnessTensor) |
stiffnessTensor is a class. sT = stiffnessTensor(varargin) |
strainRate (velocityGradientTensor) |
strain rate |
strainRateTensor (strainRateTensor) |
strainRateTensor is the symmetric part of a velocity gradient tensor |
strainTensor (strainTensor) |
strainTensor is a class. sT = strainTensor(varargin) |
stressTensor (stressTensor) |
stressTensor is a class. sT = stressTensor(varargin) |
string2Miller |
converts string to Miller indece |
subGrid (S1Grid) |
epsilon - neighborhood of a point in the grid |
subGrid (S2Grid) |
subgrid |
subGrid (SO3Grid) |
sub-SO3Grid as epsilon neigborhood of a node |
submatrix |
B = A(ind) with size as A if possible |
subsasgn (S2FunHarmonic) |
overloads subsasgn |
subsasgn (EBSD) |
overloads subsasgn |
subsasgn (grain2d) |
overloads subsasgn |
subsasgn (grainBoundary) |
overloads subsasgn |
subsasgn (triplePointList) |
overloads subsasgn |
subsasgn (PoleFigure) |
overloads subsasgn |
subsasgn (tensor) |
overloads subsasgn |
subsasgn (S2Grid) |
overloads subsasgn |
subsasgn (SO3Grid) |
overloads subsasgn |
subsasgn (dislocationSystem) |
overloads subsasgn |
subsasgn (quaternion) |
overloads subsasgn |
subsasgn (rotation) |
overloads subsasgn |
subsasgn (slipSystem) |
overloads subsasgn |
subsasgn (vector3d) |
overloads subsasgn |
subSet (EBSD) |
indexing of EBSD data |
subSet (grain2d) |
|
subSet (grainBoundary) |
restrict boundary |
subSet (triplePointList) |
restrict boundary |
subSet (crystalShape) |
crystalShape/subSet is a function. cS = subSet(cS, NSelect) |
subSet (dislocationSystem) |
subindex vector3d |
subSet (fibre) |
subindex vector3d |
subSet (quaternion) |
indexing of quaternions |
subSet (rotation) |
indexing of rotation |
subSet (slipSystem) |
subindex vector3d |
subSet (vector3d) |
subindex vector3d |
subsind (EBSD) |
subindexing of EBSD data |
subsind (EBSDhex) |
subindexing of EBSD data |
subsind (EBSDsquare) |
subindexing of EBSD data |
subsref (S2FunHarmonic) |
overloads subsref |
subsref (EBSD) |
indexing of EBSD data |
subsref (grain2d) |
implements grains(1:3) |
subsref (grainBoundary) |
implements gB(1:10) |
subsref (triplePointList) |
implements tP(1:10) |
subsref (PoleFigure) |
overide polefigure() and polefigure{} |
subsref (tensor) |
overloads subsref |
subsref (S2Grid) |
overloads subsref |
subsref (SO3Grid) |
overloads subsref |
subsref (crystalShape) |
overloads subsref |
subsref (crystalSymmetry) |
overloads subsref |
subsref (dislocationSystem) |
overloads subsref |
subsref (fibre) |
overloads subsref |
subsref (quaternion) |
overloads subsref |
subsref (rotation) |
overloads subsref |
subsref (slipSystem) |
overloads subsref |
subsref (symmetry) |
overloads subsref |
subsref (vector3d) |
overloads subsref |
sum (S2Fun) |
calculates the mean value for an univariate S2Fun or calculates the mean along a specified dimension fo a multimodal S2Fun |
sum (S2FunHarmonic) |
calculates the integral for an univariate S2Fun or sums up along a specified dimension fo a multimodal S2Fun |
sum (tensor) |
sum of a list of tensors |
sum (quaternion) |
overloads sum |
sum (vector3d) |
sum of vectors |
surf (S2Fun) |
SURF 3-D colored surface. SURF(X,Y,Z,C) plots the colored parametric surface defined by four matrix arguments. The view
point is specified by VIEW. The axis labels are determined by the range of X, Y and Z, or by the current setting of AXIS.
The color scaling is determined by the range of C, or by the current setting of CAXIS. The scaled color values are used
as indices into the current COLORMAP. The shading model is set by SHADING.
|
surf (Miller) |
Syntax |
surf (vector3d) |
Syntax |
switchUnit |
returns the closest length to a known unit. For example, 10e3m will give 10km. |
sym (tensor) |
the symmetric part S = 0.5(T + T.') of a tensor |
symmetrise (S2FunHarmonic) |
symmetrises a function with respect to a symmetry or a direction |
symmetrise (tensor) |
symmetrise a tensor according to its crystal symmetry |
symmetrise (Miller) |
directions symmetrically equivalent to m |
symmetrise (dislocationSystem) |
find all symmetrically equivalent slips systems |
symmetrise (fibre) |
all crystallographically equivalent fibres |
symmetrise (orientation) |
all crystallographically equivalent orientations |
symmetrise (quaternion) |
symmetrcially equivalent orientations |
symmetrise (slipSystem) |
find all symmetrically equivalent slips systems |
symmetrise (vector3d) |
symmetrcially equivalent directions and its multiple |
symmetry (symmetry) |
Supported Symmetries |
Back to Top
T
tensor (tensor) |
constructor |
tensor (dislocationSystem) |
tensor representation of a dislocation system |
tensorSize (tensor) |
overloads size |
text (grain2d) |
plot directions at grain centers |
text (Miller) |
plot Miller indece |
text (vector3d) |
display a text in a spherical plot |
text3 (vector3d) |
plot three dimensional arrows |
textureindex (ODF) |
caclulate texture index of ODF |
theta (S2VectorField) |
Gives the vector in the tangential plane in v in the direction theta |
times (S2FunHarmonic) |
overloads sF1 .* sF2 |
times (S2FunHarmonicSym) |
overloads sF1 .* sF2 |
times (S2FunTri) |
.* Array multiply. X.*Y denotes element-by-element multiplication. X and Y must have compatible sizes. In the simplest cases,
they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension
sizes of the inputs are either the same or one of them is 1.
|
times (S2VectorFieldHarmonic) |
Syntax sVF = sVF1.*sVF2 sVF = a.*sVF1 sVF = sVF1.*a |
times (S2VectorFieldTri) |
Syntax sVF = sVF .* sF sVF = sVF .* a |
times (ODF) |
scaling of the ODF |
times (PoleFigure) |
implements pf1 .* b and a .* pf2 |
times (tensor) |
multiply a tensor by a scalar |
times (crystalShape) |
.* Array multiply. X.*Y denotes element-by-element multiplication. X and Y must have compatible sizes. In the simplest cases,
they can be the same size or one can be a scalar. Two inputs have compatible sizes if, for every dimension, the dimension
sizes of the inputs are either the same or one of them is 1.
|
times (orientation) |
vec = ori .* Miller |
times (quaternion) |
quaternion .* quaternion and quaternion .* vector3d |
times (rotation) |
r = a .* b |
times (vector3d) |
.* - componenwtise multiplication |
times_outer |
times_outer is a function. x = times_outer(a, b) |
trace (tensor) |
compute the traces of a rank 2 tensor |
trace (slipSystem) |
trace of the slip plane in the surface normal to n |
transformationMatrix (crystalSymmetry) |
compute the transformation matrix from cs1 to cs2 |
transformReferenceFrame (tensor) |
set properties of a tensor variable |
transformReferenceFrame (Miller) |
change reference frame while keeping hkl or uvw |
transformReferenceFrame (orientation) |
change reference frame of an orientation |
transpose (S2FunHarmonic) |
overloads transpose |
transpose (tensor) |
transpose a list of a tensors |
transpose (dislocationSystem) |
transpose list of slipSystem |
transpose (fibre) |
transpose list of slipSystem |
transpose (quaternion) |
transpose array of quaternions |
transpose (rotation) |
transpose array of rotations |
transpose (slipSystem) |
transpose list of slipSystem |
transpose (vector3d) |
transpose vector |
triangle (sphericalRegion) |
define a spherical triangle by its vertices |
triplePointList (triplePointList) |
grainBoundary list of grain boundaries in 2-D |
truncate (S2FunHarmonic) |
truncate neglectable coefficients this includes a bit of regularisation |
TSLDirectionKey |
converts directions to rgb values |
Back to Top
U
uiimport |
overload standard MATLAB uiimport |
uminus (S2FunHarmonic) |
Syntax sF = -sF |
uminus (S2FunTri) |
- Unary minus. -A negates the elements of A. |
uminus (S2VectorFieldHarmonic) |
Syntax sVF = -sVF |
uminus (S2VectorFieldTri) |
- Unary minus. -A negates the elements of A. |
uminus (ODF) |
superposeing two ODFs |
uminus (PoleFigure) |
implements -pf |
uminus (tensor) |
unary minus |
uminus (dislocationSystem) |
overloads unitary minus |
uminus (quaternion) |
overload unitary minus |
uminus (rotation) |
implements -rotation |
uminus (slipSystem) |
overloads unitary minus |
uminus (vector3d) |
overloads unitary minus |
uniformComponent (uniformComponent) |
uniformComponent is a class. odf = uniformComponent(cs, ss, varargin) |
uniformODF |
get crystal and specimen symmetry |
unimodalComponent (unimodalComponent) |
unimodalComponent is a class. component = unimodalComponent(center, psi, weights) |
unimodalODF |
define a unimodal ODF |
union (PoleFigure) |
crytsallographic direction to one |
union (symmetry) |
returns the union of two symmetry groups |
unique (PoleFigure) |
remove dublicated points in a polefigure |
unique (Miller) |
disjoint list of Miller indices |
unique (orientation) |
disjoint list of quaternions |
unique (quaternion) |
disjoint list of quaternions |
unique (rotation) |
disjoint list of rotations |
unique (vector3d) |
disjoint list of vectors |
updateUnitCell (EBSD) |
this function should be called after the spatial coordinates of an EBSD data set have been modified |
UpDown |
UpDown is a function. out = UpDown(in) |
Back to Top
V
variants (orientation) |
variants of an orientation relationship |
varlink |
link to a variable |
vdisp |
vdisp is a function. vdisp(s, varargin) |
vec2cell |
vec2cell is a function. c = vec2cell(v) |
vec42quat |
returns a quaternion q with q u_1 = v1 and q u2 = v2 |
vector3d (tensor) |
convert rank one tensors to vector3d |
vector3d (vector3d) |
Constructor |
velocity (complianceTensor) |
computes the elastic wave velocity(km/s) from the elastic stiffness Cijkl tensor and density (g/cm3) |
velocity (stiffnessTensor) |
computes the elastic wave velocity(km/s) from the elastic stiffness Cijkl tensor and density (g/cm3) |
velocityGradientTensor (velocityGradientTensor) |
velocityGradientTensor is a class. L = velocityGradientTensor(varargin) |
vertcat (S2FunHarmonic) |
overloads vertcat |
vertcat (tensor) |
overloads [T1,T2,T3..] |
vertcat (dislocationSystem) |
overloads [v1,v2,v3..] |
vertcat (fibre) |
overloads [v1,v2,v3..] |
vertcat (quaternion) |
implements [q1;q2;q3..] |
vertcat (slipSystem) |
overloads [v1,v2,v3..] |
vertcat (vector3d) |
overloads [v1,v2,v3..] |
viridisColorMap |
viridisColorMap is a function. varargout = viridisColorMap(varargin) |
Voigt (tensor) |
tensor/Voigt is a function. V = Voigt(T) |
volume (S2FunHarmonic) |
S2FunHarmonic/volume is a function. sF = volume(sF1, center, radius) |
volume (S2FunTri) |
S2FunTri/volume is a function. sF = volume(sF1, center, radius) |
volume (ODF) |
ratio of orientations with a certain orientation |
volume (ODFComponent) |
get resolution |
volume (uniformComponent) |
for large angles or specimen symmetry take the quadrature based algorithm |
volume (unimodalComponent) |
for large angles or specimen symmetry take the quadrature based algorithm |
volume (orientation) |
ratio of orientations with a certain orientation |
volume (orientationRegion) |
volume of an orientation region |
volume (sphericalRegion) |
volume of a spherical region |
volume (kernel) |
kernel/volume is a function. [vol, dist] = volume(psi, radius, dist) |
volumeCompressibility (complianceTensor) |
computes the volume compressibility of an elasticity tensor |
volumeCompressibility (stiffnessTensor) |
volume compressibility of an elasticity stiffness tensor |
vonMisesFisherKernel |
extract parameter and halfwidth |
vorticity (velocityGradientTensor) |
vorticity Gamma |
Back to Top
W
Back to Top
X
Back to Top
Y
YoungsModulus (complianceTensor) |
Young's modulus for an elasticity tensor |
YoungsModulus (stiffnessTensor) |
Young's modulus for an elasticity tensor |
yvector |
vector (0,1,0) |
Back to Top
Z
Back to Top