static double *get_gradient(t_rgb **img, int y, int x, t_texture text)
{
double actual;
double *grad;
grad = NULL;
if ((grad = (double*)malloc(sizeof(double) * 4)) == NULL)
return (NULL);
actual = get_intensity(img[y][x]);
grad[0] = (y - 1 > 0 ? get_intensity(img[y - 1][x]) : actual);
grad[1] = (x - 1 > 0 ? get_intensity(img[y][x - 1]) : actual);
grad[2] = (x + 1 < text.w ? get_intensity(img[y][x + 1]) : actual);
grad[3] = (y + 1 < text.h ? get_intensity(img[y + 1][x]) : actual);
return (grad);
}
static void write_stream_reflections(FILE *fh, RefList *list)
{
Reflection *refl;
RefListIterator *iter;
fprintf(fh, " h k l I sigma(I) peak background"
" fs/px ss/px\n");
for ( refl = first_refl(list, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
double intensity, esd_i, bg, pk;
double fs, ss;
get_indices(refl, &h, &k, &l);
get_detector_pos(refl, &fs, &ss);
intensity = get_intensity(refl);
esd_i = get_esd_intensity(refl);
pk = get_peak(refl);
bg = get_mean_bg(refl);
/* Reflections with redundancy = 0 are not written */
if ( get_redundancy(refl) == 0 ) continue;
fprintf(fh,
"%4i %4i %4i %10.2f %10.2f %10.2f %10.2f %6.1f %6.1f\n",
h, k, l, intensity, esd_i, pk, bg, fs, ss);
}
}
int waveform (int color, int data_file)
{
static char write_buffer[100], read_buffer[10000] ;
int numToRead=10000;
int written_bytes;
////////////////////////////////////////////////
memset(read_buffer, 0, 10000);
ibsic(device);
strcpy (write_buffer, "DATA:STARt 1");
ibwrt (device, write_buffer, strlen(write_buffer));
sprintf (write_buffer, "DATA:STOP 10000");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "ACQUIRE:MODE SAMPLE");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "ACQUIRE:STOPAFTER SEQUENCE");
ibwrt (device, write_buffer, strlen(write_buffer));
//read pump intensity, mask type and scan ref
get_intensity();
// Delay(0.5);
strcpy (write_buffer, "ACQUIRE:STATE ON");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "*WAI");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "CURVe?");
ibwrt (device, write_buffer, strlen(write_buffer));
Delay(0.3);
ibrd (device, read_buffer, numToRead);
//Delay(1);
ConvertArrayType (read_buffer, VAL_CHAR, data2fit, VAL_DOUBLE, 10000);
written_bytes=WriteFile (data_file,read_buffer ,10000 );
CloseFile (data_file);
if (written_bytes!=10000)
{
printf("Error writing file!!\n");
}
plot_data(color);
GetCtrlVal (ERG_panel, ERG_panel_fit_live, &j);
// printf ("%d", j);
if (j==1)
{
fit_data ();
}
return 1;
}
static int write_stream_reflections_2_2(FILE *fh, RefList *list,
struct image *image)
{
Reflection *refl;
RefListIterator *iter;
fprintf(fh, " h k l I sigma(I) "
"peak background fs/px ss/px\n");
for ( refl = first_refl(list, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
double intensity, esd_i, bg, pk;
double fs, ss;
get_indices(refl, &h, &k, &l);
get_detector_pos(refl, &fs, &ss);
intensity = get_intensity(refl);
esd_i = get_esd_intensity(refl);
pk = get_peak(refl);
bg = get_mean_bg(refl);
/* Reflections with redundancy = 0 are not written */
if ( get_redundancy(refl) == 0 ) continue;
if ( image->det != NULL ) {
struct panel *p;
double write_fs, write_ss;
p = find_orig_panel(image->det, fs, ss);
if ( p == NULL ) {
ERROR("Panel not found\n");
return 1;
}
/* Convert coordinates to match arrangement of panels in HDF5
* file */
write_fs = fs - p->min_fs + p->orig_min_fs;
write_ss = ss - p->min_ss + p->orig_min_ss;
fprintf(fh, "%4i %4i %4i %10.2f %10.2f %10.2f %10.2f"
" %6.1f %6.1f\n",
h, k, l, intensity, esd_i, pk, bg, write_fs,
write_ss);
} else {
fprintf(fh, "%4i %4i %4i %10.2f %10.2f %10.2f %10.2f"
" %6.1f %6.1f\n",
h, k, l, intensity, esd_i, pk, bg, fs, ss);
}
}
return 0;
}
static double guide_dev(Crystal *cr, const RefList *full)
{
double dev = 0.0;
/* For each reflection */
Reflection *refl;
RefListIterator *iter;
for ( refl = first_refl(crystal_get_reflections(cr), &iter);
refl != NULL;
refl = next_refl(refl, iter) ) {
double G, p;
signed int h, k, l;
Reflection *full_version;
double I_full, I_partial;
if ( (get_intensity(refl) < 3.0*get_esd_intensity(refl))
|| (get_partiality(refl) < MIN_PART_REFINE) ) continue;
get_indices(refl, &h, &k, &l);
assert((h!=0) || (k!=0) || (l!=0));
full_version = find_refl(full, h, k, l);
if ( full_version == NULL ) continue;
/* Some reflections may have recently become scalable, but
* scale_intensities() might not yet have been called, so the
* full version may not have been calculated yet. */
G = crystal_get_osf(cr);
p = get_partiality(refl);
I_partial = get_intensity(refl);
I_full = get_intensity(full_version);
//STATUS("%3i %3i %3i %5.2f %5.2f %5.2f %5.2f %5.2f\n",
// h, k, l, G, p, I_partial, I_full,
// I_partial - p*G*I_full);
dev += pow(I_partial - p*G*I_full, 2.0);
}
return dev;
}
static int write_stream_reflections_2_3(FILE *fh, RefList *list,
struct image *image)
{
Reflection *refl;
RefListIterator *iter;
fprintf(fh, " h k l I sigma(I) "
"peak background fs/px ss/px panel\n");
for ( refl = first_refl(list, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
double intensity, esd_i, pk, bg;
double fs, ss;
double write_fs, write_ss;
struct panel *p = NULL;
get_indices(refl, &h, &k, &l);
get_detector_pos(refl, &fs, &ss);
intensity = get_intensity(refl);
esd_i = get_esd_intensity(refl);
pk = get_peak(refl);
bg = get_mean_bg(refl);
/* Reflections with redundancy = 0 are not written */
if ( get_redundancy(refl) == 0 ) continue;
p = find_panel(image->det,fs,ss);
if ( p == NULL ) {
ERROR("Panel not found\n");
return 1;
}
write_fs = fs-p->min_fs+p->orig_min_fs;
write_ss = ss-p->min_ss+p->orig_min_ss;
fprintf(fh,
"%4i %4i %4i %10.2f %10.2f %10.2f %10.2f "
"%6.1f %6.1f %s\n",
h, k, l, intensity, esd_i, pk, bg,
write_fs, write_ss, p->name);
}
return 0;
}
static void write_stream_reflections_2_1(FILE *fh, RefList *list)
{
Reflection *refl;
RefListIterator *iter;
fprintf(fh, " h k l I phase sigma(I) "
" counts fs/px ss/px\n");
for ( refl = first_refl(list, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
double intensity, esd_i, ph;
int red;
double fs, ss;
char phs[16];
int have_phase;
get_indices(refl, &h, &k, &l);
get_detector_pos(refl, &fs, &ss);
intensity = get_intensity(refl);
esd_i = get_esd_intensity(refl);
red = get_redundancy(refl);
ph = get_phase(refl, &have_phase);
/* Reflections with redundancy = 0 are not written */
if ( red == 0 ) continue;
if ( have_phase ) {
snprintf(phs, 16, "%8.2f", rad2deg(ph));
} else {
strncpy(phs, " -", 15);
}
fprintf(fh,
"%3i %3i %3i %10.2f %s %10.2f %7i %6.1f %6.1f\n",
h, k, l, intensity, phs, esd_i, red, fs, ss);
}
}
static int
is_edge(double *intensity, struct application *ap, const struct cell *here,
const struct cell *left, const struct cell *below, const struct cell *right, const struct cell *above)
{
int found_edge = 0;
if (!here) {
return 0;
}
if (here && here->c_ishit) {
if (detect_ids) {
if (left && below) {
if (here->c_id != left->c_id || here->c_id != below->c_id) {
found_edge = 1;
}
}
if (both_sides && right && above) {
if (here->c_id != right->c_id || here->c_id != above->c_id) {
found_edge = 1;
}
}
}
if (detect_regions) {
if (left && below) {
if (here->c_region != left->c_region ||here->c_region != below->c_region) {
found_edge = 1;
}
}
if (both_sides && right && above) {
if (here->c_region != right->c_region || here->c_region != above->c_region) {
found_edge = 1;
}
}
}
if (detect_distance) {
if (left && below) {
if (Abs(here->c_dist - left->c_dist) > max_dist || Abs(here->c_dist - below->c_dist) > max_dist) {
found_edge = 1;
}
}
if (both_sides && right && above) {
if (Abs(here->c_dist - right->c_dist) > max_dist || Abs(here->c_dist - above->c_dist) > max_dist) {
found_edge = 1;
}
}
}
if (detect_normals) {
if (left && below) {
if ((VDOT(here->c_normal, left->c_normal) < COSTOL) || (VDOT(here->c_normal, below->c_normal)< COSTOL)) {
found_edge = 1;
}
}
if (both_sides && right && above) {
if ((VDOT(here->c_normal, right->c_normal)< COSTOL) || (VDOT(here->c_normal, above->c_normal)< COSTOL)) {
found_edge = 1;
}
}
}
} else {
if (left && below) {
if (left->c_ishit || below->c_ishit) {
found_edge = 1;
}
}
if (both_sides && right && above) {
if (right->c_ishit || above->c_ishit) {
found_edge = 1;
}
}
}
if (found_edge) {
if (intensity && ap && antialias)
get_intensity(intensity, ap, here, left, below, right, above);
return 1;
}
return 0;
}
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;
}
void acquire_scans (void)
{
int color;
int Nleft=0;
char file [ FILENAME_MAX ];
SetCtrlAttribute (Main_pnl_handle, ERG_panel_acquire, ATTR_DIMMED, 1);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_abortscan, ATTR_DIMMED, 1);
if (experiment==1){
GetCtrlVal (Sequence_pnl_handle, Seq_panel_seq_number, &seq_num);
Nscans= seq_num*m;
}
else {
GetCtrlVal (Main_pnl_handle, ERG_panel_nscans, &Nscans);
}
DirSelectPopup ("d:\\data\\test", "Select Directory", 1, 1, pathname);
i=0;
SetCtrlAttribute (Main_pnl_handle, ERG_panel_pause, ATTR_DIMMED, 0);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_abortscan, ATTR_DIMMED, 0);
// start trigger
SRS_flag=2;
SRS_onoff();
DeleteGraphPlot (Main_pnl_handle, ERG_panel_mask_display, -1, VAL_IMMEDIATE_DRAW);
if (experiment==1){ // mode sequence
for (i=0;i<seq_num;i++) {
for (h=0;h<m;h++){
SetCtrlIndex (Sequence_pnl_handle, Seq_panel_mask_list, h);
for (k=0;k<Npixel;k++){
drive_level[k]=mask[h].voltages[k];
}
display_masks();
ProcessSystemEvents();
GetLabelFromIndex (Sequence_pnl_handle, Seq_panel_mask_list, h, &mask_filename);
strcpy(filename, pathname);
//prepare file to write
sprintf(file, "\\sequence%d_%s.txt", i, mask_filename);
strcat(filename, file);
data_file = OpenFile (filename, VAL_WRITE_ONLY, VAL_TRUNCATE, VAL_ASCII);
//enable oscillo then wait for trigger and get ERG trace
color=floor(256/Nscans)*(i*m+h);
waveform(color, data_file);
get_intensity();
//write header file
headerfile();
//write ERG trace
ArrayToFile (filename, data2fit, VAL_DOUBLE, 10000, 1, VAL_GROUPS_TOGETHER, VAL_GROUPS_AS_ROWS, VAL_SEP_BY_TAB, 100, VAL_ASCII, VAL_APPEND);
nmeasure[0]=i*m+h+1;
displaychannel();
Nleft=Nscans-(i*m+h);
SetCtrlVal (Main_pnl_handle, ERG_panel_nremain, Nleft);
ProcessSystemEvents();
if (pause_flag)
{
while (pause_flag)
ProcessSystemEvents();
}
}
}
}
else{ // mode normal
//prepare file name for acquiring data
while ( i < Nscans )
{
strcpy(filename, pathname);
sprintf(file, "\\scope_data%d.txt", i);
strcat(filename, file);
data_file = OpenFile (filename, VAL_WRITE_ONLY, VAL_TRUNCATE, VAL_ASCII);
color=floor(256/Nscans)*i;
waveform(color, data_file);
get_intensity();
headerfile();
ArrayToFile (filename, data2fit, VAL_DOUBLE, 10000, 1, VAL_GROUPS_TOGETHER, VAL_GROUPS_AS_ROWS, VAL_SEP_BY_TAB, 100, VAL_ASCII, VAL_APPEND);
i++;
Nleft=Nscans-i+1;
SetCtrlVal (Main_pnl_handle, ERG_panel_nremain, Nleft);
ProcessSystemEvents();
if (pause_flag)
{
while (pause_flag)
ProcessSystemEvents();
}
CloseFile (data_file);
}
}
SetCtrlVal (Main_pnl_handle, ERG_panel_nremain, 0);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_pause, ATTR_DIMMED, 1);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_abortscan, ATTR_DIMMED, 1);
SetCtrlAttribute (Main_pnl_handle, ERG_panel_acquire, ATTR_DIMMED, 0);
// stop trigger
SRS_flag=0;
SRS_onoff();
ibsic(device);
return;
}
static int write_stream_reflections_2_1(FILE *fh, RefList *list,
struct image *image)
{
Reflection *refl;
RefListIterator *iter;
fprintf(fh, " h k l I phase sigma(I) "
" counts fs/px ss/px\n");
for ( refl = first_refl(list, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int h, k, l;
double intensity, esd_i, ph;
int red;
double fs, ss;
char phs[16];
int have_phase;
get_indices(refl, &h, &k, &l);
get_detector_pos(refl, &fs, &ss);
intensity = get_intensity(refl);
esd_i = get_esd_intensity(refl);
red = get_redundancy(refl);
ph = get_phase(refl, &have_phase);
/* Reflections with redundancy = 0 are not written */
if ( red == 0 ) continue;
if ( have_phase ) {
snprintf(phs, 16, "%8.2f", rad2deg(ph));
} else {
strncpy(phs, " -", 15);
}
if ( image->det != NULL ) {
struct panel *p;
double write_fs, write_ss;
p = find_orig_panel(image->det, fs, ss);
if ( p == NULL ) {
ERROR("Panel not found\n");
return 1;
}
/* Convert coordinates to match arrangement of panels
* in HDF5 file */
write_fs = fs - p->min_fs + p->orig_min_fs;
write_ss = ss - p->min_ss + p->orig_min_ss;
fprintf(fh, "%3i %3i %3i %10.2f %s %10.2f %7i "
"%6.1f %6.1f\n",
h, k, l, intensity, phs, esd_i, red,
write_fs, write_ss);
} else {
fprintf(fh, "%3i %3i %3i %10.2f %s %10.2f %7i "
"%6.1f %6.1f\n",
h, k, l, intensity, phs, esd_i, red,
fs, ss);
}
}
return 0;
}
/* Perform one cycle of post refinement on 'image' against 'full' */
static double pr_iterate(Crystal *cr, const RefList *full,
PartialityModel pmodel, int *n_filtered)
{
gsl_matrix *M;
gsl_vector *v;
gsl_vector *shifts;
int param;
Reflection *refl;
RefListIterator *iter;
RefList *reflections;
double max_shift;
int nref = 0;
const int verbose = 0;
int num_params = 0;
enum gparam rv[32];
*n_filtered = 0;
/* If partiality model is anything other than "unity", refine all the
* geometrical parameters */
if ( pmodel != PMODEL_UNITY ) {
rv[num_params++] = GPARAM_ASX;
rv[num_params++] = GPARAM_ASY;
rv[num_params++] = GPARAM_ASZ;
rv[num_params++] = GPARAM_BSX;
rv[num_params++] = GPARAM_BSY;
rv[num_params++] = GPARAM_BSZ;
rv[num_params++] = GPARAM_CSX;
rv[num_params++] = GPARAM_CSY;
rv[num_params++] = GPARAM_CSZ;
}
STATUS("Refining %i parameters.\n", num_params);
reflections = crystal_get_reflections(cr);
M = gsl_matrix_calloc(num_params, num_params);
v = gsl_vector_calloc(num_params);
/* Construct the equations, one per reflection in this image */
for ( refl = first_refl(reflections, &iter);
refl != NULL;
refl = next_refl(refl, iter) )
{
signed int ha, ka, la;
double I_full, delta_I;
double w;
double I_partial;
int k;
double p, l;
Reflection *match;
double gradients[num_params];
/* Find the full version */
get_indices(refl, &ha, &ka, &la);
match = find_refl(full, ha, ka, la);
if ( match == NULL ) continue;
if ( (get_intensity(refl) < 3.0*get_esd_intensity(refl))
|| (get_partiality(refl) < MIN_PART_REFINE)
|| (get_redundancy(match) < 2) ) continue;
I_full = get_intensity(match);
/* Actual measurement of this reflection from this pattern? */
I_partial = get_intensity(refl) / crystal_get_osf(cr);
p = get_partiality(refl);
l = get_lorentz(refl);
/* Calculate the weight for this reflection */
w = pow(get_esd_intensity(refl), 2.0);
w += l * p * I_full * pow(get_esd_intensity(match), 2.0);
w = pow(w, -1.0);
/* Calculate all gradients for this reflection */
for ( k=0; k<num_params; k++ ) {
gradients[k] = p_gradient(cr, rv[k], refl, pmodel) * l;
}
for ( k=0; k<num_params; k++ ) {
int g;
double v_c, v_curr;
for ( g=0; g<num_params; g++ ) {
double M_c, M_curr;
/* Matrix is symmetric */
if ( g > k ) continue;
M_c = gradients[g] * gradients[k];
M_c *= w * pow(I_full, 2.0);
M_curr = gsl_matrix_get(M, k, g);
gsl_matrix_set(M, k, g, M_curr + M_c);
gsl_matrix_set(M, g, k, M_curr + M_c);
}
delta_I = I_partial - (l * p * I_full);
v_c = w * delta_I * I_full * gradients[k];
v_curr = gsl_vector_get(v, k);
gsl_vector_set(v, k, v_curr + v_c);
}
nref++;
}
if ( verbose ) {
STATUS("The original equation:\n");
show_matrix_eqn(M, v);
}
//STATUS("%i reflections went into the equations.\n", nref);
if ( nref == 0 ) {
crystal_set_user_flag(cr, 2);
gsl_matrix_free(M);
gsl_vector_free(v);
return 0.0;
}
max_shift = 0.0;
shifts = solve_svd(v, M, n_filtered, verbose);
if ( shifts != NULL ) {
for ( param=0; param<num_params; param++ ) {
double shift = gsl_vector_get(shifts, param);
apply_shift(cr, rv[param], shift);
//STATUS("Shift %i: %e\n", param, shift);
if ( fabs(shift) > max_shift ) max_shift = fabs(shift);
}
} else {
crystal_set_user_flag(cr, 3);
}
gsl_matrix_free(M);
gsl_vector_free(v);
gsl_vector_free(shifts);
return max_shift;
}
