Detector

Detector — Detector geometry

Functions

Types and Values

struct detector
struct panel
struct badregion
struct rigid_group
struct rg_collection

Includes

#include "detector.h"

Description

This structure represents the detector geometry

Functions

copy_geom ()

struct detector *
copy_geom (const struct detector *in);

fill_in_values ()

void
fill_in_values (struct detector *det,
                struct hdfile *f,
                struct event *ev);

free_detector_geometry ()

void
free_detector_geometry (struct detector *det);

get_detector_geometry ()

struct detector *
get_detector_geometry (const char *filename,
                       struct beam_params *beam);

write_detector_geometry ()

int
write_detector_geometry (const char *geometry_filename,
                         const char *output_filename,
                         struct detector *det);

write_detector_geometry_2 ()

int
write_detector_geometry_2 (const char *geometry_filename,
                           const char *output_filename,
                           struct detector *det,
                           const char *additional_comment,
                           int write_panel_coffset);

find_panel ()

struct panel *
find_panel (struct detector *det,
            double fs,
            double ss);

find_panel_by_name ()

struct panel *
find_panel_by_name (struct detector *det,
                    const char *name);

find_panel_number ()

signed int
find_panel_number (struct detector *det,
                   double fs,
                   double ss);

simple_geometry ()

struct detector *
simple_geometry (const struct image *image);

record_image ()

void
record_image (struct image *image,
              int do_poisson,
              double background,
              gsl_rng *rng,
              double beam_radius,
              double nphotons);

get_pixel_extents ()

void
get_pixel_extents (struct detector *det,
                   double *min_x,
                   double *min_y,
                   double *max_x,
                   double *max_y);

get_q ()

struct rvec
get_q (struct image *image,
       double fs,
       double ss,
       double *ttp,
       double k);

get_q_for_panel ()

struct rvec
get_q_for_panel (struct panel *p,
                 double fs,
                 double ss,
                 double *ttp,
                 double k);

get_tt ()

double
get_tt (struct image *image,
        double xs,
        double ys,
        int *err);

smallest_q ()

double
smallest_q (struct image *image);

reverse_2d_mapping ()

int
reverse_2d_mapping (double x,
                    double y,
                    double *pfs,
                    double *pss,
                    struct detector *det);

largest_q ()

double
largest_q (struct image *image);

in_bad_region ()

int
in_bad_region (struct detector *det,
               double fs,
               double ss);

mark_resolution_range_as_bad ()

void
mark_resolution_range_as_bad (struct image *image,
                              double min,
                              double max);

Flags, in the bad pixel mask for image , every pixel whose resolution is between min and max .

Parameters

image

An image structure

 

min

Minimum value of 1/d to be marked as bad

 

max

Maximum value of 1/d to be marked as bad

 

find_orig_panel ()

struct panel *
find_orig_panel (struct detector *det,
                 double fs,
                 double ss);

panel_is_in_rigid_group ()

int
panel_is_in_rigid_group (const struct rigid_group *rg,
                         struct panel *p);

rigid_group_is_in_collection ()

int
rigid_group_is_in_collection (struct rg_collection *c,
                              struct rigid_group *rg);

single_panel_data_source ()

int
single_panel_data_source (struct detector *det,
                          const char *element);

find_rigid_group_collection_by_name ()

struct rg_collection *
find_rigid_group_collection_by_name (struct detector *det,
                                     const char *name);

detector_has_clen_references ()

int
detector_has_clen_references (struct detector *det);

Types and Values

struct detector

struct detector {
	struct panel     *panels;
	int               n_panels;

	int               max_fs;
	int               max_ss;  /* Size of overall array needed, minus 1 */

	struct badregion *bad;
	int               n_bad;

	unsigned int       mask_bad;
	unsigned int       mask_good;

	struct rigid_group **rigid_groups;
	int                n_rigid_groups;

	struct rg_collection **rigid_group_collections;
	int               	 n_rg_collections;

	/* Location of the pixel furthest away from the beam position, which
	 * will have the largest value of 2theta regardless of camera length
	 * and wavelength */
	struct panel      *furthest_out_panel;
	double             furthest_out_fs;
	double             furthest_out_ss;

	/* As above, but for the smallest 2theta */
	struct panel      *furthest_in_panel;
	double             furthest_in_fs;
	double             furthest_in_ss;

	int                path_dim;
	int                dim_dim;

	struct panel       defaults;
};

struct panel

struct panel {
        char     name[1024];  /* Name for this panel */

        /* Position of panel in the data block in memory (see below) */
        int      min_fs;  /* Smallest FS value considered to be in the panel */
        int      max_fs;  /* Largest FS value considered to be in this panel */
        int      min_ss;  /* ... and so on */
        int      max_ss;

        double   cnx;       /* Location of corner (min_fs,min_ss) in pixels */
        double   cny;
        double   coffset;
        double   clen;     /* Camera length in metres */
        char    *clen_from;
        char    *mask;
        char    *mask_file;
        double   res;      /* Resolution in pixels per metre */
        char     badrow;   /* 'x' or 'y' */
        int      no_index; /* Don't index peaks in this panel if non-zero */
        double   adu_per_eV;   /* Number of ADU per eV */
        double   max_adu;  /* Treat pixel as unreliable if higher than this */
        char    *data;

        struct dim_structure *dim_structure;

        double fsx;
        double fsy;
        double ssx;
        double ssy;

        double xfs;
        double yfs;
        double xss;
        double yss;

        /* Position of the panel in the data block in the file.  The panels may
         * get moved around when the file is loaded (see hdf5_read2()),
         * especially if the panels come from different HDF5 elements. */
        int orig_min_fs;
        int orig_max_fs;
        int orig_min_ss;
        int orig_max_ss;

        int w;  /* Width, calculated as max_fs-min_fs+1 */
        int h;  /* Height, calculated as max_ss-min_ss+1 */
};

struct badregion

struct badregion {
	char name[1024];
	int is_fsss;
	char *panel;

	double min_x;
	double max_x;
	double min_y;
	double max_y;

	/* Specified INCLUSIVELY */
	int      min_fs;
	int      max_fs;
	int      min_ss;
	int      max_ss;
};

struct rigid_group

struct rigid_group {
	char *name;
	struct panel **panels;
	int n_panels;

	/* Updates to panel position calculated during integration */
	double d_fsx;
	double d_ssx;
	double d_cnx;
	double d_fsy;
	double d_ssy;
	double d_cny;
	int have_deltas;
};

struct rg_collection

struct rg_collection {
	char *name;
	struct rigid_group **rigid_groups;
	int n_rigid_groups;
};