static double test_gradients(Crystal *cr, double incr_val, int refine,
const char *str, const char *file,
PartialityModel pmodel, int quiet, int plot)
{
Reflection *refl;
RefListIterator *iter;
long double *vals[3];
int i;
int *valid;
int nref;
int n_good, n_invalid, n_small, n_nan, n_bad;
RefList *reflections;
FILE *fh = NULL;
int ntot = 0;
double total = 0.0;
char tmp[32];
double *vec1;
double *vec2;
int n_line;
double cc;
reflections = find_intersections(crystal_get_image(cr), cr, pmodel);
crystal_set_reflections(cr, reflections);
nref = num_reflections(reflections);
if ( nref < 10 ) {
ERROR("Too few reflections found. Failing test by default.\n");
return 0.0;
}
vals[0] = malloc(nref*sizeof(long double));
vals[1] = malloc(nref*sizeof(long double));
vals[2] = malloc(nref*sizeof(long double));
if ( (vals[0] == NULL) || (vals[1] == NULL) || (vals[2] == NULL) ) {
ERROR("Couldn't allocate memory.\n");
return 0.0;
}
valid = malloc(nref*sizeof(int));
if ( valid == NULL ) {
ERROR("Couldn't allocate memory.\n");
return 0.0;
}
for ( i=0; i<nref; i++ ) valid[i] = 1;
scan_partialities(reflections, reflections, valid, vals, 1, pmodel);
calc_either_side(cr, incr_val, valid, vals, refine, pmodel);
if ( plot ) {
snprintf(tmp, 32, "gradient-test-%s.dat", file);
fh = fopen(tmp, "w");
}
vec1 = malloc(nref*sizeof(double));
vec2 = malloc(nref*sizeof(double));
if ( (vec1 == NULL) || (vec2 == NULL) ) {
ERROR("Couldn't allocate memory.\n");
return 0.0;
}
n_invalid = 0; n_good = 0;
n_nan = 0; n_small = 0; n_bad = 0; n_line = 0;
i = 0;
for ( refl = first_refl(reflections, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
long double grad1, grad2, grad;
double cgrad;
signed int h, k, l;
get_indices(refl, &h, &k, &l);
if ( !valid[i] ) {
n_invalid++;
i++;
} else {
double r1, r2, p;
grad1 = (vals[1][i] - vals[0][i]) / incr_val;
grad2 = (vals[2][i] - vals[1][i]) / incr_val;
grad = (grad1 + grad2) / 2.0;
i++;
cgrad = p_gradient(cr, refine, refl, pmodel);
get_partial(refl, &r1, &r2, &p);
if ( isnan(cgrad) ) {
n_nan++;
continue;
}
if ( plot ) {
fprintf(fh, "%e %Le\n", cgrad, grad);
}
vec1[n_line] = cgrad;
vec2[n_line] = grad;
n_line++;
if ( (fabs(cgrad) < 5e-8) && (fabs(grad) < 5e-8) ) {
n_small++;
continue;
}
total += fabs(cgrad - grad);
ntot++;
if ( !within_tolerance(grad, cgrad, 5.0)
|| !within_tolerance(cgrad, grad, 5.0) )
{
if ( !quiet ) {
STATUS("!- %s %3i %3i %3i"
" %10.2Le %10.2e ratio = %5.2Lf"
" %10.2e %10.2e\n",
str, h, k, l, grad, cgrad,
cgrad/grad, r1, r2);
}
n_bad++;
} else {
//STATUS("OK %s %3i %3i %3i"
// " %10.2Le %10.2e ratio = %5.2Lf"
// " %10.2e %10.2e\n",
// str, h, k, l, grad, cgrad, cgrad/grad,
// r1, r2);
n_good++;
}
}
}
STATUS("%3s: %3i within 5%%, %3i outside, %3i nan, %3i invalid, "
"%3i small. ", str, n_good, n_bad, n_nan, n_invalid, n_small);
if ( plot ) {
fclose(fh);
}
cc = gsl_stats_correlation(vec1, 1, vec2, 1, n_line);
STATUS("CC = %+f\n", cc);
return cc;
}
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;
}
}