static Crystal *new_shifted_crystal(Crystal *cr, int refine, double incr_val)
{
Crystal *cr_new;
double r;
UnitCell *cell;
cr_new = crystal_copy(cr);
if ( cr_new == NULL ) {
ERROR("Failed to allocate crystal.\n");
return NULL;
}
crystal_set_image(cr_new, crystal_get_image(cr));
r = crystal_get_profile_radius(cr_new);
switch ( refine ) {
case REF_ASX :
case REF_ASY :
case REF_ASZ :
case REF_BSX :
case REF_BSY :
case REF_BSZ :
case REF_CSX :
case REF_CSY :
case REF_CSZ :
cell = new_shifted_cell(crystal_get_cell(cr), refine,
incr_val);
crystal_set_cell(cr_new, cell);
break;
case REF_R :
cell = cell_new_from_cell(crystal_get_cell(cr));
crystal_set_cell(cr_new, cell);
crystal_set_profile_radius(cr_new, r + incr_val);
break;
default :
ERROR("Can't shift %i\n", refine);
break;
}
return cr_new;
}
/* Apply the given shift to the 'k'th parameter of 'image'. */
static void apply_shift(Crystal *cr, int k, double shift)
{
double t;
struct image *image = crystal_get_image(cr);
switch ( k ) {
case GPARAM_DIV :
if ( isnan(shift) ) {
ERROR("NaN divergence shift\n");
} else {
image->div += shift;
if ( image->div < 0.0 ) image->div = 0.0;
}
break;
case GPARAM_R :
t = crystal_get_profile_radius(cr);
t += shift;
crystal_set_profile_radius(cr, t);
break;
case GPARAM_ASX :
case GPARAM_ASY :
case GPARAM_ASZ :
case GPARAM_BSX :
case GPARAM_BSY :
case GPARAM_BSZ :
case GPARAM_CSX :
case GPARAM_CSY :
case GPARAM_CSZ :
apply_cell_shift(crystal_get_cell(cr), k, shift);
break;
default :
ERROR("No shift defined for parameter %i\n", k);
abort();
}
}
int main(int argc, char *argv[])
{
struct image image;
const double incr_frac = 1.0/1000000.0;
double incr_val;
double ax, ay, az;
double bx, by, bz;
double cx, cy, cz;
UnitCell *cell;
Crystal *cr;
struct quaternion orientation;
int i;
int fail = 0;
int quiet = 0;
int plot = 0;
int c;
gsl_rng *rng;
const struct option longopts[] = {
{"quiet", 0, &quiet, 1},
{"plot", 0, &plot, 1},
{0, 0, NULL, 0}
};
while ((c = getopt_long(argc, argv, "", longopts, NULL)) != -1) {
switch (c) {
case 0 :
break;
case '?' :
break;
default :
ERROR("Unhandled option '%c'\n", c);
break;
}
}
image.width = 1024;
image.height = 1024;
image.det = simple_geometry(&image);
image.det->panels[0].res = 13333.3;
image.det->panels[0].clen = 80e-3;
image.det->panels[0].coffset = 0.0;
image.lambda = ph_en_to_lambda(eV_to_J(8000.0));
image.div = 1e-3;
image.bw = 0.01;
image.filename = malloc(256);
cr = crystal_new();
if ( cr == NULL ) {
ERROR("Failed to allocate crystal.\n");
return 1;
}
crystal_set_mosaicity(cr, 0.0);
crystal_set_profile_radius(cr, 0.005e9);
crystal_set_image(cr, &image);
cell = cell_new_from_parameters(10.0e-9, 10.0e-9, 10.0e-9,
deg2rad(90.0),
deg2rad(90.0),
deg2rad(90.0));
rng = gsl_rng_alloc(gsl_rng_mt19937);
for ( i=0; i<2; i++ ) {
UnitCell *rot;
double val;
PartialityModel pmodel;
if ( i == 0 ) {
pmodel = PMODEL_SCSPHERE;
STATUS("Testing SCSphere model:\n");
} else if ( i == 1 ) {
pmodel = PMODEL_SCGAUSSIAN;
STATUS("Testing SCGaussian model.\n");
} else {
ERROR("WTF?\n");
return 1;
}
orientation = random_quaternion(rng);
rot = cell_rotate(cell, orientation);
crystal_set_cell(cr, rot);
cell_get_reciprocal(rot,
&ax, &ay, &az, &bx, &by,
&bz, &cx, &cy, &cz);
incr_val = incr_frac * image.div;
val = test_gradients(cr, incr_val, REF_DIV, "div", "div",
pmodel, quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * crystal_get_profile_radius(cr);
val = test_gradients(cr, incr_val, REF_R, "R", "R", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * ax;
val = test_gradients(cr, incr_val, REF_ASX, "ax*", "x", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * bx;
val = test_gradients(cr, incr_val, REF_BSX, "bx*", "x", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * cx;
val = test_gradients(cr, incr_val, REF_CSX, "cx*", "x", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * ay;
val = test_gradients(cr, incr_val, REF_ASY, "ay*", "y", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * by;
val = test_gradients(cr, incr_val, REF_BSY, "by*", "y", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * cy;
val = test_gradients(cr, incr_val, REF_CSY, "cy*", "y", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * az;
val = test_gradients(cr, incr_val, REF_ASZ, "az*", "z", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * bz;
val = test_gradients(cr, incr_val, REF_BSZ, "bz*", "z", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
incr_val = incr_frac * cz;
val = test_gradients(cr, incr_val, REF_CSZ, "cz*", "z", pmodel,
quiet, plot);
if ( val < 0.99 ) fail = 1;
}
gsl_rng_free(rng);
return fail;
}
static void read_crystal(Stream *st, struct image *image, StreamReadFlags srf)
{
char line[1024];
char *rval = NULL;
struct rvec as, bs, cs;
int have_as = 0;
int have_bs = 0;
int have_cs = 0;
int have_latt = 0;
int have_cen = 0;
int have_ua = 0;
char centering = 'P';
char unique_axis = '*';
LatticeType lattice_type = L_TRICLINIC;
Crystal *cr;
int n;
Crystal **crystals_new;
cr = crystal_new();
if ( cr == NULL ) {
ERROR("Failed to allocate crystal!\n");
return;
}
do {
float u, v, w, lim, rad;
char c;
rval = fgets(line, 1023, st->fh);
/* Trouble? */
if ( rval == NULL ) break;
chomp(line);
if ( (srf & STREAM_READ_UNITCELL)
&& (sscanf(line, "astar = %f %f %f", &u, &v, &w) == 3) )
{
as.u = u*1e9; as.v = v*1e9; as.w = w*1e9;
have_as = 1;
}
if ( (srf & STREAM_READ_UNITCELL)
&& (sscanf(line, "bstar = %f %f %f", &u, &v, &w) == 3) )
{
bs.u = u*1e9; bs.v = v*1e9; bs.w = w*1e9;
have_bs = 1;
}
if ( (srf & STREAM_READ_UNITCELL)
&& (sscanf(line, "cstar = %f %f %f", &u, &v, &w) == 3) )
{
cs.u = u*1e9; cs.v = v*1e9; cs.w = w*1e9;
have_cs = 1;
}
if ( (srf & STREAM_READ_UNITCELL)
&& (sscanf(line, "centering = %c", &c) == 1) )
{
if ( !have_cen ) {
centering = c;
have_cen = 1;
} else {
ERROR("Duplicate centering ignored.\n");
}
}
if ( (srf & STREAM_READ_UNITCELL)
&& (sscanf(line, "unique_axis = %c", &c) == 1) )
{
if ( !have_ua ) {
unique_axis = c;
have_ua = 1;
} else {
ERROR("Duplicate unique axis ignored.\n");
}
}
if ( (srf & STREAM_READ_UNITCELL)
&& (strncmp(line, "lattice_type = ", 15) == 0) )
{
if ( !have_latt ) {
lattice_type = lattice_from_str(line+15);
have_latt = 1;
} else {
ERROR("Duplicate lattice type ignored.\n");
}
}
if ( strncmp(line, "num_saturated_reflections = ", 28) == 0 ) {
int n = atoi(line+28);
crystal_set_num_saturated_reflections(cr, n);
}
if ( sscanf(line, "diffraction_resolution_limit = %f nm^-1",
&lim) == 1 ) {
crystal_set_resolution_limit(cr, lim*1e9);
}
if ( sscanf(line, "profile_radius = %f nm^-1", &rad) == 1 ) {
crystal_set_profile_radius(cr, rad*1e9);
}
if ( (strcmp(line, REFLECTION_START_MARKER) == 0)
&& (srf & STREAM_READ_REFLECTIONS) )
{
RefList *reflist;
/* The reflection list format in the stream diverges
* after 2.2 */
if ( AT_LEAST_VERSION(st, 2, 2) ) {
reflist = read_stream_reflections(st->fh);
} else {
reflist = read_stream_reflections_2_1(st->fh);
}
if ( reflist == NULL ) {
ERROR("Failed while reading reflections\n");
break;
}
crystal_set_reflections(cr, reflist);
}
if ( strcmp(line, CRYSTAL_END_MARKER) == 0 ) break;
} while ( 1 );
if ( have_as && have_bs && have_cs ) {
UnitCell *cell;
cell = crystal_get_cell(cr);
if ( cell != NULL ) {
ERROR("Duplicate cell found in stream!\n");
ERROR("I'll use the most recent one.\n");
cell_free(cell);
}
cell = cell_new_from_reciprocal_axes(as, bs, cs);
if ( have_cen && have_ua && have_latt ) {
cell_set_centering(cell, centering);
cell_set_unique_axis(cell, unique_axis);
cell_set_lattice_type(cell, lattice_type);
} /* else keep default triclinic P */
crystal_set_cell(cr, cell);
have_as = 0; have_bs = 0; have_cs = 0;
have_latt = 0; have_ua = 0; have_cen = 0;
}
/* Unused at the moment */
crystal_set_mosaicity(cr, 0.0);
/* Add crystal to the list for this image */
n = image->n_crystals+1;
crystals_new = realloc(image->crystals, n*sizeof(Crystal *));
if ( crystals_new == NULL ) {
ERROR("Failed to expand crystal list!\n");
} else {
image->crystals = crystals_new;
image->crystals[image->n_crystals++] = cr;
}
}
