static int check_cell(UnitCell *cell, const char *text)
{
int err = 0;
err = validate_cell(cell);
if ( err ) {
ERROR("%s cell:\n", text);
cell_print(cell);
}
return err;
}
void us_repl(US* us)
{
while (1) {
char buf[1024];
fputs("> ", stdout);
//buf[0] = '\0';
if (!fgets(buf, 1024, stdin)) {
break;
}
parser_parse(us, us->parser, buf);
Cell* c = parser_result(us->parser);
if (!c) {
continue;
}
const Cell* r = cell_eval(us, c, us->env);
cell_print(r, stdout, 1);
}
}
static int check_centering(double a, double b, double c,
double al, double be, double ga,
LatticeType latt, char cen, char ua, gsl_rng *rng)
{
UnitCell *cell, *cref;
UnitCell *n;
UnitCellTransformation *t;
int fail = 0;
int i;
double asx, asy, asz;
double bsx, bsy, bsz;
double csx, csy, csz;
double ax, ay, az;
double bx, by, bz;
double cx, cy, cz;
STATUS(" ---------------> "
"Checking %s %c (ua %c) %5.2e %5.2e %5.2e %5.2f %5.2f %5.2f\n",
str_lattice(latt), cen, ua, a, b, c, al, be, ga);
cref = cell_new_from_parameters(a, b, c,
deg2rad(al), deg2rad(be), deg2rad(ga));
cell_set_lattice_type(cref, latt);
cell_set_centering(cref, cen);
cell_set_unique_axis(cref, ua);
cell = cell_rotate(cref, random_quaternion(rng));
if ( cell == NULL ) return 1;
cell_free(cref);
check_cell(cell, "Input");
n = uncenter_cell(cell, &t);
if ( n != NULL ) {
STATUS("Transformation was:\n");
tfn_print(t);
if ( check_cell(n, "Output") ) fail = 1;
if ( !fail ) cell_print(n);
} else {
fail = 1;
}
cell_get_reciprocal(cell, &asx, &asy, &asz,
&bsx, &bsy, &bsz,
&csx, &csy, &csz);
cell_get_cartesian(n, &ax, &ay, &az,
&bx, &by, &bz,
&cx, &cy, &cz);
fesetround(1); /* Round towards nearest */
for ( i=0; i<100; i++ ) {
signed int h, k, l;
double x, y, z;
double nh, nk, nl;
double dh, dk, dl;
int f = 0;
do {
h = gsl_rng_uniform_int(rng, 30);
k = gsl_rng_uniform_int(rng, 30);
l = gsl_rng_uniform_int(rng, 30);
} while ( forbidden_reflection(cell, h, k, l) );
x = h*asx + k*bsx + l*csx;
y = h*asy + k*bsy + l*csy;
z = h*asz + k*bsz + l*csz;
nh = x*ax + y*ay + z*az;
nk = x*bx + y*by + z*bz;
nl = x*cx + y*cy + z*cz;
dh = nh - lrint(nh);
dk = nk - lrint(nk);
dl = nl - lrint(nl);
if ( fabs(dh) > 0.1 ) f++;
if ( fabs(dk) > 0.1 ) f++;
if ( fabs(dl) > 0.1 ) f++;
if ( f ) {
STATUS("Centered %3i %3i %3i -> "
"Primitive %7.2f %7.2f %7.2f\n",
h, k, l, nh, nk, nl);
fail = 1;
}
}
cell_get_reciprocal(n, &asx, &asy, &asz,
&bsx, &bsy, &bsz,
&csx, &csy, &csz);
cell_get_cartesian(cell, &ax, &ay, &az,
&bx, &by, &bz,
&cx, &cy, &cz);
for ( i=0; i<100; i++ ) {
signed int h, k, l;
double x, y, z;
double nh, nk, nl;
double dh, dk, dl;
int f = 0;
long int ih, ik, il;
h = gsl_rng_uniform_int(rng, 30);
k = gsl_rng_uniform_int(rng, 30);
l = gsl_rng_uniform_int(rng, 30);
x = h*asx + k*bsx + l*csx;
y = h*asy + k*bsy + l*csy;
z = h*asz + k*bsz + l*csz;
nh = x*ax + y*ay + z*az;
nk = x*bx + y*by + z*bz;
nl = x*cx + y*cy + z*cz;
dh = nh - lrint(nh); dk = nk - lrint(nk); dl = nl - lrint(nl);
if ( fabs(dh) > 0.1 ) f++;
if ( fabs(dk) > 0.1 ) f++;
if ( fabs(dl) > 0.1 ) f++;
ih = lrint(nh); ik = lrint(nk); il = lrint(nl);
if ( forbidden_reflection(cell, ih, ik, il) ) {
STATUS("Primitive %3i %3i %3i -> "
"Centered %3li %3li %3li, "
"which is forbidden\n",
h, k, l, ih, ik, il);
fail = 1;
}
if ( f ) {
STATUS("Primitive %3i %3i %3i -> "
"Centered %7.2f %7.2f %7.2f\n",
h, k, l, nh, nk, nl);
fail = 1;
}
}
return fail;
}
int main(int argc, char *argv[])
{
int fail = 0;
struct quaternion orientation;
UnitCell *cell;
double asx, asy, asz;
double bsx, bsy, bsz;
double csx, csy, csz;
double asmag, bsmag, csmag;
double als, bes, gas;
double ax, ay, az;
double bx, by, bz;
double cx, cy, cz;
gsl_rng *rng;
rng = gsl_rng_alloc(gsl_rng_mt19937);
cell = cell_new_from_parameters(27.155e-9, 28.155e-9, 10.987e-9,
deg2rad(90.0),
deg2rad(90.0),
deg2rad(120.0));
if ( cell == NULL ) return 1;
orientation = random_quaternion(rng);
cell = cell_rotate(cell, orientation);
cell_get_reciprocal(cell, &asx, &asy, &asz,
&bsx, &bsy, &bsz,
&csx, &csy, &csz);
asmag = sqrt(pow(asx, 2.0) + pow(asy, 2.0) + pow(asz, 2.0));
bsmag = sqrt(pow(bsx, 2.0) + pow(bsy, 2.0) + pow(bsz, 2.0));
csmag = sqrt(pow(csx, 2.0) + pow(csy, 2.0) + pow(csz, 2.0));
als = angle_between(bsx, bsy, bsz, csx, csy, csz);
bes = angle_between(asx, asy, asz, csx, csy, csz);
gas = angle_between(asx, asy, asz, bsx, bsy, bsz);
STATUS("Separation between (100) planes = %5.2f nm\n", 1e9/asmag);
STATUS("Separation between (010) planes = %5.2f nm\n", 1e9/bsmag);
STATUS("Separation between (001) planes = %5.2f nm\n", 1e9/csmag);
STATUS("Angle between (100) and (010) planes = %5.2f deg\n",
rad2deg(gas));
STATUS("Angle between (100) and (001) planes = %5.2f deg\n",
rad2deg(bes));
STATUS("Angle between (010) and (001) planes = %5.2f deg\n",
rad2deg(als));
cell_free(cell);
cell = cell_new();
if ( cell == NULL ) return 1;
cell_set_reciprocal(cell, asx, asy, asz, bsx, bsy, bsz, csx, csy, csz);
cell_print(cell);
cell_get_cartesian(cell, &ax, &ay, &az,
&bx, &by, &bz,
&cx, &cy, &cz);
STATUS("Cell choice 1:\n");
cell_set_cartesian(cell, ax, ay, az,
bx, by, bz,
cx, cy, cz);
cell_print(cell);
STATUS("Cell choice 2:\n");
cell_set_cartesian(cell, bx, by, bz,
-ax-bx, -ay-by, -az-bz,
cx, cy, cz);
cell_print(cell);
STATUS("Cell choice 3:\n");
cell_set_cartesian(cell, -ax-bx, -ay-by, -az-bz,
ax, ay, az,
cx, cy, cz);
cell_print(cell);
gsl_rng_free(rng);
return fail;
}
int main(int argc, char *argv[])
{
int c;
char *filename = NULL;
char *outfile = NULL;
FILE *fh;
Stream *st;
int config_checkprefix = 1;
int config_basename = 0;
int integrate_saturated = 0;
IndexingMethod *indm;
IndexingPrivate **ipriv;
char *indm_str = NULL;
char *cellfile = NULL;
char *prefix = NULL;
char *speaks = NULL;
char *toler = NULL;
int n_proc = 1;
struct index_args iargs;
char *intrad = NULL;
char *pkrad = NULL;
char *int_str = NULL;
char *tempdir = NULL;
char *int_diag = NULL;
char *geom_filename = NULL;
struct beam_params beam;
int have_push_res = 0;
/* Defaults */
iargs.cell = NULL;
iargs.noisefilter = 0;
iargs.median_filter = 0;
iargs.satcorr = 1;
iargs.tols[0] = 5.0;
iargs.tols[1] = 5.0;
iargs.tols[2] = 5.0;
iargs.tols[3] = 1.5;
iargs.threshold = 800.0;
iargs.min_gradient = 100000.0;
iargs.min_snr = 5.0;
iargs.check_hdf5_snr = 0;
iargs.det = NULL;
iargs.peaks = PEAK_ZAEF;
iargs.beam = &beam;
iargs.hdf5_peak_path = NULL;
iargs.copyme = NULL;
iargs.pk_inn = -1.0;
iargs.pk_mid = -1.0;
iargs.pk_out = -1.0;
iargs.ir_inn = 4.0;
iargs.ir_mid = 5.0;
iargs.ir_out = 7.0;
iargs.use_saturated = 1;
iargs.no_revalidate = 0;
iargs.stream_peaks = 1;
iargs.stream_refls = 1;
iargs.int_diag = INTDIAG_NONE;
iargs.copyme = new_copy_hdf5_field_list();
if ( iargs.copyme == NULL ) {
ERROR("Couldn't allocate HDF5 field list.\n");
return 1;
}
iargs.indm = NULL; /* No default */
iargs.ipriv = NULL; /* No default */
iargs.int_meth = integration_method("rings-nocen", NULL);
iargs.push_res = 0.0;
iargs.highres = +INFINITY;
iargs.fix_profile_r = -1.0;
iargs.fix_bandwidth = -1.0;
iargs.fix_divergence = -1.0;
/* Long options */
const struct option longopts[] = {
/* Options with long and short versions */
{"help", 0, NULL, 'h'},
{"version", 0, NULL, 'v'},
{"input", 1, NULL, 'i'},
{"output", 1, NULL, 'o'},
{"indexing", 1, NULL, 'z'},
{"geometry", 1, NULL, 'g'},
{"pdb", 1, NULL, 'p'},
{"prefix", 1, NULL, 'x'},
{"threshold", 1, NULL, 't'},
{"beam", 1, NULL, 'b'},
/* Long-only options with no arguments */
{"filter-noise", 0, &iargs.noisefilter, 1},
{"no-check-prefix", 0, &config_checkprefix, 0},
{"basename", 0, &config_basename, 1},
{"no-peaks-in-stream", 0, &iargs.stream_peaks, 0},
{"no-refls-in-stream", 0, &iargs.stream_refls, 0},
{"integrate-saturated",0, &integrate_saturated, 1},
{"no-use-saturated", 0, &iargs.use_saturated, 0},
{"no-revalidate", 0, &iargs.no_revalidate, 1},
{"check-hdf5-snr", 0, &iargs.check_hdf5_snr, 1},
/* Long-only options which don't actually do anything */
{"no-sat-corr", 0, &iargs.satcorr, 0},
{"sat-corr", 0, &iargs.satcorr, 1},
{"no-check-hdf5-snr", 0, &iargs.check_hdf5_snr, 0},
{"use-saturated", 0, &iargs.use_saturated, 1},
/* Long-only options with arguments */
{"peaks", 1, NULL, 2},
{"cell-reduction", 1, NULL, 3},
{"min-gradient", 1, NULL, 4},
{"record", 1, NULL, 5},
{"cpus", 1, NULL, 6},
{"cpugroup", 1, NULL, 7},
{"cpuoffset", 1, NULL, 8},
{"hdf5-peaks", 1, NULL, 9},
{"copy-hdf5-field", 1, NULL, 10},
{"min-snr", 1, NULL, 11},
{"tolerance", 1, NULL, 13},
{"int-radius", 1, NULL, 14},
{"median-filter", 1, NULL, 15},
{"integration", 1, NULL, 16},
{"temp-dir", 1, NULL, 17},
{"int-diag", 1, NULL, 18},
{"push-res", 1, NULL, 19},
{"res-push", 1, NULL, 19}, /* compat */
{"peak-radius", 1, NULL, 20},
{"highres", 1, NULL, 21},
{"fix-profile-radius", 1, NULL, 22},
{"fix-bandwidth", 1, NULL, 23},
{"fix-divergence", 1, NULL, 24},
{0, 0, NULL, 0}
};
/* Short options */
while ((c = getopt_long(argc, argv, "hi:o:z:p:x:j:g:t:vb:",
longopts, NULL)) != -1)
{
switch (c) {
case 'h' :
show_help(argv[0]);
return 0;
case 'v' :
printf("CrystFEL: " CRYSTFEL_VERSIONSTRING "\n");
printf(CRYSTFEL_BOILERPLATE"\n");
return 0;
case 'b' :
ERROR("WARNING: This version of CrystFEL no longer "
"uses beam files. Please remove the beam file "
"from your indexamajig command line.\n");
return 1;
case 'i' :
filename = strdup(optarg);
break;
case 'o' :
outfile = strdup(optarg);
break;
case 'z' :
indm_str = strdup(optarg);
break;
case 'p' :
cellfile = strdup(optarg);
break;
case 'x' :
prefix = strdup(optarg);
break;
case 'j' :
n_proc = atoi(optarg);
break;
case 'g' :
geom_filename = optarg;
break;
case 't' :
iargs.threshold = strtof(optarg, NULL);
break;
case 2 :
speaks = strdup(optarg);
break;
case 3 :
ERROR("The option '--cell-reduction' is no longer "
"used.\n"
"The complete indexing behaviour is now "
"controlled using '--indexing'.\n"
"See 'man indexamajig' for details of the "
"available methods.\n");
return 1;
case 4 :
iargs.min_gradient = strtof(optarg, NULL);
break;
case 5 :
ERROR("The option '--record' is no longer used.\n"
"Use '--no-peaks-in-stream' and"
"'--no-refls-in-stream' if you need to control"
"the contents of the stream.\n");
return 1;
case 6 :
case 7 :
case 8 :
ERROR("The options --cpus, --cpugroup and --cpuoffset"
" are no longer used by indexamajig.\n");
break;
case 9 :
free(iargs.hdf5_peak_path);
iargs.hdf5_peak_path = strdup(optarg);
break;
case 10 :
add_copy_hdf5_field(iargs.copyme, optarg);
break;
case 11 :
iargs.min_snr = strtof(optarg, NULL);
break;
case 13 :
toler = strdup(optarg);
break;
case 14 :
intrad = strdup(optarg);
break;
case 15 :
iargs.median_filter = atoi(optarg);
break;
case 16 :
int_str = strdup(optarg);
break;
case 17 :
tempdir = strdup(optarg);
break;
case 18 :
int_diag = strdup(optarg);
break;
case 19 :
if ( sscanf(optarg, "%f", &iargs.push_res) != 1 ) {
ERROR("Invalid value for --push-res\n");
return 1;
}
iargs.push_res *= 1e9; /* nm^-1 -> m^-1 */
have_push_res = 1;
break;
case 20 :
pkrad = strdup(optarg);
break;
case 21 :
if ( sscanf(optarg, "%f", &iargs.highres) != 1 ) {
ERROR("Invalid value for --highres\n");
return 1;
}
/* A -> m^-1 */
iargs.highres = 1.0 / (iargs.highres/1e10);
break;
case 22 :
if ( sscanf(optarg, "%f", &iargs.fix_profile_r) != 1 ) {
ERROR("Invalid value for "
"--fix-profile-radius\n");
return 1;
}
break;
case 23 :
if ( sscanf(optarg, "%f", &iargs.fix_bandwidth) != 1 ) {
ERROR("Invalid value for --fix-bandwidth\n");
return 1;
}
break;
case 24 :
if ( sscanf(optarg, "%f", &iargs.fix_divergence) != 1 ) {
ERROR("Invalid value for --fix-divergence\n");
return 1;
}
break;
case 0 :
break;
case '?' :
break;
default :
ERROR("Unhandled option '%c'\n", c);
break;
}
}
if ( tempdir == NULL ) {
tempdir = strdup(".");
}
if ( filename == NULL ) {
filename = strdup("-");
}
if ( strcmp(filename, "-") == 0 ) {
fh = stdin;
} else {
fh = fopen(filename, "r");
}
if ( fh == NULL ) {
ERROR("Failed to open input file '%s'\n", filename);
return 1;
}
free(filename);
if ( speaks == NULL ) {
speaks = strdup("zaef");
STATUS("You didn't specify a peak detection method.\n");
STATUS("I'm using 'zaef' for you.\n");
}
if ( strcmp(speaks, "zaef") == 0 ) {
iargs.peaks = PEAK_ZAEF;
} else if ( strcmp(speaks, "hdf5") == 0 ) {
iargs.peaks = PEAK_HDF5;
} else if ( strcmp(speaks, "cxi") == 0 ) {
iargs.peaks = PEAK_CXI;
} else {
ERROR("Unrecognised peak detection method '%s'\n", speaks);
return 1;
}
free(speaks);
/* Set default path for peaks, if appropriate */
if ( iargs.hdf5_peak_path == NULL ) {
if ( iargs.peaks == PEAK_HDF5 ) {
iargs.hdf5_peak_path = strdup("/processing/hitfinder/peakinfo");
} else if ( iargs.peaks == PEAK_CXI ) {
iargs.hdf5_peak_path = strdup("/entry_1/result_1");
}
}
if ( prefix == NULL ) {
prefix = strdup("");
} else {
if ( config_checkprefix ) {
prefix = check_prefix(prefix);
}
}
if ( n_proc == 0 ) {
ERROR("Invalid number of processes.\n");
return 1;
}
iargs.det = get_detector_geometry(geom_filename, iargs.beam);
if ( iargs.det == NULL ) {
ERROR("Failed to read detector geometry from '%s'\n",
geom_filename);
return 1;
}
if ( indm_str == NULL ) {
STATUS("You didn't specify an indexing method, so I won't try "
" to index anything.\n"
"If that isn't what you wanted, re-run with"
" --indexing=<methods>.\n");
indm = NULL;
} else {
indm = build_indexer_list(indm_str);
if ( indm == NULL ) {
ERROR("Invalid indexer list '%s'\n", indm_str);
return 1;
}
free(indm_str);
}
if ( int_str != NULL ) {
int err;
iargs.int_meth = integration_method(int_str, &err);
if ( err ) {
ERROR("Invalid integration method '%s'\n", int_str);
return 1;
}
free(int_str);
}
if ( integrate_saturated ) {
/* Option provided for backwards compatibility */
iargs.int_meth |= INTEGRATION_SATURATED;
}
if ( have_push_res && !(iargs.int_meth & INTEGRATION_RESCUT) ) {
ERROR("WARNING: You used --push-res, but not -rescut, "
"therefore --push-res will have no effect.\n");
}
if ( toler != NULL ) {
int ttt;
ttt = sscanf(toler, "%f,%f,%f,%f",
&iargs.tols[0], &iargs.tols[1],
&iargs.tols[2], &iargs.tols[3]);
if ( ttt != 4 ) {
ERROR("Invalid parameters for '--tolerance'\n");
return 1;
}
free(toler);
}
if ( intrad != NULL ) {
int r;
r = sscanf(intrad, "%f,%f,%f",
&iargs.ir_inn, &iargs.ir_mid, &iargs.ir_out);
if ( r != 3 ) {
ERROR("Invalid parameters for '--int-radius'\n");
return 1;
}
free(intrad);
} else {
STATUS("WARNING: You did not specify --int-radius.\n");
STATUS("WARNING: I will use the default values, which are"
" probably not appropriate for your patterns.\n");
}
if ( pkrad != NULL ) {
int r;
r = sscanf(pkrad, "%f,%f,%f",
&iargs.pk_inn, &iargs.pk_mid, &iargs.pk_out);
if ( r != 3 ) {
ERROR("Invalid parameters for '--peak-radius'\n");
return 1;
}
free(pkrad);
}
if ( iargs.pk_inn < 0.0 ) {
iargs.pk_inn = iargs.ir_inn;
iargs.pk_mid = iargs.ir_mid;
iargs.pk_out = iargs.ir_out;
}
if ( iargs.det == NULL ) {
ERROR("You need to provide a geometry file (please read the"
" manual for more details).\n");
return 1;
}
add_geom_beam_stuff_to_copy_hdf5(iargs.copyme, iargs.det, iargs.beam);
if ( cellfile != NULL ) {
iargs.cell = load_cell_from_file(cellfile);
if ( iargs.cell == NULL ) {
ERROR("Couldn't read unit cell (from %s)\n", cellfile);
return 1;
}
free(cellfile);
STATUS("This is what I understood your unit cell to be:\n");
cell_print(iargs.cell);
} else {
STATUS("No unit cell given.\n");
iargs.cell = NULL;
}
if ( int_diag != NULL ) {
int r;
signed int h, k, l;
if ( strcmp(int_diag, "random") == 0 ) {
iargs.int_diag = INTDIAG_RANDOM;
}
if ( strcmp(int_diag, "all") == 0 ) {
iargs.int_diag = INTDIAG_ALL;
}
if ( strcmp(int_diag, "negative") == 0 ) {
iargs.int_diag = INTDIAG_NEGATIVE;
}
if ( strcmp(int_diag, "implausible") == 0 ) {
iargs.int_diag = INTDIAG_IMPLAUSIBLE;
}
if ( strcmp(int_diag, "strong") == 0 ) {
iargs.int_diag = INTDIAG_STRONG;
}
r = sscanf(int_diag, "%i,%i,%i", &h, &k, &l);
if ( r == 3 ) {
iargs.int_diag = INTDIAG_INDICES;
iargs.int_diag_h = h;
iargs.int_diag_k = k;
iargs.int_diag_l = l;
}
if ( (iargs.int_diag == INTDIAG_NONE)
&& (strcmp(int_diag, "none") != 0) ) {
ERROR("Invalid value for --int-diag.\n");
return 1;
}
free(int_diag);
if ( (n_proc > 1) && (iargs.int_diag != INTDIAG_NONE) ) {
n_proc = 1;
STATUS("Ignored \"-j\" because you used --int-diag.\n");
}
}
st = open_stream_for_write_2(outfile, geom_filename, argc, argv);
if ( st == NULL ) {
ERROR("Failed to open stream '%s'\n", outfile);
return 1;
}
free(outfile);
/* Prepare the indexer */
if ( indm != NULL ) {
ipriv = prepare_indexing(indm, iargs.cell, iargs.det,
iargs.tols);
if ( ipriv == NULL ) {
ERROR("Failed to prepare indexing.\n");
return 1;
}
} else {
ipriv = NULL;
}
gsl_set_error_handler_off();
iargs.indm = indm;
iargs.ipriv = ipriv;
create_sandbox(&iargs, n_proc, prefix, config_basename, fh,
st, tempdir);
free(prefix);
free(tempdir);
free_detector_geometry(iargs.det);
close_stream(st);
cleanup_indexing(indm, ipriv);
return 0;
}
