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; }