environment decl_attributes::apply(environment env, io_state const & ios, name const & d) const {
if (m_is_instance) {
if (m_priority) {
#if defined(__GNUC__) && !defined(__CLANG__)
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
env = add_instance(env, d, *m_priority, m_persistent);
} else {
env = add_instance(env, d, m_persistent);
}
}
if (m_is_trans_instance) {
if (m_priority) {
#if defined(__GNUC__) && !defined(__CLANG__)
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
env = add_trans_instance(env, d, *m_priority, m_persistent);
} else {
env = add_trans_instance(env, d, m_persistent);
}
}
if (m_is_coercion)
env = add_coercion(env, ios, d, m_persistent);
auto decl = env.find(d);
if (decl && decl->is_definition()) {
if (m_is_reducible)
env = set_reducible(env, d, reducible_status::Reducible, m_persistent);
if (m_is_irreducible)
env = set_reducible(env, d, reducible_status::Irreducible, m_persistent);
if (m_is_semireducible)
env = set_reducible(env, d, reducible_status::Semireducible, m_persistent);
if (m_is_quasireducible)
env = set_reducible(env, d, reducible_status::Quasireducible, m_persistent);
if (m_unfold_hint)
env = add_unfold_hint(env, d, m_unfold_hint, m_persistent);
if (m_unfold_full_hint)
env = add_unfold_full_hint(env, d, m_persistent);
}
if (m_constructor_hint)
env = add_constructor_hint(env, d, m_persistent);
if (m_symm)
env = add_symm(env, d, m_persistent);
if (m_refl)
env = add_refl(env, d, m_persistent);
if (m_trans)
env = add_trans(env, d, m_persistent);
if (m_subst)
env = add_subst(env, d, m_persistent);
if (m_recursor)
env = add_user_recursor(env, d, m_recursor_major_pos, m_persistent);
if (m_is_class)
env = add_class(env, d, m_persistent);
if (m_rewrite)
env = add_rewrite_rule(env, d, m_persistent);
if (m_has_multiple_instances)
env = mark_multiple_instances(env, d, m_persistent);
return env;
}
static RefList *read_stream_reflections_2_3(FILE *fh, struct detector *det)
{
char *rval = NULL;
int first = 1;
RefList *out;
out = reflist_new();
do {
char line[1024];
signed int h, k, l;
float intensity, sigma, fs, ss, pk, bg;
char pn[32];
int r;
Reflection *refl;
rval = fgets(line, 1023, fh);
if ( rval == NULL ) continue;
chomp(line);
if ( strcmp(line, REFLECTION_END_MARKER) == 0 ) return out;
r = sscanf(line, "%i %i %i %f %f %f %f %f %f %s",
&h, &k, &l, &intensity, &sigma, &pk, &bg,
&fs, &ss, pn);
if ( (r != 10) && (!first) ) {
reflist_free(out);
return NULL;
}
first = 0;
if ( r == 10 ) {
struct panel *p;
refl = add_refl(out, h, k, l);
set_intensity(refl, intensity);
if ( det != NULL ) {
double write_fs, write_ss;
p = find_panel_by_name(det,pn);
write_fs = fs - p->orig_min_fs + p->min_fs;
write_ss = ss - p->orig_min_ss + p->min_ss;
set_detector_pos(refl, write_fs, write_ss);
}
set_esd_intensity(refl, sigma);
set_peak(refl, pk);
set_mean_bg(refl, bg);
set_redundancy(refl, 1);
}
} while ( rval != NULL );
/* Got read error of some kind before finding PEAK_LIST_END_MARKER */
return NULL;
}
static RefList *read_stream_reflections_2_1(FILE *fh)
{
char *rval = NULL;
int first = 1;
RefList *out;
out = reflist_new();
do {
char line[1024];
signed int h, k, l;
float intensity, sigma, fs, ss;
char phs[1024];
int cts;
int r;
Reflection *refl;
rval = fgets(line, 1023, fh);
if ( rval == NULL ) continue;
chomp(line);
if ( strcmp(line, REFLECTION_END_MARKER) == 0 ) return out;
r = sscanf(line, "%i %i %i %f %s %f %i %f %f",
&h, &k, &l, &intensity, phs, &sigma, &cts, &fs, &ss);
if ( (r != 9) && (!first) ) {
reflist_free(out);
return NULL;
}
first = 0;
if ( r == 9 ) {
double ph;
char *v;
refl = add_refl(out, h, k, l);
set_intensity(refl, intensity);
set_detector_pos(refl, 0.0, fs, ss);
set_esd_intensity(refl, sigma);
set_redundancy(refl, cts);
ph = strtod(phs, &v);
if ( v != phs ) set_phase(refl, deg2rad(ph));
}
} while ( rval != NULL );
/* Got read error of some kind before finding PEAK_LIST_END_MARKER */
return NULL;
}
static RefList *read_stream_reflections(FILE *fh)
{
char *rval = NULL;
int first = 1;
RefList *out;
out = reflist_new();
do {
char line[1024];
signed int h, k, l;
float intensity, sigma, fs, ss, pk, bg;
int r;
Reflection *refl;
rval = fgets(line, 1023, fh);
if ( rval == NULL ) continue;
chomp(line);
if ( strcmp(line, REFLECTION_END_MARKER) == 0 ) return out;
r = sscanf(line, "%i %i %i %f %f %f %f %f %f",
&h, &k, &l, &intensity, &sigma, &pk, &bg, &fs, &ss);
if ( (r != 9) && (!first) ) {
reflist_free(out);
return NULL;
}
first = 0;
if ( r == 9 ) {
refl = add_refl(out, h, k, l);
set_intensity(refl, intensity);
set_detector_pos(refl, 0.0, fs, ss);
set_esd_intensity(refl, sigma);
set_redundancy(refl, 1);
set_peak(refl, pk);
set_mean_bg(refl, bg);
}
} while ( rval != NULL );
/* Got read error of some kind before finding PEAK_LIST_END_MARKER */
return NULL;
}
static struct flist *asymm_and_merge(RefList *in, const SymOpList *sym,
UnitCell *cell, double rmin, double rmax,
SymOpList *amb)
{
Reflection *refl;
RefListIterator *iter;
RefList *asym;
struct flist *f;
int n;
asym = reflist_new();
if ( asym == NULL ) return NULL;
for ( refl = first_refl(in, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
signed int ha, ka, la;
Reflection *cr;
double res;
get_indices(refl, &h, &k, &l);
if ( cell == NULL ) {
ERROR("Can't calculate resolution cutoff - no cell\n");
} else {
res = 2.0*resolution(cell, h, k, l);
if ( res < rmin ) continue;
if ( res > rmax ) continue;
}
get_asymm(sym, h, k, l, &ha, &ka, &la);
if ( amb != NULL ) {
signed int hr, kr, lr;
signed int hra, kra, lra;
get_equiv(amb, NULL, 0, ha, ka, la, &hr, &kr, &lr);
get_asymm(sym, hr, kr, lr, &hra, &kra, &lra);
/* Skip twin-proof reflections */
if ( (ha==hra) && (ka==kra) && (la==lra) ) {
//STATUS("%i %i %i is twin proof\n", h, k, l);
continue;
}
}
cr = find_refl(asym, ha, ka, la);
if ( cr == NULL ) {
cr = add_refl(asym, ha, ka, la);
assert(cr != NULL);
copy_data(cr, refl);
} else {
const double i = get_intensity(cr);
const int r = get_redundancy(cr);
set_intensity(cr, (r*i + get_intensity(refl))/(r+1));
set_redundancy(cr, r+1);
}
}
f = malloc(sizeof(struct flist));
if ( f == NULL ) {
ERROR("Failed to allocate flist\n");
return NULL;
}
n = num_reflections(asym);
f->s = malloc(n*sizeof(unsigned int));
f->s_reidx = malloc(n*sizeof(unsigned int));
f->i = malloc(n*sizeof(float));
f->i_reidx = malloc(n*sizeof(float));
if ( (f->s == NULL) || (f->i == NULL)
|| (f->s_reidx == NULL) || (f->i_reidx == NULL) ) {
ERROR("Failed to allocate flist\n");
return NULL;
}
f->n = 0;
for ( refl = first_refl(asym, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
get_indices(refl, &h, &k, &l);
f->s[f->n] = SERIAL(h, k, l);
f->i[f->n] = get_intensity(refl);
f->n++;
}
assert(f->n == n);
if ( amb != NULL ) {
RefList *reidx = reflist_new();
if ( reidx == NULL ) return NULL;
for ( refl = first_refl(asym, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
signed int hr, kr, lr;
signed int hra, kra, lra;
Reflection *cr;
get_indices(refl, &h, &k, &l);
get_equiv(amb, NULL, 0, h, k, l, &hr, &kr, &lr);
get_asymm(sym, hr, kr, lr, &hra, &kra, &lra);
cr = add_refl(reidx, hra, kra, lra);
copy_data(cr, refl);
}
n = 0;
for ( refl = first_refl(reidx, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
get_indices(refl, &h, &k, &l);
f->s_reidx[n] = SERIAL(h, k, l);
f->i_reidx[n++] = get_intensity(refl);
}
reflist_free(reidx);
}
reflist_free(asym);
return f;
}
static int test_lists(int num_items)
{
struct refltemp *check;
RefList *list;
int i;
signed int h, k, l;
Reflection *refl;
RefListIterator *iter;
check = malloc(num_items * sizeof(struct refltemp));
list = reflist_new();
h = RANDOM_INDEX;
k = RANDOM_INDEX;
l = RANDOM_INDEX;
for ( i=0; i<num_items; i++ ) {
int j;
int num;
if ( random() > RAND_MAX/2 ) {
h = RANDOM_INDEX;
k = RANDOM_INDEX;
l = RANDOM_INDEX;
} /* else use the same as last time */
/* Count the number of times this reflection appeared before */
num = 1;
for ( j=0; j<i; j++ ) {
if ( (check[j].h == h)
&& (check[j].k == k)
&& (check[j].l == l) ) {
num++;
}
}
/* Update all copies with this number */
for ( j=0; j<i; j++ ) {
if ( (check[j].h == h)
&& (check[j].k == k)
&& (check[j].l == l) ) {
check[j].num = num;
}
}
add_refl(list, h, k, l);
check[i].h = h;
check[i].k = k;
check[i].l = l;
check[i].num = num;
check[i].found = 0;
}
printf("Created %i items, num_reflections is %i, tree depth is %i\n",
num_items, num_reflections(list), tree_depth(list));
/* Iterate over the list and check we find everything */
int count = 0;
for ( refl = first_refl(list, &iter);
refl != NULL;
refl = next_refl(refl, iter) ) {
signed int h, k, l;
get_indices(refl, &h, &k, &l);
for ( i=0; i<num_items; i++ ) {
if ( (check[i].h == h)
&& (check[i].k == k)
&& (check[i].l == l)
&& (check[i].found == 0) ) {
check[i].found = 1;
break;
}
}
count++;
}
if ( count != num_reflections(list) ) {
fprintf(stderr, "num_reflections gave %i, iteration gave %i\n",
num_reflections(list), count);
return 1;
}
for ( i=0; i<num_items; i++ ) {
if ( check[i].found == 0 ) {
Reflection *test;
fprintf(stderr, "Iteration didn't find %3i %3i %3i %i\n",
check[i].h, check[i].k, check[i].l, i);
test = find_refl(list, check[i].h, check[i].k,
check[i].l);
if ( test == NULL ) {
fprintf(stderr, "Not in list\n");
} else {
fprintf(stderr, "But found in list.\n");
}
return 1;
}
}
/* Check that all the reflections can be found */
for ( i=0; i<num_items; i++ ) {
signed int h, k, l;
Reflection *refl;
h = check[i].h;
k = check[i].k;
l = check[i].l;
refl = find_refl(list, h, k, l);
if ( refl == NULL ) {
fprintf(stderr, "Couldn't find %3i %3i %3i\n", h, k, l);
return 1;
}
}
reflist_free(list);
free(check);
return 0;
}
