gtCrystCalculateSymmetryOperators / gtCrystCalculateReflections : added...

gtCrystCalculateSymmetryOperators / gtCrystCalculateReflections : added argument 'phaseid' to simplify use of the function. It will read spacegroup and crystal system from parameters.cryst(phaseid).

Signed-off-by: Laura Nervo <laura.nervo@esrf.fr>

zUtil_Cryst/gtCrystCalculateReflections.m

-function list = gtCrystCalculateReflections(latticepar, mintheta, maxtheta, sg, filename)
+function list = gtCrystCalculateReflections(phaseid, latticepar, sg, mintheta, maxtheta, filename)
 % GTCRYSTCALCULATEREFLECTIONS  Calculate the reflections list using python 
 %                              from xfab library in fable
-%     list = gtCrystCalculateReflections(latticepar, mintheta, maxtheta, sg, filename)
-%     --------------------------------------------------------------------------------
+%     list = gtCrystCalculateReflections(phaseid, [latticepar], [sg], [mintheta], [maxtheta], filename)
+%     -------------------------------------------------------------------------------------------------
 %
 %     INPUT: 
+%       phaseid         = phase number {1}
 %       latticepar      = lattice parameters <double 1x6>
+%       sg              = spacegroup number <int>
 %       mintheta        = minimum sin(theta)/lambda allowed <double> {0.0001}
 %       maxtheta        = maximum sin(theta)/lambda allowed <double>
-%       sg              = spacegroup number <int>
 %       filename        = filename for reflections list <string> {'reflections_*.txt'}
 %
 %     OUTPUT:
@@ -27,35 +28,37 @@ function list = gtCrystCalculateReflections(latticepar, mintheta, maxtheta, sg,
 %
 %     Version 001 03-12-2012 by LNervo
 
+if ~exist('phaseid','var') || isempty(phaseid)
+    phaseid = 1;
+end
+
+parameters = [];
+load('parameters.mat');
+energy = parameters.acq.energy;
 
 if ~exist('latticepar','var') || isempty(latticepar)
-    parameters = [];
-    load parameters;
-    latticepar = parameters.cryst(1).latticepar;
+    latticepar = parameters.cryst(phaseid).latticepar;
+end
+if ~exist('sg','var') || isempty(sg)
+    sg = parameters.cryst(phaseid).spacegroup;
 end
 if ~exist('mintheta','var') || isempty(mintheta)
-    mintheta = 0.0001;
+    tmp = parameters.labgeo.detanglemin/2;
+    mintheta = sind(tmp)/gtConvEnergyToWavelength(energy);
 end
 if ~exist('maxtheta','var') || isempty(maxtheta)
-    load parameters;
-    tmp = parameters.labgeo.detanglemax;
-    maxtheta = sind(tmp)/gtConvEnergyToWavelength(parameters.acq.energy);
+    tmp = parameters.labgeo.detanglemax/2;
+    maxtheta = sind(tmp)/gtConvEnergyToWavelength(energy);
     clear tmp;
 end
-if ~exist('sg','var') || isempty(sg)
-    load parameters;
-    sg = parameters.cryst(1).spacegroup;
-end
 if ~exist('filename','var') || isempty(filename)
     filename = 'reflections_';
 end
 
-parameters = [];
-load('parameters.mat');
-energy = parameters.acq.energy;
 
 latticepar_str = sprintf('%f ',latticepar);
-latticepar_str = strtrim(latticepar_st);
+latticepar_str = strtrim(latticepar_str);
+
 % python script to be used
 global GT_MATLAB_HOME;
 script_file = fullfile(GT_MATLAB_HOME, 'zUtil_Python', 'reflections_list.py');
@@ -108,10 +111,13 @@ end
 list.latticepar  = latticepar;
 list.spacegroup  = sg;
 list.energy      = energy;
-list.hkl         = hkl';
-list.hklsp       = hklsp';
-list.hkil        = hkil';
-list.hkilsp      = hkilsp';
+if strcmp(parameters.cryst(phaseid).crystal_system, 'hexagonal')
+    list.hkl         = hkil';
+    list.hklsp       = hkilsp';
+else
+    list.hkl        = hkl';
+    list.hklsp      = hklsp';
+end
 list.theta       = theta';
 list.thetasp     = thetasp';
 list.thetatype   = thetatype';

zUtil_Cryst/gtCrystCalculateSymmetryOperators.m

-function [symm, opsym] = gtCrystCalculateSymmetryOperators(sg, crystal_system)
+function [symm, opsym] = gtCrystCalculateSymmetryOperators(phaseid, sg, crystal_system)
 % GTCRYSTCALCULATEREFLECTIONS  Calculate the symmetry operators list using python 
 %                              from xfab library in fable (sg.py)
-%     [symm, opsym] = gtCrystCalculateSymmetryOperators(sg, crystal_system)
-%     ---------------------------------------------------------------------
+%     [symm, opsym] = gtCrystCalculateSymmetryOperators(phaseid, [sg], [crystal_system])
+%     ----------------------------------------------------------------------------------
+%     If spacegroup and crystal_system are not provided, they are read from
+%     parameters.mat.
 %
 %     INPUT: 
-%       sg             = spacegroup number <int>
-%       crystal_system = crystal system <string>
+%       phaseid        = <double>     phase number {1}
+%       sg             = <double>     spacegroup number
+%       crystal_system = <string>     crystal system
 %     
 %     OUTPUT:
 %       symm = <struct 1xN> contains :
@@ -15,19 +18,24 @@ function [symm, opsym] = gtCrystCalculateSymmetryOperators(sg, crystal_system)
 %                   indistinguishable lattice permutations <double 3x3>
 %       opsym = <struct 1xM> contains :
 %            .sg_rot   = rotations (complete list using symmetry operators) <double 3x3>
-%            .sg_trans = transition values from symmetry operators <double 1x3>
+%            .sg_trans = translation values from symmetry operators <double 1x3>
 %
 %
 %     Version 001 10-12-2012 by LNervo
 
+if ~exist('phaseid','var') || isempty(phaseid)
+    phaseid = 1;
+end
 
 if ~exist('sg','var') || isempty(sg)
-    load parameters;
-    sg = parameters.cryst(1).spacegroup;
-end
-if ~exist('crystal_system','var') || isempty(crystal_system)
-    load parameters;
-    crystal_system = parameters.cryst(1).crystal_system;
+    parameters = [];
+    load('parameters.mat');
+    sg = parameters.cryst(phaseid).spacegroup;
+    
+    if ~exist('crystal_system','var') || isempty(crystal_system)
+        crystal_system = parameters.cryst(1).crystal_system;
+    end
+
 end
 
 global GT_MATLAB_HOME;